WIP strip strings at compile time

Systematize builtins.fetchTree docs
And also render the docs nicely. I would like to use a markdown AST for this, but to avoid new deps (lowdown's AST doesn't suffice) I am just doing crude string manipulations for now.
2025-11-17 14:32:33 -05:00 · 2025-11-17 13:10:03 -05:00 · 2025-11-17 12:33:26 -05:00 · 2025-11-17 04:22:10 +00:00 · 2025-11-16 23:33:28 -04:00 · 2025-11-16 23:32:29 -04:00
49 changed files with 990 additions and 538 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -174,7 +174,7 @@ jobs:
        echo "installer-url=file://$GITHUB_WORKSPACE/out" >> "$GITHUB_OUTPUT"
        TARBALL_PATH="$(find "$GITHUB_WORKSPACE/out" -name 'nix*.tar.xz' -print | head -n 1)"
        echo "tarball-path=file://$TARBALL_PATH" >> "$GITHUB_OUTPUT"
-    - uses: cachix/install-nix-action@456688f15bc354bef6d396e4a35f4f89d40bf2b7 # v31.8.2
+    - uses: cachix/install-nix-action@7ec16f2c061ab07b235a7245e06ed46fe9a1cab6 # v31.8.3
      if: ${{ !matrix.experimental-installer }}
      with:
        install_url: ${{ format('{0}/install', steps.installer-tarball-url.outputs.installer-url) }}
--- a/src/libcmd/common-eval-args.cc
+++ b/src/libcmd/common-eval-args.cc
@@ -33,7 +33,8 @@ EvalSettings evalSettings{
                // FIXME `parseFlakeRef` should take a `std::string_view`.
                auto flakeRef = parseFlakeRef(fetchSettings, std::string{rest}, {}, true, false);
                debug("fetching flake search path element '%s''", rest);
-                auto [accessor, lockedRef] = flakeRef.resolve(state.store).lazyFetch(state.store);
+                auto [accessor, lockedRef] =
+                    flakeRef.resolve(fetchSettings, state.store).lazyFetch(fetchSettings, state.store);
                auto storePath = nix::fetchToStore(
                    state.fetchSettings,
                    *state.store,
@@ -131,7 +132,7 @@ MixEvalArgs::MixEvalArgs()
            fetchers::Attrs extraAttrs;
            if (to.subdir != "")
                extraAttrs["dir"] = to.subdir;
-            fetchers::overrideRegistry(from.input, to.input, extraAttrs);
+            fetchers::overrideRegistry(fetchSettings, from.input, to.input, extraAttrs);
        }},
        .completer = {[&](AddCompletions & completions, size_t, std::string_view prefix) {
            completeFlakeRef(completions, openStore(), prefix);
@@ -187,7 +188,7 @@ SourcePath lookupFileArg(EvalState & state, std::string_view s, const Path * bas
    else if (hasPrefix(s, "flake:")) {
        experimentalFeatureSettings.require(Xp::Flakes);
        auto flakeRef = parseFlakeRef(fetchSettings, std::string(s.substr(6)), {}, true, false);
-        auto [accessor, lockedRef] = flakeRef.resolve(state.store).lazyFetch(state.store);
+        auto [accessor, lockedRef] = flakeRef.resolve(fetchSettings, state.store).lazyFetch(fetchSettings, state.store);
        auto storePath = nix::fetchToStore(
            state.fetchSettings, *state.store, SourcePath(accessor), FetchMode::Copy, lockedRef.input.getName());
        state.allowPath(storePath);
--- a/src/libcmd/installables.cc
+++ b/src/libcmd/installables.cc
@@ -185,6 +185,7 @@ MixFlakeOptions::MixFlakeOptions()
                    }

                    overrideRegistry(
+                        fetchSettings,
                        fetchers::Input::fromAttrs(fetchSettings, {{"type", "indirect"}, {"id", inputName}}),
                        input3->lockedRef.input,
                        extraAttrs);
--- a/src/libcmd/repl.cc
+++ b/src/libcmd/repl.cc
@@ -738,7 +738,7 @@ void NixRepl::loadFlake(const std::string & flakeRefS)
    }

    auto flakeRef = parseFlakeRef(fetchSettings, flakeRefS, cwd.string(), true);
-    if (evalSettings.pureEval && !flakeRef.input.isLocked())
+    if (evalSettings.pureEval && !flakeRef.input.isLocked(fetchSettings))
        throw Error("cannot use ':load-flake' on locked flake reference '%s' (use --impure to override)", flakeRefS);

    Value v;
--- a/src/libexpr-c/nix_api_expr.cc
+++ b/src/libexpr-c/nix_api_expr.cc
@@ -137,6 +137,8 @@ nix_eval_state_builder * nix_eval_state_builder_new(nix_c_context * context, Sto

 void nix_eval_state_builder_free(nix_eval_state_builder * builder)
 {
+    if (builder)
+        builder->~nix_eval_state_builder();
    operator delete(builder, static_cast<std::align_val_t>(alignof(nix_eval_state_builder)));
 }

@@ -203,6 +205,8 @@ EvalState * nix_state_create(nix_c_context * context, const char ** lookupPath_c

 void nix_state_free(EvalState * state)
 {
+    if (state)
+        state->~EvalState();
    operator delete(state, static_cast<std::align_val_t>(alignof(EvalState)));
 }

--- a/src/libexpr-tests/nix_api_expr.cc
+++ b/src/libexpr-tests/nix_api_expr.cc
@@ -14,7 +14,7 @@

 namespace nixC {

-TEST_F(nix_api_store_test, nix_eval_state_lookup_path)
+TEST_F(nix_api_expr_test, nix_eval_state_lookup_path)
 {
    auto tmpDir = nix::createTempDir();
    auto delTmpDir = std::make_unique<nix::AutoDelete>(tmpDir, true);
@@ -42,12 +42,16 @@ TEST_F(nix_api_store_test, nix_eval_state_lookup_path)
    nix_expr_eval_from_string(ctx, state, "builtins.seq <nixos-config> <nixpkgs>", ".", value);
    assert_ctx_ok();

+    nix_state_free(state);
+
    ASSERT_EQ(nix_get_type(ctx, value), NIX_TYPE_PATH);
    assert_ctx_ok();

    auto pathStr = nix_get_path_string(ctx, value);
    assert_ctx_ok();
    ASSERT_EQ(0, strcmp(pathStr, nixpkgs.c_str()));
+
+    nix_gc_decref(nullptr, value);
 }

 TEST_F(nix_api_expr_test, nix_expr_eval_from_string)
--- a/src/libexpr-tests/primops.cc
+++ b/src/libexpr-tests/primops.cc
@@ -661,8 +661,14 @@ INSTANTIATE_TEST_SUITE_P(
        CASE(R"(null)", ""),
        CASE(R"({ v = "bar"; __toString = self: self.v; })", "bar"),
        CASE(R"({ v = "bar"; __toString = self: self.v; outPath = "foo"; })", "bar"),
-        CASE(R"({ outPath = "foo"; })", "foo"),
-        CASE(R"(./test)", "/test")));
+        CASE(R"({ outPath = "foo"; })", "foo")
+// this is broken on cygwin because canonPath("//./test", false) returns //./test
+// FIXME: don't use canonPath
+#ifndef __CYGWIN__
+            ,
+        CASE(R"(./test)", "/test")
+#endif
+            ));
 #undef CASE

 TEST_F(PrimOpTest, substring)
--- a/src/libexpr/eval.cc
+++ b/src/libexpr/eval.cc
@@ -517,15 +517,16 @@ Value * EvalState::addPrimOp(PrimOp && primOp)
    if (primOp.arity == 0) {
        primOp.arity = 1;
        auto vPrimOp = allocValue();
-        vPrimOp->mkPrimOp(new PrimOp(primOp));
+        vPrimOp->mkPrimOp(new PrimOp(std::move(primOp)));
        Value v;
        v.mkApp(vPrimOp, vPrimOp);
+        auto & primOp1 = *vPrimOp->primOp();
        return addConstant(
-            primOp.name,
+            primOp1.name,
            v,
            {
                .type = nThunk, // FIXME
-                .doc = primOp.doc,
+                .doc = primOp1.doc ? primOp1.doc->c_str() : nullptr,
            });
    }

@@ -565,13 +566,14 @@ std::optional<EvalState::Doc> EvalState::getDoc(Value & v)
 {
    if (v.isPrimOp()) {
        auto v2 = &v;
-        if (auto * doc = v2->primOp()->doc)
+        auto & primOp = *v2->primOp();
+        if (primOp.doc)
            return Doc{
                .pos = {},
-                .name = v2->primOp()->name,
-                .arity = v2->primOp()->arity,
-                .args = v2->primOp()->args,
-                .doc = doc,
+                .name = primOp.name,
+                .arity = primOp.arity,
+                .args = primOp.args,
+                .doc = primOp.doc->c_str(),
            };
    }
    if (v.isLambda()) {
--- a/src/libexpr/include/nix/expr/eval.hh
+++ b/src/libexpr/include/nix/expr/eval.hh
@@ -108,7 +108,7 @@ struct PrimOp
    /**
     * Optional free-form documentation about the primop.
     */
-    const char * doc = nullptr;
+    std::optional<std::string> doc;

    /**
     * Add a trace item, while calling the `<name>` builtin.
--- a/src/libexpr/primops/fetchMercurial.cc
+++ b/src/libexpr/primops/fetchMercurial.cc
@@ -81,7 +81,7 @@ static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value ** ar
        attrs.insert_or_assign("rev", rev->gitRev());
    auto input = fetchers::Input::fromAttrs(state.fetchSettings, std::move(attrs));

-    auto [storePath, input2] = input.fetchToStore(state.store);
+    auto [storePath, input2] = input.fetchToStore(state.fetchSettings, state.store);

    auto attrs2 = state.buildBindings(8);
    state.mkStorePathString(storePath, attrs2.alloc(state.s.outPath));
--- a/src/libexpr/primops/fetchTree.cc
+++ b/src/libexpr/primops/fetchTree.cc
@@ -82,7 +82,7 @@ struct FetchTreeParams
 static void fetchTree(
    EvalState & state, const PosIdx pos, Value ** args, Value & v, const FetchTreeParams & params = FetchTreeParams{})
 {
-    fetchers::Input input{state.fetchSettings};
+    fetchers::Input input{};
    NixStringContext context;
    std::optional<std::string> type;
    auto fetcher = params.isFetchGit ? "fetchGit" : "fetchTree";
@@ -194,9 +194,9 @@ static void fetchTree(
    }

    if (!state.settings.pureEval && !input.isDirect() && experimentalFeatureSettings.isEnabled(Xp::Flakes))
-        input = lookupInRegistries(state.store, input, fetchers::UseRegistries::Limited).first;
+        input = lookupInRegistries(state.fetchSettings, state.store, input, fetchers::UseRegistries::Limited).first;

-    if (state.settings.pureEval && !input.isLocked()) {
+    if (state.settings.pureEval && !input.isLocked(state.fetchSettings)) {
        if (input.getNarHash())
            warn(
                "Input '%s' is unlocked (e.g. lacks a Git revision) but is checked by NAR hash. "
@@ -219,7 +219,8 @@ static void fetchTree(
            throw Error("input '%s' is not allowed to use the '__final' attribute", input.to_string());
    }

-    auto cachedInput = state.inputCache->getAccessor(state.store, input, fetchers::UseRegistries::No);
+    auto cachedInput =
+        state.inputCache->getAccessor(state.fetchSettings, state.store, input, fetchers::UseRegistries::No);

    auto storePath = state.mountInput(cachedInput.lockedInput, input, cachedInput.accessor);

@@ -234,229 +235,127 @@ static void prim_fetchTree(EvalState & state, const PosIdx pos, Value ** args, V
 static RegisterPrimOp primop_fetchTree({
    .name = "fetchTree",
    .args = {"input"},
-    .doc = R"(
-      Fetch a file system tree or a plain file using one of the supported backends and return an attribute set with:
+    .doc = []() -> std::string {
+        std::string doc = stripIndentation(R"(
+          Fetch a file system tree or a plain file using one of the supported backends and return an attribute set with:

-      - the resulting fixed-output [store path](@docroot@/store/store-path.md)
-      - the corresponding [NAR](@docroot@/store/file-system-object/content-address.md#serial-nix-archive) hash
-      - backend-specific metadata (currently not documented). <!-- TODO: document output attributes -->
+          - the resulting fixed-output [store path](@docroot@/store/store-path.md)
+          - the corresponding [NAR](@docroot@/store/file-system-object/content-address.md#serial-nix-archive) hash
+          - backend-specific metadata (currently not documented). <!-- TODO: document output attributes -->

-      *input* must be an attribute set with the following attributes:
+          *input* must be an attribute set with the following attributes:

-      - `type` (String, required)
+          - `type` (String, required)

-        One of the [supported source types](#source-types).
-        This determines other required and allowed input attributes.
+            One of the [supported source types](#source-types).
+            This determines other required and allowed input attributes.

-      - `narHash` (String, optional)
+          - `narHash` (String, optional)

-        The `narHash` parameter can be used to substitute the source of the tree.
-        It also allows for verification of tree contents that may not be provided by the underlying transfer mechanism.
-        If `narHash` is set, the source is first looked up is the Nix store and [substituters](@docroot@/command-ref/conf-file.md#conf-substituters), and only fetched if not available.
+            The `narHash` parameter can be used to substitute the source of the tree.
+            It also allows for verification of tree contents that may not be provided by the underlying transfer mechanism.
+            If `narHash` is set, the source is first looked up is the Nix store and [substituters](@docroot@/command-ref/conf-file.md#conf-substituters), and only fetched if not available.

-      A subset of the output attributes of `fetchTree` can be re-used for subsequent calls to `fetchTree` to produce the same result again.
-      That is, `fetchTree` is idempotent.
+          A subset of the output attributes of `fetchTree` can be re-used for subsequent calls to `fetchTree` to produce the same result again.
+          That is, `fetchTree` is idempotent.

-      Downloads are cached in `$XDG_CACHE_HOME/nix`.
-      The remote source is fetched from the network if both are true:
-      - A NAR hash is supplied and the corresponding store path is not [valid](@docroot@/glossary.md#gloss-validity), that is, not available in the store
+          Downloads are cached in `$XDG_CACHE_HOME/nix`.
+          The remote source is fetched from the network if both are true:
+          - A NAR hash is supplied and the corresponding store path is not [valid](@docroot@/glossary.md#gloss-validity), that is, not available in the store

-        > **Note**
-        >
-        > [Substituters](@docroot@/command-ref/conf-file.md#conf-substituters) are not used in fetching.
-
-      - There is no cache entry or the cache entry is older than [`tarball-ttl`](@docroot@/command-ref/conf-file.md#conf-tarball-ttl)
-
-      ## Source types
-
-      The following source types and associated input attributes are supported.
-
-      <!-- TODO: It would be soooo much more predictable to work with (and
-      document) if `fetchTree` was a curried call with the first parameter for
-      `type` or an attribute like `builtins.fetchTree.git`! -->
-
-      - `"file"`
-
-        Place a plain file into the Nix store.
-        This is similar to [`builtins.fetchurl`](@docroot@/language/builtins.md#builtins-fetchurl)
-
-        - `url` (String, required)
-
-          Supported protocols:
-
-          - `https`
-
-            > **Example**
+            > **Note**
            >
-            > ```nix
-            > fetchTree {
-            >   type = "file";
-            >   url = "https://example.com/index.html";
-            > }
-            > ```
+            > [Substituters](@docroot@/command-ref/conf-file.md#conf-substituters) are not used in fetching.

-          - `http`
+          - There is no cache entry or the cache entry is older than [`tarball-ttl`](@docroot@/command-ref/conf-file.md#conf-tarball-ttl)

-            Insecure HTTP transfer for legacy sources.
+          ## Source types

-            > **Warning**
-            >
-            > HTTP performs no encryption or authentication.
-            > Use a `narHash` known in advance to ensure the output has expected contents.
+          The following source types and associated input attributes are supported.

-          - `file`
+          <!-- TODO: It would be soooo much more predictable to work with (and
+          document) if `fetchTree` was a curried call with the first parameter for
+          `type` or an attribute like `builtins.fetchTree.git`! -->
+        )");

-            A file on the local file system.
+        auto indentString = [](std::string const & str, std::string const & indent) {
+            std::string result;
+            std::istringstream stream(str);
+            std::string line;
+            bool first = true;
+            while (std::getline(stream, line)) {
+                if (!first)
+                    result += "\n";
+                result += indent + line;
+                first = false;
+            }
+            return result;
+        };

-            > **Example**
-            >
-            > ```nix
-            > fetchTree {
-            >   type = "file";
-            >   url = "file:///home/eelco/nix/README.md";
-            > }
-            > ```
+        for (const auto & [schemeName, scheme] : fetchers::getAllInputSchemes()) {
+            doc += "\n- `" + quoteString(schemeName, '"') + "`\n\n";
+            doc += indentString(scheme->schemeDescription(), "  ");
+            if (!doc.empty() && doc.back() != '\n')
+                doc += "\n";

-      - `"git"`
+            for (const auto & [attrName, attribute] : scheme->allowedAttrs()) {
+                doc += "\n  - `" + attrName + "` (" + attribute.type + ", "
+                       + (attribute.required ? "required" : "optional") + ")\n\n";
+                doc += indentString(stripIndentation(attribute.doc), "    ");
+                if (!doc.empty() && doc.back() != '\n')
+                    doc += "\n";
+            }
+        }

-        Fetch a Git tree and copy it to the Nix store.
-        This is similar to [`builtins.fetchGit`](@docroot@/language/builtins.md#builtins-fetchGit).
+        doc += "\n" + stripIndentation(R"(
+          The following input types are still subject to change:

-        - `allRefs` (Bool, optional)
+          - `"path"`
+          - `"github"`
+          - `"gitlab"`
+          - `"sourcehut"`
+          - `"mercurial"`

-          By default, this has no effect. This becomes relevant only once `shallow` cloning is disabled.
-
-          Whether to fetch all references (eg. branches and tags) of the repository.
-          With this argument being true, it's possible to load a `rev` from *any* `ref`.
-          (Without setting this option, only `rev`s from the specified `ref` are supported).
-
-          Default: `false`
-
-        - `lastModified` (Integer, optional)
-
-          Unix timestamp of the fetched commit.
-
-          If set, pass through the value to the output attribute set.
-          Otherwise, generated from the fetched Git tree.
-
-        - `lfs` (Bool, optional)
-
-          Fetch any [Git LFS](https://git-lfs.com/) files.
-
-          Default: `false`
-
-        - `ref` (String, optional)
-
-          By default, this has no effect. This becomes relevant only once `shallow` cloning is disabled.
-
-          A [Git reference](https://git-scm.com/book/en/v2/Git-Internals-Git-References), such as a branch or tag name.
-
-          Default: `"HEAD"`
-
-        - `rev` (String, optional)
-
-          A Git revision; a commit hash.
-
-          Default: the tip of `ref`
-
-        - `revCount` (Integer, optional)
-
-          Number of revisions in the history of the Git repository before the fetched commit.
-
-          If set, pass through the value to the output attribute set.
-          Otherwise, generated from the fetched Git tree.
-
-        - `shallow` (Bool, optional)
-
-          Make a shallow clone when fetching the Git tree.
-          When this is enabled, the options `ref` and `allRefs` have no effect anymore.
-
-          Default: `true`
-
-        - `submodules` (Bool, optional)
-
-          Also fetch submodules if available.
-
-          Default: `false`
-
-        - `url` (String, required)
-
-          The URL formats supported are the same as for Git itself.
+         *input* can also be a [URL-like reference](@docroot@/command-ref/new-cli/nix3-flake.md#flake-references).
+         The additional input types and the URL-like syntax requires the [`flakes` experimental feature](@docroot@/development/experimental-features.md#xp-feature-flakes) to be enabled.

          > **Example**
          >
+          > Fetch a GitHub repository using the attribute set representation:
+          >
          > ```nix
-          > fetchTree {
-          >   type = "git";
-          >   url = "git@github.com:NixOS/nixpkgs.git";
+          > builtins.fetchTree {
+          >   type = "github";
+          >   owner = "NixOS";
+          >   repo = "nixpkgs";
+          >   rev = "ae2e6b3958682513d28f7d633734571fb18285dd";
+          > }
+          > ```
+          >
+          > This evaluates to the following attribute set:
+          >
+          > ```nix
+          > {
+          >   lastModified = 1686503798;
+          >   lastModifiedDate = "20230611171638";
+          >   narHash = "sha256-rA9RqKP9OlBrgGCPvfd5HVAXDOy8k2SmPtB/ijShNXc=";
+          >   outPath = "/nix/store/l5m6qlvfs9sdw14ja3qbzpglcjlb6j1x-source";
+          >   rev = "ae2e6b3958682513d28f7d633734571fb18285dd";
+          >   shortRev = "ae2e6b3";
          > }
          > ```

-          > **Note**
+          > **Example**
          >
-          > If the URL points to a local directory, and no `ref` or `rev` is given, Nix only considers files added to the Git index, as listed by `git ls-files` but use the *current file contents* of the Git working directory.
+          > Fetch the same GitHub repository using the URL-like syntax:
+          >
+          >   ```nix
+          >   builtins.fetchTree "github:NixOS/nixpkgs/ae2e6b3958682513d28f7d633734571fb18285dd"
+          >   ```
+        )");

-      - `"tarball"`
-
-        Download a tar archive and extract it into the Nix store.
-        This has the same underlying implementation as [`builtins.fetchTarball`](@docroot@/language/builtins.md#builtins-fetchTarball)
-
-        - `url` (String, required)
-
-           > **Example**
-           >
-           > ```nix
-           > fetchTree {
-           >   type = "tarball";
-           >   url = "https://github.com/NixOS/nixpkgs/tarball/nixpkgs-23.11";
-           > }
-           > ```
-
-      The following input types are still subject to change:
-
-      - `"path"`
-      - `"github"`
-      - `"gitlab"`
-      - `"sourcehut"`
-      - `"mercurial"`
-
-     *input* can also be a [URL-like reference](@docroot@/command-ref/new-cli/nix3-flake.md#flake-references).
-     The additional input types and the URL-like syntax requires the [`flakes` experimental feature](@docroot@/development/experimental-features.md#xp-feature-flakes) to be enabled.
-
-      > **Example**
-      >
-      > Fetch a GitHub repository using the attribute set representation:
-      >
-      > ```nix
-      > builtins.fetchTree {
-      >   type = "github";
-      >   owner = "NixOS";
-      >   repo = "nixpkgs";
-      >   rev = "ae2e6b3958682513d28f7d633734571fb18285dd";
-      > }
-      > ```
-      >
-      > This evaluates to the following attribute set:
-      >
-      > ```nix
-      > {
-      >   lastModified = 1686503798;
-      >   lastModifiedDate = "20230611171638";
-      >   narHash = "sha256-rA9RqKP9OlBrgGCPvfd5HVAXDOy8k2SmPtB/ijShNXc=";
-      >   outPath = "/nix/store/l5m6qlvfs9sdw14ja3qbzpglcjlb6j1x-source";
-      >   rev = "ae2e6b3958682513d28f7d633734571fb18285dd";
-      >   shortRev = "ae2e6b3";
-      > }
-      > ```
-
-      > **Example**
-      >
-      > Fetch the same GitHub repository using the URL-like syntax:
-      >
-      >   ```nix
-      >   builtins.fetchTree "github:NixOS/nixpkgs/ae2e6b3958682513d28f7d633734571fb18285dd"
-      >   ```
-    )",
+        return doc;
+    }(),
    .fun = prim_fetchTree,
    .experimentalFeature = Xp::FetchTree,
 });
--- a/src/libfetchers-tests/git.cc
+++ b/src/libfetchers-tests/git.cc
@@ -196,7 +196,7 @@ TEST_F(GitTest, submodulePeriodSupport)
            {"ref", "main"},
        });

-    auto [accessor, i] = input.getAccessor(store);
+    auto [accessor, i] = input.getAccessor(settings, store);

    ASSERT_EQ(accessor->readFile(CanonPath("deps/sub/lib.txt")), "hello from submodule\n");
 }
--- a/src/libfetchers/fetchers.cc
+++ b/src/libfetchers/fetchers.cc
@@ -26,18 +26,9 @@ void registerInputScheme(std::shared_ptr<InputScheme> && inputScheme)
        throw Error("Input scheme with name %s already registered", schemeName);
 }

-nlohmann::json dumpRegisterInputSchemeInfo()
+const InputSchemeMap & getAllInputSchemes()
 {
-    using nlohmann::json;
-
-    auto res = json::object();
-
-    for (auto & [name, scheme] : inputSchemes()) {
-        auto & r = res[name] = json::object();
-        r["allowedAttrs"] = scheme->allowedAttrs();
-    }
-
-    return res;
+    return inputSchemes();
 }

 Input Input::fromURL(const Settings & settings, const std::string & url, bool requireTree)
@@ -89,7 +80,7 @@ Input Input::fromAttrs(const Settings & settings, Attrs && attrs)
        // but not all of them. Doing this is to support those other
        // operations which are supposed to be robust on
        // unknown/uninterpretable inputs.
-        Input input{settings};
+        Input input;
        input.attrs = attrs;
        fixupInput(input);
        return input;
@@ -159,9 +150,9 @@ bool Input::isDirect() const
    return !scheme || scheme->isDirect(*this);
 }

-bool Input::isLocked() const
+bool Input::isLocked(const Settings & settings) const
 {
-    return scheme && scheme->isLocked(*this);
+    return scheme && scheme->isLocked(settings, *this);
 }

 bool Input::isFinal() const
@@ -198,17 +189,17 @@ bool Input::contains(const Input & other) const
 }

 // FIXME: remove
-std::pair<StorePath, Input> Input::fetchToStore(ref<Store> store) const
+std::pair<StorePath, Input> Input::fetchToStore(const Settings & settings, ref<Store> store) const
 {
    if (!scheme)
        throw Error("cannot fetch unsupported input '%s'", attrsToJSON(toAttrs()));

    auto [storePath, input] = [&]() -> std::pair<StorePath, Input> {
        try {
-            auto [accessor, result] = getAccessorUnchecked(store);
+            auto [accessor, result] = getAccessorUnchecked(settings, store);

            auto storePath =
-                nix::fetchToStore(*settings, *store, SourcePath(accessor), FetchMode::Copy, result.getName());
+                nix::fetchToStore(settings, *store, SourcePath(accessor), FetchMode::Copy, result.getName());

            auto narHash = store->queryPathInfo(storePath)->narHash;
            result.attrs.insert_or_assign("narHash", narHash.to_string(HashFormat::SRI, true));
@@ -297,10 +288,10 @@ void Input::checkLocks(Input specified, Input & result)
    }
 }

-std::pair<ref<SourceAccessor>, Input> Input::getAccessor(ref<Store> store) const
+std::pair<ref<SourceAccessor>, Input> Input::getAccessor(const Settings & settings, ref<Store> store) const
 {
    try {
-        auto [accessor, result] = getAccessorUnchecked(store);
+        auto [accessor, result] = getAccessorUnchecked(settings, store);

        result.attrs.insert_or_assign("__final", Explicit<bool>(true));

@@ -313,7 +304,7 @@ std::pair<ref<SourceAccessor>, Input> Input::getAccessor(ref<Store> store) const
    }
 }

-std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(ref<Store> store) const
+std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(const Settings & settings, ref<Store> store) const
 {
    // FIXME: cache the accessor

@@ -349,7 +340,7 @@ std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(ref<Store> sto
            if (accessor->fingerprint) {
                ContentAddressMethod method = ContentAddressMethod::Raw::NixArchive;
                auto cacheKey = makeFetchToStoreCacheKey(getName(), *accessor->fingerprint, method, "/");
-                settings->getCache()->upsert(cacheKey, *store, {}, storePath);
+                settings.getCache()->upsert(cacheKey, *store, {}, storePath);
            }

            accessor->setPathDisplay("«" + to_string() + "»");
@@ -360,7 +351,7 @@ std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(ref<Store> sto
        }
    }

-    auto [accessor, result] = scheme->getAccessor(store, *this);
+    auto [accessor, result] = scheme->getAccessor(settings, store, *this);

    if (!accessor->fingerprint)
        accessor->fingerprint = result.getFingerprint(store);
@@ -377,10 +368,10 @@ Input Input::applyOverrides(std::optional<std::string> ref, std::optional<Hash>
    return scheme->applyOverrides(*this, ref, rev);
 }

-void Input::clone(const Path & destDir) const
+void Input::clone(const Settings & settings, const Path & destDir) const
 {
    assert(scheme);
-    scheme->clone(*this, destDir);
+    scheme->clone(settings, *this, destDir);
 }

 std::optional<std::filesystem::path> Input::getSourcePath() const
@@ -493,7 +484,7 @@ void InputScheme::putFile(
    throw Error("input '%s' does not support modifying file '%s'", input.to_string(), path);
 }

-void InputScheme::clone(const Input & input, const Path & destDir) const
+void InputScheme::clone(const Settings & settings, const Input & input, const Path & destDir) const
 {
    throw Error("do not know how to clone input '%s'", input.to_string());
 }
--- a/src/libfetchers/git.cc
+++ b/src/libfetchers/git.cc
@@ -194,28 +194,183 @@ struct GitInputScheme : InputScheme
        return "git";
    }

-    StringSet allowedAttrs() const override
+    std::string schemeDescription() const override
    {
-        return {
-            "url",
-            "ref",
-            "rev",
-            "shallow",
-            "submodules",
-            "lfs",
-            "exportIgnore",
-            "lastModified",
-            "revCount",
-            "narHash",
-            "allRefs",
-            "name",
-            "dirtyRev",
-            "dirtyShortRev",
-            "verifyCommit",
-            "keytype",
-            "publicKey",
-            "publicKeys",
+        return stripIndentation(R"(
+          Fetch a Git tree and copy it to the Nix store.
+          This is similar to [`builtins.fetchGit`](@docroot@/language/builtins.md#builtins-fetchGit).
+        )");
+    }
+
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    {
+        static const std::map<std::string, AttributeInfo> attrs = {
+            {
+                "url",
+                {
+                    .type = "String",
+                    .required = true,
+                    .doc = R"(
+                      The URL formats supported are the same as for Git itself.
+
+                      > **Example**
+                      >
+                      > ```nix
+                      > fetchTree {
+                      >   type = "git";
+                      >   url = "git@github.com:NixOS/nixpkgs.git";
+                      > }
+                      > ```
+
+                      > **Note**
+                      >
+                      > If the URL points to a local directory, and no `ref` or `rev` is given, Nix only considers files added to the Git index, as listed by `git ls-files` but uses the *current file contents* of the Git working directory.
+                    )",
+                },
+            },
+            {
+                "ref",
+                {
+                    .type = "String",
+                    .required = false,
+                    .doc = R"(
+                      By default, this has no effect. This becomes relevant only once `shallow` cloning is disabled.
+
+                      A [Git reference](https://git-scm.com/book/en/v2/Git-Internals-Git-References), such as a branch or tag name.
+
+                      Default: `"HEAD"`
+                    )",
+                },
+            },
+            {
+                "rev",
+                {
+                    .type = "String",
+                    .required = false,
+                    .doc = R"(
+                      A Git revision; a commit hash.
+
+                      Default: the tip of `ref`
+                    )",
+                },
+            },
+            {
+                "shallow",
+                {
+                    .type = "Bool",
+                    .required = false,
+                    .doc = R"(
+                      Make a shallow clone when fetching the Git tree.
+                      When this is enabled, the options `ref` and `allRefs` have no effect anymore.
+
+                      Default: `true`
+                    )",
+                },
+            },
+            {
+                "submodules",
+                {
+                    .type = "Bool",
+                    .required = false,
+                    .doc = R"(
+                      Also fetch submodules if available.
+
+                      Default: `false`
+                    )",
+                },
+            },
+            {
+                "lfs",
+                {
+                    .type = "Bool",
+                    .required = false,
+                    .doc = R"(
+                      Fetch any [Git LFS](https://git-lfs.com/) files.
+
+                      Default: `false`
+                    )",
+                },
+            },
+            {
+                "exportIgnore",
+                {},
+            },
+            {
+                "lastModified",
+                {
+                    .type = "Integer",
+                    .required = false,
+                    .doc = R"(
+                      Unix timestamp of the fetched commit.
+
+                      If set, pass through the value to the output attribute set.
+                      Otherwise, generated from the fetched Git tree.
+                    )",
+                },
+            },
+            {
+                "revCount",
+                {
+                    .type = "Integer",
+                    .required = false,
+                    .doc = R"(
+                      Number of revisions in the history of the Git repository before the fetched commit.
+
+                      If set, pass through the value to the output attribute set.
+                      Otherwise, generated from the fetched Git tree.
+                    )",
+                },
+            },
+            {
+                "narHash",
+                {},
+            },
+            {
+                "allRefs",
+                {
+                    .type = "Bool",
+                    .required = false,
+                    .doc = R"(
+                      By default, this has no effect. This becomes relevant only once `shallow` cloning is disabled.
+
+                      Whether to fetch all references (eg. branches and tags) of the repository.
+                      With this argument being true, it's possible to load a `rev` from *any* `ref`.
+                      (Without setting this option, only `rev`s from the specified `ref` are supported).
+
+                      Default: `false`
+                    )",
+                },
+            },
+            {
+                "name",
+                {},
+            },
+            {
+                "dirtyRev",
+                {},
+            },
+            {
+                "dirtyShortRev",
+                {},
+            },
+            {
+                "verifyCommit",
+                {},
+            },
+            {
+                "keytype",
+                {},
+            },
+            {
+                "publicKey",
+                {},
+            },
+            {
+                "publicKeys",
+                {},
+            },
        };
+        return attrs;
    }

    std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
@@ -229,7 +384,7 @@ struct GitInputScheme : InputScheme
        if (auto ref = maybeGetStrAttr(attrs, "ref"); ref && !isLegalRefName(*ref))
            throw BadURL("invalid Git branch/tag name '%s'", *ref);

-        Input input{settings};
+        Input input{};
        input.attrs = attrs;
        input.attrs["url"] = fixGitURL(getStrAttr(attrs, "url")).to_string();
        getShallowAttr(input);
@@ -278,7 +433,7 @@ struct GitInputScheme : InputScheme
        return res;
    }

-    void clone(const Input & input, const Path & destDir) const override
+    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
    {
        auto repoInfo = getRepoInfo(input);

@@ -623,7 +778,7 @@ struct GitInputScheme : InputScheme
    }

    std::pair<ref<SourceAccessor>, Input>
-    getAccessorFromCommit(ref<Store> store, RepoInfo & repoInfo, Input && input) const
+    getAccessorFromCommit(const Settings & settings, ref<Store> store, RepoInfo & repoInfo, Input && input) const
    {
        assert(!repoInfo.workdirInfo.isDirty);

@@ -733,10 +888,10 @@ struct GitInputScheme : InputScheme

        auto rev = *input.getRev();

-        input.attrs.insert_or_assign("lastModified", getLastModified(*input.settings, repoInfo, repoDir, rev));
+        input.attrs.insert_or_assign("lastModified", getLastModified(settings, repoInfo, repoDir, rev));

        if (!getShallowAttr(input))
-            input.attrs.insert_or_assign("revCount", getRevCount(*input.settings, repoInfo, repoDir, rev));
+            input.attrs.insert_or_assign("revCount", getRevCount(settings, repoInfo, repoDir, rev));

        printTalkative("using revision %s of repo '%s'", rev.gitRev(), repoInfo.locationToArg());

@@ -779,8 +934,8 @@ struct GitInputScheme : InputScheme
                attrs.insert_or_assign("submodules", Explicit<bool>{true});
                attrs.insert_or_assign("lfs", Explicit<bool>{smudgeLfs});
                attrs.insert_or_assign("allRefs", Explicit<bool>{true});
-                auto submoduleInput = fetchers::Input::fromAttrs(*input.settings, std::move(attrs));
-                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(store);
+                auto submoduleInput = fetchers::Input::fromAttrs(settings, std::move(attrs));
+                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(settings, store);
                submoduleAccessor->setPathDisplay("«" + submoduleInput.to_string() + "»");
                mounts.insert_or_assign(submodule.path, submoduleAccessor);
            }
@@ -797,7 +952,7 @@ struct GitInputScheme : InputScheme
    }

    std::pair<ref<SourceAccessor>, Input>
-    getAccessorFromWorkdir(ref<Store> store, RepoInfo & repoInfo, Input && input) const
+    getAccessorFromWorkdir(const Settings & settings, ref<Store> store, RepoInfo & repoInfo, Input && input) const
    {
        auto repoPath = repoInfo.getPath().value();

@@ -829,8 +984,8 @@ struct GitInputScheme : InputScheme
                // TODO: fall back to getAccessorFromCommit-like fetch when submodules aren't checked out
                // attrs.insert_or_assign("allRefs", Explicit<bool>{ true });

-                auto submoduleInput = fetchers::Input::fromAttrs(*input.settings, std::move(attrs));
-                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(store);
+                auto submoduleInput = fetchers::Input::fromAttrs(settings, std::move(attrs));
+                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(settings, store);
                submoduleAccessor->setPathDisplay("«" + submoduleInput.to_string() + "»");

                /* If the submodule is dirty, mark this repo dirty as
@@ -857,12 +1012,12 @@ struct GitInputScheme : InputScheme
            input.attrs.insert_or_assign("rev", rev.gitRev());
            if (!getShallowAttr(input)) {
                input.attrs.insert_or_assign(
-                    "revCount", rev == nullRev ? 0 : getRevCount(*input.settings, repoInfo, repoPath, rev));
+                    "revCount", rev == nullRev ? 0 : getRevCount(settings, repoInfo, repoPath, rev));
            }

            verifyCommit(input, repo);
        } else {
-            repoInfo.warnDirty(*input.settings);
+            repoInfo.warnDirty(settings);

            if (repoInfo.workdirInfo.headRev) {
                input.attrs.insert_or_assign("dirtyRev", repoInfo.workdirInfo.headRev->gitRev() + "-dirty");
@@ -874,14 +1029,14 @@ struct GitInputScheme : InputScheme

        input.attrs.insert_or_assign(
            "lastModified",
-            repoInfo.workdirInfo.headRev
-                ? getLastModified(*input.settings, repoInfo, repoPath, *repoInfo.workdirInfo.headRev)
-                : 0);
+            repoInfo.workdirInfo.headRev ? getLastModified(settings, repoInfo, repoPath, *repoInfo.workdirInfo.headRev)
+                                         : 0);

        return {accessor, std::move(input)};
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
    {
        Input input(_input);

@@ -897,8 +1052,8 @@ struct GitInputScheme : InputScheme
        }

        auto [accessor, final] = input.getRef() || input.getRev() || !repoInfo.getPath()
-                                     ? getAccessorFromCommit(store, repoInfo, std::move(input))
-                                     : getAccessorFromWorkdir(store, repoInfo, std::move(input));
+                                     ? getAccessorFromCommit(settings, store, repoInfo, std::move(input))
+                                     : getAccessorFromWorkdir(settings, store, repoInfo, std::move(input));

        return {accessor, std::move(final)};
    }
@@ -934,7 +1089,7 @@ struct GitInputScheme : InputScheme
        }
    }

-    bool isLocked(const Input & input) const override
+    bool isLocked(const Settings & settings, const Input & input) const override
    {
        auto rev = input.getRev();
        return rev && rev != nullRev;
--- a/src/libfetchers/github.cc
+++ b/src/libfetchers/github.cc
@@ -92,7 +92,7 @@ struct GitArchiveInputScheme : InputScheme
        if (ref && rev)
            throw BadURL("URL '%s' contains both a commit hash and a branch/tag name %s %s", url, *ref, rev->gitRev());

-        Input input{settings};
+        Input input{};
        input.attrs.insert_or_assign("type", std::string{schemeName()});
        input.attrs.insert_or_assign("owner", path[0]);
        input.attrs.insert_or_assign("repo", path[1]);
@@ -110,18 +110,43 @@ struct GitArchiveInputScheme : InputScheme
        return input;
    }

-    StringSet allowedAttrs() const override
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
    {
-        return {
-            "owner",
-            "repo",
-            "ref",
-            "rev",
-            "narHash",
-            "lastModified",
-            "host",
-            "treeHash",
+        static const std::map<std::string, AttributeInfo> attrs = {
+            {
+                "owner",
+                {},
+            },
+            {
+                "repo",
+                {},
+            },
+            {
+                "ref",
+                {},
+            },
+            {
+                "rev",
+                {},
+            },
+            {
+                "narHash",
+                {},
+            },
+            {
+                "lastModified",
+                {},
+            },
+            {
+                "host",
+                {},
+            },
+            {
+                "treeHash",
+                {},
+            },
        };
+        return attrs;
    }

    std::optional<Input> inputFromAttrs(const fetchers::Settings & settings, const Attrs & attrs) const override
@@ -129,7 +154,7 @@ struct GitArchiveInputScheme : InputScheme
        getStrAttr(attrs, "owner");
        getStrAttr(attrs, "repo");

-        Input input{settings};
+        Input input{};
        input.attrs = attrs;
        return input;
    }
@@ -233,9 +258,9 @@ struct GitArchiveInputScheme : InputScheme
        std::optional<Hash> treeHash;
    };

-    virtual RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const = 0;
+    virtual RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const = 0;

-    virtual DownloadUrl getDownloadUrl(const Input & input) const = 0;
+    virtual DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const = 0;

    struct TarballInfo
    {
@@ -243,7 +268,7 @@ struct GitArchiveInputScheme : InputScheme
        time_t lastModified;
    };

-    std::pair<Input, TarballInfo> downloadArchive(ref<Store> store, Input input) const
+    std::pair<Input, TarballInfo> downloadArchive(const Settings & settings, ref<Store> store, Input input) const
    {
        if (!maybeGetStrAttr(input.attrs, "ref"))
            input.attrs.insert_or_assign("ref", "HEAD");
@@ -252,7 +277,7 @@ struct GitArchiveInputScheme : InputScheme

        auto rev = input.getRev();
        if (!rev) {
-            auto refInfo = getRevFromRef(store, input);
+            auto refInfo = getRevFromRef(settings, store, input);
            rev = refInfo.rev;
            upstreamTreeHash = refInfo.treeHash;
            debug("HEAD revision for '%s' is %s", input.to_string(), refInfo.rev.gitRev());
@@ -261,7 +286,7 @@ struct GitArchiveInputScheme : InputScheme
        input.attrs.erase("ref");
        input.attrs.insert_or_assign("rev", rev->gitRev());

-        auto cache = input.settings->getCache();
+        auto cache = settings.getCache();

        Cache::Key treeHashKey{"gitRevToTreeHash", {{"rev", rev->gitRev()}}};
        Cache::Key lastModifiedKey{"gitRevToLastModified", {{"rev", rev->gitRev()}}};
@@ -270,7 +295,7 @@ struct GitArchiveInputScheme : InputScheme
            if (auto lastModifiedAttrs = cache->lookup(lastModifiedKey)) {
                auto treeHash = getRevAttr(*treeHashAttrs, "treeHash");
                auto lastModified = getIntAttr(*lastModifiedAttrs, "lastModified");
-                if (input.settings->getTarballCache()->hasObject(treeHash))
+                if (settings.getTarballCache()->hasObject(treeHash))
                    return {std::move(input), TarballInfo{.treeHash = treeHash, .lastModified = (time_t) lastModified}};
                else
                    debug("Git tree with hash '%s' has disappeared from the cache, refetching...", treeHash.gitRev());
@@ -278,7 +303,7 @@ struct GitArchiveInputScheme : InputScheme
        }

        /* Stream the tarball into the tarball cache. */
-        auto url = getDownloadUrl(input);
+        auto url = getDownloadUrl(settings, input);

        auto source = sinkToSource([&](Sink & sink) {
            FileTransferRequest req(url.url);
@@ -290,7 +315,7 @@ struct GitArchiveInputScheme : InputScheme
            *logger, lvlInfo, actUnknown, fmt("unpacking '%s' into the Git cache", input.to_string()));

        TarArchive archive{*source};
-        auto tarballCache = input.settings->getTarballCache();
+        auto tarballCache = settings.getTarballCache();
        auto parseSink = tarballCache->getFileSystemObjectSink();
        auto lastModified = unpackTarfileToSink(archive, *parseSink);
        auto tree = parseSink->flush();
@@ -315,9 +340,10 @@ struct GitArchiveInputScheme : InputScheme
        return {std::move(input), tarballInfo};
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
    {
-        auto [input, tarballInfo] = downloadArchive(store, _input);
+        auto [input, tarballInfo] = downloadArchive(settings, store, _input);

 #if 0
        input.attrs.insert_or_assign("treeHash", tarballInfo.treeHash.gitRev());
@@ -325,19 +351,18 @@ struct GitArchiveInputScheme : InputScheme
        input.attrs.insert_or_assign("lastModified", uint64_t(tarballInfo.lastModified));

        auto accessor =
-            input.settings->getTarballCache()->getAccessor(tarballInfo.treeHash, false, "«" + input.to_string() + "»");
+            settings.getTarballCache()->getAccessor(tarballInfo.treeHash, false, "«" + input.to_string() + "»");

        return {accessor, input};
    }

-    bool isLocked(const Input & input) const override
+    bool isLocked(const Settings & settings, const Input & input) const override
    {
        /* Since we can't verify the integrity of the tarball from the
           Git revision alone, we also require a NAR hash for
           locking. FIXME: in the future, we may want to require a Git
           tree hash instead of a NAR hash. */
-        return input.getRev().has_value()
-               && (input.settings->trustTarballsFromGitForges || input.getNarHash().has_value());
+        return input.getRev().has_value() && (settings.trustTarballsFromGitForges || input.getNarHash().has_value());
    }

    std::optional<ExperimentalFeature> experimentalFeature() const override
@@ -361,6 +386,12 @@ struct GitHubInputScheme : GitArchiveInputScheme
        return "github";
    }

+    std::string schemeDescription() const override
+    {
+        // TODO
+        return "";
+    }
+
    std::optional<std::pair<std::string, std::string>> accessHeaderFromToken(const std::string & token) const override
    {
        // Github supports PAT/OAuth2 tokens and HTTP Basic
@@ -387,7 +418,7 @@ struct GitHubInputScheme : GitArchiveInputScheme
        return getStrAttr(input.attrs, "repo");
    }

-    RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const override
+    RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const override
    {
        auto host = getHost(input);
        auto url = fmt(
@@ -397,9 +428,9 @@ struct GitHubInputScheme : GitArchiveInputScheme
            getRepo(input),
            *input.getRef());

-        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(settings, host, input);

-        auto downloadResult = downloadFile(store, *input.settings, url, "source", headers);
+        auto downloadResult = downloadFile(store, settings, url, "source", headers);
        auto json = nlohmann::json::parse(
            store->requireStoreObjectAccessor(downloadResult.storePath)->readFile(CanonPath::root));

@@ -408,11 +439,11 @@ struct GitHubInputScheme : GitArchiveInputScheme
            .treeHash = Hash::parseAny(std::string{json["commit"]["tree"]["sha"]}, HashAlgorithm::SHA1)};
    }

-    DownloadUrl getDownloadUrl(const Input & input) const override
+    DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const override
    {
        auto host = getHost(input);

-        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(settings, host, input);

        // If we have no auth headers then we default to the public archive
        // urls so we do not run into rate limits.
@@ -426,12 +457,12 @@ struct GitHubInputScheme : GitArchiveInputScheme
        return DownloadUrl{parseURL(url), headers};
    }

-    void clone(const Input & input, const Path & destDir) const override
+    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
    {
        auto host = getHost(input);
-        Input::fromURL(*input.settings, fmt("git+https://%s/%s/%s.git", host, getOwner(input), getRepo(input)))
+        Input::fromURL(settings, fmt("git+https://%s/%s/%s.git", host, getOwner(input), getRepo(input)))
            .applyOverrides(input.getRef(), input.getRev())
-            .clone(destDir);
+            .clone(settings, destDir);
    }
 };

@@ -442,6 +473,12 @@ struct GitLabInputScheme : GitArchiveInputScheme
        return "gitlab";
    }

+    std::string schemeDescription() const override
+    {
+        // TODO
+        return "";
+    }
+
    std::optional<std::pair<std::string, std::string>> accessHeaderFromToken(const std::string & token) const override
    {
        // Gitlab supports 4 kinds of authorization, two of which are
@@ -461,7 +498,7 @@ struct GitLabInputScheme : GitArchiveInputScheme
        return std::make_pair(token.substr(0, fldsplit), token.substr(fldsplit + 1));
    }

-    RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const override
+    RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const override
    {
        auto host = maybeGetStrAttr(input.attrs, "host").value_or("gitlab.com");
        // See rate limiting note below
@@ -472,9 +509,9 @@ struct GitLabInputScheme : GitArchiveInputScheme
                getStrAttr(input.attrs, "repo"),
                *input.getRef());

-        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(settings, host, input);

-        auto downloadResult = downloadFile(store, *input.settings, url, "source", headers);
+        auto downloadResult = downloadFile(store, settings, url, "source", headers);
        auto json = nlohmann::json::parse(
            store->requireStoreObjectAccessor(downloadResult.storePath)->readFile(CanonPath::root));

@@ -488,7 +525,7 @@ struct GitLabInputScheme : GitArchiveInputScheme
        }
    }

-    DownloadUrl getDownloadUrl(const Input & input) const override
+    DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const override
    {
        // This endpoint has a rate limit threshold that may be
        // server-specific and vary based whether the user is
@@ -503,19 +540,19 @@ struct GitLabInputScheme : GitArchiveInputScheme
                getStrAttr(input.attrs, "repo"),
                input.getRev()->to_string(HashFormat::Base16, false));

-        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
        return DownloadUrl{parseURL(url), headers};
    }

-    void clone(const Input & input, const Path & destDir) const override
+    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
    {
        auto host = maybeGetStrAttr(input.attrs, "host").value_or("gitlab.com");
        // FIXME: get username somewhere
        Input::fromURL(
-            *input.settings,
+            settings,
            fmt("git+https://%s/%s/%s.git", host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo")))
            .applyOverrides(input.getRef(), input.getRev())
-            .clone(destDir);
+            .clone(settings, destDir);
    }
 };

@@ -526,6 +563,12 @@ struct SourceHutInputScheme : GitArchiveInputScheme
        return "sourcehut";
    }

+    std::string schemeDescription() const override
+    {
+        // TODO
+        return "";
+    }
+
    std::optional<std::pair<std::string, std::string>> accessHeaderFromToken(const std::string & token) const override
    {
        // SourceHut supports both PAT and OAuth2. See
@@ -536,7 +579,7 @@ struct SourceHutInputScheme : GitArchiveInputScheme
        // Once it is implemented, however, should work as expected.
    }

-    RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const override
+    RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const override
    {
        // TODO: In the future, when the sourcehut graphql API is implemented for mercurial
        // and with anonymous access, this method should use it instead.
@@ -547,11 +590,11 @@ struct SourceHutInputScheme : GitArchiveInputScheme
        auto base_url =
            fmt("https://%s/%s/%s", host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo"));

-        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(settings, host, input);

        std::string refUri;
        if (ref == "HEAD") {
-            auto downloadFileResult = downloadFile(store, *input.settings, fmt("%s/HEAD", base_url), "source", headers);
+            auto downloadFileResult = downloadFile(store, settings, fmt("%s/HEAD", base_url), "source", headers);
            auto contents = store->requireStoreObjectAccessor(downloadFileResult.storePath)->readFile(CanonPath::root);

            auto remoteLine = git::parseLsRemoteLine(getLine(contents).first);
@@ -564,8 +607,7 @@ struct SourceHutInputScheme : GitArchiveInputScheme
        }
        std::regex refRegex(refUri);

-        auto downloadFileResult =
-            downloadFile(store, *input.settings, fmt("%s/info/refs", base_url), "source", headers);
+        auto downloadFileResult = downloadFile(store, settings, fmt("%s/info/refs", base_url), "source", headers);
        auto contents = store->requireStoreObjectAccessor(downloadFileResult.storePath)->readFile(CanonPath::root);
        std::istringstream is(contents);

@@ -583,7 +625,7 @@ struct SourceHutInputScheme : GitArchiveInputScheme
        return RefInfo{.rev = Hash::parseAny(*id, HashAlgorithm::SHA1)};
    }

-    DownloadUrl getDownloadUrl(const Input & input) const override
+    DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const override
    {
        auto host = maybeGetStrAttr(input.attrs, "host").value_or("git.sr.ht");
        auto url =
@@ -593,18 +635,18 @@ struct SourceHutInputScheme : GitArchiveInputScheme
                getStrAttr(input.attrs, "repo"),
                input.getRev()->to_string(HashFormat::Base16, false));

-        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
        return DownloadUrl{parseURL(url), headers};
    }

-    void clone(const Input & input, const Path & destDir) const override
+    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
    {
        auto host = maybeGetStrAttr(input.attrs, "host").value_or("git.sr.ht");
        Input::fromURL(
-            *input.settings,
+            settings,
            fmt("git+https://%s/%s/%s", host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo")))
            .applyOverrides(input.getRef(), input.getRev())
-            .clone(destDir);
+            .clone(settings, destDir);
    }
 };

--- a/src/libfetchers/include/nix/fetchers/fetchers.hh
+++ b/src/libfetchers/include/nix/fetchers/fetchers.hh
@@ -36,13 +36,6 @@ struct Input
 {
    friend struct InputScheme;

-    const Settings * settings;
-
-    Input(const Settings & settings)
-        : settings{&settings}
-    {
-    }
-
    std::shared_ptr<InputScheme> scheme; // note: can be null
    Attrs attrs;

@@ -87,7 +80,7 @@ public:
     * attributes like a Git revision or NAR hash that uniquely
     * identify its contents.
     */
-    bool isLocked() const;
+    bool isLocked(const Settings & settings) const;

    /**
     * Only for relative path flakes, i.e. 'path:./foo', returns the
@@ -120,7 +113,7 @@ public:
     * Fetch the entire input into the Nix store, returning the
     * location in the Nix store and the locked input.
     */
-    std::pair<StorePath, Input> fetchToStore(ref<Store> store) const;
+    std::pair<StorePath, Input> fetchToStore(const Settings & settings, ref<Store> store) const;

    /**
     * Check the locking attributes in `result` against
@@ -140,17 +133,17 @@ public:
     * input without copying it to the store. Also return a possibly
     * unlocked input.
     */
-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store) const;
+    std::pair<ref<SourceAccessor>, Input> getAccessor(const Settings & settings, ref<Store> store) const;

 private:

-    std::pair<ref<SourceAccessor>, Input> getAccessorUnchecked(ref<Store> store) const;
+    std::pair<ref<SourceAccessor>, Input> getAccessorUnchecked(const Settings & settings, ref<Store> store) const;

 public:

    Input applyOverrides(std::optional<std::string> ref, std::optional<Hash> rev) const;

-    void clone(const Path & destDir) const;
+    void clone(const Settings & settings, const Path & destDir) const;

    std::optional<std::filesystem::path> getSourcePath() const;

@@ -210,20 +203,33 @@ struct InputScheme
     */
    virtual std::string_view schemeName() const = 0;

+    /**
+     * Longform description of this scheme, for documentation purposes.
+     */
+    virtual std::string schemeDescription() const = 0;
+
+    // TODO remove these defaults
+    struct AttributeInfo
+    {
+        const char * type = "String";
+        bool required = true;
+        const char * doc = "";
+    };
+
    /**
     * Allowed attributes in an attribute set that is converted to an
-     * input.
+     * input, and documentation for each attribute.
     *
-     * `type` is not included from this set, because the `type` field is
+     * `type` is not included from this map, because the `type` field is
      parsed first to choose which scheme; `type` is always required.
     */
-    virtual StringSet allowedAttrs() const = 0;
+    virtual const std::map<std::string, AttributeInfo> & allowedAttrs() const = 0;

    virtual ParsedURL toURL(const Input & input) const;

    virtual Input applyOverrides(const Input & input, std::optional<std::string> ref, std::optional<Hash> rev) const;

-    virtual void clone(const Input & input, const Path & destDir) const;
+    virtual void clone(const Settings & settings, const Input & input, const Path & destDir) const;

    virtual std::optional<std::filesystem::path> getSourcePath(const Input & input) const;

@@ -233,7 +239,8 @@ struct InputScheme
        std::string_view contents,
        std::optional<std::string> commitMsg) const;

-    virtual std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & input) const = 0;
+    virtual std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & input) const = 0;

    /**
     * Is this `InputScheme` part of an experimental feature?
@@ -250,7 +257,7 @@ struct InputScheme
        return std::nullopt;
    }

-    virtual bool isLocked(const Input & input) const
+    virtual bool isLocked(const Settings & settings, const Input & input) const
    {
        return false;
    }
@@ -269,7 +276,12 @@ struct InputScheme

 void registerInputScheme(std::shared_ptr<InputScheme> && fetcher);

-nlohmann::json dumpRegisterInputSchemeInfo();
+using InputSchemeMap = std::map<std::string_view, std::shared_ptr<InputScheme>>;
+
+/**
+ * Use this for docs, not for finding a specific scheme
+ */
+const InputSchemeMap & getAllInputSchemes();

 struct PublicKey
 {
--- a/src/libfetchers/include/nix/fetchers/input-cache.hh
+++ b/src/libfetchers/include/nix/fetchers/input-cache.hh
@@ -3,6 +3,7 @@
 namespace nix::fetchers {

 enum class UseRegistries : int;
+struct Settings;

 struct InputCache
 {
@@ -14,7 +15,8 @@ struct InputCache
        Attrs extraAttrs;
    };

-    CachedResult getAccessor(ref<Store> store, const Input & originalInput, UseRegistries useRegistries);
+    CachedResult
+    getAccessor(const Settings & settings, ref<Store> store, const Input & originalInput, UseRegistries useRegistries);

    struct CachedInput
    {
--- a/src/libfetchers/include/nix/fetchers/registry.hh
+++ b/src/libfetchers/include/nix/fetchers/registry.hh
@@ -59,7 +59,7 @@ Path getUserRegistryPath();

 Registries getRegistries(const Settings & settings, ref<Store> store);

-void overrideRegistry(const Input & from, const Input & to, const Attrs & extraAttrs);
+void overrideRegistry(const Settings & settings, const Input & from, const Input & to, const Attrs & extraAttrs);

 enum class UseRegistries : int {
    No,
@@ -71,6 +71,7 @@ enum class UseRegistries : int {
 * Rewrite a flakeref using the registries. If `filter` is set, only
 * use the registries for which the filter function returns true.
 */
-std::pair<Input, Attrs> lookupInRegistries(ref<Store> store, const Input & input, UseRegistries useRegistries);
+std::pair<Input, Attrs>
+lookupInRegistries(const Settings & settings, ref<Store> store, const Input & input, UseRegistries useRegistries);

 } // namespace nix::fetchers
--- a/src/libfetchers/indirect.cc
+++ b/src/libfetchers/indirect.cc
@@ -44,7 +44,7 @@ struct IndirectInputScheme : InputScheme

        // FIXME: forbid query params?

-        Input input{settings};
+        Input input{};
        input.attrs.insert_or_assign("type", "indirect");
        input.attrs.insert_or_assign("id", id);
        if (rev)
@@ -60,14 +60,33 @@ struct IndirectInputScheme : InputScheme
        return "indirect";
    }

-    StringSet allowedAttrs() const override
+    std::string schemeDescription() const override
    {
-        return {
-            "id",
-            "ref",
-            "rev",
-            "narHash",
+        // TODO
+        return "";
+    }
+
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    {
+        static const std::map<std::string, AttributeInfo> attrs = {
+            {
+                "id",
+                {},
+            },
+            {
+                "ref",
+                {},
+            },
+            {
+                "rev",
+                {},
+            },
+            {
+                "narHash",
+                {},
+            },
        };
+        return attrs;
    }

    std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
@@ -76,7 +95,7 @@ struct IndirectInputScheme : InputScheme
        if (!std::regex_match(id, flakeRegex))
            throw BadURL("'%s' is not a valid flake ID", id);

-        Input input{settings};
+        Input input{};
        input.attrs = attrs;
        return input;
    }
@@ -106,7 +125,8 @@ struct IndirectInputScheme : InputScheme
        return input;
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & input) const override
    {
        throw Error("indirect input '%s' cannot be fetched directly", input.to_string());
    }
--- a/src/libfetchers/input-cache.cc
+++ b/src/libfetchers/input-cache.cc
@@ -5,23 +5,23 @@

 namespace nix::fetchers {

-InputCache::CachedResult
-InputCache::getAccessor(ref<Store> store, const Input & originalInput, UseRegistries useRegistries)
+InputCache::CachedResult InputCache::getAccessor(
+    const Settings & settings, ref<Store> store, const Input & originalInput, UseRegistries useRegistries)
 {
    auto fetched = lookup(originalInput);
    Input resolvedInput = originalInput;

    if (!fetched) {
        if (originalInput.isDirect()) {
-            auto [accessor, lockedInput] = originalInput.getAccessor(store);
+            auto [accessor, lockedInput] = originalInput.getAccessor(settings, store);
            fetched.emplace(CachedInput{.lockedInput = lockedInput, .accessor = accessor});
        } else {
            if (useRegistries != UseRegistries::No) {
-                auto [res, extraAttrs] = lookupInRegistries(store, originalInput, useRegistries);
+                auto [res, extraAttrs] = lookupInRegistries(settings, store, originalInput, useRegistries);
                resolvedInput = std::move(res);
                fetched = lookup(resolvedInput);
                if (!fetched) {
-                    auto [accessor, lockedInput] = resolvedInput.getAccessor(store);
+                    auto [accessor, lockedInput] = resolvedInput.getAccessor(settings, store);
                    fetched.emplace(
                        CachedInput{.lockedInput = lockedInput, .accessor = accessor, .extraAttrs = extraAttrs});
                }
--- a/src/libfetchers/mercurial.cc
+++ b/src/libfetchers/mercurial.cc
@@ -68,16 +68,41 @@ struct MercurialInputScheme : InputScheme
        return "hg";
    }

-    StringSet allowedAttrs() const override
+    std::string schemeDescription() const override
    {
-        return {
-            "url",
-            "ref",
-            "rev",
-            "revCount",
-            "narHash",
-            "name",
+        // TODO
+        return "";
+    }
+
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    {
+        static const std::map<std::string, AttributeInfo> attrs = {
+            {
+                "url",
+                {},
+            },
+            {
+                "ref",
+                {},
+            },
+            {
+                "rev",
+                {},
+            },
+            {
+                "revCount",
+                {},
+            },
+            {
+                "narHash",
+                {},
+            },
+            {
+                "name",
+                {},
+            },
        };
+        return attrs;
    }

    std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
@@ -89,7 +114,7 @@ struct MercurialInputScheme : InputScheme
                throw BadURL("invalid Mercurial branch/tag name '%s'", *ref);
        }

-        Input input{settings};
+        Input input{};
        input.attrs = attrs;
        return input;
    }
@@ -154,7 +179,7 @@ struct MercurialInputScheme : InputScheme
        return {isLocal, isLocal ? renderUrlPathEnsureLegal(url.path) : url.to_string()};
    }

-    StorePath fetchToStore(ref<Store> store, Input & input) const
+    StorePath fetchToStore(const Settings & settings, ref<Store> store, Input & input) const
    {
        auto origRev = input.getRev();

@@ -176,10 +201,10 @@ struct MercurialInputScheme : InputScheme
                /* This is an unclean working tree. So copy all tracked
                   files. */

-                if (!input.settings->allowDirty)
+                if (!settings.allowDirty)
                    throw Error("Mercurial tree '%s' is unclean", actualUrl);

-                if (input.settings->warnDirty)
+                if (settings.warnDirty)
                    warn("Mercurial tree '%s' is unclean", actualUrl);

                input.attrs.insert_or_assign("ref", chomp(runHg({"branch", "-R", actualUrl})));
@@ -240,13 +265,13 @@ struct MercurialInputScheme : InputScheme
        Cache::Key refToRevKey{"hgRefToRev", {{"url", actualUrl}, {"ref", *input.getRef()}}};

        if (!input.getRev()) {
-            if (auto res = input.settings->getCache()->lookupWithTTL(refToRevKey))
+            if (auto res = settings.getCache()->lookupWithTTL(refToRevKey))
                input.attrs.insert_or_assign("rev", getRevAttr(*res, "rev").gitRev());
        }

        /* If we have a rev, check if we have a cached store path. */
        if (auto rev = input.getRev()) {
-            if (auto res = input.settings->getCache()->lookupStorePath(revInfoKey(*rev), *store))
+            if (auto res = settings.getCache()->lookupStorePath(revInfoKey(*rev), *store))
                return makeResult(res->value, res->storePath);
        }

@@ -300,7 +325,7 @@ struct MercurialInputScheme : InputScheme

        /* Now that we have the rev, check the cache again for a
           cached store path. */
-        if (auto res = input.settings->getCache()->lookupStorePath(revInfoKey(rev), *store))
+        if (auto res = settings.getCache()->lookupStorePath(revInfoKey(rev), *store))
            return makeResult(res->value, res->storePath);

        Path tmpDir = createTempDir();
@@ -317,18 +342,19 @@ struct MercurialInputScheme : InputScheme
        });

        if (!origRev)
-            input.settings->getCache()->upsert(refToRevKey, {{"rev", rev.gitRev()}});
+            settings.getCache()->upsert(refToRevKey, {{"rev", rev.gitRev()}});

-        input.settings->getCache()->upsert(revInfoKey(rev), *store, infoAttrs, storePath);
+        settings.getCache()->upsert(revInfoKey(rev), *store, infoAttrs, storePath);

        return makeResult(infoAttrs, std::move(storePath));
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
    {
        Input input(_input);

-        auto storePath = fetchToStore(store, input);
+        auto storePath = fetchToStore(settings, store, input);
        auto accessor = store->requireStoreObjectAccessor(storePath);

        accessor->setPathDisplay("«" + input.to_string() + "»");
@@ -336,7 +362,7 @@ struct MercurialInputScheme : InputScheme
        return {accessor, input};
    }

-    bool isLocked(const Input & input) const override
+    bool isLocked(const Settings & settings, const Input & input) const override
    {
        return (bool) input.getRev();
    }
--- a/src/libfetchers/path.cc
+++ b/src/libfetchers/path.cc
@@ -17,7 +17,7 @@ struct PathInputScheme : InputScheme
        if (url.authority && url.authority->host.size())
            throw Error("path URL '%s' should not have an authority ('%s')", url, *url.authority);

-        Input input{settings};
+        Input input{};
        input.attrs.insert_or_assign("type", "path");
        input.attrs.insert_or_assign("path", renderUrlPathEnsureLegal(url.path));

@@ -40,27 +40,49 @@ struct PathInputScheme : InputScheme
        return "path";
    }

-    StringSet allowedAttrs() const override
+    std::string schemeDescription() const override
    {
-        return {
-            "path",
+        // TODO
+        return "";
+    }
+
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    {
+        static const std::map<std::string, AttributeInfo> attrs = {
+            {
+                "path",
+                {},
+            },
            /* Allow the user to pass in "fake" tree info
               attributes. This is useful for making a pinned tree work
               the same as the repository from which is exported (e.g.
               path:/nix/store/...-source?lastModified=1585388205&rev=b0c285...).
             */
-            "rev",
-            "revCount",
-            "lastModified",
-            "narHash",
+            {
+                "rev",
+                {},
+            },
+            {
+                "revCount",
+                {},
+            },
+            {
+                "lastModified",
+                {},
+            },
+            {
+                "narHash",
+                {},
+            },
        };
+        return attrs;
    }

    std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
    {
        getStrAttr(attrs, "path");

-        Input input{settings};
+        Input input{};
        input.attrs = attrs;
        return input;
    }
@@ -101,7 +123,7 @@ struct PathInputScheme : InputScheme
            return path;
    }

-    bool isLocked(const Input & input) const override
+    bool isLocked(const Settings & settings, const Input & input) const override
    {
        return (bool) input.getNarHash();
    }
@@ -116,7 +138,8 @@ struct PathInputScheme : InputScheme
        throw Error("cannot fetch input '%s' because it uses a relative path", input.to_string());
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
    {
        Input input(_input);
        auto path = getStrAttr(input.attrs, "path");
@@ -145,7 +168,7 @@ struct PathInputScheme : InputScheme
        auto info = store->queryPathInfo(*storePath);
        accessor->fingerprint =
            fmt("path:%s", store->queryPathInfo(*storePath)->narHash.to_string(HashFormat::SRI, true));
-        input.settings->getCache()->upsert(
+        settings.getCache()->upsert(
            makeFetchToStoreCacheKey(
                input.getName(), *accessor->fingerprint, ContentAddressMethod::Raw::NixArchive, "/"),
            *store,
--- a/src/libfetchers/registry.cc
+++ b/src/libfetchers/registry.cc
@@ -131,9 +131,9 @@ std::shared_ptr<Registry> getFlagRegistry(const Settings & settings)
    return flagRegistry;
 }

-void overrideRegistry(const Input & from, const Input & to, const Attrs & extraAttrs)
+void overrideRegistry(const Settings & settings, const Input & from, const Input & to, const Attrs & extraAttrs)
 {
-    getFlagRegistry(*from.settings)->add(from, to, extraAttrs);
+    getFlagRegistry(settings)->add(from, to, extraAttrs);
 }

 static std::shared_ptr<Registry> getGlobalRegistry(const Settings & settings, ref<Store> store)
@@ -172,7 +172,8 @@ Registries getRegistries(const Settings & settings, ref<Store> store)
    return registries;
 }

-std::pair<Input, Attrs> lookupInRegistries(ref<Store> store, const Input & _input, UseRegistries useRegistries)
+std::pair<Input, Attrs>
+lookupInRegistries(const Settings & settings, ref<Store> store, const Input & _input, UseRegistries useRegistries)
 {
    Attrs extraAttrs;
    int n = 0;
@@ -187,7 +188,7 @@ restart:
    if (n > 100)
        throw Error("cycle detected in flake registry for '%s'", input.to_string());

-    for (auto & registry : getRegistries(*input.settings, store)) {
+    for (auto & registry : getRegistries(settings, store)) {
        if (useRegistries == UseRegistries::Limited
            && !(registry->type == fetchers::Registry::Flag || registry->type == fetchers::Registry::Global))
            continue;
--- a/src/libfetchers/tarball.cc
+++ b/src/libfetchers/tarball.cc
@@ -224,7 +224,7 @@ ref<SourceAccessor> downloadTarball(ref<Store> store, const Settings & settings,

    auto input = Input::fromAttrs(settings, std::move(attrs));

-    return input.getAccessor(store).first;
+    return input.getAccessor(settings, store).first;
 }

 // An input scheme corresponding to a curl-downloadable resource.
@@ -252,7 +252,7 @@ struct CurlInputScheme : InputScheme
        if (!isValidURL(_url, requireTree))
            return std::nullopt;

-        Input input{settings};
+        Input input{};

        auto url = _url;

@@ -278,7 +278,7 @@ struct CurlInputScheme : InputScheme
           HTTP request. Now that we've processed the Nix-specific
           attributes above, remove them so we don't also send them as
           part of the HTTP request. */
-        for (auto & param : allowedAttrs())
+        for (auto & [param, _] : allowedAttrs())
            url.query.erase(param);

        input.attrs.insert_or_assign("type", std::string{schemeName()});
@@ -286,23 +286,88 @@ struct CurlInputScheme : InputScheme
        return input;
    }

-    StringSet allowedAttrs() const override
+    static const std::map<std::string, AttributeInfo> & allowedAttrsImpl()
    {
-        return {
-            "type",
-            "url",
-            "narHash",
-            "name",
-            "unpack",
-            "rev",
-            "revCount",
-            "lastModified",
+        static const std::map<std::string, AttributeInfo> attrs = {
+            {
+                "url",
+                {
+                    .type = "String",
+                    .required = true,
+                    .doc = R"(
+                      Supported protocols:
+
+                      - `https`
+
+                        > **Example**
+                        >
+                        > ```nix
+                        > fetchTree {
+                        >   type = "file";
+                        >   url = "https://example.com/index.html";
+                        > }
+                        > ```
+
+                      - `http`
+
+                        Insecure HTTP transfer for legacy sources.
+
+                        > **Warning**
+                        >
+                        > HTTP performs no encryption or authentication.
+                        > Use a `narHash` known in advance to ensure the output has expected contents.
+
+                      - `file`
+
+                        A file on the local file system.
+
+                        > **Example**
+                        >
+                        > ```nix
+                        > fetchTree {
+                        >   type = "file";
+                        >   url = "file:///home/eelco/nix/README.md";
+                        > }
+                        > ```
+                    )",
+                },
+            },
+            {
+                "narHash",
+                {},
+            },
+            {
+                "name",
+                {},
+            },
+            {
+                "unpack",
+                {},
+            },
+            {
+                "rev",
+                {},
+            },
+            {
+                "revCount",
+                {},
+            },
+            {
+                "lastModified",
+                {},
+            },
        };
+        return attrs;
+    }
+
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    {
+        return allowedAttrsImpl();
    }

    std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
    {
-        Input input{settings};
+        Input input{};
        input.attrs = attrs;

        // input.locked = (bool) maybeGetStrAttr(input.attrs, "hash");
@@ -319,7 +384,7 @@ struct CurlInputScheme : InputScheme
        return url;
    }

-    bool isLocked(const Input & input) const override
+    bool isLocked(const Settings & settings, const Input & input) const override
    {
        return (bool) input.getNarHash();
    }
@@ -332,6 +397,14 @@ struct FileInputScheme : CurlInputScheme
        return "file";
    }

+    std::string schemeDescription() const override
+    {
+        return stripIndentation(R"(
+          Place a plain file into the Nix store.
+          This is similar to [`builtins.fetchurl`](@docroot@/language/builtins.md#builtins-fetchurl)
+        )");
+    }
+
    bool isValidURL(const ParsedURL & url, bool requireTree) const override
    {
        auto parsedUrlScheme = parseUrlScheme(url.scheme);
@@ -340,7 +413,8 @@ struct FileInputScheme : CurlInputScheme
                                               : (!requireTree && !hasTarballExtension(url)));
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
    {
        auto input(_input);

@@ -348,7 +422,7 @@ struct FileInputScheme : CurlInputScheme
           the Nix store directly, since there is little deduplication
           benefit in using the Git cache for single big files like
           tarballs. */
-        auto file = downloadFile(store, *input.settings, getStrAttr(input.attrs, "url"), input.getName());
+        auto file = downloadFile(store, settings, getStrAttr(input.attrs, "url"), input.getName());

        auto narHash = store->queryPathInfo(file.storePath)->narHash;
        input.attrs.insert_or_assign("narHash", narHash.to_string(HashFormat::SRI, true));
@@ -368,6 +442,34 @@ struct TarballInputScheme : CurlInputScheme
        return "tarball";
    }

+    std::string schemeDescription() const override
+    {
+        return stripIndentation(R"(
+          Download a tar archive and extract it into the Nix store.
+          This has the same underlying implementation as [`builtins.fetchTarball`](@docroot@/language/builtins.md#builtins-fetchTarball)
+        )");
+    }
+
+    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    {
+        static const std::map<std::string, AttributeInfo> attrs = [] {
+            auto attrs = CurlInputScheme::allowedAttrsImpl();
+            // Override the "url" attribute to add tarball-specific example
+            attrs["url"].doc = R"(
+              > **Example**
+              >
+              > ```nix
+              > fetchTree {
+              >   type = "tarball";
+              >   url = "https://github.com/NixOS/nixpkgs/tarball/nixpkgs-23.11";
+              > }
+              > ```
+            )";
+            return attrs;
+        }();
+        return attrs;
+    }
+
    bool isValidURL(const ParsedURL & url, bool requireTree) const override
    {
        auto parsedUrlScheme = parseUrlScheme(url.scheme);
@@ -377,15 +479,15 @@ struct TarballInputScheme : CurlInputScheme
                                               : (requireTree || hasTarballExtension(url)));
    }

-    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input>
+    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
    {
        auto input(_input);

-        auto result =
-            downloadTarball_(*input.settings, getStrAttr(input.attrs, "url"), {}, "«" + input.to_string() + "»");
+        auto result = downloadTarball_(settings, getStrAttr(input.attrs, "url"), {}, "«" + input.to_string() + "»");

        if (result.immutableUrl) {
-            auto immutableInput = Input::fromURL(*input.settings, *result.immutableUrl);
+            auto immutableInput = Input::fromURL(settings, *result.immutableUrl);
            // FIXME: would be nice to support arbitrary flakerefs
            // here, e.g. git flakes.
            if (immutableInput.getType() != "tarball")
@@ -398,9 +500,7 @@ struct TarballInputScheme : CurlInputScheme

        input.attrs.insert_or_assign(
            "narHash",
-            input.settings->getTarballCache()
-                ->treeHashToNarHash(*input.settings, result.treeHash)
-                .to_string(HashFormat::SRI, true));
+            settings.getTarballCache()->treeHashToNarHash(settings, result.treeHash).to_string(HashFormat::SRI, true));

        return {result.accessor, input};
    }
--- a/src/libflake/flake-primops.cc
+++ b/src/libflake/flake-primops.cc
@@ -38,7 +38,7 @@ PrimOp getFlake(const Settings & settings)
        std::string flakeRefS(
            state.forceStringNoCtx(*args[0], pos, "while evaluating the argument passed to builtins.getFlake"));
        auto flakeRef = nix::parseFlakeRef(state.fetchSettings, flakeRefS, {}, true);
-        if (state.settings.pureEval && !flakeRef.input.isLocked())
+        if (state.settings.pureEval && !flakeRef.input.isLocked(state.fetchSettings))
            throw Error(
                "cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)",
                flakeRefS,
--- a/src/libflake/flake.cc
+++ b/src/libflake/flake.cc
@@ -372,7 +372,8 @@ static Flake getFlake(
    const InputAttrPath & lockRootAttrPath)
 {
    // Fetch a lazy tree first.
-    auto cachedInput = state.inputCache->getAccessor(state.store, originalRef.input, useRegistries);
+    auto cachedInput =
+        state.inputCache->getAccessor(state.fetchSettings, state.store, originalRef.input, useRegistries);

    auto subdir = fetchers::maybeGetStrAttr(cachedInput.extraAttrs, "dir").value_or(originalRef.subdir);
    auto resolvedRef = FlakeRef(std::move(cachedInput.resolvedInput), subdir);
@@ -388,7 +389,8 @@ static Flake getFlake(
        debug("refetching input '%s' due to self attribute", newLockedRef);
        // FIXME: need to remove attrs that are invalidated by the changed input attrs, such as 'narHash'.
        newLockedRef.input.attrs.erase("narHash");
-        auto cachedInput2 = state.inputCache->getAccessor(state.store, newLockedRef.input, fetchers::UseRegistries::No);
+        auto cachedInput2 = state.inputCache->getAccessor(
+            state.fetchSettings, state.store, newLockedRef.input, fetchers::UseRegistries::No);
        cachedInput.accessor = cachedInput2.accessor;
        lockedRef = FlakeRef(std::move(cachedInput2.lockedInput), newLockedRef.subdir);
    }
@@ -704,7 +706,8 @@ lockFlake(const Settings & settings, EvalState & state, const FlakeRef & topRef,
                           this input. */
                        debug("creating new input '%s'", inputAttrPathS);

-                        if (!lockFlags.allowUnlocked && !input.ref->input.isLocked() && !input.ref->input.isRelative())
+                        if (!lockFlags.allowUnlocked && !input.ref->input.isLocked(state.fetchSettings)
+                            && !input.ref->input.isRelative())
                            throw Error("cannot update unlocked flake input '%s' in pure mode", inputAttrPathS);

                        /* Note: in case of an --override-input, we use
@@ -753,7 +756,7 @@ lockFlake(const Settings & settings, EvalState & state, const FlakeRef & topRef,
                                    return {*resolvedPath, *input.ref};
                                } else {
                                    auto cachedInput = state.inputCache->getAccessor(
-                                        state.store, input.ref->input, useRegistriesInputs);
+                                        state.fetchSettings, state.store, input.ref->input, useRegistriesInputs);

                                    auto lockedRef = FlakeRef(std::move(cachedInput.lockedInput), input.ref->subdir);

--- a/src/libflake/flakeref.cc
+++ b/src/libflake/flakeref.cc
@@ -64,9 +64,10 @@ std::ostream & operator<<(std::ostream & str, const FlakeRef & flakeRef)
    return str;
 }

-FlakeRef FlakeRef::resolve(ref<Store> store, fetchers::UseRegistries useRegistries) const
+FlakeRef FlakeRef::resolve(
+    const fetchers::Settings & fetchSettings, ref<Store> store, fetchers::UseRegistries useRegistries) const
 {
-    auto [input2, extraAttrs] = lookupInRegistries(store, input, useRegistries);
+    auto [input2, extraAttrs] = lookupInRegistries(fetchSettings, store, input, useRegistries);
    return FlakeRef(std::move(input2), fetchers::maybeGetStrAttr(extraAttrs, "dir").value_or(subdir));
 }

@@ -287,9 +288,10 @@ FlakeRef FlakeRef::fromAttrs(const fetchers::Settings & fetchSettings, const fet
        fetchers::maybeGetStrAttr(attrs, "dir").value_or(""));
 }

-std::pair<ref<SourceAccessor>, FlakeRef> FlakeRef::lazyFetch(ref<Store> store) const
+std::pair<ref<SourceAccessor>, FlakeRef>
+FlakeRef::lazyFetch(const fetchers::Settings & fetchSettings, ref<Store> store) const
 {
-    auto [accessor, lockedInput] = input.getAccessor(store);
+    auto [accessor, lockedInput] = input.getAccessor(fetchSettings, store);
    return {accessor, FlakeRef(std::move(lockedInput), subdir)};
 }

--- a/src/libflake/include/nix/flake/flakeref.hh
+++ b/src/libflake/include/nix/flake/flakeref.hh
@@ -71,11 +71,15 @@ struct FlakeRef

    fetchers::Attrs toAttrs() const;

-    FlakeRef resolve(ref<Store> store, fetchers::UseRegistries useRegistries = fetchers::UseRegistries::All) const;
+    FlakeRef resolve(
+        const fetchers::Settings & fetchSettings,
+        ref<Store> store,
+        fetchers::UseRegistries useRegistries = fetchers::UseRegistries::All) const;

    static FlakeRef fromAttrs(const fetchers::Settings & fetchSettings, const fetchers::Attrs & attrs);

-    std::pair<ref<SourceAccessor>, FlakeRef> lazyFetch(ref<Store> store) const;
+    std::pair<ref<SourceAccessor>, FlakeRef>
+    lazyFetch(const fetchers::Settings & fetchSettings, ref<Store> store) const;

    /**
     * Canonicalize a flakeref for the purpose of comparing "old" and
--- a/src/libflake/lockfile.cc
+++ b/src/libflake/lockfile.cc
@@ -74,7 +74,7 @@ LockedNode::LockedNode(const fetchers::Settings & fetchSettings, const nlohmann:
    , parentInputAttrPath(
          json.find("parent") != json.end() ? (std::optional<InputAttrPath>) json["parent"] : std::nullopt)
 {
-    if (!lockedRef.input.isLocked() && !lockedRef.input.isRelative()) {
+    if (!lockedRef.input.isLocked(fetchSettings) && !lockedRef.input.isRelative()) {
        if (lockedRef.input.getNarHash())
            warn(
                "Lock file entry '%s' is unlocked (e.g. lacks a Git revision) but is checked by NAR hash. "
@@ -282,7 +282,7 @@ std::optional<FlakeRef> LockFile::isUnlocked(const fetchers::Settings & fetchSet
       latter case, we can verify the input but we may not be able to
       fetch it from anywhere. */
    auto isConsideredLocked = [&](const fetchers::Input & input) {
-        return input.isLocked() || (fetchSettings.allowDirtyLocks && input.getNarHash());
+        return input.isLocked(fetchSettings) || (fetchSettings.allowDirtyLocks && input.getNarHash());
    };

    for (auto & i : nodes) {
--- a/src/libstore/build-result.cc
+++ b/src/libstore/build-result.cc
@@ -40,7 +40,7 @@ static BuildResult::Success::Status successStatusFromString(std::string_view str
    throw Error("unknown built result success status '%s'", str);
 }

-static constexpr std::array<std::pair<BuildResult::Failure::Status, std::string_view>, 13> failureStatusStrings{{
+static constexpr std::array<std::pair<BuildResult::Failure::Status, std::string_view>, 12> failureStatusStrings{{
 #define ENUM_ENTRY(e) {BuildResult::Failure::e, #e}
    ENUM_ENTRY(PermanentFailure),
    ENUM_ENTRY(InputRejected),
@@ -54,7 +54,6 @@ static constexpr std::array<std::pair<BuildResult::Failure::Status, std::string_
    ENUM_ENTRY(NotDeterministic),
    ENUM_ENTRY(NoSubstituters),
    ENUM_ENTRY(HashMismatch),
-    ENUM_ENTRY(Cancelled),
 #undef ENUM_ENTRY
 }};

--- a/src/libstore/include/nix/store/build-result.hh
+++ b/src/libstore/include/nix/store/build-result.hh
@@ -74,7 +74,6 @@ struct BuildResult
            /// know about this one, so change it back to `OutputRejected`
            /// before serialization.
            HashMismatch = 15,
-            Cancelled = 16,
        } status = MiscFailure;

        /**
--- a/src/libstore/include/nix/store/build/goal.hh
+++ b/src/libstore/include/nix/store/build/goal.hh
@@ -109,7 +109,7 @@ public:
    /**
     * Build result.
     */
-    BuildResult buildResult = {.inner = BuildResult::Failure{.status = BuildResult::Failure::Cancelled}};
+    BuildResult buildResult;

    /**
     * Suspend our goal and wait until we get `work`-ed again.
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -1385,7 +1385,6 @@ bool LocalStore::verifyStore(bool checkContents, RepairFlag repair)
            checkInterrupt();
            auto name = link.path().filename();
            printMsg(lvlTalkative, "checking contents of %s", name);
-            PosixSourceAccessor accessor;
            std::string hash = hashPath(
                                   PosixSourceAccessor::createAtRoot(link.path()),
                                   FileIngestionMethod::NixArchive,
--- a/src/libutil-tests/monitorfdhup.cc
+++ b/src/libutil-tests/monitorfdhup.cc
@@ -1,4 +1,5 @@
-#ifndef _WIN32
+// TODO: investigate why this is hanging on cygwin
+#if !defined(_WIN32) && !defined(__CYGWIN__)

 #  include "nix/util/util.hh"
 #  include "nix/util/monitor-fd.hh"
--- a/src/libutil/archive.cc
+++ b/src/libutil/archive.cc
@@ -103,9 +103,9 @@ void SourceAccessor::dumpPath(const CanonPath & path, Sink & sink, PathFilter &

 time_t dumpPathAndGetMtime(const Path & path, Sink & sink, PathFilter & filter)
 {
-    auto path2 = PosixSourceAccessor::createAtRoot(path);
+    auto path2 = PosixSourceAccessor::createAtRoot(path, /*trackLastModified=*/true);
    path2.dumpPath(sink, filter);
-    return path2.accessor.dynamic_pointer_cast<PosixSourceAccessor>()->mtime;
+    return path2.accessor->getLastModified().value();
 }

 void dumpPath(const Path & path, Sink & sink, PathFilter & filter)
--- a/src/libutil/include/nix/util/canon-path.hh
+++ b/src/libutil/include/nix/util/canon-path.hh
@@ -8,6 +8,7 @@
 #include <iostream>
 #include <set>
 #include <vector>
+#include <ranges>

 #include <boost/container_hash/hash.hpp>

@@ -122,33 +123,70 @@ public:
        return &cs[1];
    }

-    struct Iterator
+    class Iterator
    {
+        /**
+         * Helper class with overloaded operator-> for "drill-down" behavior.
+         * This was a "temporary" string_view doesn't have to be stored anywhere.
+         */
+        class PointerProxy
+        {
+            std::string_view segment;
+
+        public:
+            PointerProxy(std::string_view segment_)
+                : segment(segment_)
+            {
+            }
+
+            const std::string_view * operator->() const
+            {
+                return &segment;
+            }
+        };
+
+    public:
+        using value_type = std::string_view;
+        using reference_type = const std::string_view;
+        using pointer_type = PointerProxy;
+        using difference_type = std::ptrdiff_t;
+        using iterator_category = std::forward_iterator_tag;
+
        std::string_view remaining;
        size_t slash;

+        /**
+         * Dummy default constructor required for forward iterators. Doesn't return
+         * a usable iterator.
+         */
+        Iterator()
+            : remaining()
+            , slash(0)
+        {
+        }
+
        Iterator(std::string_view remaining)
            : remaining(remaining)
            , slash(remaining.find('/'))
        {
        }

-        bool operator!=(const Iterator & x) const
-        {
-            return remaining.data() != x.remaining.data();
-        }
-
        bool operator==(const Iterator & x) const
        {
-            return !(*this != x);
+            return remaining.data() == x.remaining.data();
        }

-        const std::string_view operator*() const
+        reference_type operator*() const
        {
            return remaining.substr(0, slash);
        }

-        void operator++()
+        pointer_type operator->() const
+        {
+            return PointerProxy(**this);
+        }
+
+        Iterator & operator++()
        {
            if (slash == remaining.npos)
                remaining = remaining.substr(remaining.size());
@@ -156,9 +194,19 @@ public:
                remaining = remaining.substr(slash + 1);
                slash = remaining.find('/');
            }
+            return *this;
+        }
+
+        Iterator operator++(int)
+        {
+            auto tmp = *this;
+            ++*this;
+            return tmp;
        }
    };

+    static_assert(std::forward_iterator<Iterator>);
+
    Iterator begin() const
    {
        return Iterator(rel());
@@ -265,6 +313,8 @@ public:
    friend std::size_t hash_value(const CanonPath &);
 };

+static_assert(std::ranges::forward_range<CanonPath>);
+
 std::ostream & operator<<(std::ostream & stream, const CanonPath & path);

 inline std::size_t hash_value(const CanonPath & path)
--- a/src/libutil/include/nix/util/posix-source-accessor.hh
+++ b/src/libutil/include/nix/util/posix-source-accessor.hh
@@ -9,7 +9,7 @@ struct SourcePath;
 /**
 * A source accessor that uses the Unix filesystem.
 */
-struct PosixSourceAccessor : virtual SourceAccessor
+class PosixSourceAccessor : virtual public SourceAccessor
 {
    /**
     * Optional root path to prefix all operations into the native file
@@ -18,8 +18,12 @@ struct PosixSourceAccessor : virtual SourceAccessor
     */
    const std::filesystem::path root;

+    const bool trackLastModified = false;
+
+public:
+
    PosixSourceAccessor();
-    PosixSourceAccessor(std::filesystem::path && root);
+    PosixSourceAccessor(std::filesystem::path && root, bool trackLastModified = false);

    /**
     * The most recent mtime seen by lstat(). This is a hack to
@@ -43,6 +47,9 @@ struct PosixSourceAccessor : virtual SourceAccessor
     * Create a `PosixSourceAccessor` and `SourcePath` corresponding to
     * some native path.
     *
+     * @param Whether the accessor should return a non-null getLastModified.
+     * When true the accessor must be used only by a single thread.
+     *
     * The `PosixSourceAccessor` is rooted as far up the tree as
     * possible, (e.g. on Windows it could scoped to a drive like
     * `C:\`). This allows more `..` parent accessing to work.
@@ -64,7 +71,12 @@ struct PosixSourceAccessor : virtual SourceAccessor
     * and
     * [`std::filesystem::path::relative_path`](https://en.cppreference.com/w/cpp/filesystem/path/relative_path).
     */
-    static SourcePath createAtRoot(const std::filesystem::path & path);
+    static SourcePath createAtRoot(const std::filesystem::path & path, bool trackLastModified = false);
+
+    std::optional<std::time_t> getLastModified() override
+    {
+        return trackLastModified ? std::optional{mtime} : std::nullopt;
+    }

 private:

--- a/src/libutil/include/nix/util/strings-inline.hh
+++ b/src/libutil/include/nix/util/strings-inline.hh
@@ -114,4 +114,69 @@ std::string dropEmptyInitThenConcatStringsSep(const std::string_view sep, const
    return s;
 }

+/**
+ * Consteval helper for the "constexpr 2-step" pattern.
+ * Converts a std::string to a std::array<char, N> for stable compile-time storage.
+ *
+ * Usage:
+ *   static constexpr auto str = stripIndentationConsteval(...);
+ *   static constexpr auto arr = toArray<str.size()>(str);
+ *   static constexpr std::string_view view{arr.data(), arr.size()};
+ */
+template<size_t N>
+consteval std::string_view toArray(const std::string & s)
+{
+    static std::array<char, N> arr{};
+    for (size_t i = 0; i < N; ++i) {
+        arr[i] = s[i];
+    }
+    return {arr.data(), N};
+}
+
+constexpr std::string stripIndentationImpl(std::string_view s)
+{
+    size_t minIndent = 10000;
+    size_t curIndent = 0;
+    bool atStartOfLine = true;
+
+    for (auto & c : s) {
+        if (atStartOfLine && c == ' ')
+            curIndent++;
+        else if (c == '\n') {
+            if (atStartOfLine)
+                minIndent = std::max(minIndent, curIndent);
+            curIndent = 0;
+            atStartOfLine = true;
+        } else {
+            if (atStartOfLine) {
+                minIndent = std::min(minIndent, curIndent);
+                atStartOfLine = false;
+            }
+        }
+    }
+
+    std::string res;
+
+    size_t pos = 0;
+    while (pos < s.size()) {
+        auto eol = s.find('\n', pos);
+        if (eol == s.npos)
+            eol = s.size();
+        if (eol - pos > minIndent)
+            res.append(s.substr(pos + minIndent, eol - pos - minIndent));
+        res.push_back('\n');
+        pos = eol + 1;
+    }
+
+    return res;
+}
+
+template<std::string_view s>
+consteval std::string_view stripIndentationConsteval()
+{
+    constexpr auto stripped = stripIndentationImpl(s);
+    constexpr size_t n = stripped.size();
+    return toArray<n>(stripped);
+}
+
 } // namespace nix
--- a/src/libutil/include/nix/util/strings.hh
+++ b/src/libutil/include/nix/util/strings.hh
@@ -132,6 +132,13 @@ std::string optionalBracket(std::string_view prefix, const std::optional<T> & co
    return optionalBracket(prefix, std::string_view(*content), suffix);
 }

+/**
+ * Remove common leading whitespace from the lines in the string
+ * 's'. For example, if every line is indented by at least 3 spaces,
+ * then we remove 3 spaces from the start of every line.
+ */
+std::string stripIndentation(std::string_view s);
+
 /**
 * Hash implementation that can be used for zero-copy heterogenous lookup from
 * P1690R1[1] in unordered containers.
--- a/src/libutil/include/nix/util/util.hh
+++ b/src/libutil/include/nix/util/util.hh
@@ -33,15 +33,28 @@ auto concatStrings(Parts &&... parts)
    return concatStringsSep({}, views);
 }

+/**
+ * Add quotes around a string.
+ */
+inline std::string quoteString(std::string_view s, char quote = '\'')
+{
+    std::string result;
+    result.reserve(s.size() + 2);
+    result += quote;
+    result += s;
+    result += quote;
+    return result;
+}
+
 /**
 * Add quotes around a collection of strings.
 */
 template<class C>
-Strings quoteStrings(const C & c)
+Strings quoteStrings(const C & c, char quote = '\'')
 {
    Strings res;
    for (auto & s : c)
-        res.push_back("'" + s + "'");
+        res.push_back(quoteString(s, quote));
    return res;
 }

@@ -215,13 +228,6 @@ constexpr char treeLast[] = "└───";
 constexpr char treeLine[] = "│   ";
 constexpr char treeNull[] = "    ";

-/**
- * Remove common leading whitespace from the lines in the string
- * 's'. For example, if every line is indented by at least 3 spaces,
- * then we remove 3 spaces from the start of every line.
- */
-std::string stripIndentation(std::string_view s);
-
 /**
 * Get the prefix of 's' up to and excluding the next line break (LF
 * optionally preceded by CR), and the remainder following the line
--- a/src/libutil/posix-source-accessor.cc
+++ b/src/libutil/posix-source-accessor.cc
@@ -7,8 +7,9 @@

 namespace nix {

-PosixSourceAccessor::PosixSourceAccessor(std::filesystem::path && argRoot)
+PosixSourceAccessor::PosixSourceAccessor(std::filesystem::path && argRoot, bool trackLastModified)
    : root(std::move(argRoot))
+    , trackLastModified(trackLastModified)
 {
    assert(root.empty() || root.is_absolute());
    displayPrefix = root.string();
@@ -19,11 +20,11 @@ PosixSourceAccessor::PosixSourceAccessor()
 {
 }

-SourcePath PosixSourceAccessor::createAtRoot(const std::filesystem::path & path)
+SourcePath PosixSourceAccessor::createAtRoot(const std::filesystem::path & path, bool trackLastModified)
 {
    std::filesystem::path path2 = absPath(path);
    return {
-        make_ref<PosixSourceAccessor>(path2.root_path()),
+        make_ref<PosixSourceAccessor>(path2.root_path(), trackLastModified),
        CanonPath{path2.relative_path().string()},
    };
 }
@@ -114,9 +115,12 @@ std::optional<SourceAccessor::Stat> PosixSourceAccessor::maybeLstat(const CanonP
    auto st = cachedLstat(path);
    if (!st)
        return std::nullopt;
-    // This makes the accessor thread-unsafe, but we only seem to use the actual value in a single threaded context in
-    // `src/libfetchers/path.cc`.
-    mtime = std::max(mtime, st->st_mtime);
+
+    /* The contract is that trackLastModified implies that the caller uses the accessor
+       from a single thread. Thus this is not a CAS loop. */
+    if (trackLastModified)
+        mtime = std::max(mtime, st->st_mtime);
+
    return Stat{
        .type = S_ISREG(st->st_mode)   ? tRegular
                : S_ISDIR(st->st_mode) ? tDirectory
--- a/src/libutil/strings.cc
+++ b/src/libutil/strings.cc
@@ -152,4 +152,8 @@ std::string optionalBracket(std::string_view prefix, std::string_view content, s
    return result;
 }

+std::string stripIndentation(std::string_view s) {
+    return stripIndentationImpl(s);
+}
+
 } // namespace nix
--- a/src/libutil/util.cc
+++ b/src/libutil/util.cc
@@ -250,44 +250,6 @@ void ignoreExceptionExceptInterrupt(Verbosity lvl)
    }
 }

-std::string stripIndentation(std::string_view s)
-{
-    size_t minIndent = 10000;
-    size_t curIndent = 0;
-    bool atStartOfLine = true;
-
-    for (auto & c : s) {
-        if (atStartOfLine && c == ' ')
-            curIndent++;
-        else if (c == '\n') {
-            if (atStartOfLine)
-                minIndent = std::max(minIndent, curIndent);
-            curIndent = 0;
-            atStartOfLine = true;
-        } else {
-            if (atStartOfLine) {
-                minIndent = std::min(minIndent, curIndent);
-                atStartOfLine = false;
-            }
-        }
-    }
-
-    std::string res;
-
-    size_t pos = 0;
-    while (pos < s.size()) {
-        auto eol = s.find('\n', pos);
-        if (eol == s.npos)
-            eol = s.size();
-        if (eol - pos > minIndent)
-            res.append(s.substr(pos + minIndent, eol - pos - minIndent));
-        res.push_back('\n');
-        pos = eol + 1;
-    }
-
-    return res;
-}
-
 std::pair<std::string_view, std::string_view> getLine(std::string_view s)
 {
    auto newline = s.find('\n');
--- a/src/nix/flake-prefetch-inputs.cc
+++ b/src/nix/flake-prefetch-inputs.cc
@@ -45,7 +45,7 @@ struct CmdFlakePrefetchInputs : FlakeCommand
            if (auto lockedNode = dynamic_cast<const LockedNode *>(&node)) {
                try {
                    Activity act(*logger, lvlInfo, actUnknown, fmt("fetching '%s'", lockedNode->lockedRef));
-                    auto accessor = lockedNode->lockedRef.input.getAccessor(store).first;
+                    auto accessor = lockedNode->lockedRef.input.getAccessor(fetchSettings, store).first;
                    fetchToStore(
                        fetchSettings, *store, accessor, FetchMode::Copy, lockedNode->lockedRef.input.getName());
                } catch (Error & e) {
--- a/src/nix/flake.cc
+++ b/src/nix/flake.cc
@@ -245,7 +245,7 @@ struct CmdFlakeMetadata : FlakeCommand, MixJSON
            printJSON(j);
        } else {
            logger->cout(ANSI_BOLD "Resolved URL:" ANSI_NORMAL "  %s", flake.resolvedRef.to_string());
-            if (flake.lockedRef.input.isLocked())
+            if (flake.lockedRef.input.isLocked(fetchSettings))
                logger->cout(ANSI_BOLD "Locked URL:" ANSI_NORMAL "    %s", flake.lockedRef.to_string());
            if (flake.description)
                logger->cout(ANSI_BOLD "Description:" ANSI_NORMAL "   %s", *flake.description);
@@ -1049,7 +1049,7 @@ struct CmdFlakeClone : FlakeCommand
        if (destDir.empty())
            throw Error("missing flag '--dest'");

-        getFlakeRef().resolve(store).input.clone(destDir);
+        getFlakeRef().resolve(fetchSettings, store).input.clone(fetchSettings, destDir);
    }
 };

@@ -1100,7 +1100,7 @@ struct CmdFlakeArchive : FlakeCommand, MixJSON, MixDryRun, MixNoCheckSigs
                    std::optional<StorePath> storePath;
                    if (!(*inputNode)->lockedRef.input.isRelative()) {
                        storePath = dryRun ? (*inputNode)->lockedRef.input.computeStorePath(*store)
-                                           : (*inputNode)->lockedRef.input.fetchToStore(store).first;
+                                           : (*inputNode)->lockedRef.input.fetchToStore(fetchSettings, store).first;
                        sources.insert(*storePath);
                    }
                    if (json) {
@@ -1324,8 +1324,10 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                        try {
                            if (visitor.isDerivation())
                                showDerivation();
-                            else
-                                throw Error("expected a derivation");
+                            else {
+                                auto name = visitor.getAttrPathStr(state->s.name);
+                                logger->warn(fmt("%s is not a derivation", name));
+                            }
                        } catch (IFDError & e) {
                            if (!json) {
                                logger->cout(
@@ -1496,8 +1498,8 @@ struct CmdFlakePrefetch : FlakeCommand, MixJSON
    void run(ref<Store> store) override
    {
        auto originalRef = getFlakeRef();
-        auto resolvedRef = originalRef.resolve(store);
-        auto [accessor, lockedRef] = resolvedRef.lazyFetch(store);
+        auto resolvedRef = originalRef.resolve(fetchSettings, store);
+        auto [accessor, lockedRef] = resolvedRef.lazyFetch(getEvalState()->fetchSettings, store);
        auto storePath =
            fetchToStore(getEvalState()->fetchSettings, *store, accessor, FetchMode::Copy, lockedRef.input.getName());
        auto hash = store->queryPathInfo(storePath)->narHash;
--- a/src/nix/main.cc
+++ b/src/nix/main.cc
@@ -193,20 +193,38 @@ struct NixArgs : virtual MultiCommand, virtual MixCommonArgs, virtual RootArgs

    std::string dumpCli()
    {
-        auto res = nlohmann::json::object();
+        using nlohmann::json;
+
+        auto res = json::object();

        res["args"] = toJSON();

-        auto stores = nlohmann::json::object();
-        for (auto & [storeName, implem] : Implementations::registered()) {
-            auto & j = stores[storeName];
-            j["doc"] = implem.doc;
-            j["uri-schemes"] = implem.uriSchemes;
-            j["settings"] = implem.getConfig()->toJSON();
-            j["experimentalFeature"] = implem.experimentalFeature;
+        {
+            auto & stores = res["stores"] = json::object();
+            for (auto & [storeName, implem] : Implementations::registered()) {
+                auto & j = stores[storeName];
+                j["doc"] = implem.doc;
+                j["uri-schemes"] = implem.uriSchemes;
+                j["settings"] = implem.getConfig()->toJSON();
+                j["experimentalFeature"] = implem.experimentalFeature;
+            }
        }
-        res["stores"] = std::move(stores);
-        res["fetchers"] = fetchers::dumpRegisterInputSchemeInfo();
+
+        {
+            auto & fetchers = res["fetchers"] = json::object();
+
+            for (const auto & [schemeName, scheme] : fetchers::getAllInputSchemes()) {
+                auto & s = fetchers[schemeName] = json::object();
+                s["description"] = scheme->schemeDescription();
+                auto & attrs = s["allowedAttrs"] = json::object();
+                for (auto & [fieldName, field] : scheme->allowedAttrs()) {
+                    auto & f = attrs[fieldName] = json::object();
+                    f["type"] = field.type;
+                    f["required"] = field.required;
+                    f["doc"] = stripIndentation(field.doc);
+                }
+            }
+        };

        return res.dump();
    }
@@ -440,7 +458,7 @@ void mainWrapped(int argc, char ** argv)
            if (!primOp->doc)
                continue;
            b["args"] = primOp->args;
-            b["doc"] = trim(stripIndentation(primOp->doc));
+            b["doc"] = trim(stripIndentation(*primOp->doc));
            if (primOp->experimentalFeature)
                b["experimental-feature"] = primOp->experimentalFeature;
            builtinsJson.emplace(state.symbols[builtin.name], std::move(b));
--- a/src/nix/profile.cc
+++ b/src/nix/profile.cc
@@ -711,7 +711,7 @@ struct CmdProfileUpgrade : virtual SourceExprCommand, MixDefaultProfile, MixProf
                    element.identifier());
                continue;
            }
-            if (element.source->originalRef.input.isLocked()) {
+            if (element.source->originalRef.input.isLocked(getEvalState()->fetchSettings)) {
                warn(
                    "Found package '%s', but it was added from a locked flake reference so it can't be upgraded!",
                    element.identifier());
@@ -740,7 +740,8 @@ struct CmdProfileUpgrade : virtual SourceExprCommand, MixDefaultProfile, MixProf
            assert(infop);
            auto & info = *infop;

-            if (info.flake.lockedRef.input.isLocked() && element.source->lockedRef == info.flake.lockedRef)
+            if (info.flake.lockedRef.input.isLocked(getEvalState()->fetchSettings)
+                && element.source->lockedRef == info.flake.lockedRef)
                continue;

            printInfo(
--- a/src/nix/registry.cc
+++ b/src/nix/registry.cc
@@ -190,8 +190,9 @@ struct CmdRegistryPin : RegistryCommand, EvalCommand
        auto ref = parseFlakeRef(fetchSettings, url);
        auto lockedRef = parseFlakeRef(fetchSettings, locked);
        registry->remove(ref.input);
-        auto resolved = lockedRef.resolve(store).input.getAccessor(store).second;
-        if (!resolved.isLocked())
+        auto resolvedInput = lockedRef.resolve(fetchSettings, store).input;
+        auto resolved = resolvedInput.getAccessor(fetchSettings, store).second;
+        if (!resolved.isLocked(fetchSettings))
            warn("flake '%s' is not locked", resolved.to_string());
        fetchers::Attrs extraAttrs;
        if (ref.subdir != "")
--- a/tests/functional/flakes/show.sh
+++ b/tests/functional/flakes/show.sh
@@ -107,3 +107,26 @@ in
 assert show_output.packages.${builtins.currentSystem}.default == { };
 true
 '
+
+
+# Test that nix keeps going even when packages.$SYSTEM contains not derivations
+cat >flake.nix <<EOF
+{
+  outputs = inputs: {
+    packages.$system = {
+      drv1 = import ./simple.nix;
+      not-a-derivation = 42;
+      drv2 = import ./simple.nix;
+    };
+  };
+}
+EOF
+nix flake show --json --all-systems > show-output.json
+# shellcheck disable=SC2016
+nix eval --impure --expr '
+let show_output = builtins.fromJSON (builtins.readFile ./show-output.json);
+in
+assert show_output.packages.${builtins.currentSystem}.not-a-derivation == {};
+true
+'
+
Author	SHA1	Message	Date
John Ericson	adcbf3e19a	WIP strip strings at compile time	2025-11-17 14:32:33 -05:00
John Ericson	bae1ca257a	Systematize `builtins.fetchTree` docs And also render the docs nicely. I would like to use a markdown AST for this, but to avoid new deps (lowdown's AST doesn't suffice) I am just doing crude string manipulations for now.	2025-11-17 13:10:03 -05:00
John Ericson	2cc0b1b404	Introduce `quoteString` utility function	2025-11-17 12:33:26 -05:00
John Ericson	5446d6345f	Merge pull request #14576 from corngood/cygwin-tests Fix/disable tests on cygwin	2025-11-17 04:22:10 +00:00
David McFarland	b115c90043	Disable MonitorFdHup test on cygwin	2025-11-16 23:33:28 -04:00
David McFarland	13b896a188	Disable toString/ToStringPrimOpTest.toString/10 on cygwin	2025-11-16 23:32:29 -04:00
Sergei Zimmerman	5462c5eedd	Merge pull request #8871 from teto/flake_show_attr nix flake show: name attribute that must be a derivation	2025-11-16 19:48:15 +00:00
John Ericson	aec59a973a	Merge pull request #14573 from corngood/libexpr-leak nix_api_expr: ensure destructors are called for builder/state	2025-11-16 04:28:08 +00:00
Matthieu Coudron	653d701300	Merge branch 'master' into flake_show_attr	2025-11-15 23:30:42 +01:00
David McFarland	8d881ee3a3	nix_api_expr: ensure destructors are called for builder/state I found this because of a test failure on cygwin in nix_api_expr_test.nix_eval_state_lookup_path: 'std::filesystem::__cxx11::filesystem_error' what(): filesystem error: cannot remove all: Device or resource busy [...] [.../my_state/db/db.sqlite] LocalState was never getting destroyed due to a reference leak. These _free functions use an 'operator delete' which doesn't call the destructor for the type. Fixes: `309d55807c`	2025-11-15 15:39:39 -04:00
David McFarland	2872c8ede0	Fix leaks in nix_api_store_test.nix_eval_state_lookup_path	2025-11-15 15:38:39 -04:00
David McFarland	57f526ecda	Fix nix_api_store_test.nix_eval_state_lookup_path when run on its own Currently, --gtest_filter=nix_api_store_test.nix_eval_state_lookup_path will result in: terminating due to unexpected unrecoverable internal error: Assertion 'gcInitialised' failed in void nix::assertGCInitialized() at ../src/libexpr/eval-gc.cc:138 Changing the test fixture to _exr_test causes GC to be initialised.	2025-11-15 15:36:49 -04:00
John Ericson	1f2a994fb9	Merge pull request #14568 from NixOS/proper-range-canon-path libutil: Make CanonPath a proper range	2025-11-15 17:09:13 +00:00
Sergei Zimmerman	0e81a35881	libutil: Make CanonPath a proper range This was we can use std::ranges algorithms on it. Requires making the iterator a proper forward iterator type as well.	2025-11-14 22:45:20 +03:00
John Ericson	94c3bb3e4c	Merge pull request #14562 from NixOS/no-races-posix-source-accessor libutil: Make PosixSourceAccessor update mtime only when needed	2025-11-14 04:48:41 +00:00
John Ericson	30dbc7ee0c	Merge pull request #14563 from NixOS/dead-variable libstore: Remove dead PosixSourceAccessor variable in verifyStore	2025-11-14 04:42:38 +00:00
Sergei Zimmerman	19ab65c9d7	libstore: Remove dead PosixSourceAccessor variable in verifyStore	2025-11-14 04:18:53 +03:00
John Ericson	805496657d	Merge pull request #14550 from roberth/fetchers-settings-arg Remove setting from Input	2025-11-13 22:59:27 +00:00
Sergei Zimmerman	e95503cf9a	libutil: Make PosixSourceAccessor update mtime only when needed Typically PosixSourceAccessor can be used from multiple threads, but mtime is not updated atomically (i.e. with compare_exchange_weak), so mtime gets raced. It's only needed in dumpPathAndGetMtime and mtime tracking can be gated behind that. Also start using getLastModified interface instead of dynamic casts.	2025-11-13 23:54:14 +03:00
Eelco Dolstra	1bcbe652fb	Merge pull request #14537 from NixOS/dependabot/github_actions/cachix/install-nix-action-31.8.3 build(deps): bump cachix/install-nix-action from 31.8.2 to 31.8.3	2025-11-13 17:13:59 +00:00
Robert Hensing	292bd390af	Remove setting from Input This is more straightforward and not subject to undocumented memory safety restrictions. Also easier to test.	2025-11-12 23:42:09 +01:00
dependabot[bot]	2150d7a754	build(deps): bump cachix/install-nix-action from 31.8.2 to 31.8.3 Bumps [cachix/install-nix-action](https://github.com/cachix/install-nix-action) from 31.8.2 to 31.8.3. - [Release notes](https://github.com/cachix/install-nix-action/releases) - [Changelog](https://github.com/cachix/install-nix-action/blob/master/RELEASE.md) - [Commits](`456688f15b...7ec16f2c06`) --- updated-dependencies: - dependency-name: cachix/install-nix-action dependency-version: 31.8.3 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2025-11-10 22:00:54 +00:00
Matthieu Coudron	ac9d2a5b06	nix flake show: log attribute name that "must be a derivation" I would run `nix flake show` on a flake than hit: === ├───ihaskell: package 'ihaskell-wrapper' ├───ihaskell-96: package 'ihaskell-wrapper' ├───ihaskell-96-dev: package 'ghc-shell-for-ihaskell-0.10.4.0' error: expected a derivation === and it is not obvious what package is the culprit here since nix stops rightaway. Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>	2025-11-08 13:30:57 +01:00