get-env.sh: Version the JSON output

.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@7ec16f2c061ab07b235a7245e06ed46fe9a1cab6 # v31.8.3
+    - uses: cachix/install-nix-action@456688f15bc354bef6d396e4a35f4f89d40bf2b7 # v31.8.2
       if: ${{ !matrix.experimental-installer }}
       with:
         install_url: ${{ format('{0}/install', steps.installer-tarball-url.outputs.installer-url) }}

doc/manual/package.nix

@@ -58,8 +58,8 @@ mkMesonDerivation (finalAttrs: {
     "man"
   ];
 
-  nativeBuildInputs = [
-    nix-cli
+  # Hack for sake of the dev shell
+  passthru.externalNativeBuildInputs = [
     meson
     ninja
     (lib.getBin lowdown-unsandboxed)
@@ -78,6 +78,10 @@ mkMesonDerivation (finalAttrs: {
     changelog-d
   ];
 
+  nativeBuildInputs = finalAttrs.passthru.externalNativeBuildInputs ++ [
+    nix-cli
+  ];
+
   preConfigure = ''
     chmod u+w ./.version
     echo ${finalAttrs.version} > ./.version

doc/manual/rl-next/s3-storage-class.md

@@ -1,21 +0,0 @@
----
-synopsis: "S3 binary cache stores now support storage class configuration"
-prs: [14464]
-issues: [7015]
----
-
-S3 binary cache stores now support configuring the storage class for uploaded objects via the `storage-class` parameter. This allows users to optimize costs by selecting appropriate storage tiers based on access patterns.
-
-Example usage:
-
-```bash
-# Use Glacier storage for long-term archival
-nix copy --to 's3://my-bucket?storage-class=GLACIER' /nix/store/...
-
-# Use Intelligent Tiering for automatic cost optimization
-nix copy --to 's3://my-bucket?storage-class=INTELLIGENT_TIERING' /nix/store/...
-```
-
-The storage class applies to both regular uploads and multipart uploads. When not specified, objects use the bucket's default storage class.
-
-See the [S3 storage classes documentation](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) for available storage classes and their characteristics.

doc/manual/source/SUMMARY.md.in

@@ -29,7 +29,6 @@
   - [Build Trace](store/build-trace.md)
   - [Derivation Resolution](store/resolution.md)
   - [Building](store/building.md)
-  - [Secrets](store/secrets.md)
   - [Store Types](store/types/index.md)
 {{#include ./store/types/SUMMARY.md}}
   - [Appendix: Math notation](store/math-notation.md)

doc/manual/source/protocols/nix-archive/index.md

@@ -24,7 +24,7 @@ nar-obj-inner
   | str("type"), str("directory") directory
   ;
 
-regular = [ str("executable"), str("") ], str("contents"), str(contents);
+regular = [ str("executable") ], str("contents"), str(contents);
 
 symlink = str("target"), str(target);
 
@@ -52,4 +52,4 @@ The Nix Archive (NAR) format is also formally described using [Kaitai Struct](ht
 {{#include nar.ksy}}
 ```
 
-The source of the spec can be found [here](https://github.com/nixos/nix/blob/master/src/nix-manual/source/protocols/nix-archive/nar.ksy). Contributions and improvements to the spec are welcomed.
+The source of the spec can be found [here](https://github.com/nixos/nix/blob/master/src/nix-manual/source/protocols/nix-archive/nar.ksy). Contributions and improvements to the spec are welcomed.

doc/manual/source/store/secrets.md

@@ -1,20 +0,0 @@
-# Secrets
-
-The store is readable to all users on the system. For this reason, it
-is generally discouraged to allow secrets to make it into the store.
-
-Even on a single-user system, separate system users isolate services
-from each other and having secrets that all local users can read
-weakens that isolation. When using external store caches the secrets
-may end up there, and on multi-user systems the secrets will be
-available to all those users.
-
-Organize your derivations so that secrets are read from the filesystem
-(with appropriate access controls) at run time. Place the secrets on
-the filesystem manually or use a scheme that includes the secret in
-the store in encrypted form, and decrypts it adding the relevant
-access control on system activation.
-Several such schemes for NixOS can in the
-[comparison of secret managing schemes] on the wiki.
-
-[comparison of secret managing schemes]: https://wiki.nixos.org/wiki/Comparison_of_secret_managing_schemes

meson.build

@@ -60,9 +60,4 @@ if get_option('unit-tests')
   subproject('libflake-tests')
 endif
 subproject('nix-functional-tests')
-if get_option('json-schema-checks')
-  subproject('json-schema-checks')
-endif
-if get_option('kaitai-struct-checks')
-  subproject('kaitai-struct-checks')
-endif
+subproject('json-schema-checks')

meson.options

@@ -27,17 +27,3 @@ option(
   value : false,
   description : 'Build benchmarks (requires gbenchmark)',
 )
-
-option(
-  'kaitai-struct-checks',
-  type : 'boolean',
-  value : true,
-  description : 'Check the Kaitai Struct specifications (requires Kaitai Struct)',
-)
-
-option(
-  'json-schema-checks',
-  type : 'boolean',
-  value : true,
-  description : 'Check JSON schema validity of schemas and examples (requires jv)',
-)

packaging/dev-shell.nix

@@ -3,118 +3,10 @@
   devFlake,
 }:
 
-let
-  # Some helper functions
-
-  /**
-    Compute a filtered closure of build inputs.
-
-    Specifically, `buildInputsClosure cond startSet` computes the closure formed
-    by recursive application of `p: filter cond p.buildInputs ++ filter cond p.propagatedBuildInputs`
-    to `startSet`.
-
-    Example:
-    ```nix
-    builtInputsClosure isInternal [ pkg1 pkg2 ]
-    => [ pkg1 pkg3 pkg2 pkg10 ]
-    ```
-
-    Note: order tbd
-
-    Note: `startSet` is *NOT* filtered.
-  */
-  buildInputsClosureCond =
-    cond: startSet:
-    let
-      closure = builtins.genericClosure {
-        startSet = map (d: {
-          key = d.drvPath;
-          value = d;
-        }) startSet;
-        operator =
-          d:
-          let
-            r =
-              map
-                (d': {
-                  key = d'.drvPath;
-                  value = d';
-                })
-                (
-                  lib.filter cond d.value.buildInputs or [ ] ++ lib.filter cond d.value.propagatedBuildInputs or [ ]
-                );
-          in
-          r;
-      };
-    in
-    map (item: item.value) closure;
-
-  /**
-    `[ pkg1 pkg2 ]` -> `{ "...-pkg2.drv" = null; "...-pkg1.drv" = null }`
-
-    Note: fairly arbitrary order (hash based). Use for efficient set membership test only.
-  */
-  byDrvPath =
-    l:
-    lib.listToAttrs (
-      map (c: {
-        name =
-          # Just a lookup key
-          builtins.unsafeDiscardStringContext c.drvPath;
-        value = null;
-      }) l
-    );
-
-  /**
-    Stable dedup.
-
-    Unlike `listToAttrs` -> `attrValues`, this preserves the input ordering,
-    which is more predictable ("deterministic") than e.g. sorting store paths,
-    whose hashes affect the ordering on every change.
-  */
-  # TODO: add to Nixpkgs lib, refer from uniqueStrings
-  dedupByString =
-    key: l:
-    let
-      r =
-        lib.foldl'
-          (
-            a@{ list, set }:
-            elem:
-            let
-              k = builtins.unsafeDiscardStringContext (key elem);
-            in
-            if set ? ${k} then
-              a
-            else
-              let
-                # Note: O(n²) copying. Use linkedLists to concat them in one go at the end.
-                # https://github.com/NixOS/nixpkgs/pull/452088
-                newList = [ elem ] ++ list;
-                newSet = set // {
-                  ${k} = null;
-                };
-              in
-              builtins.seq newList builtins.seq newSet {
-                list = newList;
-                set = newSet;
-              }
-          )
-          {
-            list = [ ];
-            set = { };
-          }
-          l;
-    in
-    r.list;
-
-in
-
 { pkgs }:
 
-# TODO: don't use nix-util for this?
 pkgs.nixComponents2.nix-util.overrideAttrs (
-  finalAttrs: prevAttrs:
+  attrs:
 
   let
     stdenv = pkgs.nixDependencies2.stdenv;
@@ -129,89 +21,13 @@ pkgs.nixComponents2.nix-util.overrideAttrs (
       "-D${prefix}:${rest}";
     havePerl = stdenv.buildPlatform == stdenv.hostPlatform && stdenv.hostPlatform.isUnix;
     ignoreCrossFile = flags: builtins.filter (flag: !(lib.strings.hasInfix "cross-file" flag)) flags;
-
-    activeComponents = buildInputsClosureCond isInternal (
-      lib.attrValues (finalAttrs.passthru.config.getComponents allComponents)
-    );
-
-    allComponents = lib.filterAttrs (k: v: lib.isDerivation v) pkgs.nixComponents2;
-    internalDrvs = byDrvPath (
-      # Drop the attr names (not present in buildInputs anyway)
-      lib.attrValues allComponents
-      ++ lib.concatMap (c: lib.attrValues c.tests or { }) (lib.attrValues allComponents)
-    );
-
-    isInternal =
-      dep: internalDrvs ? ${builtins.unsafeDiscardStringContext dep.drvPath or "_non-existent_"};
-
   in
   {
-    pname = "shell-for-nix";
-
-    passthru = {
-      inherit activeComponents;
-
-      # We use this attribute to store non-derivation values like functions and
-      # perhaps other things that are primarily for overriding and not the shell.
-      config = {
-        # Default getComponents
-        getComponents =
-          c:
-          builtins.removeAttrs c (
-            lib.optionals (!havePerl) [ "nix-perl-bindings" ]
-            ++ lib.optionals (!buildCanExecuteHost) [ "nix-manual" ]
-          );
-      };
-
-      /**
-        Produce a devShell for a given set of nix components
-
-        Example:
-
-        ```nix
-        shell.withActiveComponents (c: {
-          inherit (c) nix-util;
-        })
-        ```
-      */
-      withActiveComponents =
-        f2:
-        finalAttrs.finalPackage.overrideAttrs (
-          finalAttrs: prevAttrs: {
-            passthru = prevAttrs.passthru // {
-              config = prevAttrs.passthru.config // {
-                getComponents = f2;
-              };
-            };
-          }
-        );
-
-      small =
-        (finalAttrs.finalPackage.withActiveComponents (c: {
-          inherit (c)
-            nix-cli
-            nix-util-tests
-            nix-store-tests
-            nix-expr-tests
-            nix-fetchers-tests
-            nix-flake-tests
-            nix-functional-tests
-            # Currently required
-            nix-perl-bindings
-            ;
-        })).overrideAttrs
-          (o: {
-            mesonFlags = o.mesonFlags ++ [
-              # TODO: infer from activeComponents or vice versa
-              "-Dkaitai-struct-checks=false"
-              "-Djson-schema-checks=false"
-            ];
-          });
-    };
+    pname = "shell-for-" + attrs.pname;
 
     # Remove the version suffix to avoid unnecessary attempts to substitute in nix develop
     version = lib.fileContents ../.version;
-    name = finalAttrs.pname;
+    name = attrs.pname;
 
     installFlags = "sysconfdir=$(out)/etc";
     shellHook = ''
@@ -282,9 +98,17 @@ pkgs.nixComponents2.nix-util.overrideAttrs (
     nativeBuildInputs =
       let
         inputs =
-          dedupByString (v: "${v}") (
-            lib.filter (x: !isInternal x) (lib.lists.concatMap (c: c.nativeBuildInputs) activeComponents)
-          )
+          attrs.nativeBuildInputs or [ ]
+          ++ pkgs.nixComponents2.nix-util.nativeBuildInputs
+          ++ pkgs.nixComponents2.nix-store.nativeBuildInputs
+          ++ pkgs.nixComponents2.nix-fetchers.nativeBuildInputs
+          ++ pkgs.nixComponents2.nix-expr.nativeBuildInputs
+          ++ lib.optionals havePerl pkgs.nixComponents2.nix-perl-bindings.nativeBuildInputs
+          ++ lib.optionals buildCanExecuteHost pkgs.nixComponents2.nix-manual.externalNativeBuildInputs
+          ++ pkgs.nixComponents2.nix-internal-api-docs.nativeBuildInputs
+          ++ pkgs.nixComponents2.nix-external-api-docs.nativeBuildInputs
+          ++ pkgs.nixComponents2.nix-functional-tests.externalNativeBuildInputs
+          ++ pkgs.nixComponents2.nix-json-schema-checks.externalNativeBuildInputs
           ++ lib.optional (
             !buildCanExecuteHost
             # Hack around https://github.com/nixos/nixpkgs/commit/bf7ad8cfbfa102a90463433e2c5027573b462479
@@ -293,7 +117,9 @@ pkgs.nixComponents2.nix-util.overrideAttrs (
             && lib.meta.availableOn stdenv.buildPlatform (stdenv.hostPlatform.emulator pkgs.buildPackages)
           ) pkgs.buildPackages.mesonEmulatorHook
           ++ [
+            pkgs.buildPackages.cmake
             pkgs.buildPackages.gnused
+            pkgs.buildPackages.changelog-d
             modular.pre-commit.settings.package
             (pkgs.writeScriptBin "pre-commit-hooks-install" modular.pre-commit.settings.installationScript)
             pkgs.buildPackages.nixfmt-rfc-style
@@ -310,22 +136,18 @@ pkgs.nixComponents2.nix-util.overrideAttrs (
       # from making its way into NIX_CFLAGS_COMPILE.
       lib.filter (p: !lib.hasInfix "separate-debug-info" p) inputs;
 
-    propagatedNativeBuildInputs = dedupByString (v: "${v}") (
-      lib.filter (x: !isInternal x) (
-        lib.lists.concatMap (c: c.propagatedNativeBuildInputs) activeComponents
-      )
-    );
-
     buildInputs = [
       pkgs.gbenchmark
     ]
-    ++ dedupByString (v: "${v}") (
-      lib.filter (x: !isInternal x) (lib.lists.concatMap (c: c.buildInputs) activeComponents)
-    )
+    ++ attrs.buildInputs or [ ]
+    ++ pkgs.nixComponents2.nix-util.buildInputs
+    ++ pkgs.nixComponents2.nix-store.buildInputs
+    ++ pkgs.nixComponents2.nix-store-tests.externalBuildInputs
+    ++ pkgs.nixComponents2.nix-fetchers.buildInputs
+    ++ pkgs.nixComponents2.nix-expr.buildInputs
+    ++ pkgs.nixComponents2.nix-expr.externalPropagatedBuildInputs
+    ++ pkgs.nixComponents2.nix-cmd.buildInputs
+    ++ lib.optionals havePerl pkgs.nixComponents2.nix-perl-bindings.externalBuildInputs
     ++ lib.optional havePerl pkgs.perl;
-
-    propagatedBuildInputs = dedupByString (v: "${v}") (
-      lib.filter (x: !isInternal x) (lib.lists.concatMap (c: c.propagatedBuildInputs) activeComponents)
-    );
   }
 )

src/json-schema-checks/package.nix

@@ -34,11 +34,15 @@ mkMesonDerivation (finalAttrs: {
 
   outputs = [ "out" ];
 
+  passthru.externalNativeBuildInputs = [
+    jsonschema
+  ];
+
   nativeBuildInputs = [
     meson
     ninja
-    jsonschema
-  ];
+  ]
+  ++ finalAttrs.passthru.externalNativeBuildInputs;
 
   doCheck = true;
 

src/kaitai-struct-checks/package.nix

@@ -37,15 +37,7 @@ mkMesonDerivation (finalAttrs: {
 
   outputs = [ "out" ];
 
-  buildInputs = [
-    gtest
-    kaitai-struct-cpp-stl-runtime
-  ];
-
-  nativeBuildInputs = [
-    meson
-    ninja
-    pkg-config
+  passthru.externalNativeBuildInputs = [
     # This can go away when we bump up to 25.11
     (kaitai-struct-compiler.overrideAttrs (finalAttrs: {
       version = "0.11";
@@ -56,6 +48,20 @@ mkMesonDerivation (finalAttrs: {
     }))
   ];
 
+  passthru.externalBuildInputs = [
+    gtest
+    kaitai-struct-cpp-stl-runtime
+  ];
+
+  buildInputs = finalAttrs.passthru.externalBuildInputs;
+
+  nativeBuildInputs = [
+    meson
+    ninja
+    pkg-config
+  ]
+  ++ finalAttrs.passthru.externalNativeBuildInputs;
+
   doCheck = true;
 
   mesonCheckFlags = [ "--print-errorlogs" ];

src/libcmd/command.cc

@@ -2,7 +2,6 @@
 #include <nlohmann/json.hpp>
 
 #include "nix/cmd/command.hh"
-#include "nix/cmd/legacy.hh"
 #include "nix/cmd/markdown.hh"
 #include "nix/store/store-open.hh"
 #include "nix/store/local-fs-store.hh"
@@ -15,18 +14,6 @@
 
 namespace nix {
 
-RegisterCommand::Commands & RegisterCommand::commands()
-{
-    static RegisterCommand::Commands commands;
-    return commands;
-}
-
-RegisterLegacyCommand::Commands & RegisterLegacyCommand::commands()
-{
-    static RegisterLegacyCommand::Commands commands;
-    return commands;
-}
-
 nix::Commands RegisterCommand::getCommandsFor(const std::vector<std::string> & prefix)
 {
     nix::Commands res;

src/libcmd/common-eval-args.cc

@@ -33,8 +33,7 @@ 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(fetchSettings, state.store).lazyFetch(fetchSettings, state.store);
+                auto [accessor, lockedRef] = flakeRef.resolve(state.store).lazyFetch(state.store);
                 auto storePath = nix::fetchToStore(
                     state.fetchSettings,
                     *state.store,
@@ -132,7 +131,7 @@ MixEvalArgs::MixEvalArgs()
             fetchers::Attrs extraAttrs;
             if (to.subdir != "")
                 extraAttrs["dir"] = to.subdir;
-            fetchers::overrideRegistry(fetchSettings, from.input, to.input, extraAttrs);
+            fetchers::overrideRegistry(from.input, to.input, extraAttrs);
         }},
         .completer = {[&](AddCompletions & completions, size_t, std::string_view prefix) {
             completeFlakeRef(completions, openStore(), prefix);
@@ -188,7 +187,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(fetchSettings, state.store).lazyFetch(fetchSettings, state.store);
+        auto [accessor, lockedRef] = flakeRef.resolve(state.store).lazyFetch(state.store);
         auto storePath = nix::fetchToStore(
             state.fetchSettings, *state.store, SourcePath(accessor), FetchMode::Copy, lockedRef.input.getName());
         state.allowPath(storePath);

src/libcmd/include/nix/cmd/command.hh

@@ -286,7 +286,11 @@ struct RegisterCommand
 {
     typedef std::map<std::vector<std::string>, std::function<ref<Command>()>> Commands;
 
-    static Commands & commands();
+    static Commands & commands()
+    {
+        static Commands commands;
+        return commands;
+    }
 
     RegisterCommand(std::vector<std::string> && name, std::function<ref<Command>()> command)
     {

src/libcmd/include/nix/cmd/legacy.hh

@@ -13,7 +13,11 @@ struct RegisterLegacyCommand
 {
     typedef std::map<std::string, MainFunction> Commands;
 
-    static Commands & commands();
+    static Commands & commands()
+    {
+        static Commands commands;
+        return commands;
+    }
 
     RegisterLegacyCommand(const std::string & name, MainFunction fun)
     {

src/libcmd/installables.cc

@@ -185,7 +185,6 @@ MixFlakeOptions::MixFlakeOptions()
                     }
 
                     overrideRegistry(
-                        fetchSettings,
                         fetchers::Input::fromAttrs(fetchSettings, {{"type", "indirect"}, {"id", inputName}}),
                         input3->lockedRef.input,
                         extraAttrs);

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(fetchSettings))
+    if (evalSettings.pureEval && !flakeRef.input.isLocked())
         throw Error("cannot use ':load-flake' on locked flake reference '%s' (use --impure to override)", flakeRefS);
 
     Value v;

src/libexpr-c/nix_api_expr.cc

@@ -137,8 +137,6 @@ 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)));
 }
 
@@ -205,8 +203,6 @@ 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)));
 }
 

src/libexpr-tests/nix_api_expr.cc

@@ -14,7 +14,7 @@
 
 namespace nixC {
 
-TEST_F(nix_api_expr_test, nix_eval_state_lookup_path)
+TEST_F(nix_api_store_test, nix_eval_state_lookup_path)
 {
     auto tmpDir = nix::createTempDir();
     auto delTmpDir = std::make_unique<nix::AutoDelete>(tmpDir, true);
@@ -42,16 +42,12 @@ TEST_F(nix_api_expr_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)

src/libexpr-tests/primops.cc

@@ -661,14 +661,8 @@ 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")
-// this is broken on cygwin because canonPath("//./test", false) returns //./test
-// FIXME: don't use canonPath
-#ifndef __CYGWIN__
-            ,
-        CASE(R"(./test)", "/test")
-#endif
-            ));
+        CASE(R"({ outPath = "foo"; })", "foo"),
+        CASE(R"(./test)", "/test")));
 #undef CASE
 
 TEST_F(PrimOpTest, substring)

src/libexpr/eval.cc

@@ -517,16 +517,15 @@ Value * EvalState::addPrimOp(PrimOp && primOp)
     if (primOp.arity == 0) {
         primOp.arity = 1;
         auto vPrimOp = allocValue();
-        vPrimOp->mkPrimOp(new PrimOp(std::move(primOp)));
+        vPrimOp->mkPrimOp(new PrimOp(primOp));
         Value v;
         v.mkApp(vPrimOp, vPrimOp);
-        auto & primOp1 = *vPrimOp->primOp();
         return addConstant(
-            primOp1.name,
+            primOp.name,
             v,
             {
                 .type = nThunk, // FIXME
-                .doc = primOp1.doc ? primOp1.doc->c_str() : nullptr,
+                .doc = primOp.doc,
             });
     }
 
@@ -566,14 +565,13 @@ std::optional<EvalState::Doc> EvalState::getDoc(Value & v)
 {
     if (v.isPrimOp()) {
         auto v2 = &v;
-        auto & primOp = *v2->primOp();
-        if (primOp.doc)
+        if (auto * doc = v2->primOp()->doc)
             return Doc{
                 .pos = {},
-                .name = primOp.name,
-                .arity = primOp.arity,
-                .args = primOp.args,
-                .doc = primOp.doc->c_str(),
+                .name = v2->primOp()->name,
+                .arity = v2->primOp()->arity,
+                .args = v2->primOp()->args,
+                .doc = doc,
             };
     }
     if (v.isLambda()) {
@@ -854,26 +852,25 @@ void Value::mkString(std::string_view s)
     mkStringNoCopy(StringData::make(s));
 }
 
-Value::StringWithContext::Context *
-Value::StringWithContext::Context::fromBuilder(const NixStringContext & context, EvalMemory & mem)
+Value::StringWithContext::Context * Value::StringWithContext::Context::fromBuilder(const NixStringContext & context)
 {
     if (context.empty())
         return nullptr;
 
-    auto ctx = new (mem.allocBytes(sizeof(Context) + context.size() * sizeof(value_type))) Context(context.size());
+    auto ctx = new (allocBytes(sizeof(Context) + context.size() * sizeof(value_type))) Context(context.size());
     std::ranges::transform(
         context, ctx->elems, [](const NixStringContextElem & elt) { return &StringData::make(elt.to_string()); });
     return ctx;
 }
 
-void Value::mkString(std::string_view s, const NixStringContext & context, EvalMemory & mem)
+void Value::mkString(std::string_view s, const NixStringContext & context)
 {
-    mkStringNoCopy(StringData::make(s), Value::StringWithContext::Context::fromBuilder(context, mem));
+    mkStringNoCopy(StringData::make(s), Value::StringWithContext::Context::fromBuilder(context));
 }
 
-void Value::mkStringMove(const StringData & s, const NixStringContext & context, EvalMemory & mem)
+void Value::mkStringMove(const StringData & s, const NixStringContext & context)
 {
-    mkStringNoCopy(s, Value::StringWithContext::Context::fromBuilder(context, mem));
+    mkStringNoCopy(s, Value::StringWithContext::Context::fromBuilder(context));
 }
 
 void Value::mkPath(const SourcePath & path)
@@ -914,9 +911,9 @@ inline Value * EvalState::lookupVar(Env * env, const ExprVar & var, bool noEval)
     }
 }
 
-ListBuilder::ListBuilder(EvalMemory & mem, size_t size)
+ListBuilder::ListBuilder(size_t size)
     : size(size)
-    , elems(size <= 2 ? inlineElems : (Value **) mem.allocBytes(size * sizeof(Value *)))
+    , elems(size <= 2 ? inlineElems : (Value **) allocBytes(size * sizeof(Value *)))
 {
 }
 
@@ -956,8 +953,7 @@ void EvalState::mkStorePathString(const StorePath & p, Value & v)
         store->printStorePath(p),
         NixStringContext{
             NixStringContextElem::Opaque{.path = p},
-        },
-        mem);
+        });
 }
 
 std::string EvalState::mkOutputStringRaw(
@@ -979,7 +975,7 @@ void EvalState::mkOutputString(
     std::optional<StorePath> optStaticOutputPath,
     const ExperimentalFeatureSettings & xpSettings)
 {
-    value.mkString(mkOutputStringRaw(b, optStaticOutputPath, xpSettings), NixStringContext{b}, mem);
+    value.mkString(mkOutputStringRaw(b, optStaticOutputPath, xpSettings), NixStringContext{b});
 }
 
 std::string EvalState::mkSingleDerivedPathStringRaw(const SingleDerivedPath & p)
@@ -1014,8 +1010,7 @@ void EvalState::mkSingleDerivedPathString(const SingleDerivedPath & p, Value & v
         mkSingleDerivedPathStringRaw(p),
         NixStringContext{
             std::visit([](auto && v) -> NixStringContextElem { return v; }, p),
-        },
-        mem);
+        });
 }
 
 Value * Expr::maybeThunk(EvalState & state, Env & env)
@@ -2148,7 +2143,7 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
             tmp += part->size();
         }
         *tmp = '\0';
-        v.mkStringMove(resultStr, context, state.mem);
+        v.mkStringMove(resultStr, context);
     }
 }
 
@@ -2345,7 +2340,7 @@ std::string_view EvalState::forceStringNoCtx(Value & v, const PosIdx pos, std::s
         error<EvalError>(
             "the string '%1%' is not allowed to refer to a store path (such as '%2%')",
             v.string_view(),
-            (*v.context()->begin())->view())
+            *v.context()->begin())
             .withTrace(pos, errorCtx)
             .debugThrow();
     }

src/libexpr/include/nix/expr/eval-inline.hh

@@ -12,7 +12,7 @@ namespace nix {
  * Note: Various places expect the allocated memory to be zeroed.
  */
 [[gnu::always_inline]]
-inline void * EvalMemory::allocBytes(size_t n)
+inline void * allocBytes(size_t n)
 {
     void * p;
 #if NIX_USE_BOEHMGC

src/libexpr/include/nix/expr/eval.hh

@@ -108,7 +108,7 @@ struct PrimOp
     /**
      * Optional free-form documentation about the primop.
      */
-    std::optional<std::string> doc;
+    const char * doc = nullptr;
 
     /**
      * Add a trace item, while calling the `<name>` builtin.
@@ -335,7 +335,6 @@ public:
     EvalMemory & operator=(const EvalMemory &) = delete;
     EvalMemory & operator=(EvalMemory &&) = delete;
 
-    inline void * allocBytes(size_t n);
     inline Value * allocValue();
     inline Env & allocEnv(size_t size);
 
@@ -349,7 +348,7 @@ public:
     ListBuilder buildList(size_t size)
     {
         stats.nrListElems += size;
-        return ListBuilder(*this, size);
+        return ListBuilder(size);
     }
 
     const Statistics & getStats() const &

src/libexpr/include/nix/expr/nixexpr.hh

@@ -339,7 +339,7 @@ struct ExprOpHasAttr : Expr
     Expr * e;
     std::span<AttrName> attrPath;
 
-    ExprOpHasAttr(std::pmr::polymorphic_allocator<char> & alloc, Expr * e, std::span<AttrName> attrPath)
+    ExprOpHasAttr(std::pmr::polymorphic_allocator<char> & alloc, Expr * e, std::vector<AttrName> attrPath)
         : e(e)
         , attrPath({alloc.allocate_object<AttrName>(attrPath.size()), attrPath.size()})
     {
@@ -433,7 +433,7 @@ struct ExprList : Expr
 {
     std::span<Expr *> elems;
 
-    ExprList(std::pmr::polymorphic_allocator<char> & alloc, std::span<Expr *> exprs)
+    ExprList(std::pmr::polymorphic_allocator<char> & alloc, std::vector<Expr *> exprs)
         : elems({alloc.allocate_object<Expr *>(exprs.size()), exprs.size()})
     {
         std::ranges::copy(exprs, elems.begin());
@@ -562,7 +562,7 @@ public:
         const PosTable & positions,
         std::pmr::polymorphic_allocator<char> & alloc,
         PosIdx pos,
-        const FormalsBuilder & formals,
+        FormalsBuilder formals,
         Expr * body)
         : ExprLambda(positions, alloc, pos, Symbol(), formals, body) {};
 
@@ -753,19 +753,7 @@ struct ExprConcatStrings : Expr
         std::pmr::polymorphic_allocator<char> & alloc,
         const PosIdx & pos,
         bool forceString,
-        std::span<std::pair<PosIdx, Expr *>> es)
-        : pos(pos)
-        , forceString(forceString)
-        , es({alloc.allocate_object<std::pair<PosIdx, Expr *>>(es.size()), es.size()})
-    {
-        std::ranges::copy(es, this->es.begin());
-    };
-
-    ExprConcatStrings(
-        std::pmr::polymorphic_allocator<char> & alloc,
-        const PosIdx & pos,
-        bool forceString,
-        std::initializer_list<std::pair<PosIdx, Expr *>> es)
+        const std::vector<std::pair<PosIdx, Expr *>> & es)
         : pos(pos)
         , forceString(forceString)
         , es({alloc.allocate_object<std::pair<PosIdx, Expr *>>(es.size()), es.size()})
@@ -845,19 +833,7 @@ public:
     add(std::pmr::polymorphic_allocator<char> & alloc,
         const PosIdx & pos,
         bool forceString,
-        std::span<std::pair<PosIdx, Expr *>> es)
-        requires(std::same_as<C, ExprConcatStrings>)
-    {
-        return alloc.new_object<C>(alloc, pos, forceString, es);
-    }
-
-    template<class C>
-    [[gnu::always_inline]]
-    C *
-    add(std::pmr::polymorphic_allocator<char> & alloc,
-        const PosIdx & pos,
-        bool forceString,
-        std::initializer_list<std::pair<PosIdx, Expr *>> es)
+        const std::vector<std::pair<PosIdx, Expr *>> & es)
         requires(std::same_as<C, ExprConcatStrings>)
     {
         return alloc.new_object<C>(alloc, pos, forceString, es);

src/libexpr/include/nix/expr/parser-state.hh

@@ -96,7 +96,7 @@ struct ParserState
         ExprAttrs * attrs, AttrPath && attrPath, const ParserLocation & loc, Expr * e, const ParserLocation & exprLoc);
     void addAttr(ExprAttrs * attrs, AttrPath & attrPath, const Symbol & symbol, ExprAttrs::AttrDef && def);
     void validateFormals(FormalsBuilder & formals, PosIdx pos = noPos, Symbol arg = {});
-    Expr * stripIndentation(const PosIdx pos, std::span<std::pair<PosIdx, std::variant<Expr *, StringToken>>> es);
+    Expr * stripIndentation(const PosIdx pos, std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>> && es);
     PosIdx at(const ParserLocation & loc);
 };
 
@@ -239,7 +239,7 @@ inline void ParserState::validateFormals(FormalsBuilder & formals, PosIdx pos, S
 }
 
 inline Expr *
-ParserState::stripIndentation(const PosIdx pos, std::span<std::pair<PosIdx, std::variant<Expr *, StringToken>>> es)
+ParserState::stripIndentation(const PosIdx pos, std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>> && es)
 {
     if (es.empty())
         return exprs.add<ExprString>(""_sds);
@@ -343,7 +343,7 @@ ParserState::stripIndentation(const PosIdx pos, std::span<std::pair<PosIdx, std:
         auto * const result = (es2)[0].second;
         return result;
     }
-    return exprs.add<ExprConcatStrings>(exprs.alloc, pos, true, es2);
+    return exprs.add<ExprConcatStrings>(exprs.alloc, pos, true, std::move(es2));
 }
 
 inline PosIdx LexerState::at(const ParserLocation & loc)

src/libexpr/include/nix/expr/primops.hh

@@ -12,7 +12,11 @@ struct RegisterPrimOp
 {
     typedef std::vector<PrimOp> PrimOps;
 
-    static PrimOps & primOps();
+    static PrimOps & primOps()
+    {
+        static PrimOps primOps;
+        return primOps;
+    }
 
     /**
      * You can register a constant by passing an arity of 0. fun

src/libexpr/include/nix/expr/print-options.hh

@@ -110,7 +110,7 @@ struct PrintOptions
  * `PrintOptions` for unknown and therefore potentially large values in error messages,
  * to avoid printing "too much" output.
  */
-static constexpr PrintOptions errorPrintOptions = PrintOptions{
+static PrintOptions errorPrintOptions = PrintOptions{
     .ansiColors = true,
     .maxDepth = 10,
     .maxAttrs = 10,

src/libexpr/include/nix/expr/value.hh

@@ -88,7 +88,6 @@ class PosIdx;
 struct Pos;
 class StorePath;
 class EvalState;
-class EvalMemory;
 class XMLWriter;
 class Printer;
 
@@ -162,7 +161,7 @@ class ListBuilder
     Value * inlineElems[2] = {nullptr, nullptr};
 public:
     Value ** elems;
-    ListBuilder(EvalMemory & mem, size_t size);
+    ListBuilder(size_t size);
 
     // NOTE: Can be noexcept because we are just copying integral values and
     // raw pointers.
@@ -365,7 +364,7 @@ struct ValueBase
             /**
              * @return null pointer when context.empty()
              */
-            static Context * fromBuilder(const NixStringContext & context, EvalMemory & mem);
+            static Context * fromBuilder(const NixStringContext & context);
         };
 
         /**
@@ -1149,9 +1148,9 @@ public:
 
     void mkString(std::string_view s);
 
-    void mkString(std::string_view s, const NixStringContext & context, EvalMemory & mem);
+    void mkString(std::string_view s, const NixStringContext & context);
 
-    void mkStringMove(const StringData & s, const NixStringContext & context, EvalMemory & mem);
+    void mkStringMove(const StringData & s, const NixStringContext & context);
 
     void mkPath(const SourcePath & path);
 

src/libexpr/package.nix

@@ -70,6 +70,11 @@ mkMesonLibrary (finalAttrs: {
     nix-util
     nix-store
     nix-fetchers
+  ]
+  ++ finalAttrs.passthru.externalPropagatedBuildInputs;
+
+  # Hack for sake of the dev shell
+  passthru.externalPropagatedBuildInputs = [
     boost
     nlohmann_json
   ]

src/libexpr/parser.y

@@ -126,26 +126,26 @@ static Expr * makeCall(Exprs & exprs, PosIdx pos, Expr * fn, Expr * arg) {
 
 %define api.value.type variant
 
-%type <Expr *> start expr expr_function expr_if expr_op
-%type <Expr *> expr_select expr_simple expr_app
-%type <Expr *> expr_pipe_from expr_pipe_into
+%type <nix::Expr *> start expr expr_function expr_if expr_op
+%type <nix::Expr *> expr_select expr_simple expr_app
+%type <nix::Expr *> expr_pipe_from expr_pipe_into
 %type <std::vector<Expr *>> list
-%type <ExprAttrs *> binds binds1
-%type <FormalsBuilder> formals formal_set
-%type <Formal> formal
-%type <std::vector<AttrName>> attrpath
-%type <std::vector<std::pair<AttrName, PosIdx>>> attrs
-%type <std::vector<std::pair<PosIdx, Expr *>>> string_parts_interpolated
-%type <std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>>> ind_string_parts
-%type <Expr *> path_start
-%type <std::variant<Expr *, std::string_view>> string_parts string_attr
-%type <StringToken> attr
-%token <StringToken> ID
-%token <StringToken> STR IND_STR
-%token <NixInt> INT_LIT
-%token <NixFloat> FLOAT_LIT
-%token <StringToken> PATH HPATH SPATH PATH_END
-%token <StringToken> URI
+%type <nix::ExprAttrs *> binds binds1
+%type <nix::FormalsBuilder> formals formal_set
+%type <nix::Formal> formal
+%type <std::vector<nix::AttrName>> attrpath
+%type <std::vector<std::pair<nix::AttrName, nix::PosIdx>>> attrs
+%type <std::vector<std::pair<nix::PosIdx, nix::Expr *>>> string_parts_interpolated
+%type <std::vector<std::pair<nix::PosIdx, std::variant<nix::Expr *, nix::StringToken>>>> ind_string_parts
+%type <nix::Expr *> path_start
+%type <std::variant<nix::Expr *, std::string_view>> string_parts string_attr
+%type <nix::StringToken> attr
+%token <nix::StringToken> ID
+%token <nix::StringToken> STR IND_STR
+%token <nix::NixInt> INT_LIT
+%token <nix::NixFloat> FLOAT_LIT
+%token <nix::StringToken> PATH HPATH SPATH PATH_END
+%token <nix::StringToken> URI
 %token IF THEN ELSE ASSERT WITH LET IN_KW REC INHERIT EQ NEQ AND OR IMPL OR_KW
 %token PIPE_FROM PIPE_INTO /* <| and |> */
 %token DOLLAR_CURLY /* == ${ */
@@ -186,7 +186,7 @@ expr_function
   | formal_set ':' expr_function[body]
     {
       state->validateFormals($formal_set);
-      auto me = state->exprs.add<ExprLambda>(state->positions, state->exprs.alloc, CUR_POS, $formal_set, $body);
+      auto me = state->exprs.add<ExprLambda>(state->positions, state->exprs.alloc, CUR_POS, std::move($formal_set), $body);
       $$ = me;
       SET_DOC_POS(me, @1);
     }
@@ -194,7 +194,7 @@ expr_function
     {
       auto arg = state->symbols.create($ID);
       state->validateFormals($formal_set, CUR_POS, arg);
-      auto me = state->exprs.add<ExprLambda>(state->positions, state->exprs.alloc, CUR_POS, arg, $formal_set, $body);
+      auto me = state->exprs.add<ExprLambda>(state->positions, state->exprs.alloc, CUR_POS, arg, std::move($formal_set), $body);
       $$ = me;
       SET_DOC_POS(me, @1);
     }
@@ -202,7 +202,7 @@ expr_function
     {
       auto arg = state->symbols.create($ID);
       state->validateFormals($formal_set, CUR_POS, arg);
-      auto me = state->exprs.add<ExprLambda>(state->positions, state->exprs.alloc, CUR_POS, arg, $formal_set, $body);
+      auto me = state->exprs.add<ExprLambda>(state->positions, state->exprs.alloc, CUR_POS, arg, std::move($formal_set), $body);
       $$ = me;
       SET_DOC_POS(me, @1);
     }
@@ -251,7 +251,7 @@ expr_op
   | expr_op OR expr_op { $$ = state->exprs.add<ExprOpOr>(state->at(@2), $1, $3); }
   | expr_op IMPL expr_op { $$ = state->exprs.add<ExprOpImpl>(state->at(@2), $1, $3); }
   | expr_op UPDATE expr_op { $$ = state->exprs.add<ExprOpUpdate>(state->at(@2), $1, $3); }
-  | expr_op '?' attrpath { $$ = state->exprs.add<ExprOpHasAttr>(state->exprs.alloc, $1, $3); }
+  | expr_op '?' attrpath { $$ = state->exprs.add<ExprOpHasAttr>(state->exprs.alloc, $1, std::move($3)); }
   | expr_op '+' expr_op
     { $$ = state->exprs.add<ExprConcatStrings>(state->exprs.alloc, state->at(@2), false, {{state->at(@1), $1}, {state->at(@3), $3}}); }
   | expr_op '-' expr_op { $$ = state->exprs.add<ExprCall>(state->at(@2), state->exprs.add<ExprVar>(state->s.sub), {$1, $3}); }
@@ -272,9 +272,9 @@ expr_app
 
 expr_select
   : expr_simple '.' attrpath
-    { $$ = state->exprs.add<ExprSelect>(state->exprs.alloc, CUR_POS, $1, $3, nullptr); }
+    { $$ = state->exprs.add<ExprSelect>(state->exprs.alloc, CUR_POS, $1, std::move($3), nullptr); }
   | expr_simple '.' attrpath OR_KW expr_select
-    { $$ = state->exprs.add<ExprSelect>(state->exprs.alloc, CUR_POS, $1, $3, $5); $5->warnIfCursedOr(state->symbols, state->positions); }
+    { $$ = state->exprs.add<ExprSelect>(state->exprs.alloc, CUR_POS, $1, std::move($3), $5); $5->warnIfCursedOr(state->symbols, state->positions); }
   | /* Backwards compatibility: because Nixpkgs has a function named ‘or’,
        allow stuff like ‘map or [...]’. This production is problematic (see
        https://github.com/NixOS/nix/issues/11118) and will be refactored in the
@@ -304,12 +304,12 @@ expr_simple
       $2);
   }
   | IND_STRING_OPEN ind_string_parts IND_STRING_CLOSE {
-      $$ = state->stripIndentation(CUR_POS, $2);
+      $$ = state->stripIndentation(CUR_POS, std::move($2));
   }
   | path_start PATH_END
   | path_start string_parts_interpolated PATH_END {
       $2.insert($2.begin(), {state->at(@1), $1});
-      $$ = state->exprs.add<ExprConcatStrings>(state->exprs.alloc, CUR_POS, false, $2);
+      $$ = state->exprs.add<ExprConcatStrings>(state->exprs.alloc, CUR_POS, false, std::move($2));
   }
   | SPATH {
       std::string_view path($1.p + 1, $1.l - 2);
@@ -338,12 +338,12 @@ expr_simple
     { $2->pos = CUR_POS; $$ = $2; }
   | '{' '}'
     { $$ = state->exprs.add<ExprAttrs>(CUR_POS); }
-  | '[' list ']' { $$ = state->exprs.add<ExprList>(state->exprs.alloc, $2); }
+  | '[' list ']' { $$ = state->exprs.add<ExprList>(state->exprs.alloc, std::move($2)); }
   ;
 
 string_parts
   : STR { $$ = $1; }
-  | string_parts_interpolated { $$ = state->exprs.add<ExprConcatStrings>(state->exprs.alloc, CUR_POS, true, $1); }
+  | string_parts_interpolated { $$ = state->exprs.add<ExprConcatStrings>(state->exprs.alloc, CUR_POS, true, std::move($1)); }
   | { $$ = std::string_view(); }
   ;
 
@@ -425,7 +425,7 @@ binds1
       if (!$accum->inheritFromExprs)
           $accum->inheritFromExprs = std::make_unique<std::vector<Expr *>>();
       $accum->inheritFromExprs->push_back($expr);
-      auto from = state->exprs.add<ExprInheritFrom>(state->at(@expr), $accum->inheritFromExprs->size() - 1);
+      auto from = new nix::ExprInheritFrom(state->at(@expr), $accum->inheritFromExprs->size() - 1);
       for (auto & [i, iPos] : $attrs) {
           if ($accum->attrs.find(i.symbol) != $accum->attrs.end())
               state->dupAttr(i.symbol, iPos, $accum->attrs[i.symbol].pos);

src/libexpr/primops.cc

@@ -40,12 +40,6 @@
 
 namespace nix {
 
-RegisterPrimOp::PrimOps & RegisterPrimOp::primOps()
-{
-    static RegisterPrimOp::PrimOps primOps;
-    return primOps;
-}
-
 /*************************************************************
  * Miscellaneous
  *************************************************************/
@@ -228,8 +222,7 @@ void derivationToValue(
             path2,
             {
                 NixStringContextElem::DrvDeep{.drvPath = storePath},
-            },
-            state.mem);
+            });
     attrs.alloc(state.s.name).mkString(drv.env["name"]);
 
     auto list = state.buildList(drv.outputs.size());
@@ -1818,8 +1811,7 @@ static void derivationStrictInternal(EvalState & state, std::string_view drvName
             drvPathS,
             {
                 NixStringContextElem::DrvDeep{.drvPath = drvPath},
-            },
-            state.mem);
+            });
     for (auto & i : drv.outputs)
         mkOutputString(state, result, drvPath, i);
 
@@ -1872,7 +1864,7 @@ static void prim_toPath(EvalState & state, const PosIdx pos, Value ** args, Valu
     NixStringContext context;
     auto path =
         state.coerceToPath(pos, *args[0], context, "while evaluating the first argument passed to builtins.toPath");
-    v.mkString(path.path.abs(), context, state.mem);
+    v.mkString(path.path.abs(), context);
 }
 
 static RegisterPrimOp primop_toPath({
@@ -1915,7 +1907,7 @@ static void prim_storePath(EvalState & state, const PosIdx pos, Value ** args, V
     if (!settings.readOnlyMode)
         state.store->ensurePath(path2);
     context.insert(NixStringContextElem::Opaque{.path = path2});
-    v.mkString(path.abs(), context, state.mem);
+    v.mkString(path.abs(), context);
 }
 
 static RegisterPrimOp primop_storePath({
@@ -1997,8 +1989,7 @@ static void prim_baseNameOf(EvalState & state, const PosIdx pos, Value ** args,
     v.mkString(
         legacyBaseNameOf(*state.coerceToString(
             pos, *args[0], context, "while evaluating the first argument passed to builtins.baseNameOf", false, false)),
-        context,
-        state.mem);
+        context);
 }
 
 static RegisterPrimOp primop_baseNameOf({
@@ -2034,11 +2025,11 @@ static void prim_dirOf(EvalState & state, const PosIdx pos, Value ** args, Value
             pos, *args[0], context, "while evaluating the first argument passed to 'builtins.dirOf'", false, false);
         auto pos = path->rfind('/');
         if (pos == path->npos)
-            v.mkStringMove("."_sds, context, state.mem);
+            v.mkStringMove("."_sds, context);
         else if (pos == 0)
-            v.mkStringMove("/"_sds, context, state.mem);
+            v.mkStringMove("/"_sds, context);
         else
-            v.mkString(path->substr(0, pos), context, state.mem);
+            v.mkString(path->substr(0, pos), context);
     }
 }
 
@@ -2080,7 +2071,7 @@ static void prim_readFile(EvalState & state, const PosIdx pos, Value ** args, Va
                 .path = std::move((StorePath &&) p),
             });
     }
-    v.mkString(s, context, state.mem);
+    v.mkString(s, context);
 }
 
 static RegisterPrimOp primop_readFile({
@@ -2476,7 +2467,7 @@ static void prim_toXML(EvalState & state, const PosIdx pos, Value ** args, Value
     std::ostringstream out;
     NixStringContext context;
     printValueAsXML(state, true, false, *args[0], out, context, pos);
-    v.mkString(out.view(), context, state.mem);
+    v.mkString(out.view(), context);
 }
 
 static RegisterPrimOp primop_toXML({
@@ -2584,7 +2575,7 @@ static void prim_toJSON(EvalState & state, const PosIdx pos, Value ** args, Valu
     std::ostringstream out;
     NixStringContext context;
     printValueAsJSON(state, true, *args[0], pos, out, context);
-    v.mkString(out.view(), context, state.mem);
+    v.mkString(out.view(), context);
 }
 
 static RegisterPrimOp primop_toJSON({
@@ -4413,7 +4404,7 @@ static void prim_toString(EvalState & state, const PosIdx pos, Value ** args, Va
     NixStringContext context;
     auto s = state.coerceToString(
         pos, *args[0], context, "while evaluating the first argument passed to builtins.toString", true, false);
-    v.mkString(*s, context, state.mem);
+    v.mkString(*s, context);
 }
 
 static RegisterPrimOp primop_toString({
@@ -4486,7 +4477,7 @@ static void prim_substring(EvalState & state, const PosIdx pos, Value ** args, V
     auto s = state.coerceToString(
         pos, *args[2], context, "while evaluating the third argument (the string) passed to builtins.substring");
 
-    v.mkString(NixUInt(start) >= s->size() ? "" : s->substr(start, _len), context, state.mem);
+    v.mkString(NixUInt(start) >= s->size() ? "" : s->substr(start, _len), context);
 }
 
 static RegisterPrimOp primop_substring({
@@ -4884,7 +4875,7 @@ static void prim_concatStringsSep(EvalState & state, const PosIdx pos, Value **
             "while evaluating one element of the list of strings to concat passed to builtins.concatStringsSep");
     }
 
-    v.mkString(res, context, state.mem);
+    v.mkString(res, context);
 }
 
 static RegisterPrimOp primop_concatStringsSep({
@@ -4959,7 +4950,7 @@ static void prim_replaceStrings(EvalState & state, const PosIdx pos, Value ** ar
         }
     }
 
-    v.mkString(res, context, state.mem);
+    v.mkString(res, context);
 }
 
 static RegisterPrimOp primop_replaceStrings({

src/libexpr/primops/context.cc

@@ -69,7 +69,7 @@ static void prim_unsafeDiscardOutputDependency(EvalState & state, const PosIdx p
         }
     }
 
-    v.mkString(*s, context2, state.mem);
+    v.mkString(*s, context2);
 }
 
 static RegisterPrimOp primop_unsafeDiscardOutputDependency(
@@ -137,7 +137,7 @@ static void prim_addDrvOutputDependencies(EvalState & state, const PosIdx pos, V
             context.begin()->raw)}),
     };
 
-    v.mkString(*s, context2, state.mem);
+    v.mkString(*s, context2);
 }
 
 static RegisterPrimOp primop_addDrvOutputDependencies(
@@ -321,7 +321,7 @@ static void prim_appendContext(EvalState & state, const PosIdx pos, Value ** arg
         }
     }
 
-    v.mkString(orig, context, state.mem);
+    v.mkString(orig, context);
 }
 
 static RegisterPrimOp primop_appendContext({.name = "__appendContext", .arity = 2, .fun = prim_appendContext});

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.fetchSettings, state.store);
+    auto [storePath, input2] = input.fetchToStore(state.store);
 
     auto attrs2 = state.buildBindings(8);
     state.mkStorePathString(storePath, attrs2.alloc(state.s.outPath));

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{};
+    fetchers::Input input{state.fetchSettings};
     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.fetchSettings, state.store, input, fetchers::UseRegistries::Limited).first;
+        input = lookupInRegistries(state.store, input, fetchers::UseRegistries::Limited).first;
 
-    if (state.settings.pureEval && !input.isLocked(state.fetchSettings)) {
+    if (state.settings.pureEval && !input.isLocked()) {
         if (input.getNarHash())
             warn(
                 "Input '%s' is unlocked (e.g. lacks a Git revision) but is checked by NAR hash. "
@@ -219,8 +219,7 @@ static void fetchTree(
             throw Error("input '%s' is not allowed to use the '__final' attribute", input.to_string());
     }
 
-    auto cachedInput =
-        state.inputCache->getAccessor(state.fetchSettings, state.store, input, fetchers::UseRegistries::No);
+    auto cachedInput = state.inputCache->getAccessor(state.store, input, fetchers::UseRegistries::No);
 
     auto storePath = state.mountInput(cachedInput.lockedInput, input, cachedInput.accessor);
 
@@ -235,127 +234,229 @@ static void prim_fetchTree(EvalState & state, const PosIdx pos, Value ** args, V
 static RegisterPrimOp primop_fetchTree({
     .name = "fetchTree",
     .args = {"input"},
-    .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:
+    .doc = 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**
+        > **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**
             >
-            > [Substituters](@docroot@/command-ref/conf-file.md#conf-substituters) are not used in fetching.
+            > ```nix
+            > fetchTree {
+            >   type = "file";
+            >   url = "https://example.com/index.html";
+            > }
+            > ```
 
-          - There is no cache entry or the cache entry is older than [`tarball-ttl`](@docroot@/command-ref/conf-file.md#conf-tarball-ttl)
+          - `http`
 
-          ## Source types
+            Insecure HTTP transfer for legacy sources.
 
-          The following source types and associated input attributes are supported.
+            > **Warning**
+            >
+            > HTTP performs no encryption or authentication.
+            > Use a `narHash` known in advance to ensure the output has expected contents.
 
-          <!-- 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`
 
-        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;
-        };
+            A file on the local file system.
 
-        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";
+            > **Example**
+            >
+            > ```nix
+            > fetchTree {
+            >   type = "file";
+            >   url = "file:///home/eelco/nix/README.md";
+            > }
+            > ```
 
-            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";
-            }
-        }
+      - `"tarball"`
 
-        doc += "\n" + stripIndentation(R"(
-          The following input types are still subject to change:
+        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)
 
-          - `"path"`
-          - `"github"`
-          - `"gitlab"`
-          - `"sourcehut"`
-          - `"mercurial"`
+        - `url` (String, required)
 
-         *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**
+           >
+           > ```nix
+           > fetchTree {
+           >   type = "tarball";
+           >   url = "https://github.com/NixOS/nixpkgs/tarball/nixpkgs-23.11";
+           > }
+           > ```
+
+      - `"git"`
+
+        Fetch a Git tree and copy it to the Nix store.
+        This is similar to [`builtins.fetchGit`](@docroot@/language/builtins.md#builtins-fetchGit).
+
+        - `url` (String, required)
+
+          The URL formats supported are the same as for Git itself.
 
           > **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";
+          > fetchTree {
+          >   type = "git";
+          >   url = "git@github.com:NixOS/nixpkgs.git";
           > }
           > ```
 
-          > **Example**
+          > **Note**
           >
-          > Fetch the same GitHub repository using the URL-like syntax:
-          >
-          >   ```nix
-          >   builtins.fetchTree "github:NixOS/nixpkgs/ae2e6b3958682513d28f7d633734571fb18285dd"
-          >   ```
-        )");
+          > 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.
 
-        return doc;
-    }(),
+        - `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`
+
+        - `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`
+
+        - `lfs` (Bool, optional)
+
+          Fetch any [Git LFS](https://git-lfs.com/) files.
+
+          Default: `false`
+
+        - `allRefs` (Bool, optional)
+
+          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.
+
+        - `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.
+
+      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"
+      >   ```
+    )",
     .fun = prim_fetchTree,
     .experimentalFeature = Xp::FetchTree,
 });

src/libfetchers-tests/git.cc

@@ -196,7 +196,7 @@ TEST_F(GitTest, submodulePeriodSupport)
             {"ref", "main"},
         });
 
-    auto [accessor, i] = input.getAccessor(settings, store);
+    auto [accessor, i] = input.getAccessor(store);
 
     ASSERT_EQ(accessor->readFile(CanonPath("deps/sub/lib.txt")), "hello from submodule\n");
 }

src/libfetchers/fetchers.cc

@@ -26,9 +26,18 @@ void registerInputScheme(std::shared_ptr<InputScheme> && inputScheme)
         throw Error("Input scheme with name %s already registered", schemeName);
 }
 
-const InputSchemeMap & getAllInputSchemes()
+nlohmann::json dumpRegisterInputSchemeInfo()
 {
-    return inputSchemes();
+    using nlohmann::json;
+
+    auto res = json::object();
+
+    for (auto & [name, scheme] : inputSchemes()) {
+        auto & r = res[name] = json::object();
+        r["allowedAttrs"] = scheme->allowedAttrs();
+    }
+
+    return res;
 }
 
 Input Input::fromURL(const Settings & settings, const std::string & url, bool requireTree)
@@ -80,7 +89,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;
+        Input input{settings};
         input.attrs = attrs;
         fixupInput(input);
         return input;
@@ -150,9 +159,9 @@ bool Input::isDirect() const
     return !scheme || scheme->isDirect(*this);
 }
 
-bool Input::isLocked(const Settings & settings) const
+bool Input::isLocked() const
 {
-    return scheme && scheme->isLocked(settings, *this);
+    return scheme && scheme->isLocked(*this);
 }
 
 bool Input::isFinal() const
@@ -189,17 +198,17 @@ bool Input::contains(const Input & other) const
 }
 
 // FIXME: remove
-std::pair<StorePath, Input> Input::fetchToStore(const Settings & settings, ref<Store> store) const
+std::pair<StorePath, Input> Input::fetchToStore(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(settings, store);
+            auto [accessor, result] = getAccessorUnchecked(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));
@@ -288,10 +297,10 @@ void Input::checkLocks(Input specified, Input & result)
     }
 }
 
-std::pair<ref<SourceAccessor>, Input> Input::getAccessor(const Settings & settings, ref<Store> store) const
+std::pair<ref<SourceAccessor>, Input> Input::getAccessor(ref<Store> store) const
 {
     try {
-        auto [accessor, result] = getAccessorUnchecked(settings, store);
+        auto [accessor, result] = getAccessorUnchecked(store);
 
         result.attrs.insert_or_assign("__final", Explicit<bool>(true));
 
@@ -304,7 +313,7 @@ std::pair<ref<SourceAccessor>, Input> Input::getAccessor(const Settings & settin
     }
 }
 
-std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(const Settings & settings, ref<Store> store) const
+std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(ref<Store> store) const
 {
     // FIXME: cache the accessor
 
@@ -340,7 +349,7 @@ std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(const Settings
             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() + "»");
@@ -351,7 +360,7 @@ std::pair<ref<SourceAccessor>, Input> Input::getAccessorUnchecked(const Settings
         }
     }
 
-    auto [accessor, result] = scheme->getAccessor(settings, store, *this);
+    auto [accessor, result] = scheme->getAccessor(store, *this);
 
     if (!accessor->fingerprint)
         accessor->fingerprint = result.getFingerprint(store);
@@ -368,10 +377,10 @@ Input Input::applyOverrides(std::optional<std::string> ref, std::optional<Hash>
     return scheme->applyOverrides(*this, ref, rev);
 }
 
-void Input::clone(const Settings & settings, const Path & destDir) const
+void Input::clone(const Path & destDir) const
 {
     assert(scheme);
-    scheme->clone(settings, *this, destDir);
+    scheme->clone(*this, destDir);
 }
 
 std::optional<std::filesystem::path> Input::getSourcePath() const
@@ -484,7 +493,7 @@ void InputScheme::putFile(
     throw Error("input '%s' does not support modifying file '%s'", input.to_string(), path);
 }
 
-void InputScheme::clone(const Settings & settings, const Input & input, const Path & destDir) const
+void InputScheme::clone(const Input & input, const Path & destDir) const
 {
     throw Error("do not know how to clone input '%s'", input.to_string());
 }

src/libfetchers/git.cc

@@ -194,183 +194,28 @@ struct GitInputScheme : InputScheme
         return "git";
     }
 
-    std::string schemeDescription() const override
+    StringSet allowedAttrs() const override
     {
-        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 {
+            "url",
+            "ref",
+            "rev",
+            "shallow",
+            "submodules",
+            "lfs",
+            "exportIgnore",
+            "lastModified",
+            "revCount",
+            "narHash",
+            "allRefs",
+            "name",
+            "dirtyRev",
+            "dirtyShortRev",
+            "verifyCommit",
+            "keytype",
+            "publicKey",
+            "publicKeys",
         };
-        return attrs;
     }
 
     std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
@@ -384,7 +229,7 @@ struct GitInputScheme : InputScheme
         if (auto ref = maybeGetStrAttr(attrs, "ref"); ref && !isLegalRefName(*ref))
             throw BadURL("invalid Git branch/tag name '%s'", *ref);
 
-        Input input{};
+        Input input{settings};
         input.attrs = attrs;
         input.attrs["url"] = fixGitURL(getStrAttr(attrs, "url")).to_string();
         getShallowAttr(input);
@@ -433,7 +278,7 @@ struct GitInputScheme : InputScheme
         return res;
     }
 
-    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
+    void clone(const Input & input, const Path & destDir) const override
     {
         auto repoInfo = getRepoInfo(input);
 
@@ -778,7 +623,7 @@ struct GitInputScheme : InputScheme
     }
 
     std::pair<ref<SourceAccessor>, Input>
-    getAccessorFromCommit(const Settings & settings, ref<Store> store, RepoInfo & repoInfo, Input && input) const
+    getAccessorFromCommit(ref<Store> store, RepoInfo & repoInfo, Input && input) const
     {
         assert(!repoInfo.workdirInfo.isDirty);
 
@@ -888,10 +733,10 @@ struct GitInputScheme : InputScheme
 
         auto rev = *input.getRev();
 
-        input.attrs.insert_or_assign("lastModified", getLastModified(settings, repoInfo, repoDir, rev));
+        input.attrs.insert_or_assign("lastModified", getLastModified(*input.settings, repoInfo, repoDir, rev));
 
         if (!getShallowAttr(input))
-            input.attrs.insert_or_assign("revCount", getRevCount(settings, repoInfo, repoDir, rev));
+            input.attrs.insert_or_assign("revCount", getRevCount(*input.settings, repoInfo, repoDir, rev));
 
         printTalkative("using revision %s of repo '%s'", rev.gitRev(), repoInfo.locationToArg());
 
@@ -934,8 +779,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(settings, std::move(attrs));
-                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(settings, store);
+                auto submoduleInput = fetchers::Input::fromAttrs(*input.settings, std::move(attrs));
+                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(store);
                 submoduleAccessor->setPathDisplay("«" + submoduleInput.to_string() + "»");
                 mounts.insert_or_assign(submodule.path, submoduleAccessor);
             }
@@ -952,7 +797,7 @@ struct GitInputScheme : InputScheme
     }
 
     std::pair<ref<SourceAccessor>, Input>
-    getAccessorFromWorkdir(const Settings & settings, ref<Store> store, RepoInfo & repoInfo, Input && input) const
+    getAccessorFromWorkdir(ref<Store> store, RepoInfo & repoInfo, Input && input) const
     {
         auto repoPath = repoInfo.getPath().value();
 
@@ -984,8 +829,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(settings, std::move(attrs));
-                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(settings, store);
+                auto submoduleInput = fetchers::Input::fromAttrs(*input.settings, std::move(attrs));
+                auto [submoduleAccessor, submoduleInput2] = submoduleInput.getAccessor(store);
                 submoduleAccessor->setPathDisplay("«" + submoduleInput.to_string() + "»");
 
                 /* If the submodule is dirty, mark this repo dirty as
@@ -1012,12 +857,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(settings, repoInfo, repoPath, rev));
+                    "revCount", rev == nullRev ? 0 : getRevCount(*input.settings, repoInfo, repoPath, rev));
             }
 
             verifyCommit(input, repo);
         } else {
-            repoInfo.warnDirty(settings);
+            repoInfo.warnDirty(*input.settings);
 
             if (repoInfo.workdirInfo.headRev) {
                 input.attrs.insert_or_assign("dirtyRev", repoInfo.workdirInfo.headRev->gitRev() + "-dirty");
@@ -1029,14 +874,14 @@ struct GitInputScheme : InputScheme
 
         input.attrs.insert_or_assign(
             "lastModified",
-            repoInfo.workdirInfo.headRev ? getLastModified(settings, repoInfo, repoPath, *repoInfo.workdirInfo.headRev)
-                                         : 0);
+            repoInfo.workdirInfo.headRev
+                ? getLastModified(*input.settings, repoInfo, repoPath, *repoInfo.workdirInfo.headRev)
+                : 0);
 
         return {accessor, std::move(input)};
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
     {
         Input input(_input);
 
@@ -1052,8 +897,8 @@ struct GitInputScheme : InputScheme
         }
 
         auto [accessor, final] = input.getRef() || input.getRev() || !repoInfo.getPath()
-                                     ? getAccessorFromCommit(settings, store, repoInfo, std::move(input))
-                                     : getAccessorFromWorkdir(settings, store, repoInfo, std::move(input));
+                                     ? getAccessorFromCommit(store, repoInfo, std::move(input))
+                                     : getAccessorFromWorkdir(store, repoInfo, std::move(input));
 
         return {accessor, std::move(final)};
     }
@@ -1089,7 +934,7 @@ struct GitInputScheme : InputScheme
         }
     }
 
-    bool isLocked(const Settings & settings, const Input & input) const override
+    bool isLocked(const Input & input) const override
     {
         auto rev = input.getRev();
         return rev && rev != nullRev;

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{};
+        Input input{settings};
         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,43 +110,18 @@ struct GitArchiveInputScheme : InputScheme
         return input;
     }
 
-    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
+    StringSet allowedAttrs() const override
     {
-        static const std::map<std::string, AttributeInfo> attrs = {
-            {
-                "owner",
-                {},
-            },
-            {
-                "repo",
-                {},
-            },
-            {
-                "ref",
-                {},
-            },
-            {
-                "rev",
-                {},
-            },
-            {
-                "narHash",
-                {},
-            },
-            {
-                "lastModified",
-                {},
-            },
-            {
-                "host",
-                {},
-            },
-            {
-                "treeHash",
-                {},
-            },
+        return {
+            "owner",
+            "repo",
+            "ref",
+            "rev",
+            "narHash",
+            "lastModified",
+            "host",
+            "treeHash",
         };
-        return attrs;
     }
 
     std::optional<Input> inputFromAttrs(const fetchers::Settings & settings, const Attrs & attrs) const override
@@ -154,7 +129,7 @@ struct GitArchiveInputScheme : InputScheme
         getStrAttr(attrs, "owner");
         getStrAttr(attrs, "repo");
 
-        Input input{};
+        Input input{settings};
         input.attrs = attrs;
         return input;
     }
@@ -258,9 +233,9 @@ struct GitArchiveInputScheme : InputScheme
         std::optional<Hash> treeHash;
     };
 
-    virtual RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const = 0;
+    virtual RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const = 0;
 
-    virtual DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const = 0;
+    virtual DownloadUrl getDownloadUrl(const Input & input) const = 0;
 
     struct TarballInfo
     {
@@ -268,7 +243,7 @@ struct GitArchiveInputScheme : InputScheme
         time_t lastModified;
     };
 
-    std::pair<Input, TarballInfo> downloadArchive(const Settings & settings, ref<Store> store, Input input) const
+    std::pair<Input, TarballInfo> downloadArchive(ref<Store> store, Input input) const
     {
         if (!maybeGetStrAttr(input.attrs, "ref"))
             input.attrs.insert_or_assign("ref", "HEAD");
@@ -277,7 +252,7 @@ struct GitArchiveInputScheme : InputScheme
 
         auto rev = input.getRev();
         if (!rev) {
-            auto refInfo = getRevFromRef(settings, store, input);
+            auto refInfo = getRevFromRef(store, input);
             rev = refInfo.rev;
             upstreamTreeHash = refInfo.treeHash;
             debug("HEAD revision for '%s' is %s", input.to_string(), refInfo.rev.gitRev());
@@ -286,7 +261,7 @@ struct GitArchiveInputScheme : InputScheme
         input.attrs.erase("ref");
         input.attrs.insert_or_assign("rev", rev->gitRev());
 
-        auto cache = settings.getCache();
+        auto cache = input.settings->getCache();
 
         Cache::Key treeHashKey{"gitRevToTreeHash", {{"rev", rev->gitRev()}}};
         Cache::Key lastModifiedKey{"gitRevToLastModified", {{"rev", rev->gitRev()}}};
@@ -295,7 +270,7 @@ struct GitArchiveInputScheme : InputScheme
             if (auto lastModifiedAttrs = cache->lookup(lastModifiedKey)) {
                 auto treeHash = getRevAttr(*treeHashAttrs, "treeHash");
                 auto lastModified = getIntAttr(*lastModifiedAttrs, "lastModified");
-                if (settings.getTarballCache()->hasObject(treeHash))
+                if (input.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());
@@ -303,7 +278,7 @@ struct GitArchiveInputScheme : InputScheme
         }
 
         /* Stream the tarball into the tarball cache. */
-        auto url = getDownloadUrl(settings, input);
+        auto url = getDownloadUrl(input);
 
         auto source = sinkToSource([&](Sink & sink) {
             FileTransferRequest req(url.url);
@@ -315,7 +290,7 @@ struct GitArchiveInputScheme : InputScheme
             *logger, lvlInfo, actUnknown, fmt("unpacking '%s' into the Git cache", input.to_string()));
 
         TarArchive archive{*source};
-        auto tarballCache = settings.getTarballCache();
+        auto tarballCache = input.settings->getTarballCache();
         auto parseSink = tarballCache->getFileSystemObjectSink();
         auto lastModified = unpackTarfileToSink(archive, *parseSink);
         auto tree = parseSink->flush();
@@ -340,10 +315,9 @@ struct GitArchiveInputScheme : InputScheme
         return {std::move(input), tarballInfo};
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
     {
-        auto [input, tarballInfo] = downloadArchive(settings, store, _input);
+        auto [input, tarballInfo] = downloadArchive(store, _input);
 
 #if 0
         input.attrs.insert_or_assign("treeHash", tarballInfo.treeHash.gitRev());
@@ -351,18 +325,19 @@ struct GitArchiveInputScheme : InputScheme
         input.attrs.insert_or_assign("lastModified", uint64_t(tarballInfo.lastModified));
 
         auto accessor =
-            settings.getTarballCache()->getAccessor(tarballInfo.treeHash, false, "«" + input.to_string() + "»");
+            input.settings->getTarballCache()->getAccessor(tarballInfo.treeHash, false, "«" + input.to_string() + "»");
 
         return {accessor, input};
     }
 
-    bool isLocked(const Settings & settings, const Input & input) const override
+    bool isLocked(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() && (settings.trustTarballsFromGitForges || input.getNarHash().has_value());
+        return input.getRev().has_value()
+               && (input.settings->trustTarballsFromGitForges || input.getNarHash().has_value());
     }
 
     std::optional<ExperimentalFeature> experimentalFeature() const override
@@ -386,12 +361,6 @@ 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
@@ -418,7 +387,7 @@ struct GitHubInputScheme : GitArchiveInputScheme
         return getStrAttr(input.attrs, "repo");
     }
 
-    RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const override
+    RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const override
     {
         auto host = getHost(input);
         auto url = fmt(
@@ -428,9 +397,9 @@ struct GitHubInputScheme : GitArchiveInputScheme
             getRepo(input),
             *input.getRef());
 
-        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
 
-        auto downloadResult = downloadFile(store, settings, url, "source", headers);
+        auto downloadResult = downloadFile(store, *input.settings, url, "source", headers);
         auto json = nlohmann::json::parse(
             store->requireStoreObjectAccessor(downloadResult.storePath)->readFile(CanonPath::root));
 
@@ -439,11 +408,11 @@ struct GitHubInputScheme : GitArchiveInputScheme
             .treeHash = Hash::parseAny(std::string{json["commit"]["tree"]["sha"]}, HashAlgorithm::SHA1)};
     }
 
-    DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const override
+    DownloadUrl getDownloadUrl(const Input & input) const override
     {
         auto host = getHost(input);
 
-        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(*input.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.
@@ -457,12 +426,12 @@ struct GitHubInputScheme : GitArchiveInputScheme
         return DownloadUrl{parseURL(url), headers};
     }
 
-    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
+    void clone(const Input & input, const Path & destDir) const override
     {
         auto host = getHost(input);
-        Input::fromURL(settings, fmt("git+https://%s/%s/%s.git", host, getOwner(input), getRepo(input)))
+        Input::fromURL(*input.settings, fmt("git+https://%s/%s/%s.git", host, getOwner(input), getRepo(input)))
             .applyOverrides(input.getRef(), input.getRev())
-            .clone(settings, destDir);
+            .clone(destDir);
     }
 };
 
@@ -473,12 +442,6 @@ 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
@@ -498,7 +461,7 @@ struct GitLabInputScheme : GitArchiveInputScheme
         return std::make_pair(token.substr(0, fldsplit), token.substr(fldsplit + 1));
     }
 
-    RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const override
+    RefInfo getRevFromRef(nix::ref<Store> store, const Input & input) const override
     {
         auto host = maybeGetStrAttr(input.attrs, "host").value_or("gitlab.com");
         // See rate limiting note below
@@ -509,9 +472,9 @@ struct GitLabInputScheme : GitArchiveInputScheme
                 getStrAttr(input.attrs, "repo"),
                 *input.getRef());
 
-        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
 
-        auto downloadResult = downloadFile(store, settings, url, "source", headers);
+        auto downloadResult = downloadFile(store, *input.settings, url, "source", headers);
         auto json = nlohmann::json::parse(
             store->requireStoreObjectAccessor(downloadResult.storePath)->readFile(CanonPath::root));
 
@@ -525,7 +488,7 @@ struct GitLabInputScheme : GitArchiveInputScheme
         }
     }
 
-    DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const override
+    DownloadUrl getDownloadUrl(const Input & input) const override
     {
         // This endpoint has a rate limit threshold that may be
         // server-specific and vary based whether the user is
@@ -540,19 +503,19 @@ struct GitLabInputScheme : GitArchiveInputScheme
                 getStrAttr(input.attrs, "repo"),
                 input.getRev()->to_string(HashFormat::Base16, false));
 
-        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
         return DownloadUrl{parseURL(url), headers};
     }
 
-    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
+    void clone(const Input & input, const Path & destDir) const override
     {
         auto host = maybeGetStrAttr(input.attrs, "host").value_or("gitlab.com");
         // FIXME: get username somewhere
         Input::fromURL(
-            settings,
+            *input.settings,
             fmt("git+https://%s/%s/%s.git", host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo")))
             .applyOverrides(input.getRef(), input.getRev())
-            .clone(settings, destDir);
+            .clone(destDir);
     }
 };
 
@@ -563,12 +526,6 @@ 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
@@ -579,7 +536,7 @@ struct SourceHutInputScheme : GitArchiveInputScheme
         // Once it is implemented, however, should work as expected.
     }
 
-    RefInfo getRevFromRef(const Settings & settings, nix::ref<Store> store, const Input & input) const override
+    RefInfo getRevFromRef(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.
@@ -590,11 +547,11 @@ struct SourceHutInputScheme : GitArchiveInputScheme
         auto base_url =
             fmt("https://%s/%s/%s", host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo"));
 
-        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
 
         std::string refUri;
         if (ref == "HEAD") {
-            auto downloadFileResult = downloadFile(store, settings, fmt("%s/HEAD", base_url), "source", headers);
+            auto downloadFileResult = downloadFile(store, *input.settings, fmt("%s/HEAD", base_url), "source", headers);
             auto contents = store->requireStoreObjectAccessor(downloadFileResult.storePath)->readFile(CanonPath::root);
 
             auto remoteLine = git::parseLsRemoteLine(getLine(contents).first);
@@ -607,7 +564,8 @@ struct SourceHutInputScheme : GitArchiveInputScheme
         }
         std::regex refRegex(refUri);
 
-        auto downloadFileResult = downloadFile(store, settings, fmt("%s/info/refs", base_url), "source", headers);
+        auto downloadFileResult =
+            downloadFile(store, *input.settings, fmt("%s/info/refs", base_url), "source", headers);
         auto contents = store->requireStoreObjectAccessor(downloadFileResult.storePath)->readFile(CanonPath::root);
         std::istringstream is(contents);
 
@@ -625,7 +583,7 @@ struct SourceHutInputScheme : GitArchiveInputScheme
         return RefInfo{.rev = Hash::parseAny(*id, HashAlgorithm::SHA1)};
     }
 
-    DownloadUrl getDownloadUrl(const Settings & settings, const Input & input) const override
+    DownloadUrl getDownloadUrl(const Input & input) const override
     {
         auto host = maybeGetStrAttr(input.attrs, "host").value_or("git.sr.ht");
         auto url =
@@ -635,18 +593,18 @@ struct SourceHutInputScheme : GitArchiveInputScheme
                 getStrAttr(input.attrs, "repo"),
                 input.getRev()->to_string(HashFormat::Base16, false));
 
-        Headers headers = makeHeadersWithAuthTokens(settings, host, input);
+        Headers headers = makeHeadersWithAuthTokens(*input.settings, host, input);
         return DownloadUrl{parseURL(url), headers};
     }
 
-    void clone(const Settings & settings, const Input & input, const Path & destDir) const override
+    void clone(const Input & input, const Path & destDir) const override
     {
         auto host = maybeGetStrAttr(input.attrs, "host").value_or("git.sr.ht");
         Input::fromURL(
-            settings,
+            *input.settings,
             fmt("git+https://%s/%s/%s", host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo")))
             .applyOverrides(input.getRef(), input.getRev())
-            .clone(settings, destDir);
+            .clone(destDir);
     }
 };
 

src/libfetchers/include/nix/fetchers/fetchers.hh

@@ -36,6 +36,13 @@ 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;
 
@@ -80,7 +87,7 @@ public:
      * attributes like a Git revision or NAR hash that uniquely
      * identify its contents.
      */
-    bool isLocked(const Settings & settings) const;
+    bool isLocked() const;
 
     /**
      * Only for relative path flakes, i.e. 'path:./foo', returns the
@@ -113,7 +120,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(const Settings & settings, ref<Store> store) const;
+    std::pair<StorePath, Input> fetchToStore(ref<Store> store) const;
 
     /**
      * Check the locking attributes in `result` against
@@ -133,17 +140,17 @@ public:
      * input without copying it to the store. Also return a possibly
      * unlocked input.
      */
-    std::pair<ref<SourceAccessor>, Input> getAccessor(const Settings & settings, ref<Store> store) const;
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store) const;
 
 private:
 
-    std::pair<ref<SourceAccessor>, Input> getAccessorUnchecked(const Settings & settings, ref<Store> store) const;
+    std::pair<ref<SourceAccessor>, Input> getAccessorUnchecked(ref<Store> store) const;
 
 public:
 
     Input applyOverrides(std::optional<std::string> ref, std::optional<Hash> rev) const;
 
-    void clone(const Settings & settings, const Path & destDir) const;
+    void clone(const Path & destDir) const;
 
     std::optional<std::filesystem::path> getSourcePath() const;
 
@@ -203,33 +210,20 @@ 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, and documentation for each attribute.
+     * input.
      *
-     * `type` is not included from this map, because the `type` field is
+     * `type` is not included from this set, because the `type` field is
       parsed first to choose which scheme; `type` is always required.
      */
-    virtual const std::map<std::string, AttributeInfo> & allowedAttrs() const = 0;
+    virtual StringSet 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 Settings & settings, const Input & input, const Path & destDir) const;
+    virtual void clone(const Input & input, const Path & destDir) const;
 
     virtual std::optional<std::filesystem::path> getSourcePath(const Input & input) const;
 
@@ -239,8 +233,7 @@ struct InputScheme
         std::string_view contents,
         std::optional<std::string> commitMsg) const;
 
-    virtual std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & input) const = 0;
+    virtual std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & input) const = 0;
 
     /**
      * Is this `InputScheme` part of an experimental feature?
@@ -257,7 +250,7 @@ struct InputScheme
         return std::nullopt;
     }
 
-    virtual bool isLocked(const Settings & settings, const Input & input) const
+    virtual bool isLocked(const Input & input) const
     {
         return false;
     }
@@ -276,12 +269,7 @@ struct InputScheme
 
 void registerInputScheme(std::shared_ptr<InputScheme> && fetcher);
 
-using InputSchemeMap = std::map<std::string_view, std::shared_ptr<InputScheme>>;
-
-/**
- * Use this for docs, not for finding a specific scheme
- */
-const InputSchemeMap & getAllInputSchemes();
+nlohmann::json dumpRegisterInputSchemeInfo();
 
 struct PublicKey
 {

src/libfetchers/include/nix/fetchers/input-cache.hh

@@ -3,7 +3,6 @@
 namespace nix::fetchers {
 
 enum class UseRegistries : int;
-struct Settings;
 
 struct InputCache
 {
@@ -15,8 +14,7 @@ struct InputCache
         Attrs extraAttrs;
     };
 
-    CachedResult
-    getAccessor(const Settings & settings, ref<Store> store, const Input & originalInput, UseRegistries useRegistries);
+    CachedResult getAccessor(ref<Store> store, const Input & originalInput, UseRegistries useRegistries);
 
     struct CachedInput
     {

src/libfetchers/include/nix/fetchers/registry.hh

@@ -59,7 +59,7 @@ Path getUserRegistryPath();
 
 Registries getRegistries(const Settings & settings, ref<Store> store);
 
-void overrideRegistry(const Settings & settings, const Input & from, const Input & to, const Attrs & extraAttrs);
+void overrideRegistry(const Input & from, const Input & to, const Attrs & extraAttrs);
 
 enum class UseRegistries : int {
     No,
@@ -71,7 +71,6 @@ 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(const Settings & settings, ref<Store> store, const Input & input, UseRegistries useRegistries);
+std::pair<Input, Attrs> lookupInRegistries(ref<Store> store, const Input & input, UseRegistries useRegistries);
 
 } // namespace nix::fetchers

src/libfetchers/indirect.cc

@@ -44,7 +44,7 @@ struct IndirectInputScheme : InputScheme
 
         // FIXME: forbid query params?
 
-        Input input{};
+        Input input{settings};
         input.attrs.insert_or_assign("type", "indirect");
         input.attrs.insert_or_assign("id", id);
         if (rev)
@@ -60,33 +60,14 @@ struct IndirectInputScheme : InputScheme
         return "indirect";
     }
 
-    std::string schemeDescription() const override
+    StringSet allowedAttrs() const override
     {
-        // TODO
-        return "";
-    }
-
-    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
-    {
-        static const std::map<std::string, AttributeInfo> attrs = {
-            {
-                "id",
-                {},
-            },
-            {
-                "ref",
-                {},
-            },
-            {
-                "rev",
-                {},
-            },
-            {
-                "narHash",
-                {},
-            },
+        return {
+            "id",
+            "ref",
+            "rev",
+            "narHash",
         };
-        return attrs;
     }
 
     std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
@@ -95,7 +76,7 @@ struct IndirectInputScheme : InputScheme
         if (!std::regex_match(id, flakeRegex))
             throw BadURL("'%s' is not a valid flake ID", id);
 
-        Input input{};
+        Input input{settings};
         input.attrs = attrs;
         return input;
     }
@@ -125,8 +106,7 @@ struct IndirectInputScheme : InputScheme
         return input;
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & input) const override
     {
         throw Error("indirect input '%s' cannot be fetched directly", input.to_string());
     }

src/libfetchers/input-cache.cc

@@ -5,23 +5,23 @@
 
 namespace nix::fetchers {
 
-InputCache::CachedResult InputCache::getAccessor(
-    const Settings & settings, ref<Store> store, const Input & originalInput, UseRegistries useRegistries)
+InputCache::CachedResult
+InputCache::getAccessor(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(settings, store);
+            auto [accessor, lockedInput] = originalInput.getAccessor(store);
             fetched.emplace(CachedInput{.lockedInput = lockedInput, .accessor = accessor});
         } else {
             if (useRegistries != UseRegistries::No) {
-                auto [res, extraAttrs] = lookupInRegistries(settings, store, originalInput, useRegistries);
+                auto [res, extraAttrs] = lookupInRegistries(store, originalInput, useRegistries);
                 resolvedInput = std::move(res);
                 fetched = lookup(resolvedInput);
                 if (!fetched) {
-                    auto [accessor, lockedInput] = resolvedInput.getAccessor(settings, store);
+                    auto [accessor, lockedInput] = resolvedInput.getAccessor(store);
                     fetched.emplace(
                         CachedInput{.lockedInput = lockedInput, .accessor = accessor, .extraAttrs = extraAttrs});
                 }

src/libfetchers/mercurial.cc

@@ -68,41 +68,16 @@ struct MercurialInputScheme : InputScheme
         return "hg";
     }
 
-    std::string schemeDescription() const override
+    StringSet allowedAttrs() const override
     {
-        // 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 {
+            "url",
+            "ref",
+            "rev",
+            "revCount",
+            "narHash",
+            "name",
         };
-        return attrs;
     }
 
     std::optional<Input> inputFromAttrs(const Settings & settings, const Attrs & attrs) const override
@@ -114,7 +89,7 @@ struct MercurialInputScheme : InputScheme
                 throw BadURL("invalid Mercurial branch/tag name '%s'", *ref);
         }
 
-        Input input{};
+        Input input{settings};
         input.attrs = attrs;
         return input;
     }
@@ -179,7 +154,7 @@ struct MercurialInputScheme : InputScheme
         return {isLocal, isLocal ? renderUrlPathEnsureLegal(url.path) : url.to_string()};
     }
 
-    StorePath fetchToStore(const Settings & settings, ref<Store> store, Input & input) const
+    StorePath fetchToStore(ref<Store> store, Input & input) const
     {
         auto origRev = input.getRev();
 
@@ -201,10 +176,10 @@ struct MercurialInputScheme : InputScheme
                 /* This is an unclean working tree. So copy all tracked
                    files. */
 
-                if (!settings.allowDirty)
+                if (!input.settings->allowDirty)
                     throw Error("Mercurial tree '%s' is unclean", actualUrl);
 
-                if (settings.warnDirty)
+                if (input.settings->warnDirty)
                     warn("Mercurial tree '%s' is unclean", actualUrl);
 
                 input.attrs.insert_or_assign("ref", chomp(runHg({"branch", "-R", actualUrl})));
@@ -265,13 +240,13 @@ struct MercurialInputScheme : InputScheme
         Cache::Key refToRevKey{"hgRefToRev", {{"url", actualUrl}, {"ref", *input.getRef()}}};
 
         if (!input.getRev()) {
-            if (auto res = settings.getCache()->lookupWithTTL(refToRevKey))
+            if (auto res = input.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 = settings.getCache()->lookupStorePath(revInfoKey(*rev), *store))
+            if (auto res = input.settings->getCache()->lookupStorePath(revInfoKey(*rev), *store))
                 return makeResult(res->value, res->storePath);
         }
 
@@ -325,7 +300,7 @@ struct MercurialInputScheme : InputScheme
 
         /* Now that we have the rev, check the cache again for a
            cached store path. */
-        if (auto res = settings.getCache()->lookupStorePath(revInfoKey(rev), *store))
+        if (auto res = input.settings->getCache()->lookupStorePath(revInfoKey(rev), *store))
             return makeResult(res->value, res->storePath);
 
         Path tmpDir = createTempDir();
@@ -342,19 +317,18 @@ struct MercurialInputScheme : InputScheme
         });
 
         if (!origRev)
-            settings.getCache()->upsert(refToRevKey, {{"rev", rev.gitRev()}});
+            input.settings->getCache()->upsert(refToRevKey, {{"rev", rev.gitRev()}});
 
-        settings.getCache()->upsert(revInfoKey(rev), *store, infoAttrs, storePath);
+        input.settings->getCache()->upsert(revInfoKey(rev), *store, infoAttrs, storePath);
 
         return makeResult(infoAttrs, std::move(storePath));
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
     {
         Input input(_input);
 
-        auto storePath = fetchToStore(settings, store, input);
+        auto storePath = fetchToStore(store, input);
         auto accessor = store->requireStoreObjectAccessor(storePath);
 
         accessor->setPathDisplay("«" + input.to_string() + "»");
@@ -362,7 +336,7 @@ struct MercurialInputScheme : InputScheme
         return {accessor, input};
     }
 
-    bool isLocked(const Settings & settings, const Input & input) const override
+    bool isLocked(const Input & input) const override
     {
         return (bool) input.getRev();
     }

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{};
+        Input input{settings};
         input.attrs.insert_or_assign("type", "path");
         input.attrs.insert_or_assign("path", renderUrlPathEnsureLegal(url.path));
 
@@ -40,49 +40,27 @@ struct PathInputScheme : InputScheme
         return "path";
     }
 
-    std::string schemeDescription() const override
+    StringSet allowedAttrs() const override
     {
-        // TODO
-        return "";
-    }
-
-    const std::map<std::string, AttributeInfo> & allowedAttrs() const override
-    {
-        static const std::map<std::string, AttributeInfo> attrs = {
-            {
-                "path",
-                {},
-            },
+        return {
+            "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{};
+        Input input{settings};
         input.attrs = attrs;
         return input;
     }
@@ -123,7 +101,7 @@ struct PathInputScheme : InputScheme
             return path;
     }
 
-    bool isLocked(const Settings & settings, const Input & input) const override
+    bool isLocked(const Input & input) const override
     {
         return (bool) input.getNarHash();
     }
@@ -138,8 +116,7 @@ struct PathInputScheme : InputScheme
         throw Error("cannot fetch input '%s' because it uses a relative path", input.to_string());
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
     {
         Input input(_input);
         auto path = getStrAttr(input.attrs, "path");
@@ -168,7 +145,7 @@ struct PathInputScheme : InputScheme
         auto info = store->queryPathInfo(*storePath);
         accessor->fingerprint =
             fmt("path:%s", store->queryPathInfo(*storePath)->narHash.to_string(HashFormat::SRI, true));
-        settings.getCache()->upsert(
+        input.settings->getCache()->upsert(
             makeFetchToStoreCacheKey(
                 input.getName(), *accessor->fingerprint, ContentAddressMethod::Raw::NixArchive, "/"),
             *store,

src/libfetchers/registry.cc

@@ -131,9 +131,9 @@ std::shared_ptr<Registry> getFlagRegistry(const Settings & settings)
     return flagRegistry;
 }
 
-void overrideRegistry(const Settings & settings, const Input & from, const Input & to, const Attrs & extraAttrs)
+void overrideRegistry(const Input & from, const Input & to, const Attrs & extraAttrs)
 {
-    getFlagRegistry(settings)->add(from, to, extraAttrs);
+    getFlagRegistry(*from.settings)->add(from, to, extraAttrs);
 }
 
 static std::shared_ptr<Registry> getGlobalRegistry(const Settings & settings, ref<Store> store)
@@ -172,8 +172,7 @@ Registries getRegistries(const Settings & settings, ref<Store> store)
     return registries;
 }
 
-std::pair<Input, Attrs>
-lookupInRegistries(const Settings & settings, ref<Store> store, const Input & _input, UseRegistries useRegistries)
+std::pair<Input, Attrs> lookupInRegistries(ref<Store> store, const Input & _input, UseRegistries useRegistries)
 {
     Attrs extraAttrs;
     int n = 0;
@@ -188,7 +187,7 @@ restart:
     if (n > 100)
         throw Error("cycle detected in flake registry for '%s'", input.to_string());
 
-    for (auto & registry : getRegistries(settings, store)) {
+    for (auto & registry : getRegistries(*input.settings, store)) {
         if (useRegistries == UseRegistries::Limited
             && !(registry->type == fetchers::Registry::Flag || registry->type == fetchers::Registry::Global))
             continue;

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(settings, store).first;
+    return input.getAccessor(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{};
+        Input input{settings};
 
         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,88 +286,23 @@ struct CurlInputScheme : InputScheme
         return input;
     }
 
-    static const std::map<std::string, AttributeInfo> & allowedAttrsImpl()
+    StringSet allowedAttrs() const override
     {
-        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 {
+            "type",
+            "url",
+            "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{};
+        Input input{settings};
         input.attrs = attrs;
 
         // input.locked = (bool) maybeGetStrAttr(input.attrs, "hash");
@@ -384,7 +319,7 @@ struct CurlInputScheme : InputScheme
         return url;
     }
 
-    bool isLocked(const Settings & settings, const Input & input) const override
+    bool isLocked(const Input & input) const override
     {
         return (bool) input.getNarHash();
     }
@@ -397,14 +332,6 @@ 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);
@@ -413,8 +340,7 @@ struct FileInputScheme : CurlInputScheme
                                                : (!requireTree && !hasTarballExtension(url)));
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
     {
         auto input(_input);
 
@@ -422,7 +348,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, settings, getStrAttr(input.attrs, "url"), input.getName());
+        auto file = downloadFile(store, *input.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));
@@ -442,34 +368,6 @@ 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);
@@ -479,15 +377,15 @@ struct TarballInputScheme : CurlInputScheme
                                                : (requireTree || hasTarballExtension(url)));
     }
 
-    std::pair<ref<SourceAccessor>, Input>
-    getAccessor(const Settings & settings, ref<Store> store, const Input & _input) const override
+    std::pair<ref<SourceAccessor>, Input> getAccessor(ref<Store> store, const Input & _input) const override
     {
         auto input(_input);
 
-        auto result = downloadTarball_(settings, getStrAttr(input.attrs, "url"), {}, "«" + input.to_string() + "»");
+        auto result =
+            downloadTarball_(*input.settings, getStrAttr(input.attrs, "url"), {}, "«" + input.to_string() + "»");
 
         if (result.immutableUrl) {
-            auto immutableInput = Input::fromURL(settings, *result.immutableUrl);
+            auto immutableInput = Input::fromURL(*input.settings, *result.immutableUrl);
             // FIXME: would be nice to support arbitrary flakerefs
             // here, e.g. git flakes.
             if (immutableInput.getType() != "tarball")
@@ -500,7 +398,9 @@ struct TarballInputScheme : CurlInputScheme
 
         input.attrs.insert_or_assign(
             "narHash",
-            settings.getTarballCache()->treeHashToNarHash(settings, result.treeHash).to_string(HashFormat::SRI, true));
+            input.settings->getTarballCache()
+                ->treeHashToNarHash(*input.settings, result.treeHash)
+                .to_string(HashFormat::SRI, true));
 
         return {result.accessor, input};
     }

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(state.fetchSettings))
+        if (state.settings.pureEval && !flakeRef.input.isLocked())
             throw Error(
                 "cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)",
                 flakeRefS,

src/libflake/flake.cc

@@ -372,8 +372,7 @@ static Flake getFlake(
     const InputAttrPath & lockRootAttrPath)
 {
     // Fetch a lazy tree first.
-    auto cachedInput =
-        state.inputCache->getAccessor(state.fetchSettings, state.store, originalRef.input, useRegistries);
+    auto cachedInput = state.inputCache->getAccessor(state.store, originalRef.input, useRegistries);
 
     auto subdir = fetchers::maybeGetStrAttr(cachedInput.extraAttrs, "dir").value_or(originalRef.subdir);
     auto resolvedRef = FlakeRef(std::move(cachedInput.resolvedInput), subdir);
@@ -389,8 +388,7 @@ 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.fetchSettings, state.store, newLockedRef.input, fetchers::UseRegistries::No);
+        auto cachedInput2 = state.inputCache->getAccessor(state.store, newLockedRef.input, fetchers::UseRegistries::No);
         cachedInput.accessor = cachedInput2.accessor;
         lockedRef = FlakeRef(std::move(cachedInput2.lockedInput), newLockedRef.subdir);
     }
@@ -706,8 +704,7 @@ lockFlake(const Settings & settings, EvalState & state, const FlakeRef & topRef,
                            this input. */
                         debug("creating new input '%s'", inputAttrPathS);
 
-                        if (!lockFlags.allowUnlocked && !input.ref->input.isLocked(state.fetchSettings)
-                            && !input.ref->input.isRelative())
+                        if (!lockFlags.allowUnlocked && !input.ref->input.isLocked() && !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
@@ -756,7 +753,7 @@ lockFlake(const Settings & settings, EvalState & state, const FlakeRef & topRef,
                                     return {*resolvedPath, *input.ref};
                                 } else {
                                     auto cachedInput = state.inputCache->getAccessor(
-                                        state.fetchSettings, state.store, input.ref->input, useRegistriesInputs);
+                                        state.store, input.ref->input, useRegistriesInputs);
 
                                     auto lockedRef = FlakeRef(std::move(cachedInput.lockedInput), input.ref->subdir);
 

src/libflake/flakeref.cc

@@ -64,10 +64,9 @@ std::ostream & operator<<(std::ostream & str, const FlakeRef & flakeRef)
     return str;
 }
 
-FlakeRef FlakeRef::resolve(
-    const fetchers::Settings & fetchSettings, ref<Store> store, fetchers::UseRegistries useRegistries) const
+FlakeRef FlakeRef::resolve(ref<Store> store, fetchers::UseRegistries useRegistries) const
 {
-    auto [input2, extraAttrs] = lookupInRegistries(fetchSettings, store, input, useRegistries);
+    auto [input2, extraAttrs] = lookupInRegistries(store, input, useRegistries);
     return FlakeRef(std::move(input2), fetchers::maybeGetStrAttr(extraAttrs, "dir").value_or(subdir));
 }
 
@@ -288,10 +287,9 @@ FlakeRef FlakeRef::fromAttrs(const fetchers::Settings & fetchSettings, const fet
         fetchers::maybeGetStrAttr(attrs, "dir").value_or(""));
 }
 
-std::pair<ref<SourceAccessor>, FlakeRef>
-FlakeRef::lazyFetch(const fetchers::Settings & fetchSettings, ref<Store> store) const
+std::pair<ref<SourceAccessor>, FlakeRef> FlakeRef::lazyFetch(ref<Store> store) const
 {
-    auto [accessor, lockedInput] = input.getAccessor(fetchSettings, store);
+    auto [accessor, lockedInput] = input.getAccessor(store);
     return {accessor, FlakeRef(std::move(lockedInput), subdir)};
 }
 

src/libflake/include/nix/flake/flakeref.hh

@@ -71,15 +71,11 @@ struct FlakeRef
 
     fetchers::Attrs toAttrs() const;
 
-    FlakeRef resolve(
-        const fetchers::Settings & fetchSettings,
-        ref<Store> store,
-        fetchers::UseRegistries useRegistries = fetchers::UseRegistries::All) const;
+    FlakeRef resolve(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(const fetchers::Settings & fetchSettings, ref<Store> store) const;
+    std::pair<ref<SourceAccessor>, FlakeRef> lazyFetch(ref<Store> store) const;
 
     /**
      * Canonicalize a flakeref for the purpose of comparing "old" and

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(fetchSettings) && !lockedRef.input.isRelative()) {
+    if (!lockedRef.input.isLocked() && !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) || (fetchSettings.allowDirtyLocks && input.getNarHash());
+        return input.isLocked() || (fetchSettings.allowDirtyLocks && input.getNarHash());
     };
 
     for (auto & i : nodes) {

src/libstore-test-support/include/nix/store/tests/protocol.hh

@@ -6,7 +6,6 @@
 
 #include "nix/store/tests/libstore.hh"
 #include "nix/util/tests/characterization.hh"
-#include "nix/util/tests/json-characterization.hh"
 
 namespace nix {
 
@@ -17,30 +16,12 @@ class ProtoTest : public CharacterizationTest
 
     std::filesystem::path goldenMaster(std::string_view testStem) const override
     {
-        return unitTestData / testStem;
+        return unitTestData / (std::string{testStem + ".bin"});
     }
 
 public:
     Path storeDir = "/nix/store";
     StoreDirConfig store{storeDir};
-
-    /**
-     * Golden test for `T` JSON reading
-     */
-    template<typename T>
-    void readJsonTest(PathView testStem, const T & expected)
-    {
-        nix::readJsonTest(*this, testStem, expected);
-    }
-
-    /**
-     * Golden test for `T` JSON write
-     */
-    template<typename T>
-    void writeJsonTest(PathView testStem, const T & decoded)
-    {
-        nix::writeJsonTest(*this, testStem, decoded);
-    }
 };
 
 template<class Proto, const char * protocolDir>
@@ -53,7 +34,7 @@ public:
     template<typename T>
     void readProtoTest(PathView testStem, typename Proto::Version version, T expected)
     {
-        CharacterizationTest::readTest(std::string{testStem + ".bin"}, [&](const auto & encoded) {
+        CharacterizationTest::readTest(testStem, [&](const auto & encoded) {
             T got = ({
                 StringSource from{encoded};
                 Proto::template Serialise<T>::read(
@@ -74,7 +55,7 @@ public:
     template<typename T>
     void writeProtoTest(PathView testStem, typename Proto::Version version, const T & decoded)
     {
-        CharacterizationTest::writeTest(std::string{testStem + ".bin"}, [&]() {
+        CharacterizationTest::writeTest(testStem, [&]() {
             StringSink to;
             Proto::template Serialise<T>::write(
                 this->store,
@@ -88,25 +69,14 @@ public:
     }
 };
 
-#define VERSIONED_CHARACTERIZATION_TEST_NO_JSON(FIXTURE, NAME, STEM, VERSION, VALUE) \
-    TEST_F(FIXTURE, NAME##_read)                                                     \
-    {                                                                                \
-        readProtoTest(STEM, VERSION, VALUE);                                         \
-    }                                                                                \
-    TEST_F(FIXTURE, NAME##_write)                                                    \
-    {                                                                                \
-        writeProtoTest(STEM, VERSION, VALUE);                                        \
-    }
-
-#define VERSIONED_CHARACTERIZATION_TEST(FIXTURE, NAME, STEM, VERSION, VALUE)     \
-    VERSIONED_CHARACTERIZATION_TEST_NO_JSON(FIXTURE, NAME, STEM, VERSION, VALUE) \
-    TEST_F(FIXTURE, NAME##_json_read)                                            \
-    {                                                                            \
-        readJsonTest(STEM, VALUE);                                               \
-    }                                                                            \
-    TEST_F(FIXTURE, NAME##_json_write)                                           \
-    {                                                                            \
-        writeJsonTest(STEM, VALUE);                                              \
+#define VERSIONED_CHARACTERIZATION_TEST(FIXTURE, NAME, STEM, VERSION, VALUE) \
+    TEST_F(FIXTURE, NAME##_read)                                             \
+    {                                                                        \
+        readProtoTest(STEM, VERSION, VALUE);                                 \
+    }                                                                        \
+    TEST_F(FIXTURE, NAME##_write)                                            \
+    {                                                                        \
+        writeProtoTest(STEM, VERSION, VALUE);                                \
     }
 
 } // namespace nix

src/libstore-tests/common-protocol.cc

@@ -3,7 +3,6 @@
 #include <nlohmann/json.hpp>
 #include <gtest/gtest.h>
 
-#include "nix/util/json-utils.hh"
 #include "nix/store/common-protocol.hh"
 #include "nix/store/common-protocol-impl.hh"
 #include "nix/store/build-result.hh"
@@ -23,7 +22,7 @@ public:
     template<typename T>
     void readProtoTest(PathView testStem, const T & expected)
     {
-        CharacterizationTest::readTest(std::string{testStem + ".bin"}, [&](const auto & encoded) {
+        CharacterizationTest::readTest(testStem, [&](const auto & encoded) {
             T got = ({
                 StringSource from{encoded};
                 CommonProto::Serialise<T>::read(store, CommonProto::ReadConn{.from = from});
@@ -39,7 +38,7 @@ public:
     template<typename T>
     void writeProtoTest(PathView testStem, const T & decoded)
     {
-        CharacterizationTest::writeTest(std::string{testStem + ".bin"}, [&]() -> std::string {
+        CharacterizationTest::writeTest(testStem, [&]() -> std::string {
             StringSink to;
             CommonProto::Serialise<T>::write(store, CommonProto::WriteConn{.to = to}, decoded);
             return to.s;
@@ -55,14 +54,6 @@ public:
     TEST_F(CommonProtoTest, NAME##_write)        \
     {                                            \
         writeProtoTest(STEM, VALUE);             \
-    }                                            \
-    TEST_F(CommonProtoTest, NAME##_json_read)    \
-    {                                            \
-        readJsonTest(STEM, VALUE);               \
-    }                                            \
-    TEST_F(CommonProtoTest, NAME##_json_write)   \
-    {                                            \
-        writeJsonTest(STEM, VALUE);              \
     }
 
 CHARACTERIZATION_TEST(

src/libstore-tests/data/common-protocol/content-address.json

@@ -1,26 +0,0 @@
-[
-  {
-    "hash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "+Xc9Ll6mcPltwaewrk/BAQ56Y3G5T//wzhKUc0zrYu0="
-    },
-    "method": "text"
-  },
-  {
-    "hash": {
-      "algorithm": "sha1",
-      "format": "base64",
-      "hash": "gGemBoenViNZM3hiwqns/Fgzqwo="
-    },
-    "method": "flat"
-  },
-  {
-    "hash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "EMIJ+giQ/gLIWoxmPKjno3zHZrxbGymgzGGyZvZBIdM="
-    },
-    "method": "nar"
-  }
-]

src/libstore-tests/data/common-protocol/drv-output.json

@@ -1,4 +0,0 @@
-[
-  "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-  "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!quux"
-]

src/libstore-tests/data/common-protocol/optional-content-address.json

@@ -1,11 +0,0 @@
-[
-  null,
-  {
-    "hash": {
-      "algorithm": "sha1",
-      "format": "base64",
-      "hash": "gGemBoenViNZM3hiwqns/Fgzqwo="
-    },
-    "method": "flat"
-  }
-]

src/libstore-tests/data/common-protocol/optional-store-path.json

@@ -1,4 +0,0 @@
-[
-  null,
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar"
-]

src/libstore-tests/data/common-protocol/realisation-with-deps.json

@@ -1,13 +0,0 @@
-[
-  {
-    "dependentRealisations": {
-      "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!quux": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"
-    },
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": [
-      "asdf",
-      "qwer"
-    ]
-  }
-]

src/libstore-tests/data/common-protocol/realisation.json

@@ -1,17 +0,0 @@
-[
-  {
-    "dependentRealisations": {},
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": []
-  },
-  {
-    "dependentRealisations": {},
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": [
-      "asdf",
-      "qwer"
-    ]
-  }
-]

src/libstore-tests/data/common-protocol/set.json

@@ -1,22 +0,0 @@
-[
-  [],
-  [
-    ""
-  ],
-  [
-    "",
-    "bar",
-    "foo"
-  ],
-  [
-    [],
-    [
-      ""
-    ],
-    [
-      "",
-      "1",
-      "2"
-    ]
-  ]
-]

src/libstore-tests/data/common-protocol/store-path.json

@@ -1,4 +0,0 @@
-[
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar"
-]

src/libstore-tests/data/common-protocol/string.json

@@ -1,7 +0,0 @@
-[
-  "",
-  "hi",
-  "white rabbit",
-  "大白兔",
-  "oh no "
-]

src/libstore-tests/data/common-protocol/vector.json

@@ -1,22 +0,0 @@
-[
-  [],
-  [
-    ""
-  ],
-  [
-    "",
-    "foo",
-    "bar"
-  ],
-  [
-    [],
-    [
-      ""
-    ],
-    [
-      "",
-      "1",
-      "2"
-    ]
-  ]
-]

src/libstore-tests/data/serve-protocol/build-result-2.2.json

@@ -1,28 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "NotDeterministic",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "builtOutputs": {},
-    "startTime": 0,
-    "status": "Built",
-    "stopTime": 0,
-    "success": true,
-    "timesBuilt": 0
-  }
-]

src/libstore-tests/data/serve-protocol/build-result-2.3.json

@@ -1,28 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": true,
-    "startTime": 30,
-    "status": "NotDeterministic",
-    "stopTime": 50,
-    "success": false,
-    "timesBuilt": 3
-  },
-  {
-    "builtOutputs": {},
-    "startTime": 30,
-    "status": "Built",
-    "stopTime": 50,
-    "success": true,
-    "timesBuilt": 0
-  }
-]

src/libstore-tests/data/serve-protocol/build-result-2.6.json

@@ -1,41 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": true,
-    "startTime": 30,
-    "status": "NotDeterministic",
-    "stopTime": 50,
-    "success": false,
-    "timesBuilt": 3
-  },
-  {
-    "builtOutputs": {
-      "bar": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!bar",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-        "signatures": []
-      },
-      "foo": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!foo",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-        "signatures": []
-      }
-    },
-    "startTime": 30,
-    "status": "Built",
-    "stopTime": 50,
-    "success": true,
-    "timesBuilt": 1
-  }
-]

src/libstore-tests/data/serve-protocol/content-address.json

@@ -1,26 +0,0 @@
-[
-  {
-    "hash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "+Xc9Ll6mcPltwaewrk/BAQ56Y3G5T//wzhKUc0zrYu0="
-    },
-    "method": "text"
-  },
-  {
-    "hash": {
-      "algorithm": "sha1",
-      "format": "base64",
-      "hash": "gGemBoenViNZM3hiwqns/Fgzqwo="
-    },
-    "method": "flat"
-  },
-  {
-    "hash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "EMIJ+giQ/gLIWoxmPKjno3zHZrxbGymgzGGyZvZBIdM="
-    },
-    "method": "nar"
-  }
-]

src/libstore-tests/data/serve-protocol/drv-output.json

@@ -1,4 +0,0 @@
-[
-  "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-  "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!quux"
-]

src/libstore-tests/data/serve-protocol/optional-content-address.json

@@ -1,11 +0,0 @@
-[
-  null,
-  {
-    "hash": {
-      "algorithm": "sha1",
-      "format": "base64",
-      "hash": "gGemBoenViNZM3hiwqns/Fgzqwo="
-    },
-    "method": "flat"
-  }
-]

src/libstore-tests/data/serve-protocol/optional-store-path.json

@@ -1,4 +0,0 @@
-[
-  null,
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar"
-]

src/libstore-tests/data/serve-protocol/realisation-with-deps.json

@@ -1,13 +0,0 @@
-[
-  {
-    "dependentRealisations": {
-      "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!quux": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"
-    },
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": [
-      "asdf",
-      "qwer"
-    ]
-  }
-]

src/libstore-tests/data/serve-protocol/realisation.json

@@ -1,17 +0,0 @@
-[
-  {
-    "dependentRealisations": {},
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": []
-  },
-  {
-    "dependentRealisations": {},
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": [
-      "asdf",
-      "qwer"
-    ]
-  }
-]

src/libstore-tests/data/serve-protocol/set.json

@@ -1,22 +0,0 @@
-[
-  [],
-  [
-    ""
-  ],
-  [
-    "",
-    "bar",
-    "foo"
-  ],
-  [
-    [],
-    [
-      ""
-    ],
-    [
-      "",
-      "1",
-      "2"
-    ]
-  ]
-]

src/libstore-tests/data/serve-protocol/store-path.json

@@ -1,4 +0,0 @@
-[
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar"
-]

src/libstore-tests/data/serve-protocol/string.json

@@ -1,7 +0,0 @@
-[
-  "",
-  "hi",
-  "white rabbit",
-  "大白兔",
-  "oh no "
-]

src/libstore-tests/data/serve-protocol/unkeyed-valid-path-info-2.3.json

@@ -1,34 +0,0 @@
-[
-  {
-    "ca": null,
-    "deriver": null,
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
-    },
-    "narSize": 34878,
-    "references": [],
-    "registrationTime": null,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  },
-  {
-    "ca": null,
-    "deriver": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
-    },
-    "narSize": 34878,
-    "references": [
-      "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo.drv"
-    ],
-    "registrationTime": null,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  }
-]

src/libstore-tests/data/serve-protocol/unkeyed-valid-path-info-2.4.json

@@ -1,47 +0,0 @@
-[
-  {
-    "ca": null,
-    "deriver": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "references": [
-      "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo.drv"
-    ],
-    "registrationTime": null,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  },
-  {
-    "ca": {
-      "hash": {
-        "algorithm": "sha256",
-        "format": "base64",
-        "hash": "EMIJ+giQ/gLIWoxmPKjno3zHZrxbGymgzGGyZvZBIdM="
-      },
-      "method": "nar"
-    },
-    "deriver": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "references": [
-      "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-      "n5wkd9frr45pa74if5gpz9j7mifg27fh-foo"
-    ],
-    "registrationTime": null,
-    "signatures": [
-      "fake-sig-1",
-      "fake-sig-2"
-    ],
-    "ultimate": false,
-    "version": 2
-  }
-]

src/libstore-tests/data/serve-protocol/vector.json

@@ -1,22 +0,0 @@
-[
-  [],
-  [
-    ""
-  ],
-  [
-    "",
-    "foo",
-    "bar"
-  ],
-  [
-    [],
-    [
-      ""
-    ],
-    [
-      "",
-      "1",
-      "2"
-    ]
-  ]
-]

src/libstore-tests/data/worker-protocol/build-mode.json

@@ -1,5 +0,0 @@
-[
-  0,
-  1,
-  2
-]

src/libstore-tests/data/worker-protocol/build-result-1.27.json

@@ -1,28 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "NotDeterministic",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "builtOutputs": {},
-    "startTime": 0,
-    "status": "Built",
-    "stopTime": 0,
-    "success": true,
-    "timesBuilt": 0
-  }
-]

src/libstore-tests/data/worker-protocol/build-result-1.28.json

@@ -1,41 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "NotDeterministic",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "builtOutputs": {
-      "bar": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!bar",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-        "signatures": []
-      },
-      "foo": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!foo",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-        "signatures": []
-      }
-    },
-    "startTime": 0,
-    "status": "Built",
-    "stopTime": 0,
-    "success": true,
-    "timesBuilt": 0
-  }
-]

src/libstore-tests/data/worker-protocol/build-result-1.29.json

@@ -1,41 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": true,
-    "startTime": 30,
-    "status": "NotDeterministic",
-    "stopTime": 50,
-    "success": false,
-    "timesBuilt": 3
-  },
-  {
-    "builtOutputs": {
-      "bar": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!bar",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-        "signatures": []
-      },
-      "foo": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!foo",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-        "signatures": []
-      }
-    },
-    "startTime": 30,
-    "status": "Built",
-    "stopTime": 50,
-    "success": true,
-    "timesBuilt": 1
-  }
-]

src/libstore-tests/data/worker-protocol/build-result-1.37.json

@@ -1,43 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": true,
-    "startTime": 30,
-    "status": "NotDeterministic",
-    "stopTime": 50,
-    "success": false,
-    "timesBuilt": 3
-  },
-  {
-    "builtOutputs": {
-      "bar": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!bar",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-        "signatures": []
-      },
-      "foo": {
-        "dependentRealisations": {},
-        "id": "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!foo",
-        "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-        "signatures": []
-      }
-    },
-    "cpuSystem": 604000000,
-    "cpuUser": 500000000,
-    "startTime": 30,
-    "status": "Built",
-    "stopTime": 50,
-    "success": true,
-    "timesBuilt": 1
-  }
-]

src/libstore-tests/data/worker-protocol/content-address.json

@@ -1,26 +0,0 @@
-[
-  {
-    "hash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "+Xc9Ll6mcPltwaewrk/BAQ56Y3G5T//wzhKUc0zrYu0="
-    },
-    "method": "text"
-  },
-  {
-    "hash": {
-      "algorithm": "sha1",
-      "format": "base64",
-      "hash": "gGemBoenViNZM3hiwqns/Fgzqwo="
-    },
-    "method": "flat"
-  },
-  {
-    "hash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "EMIJ+giQ/gLIWoxmPKjno3zHZrxbGymgzGGyZvZBIdM="
-    },
-    "method": "nar"
-  }
-]

src/libstore-tests/data/worker-protocol/derived-path-1.29.json

@@ -1,16 +0,0 @@
-[
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-  {
-    "drvPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "outputs": [
-      "*"
-    ]
-  },
-  {
-    "drvPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "outputs": [
-      "x",
-      "y"
-    ]
-  }
-]

src/libstore-tests/data/worker-protocol/derived-path-1.30.json

@@ -1,17 +0,0 @@
-[
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv",
-  {
-    "drvPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "outputs": [
-      "*"
-    ]
-  },
-  {
-    "drvPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "outputs": [
-      "x",
-      "y"
-    ]
-  }
-]

src/libstore-tests/data/worker-protocol/drv-output.json

@@ -1,4 +0,0 @@
-[
-  "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-  "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!quux"
-]

src/libstore-tests/data/worker-protocol/keyed-build-result-1.29.json

@@ -1,27 +0,0 @@
-[
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": false,
-    "path": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-xxx",
-    "startTime": 0,
-    "status": "OutputRejected",
-    "stopTime": 0,
-    "success": false,
-    "timesBuilt": 0
-  },
-  {
-    "errorMsg": "no idea why",
-    "isNonDeterministic": true,
-    "path": {
-      "drvPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-      "outputs": [
-        "out"
-      ]
-    },
-    "startTime": 30,
-    "status": "NotDeterministic",
-    "stopTime": 50,
-    "success": false,
-    "timesBuilt": 3
-  }
-]

src/libstore-tests/data/worker-protocol/optional-content-address.json

@@ -1,11 +0,0 @@
-[
-  null,
-  {
-    "hash": {
-      "algorithm": "sha1",
-      "format": "base64",
-      "hash": "gGemBoenViNZM3hiwqns/Fgzqwo="
-    },
-    "method": "flat"
-  }
-]

src/libstore-tests/data/worker-protocol/optional-store-path.json

@@ -1,4 +0,0 @@
-[
-  null,
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar"
-]

src/libstore-tests/data/worker-protocol/optional-trusted-flag.json

@@ -1,5 +0,0 @@
-[
-  null,
-  true,
-  false
-]

src/libstore-tests/data/worker-protocol/realisation-with-deps.json

@@ -1,13 +0,0 @@
-[
-  {
-    "dependentRealisations": {
-      "sha256:6f869f9ea2823bda165e06076fd0de4366dead2c0e8d2dbbad277d4f15c373f5!quux": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"
-    },
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": [
-      "asdf",
-      "qwer"
-    ]
-  }
-]

src/libstore-tests/data/worker-protocol/realisation.json

@@ -1,17 +0,0 @@
-[
-  {
-    "dependentRealisations": {},
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": []
-  },
-  {
-    "dependentRealisations": {},
-    "id": "sha256:15e3c560894cbb27085cf65b5a2ecb18488c999497f4531b6907a7581ce6d527!baz",
-    "outPath": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-    "signatures": [
-      "asdf",
-      "qwer"
-    ]
-  }
-]

src/libstore-tests/data/worker-protocol/set.json

@@ -1,22 +0,0 @@
-[
-  [],
-  [
-    ""
-  ],
-  [
-    "",
-    "bar",
-    "foo"
-  ],
-  [
-    [],
-    [
-      ""
-    ],
-    [
-      "",
-      "1",
-      "2"
-    ]
-  ]
-]

src/libstore-tests/data/worker-protocol/store-path.json

@@ -1,4 +0,0 @@
-[
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo",
-  "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar"
-]

src/libstore-tests/data/worker-protocol/string.json

@@ -1,7 +0,0 @@
-[
-  "",
-  "hi",
-  "white rabbit",
-  "大白兔",
-  "oh no "
-]

src/libstore-tests/data/worker-protocol/unkeyed-valid-path-info-1.15.json

@@ -1,34 +0,0 @@
-[
-  {
-    "ca": null,
-    "deriver": null,
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "references": [],
-    "registrationTime": 23423,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  },
-  {
-    "ca": null,
-    "deriver": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "references": [
-      "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo.drv"
-    ],
-    "registrationTime": 23423,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  }
-]

src/libstore-tests/data/worker-protocol/valid-path-info-1.15.json

@@ -1,37 +0,0 @@
-[
-  {
-    "ca": null,
-    "deriver": null,
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "path": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-    "references": [],
-    "registrationTime": 23423,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  },
-  {
-    "ca": null,
-    "deriver": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "path": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-    "references": [
-      "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-      "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo"
-    ],
-    "registrationTime": 23423,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  }
-]

src/libstore-tests/data/worker-protocol/valid-path-info-1.16.json

@@ -1,66 +0,0 @@
-[
-  {
-    "ca": null,
-    "deriver": null,
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "path": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-    "references": [],
-    "registrationTime": 23423,
-    "signatures": [],
-    "ultimate": true,
-    "version": 2
-  },
-  {
-    "ca": null,
-    "deriver": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "path": "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-    "references": [
-      "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-      "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo"
-    ],
-    "registrationTime": 23423,
-    "signatures": [
-      "fake-sig-1",
-      "fake-sig-2"
-    ],
-    "ultimate": false,
-    "version": 2
-  },
-  {
-    "ca": {
-      "hash": {
-        "algorithm": "sha256",
-        "format": "base64",
-        "hash": "EMIJ+giQ/gLIWoxmPKjno3zHZrxbGymgzGGyZvZBIdM="
-      },
-      "method": "nar"
-    },
-    "deriver": null,
-    "narHash": {
-      "algorithm": "sha256",
-      "format": "base64",
-      "hash": "FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="
-    },
-    "narSize": 34878,
-    "path": "n5wkd9frr45pa74if5gpz9j7mifg27fh-foo",
-    "references": [
-      "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
-      "n5wkd9frr45pa74if5gpz9j7mifg27fh-foo"
-    ],
-    "registrationTime": 23423,
-    "signatures": [],
-    "ultimate": false,
-    "version": 2
-  }
-]