WIP get rid of global Settings in libstore

This is analogous to 52bfccf8d8 for
`EvalSettings`, and 3fc77f281e for
`FlakeSettings` and `fetchers::Settings`.

src/libcmd/command.cc

@@ -4,6 +4,7 @@
 #include "nix/cmd/command.hh"
 #include "nix/cmd/legacy.hh"
 #include "nix/cmd/markdown.hh"
+#include "nix/main/shared.hh"
 #include "nix/store/globals.hh"
 #include "nix/store/store-open.hh"
 #include "nix/store/local-fs-store.hh"
@@ -75,7 +76,7 @@ ref<StoreConfig> StoreConfigCommand::getStoreConfig()
 
 ref<StoreConfig> StoreConfigCommand::createStoreConfig()
 {
-    return resolveStoreConfig(StoreReference{settings.storeUri.get()});
+    return resolveStoreConfig(settings, StoreReference{settings.storeUri.get()});
 }
 
 void StoreConfigCommand::run()
@@ -129,7 +130,7 @@ CopyCommand::CopyCommand()
 
 ref<StoreConfig> CopyCommand::createStoreConfig()
 {
-    return !srcUri ? StoreCommand::createStoreConfig() : resolveStoreConfig(StoreReference{*srcUri});
+    return !srcUri ? StoreCommand::createStoreConfig() : resolveStoreConfig(settings, StoreReference{*srcUri});
 }
 
 ref<Store> CopyCommand::getDstStore()
@@ -137,7 +138,7 @@ ref<Store> CopyCommand::getDstStore()
     if (!srcUri && !dstUri)
         throw UsageError("you must pass '--from' and/or '--to'");
 
-    return !dstUri ? openStore() : openStore(StoreReference{*dstUri});
+    return !dstUri ? openStore(settings) : openStore(settings, StoreReference{*dstUri});
 }
 
 EvalCommand::EvalCommand()
@@ -159,7 +160,7 @@ EvalCommand::~EvalCommand()
 ref<Store> EvalCommand::getEvalStore()
 {
     if (!evalStore)
-        evalStore = evalStoreUrl ? openStore(StoreReference{*evalStoreUrl}) : getStore();
+        evalStore = evalStoreUrl ? openStore(settings, StoreReference{*evalStoreUrl}) : getStore();
     return ref<Store>(evalStore);
 }
 

src/libcmd/common-eval-args.cc

@@ -19,12 +19,12 @@
 
 namespace nix {
 
-fetchers::Settings fetchSettings;
+fetchers::Settings fetchSettings{settings};
 
 static GlobalConfig::Register rFetchSettings(&fetchSettings);
 
 EvalSettings evalSettings{
-    settings.readOnlyMode,
+    settings,
     {
         {
             "flake",
@@ -135,7 +135,7 @@ MixEvalArgs::MixEvalArgs()
             fetchers::overrideRegistry(from.input, to.input, extraAttrs);
         }},
         .completer = {[&](AddCompletions & completions, size_t, std::string_view prefix) {
-            completeFlakeRef(completions, openStore(), prefix);
+            completeFlakeRef(completions, openStore(settings), prefix);
         }},
     });
 

src/libcmd/get-build-log.cc

@@ -4,9 +4,9 @@
 
 namespace nix {
 
-std::string fetchBuildLog(ref<Store> store, const StorePath & path, std::string_view what)
+std::string fetchBuildLog(Settings & settings, ref<Store> store, const StorePath & path, std::string_view what)
 {
-    auto subs = getDefaultSubstituters();
+    auto subs = getDefaultSubstituters(settings);
 
     subs.push_front(store);
 

src/libcmd/include/nix/cmd/get-build-log.hh

@@ -8,6 +8,8 @@
 
 namespace nix {
 
+class Settings;
+
 /**
  * Fetch the build log for a store path, searching the store and its
  * substituters.
@@ -18,6 +20,6 @@ namespace nix {
  * @return The build log content.
  * @throws Error if the build log is not available.
  */
-std::string fetchBuildLog(ref<Store> store, const StorePath & path, std::string_view what);
+std::string fetchBuildLog(Settings & settings, ref<Store> store, const StorePath & path, std::string_view what);
 
 } // namespace nix

src/libcmd/include/nix/cmd/installable-attr-path.hh

@@ -1,7 +1,6 @@
 #pragma once
 ///@file
 
-#include "nix/store/globals.hh"
 #include "nix/cmd/installable-value.hh"
 #include "nix/store/outputs-spec.hh"
 #include "nix/cmd/command.hh"

src/libcmd/repl.cc

@@ -564,7 +564,7 @@ ProcessLineResult NixRepl::processLine(std::string line)
             settings.readOnlyMode = true;
             Finally roModeReset([&]() { settings.readOnlyMode = false; });
             RunPager pager;
-            auto log = fetchBuildLog(state->store, drvPath, drvPathRaw);
+            auto log = fetchBuildLog(settings, state->store, drvPath, drvPathRaw);
             logger->writeToStdout(log);
         } else {
             runNix("nix-shell", {drvPathRaw});

src/libexpr-c/nix_api_expr.cc

@@ -132,9 +132,8 @@ nix_eval_state_builder * nix_eval_state_builder_new(nix_c_context * context, Sto
         return unsafe_new_with_self<nix_eval_state_builder>([&](auto * self) {
             return nix_eval_state_builder{
                 .store = nix::ref<nix::Store>(store->ptr),
-                .settings = nix::EvalSettings{/* &bool */ self->readOnlyMode},
-                .fetchSettings = nix::fetchers::Settings{},
-                .readOnlyMode = true,
+                .settings = nix::EvalSettings{cStoreSettings},
+                .fetchSettings = nix::fetchers::Settings{cStoreSettings},
             };
         });
     }
@@ -153,8 +152,7 @@ nix_err nix_eval_state_builder_load(nix_c_context * context, nix_eval_state_buil
     if (context)
         context->last_err_code = NIX_OK;
     try {
-        // TODO: load in one go?
-        builder->settings.readOnlyMode = nix::settings.readOnlyMode;
+        loadConfFile(cStoreSettings);
         loadConfFile(builder->settings);
         loadConfFile(builder->fetchSettings);
     }

src/libexpr-c/nix_api_expr_internal.h

@@ -16,8 +16,6 @@ struct nix_eval_state_builder
     nix::EvalSettings settings;
     nix::fetchers::Settings fetchSettings;
     nix::LookupPath lookupPath;
-    // TODO: make an EvalSettings setting own this instead?
-    bool readOnlyMode;
 };
 
 struct EvalState

src/libexpr-test-support/include/nix/expr/tests/libexpr.hh

@@ -26,18 +26,18 @@ public:
     }
 
 protected:
-    LibExprTest(ref<Store> store, auto && makeEvalSettings)
-        : LibStoreTest()
-        , evalSettings(makeEvalSettings(readOnlyMode))
+    LibExprTest(auto && makeEvalSettings, auto &&... args)
+        : LibStoreTest(args...)
+        , evalSettings(makeEvalSettings(settings))
         , state({}, store, fetchSettings, evalSettings, nullptr)
     {
     }
 
     LibExprTest()
-        : LibExprTest(openStore("dummy://"), [](bool & readOnlyMode) {
-            EvalSettings settings{readOnlyMode};
-            settings.nixPath = {};
-            return settings;
+        : LibExprTest([](Settings & settings) {
+            EvalSettings evalSettings{settings};
+            evalSettings.nixPath = {};
+            return evalSettings;
         })
     {
     }
@@ -66,8 +66,8 @@ protected:
     }
 
     bool readOnlyMode = true;
-    fetchers::Settings fetchSettings{};
-    EvalSettings evalSettings{readOnlyMode};
+    fetchers::Settings fetchSettings{settings};
+    EvalSettings evalSettings{settings};
     EvalState state;
 };
 

src/libexpr-tests/eval.cc

@@ -179,12 +179,15 @@ class PureEvalTest : public LibExprTest
 {
 public:
     PureEvalTest()
-        : LibExprTest(openStore("dummy://", {{"read-only", "false"}}), [](bool & readOnlyMode) {
-            EvalSettings settings{readOnlyMode};
-            settings.pureEval = true;
-            settings.restrictEval = true;
-            return settings;
-        })
+        : LibExprTest{
+              [](auto & settings) {
+                  EvalSettings evalSettings{settings};
+                  evalSettings.pureEval = true;
+                  evalSettings.restrictEval = true;
+                  return evalSettings;
+              },
+              [](auto & settings) { return openStore(settings, "dummy://", {{"read-only", "false"}}); },
+          }
     {
     }
 };

src/libexpr/eval-cache.cc

@@ -63,7 +63,7 @@ struct AttrDb
 
     SymbolTable & symbols;
 
-    AttrDb(const StoreDirConfig & cfg, const Hash & fingerprint, SymbolTable & symbols)
+    AttrDb(bool useSQLiteWAL, const StoreDirConfig & cfg, const Hash & fingerprint, SymbolTable & symbols)
         : cfg(cfg)
         , _state(std::make_unique<Sync<State>>())
         , symbols(symbols)
@@ -75,7 +75,7 @@ struct AttrDb
 
         auto dbPath = cacheDir / (fingerprint.to_string(HashFormat::Base16, false) + ".sqlite");
 
-        state->db = SQLite(dbPath, {.useWAL = settings.useSQLiteWAL});
+        state->db = SQLite(dbPath, {.useWAL = useSQLiteWAL});
         state->db.isCache();
         state->db.exec(schema);
 
@@ -287,10 +287,11 @@ struct AttrDb
     }
 };
 
-static std::shared_ptr<AttrDb> makeAttrDb(const StoreDirConfig & cfg, const Hash & fingerprint, SymbolTable & symbols)
+static std::shared_ptr<AttrDb>
+makeAttrDb(bool useSQLiteWAL, const StoreDirConfig & cfg, const Hash & fingerprint, SymbolTable & symbols)
 {
     try {
-        return std::make_shared<AttrDb>(cfg, fingerprint, symbols);
+        return std::make_shared<AttrDb>(useSQLiteWAL, cfg, fingerprint, symbols);
     } catch (SQLiteError &) {
         ignoreExceptionExceptInterrupt();
         return nullptr;
@@ -299,7 +300,8 @@ static std::shared_ptr<AttrDb> makeAttrDb(const StoreDirConfig & cfg, const Hash
 
 EvalCache::EvalCache(
     std::optional<std::reference_wrapper<const Hash>> useCache, EvalState & state, RootLoader rootLoader)
-    : db(useCache ? makeAttrDb(*state.store, *useCache, state.symbols) : nullptr)
+    : db(useCache ? makeAttrDb(state.store->config.settings.useSQLiteWAL, *state.store, *useCache, state.symbols)
+                  : nullptr)
     , state(state)
     , rootLoader(rootLoader)
 {
@@ -707,7 +709,7 @@ StorePath AttrCursor::forceDerivation()
     auto aDrvPath = getAttr(root->state.s.drvPath);
     auto drvPath = root->state.store->parseStorePath(aDrvPath->getString());
     drvPath.requireDerivation();
-    if (!root->state.store->isValidPath(drvPath) && !settings.readOnlyMode) {
+    if (!root->state.store->isValidPath(drvPath) && !root->state.store->config.settings.readOnlyMode) {
         /* The eval cache contains 'drvPath', but the actual path has
            been garbage-collected. So force it to be regenerated. */
         aDrvPath->forceValue();

src/libexpr/eval-settings.cc

@@ -48,8 +48,8 @@ Strings EvalSettings::parseNixPath(const std::string & s)
     return res;
 }
 
-EvalSettings::EvalSettings(bool & readOnlyMode, EvalSettings::LookupPathHooks lookupPathHooks)
-    : readOnlyMode{readOnlyMode}
+EvalSettings::EvalSettings(nix::Settings & storeSettings, EvalSettings::LookupPathHooks lookupPathHooks)
+    : storeSettings{storeSettings}
     , lookupPathHooks{lookupPathHooks}
 {
     auto var = getEnv("NIX_ABORT_ON_WARN");
@@ -57,7 +57,7 @@ EvalSettings::EvalSettings(bool & readOnlyMode, EvalSettings::LookupPathHooks lo
         builtinsAbortOnWarn = true;
 }
 
-Strings EvalSettings::getDefaultNixPath()
+Strings EvalSettings::getDefaultNixPath(nix::Settings & settings)
 {
     Strings res;
     auto add = [&](const std::filesystem::path & p, const std::string & s = std::string()) {
@@ -70,7 +70,7 @@ Strings EvalSettings::getDefaultNixPath()
         }
     };
 
-    add(std::filesystem::path{getNixDefExpr()} / "channels");
+    add(std::filesystem::path{getNixDefExpr(settings)} / "channels");
     auto profilesDirOpts = settings.getProfileDirsOptions();
     add(rootChannelsDir(profilesDirOpts) / "nixpkgs", "nixpkgs");
     add(rootChannelsDir(profilesDirOpts));
@@ -101,10 +101,10 @@ std::string EvalSettings::resolvePseudoUrl(std::string_view url)
 const std::string & EvalSettings::getCurrentSystem() const
 {
     const auto & evalSystem = currentSystem.get();
-    return evalSystem != "" ? evalSystem : settings.thisSystem.get();
+    return evalSystem != "" ? evalSystem : storeSettings.thisSystem.get();
 }
 
-std::filesystem::path getNixDefExpr()
+std::filesystem::path getNixDefExpr(const Settings & settings)
 {
     return settings.useXDGBaseDirectories ? getStateDir() / "defexpr" : getHome() / ".nix-defexpr";
 }

src/libexpr/eval.cc

@@ -15,6 +15,7 @@
 #include "nix/store/filetransfer.hh"
 #include "nix/expr/function-trace.hh"
 #include "nix/store/profiles.hh"
+#include "nix/store/globals.hh"
 #include "nix/expr/print.hh"
 #include "nix/fetchers/filtering-source-accessor.hh"
 #include "nix/util/memory-source-accessor.hh"
@@ -330,7 +331,7 @@ EvalState::EvalState(
             lookupPath.elements.emplace_back(LookupPath::Elem::parse(i));
         }
         if (!settings.restrictEval) {
-            for (auto & i : EvalSettings::getDefaultNixPath()) {
+            for (auto & i : EvalSettings::getDefaultNixPath(store->config.settings)) {
                 lookupPath.elements.emplace_back(LookupPath::Elem::parse(i));
             }
         }
@@ -2508,7 +2509,7 @@ StorePath EvalState::copyPathToStore(NixStringContext & context, const SourcePat
             fetchSettings,
             *store,
             path.resolveSymlinks(SymlinkResolution::Ancestors),
-            settings.readOnlyMode ? FetchMode::DryRun : FetchMode::Copy,
+            settings.storeSettings.readOnlyMode ? FetchMode::DryRun : FetchMode::Copy,
             path.baseName(),
             ContentAddressMethod::Raw::NixArchive,
             nullptr,

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

@@ -9,9 +9,15 @@ namespace nix {
 
 class EvalState;
 struct PrimOp;
+class Settings;
 
 struct EvalSettings : Config
 {
+    /**
+     * Reference to the "parent" store-layer settings.
+     */
+    nix::Settings & storeSettings;
+
     /**
      * Function used to interpret look path entries of a given scheme.
      *
@@ -38,11 +44,9 @@ struct EvalSettings : Config
      */
     using LookupPathHooks = std::map<std::string, std::function<LookupPathHook>>;
 
-    EvalSettings(bool & readOnlyMode, LookupPathHooks lookupPathHooks = {});
+    EvalSettings(nix::Settings & settings, LookupPathHooks lookupPathHooks = {});
 
-    bool & readOnlyMode;
-
-    static Strings getDefaultNixPath();
+    static Strings getDefaultNixPath(nix::Settings & settings);
 
     static bool isPseudoUrl(std::string_view s);
 
@@ -366,6 +370,6 @@ struct EvalSettings : Config
 /**
  * Conventionally part of the default nix path in impure mode.
  */
-std::filesystem::path getNixDefExpr();
+std::filesystem::path getNixDefExpr(const Settings & settings);
 
 } // namespace nix

src/libexpr/primops.cc

@@ -1819,8 +1819,8 @@ static void derivationStrictInternal(EvalState & state, std::string_view drvName
        Unless we are in read-only mode, that is, in which case we do not
        write anything. Users commonly do this to speed up evaluation in
        contexts where they don't actually want to build anything. */
-    auto drvPath =
-        settings.readOnlyMode ? computeStorePath(*state.store, drv) : state.store->writeDerivation(drv, state.repair);
+    auto drvPath = state.settings.storeSettings.readOnlyMode ? computeStorePath(*state.store, drv)
+                                                             : state.store->writeDerivation(drv, state.repair);
     auto drvPathS = state.store->printStorePath(drvPath);
 
     printMsg(lvlChatty, "instantiated '%1%' -> '%2%'", drvName, drvPathS);
@@ -1935,7 +1935,7 @@ static void prim_storePath(EvalState & state, const PosIdx pos, Value ** args, V
     if (!state.store->isInStore(path.abs()))
         state.error<EvalError>("path '%1%' is not in the Nix store", path).atPos(pos).debugThrow();
     auto path2 = state.store->toStorePath(path.abs()).first;
-    if (!settings.readOnlyMode)
+    if (!state.settings.storeSettings.readOnlyMode)
         state.store->ensurePath(path2);
     context.insert(NixStringContextElem::Opaque{.path = path2});
     v.mkString(path.abs(), context, state.mem);
@@ -2676,23 +2676,24 @@ static void prim_toFile(EvalState & state, const PosIdx pos, Value ** args, Valu
                 .debugThrow();
     }
 
-    auto storePath = settings.readOnlyMode ? state.store->makeFixedOutputPathFromCA(
-                                                 name,
-                                                 TextInfo{
-                                                     .hash = hashString(HashAlgorithm::SHA256, contents),
-                                                     .references = std::move(refs),
-                                                 })
-                                           : ({
-                                                 StringSource s{contents};
-                                                 state.store->addToStoreFromDump(
-                                                     s,
-                                                     name,
-                                                     FileSerialisationMethod::Flat,
-                                                     ContentAddressMethod::Raw::Text,
-                                                     HashAlgorithm::SHA256,
-                                                     refs,
-                                                     state.repair);
-                                             });
+    auto storePath = state.settings.storeSettings.readOnlyMode
+                         ? state.store->makeFixedOutputPathFromCA(
+                               name,
+                               TextInfo{
+                                   .hash = hashString(HashAlgorithm::SHA256, contents),
+                                   .references = std::move(refs),
+                               })
+                         : ({
+                               StringSource s{contents};
+                               state.store->addToStoreFromDump(
+                                   s,
+                                   name,
+                                   FileSerialisationMethod::Flat,
+                                   ContentAddressMethod::Raw::Text,
+                                   HashAlgorithm::SHA256,
+                                   refs,
+                                   state.repair);
+                           });
 
     /* Note: we don't need to add `context' to the context of the
        result, since `storePath' itself has references to the paths
@@ -2836,23 +2837,24 @@ static void addPath(
 
         if (!expectedHash || !state.store->isValidPath(*expectedStorePath)) {
             // FIXME: support refs in fetchToStore()?
-            auto dstPath = refs.empty() ? fetchToStore(
-                                              state.fetchSettings,
-                                              *state.store,
-                                              path.resolveSymlinks(),
-                                              settings.readOnlyMode ? FetchMode::DryRun : FetchMode::Copy,
-                                              name,
-                                              method,
-                                              filter.get(),
-                                              state.repair)
-                                        : state.store->addToStore(
-                                              name,
-                                              path.resolveSymlinks(),
-                                              method,
-                                              HashAlgorithm::SHA256,
-                                              refs,
-                                              filter ? *filter.get() : defaultPathFilter,
-                                              state.repair);
+            auto dstPath = refs.empty()
+                               ? fetchToStore(
+                                     state.fetchSettings,
+                                     *state.store,
+                                     path.resolveSymlinks(),
+                                     state.settings.storeSettings.readOnlyMode ? FetchMode::DryRun : FetchMode::Copy,
+                                     name,
+                                     method,
+                                     filter.get(),
+                                     state.repair)
+                               : state.store->addToStore(
+                                     name,
+                                     path.resolveSymlinks(),
+                                     method,
+                                     HashAlgorithm::SHA256,
+                                     refs,
+                                     filter ? *filter.get() : defaultPathFilter,
+                                     state.repair);
             if (expectedHash && expectedStorePath != dstPath)
                 state.error<EvalError>("store path mismatch in (possibly filtered) path added from '%s'", path)
                     .atPos(pos)

src/libexpr/primops/context.cc

@@ -271,7 +271,7 @@ static void prim_appendContext(EvalState & state, const PosIdx pos, Value ** arg
         if (!state.store->isStorePath(name))
             state.error<EvalError>("context key '%s' is not a store path", name).atPos(i.pos).debugThrow();
         auto namePath = state.store->parseStorePath(name);
-        if (!settings.readOnlyMode)
+        if (!state.settings.storeSettings.readOnlyMode)
             state.store->ensurePath(namePath);
         state.forceAttrs(*i.value, i.pos, "while evaluating the value of a string context");
 

src/libexpr/primops/fetchClosure.cc

@@ -209,7 +209,7 @@ static void prim_fetchClosure(EvalState & state, const PosIdx pos, Value ** args
             {.msg = HintFmt("'fetchClosure' does not support URL query parameters (in '%s')", *fromStoreUrl),
              .pos = state.positions[pos]});
 
-    auto fromStore = openStore(std::move(storeRef));
+    auto fromStore = openStore(state.settings.storeSettings, std::move(storeRef));
 
     if (toPath)
         runFetchClosureWithRewrite(state, pos, *fromStore, *fromPath, *toPath, v);

src/libfetchers-c/nix_api_fetchers.cc

@@ -1,13 +1,14 @@
 #include "nix_api_fetchers.h"
 #include "nix_api_fetchers_internal.hh"
 #include "nix_api_util_internal.h"
+#include "nix_api_store_internal.h"
 
 extern "C" {
 
 nix_fetchers_settings * nix_fetchers_settings_new(nix_c_context * context)
 {
     try {
-        auto fetchersSettings = nix::make_ref<nix::fetchers::Settings>(nix::fetchers::Settings{});
+        auto fetchersSettings = nix::make_ref<nix::fetchers::Settings>(nix::fetchers::Settings{cStoreSettings});
         return new nix_fetchers_settings{
             .settings = fetchersSettings,
         };

src/libfetchers-tests/access-tokens.cc

@@ -1,9 +1,12 @@
 #include <nlohmann/json.hpp>
 #include <gtest/gtest.h>
 
+#include "nix/util/json-utils.hh"
+#include "nix/store/globals.hh"
 #include "nix/fetchers/fetchers.hh"
 #include "nix/fetchers/fetch-settings.hh"
-#include "nix/util/json-utils.hh"
+
+#include "nix/store/tests/test-main.hh"
 #include "nix/util/tests/characterization.hh"
 
 namespace nix::fetchers {
@@ -25,7 +28,8 @@ public:
 
 TEST_F(AccessKeysTest, singleOrgGitHub)
 {
-    fetchers::Settings fetchSettings = fetchers::Settings{};
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings = fetchers::Settings{settings};
     fetchSettings.accessTokens.get().insert({"github.com/a", "token"});
     auto i = Input::fromURL(fetchSettings, "github:a/b");
 
@@ -35,7 +39,8 @@ TEST_F(AccessKeysTest, singleOrgGitHub)
 
 TEST_F(AccessKeysTest, nonMatches)
 {
-    fetchers::Settings fetchSettings = fetchers::Settings{};
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings = fetchers::Settings{settings};
     fetchSettings.accessTokens.get().insert({"github.com", "token"});
     auto i = Input::fromURL(fetchSettings, "gitlab:github.com/evil");
 
@@ -45,7 +50,8 @@ TEST_F(AccessKeysTest, nonMatches)
 
 TEST_F(AccessKeysTest, noPartialMatches)
 {
-    fetchers::Settings fetchSettings = fetchers::Settings{};
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings = fetchers::Settings{settings};
     fetchSettings.accessTokens.get().insert({"github.com/partial", "token"});
     auto i = Input::fromURL(fetchSettings, "github:partial-match/repo");
 
@@ -55,7 +61,8 @@ TEST_F(AccessKeysTest, noPartialMatches)
 
 TEST_F(AccessKeysTest, repoGitHub)
 {
-    fetchers::Settings fetchSettings = fetchers::Settings{};
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings = fetchers::Settings{settings};
     fetchSettings.accessTokens.get().insert({"github.com", "token"});
     fetchSettings.accessTokens.get().insert({"github.com/a/b", "another_token"});
     fetchSettings.accessTokens.get().insert({"github.com/a/c", "yet_another_token"});
@@ -73,7 +80,8 @@ TEST_F(AccessKeysTest, repoGitHub)
 
 TEST_F(AccessKeysTest, multipleGitLab)
 {
-    fetchers::Settings fetchSettings = fetchers::Settings{};
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings = fetchers::Settings{settings};
     fetchSettings.accessTokens.get().insert({"gitlab.com", "token"});
     fetchSettings.accessTokens.get().insert({"gitlab.com/a/b", "another_token"});
     auto i = Input::fromURL(fetchSettings, "gitlab:a/b");
@@ -87,7 +95,8 @@ TEST_F(AccessKeysTest, multipleGitLab)
 
 TEST_F(AccessKeysTest, multipleSourceHut)
 {
-    fetchers::Settings fetchSettings = fetchers::Settings{};
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings = fetchers::Settings{settings};
     fetchSettings.accessTokens.get().insert({"git.sr.ht", "token"});
     fetchSettings.accessTokens.get().insert({"git.sr.ht/~a/b", "another_token"});
     auto i = Input::fromURL(fetchSettings, "sourcehut:a/b");

src/libfetchers-tests/git.cc

@@ -5,6 +5,8 @@
 #include "nix/fetchers/fetchers.hh"
 #include "nix/fetchers/git-utils.hh"
 
+#include "nix/store/tests/test-main.hh"
+
 #include <git2.h>
 #include <gtest/gtest.h>
 
@@ -180,13 +182,15 @@ TEST_F(GitTest, submodulePeriodSupport)
     // 6) Commit the addition in super
     commitAll(super.get(), "Add submodule with branch='.'");
 
-    auto store = [] {
-        auto cfg = make_ref<DummyStoreConfig>(StoreReference::Params{});
+    auto settings = getTestSettings();
+
+    auto store = [&] {
+        auto cfg = make_ref<DummyStoreConfig>(settings, StoreReference::Params{});
         cfg->readOnly = false;
         return cfg->openStore();
     }();
 
-    auto settings = fetchers::Settings{};
+    auto fetchSettings = fetchers::Settings{settings};
     auto input = fetchers::Input::fromAttrs(
         settings,
         {
@@ -196,7 +200,7 @@ TEST_F(GitTest, submodulePeriodSupport)
             {"ref", "main"},
         });
 
-    auto [accessor, i] = input.getAccessor(settings, *store);
+    auto [accessor, i] = input.getAccessor(fetchSettings, *store);
 
     ASSERT_EQ(accessor->readFile(CanonPath("deps/sub/lib.txt")), "hello from submodule\n");
 }

src/libfetchers-tests/input.cc

@@ -1,7 +1,11 @@
+#include "nix/store/globals.hh"
+
 #include "nix/fetchers/fetch-settings.hh"
 #include "nix/fetchers/attrs.hh"
 #include "nix/fetchers/fetchers.hh"
 
+#include "nix/store/tests/test-main.hh"
+
 #include <gtest/gtest.h>
 
 #include <string>
@@ -23,7 +27,8 @@ class InputFromAttrsTest : public ::testing::WithParamInterface<InputFromAttrsTe
 
 TEST_P(InputFromAttrsTest, attrsAreCorrectAndRoundTrips)
 {
-    fetchers::Settings fetchSettings;
+    auto settings = getTestSettings();
+    fetchers::Settings fetchSettings{settings};
 
     const auto & testCase = GetParam();
 

src/libfetchers/cache.cc

@@ -47,7 +47,7 @@ struct CacheImpl : Cache
         auto dbPath = (getCacheDir() / "fetcher-cache-v4.sqlite").string();
         createDirs(dirOf(dbPath));
 
-        state->db = SQLite(dbPath, {.useWAL = nix::settings.useSQLiteWAL});
+        state->db = SQLite(dbPath, {.useWAL = settings.storeSettings.useSQLiteWAL});
         state->db.isCache();
         state->db.exec(schema);
 

src/libfetchers/fetch-settings.cc

@@ -2,6 +2,9 @@
 
 namespace nix::fetchers {
 
-Settings::Settings() {}
+Settings::Settings(const nix::Settings & storeSettings)
+    : storeSettings(storeSettings)
+{
+}
 
 } // namespace nix::fetchers

src/libfetchers/fetch-to-store.cc

@@ -76,8 +76,8 @@ std::pair<StorePath, Hash> fetchToStore2(
     auto [storePath, hash] =
         mode == FetchMode::DryRun
             ? [&]() {
-                  auto [storePath, hash] =
-                      store.computeStorePath(name, path, method, HashAlgorithm::SHA256, {}, filter2);
+                  auto [storePath, hash] = store.computeStorePath(
+                      store.config.settings, name, path, method, HashAlgorithm::SHA256, {}, filter2);
                   debug(
                       "hashed '%s' to '%s' (hash '%s')",
                       path,

src/libfetchers/include/nix/fetchers/fetch-settings.hh

@@ -13,9 +13,10 @@
 
 namespace nix {
 
+class Settings;
 struct GitRepo;
 
-}
+} // namespace nix
 
 namespace nix::fetchers {
 
@@ -23,7 +24,12 @@ struct Cache;
 
 struct Settings : public Config
 {
-    Settings();
+    /**
+     * Reference to the "parent" store-layer settings.
+     */
+    const nix::Settings & storeSettings;
+
+    Settings(const nix::Settings & storeSettings);
 
     Setting<StringMap> accessTokens{
         this,

src/libflake-tests/flakeref.cc

@@ -3,6 +3,7 @@
 #include <string>
 #include <utility>
 
+#include "nix/store/globals.hh"
 #include "nix/fetchers/fetch-settings.hh"
 #include "nix/flake/flakeref.hh"
 #include "nix/fetchers/attrs.hh"
@@ -19,7 +20,8 @@ TEST(parseFlakeRef, path)
 {
     experimentalFeatureSettings.experimentalFeatures.get().insert(Xp::Flakes);
 
-    fetchers::Settings fetchSettings;
+    Settings settings;
+    fetchers::Settings fetchSettings{settings};
 
     {
         auto s = "/foo/bar";
@@ -69,7 +71,8 @@ TEST(parseFlakeRef, GitArchiveInput)
 {
     experimentalFeatureSettings.experimentalFeatures.get().insert(Xp::Flakes);
 
-    fetchers::Settings fetchSettings;
+    Settings settings;
+    fetchers::Settings fetchSettings{settings};
 
     {
         auto s = "github:foo/bar/branch%23"; // branch name with `#`
@@ -112,7 +115,8 @@ class InputFromURLTest : public ::testing::WithParamInterface<InputFromURLTestCa
 TEST_P(InputFromURLTest, attrsAreCorrectAndRoundTrips)
 {
     experimentalFeatureSettings.experimentalFeatures.get().insert(Xp::Flakes);
-    fetchers::Settings fetchSettings;
+    Settings settings;
+    fetchers::Settings fetchSettings{settings};
 
     const auto & testCase = GetParam();
 
@@ -274,7 +278,8 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST(to_string, doesntReencodeUrl)
 {
-    fetchers::Settings fetchSettings;
+    Settings settings;
+    fetchers::Settings fetchSettings{settings};
     auto s = "http://localhost:8181/test/+3d.tar.gz";
     auto flakeref = parseFlakeRef(fetchSettings, s);
     auto unparsed = flakeref.to_string();

src/libmain/common-args.cc

@@ -8,6 +8,7 @@
 #include "nix/main/loggers.hh"
 #include "nix/util/util.hh"
 #include "nix/main/plugin.hh"
+#include "nix/main/shared.hh"
 
 namespace nix {
 

src/libmain/include/nix/main/shared.hh

@@ -13,6 +13,13 @@
 
 namespace nix {
 
+class Settings;
+
+// FIXME: don't use a global variable.
+extern Settings settings;
+
+int handleExceptions(const std::string & programName, std::function<void()> fun);
+
 /**
  * Don't forget to call initPlugins() after settings are initialized!
  * @param loadConfig Whether to load configuration from `nix.conf`, `NIX_CONFIG`, etc. May be disabled for unit tests.

src/libmain/shared.cc

@@ -31,12 +31,17 @@
 
 #include "nix/util/exit.hh"
 #include "nix/util/strings.hh"
+#include "nix/util/config-global.hh"
 
 #include "main-config-private.hh"
 #include "nix/expr/config.hh"
 
 namespace nix {
 
+Settings settings;
+
+static GlobalConfig::Register rSettings(&settings);
+
 char ** savedArgv;
 
 static bool gcWarning = true;
@@ -335,8 +340,8 @@ void printVersion(const std::string & programName)
         std::cout << "System configuration file: " << nixConfFile() << "\n";
         std::cout << "User configuration files: "
                   << os_string_to_string(ExecutablePath{.directories = nixUserConfFiles()}.render()) << "\n";
-        std::cout << "Store directory: " << resolveStoreConfig(StoreReference{settings.storeUri.get()})->storeDir
-                  << "\n";
+        std::cout << "Store directory: "
+                  << resolveStoreConfig(settings, StoreReference{settings.storeUri.get()})->storeDir << "\n";
         std::cout << "State directory: " << settings.nixStateDir << "\n";
     }
     throw Exit();

src/libstore-c/nix_api_store.cc

@@ -18,6 +18,9 @@
 
 extern "C" {
 
+// FIXME: This is going to conflict with the one in libmain.
+nix::Settings cStoreSettings;
+
 nix_err nix_libstore_init(nix_c_context * context)
 {
     if (context)
@@ -46,7 +49,7 @@ Store * nix_store_open(nix_c_context * context, const char * uri, const char ***
         std::string uri_str = uri ? uri : "";
 
         if (uri_str.empty())
-            return new Store{nix::openStore()};
+            return new Store{nix::openStore(cStoreSettings)};
 
         auto storeRef = nix::StoreReference::parse(uri_str);
 
@@ -55,7 +58,7 @@ Store * nix_store_open(nix_c_context * context, const char * uri, const char ***
                 storeRef.params[params[i][0]] = params[i][1];
             }
         }
-        return new Store{nix::openStore(std::move(storeRef))};
+        return new Store{nix::openStore(cStoreSettings, std::move(storeRef))};
     }
     NIXC_CATCH_ERRS_NULL
 }
@@ -312,8 +315,8 @@ StorePath * nix_add_derivation(nix_c_context * context, Store * store, nix_deriv
            without actually writing the derivation if this setting is
            set, but it was that way already, so we are doing this for
            back-compat for now. */
-        auto ret = nix::settings.readOnlyMode ? nix::computeStorePath(*store->ptr, derivation->drv)
-                                              : store->ptr->writeDerivation(derivation->drv, nix::NoRepair);
+        auto ret = cStoreSettings.readOnlyMode ? nix::computeStorePath(*store->ptr, derivation->drv)
+                                               : store->ptr->writeDerivation(derivation->drv, nix::NoRepair);
 
         return new StorePath{ret};
     }

src/libstore-c/nix_api_store_internal.h

@@ -5,6 +5,8 @@
 
 extern "C" {
 
+extern nix::Settings cStoreSettings;
+
 struct Store
 {
     nix::ref<nix::Store> ptr;

src/libstore-test-support/https-store.cc

@@ -1,4 +1,5 @@
 #include "nix/store/tests/https-store.hh"
+#include "nix/store/tests/test-main.hh"
 
 #include <thread>
 
@@ -36,9 +37,9 @@ void HttpsBinaryCacheStoreTest::SetUp()
     cacheDir = tmpDir / "cache";
     delTmpDir = std::make_unique<AutoDelete>(tmpDir);
 
-    localCacheStore =
-        make_ref<LocalBinaryCacheStoreConfig>("file", cacheDir.string(), LocalBinaryCacheStoreConfig::Params{})
-            ->openStore();
+    localCacheStore = make_ref<LocalBinaryCacheStoreConfig>(
+                          settings, "file", cacheDir.string(), LocalBinaryCacheStoreConfig::Params{})
+                          ->openStore();
 
     caCert = tmpDir / "ca.crt";
     caKey = tmpDir / "ca.key";
@@ -121,6 +122,7 @@ std::vector<std::string> HttpsBinaryCacheStoreMtlsTest::serverArgs()
 ref<TestHttpBinaryCacheStoreConfig> HttpsBinaryCacheStoreTest::makeConfig()
 {
     auto res = make_ref<TestHttpBinaryCacheStoreConfig>(
+        settings,
         ParsedURL{
             .scheme = "https",
             .authority =

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

@@ -12,6 +12,8 @@
 #include "nix/util/file-system.hh"
 #include "nix/util/processes.hh"
 
+#include "nix/store/tests/test-main.hh"
+
 namespace nix::testing {
 
 class TestHttpBinaryCacheStoreConfig;
@@ -42,9 +44,9 @@ public:
 class TestHttpBinaryCacheStoreConfig : public HttpBinaryCacheStoreConfig
 {
 public:
-    TestHttpBinaryCacheStoreConfig(ParsedURL url, const Store::Config::Params & params)
-        : StoreConfig(params)
-        , HttpBinaryCacheStoreConfig(url, params)
+    TestHttpBinaryCacheStoreConfig(nix::Settings & settings, ParsedURL url, const Store::Config::Params & params)
+        : StoreConfig(settings, params)
+        , HttpBinaryCacheStoreConfig(settings, url, params)
     {
     }
 
@@ -56,6 +58,8 @@ class HttpsBinaryCacheStoreTest : public virtual LibStoreNetworkTest
     std::unique_ptr<AutoDelete> delTmpDir;
 
 public:
+    Settings settings = getTestSettings();
+
     static void SetUpTestSuite()
     {
         initLibStore(/*loadConfig=*/false);

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

@@ -7,6 +7,7 @@
 #include "nix/store/store-api.hh"
 #include "nix/store/store-open.hh"
 #include "nix/store/globals.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
@@ -18,14 +19,16 @@ public:
         initLibStore(false);
     }
 
+    Settings settings = getTestSettings();
+
 protected:
-    LibStoreTest(ref<Store> store)
-        : store(std::move(store))
+    LibStoreTest(auto && makeStore)
+        : store(makeStore(settings))
     {
     }
 
     LibStoreTest()
-        : LibStoreTest(openStore("dummy://"))
+        : LibStoreTest([](auto & settings) { return openStore(settings, "dummy://"); })
     {
     }
 

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

@@ -4,6 +4,13 @@
 
 namespace nix {
 
+class Settings;
+
+/**
+ * Get a Settings object configured appropriately for unit testing.
+ */
+Settings getTestSettings();
+
 /**
  * Call this for a GTest test suite that will including performing Nix
  * builds, before running tests.

src/libstore-test-support/test-main.cc

@@ -7,12 +7,9 @@
 
 namespace nix {
 
-int testMainForBuidingPre(int argc, char ** argv)
+Settings getTestSettings()
 {
-    if (argc > 1 && std::string_view(argv[1]) == "__build-remote") {
-        printError("test-build-remote: not supported in libexpr unit tests");
-        return EXIT_FAILURE;
-    }
+    Settings settings;
 
     // Disable build hook. We won't be testing remote builds in these unit tests. If we do, fix the above build hook.
     settings.getWorkerSettings().buildHook = {};
@@ -41,6 +38,16 @@ int testMainForBuidingPre(int argc, char ** argv)
     setEnv("_NIX_TEST_NO_SANDBOX", "1");
 #endif
 
+    return settings;
+}
+
+int testMainForBuidingPre(int argc, char ** argv)
+{
+    if (argc > 1 && std::string_view(argv[1]) == "__build-remote") {
+        printError("test-build-remote: not supported in libexpr unit tests");
+        return EXIT_FAILURE;
+    }
+
     return EXIT_SUCCESS;
 }
 

src/libstore-tests/derivation-advanced-attrs.cc

@@ -193,7 +193,7 @@ TYPED_TEST(DerivationAdvancedAttrsBothTest, advancedAttributes_defaults)
 
         EXPECT_EQ(options, advancedAttributes_defaults);
 
-        EXPECT_EQ(options.substitutesAllowed(settings.getWorkerSettings()), true);
+        EXPECT_EQ(options.substitutesAllowed(this->settings.getWorkerSettings()), true);
         EXPECT_EQ(options.useUidRange(got), false);
     });
 };
@@ -241,7 +241,7 @@ TYPED_TEST(DerivationAdvancedAttrsBothTest, advancedAttributes)
 
         EXPECT_EQ(options, expected);
 
-        EXPECT_EQ(options.substitutesAllowed(settings.getWorkerSettings()), false);
+        EXPECT_EQ(options.substitutesAllowed(this->settings.getWorkerSettings()), false);
         EXPECT_EQ(options.useUidRange(got), true);
     });
 };
@@ -333,7 +333,7 @@ TYPED_TEST(DerivationAdvancedAttrsBothTest, advancedAttributes_structuredAttrs_d
 
         EXPECT_EQ(options, advancedAttributes_structuredAttrs_defaults);
 
-        EXPECT_EQ(options.substitutesAllowed(settings.getWorkerSettings()), true);
+        EXPECT_EQ(options.substitutesAllowed(this->settings.getWorkerSettings()), true);
         EXPECT_EQ(options.useUidRange(got), false);
     });
 };
@@ -398,7 +398,7 @@ TYPED_TEST(DerivationAdvancedAttrsBothTest, advancedAttributes_structuredAttrs)
 
         EXPECT_EQ(options, expected);
 
-        EXPECT_EQ(options.substitutesAllowed(settings.getWorkerSettings()), false);
+        EXPECT_EQ(options.substitutesAllowed(this->settings.getWorkerSettings()), false);
         EXPECT_EQ(options.useUidRange(got), true);
     });
 };

src/libstore-tests/derivation/invariants.cc

@@ -16,11 +16,11 @@ class FillInOutputPathsTest : public LibStoreTest, public JsonCharacterizationTe
 
 protected:
     FillInOutputPathsTest()
-        : LibStoreTest([]() {
-            auto config = make_ref<DummyStoreConfig>(DummyStoreConfig::Params{});
+        : LibStoreTest([](auto & settings) {
+            auto config = make_ref<DummyStoreConfig>(settings, DummyStoreConfig::Params{});
             config->readOnly = false;
             return config->openDummyStore();
-        }())
+        })
     {
     }
 

src/libstore-tests/dummy-store.cc

@@ -7,6 +7,7 @@
 #include "nix/store/realisation.hh"
 
 #include "nix/util/tests/json-characterization.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
@@ -31,8 +32,10 @@ TEST(DummyStore, realisation_read)
 {
     initLibStore(/*loadConfig=*/false);
 
-    auto store = [] {
-        auto cfg = make_ref<DummyStoreConfig>(StoreReference::Params{});
+    auto settings = getTestSettings();
+
+    auto store = [&] {
+        auto cfg = make_ref<DummyStoreConfig>(settings, StoreReference::Params{});
         cfg->readOnly = false;
         return cfg->openDummyStore();
     }();
@@ -73,9 +76,10 @@ TEST_P(DummyStoreJsonTest, from_json)
     using namespace nlohmann;
     /* Cannot use `readJsonTest` because need to dereference the stores
        for equality. */
+    auto settings = getTestSettings();
     readTest(Path{name} + ".json", [&](const auto & encodedRaw) {
         auto encoded = json::parse(encodedRaw);
-        ref<DummyStore> decoded = adl_serializer<ref<DummyStore>>::from_json(encoded);
+        ref<DummyStore> decoded = adl_serializer<ref<DummyStore>>::from_json(settings, encoded);
         ASSERT_EQ(*decoded, *expected);
     });
 }
@@ -88,12 +92,13 @@ TEST_P(DummyStoreJsonTest, to_json)
 
 INSTANTIATE_TEST_SUITE_P(DummyStoreJSON, DummyStoreJsonTest, [] {
     initLibStore(false);
-    auto writeCfg = make_ref<DummyStore::Config>(DummyStore::Config::Params{});
+    auto settings = getTestSettings();
+    auto writeCfg = make_ref<DummyStore::Config>(settings, DummyStore::Config::Params{});
     writeCfg->readOnly = false;
     return ::testing::Values(
         std::pair{
             "empty",
-            make_ref<DummyStore::Config>(DummyStore::Config::Params{})->openDummyStore(),
+            make_ref<DummyStore::Config>(settings, DummyStore::Config::Params{})->openDummyStore(),
         },
         std::pair{
             "one-flat-file",

src/libstore-tests/http-binary-cache-store.cc

@@ -1,38 +1,44 @@
 #include <gtest/gtest.h>
 #include <regex>
 
+#include "nix/store/globals.hh"
 #include "nix/store/http-binary-cache-store.hh"
 #include "nix/store/tests/https-store.hh"
 #include "nix/util/fs-sink.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
 TEST(HttpBinaryCacheStore, constructConfig)
 {
-    HttpBinaryCacheStoreConfig config{"http", "foo.bar.baz", {}};
+    auto settings = getTestSettings();
+    HttpBinaryCacheStoreConfig config{settings, "http", "foo.bar.baz", {}};
 
     EXPECT_EQ(config.cacheUri.to_string(), "http://foo.bar.baz");
 }
 
 TEST(HttpBinaryCacheStore, constructConfigNoTrailingSlash)
 {
-    HttpBinaryCacheStoreConfig config{"https", "foo.bar.baz/a/b/", {}};
+    auto settings = getTestSettings();
+    HttpBinaryCacheStoreConfig config{settings, "https", "foo.bar.baz/a/b/", {}};
 
     EXPECT_EQ(config.cacheUri.to_string(), "https://foo.bar.baz/a/b");
 }
 
 TEST(HttpBinaryCacheStore, constructConfigWithParams)
 {
+    auto settings = getTestSettings();
     StoreConfig::Params params{{"compression", "xz"}};
-    HttpBinaryCacheStoreConfig config{"https", "foo.bar.baz/a/b/", params};
+    HttpBinaryCacheStoreConfig config{settings, "https", "foo.bar.baz/a/b/", params};
     EXPECT_EQ(config.cacheUri.to_string(), "https://foo.bar.baz/a/b");
     EXPECT_EQ(config.getReference().params, params);
 }
 
 TEST(HttpBinaryCacheStore, constructConfigWithParamsAndUrlWithParams)
 {
+    auto settings = getTestSettings();
     StoreConfig::Params params{{"compression", "xz"}};
-    HttpBinaryCacheStoreConfig config{"https", "foo.bar.baz/a/b?some-param=some-value", params};
+    HttpBinaryCacheStoreConfig config{settings, "https", "foo.bar.baz/a/b?some-param=some-value", params};
     EXPECT_EQ(config.cacheUri.to_string(), "https://foo.bar.baz/a/b?some-param=some-value");
     EXPECT_EQ(config.getReference().params, params);
 }

src/libstore-tests/legacy-ssh-store.cc

@@ -1,12 +1,16 @@
 #include <gtest/gtest.h>
 
+#include "nix/store/globals.hh"
 #include "nix/store/legacy-ssh-store.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
 TEST(LegacySSHStore, constructConfig)
 {
+    auto settings = getTestSettings();
     LegacySSHStoreConfig config(
+        settings,
         "ssh",
         "me@localhost:2222",
         StoreConfig::Params{

src/libstore-tests/local-binary-cache-store.cc

@@ -1,12 +1,14 @@
 #include <gtest/gtest.h>
 
+#include "nix/store/globals.hh"
 #include "nix/store/local-binary-cache-store.hh"
 
 namespace nix {
 
 TEST(LocalBinaryCacheStore, constructConfig)
 {
-    LocalBinaryCacheStoreConfig config{"local", "/foo/bar/baz", {}};
+    Settings settings;
+    LocalBinaryCacheStoreConfig config{settings, "local", "/foo/bar/baz", {}};
 
     EXPECT_EQ(config.binaryCacheDir, "/foo/bar/baz");
 }

src/libstore-tests/local-overlay-store.cc

@@ -1,12 +1,16 @@
 #include <gtest/gtest.h>
 
+#include "nix/store/globals.hh"
 #include "nix/store/local-overlay-store.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
 TEST(LocalOverlayStore, constructConfig_rootQueryParam)
 {
+    auto settings = getTestSettings();
     LocalOverlayStoreConfig config{
+        settings,
         "local-overlay",
         "",
         {
@@ -22,7 +26,8 @@ TEST(LocalOverlayStore, constructConfig_rootQueryParam)
 
 TEST(LocalOverlayStore, constructConfig_rootPath)
 {
-    LocalOverlayStoreConfig config{"local-overlay", "/foo/bar", {}};
+    auto settings = getTestSettings();
+    LocalOverlayStoreConfig config{settings, "local-overlay", "/foo/bar", {}};
 
     EXPECT_EQ(config.rootDir.get(), std::optional{"/foo/bar"});
 }

src/libstore-tests/local-store.cc

@@ -1,18 +1,16 @@
 #include <gtest/gtest.h>
 
+#include "nix/store/globals.hh"
 #include "nix/store/local-store.hh"
-
-// Needed for template specialisations. This is not good! When we
-// overhaul how store configs work, this should be fixed.
-#include "nix/util/args.hh"
-#include "nix/util/config-impl.hh"
-#include "nix/util/abstract-setting-to-json.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
 TEST(LocalStore, constructConfig_rootQueryParam)
 {
+    auto settings = getTestSettings();
     LocalStoreConfig config{
+        settings,
         "local",
         "",
         {
@@ -28,14 +26,16 @@ TEST(LocalStore, constructConfig_rootQueryParam)
 
 TEST(LocalStore, constructConfig_rootPath)
 {
-    LocalStoreConfig config{"local", "/foo/bar", {}};
+    auto settings = getTestSettings();
+    LocalStoreConfig config{settings, "local", "/foo/bar", {}};
 
     EXPECT_EQ(config.rootDir.get(), std::optional{"/foo/bar"});
 }
 
 TEST(LocalStore, constructConfig_to_string)
 {
-    LocalStoreConfig config{"local", "", {}};
+    auto settings = getTestSettings();
+    LocalStoreConfig config{settings, "local", "", {}};
     EXPECT_EQ(config.getReference().to_string(), "local");
 }
 

src/libstore-tests/nar-info-disk-cache.cc

@@ -1,11 +1,13 @@
-#include "nix/store/nar-info-disk-cache.hh"
-
 #include <gtest/gtest.h>
 #include <rapidcheck/gtest.h>
 #include "nix/store/globals.hh"
 #include "nix/store/sqlite.hh"
 #include <sqlite3.h>
 
+#include "nix/store/globals.hh"
+#include "nix/store/sqlite.hh"
+#include "nix/store/nar-info-disk-cache.hh"
+
 namespace nix {
 
 TEST(NarInfoDiskCacheImpl, create_and_read)
@@ -24,6 +26,8 @@ TEST(NarInfoDiskCacheImpl, create_and_read)
     SQLite db;
     SQLiteStmt getIds;
 
+    Settings settings;
+
     {
         auto cache = NarInfoDiskCache::getTest(
             settings.getNarInfoDiskCacheSettings(), {.useWAL = settings.useSQLiteWAL}, dbPath.string());

src/libstore-tests/nix_api_store.cc

@@ -299,7 +299,7 @@ public:
         nix_api_store_test_base::SetUp();
 
         nix::experimentalFeatureSettings.set("extra-experimental-features", "ca-derivations");
-        nix::settings.getWorkerSettings().substituters = {};
+        cStoreSettings.getWorkerSettings().substituters = {};
 
         store = open_local_store();
 
@@ -309,7 +309,7 @@ public:
         buffer << t.rdbuf();
 
         // Replace the hardcoded system with the current system
-        std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", nix::settings.thisSystem.get());
+        std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", cStoreSettings.thisSystem.get());
 
         drv = nix_derivation_from_json(ctx, store, jsonStr.c_str());
         assert_ctx_ok();
@@ -354,7 +354,7 @@ TEST_F(nix_api_store_test_base, build_from_json)
 {
     // FIXME get rid of these
     nix::experimentalFeatureSettings.set("extra-experimental-features", "ca-derivations");
-    nix::settings.getWorkerSettings().substituters = {};
+    cStoreSettings.getWorkerSettings().substituters = {};
 
     auto * store = open_local_store();
 
@@ -365,7 +365,7 @@ TEST_F(nix_api_store_test_base, build_from_json)
     buffer << t.rdbuf();
 
     // Replace the hardcoded system with the current system
-    std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", nix::settings.thisSystem.get());
+    std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", cStoreSettings.thisSystem.get());
 
     auto * drv = nix_derivation_from_json(ctx, store, jsonStr.c_str());
     assert_ctx_ok();
@@ -401,7 +401,7 @@ TEST_F(nix_api_store_test_base, nix_store_realise_invalid_system)
 {
     // Test that nix_store_realise properly reports errors when the system is invalid
     nix::experimentalFeatureSettings.set("extra-experimental-features", "ca-derivations");
-    nix::settings.getWorkerSettings().substituters = {};
+    cStoreSettings.getWorkerSettings().substituters = {};
 
     auto * store = open_local_store();
 
@@ -446,7 +446,7 @@ TEST_F(nix_api_store_test_base, nix_store_realise_builder_fails)
 {
     // Test that nix_store_realise properly reports errors when the builder fails
     nix::experimentalFeatureSettings.set("extra-experimental-features", "ca-derivations");
-    nix::settings.getWorkerSettings().substituters = {};
+    cStoreSettings.getWorkerSettings().substituters = {};
 
     auto * store = open_local_store();
 
@@ -456,7 +456,7 @@ TEST_F(nix_api_store_test_base, nix_store_realise_builder_fails)
     buffer << t.rdbuf();
 
     // Replace with current system and make builder command fail
-    std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", nix::settings.thisSystem.get());
+    std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", cStoreSettings.thisSystem.get());
     jsonStr = nix::replaceStrings(jsonStr, "echo $name foo > $out", "exit 1");
 
     auto * drv = nix_derivation_from_json(ctx, store, jsonStr.c_str());
@@ -491,7 +491,7 @@ TEST_F(nix_api_store_test_base, nix_store_realise_builder_no_output)
 {
     // Test that nix_store_realise properly reports errors when builder succeeds but produces no output
     nix::experimentalFeatureSettings.set("extra-experimental-features", "ca-derivations");
-    nix::settings.getWorkerSettings().substituters = {};
+    cStoreSettings.getWorkerSettings().substituters = {};
 
     auto * store = open_local_store();
 
@@ -501,7 +501,7 @@ TEST_F(nix_api_store_test_base, nix_store_realise_builder_no_output)
     buffer << t.rdbuf();
 
     // Replace with current system and make builder succeed but not produce output
-    std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", nix::settings.thisSystem.get());
+    std::string jsonStr = nix::replaceStrings(buffer.str(), "x86_64-linux", cStoreSettings.thisSystem.get());
     jsonStr = nix::replaceStrings(jsonStr, "echo $name foo > $out", "true");
 
     auto * drv = nix_derivation_from_json(ctx, store, jsonStr.c_str());
@@ -687,7 +687,7 @@ TEST_F(NixApiStoreTestWithRealisedPath, nix_store_realise_output_ordering)
     // This test uses a CA derivation with 10 outputs in randomized input order
     // to verify that the callback order is deterministic and alphabetical.
     nix::experimentalFeatureSettings.set("extra-experimental-features", "ca-derivations");
-    nix::settings.getWorkerSettings().substituters = {};
+    cStoreSettings.getWorkerSettings().substituters = {};
 
     auto * store = open_local_store();
 
@@ -706,14 +706,14 @@ TEST_F(NixApiStoreTestWithRealisedPath, nix_store_realise_output_ordering)
     std::string drvJson = R"({
         "version": 4,
         "name": "multi-output-test",
-        "system": ")" + nix::settings.thisSystem.get()
+        "system": ")" + cStoreSettings.thisSystem.get()
                           + R"(",
         "builder": "/bin/sh",
         "args": ["-c", "echo a > $outa; echo b > $outb; echo c > $outc; echo d > $outd; echo e > $oute; echo f > $outf; echo g > $outg; echo h > $outh; echo i > $outi; echo j > $outj"],
         "env": {
             "builder": "/bin/sh",
             "name": "multi-output-test",
-            "system": ")" + nix::settings.thisSystem.get()
+            "system": ")" + cStoreSettings.thisSystem.get()
                           + R"(",
             "outf": ")" + outf_ph
                           + R"(",

src/libstore-tests/s3-binary-cache-store.cc

@@ -1,7 +1,9 @@
+#include "nix/store/globals.hh"
 #include "nix/store/s3-binary-cache-store.hh"
 #include "nix/store/http-binary-cache-store.hh"
 #include "nix/store/filetransfer.hh"
 #include "nix/store/s3-url.hh"
+#include "nix/store/tests/test-main.hh"
 
 #include <gtest/gtest.h>
 
@@ -9,7 +11,8 @@ namespace nix {
 
 TEST(S3BinaryCacheStore, constructConfig)
 {
-    S3BinaryCacheStoreConfig config{"s3", "foobar", {}};
+    auto settings = getTestSettings();
+    S3BinaryCacheStoreConfig config{settings, "s3", "foobar", {}};
 
     // The bucket name is stored as the host part of the authority in cacheUri
     EXPECT_EQ(
@@ -22,8 +25,9 @@ TEST(S3BinaryCacheStore, constructConfig)
 
 TEST(S3BinaryCacheStore, constructConfigWithRegion)
 {
+    auto settings = getTestSettings();
     Store::Config::Params params{{"region", "eu-west-1"}};
-    S3BinaryCacheStoreConfig config{"s3", "my-bucket", params};
+    S3BinaryCacheStoreConfig config{settings, "s3", "my-bucket", params};
 
     EXPECT_EQ(
         config.cacheUri,
@@ -37,7 +41,8 @@ TEST(S3BinaryCacheStore, constructConfigWithRegion)
 
 TEST(S3BinaryCacheStore, defaultSettings)
 {
-    S3BinaryCacheStoreConfig config{"s3", "test-bucket", {}};
+    auto settings = getTestSettings();
+    S3BinaryCacheStoreConfig config{settings, "s3", "test-bucket", {}};
 
     EXPECT_EQ(
         config.cacheUri,
@@ -58,11 +63,13 @@ TEST(S3BinaryCacheStore, defaultSettings)
  */
 TEST(S3BinaryCacheStore, s3StoreConfigPreservesParameters)
 {
+    auto settings = getTestSettings();
+
     StringMap params;
     params["region"] = "eu-west-1";
     params["endpoint"] = "custom.s3.com";
 
-    S3BinaryCacheStoreConfig config("s3", "test-bucket", params);
+    S3BinaryCacheStoreConfig config(settings, "s3", "test-bucket", params);
 
     // The config should preserve S3-specific parameters
     EXPECT_EQ(
@@ -93,13 +100,15 @@ TEST(S3BinaryCacheStore, s3SchemeRegistration)
  */
 TEST(S3BinaryCacheStore, parameterFiltering)
 {
+    auto settings = getTestSettings();
+
     StringMap params;
     params["region"] = "eu-west-1";
     params["endpoint"] = "minio.local";
     params["want-mass-query"] = "true"; // Non-S3 store parameter
     params["priority"] = "10";          // Non-S3 store parameter
 
-    S3BinaryCacheStoreConfig config("s3", "test-bucket", params);
+    S3BinaryCacheStoreConfig config(settings, "s3", "test-bucket", params);
 
     // Only S3-specific params should be in cacheUri.query
     EXPECT_EQ(
@@ -127,16 +136,19 @@ TEST(S3BinaryCacheStore, parameterFiltering)
  */
 TEST(S3BinaryCacheStore, storageClassDefault)
 {
-    S3BinaryCacheStoreConfig config{"s3", "test-bucket", {}};
+    auto settings = getTestSettings();
+    S3BinaryCacheStoreConfig config{settings, "s3", "test-bucket", {}};
     EXPECT_EQ(config.storageClass.get(), std::nullopt);
 }
 
 TEST(S3BinaryCacheStore, storageClassConfiguration)
 {
+    auto settings = getTestSettings();
+
     StringMap params;
     params["storage-class"] = "GLACIER";
 
-    S3BinaryCacheStoreConfig config("s3", "test-bucket", params);
+    S3BinaryCacheStoreConfig config(settings, "s3", "test-bucket", params);
     EXPECT_EQ(config.storageClass.get(), std::optional<std::string>("GLACIER"));
 }
 

src/libstore-tests/ssh-store.cc

@@ -1,14 +1,16 @@
 #include <gtest/gtest.h>
 
+#include "nix/store/globals.hh"
 #include "nix/store/ssh-store.hh"
-#include "nix/util/config-impl.hh"
-#include "nix/util/abstract-setting-to-json.hh"
+#include "nix/store/tests/test-main.hh"
 
 namespace nix {
 
 TEST(SSHStore, constructConfig)
 {
+    auto settings = getTestSettings();
     SSHStoreConfig config{
+        settings,
         "ssh-ng",
         "me@localhost:2222",
         StoreConfig::Params{
@@ -34,7 +36,9 @@ TEST(SSHStore, constructConfig)
 
 TEST(MountedSSHStore, constructConfig)
 {
+    auto settings = getTestSettings();
     MountedSSHStoreConfig config{
+        settings,
         "mounted-ssh",
         "localhost",
         StoreConfig::Params{

src/libstore-tests/uds-remote-store.cc

@@ -1,31 +1,38 @@
 #include <gtest/gtest.h>
 
+#include "nix/store/globals.hh"
 #include "nix/store/uds-remote-store.hh"
 
 namespace nix {
 
 TEST(UDSRemoteStore, constructConfig)
 {
-    UDSRemoteStoreConfig config{"unix", "/tmp/socket", {}};
+    Settings settings;
+    UDSRemoteStoreConfig config{settings, "unix", "/tmp/socket", {}};
 
     EXPECT_EQ(config.path, "/tmp/socket");
 }
 
 TEST(UDSRemoteStore, constructConfigWrongScheme)
 {
-    EXPECT_THROW(UDSRemoteStoreConfig("http", "/tmp/socket", {}), UsageError);
+    Settings settings;
+    EXPECT_THROW(UDSRemoteStoreConfig(settings, "http", "/tmp/socket", {}), UsageError);
 }
 
 TEST(UDSRemoteStore, constructConfig_to_string)
 {
-    UDSRemoteStoreConfig config{"unix", "", {}};
+    Settings settings;
+    UDSRemoteStoreConfig config{settings, "unix", "", {}};
     EXPECT_EQ(config.getReference().to_string(), "daemon");
 }
 
 TEST(UDSRemoteStore, constructConfigWithParams)
 {
+    Settings settings;
+
     StoreConfig::Params params{{"max-connections", "1"}};
-    UDSRemoteStoreConfig config{"unix", "/tmp/socket", params};
+    UDSRemoteStoreConfig config{settings, "unix", "/tmp/socket", params};
+
     auto storeReference = config.getReference();
     EXPECT_EQ(storeReference.to_string(), "unix:///tmp/socket?max-connections=1");
     EXPECT_EQ(storeReference.render(/*withParams=*/false), "unix:///tmp/socket");
@@ -34,8 +41,11 @@ TEST(UDSRemoteStore, constructConfigWithParams)
 
 TEST(UDSRemoteStore, constructConfigWithParamsNoPath)
 {
+    Settings settings;
+
     StoreConfig::Params params{{"max-connections", "1"}};
-    UDSRemoteStoreConfig config{"unix", "", params};
+    UDSRemoteStoreConfig config{settings, "unix", "", params};
+
     auto storeReference = config.getReference();
     EXPECT_EQ(storeReference.to_string(), "daemon?max-connections=1");
     EXPECT_EQ(storeReference.render(/*withParams=*/false), "daemon");

src/libstore-tests/worker-substitution.cc

@@ -21,14 +21,14 @@ protected:
     ref<DummyStore> substituter;
 
     WorkerSubstitutionTest()
-        : LibStoreTest([] {
-            auto config = make_ref<DummyStoreConfig>(DummyStoreConfig::Params{});
+        : LibStoreTest([](auto & settings) {
+            auto config = make_ref<DummyStoreConfig>(settings, DummyStoreConfig::Params{});
             config->readOnly = false;
             return config->openDummyStore();
-        }())
+        })
         , dummyStore(store.dynamic_pointer_cast<DummyStore>())
-        , substituter([] {
-            auto config = make_ref<DummyStoreConfig>(DummyStoreConfig::Params{});
+        , substituter([this] {
+            auto config = make_ref<DummyStoreConfig>(settings, DummyStoreConfig::Params{});
             config->readOnly = false;
             config->isTrusted = true;
             return config->openDummyStore();
@@ -67,10 +67,10 @@ TEST_F(WorkerSubstitutionTest, singleStoreObject)
         HashAlgorithm::SHA256);
 
     // Snapshot the substituter (has one store object)
-    checkpointJson("single/substituter", substituter);
+    checkpointJson("single/substituter", substituter, settings);
 
     // Snapshot the destination store before (should be empty)
-    checkpointJson("../dummy-store/empty", dummyStore);
+    checkpointJson("../dummy-store/empty", dummyStore, settings);
 
     // The path should not exist in the destination store yet
     ASSERT_FALSE(dummyStore->isValidPath(pathInSubstituter));
@@ -92,7 +92,7 @@ TEST_F(WorkerSubstitutionTest, singleStoreObject)
     worker.run(goals);
 
     // Snapshot the destination store after (should match the substituter)
-    checkpointJson("single/substituter", dummyStore);
+    checkpointJson("single/substituter", dummyStore, settings);
 
     // The path should now exist in the destination store
     ASSERT_TRUE(dummyStore->isValidPath(pathInSubstituter));
@@ -138,10 +138,10 @@ TEST_F(WorkerSubstitutionTest, singleRootStoreObjectWithSingleDepStoreObject)
         StorePathSet{dependencyPath});
 
     // Snapshot the substituter (has two store objects)
-    checkpointJson("with-dep/substituter", substituter);
+    checkpointJson("with-dep/substituter", substituter, settings);
 
     // Snapshot the destination store before (should be empty)
-    checkpointJson("../dummy-store/empty", dummyStore);
+    checkpointJson("../dummy-store/empty", dummyStore, settings);
 
     // Neither path should exist in the destination store yet
     ASSERT_FALSE(dummyStore->isValidPath(dependencyPath));
@@ -164,7 +164,7 @@ TEST_F(WorkerSubstitutionTest, singleRootStoreObjectWithSingleDepStoreObject)
     worker.run(goals);
 
     // Snapshot the destination store after (should match the substituter)
-    checkpointJson("with-dep/substituter", dummyStore);
+    checkpointJson("with-dep/substituter", dummyStore, settings);
 
     // Both paths should now exist in the destination store
     ASSERT_TRUE(dummyStore->isValidPath(dependencyPath));
@@ -196,7 +196,7 @@ TEST_F(WorkerSubstitutionTest, floatingDerivationOutput)
     auto drvPath = dummyStore->writeDerivation(drv);
 
     // Snapshot the destination store before
-    checkpointJson("ca-drv/store-before", dummyStore);
+    checkpointJson("ca-drv/store-before", dummyStore, settings);
 
     // Compute the hash modulo of the derivation
     // For CA floating derivations, the kind is Deferred since outputs aren't known until build
@@ -233,7 +233,7 @@ TEST_F(WorkerSubstitutionTest, floatingDerivationOutput)
         });
 
     // Snapshot the substituter
-    checkpointJson("ca-drv/substituter", substituter);
+    checkpointJson("ca-drv/substituter", substituter, settings);
 
     // The realisation should not exist in the destination store yet
     DrvOutput drvOutput{drvHash, "out"};
@@ -256,7 +256,7 @@ TEST_F(WorkerSubstitutionTest, floatingDerivationOutput)
     worker.run(goals);
 
     // Snapshot the destination store after
-    checkpointJson("ca-drv/store-after", dummyStore);
+    checkpointJson("ca-drv/store-after", dummyStore, settings);
 
     // The output path should now exist in the destination store
     ASSERT_TRUE(dummyStore->isValidPath(outputPath));
@@ -351,7 +351,7 @@ TEST_F(WorkerSubstitutionTest, floatingDerivationOutputWithDepDrv)
     auto rootDrvPath = dummyStore->writeDerivation(rootDrv);
 
     // Snapshot the destination store before
-    checkpointJson("issue-11928/store-before", dummyStore);
+    checkpointJson("issue-11928/store-before", dummyStore, settings);
 
     // Compute the hash modulo for the root derivation
     auto rootHashModulo = hashDerivationModulo(*dummyStore, rootDrv, true);
@@ -395,7 +395,7 @@ TEST_F(WorkerSubstitutionTest, floatingDerivationOutputWithDepDrv)
 
     // Snapshot the substituter
     // Note: it has realisations for both drvs, but only the root's output store object
-    checkpointJson("issue-11928/substituter", substituter);
+    checkpointJson("issue-11928/substituter", substituter, settings);
 
     // The realisations should not exist in the destination store yet
     ASSERT_FALSE(dummyStore->queryRealisation(depDrvOutput));
@@ -418,7 +418,7 @@ TEST_F(WorkerSubstitutionTest, floatingDerivationOutputWithDepDrv)
     worker.run(goals);
 
     // Snapshot the destination store after
-    checkpointJson("issue-11928/store-after", dummyStore);
+    checkpointJson("issue-11928/store-after", dummyStore, settings);
 
     // The root output path should now exist in the destination store
     ASSERT_TRUE(dummyStore->isValidPath(rootOutputPath));

src/libstore-tests/write-derivation.cc

@@ -12,19 +12,22 @@ namespace {
 class WriteDerivationTest : public LibStoreTest
 {
 protected:
-    WriteDerivationTest(ref<DummyStoreConfig> config_)
-        : LibStoreTest(config_->openDummyStore())
-        , config(std::move(config_))
+    WriteDerivationTest(auto && makeConfig)
+        : LibStoreTest([&](auto & settings) {
+            this->config = makeConfig(settings);
+            return config->openDummyStore();
+        })
     {
         config->readOnly = false;
     }
 
     WriteDerivationTest()
-        : WriteDerivationTest(make_ref<DummyStoreConfig>(DummyStoreConfig::Params{}))
+        : WriteDerivationTest(
+              [](auto & settings) { return make_ref<DummyStoreConfig>(settings, DummyStoreConfig::Params{}); })
     {
     }
 
-    ref<DummyStoreConfig> config;
+    std::shared_ptr<DummyStoreConfig> config;
 };
 
 static Derivation makeSimpleDrv()

src/libstore/build/derivation-building-goal.cc

@@ -327,8 +327,8 @@ Goal::Co DerivationBuildingGoal::tryToBuild(StorePathSet inputPaths)
         }
 
         bool canBuildLocally = [&] {
-            if (drv->platform != settings.thisSystem.get() && !settings.extraPlatforms.get().count(drv->platform)
-                && !drv->isBuiltin())
+            if (drv->platform != worker.store.config.settings.thisSystem.get()
+                && !worker.store.config.settings.extraPlatforms.get().count(drv->platform) && !drv->isBuiltin())
                 return false;
 
             if (worker.settings.maxBuildJobs.get() == 0 && !drv->isBuiltin())
@@ -377,7 +377,7 @@ Goal::Co DerivationBuildingGoal::tryToBuild(StorePathSet inputPaths)
                    use that. If there is not, then check if we can do a "true" local
                    build. */
 
-                externalBuilder = settings.findExternalDerivationBuilderIfSupported(*drv);
+                externalBuilder = worker.store.config.settings.findExternalDerivationBuilderIfSupported(*drv);
 
                 if (!externalBuilder && !canBuildLocally) {
                     auto msg =
@@ -389,12 +389,12 @@ Goal::Co DerivationBuildingGoal::tryToBuild(StorePathSet inputPaths)
                             Magenta(worker.store.printStorePath(drvPath)),
                             Magenta(drv->platform),
                             concatStringsSep(", ", drvOptions.getRequiredSystemFeatures(*drv)),
-                            Magenta(settings.thisSystem),
+                            Magenta(worker.store.config.settings.thisSystem),
                             concatStringsSep<StringSet>(", ", worker.store.Store::config.systemFeatures));
 
                     // since aarch64-darwin has Rosetta 2, this user can actually run x86_64-darwin on their hardware -
                     // we should tell them to run the command to install Darwin 2
-                    if (drv->platform == "x86_64-darwin" && settings.thisSystem == "aarch64-darwin")
+                    if (drv->platform == "x86_64-darwin" && worker.store.config.settings.thisSystem == "aarch64-darwin")
                         msg += fmt(
                             "\nNote: run `%s` to run programs for x86_64-darwin",
                             Magenta(
@@ -479,7 +479,8 @@ Goal::Co DerivationBuildingGoal::buildWithHook(
     hook->toHook.writeSide.close();
 
     /* Create the log file and pipe. */
-    std::unique_ptr<LogFile> logFile = std::make_unique<LogFile>(worker.store, drvPath, settings.getLogFileSettings());
+    std::unique_ptr<LogFile> logFile =
+        std::make_unique<LogFile>(worker.store, drvPath, worker.store.config.settings.getLogFileSettings());
 
     std::set<MuxablePipePollState::CommChannel> fds;
     fds.insert(hook->fromHook.readSide.get());
@@ -655,7 +656,7 @@ Goal::Co DerivationBuildingGoal::buildLocally(
     std::unique_ptr<LogFile> logFile;
 
     auto openLogFile = [&]() {
-        logFile = std::make_unique<LogFile>(worker.store, drvPath, settings.getLogFileSettings());
+        logFile = std::make_unique<LogFile>(worker.store, drvPath, worker.store.config.settings.getLogFileSettings());
     };
 
     auto closeLogFile = [&]() { logFile.reset(); };
@@ -756,6 +757,7 @@ Goal::Co DerivationBuildingGoal::buildLocally(
             }
 
             DerivationBuilderParams params{
+                .settings = worker.store.config.settings,
                 .drvPath = drvPath,
                 .buildResult = buildResult,
                 .drv = *drv,

src/libstore/build/worker.cc

@@ -22,9 +22,9 @@ Worker::Worker(Store & store, Store & evalStore)
     , actSubstitutions(*logger, actCopyPaths)
     , store(store)
     , evalStore(evalStore)
-    , settings(nix::settings.getWorkerSettings())
-    , getSubstituters{[] {
-        return nix::settings.getWorkerSettings().useSubstitutes ? getDefaultSubstituters() : std::list<ref<Store>>{};
+    , settings(store.config.settings.getWorkerSettings())
+    , getSubstituters{[&] {
+        return settings.useSubstitutes ? getDefaultSubstituters(store.config.settings) : std::list<ref<Store>>{};
     }}
 {
     nrLocalBuilds = 0;
@@ -367,7 +367,9 @@ void Worker::run(const Goals & _topGoals)
         if (!children.empty() || !waitingForAWhile.empty())
             waitForInput();
         else if (awake.empty() && 0U == settings.maxBuildJobs) {
-            if (Machine::parseConfig({nix::settings.thisSystem}, nix::settings.getWorkerSettings().builders).empty())
+            if (Machine::parseConfig(
+                    {store.config.settings.thisSystem}, store.config.settings.getWorkerSettings().builders)
+                    .empty())
                 throw Error(
                     "Unable to start any build; either increase '--max-jobs' or enable remote builds.\n"
                     "\n"

src/libstore/common-ssh-store-config.cc

@@ -5,14 +5,15 @@
 
 namespace nix {
 
-CommonSSHStoreConfig::CommonSSHStoreConfig(std::string_view scheme, std::string_view authority, const Params & params)
-    : CommonSSHStoreConfig(scheme, ParsedURL::Authority::parse(authority), params)
+CommonSSHStoreConfig::CommonSSHStoreConfig(
+    nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params)
+    : CommonSSHStoreConfig(settings, scheme, ParsedURL::Authority::parse(authority), params)
 {
 }
 
 CommonSSHStoreConfig::CommonSSHStoreConfig(
-    std::string_view scheme, const ParsedURL::Authority & authority, const Params & params)
-    : StoreConfig(params)
+    nix::Settings & settings, std::string_view scheme, const ParsedURL::Authority & authority, const Params & params)
+    : StoreConfig(settings, params)
     , authority(authority)
 {
 }

src/libstore/daemon.cc

@@ -230,7 +230,7 @@ struct ClientSettings
     bool useSubstitutes;
     StringMap overrides;
 
-    void apply(TrustedFlag trusted)
+    void apply(Settings & settings, TrustedFlag trusted)
     {
         settings.keepFailed = keepFailed;
         settings.getWorkerSettings().keepGoing = keepGoing;
@@ -783,7 +783,7 @@ static void performOp(
         // FIXME: use some setting in recursive mode. Will need to use
         // non-global variables.
         if (!recursive)
-            clientSettings.apply(trusted);
+            clientSettings.apply(store->config.settings, trusted);
 
         logger->stopWork();
         break;

src/libstore/dummy-store.cc

@@ -408,10 +408,10 @@ void adl_serializer<DummyStore::PathInfoAndContents>::to_json(json & json, const
     };
 }
 
-ref<DummyStoreConfig> adl_serializer<ref<DummyStore::Config>>::from_json(const json & json)
+ref<DummyStoreConfig> adl_serializer<ref<DummyStore::Config>>::from_json(Settings & settings, const json & json)
 {
     auto & obj = getObject(json);
-    auto cfg = make_ref<DummyStore::Config>(DummyStore::Config::Params{});
+    auto cfg = make_ref<DummyStore::Config>(settings, DummyStore::Config::Params{});
     const_cast<PathSetting &>(cfg->storeDir_).set(getString(valueAt(obj, "store")));
     cfg->readOnly = true;
     return cfg;
@@ -424,10 +424,11 @@ void adl_serializer<DummyStoreConfig>::to_json(json & json, const DummyStoreConf
     };
 }
 
-ref<DummyStore> adl_serializer<ref<DummyStore>>::from_json(const json & json)
+ref<DummyStore> adl_serializer<ref<DummyStore>>::from_json(Settings & settings, const json & json)
 {
     auto & obj = getObject(json);
-    ref<DummyStore> res = adl_serializer<ref<DummyStoreConfig>>::from_json(valueAt(obj, "config"))->openDummyStore();
+    ref<DummyStore> res =
+        adl_serializer<ref<DummyStoreConfig>>::from_json(settings, valueAt(obj, "config"))->openDummyStore();
     for (auto & [k, v] : getObject(valueAt(obj, "contents")))
         res->contents.insert({StorePath{k}, v});
     for (auto & [k, v] : getObject(valueAt(obj, "derivations")))

src/libstore/globals.cc

@@ -79,10 +79,6 @@ LogFileSettings::LogFileSettings()
 {
 }
 
-Settings settings;
-
-static GlobalConfig::Register rSettings(&settings);
-
 Settings::Settings()
     : nixStateDir(canonPath(getEnvNonEmpty("NIX_STATE_DIR").value_or(NIX_STATE_DIR)))
     , nixDaemonSocketFile(canonPath(getEnvOsNonEmpty(OS_STR("NIX_DAEMON_SOCKET_PATH"))

src/libstore/http-binary-cache-store.cc

@@ -5,7 +5,6 @@
 #include "nix/store/sqlite.hh"
 #include "nix/util/callback.hh"
 #include "nix/store/store-registration.hh"
-#include "nix/store/globals.hh"
 
 namespace nix {
 
@@ -21,8 +20,9 @@ StringSet HttpBinaryCacheStoreConfig::uriSchemes()
 }
 
 HttpBinaryCacheStoreConfig::HttpBinaryCacheStoreConfig(
-    std::string_view scheme, std::string_view _cacheUri, const Params & params)
+    nix::Settings & settings, std::string_view scheme, std::string_view _cacheUri, const Params & params)
     : HttpBinaryCacheStoreConfig(
+          settings,
           parseURL(
               std::string{scheme} + "://"
               + (!_cacheUri.empty()
@@ -32,9 +32,10 @@ HttpBinaryCacheStoreConfig::HttpBinaryCacheStoreConfig(
 {
 }
 
-HttpBinaryCacheStoreConfig::HttpBinaryCacheStoreConfig(ParsedURL _cacheUri, const Params & params)
-    : StoreConfig(params)
-    , BinaryCacheStoreConfig(params)
+HttpBinaryCacheStoreConfig::HttpBinaryCacheStoreConfig(
+    nix::Settings & settings, ParsedURL _cacheUri, const Params & params)
+    : StoreConfig(settings, params)
+    , BinaryCacheStoreConfig(settings, params)
     , cacheUri(std::move(_cacheUri))
 {
     while (!cacheUri.path.empty() && cacheUri.path.back() == "")
@@ -66,7 +67,8 @@ HttpBinaryCacheStore::HttpBinaryCacheStore(ref<Config> config, ref<FileTransfer>
     , fileTransfer{fileTransfer}
     , config{config}
 {
-    diskCache = NarInfoDiskCache::get(settings.getNarInfoDiskCacheSettings(), {.useWAL = settings.useSQLiteWAL});
+    diskCache = NarInfoDiskCache::get(
+        config->settings.getNarInfoDiskCacheSettings(), {.useWAL = config->settings.useSQLiteWAL});
 }
 
 void HttpBinaryCacheStore::init()
@@ -104,7 +106,7 @@ std::optional<CompressionAlgo> HttpBinaryCacheStore::getCompressionMethod(const
 void HttpBinaryCacheStore::maybeDisable()
 {
     auto state(_state.lock());
-    if (state->enabled && settings.getWorkerSettings().tryFallback) {
+    if (state->enabled && config->settings.getWorkerSettings().tryFallback) {
         int t = 60;
         printError("disabling binary cache '%s' for %s seconds", config->getHumanReadableURI(), t);
         state->enabled = false;

src/libstore/include/nix/store/build/derivation-builder.hh

@@ -16,6 +16,8 @@
 
 namespace nix {
 
+class Settings;
+
 /**
  * Denotes a build failure that stemmed from the builder exiting with a
  * failing exist status.
@@ -55,6 +57,8 @@ typedef std::map<std::filesystem::path, ChrootPath> PathsInChroot; // maps targe
  */
 struct DerivationBuilderParams
 {
+    Settings & settings;
+
     /** The path of the derivation. */
     const StorePath & drvPath;
 

src/libstore/include/nix/store/common-ssh-store-config.hh

@@ -12,8 +12,13 @@ struct CommonSSHStoreConfig : virtual StoreConfig
 {
     using StoreConfig::StoreConfig;
 
-    CommonSSHStoreConfig(std::string_view scheme, const ParsedURL::Authority & authority, const Params & params);
-    CommonSSHStoreConfig(std::string_view scheme, std::string_view authority, const Params & params);
+    CommonSSHStoreConfig(
+        nix::Settings & settings,
+        std::string_view scheme,
+        const ParsedURL::Authority & authority,
+        const Params & params);
+    CommonSSHStoreConfig(
+        nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params);
 
     Setting<Path> sshKey{
         this, "", "ssh-key", "Path to the SSH private key used to authenticate to the remote machine."};

src/libstore/include/nix/store/dummy-store.hh

@@ -12,15 +12,16 @@ struct DummyStore;
 
 struct DummyStoreConfig : public std::enable_shared_from_this<DummyStoreConfig>, virtual StoreConfig
 {
-    DummyStoreConfig(const Params & params)
-        : StoreConfig(params)
+    DummyStoreConfig(nix::Settings & settings, const Params & params)
+        : StoreConfig(settings, params)
     {
         // Disable caching since this a temporary in-memory store.
         pathInfoCacheSize = 0;
     }
 
-    DummyStoreConfig(std::string_view scheme, std::string_view authority, const Params & params)
-        : DummyStoreConfig(params)
+    DummyStoreConfig(
+        nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params)
+        : DummyStoreConfig(settings, params)
     {
         if (!authority.empty())
             throw UsageError("`%s` store URIs must not contain an authority part %s", scheme, authority);
@@ -90,11 +91,20 @@ namespace nlohmann {
 
 template<>
 JSON_IMPL_INNER_TO(nix::DummyStoreConfig);
+
 template<>
-JSON_IMPL_INNER_FROM(nix::ref<nix::DummyStoreConfig>);
+struct adl_serializer<nix::ref<nix::DummyStoreConfig>>
+{
+    static nix::ref<nix::DummyStoreConfig> from_json(nix::Settings & settings, const json & json);
+};
+
 template<>
 JSON_IMPL_INNER_TO(nix::DummyStore);
+
 template<>
-JSON_IMPL_INNER_FROM(nix::ref<nix::DummyStore>);
+struct adl_serializer<nix::ref<nix::DummyStore>>
+{
+    static nix::ref<nix::DummyStore> from_json(nix::Settings & settings, const json & json);
+};
 
 } // namespace nlohmann

src/libstore/include/nix/store/globals.hh

@@ -422,9 +422,6 @@ public:
     ProfileDirsOptions getProfileDirsOptions() const;
 };
 
-// FIXME: don't use a global variable.
-extern nix::Settings settings;
-
 /**
  * Load the configuration (from `nix.conf`, `NIX_CONFIG`, etc.) into the
  * given configuration object.

src/libstore/include/nix/store/http-binary-cache-store.hh

@@ -17,9 +17,12 @@ struct HttpBinaryCacheStoreConfig : std::enable_shared_from_this<HttpBinaryCache
     using BinaryCacheStoreConfig::BinaryCacheStoreConfig;
 
     HttpBinaryCacheStoreConfig(
-        std::string_view scheme, std::string_view cacheUri, const Store::Config::Params & params);
+        nix::Settings & settings,
+        std::string_view scheme,
+        std::string_view cacheUri,
+        const Store::Config::Params & params);
 
-    HttpBinaryCacheStoreConfig(ParsedURL cacheUri, const Store::Config::Params & params);
+    HttpBinaryCacheStoreConfig(nix::Settings & settings, ParsedURL cacheUri, const Store::Config::Params & params);
 
     ParsedURL cacheUri;
 

src/libstore/include/nix/store/keys.hh

@@ -5,6 +5,12 @@
 
 namespace nix {
 
-PublicKeys getDefaultPublicKeys();
+class Settings;
 
-}
+/**
+ * @todo use more narrow settings, or rethink whether this is a good
+ * idea at all, vs always associating keys with stores.
+ */
+PublicKeys getDefaultPublicKeys(const Settings & settings);
+
+} // namespace nix

src/libstore/include/nix/store/legacy-ssh-store.hh

@@ -14,7 +14,8 @@ struct LegacySSHStoreConfig : std::enable_shared_from_this<LegacySSHStoreConfig>
 {
     using CommonSSHStoreConfig::CommonSSHStoreConfig;
 
-    LegacySSHStoreConfig(std::string_view scheme, std::string_view authority, const Params & params);
+    LegacySSHStoreConfig(
+        nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params);
 
 #ifndef _WIN32
     // Hack for getting remote build log output.

src/libstore/include/nix/store/local-binary-cache-store.hh

@@ -12,7 +12,8 @@ struct LocalBinaryCacheStoreConfig : std::enable_shared_from_this<LocalBinaryCac
      * @param binaryCacheDir `file://` is a short-hand for `file:///`
      * for now.
      */
-    LocalBinaryCacheStoreConfig(std::string_view scheme, PathView binaryCacheDir, const Params & params);
+    LocalBinaryCacheStoreConfig(
+        nix::Settings & settings, std::string_view scheme, PathView binaryCacheDir, const Params & params);
 
     Path binaryCacheDir;
 

src/libstore/include/nix/store/local-fs-store.hh

@@ -30,7 +30,7 @@ public:
      *
      * @todo Make this less error-prone with new store settings system.
      */
-    LocalFSStoreConfig(PathView path, const Params & params);
+    LocalFSStoreConfig(nix::Settings & settings, PathView path, const Params & params);
 
     OptionalPathSetting rootDir = makeRootDirSetting(*this, std::nullopt);
 
@@ -40,25 +40,25 @@ private:
      * An indirection so that we don't need to refer to global settings
      * in headers.
      */
-    static Path getDefaultStateDir();
+    static Path getDefaultStateDir(const nix::Settings & settings);
 
     /**
      * An indirection so that we don't need to refer to global settings
      * in headers.
      */
-    static Path getDefaultLogDir();
+    static Path getDefaultLogDir(const nix::Settings & settings);
 
 public:
 
     PathSetting stateDir{
         this,
-        rootDir.get() ? *rootDir.get() + "/nix/var/nix" : getDefaultStateDir(),
+        rootDir.get() ? *rootDir.get() + "/nix/var/nix" : getDefaultStateDir(settings),
         "state",
         "Directory where Nix stores state."};
 
     PathSetting logDir{
         this,
-        rootDir.get() ? *rootDir.get() + "/nix/var/log/nix" : getDefaultLogDir(),
+        rootDir.get() ? *rootDir.get() + "/nix/var/log/nix" : getDefaultLogDir(settings),
         "log",
         "directory where Nix stores log files."};
 

src/libstore/include/nix/store/local-overlay-store.hh

@@ -7,15 +7,15 @@ namespace nix {
  */
 struct LocalOverlayStoreConfig : virtual LocalStoreConfig
 {
-    LocalOverlayStoreConfig(const StringMap & params)
-        : LocalOverlayStoreConfig("local-overlay", "", params)
+    LocalOverlayStoreConfig(nix::Settings & settings, const StringMap & params)
+        : LocalOverlayStoreConfig(settings, "local-overlay", "", params)
     {
     }
 
-    LocalOverlayStoreConfig(std::string_view scheme, PathView path, const Params & params)
-        : StoreConfig(params)
-        , LocalFSStoreConfig(path, params)
-        , LocalStoreConfig(scheme, path, params)
+    LocalOverlayStoreConfig(nix::Settings & settings, std::string_view scheme, PathView path, const Params & params)
+        : StoreConfig(settings, params)
+        , LocalFSStoreConfig(settings, path, params)
+        , LocalStoreConfig(settings, scheme, path, params)
     {
     }
 

src/libstore/include/nix/store/local-store.hh

@@ -82,7 +82,8 @@ struct LocalStoreConfig : std::enable_shared_from_this<LocalStoreConfig>,
 {
     using LocalFSStoreConfig::LocalFSStoreConfig;
 
-    LocalStoreConfig(std::string_view scheme, std::string_view authority, const Params & params);
+    LocalStoreConfig(
+        nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params);
 
 private:
 

src/libstore/include/nix/store/machines.hh

@@ -6,6 +6,7 @@
 
 namespace nix {
 
+class Settings;
 class Store;
 
 struct Machine;
@@ -67,7 +68,7 @@ struct Machine
      * nix::openStore(completeStoreReference())
      * ```
      */
-    ref<Store> openStore() const;
+    ref<Store> openStore(Settings & settings) const;
 
     /**
      * Parse a machine configuration.

src/libstore/include/nix/store/profiles.hh

@@ -16,6 +16,7 @@
 
 namespace nix {
 
+class Settings;
 class StorePath;
 
 /**
@@ -216,7 +217,7 @@ struct ProfileDirsOptions
 };
 
 /**
- * Create and return the path to a directory suitable for storing the user’s
+ * Create and return the path to a directory suitable for storing the user's
  * profiles.
  */
 std::filesystem::path profilesDir(ProfileDirsOptions opts);

src/libstore/include/nix/store/s3-binary-cache-store.hh

@@ -11,7 +11,8 @@ struct S3BinaryCacheStoreConfig : HttpBinaryCacheStoreConfig
 {
     using HttpBinaryCacheStoreConfig::HttpBinaryCacheStoreConfig;
 
-    S3BinaryCacheStoreConfig(std::string_view uriScheme, std::string_view bucketName, const Params & params);
+    S3BinaryCacheStoreConfig(
+        nix::Settings & settings, std::string_view uriScheme, std::string_view bucketName, const Params & params);
 
     Setting<std::string> profile{
         this,

src/libstore/include/nix/store/ssh-store.hh

@@ -15,7 +15,8 @@ struct SSHStoreConfig : std::enable_shared_from_this<SSHStoreConfig>,
     using CommonSSHStoreConfig::CommonSSHStoreConfig;
     using RemoteStoreConfig::RemoteStoreConfig;
 
-    SSHStoreConfig(std::string_view scheme, std::string_view authority, const Params & params);
+    SSHStoreConfig(
+        nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params);
 
     Setting<Strings> remoteProgram{
         this, {"nix-daemon"}, "remote-program", "Path to the `nix-daemon` executable on the remote machine."};
@@ -39,8 +40,8 @@ struct SSHStoreConfig : std::enable_shared_from_this<SSHStoreConfig>,
 
 struct MountedSSHStoreConfig : virtual SSHStoreConfig, virtual LocalFSStoreConfig
 {
-    MountedSSHStoreConfig(StringMap params);
-    MountedSSHStoreConfig(std::string_view scheme, std::string_view host, StringMap params);
+    MountedSSHStoreConfig(nix::Settings & settings, StringMap params);
+    MountedSSHStoreConfig(nix::Settings & settings, std::string_view scheme, std::string_view host, StringMap params);
 
     static const std::string name()
     {

src/libstore/include/nix/store/store-api.hh

@@ -44,6 +44,8 @@ struct NarInfoDiskCache;
 struct NarInfoDiskCacheSettings;
 class Store;
 
+class Settings;
+
 typedef std::map<std::string, StorePath> OutputPathMap;
 
 enum CheckSigsFlag : bool { NoCheckSigs = false, CheckSigs = true };
@@ -80,19 +82,32 @@ struct StoreConfigBase : Config
 {
     using Config::Config;
 
+    /**
+     * Global settings, which are we trying to triage and give better
+     * homes. Putting a reference to them on stores will help a bit with
+     * this, though we may find that some of the things here should
+     * *not* be per-store.
+     */
+    nix::Settings & settings;
+
+    StoreConfigBase(nix::Settings & settings)
+        : settings{settings}
+    {
+    }
+
 private:
 
     /**
      * Compute the default Nix store directory from environment variables
      * (`NIX_STORE_DIR`, `NIX_STORE`) or the compile-time default.
      */
-    static Path getDefaultNixStoreDir();
+    static Path getDefaultNixStoreDir(const nix::Settings & settings);
 
 public:
 
     const PathSetting storeDir_{
         this,
-        getDefaultNixStoreDir(),
+        getDefaultNixStoreDir(settings),
         "store",
         R"(
           Logical location of the Nix store, usually
@@ -137,13 +152,13 @@ struct StoreConfig : public StoreConfigBase, public StoreDirConfig
 {
     using Params = StoreReference::Params;
 
-    StoreConfig(const Params & params);
+    StoreConfig(nix::Settings & settings, const Params & params);
 
     StoreConfig() = delete;
 
     virtual ~StoreConfig() {}
 
-    static StringSet getDefaultSystemFeatures();
+    static StringSet getDefaultSystemFeatures(const nix::Settings & settings);
 
     /**
      * Documentation for this type of store.
@@ -208,7 +223,7 @@ struct StoreConfig : public StoreConfigBase, public StoreDirConfig
 
     Setting<StringSet> systemFeatures{
         this,
-        getDefaultSystemFeatures(),
+        getDefaultSystemFeatures(settings),
         "system-features",
         R"(
           Optional [system features](@docroot@/command-ref/conf-file.md#conf-system-features) available on the system this store uses to build derivations.

src/libstore/include/nix/store/store-dir-config.hh

@@ -11,6 +11,7 @@
 
 namespace nix {
 
+class Settings;
 struct SourcePath;
 
 MakeError(BadStorePath, Error);
@@ -89,6 +90,7 @@ struct StoreDirConfig
      * path for the given file system object.
      */
     std::pair<StorePath, Hash> computeStorePath(
+        const Settings & settings,
         std::string_view name,
         const SourcePath & path,
         ContentAddressMethod method = ContentAddressMethod::Raw::NixArchive,

src/libstore/include/nix/store/store-open.hh

@@ -15,32 +15,37 @@
 
 namespace nix {
 
+class Settings;
+
 /**
  * @return The store config denoted by `storeURI` (slight misnomer...).
  */
-ref<StoreConfig> resolveStoreConfig(StoreReference && storeURI);
+ref<StoreConfig> resolveStoreConfig(Settings & settings, StoreReference && storeURI);
 
 /**
  * @return a Store object to access the Nix store denoted by
- * ‘uri’ (slight misnomer...).
+ * 'uri' (slight misnomer...).
  */
-ref<Store> openStore(StoreReference && storeURI);
+ref<Store> openStore(Settings & settings, StoreReference && storeURI);
 
 /**
  * Opens the store at `uri`, where `uri` is in the format expected by
  * `StoreReference::parse`
  */
-ref<Store> openStore(const std::string & uri, const StoreReference::Params & extraParams = StoreReference::Params());
+ref<Store> openStore(
+    Settings & settings,
+    const std::string & uri,
+    const StoreReference::Params & extraParams = StoreReference::Params());
 
 /**
  * Short-hand which opens the default store, according to global settings
  */
-ref<Store> openStore();
+ref<Store> openStore(Settings & settings);
 
 /**
  * @return the default substituter stores, defined by the
- * ‘substituters’ option and various legacy options.
+ * 'substituters' option and various legacy options.
  */
-std::list<ref<Store>> getDefaultSubstituters();
+std::list<ref<Store>> getDefaultSubstituters(Settings & settings);
 
 } // namespace nix

src/libstore/include/nix/store/store-registration.hh

@@ -14,6 +14,7 @@
  */
 
 #include "nix/store/store-api.hh"
+#include "nix/store/globals.hh"
 
 namespace nix {
 
@@ -40,7 +41,10 @@ struct StoreFactory
      * whatever comes after `<scheme>://` and before `?<query-params>`.
      */
     std::function<ref<StoreConfig>(
-        std::string_view scheme, std::string_view authorityPath, const Store::Config::Params & params)>
+        Settings & settings,
+        std::string_view scheme,
+        std::string_view authorityPath,
+        const Store::Config::Params & params)>
         parseConfig;
 
     /**
@@ -64,10 +68,13 @@ struct Implementations
             .doc = TConfig::doc(),
             .uriSchemes = TConfig::uriSchemes(),
             .experimentalFeature = TConfig::experimentalFeature(),
-            .parseConfig = ([](auto scheme, auto uri, auto & params) -> ref<StoreConfig> {
-                return make_ref<TConfig>(scheme, uri, params);
+            .parseConfig = ([](Settings & settings, auto scheme, auto uri, auto & params) -> ref<StoreConfig> {
+                return make_ref<TConfig>(settings, scheme, uri, params);
+            }),
+            .getConfig = ([]() -> ref<StoreConfig> {
+                Settings settings;
+                return make_ref<TConfig>(settings, Store::Config::Params{});
             }),
-            .getConfig = ([]() -> ref<StoreConfig> { return make_ref<TConfig>(Store::Config::Params{}); }),
         };
         auto [it, didInsert] = registered().insert({TConfig::name(), std::move(factory)});
         if (!didInsert) {

src/libstore/include/nix/store/uds-remote-store.hh

@@ -19,9 +19,10 @@ struct UDSRemoteStoreConfig : std::enable_shared_from_this<UDSRemoteStoreConfig>
     /**
      * @param authority is the socket path.
      */
-    UDSRemoteStoreConfig(std::string_view scheme, std::string_view authority, const Params & params);
+    UDSRemoteStoreConfig(
+        nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params);
 
-    UDSRemoteStoreConfig(const Params & params);
+    UDSRemoteStoreConfig(nix::Settings & settings, const Params & params);
 
     static const std::string name()
     {

src/libstore/keys.cc

@@ -4,7 +4,7 @@
 
 namespace nix {
 
-PublicKeys getDefaultPublicKeys()
+PublicKeys getDefaultPublicKeys(const Settings & settings)
 {
     PublicKeys publicKeys;
 

src/libstore/legacy-ssh-store.cc

@@ -18,9 +18,10 @@
 
 namespace nix {
 
-LegacySSHStoreConfig::LegacySSHStoreConfig(std::string_view scheme, std::string_view authority, const Params & params)
-    : StoreConfig(params)
-    , CommonSSHStoreConfig(scheme, ParsedURL::Authority::parse(authority), params)
+LegacySSHStoreConfig::LegacySSHStoreConfig(
+    nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params)
+    : StoreConfig(settings, params)
+    , CommonSSHStoreConfig(settings, scheme, ParsedURL::Authority::parse(authority), params)
 {
 }
 
@@ -180,7 +181,7 @@ void LegacySSHStore::narFromPath(const StorePath & path, std::function<void(Sour
     conn->narFromPath(*this, path, fun);
 }
 
-static ServeProto::BuildOptions buildSettings()
+static ServeProto::BuildOptions buildSettings(const Settings & settings)
 {
     return {
         .maxSilentTime = settings.getWorkerSettings().maxSilentTime,
@@ -196,7 +197,7 @@ BuildResult LegacySSHStore::buildDerivation(const StorePath & drvPath, const Bas
 {
     auto conn(connections->get());
 
-    conn->putBuildDerivationRequest(*this, drvPath, drv, buildSettings());
+    conn->putBuildDerivationRequest(*this, drvPath, drv, buildSettings(config->settings));
 
     return conn->getBuildDerivationResponse(*this);
 }
@@ -240,7 +241,7 @@ void LegacySSHStore::buildPaths(
     }
     conn->to << ss;
 
-    ServeProto::write(*this, *conn, buildSettings());
+    ServeProto::write(*this, *conn, buildSettings(config->settings));
 
     conn->to.flush();
 

src/libstore/linux/include/nix/store/personality.hh

@@ -3,6 +3,12 @@
 
 #include <string>
 
+namespace nix {
+
+class Settings;
+
+}
+
 namespace nix::linux {
 
 struct PersonalityArgs

src/libstore/local-binary-cache-store.cc

@@ -9,9 +9,9 @@
 namespace nix {
 
 LocalBinaryCacheStoreConfig::LocalBinaryCacheStoreConfig(
-    std::string_view scheme, PathView binaryCacheDir, const StoreReference::Params & params)
-    : Store::Config{params}
-    , BinaryCacheStoreConfig{params}
+    nix::Settings & settings, std::string_view scheme, PathView binaryCacheDir, const StoreReference::Params & params)
+    : Store::Config{settings, params}
+    , BinaryCacheStoreConfig{settings, params}
     , binaryCacheDir(binaryCacheDir)
 {
 }

src/libstore/local-fs-store.cc

@@ -8,18 +8,18 @@
 
 namespace nix {
 
-Path LocalFSStoreConfig::getDefaultStateDir()
+Path LocalFSStoreConfig::getDefaultStateDir(const nix::Settings & settings)
 {
     return settings.nixStateDir.string();
 }
 
-Path LocalFSStoreConfig::getDefaultLogDir()
+Path LocalFSStoreConfig::getDefaultLogDir(const nix::Settings & settings)
 {
     return settings.getLogFileSettings().nixLogDir.string();
 }
 
-LocalFSStoreConfig::LocalFSStoreConfig(PathView rootDir, const Params & params)
-    : StoreConfig(params)
+LocalFSStoreConfig::LocalFSStoreConfig(nix::Settings & settings, PathView rootDir, const Params & params)
+    : StoreConfig(settings, params)
     /* Default `?root` from `rootDir` if non set
      * NOTE: We would like to just do rootDir.set(...), which would take care of
      * all normalization and error checking for us. Unfortunately we cannot do

src/libstore/local-overlay-store.cc

@@ -43,7 +43,7 @@ LocalOverlayStore::LocalOverlayStore(ref<const Config> config)
     , LocalFSStore{*config}
     , LocalStore{static_cast<ref<const LocalStore::Config>>(config)}
     , config{config}
-    , lowerStore(openStore(config->lowerStoreUri.get()).dynamic_pointer_cast<LocalFSStore>())
+    , lowerStore(openStore(config->settings, config->lowerStoreUri.get()).dynamic_pointer_cast<LocalFSStore>())
 {
     if (config->checkMount.get()) {
         std::smatch match;

src/libstore/local-store.cc

@@ -56,9 +56,10 @@
 
 namespace nix {
 
-LocalStoreConfig::LocalStoreConfig(std::string_view scheme, std::string_view authority, const Params & params)
-    : StoreConfig(params)
-    , LocalFSStoreConfig(authority, params)
+LocalStoreConfig::LocalStoreConfig(
+    nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params)
+    : StoreConfig(settings, params)
+    , LocalFSStoreConfig(settings, authority, params)
 {
 }
 
@@ -505,7 +506,8 @@ void LocalStore::openDB(State & state, bool create)
     auto openMode = config->readOnly ? SQLiteOpenMode::Immutable
                     : create         ? SQLiteOpenMode::Normal
                                      : SQLiteOpenMode::NoCreate;
-    state.db = SQLite(std::filesystem::path(dbDir) / "db.sqlite", {.mode = openMode, .useWAL = settings.useSQLiteWAL});
+    state.db =
+        SQLite(std::filesystem::path(dbDir) / "db.sqlite", {.mode = openMode, .useWAL = config->settings.useSQLiteWAL});
 
 #ifdef __CYGWIN__
     /* The cygwin version of sqlite3 has a patch which calls
@@ -529,7 +531,7 @@ void LocalStore::openDB(State & state, bool create)
 
     /* Set the SQLite journal mode.  WAL mode is fastest, so it's the
        default. */
-    std::string mode = settings.useSQLiteWAL ? "wal" : "truncate";
+    std::string mode = config->settings.useSQLiteWAL ? "wal" : "truncate";
     std::string prevMode;
     {
         SQLiteStmt stmt;
@@ -974,7 +976,7 @@ const PublicKeys & LocalStore::getPublicKeys()
 {
     auto state(_state->lock());
     if (!state->publicKeys)
-        state->publicKeys = std::make_unique<PublicKeys>(getDefaultPublicKeys());
+        state->publicKeys = std::make_unique<PublicKeys>(getDefaultPublicKeys(config->settings));
     return *state->publicKeys;
 }
 

src/libstore/machines.cc

@@ -91,9 +91,9 @@ StoreReference Machine::completeStoreReference() const
     return storeUri;
 }
 
-ref<Store> Machine::openStore() const
+ref<Store> Machine::openStore(Settings & settings) const
 {
-    return nix::openStore(completeStoreReference());
+    return nix::openStore(settings, completeStoreReference());
 }
 
 static std::vector<std::string> expandBuilderLines(const std::string & builders)

src/libstore/misc.cc

@@ -236,8 +236,8 @@ MissingPaths Store::queryMissing(const std::vector<DerivedPath> & targets)
                         throw;
                     }
 
-                    if (!knownOutputPaths && settings.getWorkerSettings().useSubstitutes
-                        && drvOptions.substitutesAllowed(settings.getWorkerSettings())) {
+                    if (!knownOutputPaths && config.settings.getWorkerSettings().useSubstitutes
+                        && drvOptions.substitutesAllowed(config.settings.getWorkerSettings())) {
                         experimentalFeatureSettings.require(Xp::CaDerivations);
 
                         // If there are unknown output paths, attempt to find if the
@@ -250,7 +250,7 @@ MissingPaths Store::queryMissing(const std::vector<DerivedPath> & targets)
                                 continue;
 
                             bool found = false;
-                            for (auto & sub : getDefaultSubstituters()) {
+                            for (auto & sub : getDefaultSubstituters(config.settings)) {
                                 auto realisation = sub->queryRealisation({hash, outputName});
                                 if (!realisation)
                                     continue;
@@ -267,8 +267,8 @@ MissingPaths Store::queryMissing(const std::vector<DerivedPath> & targets)
                         }
                     }
 
-                    if (knownOutputPaths && settings.getWorkerSettings().useSubstitutes
-                        && drvOptions.substitutesAllowed(settings.getWorkerSettings())) {
+                    if (knownOutputPaths && config.settings.getWorkerSettings().useSubstitutes
+                        && drvOptions.substitutesAllowed(config.settings.getWorkerSettings())) {
                         auto drvState = make_ref<Sync<DrvState>>(DrvState(invalid.size()));
                         for (auto & output : invalid)
                             pool.enqueue(std::bind(checkOutput, drvPath, drv, output, drvState));

src/libstore/remote-store.cc

@@ -114,6 +114,8 @@ void RemoteStore::initConnection(Connection & conn)
 
 void RemoteStore::setOptions(Connection & conn)
 {
+    auto & settings = config.settings;
+
     conn.to << WorkerProto::Op::SetOptions << settings.keepFailed << settings.getWorkerSettings().keepGoing
             << settings.getWorkerSettings().tryFallback << verbosity << settings.getWorkerSettings().maxBuildJobs
             << settings.getWorkerSettings().maxSilentTime << true << (settings.verboseBuild ? lvlError : lvlVomit)

src/libstore/s3-binary-cache-store.cc

@@ -417,9 +417,9 @@ StringSet S3BinaryCacheStoreConfig::uriSchemes()
 }
 
 S3BinaryCacheStoreConfig::S3BinaryCacheStoreConfig(
-    std::string_view scheme, std::string_view _cacheUri, const Params & params)
-    : StoreConfig(params)
-    , HttpBinaryCacheStoreConfig(scheme, _cacheUri, params)
+    nix::Settings & settings, std::string_view scheme, std::string_view _cacheUri, const Params & params)
+    : StoreConfig(settings, params)
+    , HttpBinaryCacheStoreConfig(settings, scheme, _cacheUri, params)
 {
     assert(cacheUri.query.empty());
     assert(cacheUri.scheme == "s3");

src/libstore/ssh-store.cc

@@ -11,10 +11,11 @@
 
 namespace nix {
 
-SSHStoreConfig::SSHStoreConfig(std::string_view scheme, std::string_view authority, const Params & params)
-    : Store::Config{params}
-    , RemoteStore::Config{params}
-    , CommonSSHStoreConfig{scheme, authority, params}
+SSHStoreConfig::SSHStoreConfig(
+    nix::Settings & settings, std::string_view scheme, std::string_view authority, const Params & params)
+    : Store::Config{settings, params}
+    , RemoteStore::Config{settings, params}
+    , CommonSSHStoreConfig{settings, scheme, authority, params}
 {
 }
 
@@ -88,21 +89,22 @@ protected:
     };
 };
 
-MountedSSHStoreConfig::MountedSSHStoreConfig(StringMap params)
-    : StoreConfig(params)
-    , RemoteStoreConfig(params)
-    , CommonSSHStoreConfig(params)
-    , SSHStoreConfig(params)
-    , LocalFSStoreConfig(params)
+MountedSSHStoreConfig::MountedSSHStoreConfig(nix::Settings & settings, StringMap params)
+    : StoreConfig(settings, params)
+    , RemoteStoreConfig(settings, params)
+    , CommonSSHStoreConfig(settings, params)
+    , SSHStoreConfig(settings, params)
+    , LocalFSStoreConfig(settings, "", params)
 {
 }
 
-MountedSSHStoreConfig::MountedSSHStoreConfig(std::string_view scheme, std::string_view host, StringMap params)
-    : StoreConfig(params)
-    , RemoteStoreConfig(params)
-    , CommonSSHStoreConfig(scheme, host, params)
-    , SSHStoreConfig(scheme, host, params)
-    , LocalFSStoreConfig(params)
+MountedSSHStoreConfig::MountedSSHStoreConfig(
+    nix::Settings & settings, std::string_view scheme, std::string_view host, StringMap params)
+    : StoreConfig(settings, params)
+    , RemoteStoreConfig(settings, params)
+    , CommonSSHStoreConfig(settings, scheme, host, params)
+    , SSHStoreConfig(settings, scheme, host, params)
+    , LocalFSStoreConfig(settings, "", params)
 {
 }
 

src/libstore/store-api.cc

@@ -32,7 +32,7 @@ using json = nlohmann::json;
 
 namespace nix {
 
-Path StoreConfigBase::getDefaultNixStoreDir()
+Path StoreConfigBase::getDefaultNixStoreDir(const nix::Settings & settings)
 {
     return
 #ifndef _WIN32
@@ -41,8 +41,8 @@ Path StoreConfigBase::getDefaultNixStoreDir()
         (getEnvNonEmpty("NIX_STORE_DIR").value_or(getEnvNonEmpty("NIX_STORE").value_or(NIX_STORE_DIR)));
 }
 
-StoreConfig::StoreConfig(const Params & params)
-    : StoreConfigBase(params)
+StoreConfig::StoreConfig(nix::Settings & settings, const Params & params)
+    : StoreConfigBase(settings)
     , StoreDirConfig{storeDir_}
 {
 }
@@ -118,7 +118,7 @@ StorePath Store::addToStore(
     auto sink = sourceToSink([&](Source & source) {
         LengthSource lengthSource(source);
         storePath = addToStoreFromDump(lengthSource, name, fsm, method, hashAlgo, references, repair);
-        if (settings.warnLargePathThreshold && lengthSource.total >= settings.warnLargePathThreshold)
+        if (config.settings.warnLargePathThreshold && lengthSource.total >= config.settings.warnLargePathThreshold)
             warn("copied large path '%s' to the store (%s)", path, renderSize(lengthSource.total));
     });
     dumpPath(path, *sink, fsm, filter);
@@ -184,7 +184,7 @@ void Store::addMultipleToStore(PathsSource && pathsToCopy, Activity & act, Repai
                     addToStore(info, *source, repair, checkSigs);
                 } catch (Error & e) {
                     nrFailed++;
-                    if (!settings.getWorkerSettings().keepGoing)
+                    if (!config.settings.getWorkerSettings().keepGoing)
                         throw e;
                     printMsg(lvlError, "could not copy %s: %s", printStorePath(path), e.what());
                     showProgress();
@@ -315,7 +315,7 @@ void Store::narFromPath(const StorePath & path, Sink & sink)
     dumpPath(sourcePath, sink, FileSerialisationMethod::NixArchive);
 }
 
-StringSet Store::Config::getDefaultSystemFeatures()
+StringSet Store::Config::getDefaultSystemFeatures(const nix::Settings & settings)
 {
     auto res = settings.systemFeatures.get();
 
@@ -420,12 +420,12 @@ StorePathSet Store::queryDerivationOutputs(const StorePath & path)
 
 void Store::querySubstitutablePathInfos(const StorePathCAMap & paths, SubstitutablePathInfos & infos)
 {
-    if (!settings.getWorkerSettings().useSubstitutes)
+    if (!config.settings.getWorkerSettings().useSubstitutes)
         return;
 
     for (auto & path : paths) {
         std::optional<Error> lastStoresException = std::nullopt;
-        for (auto & sub : getDefaultSubstituters()) {
+        for (auto & sub : getDefaultSubstituters(config.settings)) {
             if (lastStoresException.has_value()) {
                 logError(lastStoresException->info());
                 lastStoresException.reset();
@@ -476,7 +476,7 @@ void Store::querySubstitutablePathInfos(const StorePathCAMap & paths, Substituta
             }
         }
         if (lastStoresException.has_value()) {
-            if (!settings.getWorkerSettings().tryFallback) {
+            if (!config.settings.getWorkerSettings().tryFallback) {
                 throw *lastStoresException;
             } else
                 logError(lastStoresException->info());
@@ -486,7 +486,7 @@ void Store::querySubstitutablePathInfos(const StorePathCAMap & paths, Substituta
 
 StorePathSet Store::querySubstitutablePaths(const StorePathSet & paths)
 {
-    if (!settings.getWorkerSettings().useSubstitutes)
+    if (!config.settings.getWorkerSettings().useSubstitutes)
         return StorePathSet();
 
     StorePathSet remaining;
@@ -495,7 +495,7 @@ StorePathSet Store::querySubstitutablePaths(const StorePathSet & paths)
 
     StorePathSet res;
 
-    for (auto & sub : getDefaultSubstituters()) {
+    for (auto & sub : getDefaultSubstituters(config.settings)) {
         if (remaining.empty())
             break;
         if (sub->storeDir != storeDir)
@@ -521,7 +521,7 @@ StorePathSet Store::querySubstitutablePaths(const StorePathSet & paths)
 bool Store::isValidPath(const StorePath & storePath)
 {
     auto res = pathInfoCache->lock()->get(storePath);
-    if (res && res->isKnownNow(settings.getNarInfoDiskCacheSettings())) {
+    if (res && res->isKnownNow(config.settings.getNarInfoDiskCacheSettings())) {
         stats.narInfoReadAverted++;
         return res->didExist();
     }
@@ -587,7 +587,7 @@ std::optional<std::shared_ptr<const ValidPathInfo>> Store::queryPathInfoFromClie
     auto hashPart = std::string(storePath.hashPart());
 
     auto res = pathInfoCache->lock()->get(storePath);
-    if (res && res->isKnownNow(settings.getNarInfoDiskCacheSettings())) {
+    if (res && res->isKnownNow(config.settings.getNarInfoDiskCacheSettings())) {
         stats.narInfoReadAverted++;
         if (res->didExist())
             return std::make_optional(res->value);
@@ -1240,7 +1240,7 @@ void Store::signPathInfo(ValidPathInfo & info)
 {
     // FIXME: keep secret keys in memory.
 
-    auto secretKeyFiles = settings.secretKeyFiles;
+    auto secretKeyFiles = config.settings.secretKeyFiles;
 
     for (auto & secretKeyFile : secretKeyFiles.get()) {
         SecretKey secretKey(readFile(secretKeyFile));
@@ -1253,7 +1253,7 @@ void Store::signRealisation(Realisation & realisation)
 {
     // FIXME: keep secret keys in memory.
 
-    auto secretKeyFiles = settings.secretKeyFiles;
+    auto secretKeyFiles = config.settings.secretKeyFiles;
 
     for (auto & secretKeyFile : secretKeyFiles.get()) {
         SecretKey secretKey(readFile(secretKeyFile));

src/libstore/store-dir-config.cc

@@ -149,6 +149,7 @@ StoreDirConfig::makeFixedOutputPathFromCA(std::string_view name, const ContentAd
 }
 
 std::pair<StorePath, Hash> StoreDirConfig::computeStorePath(
+    const Settings & settings,
     std::string_view name,
     const SourcePath & path,
     ContentAddressMethod method,

src/libstore/store-registration.cc

@@ -6,24 +6,24 @@
 
 namespace nix {
 
-ref<Store> openStore()
+ref<Store> openStore(Settings & settings)
 {
-    return openStore(StoreReference{settings.storeUri.get()});
+    return openStore(settings, StoreReference{settings.storeUri.get()});
 }
 
-ref<Store> openStore(const std::string & uri, const Store::Config::Params & extraParams)
+ref<Store> openStore(Settings & settings, const std::string & uri, const Store::Config::Params & extraParams)
 {
-    return openStore(StoreReference::parse(uri, extraParams));
+    return openStore(settings, StoreReference::parse(uri, extraParams));
 }
 
-ref<Store> openStore(StoreReference && storeURI)
+ref<Store> openStore(Settings & settings, StoreReference && storeURI)
 {
-    auto store = resolveStoreConfig(std::move(storeURI))->openStore();
+    auto store = resolveStoreConfig(settings, std::move(storeURI))->openStore();
     store->init();
     return store;
 }
 
-ref<StoreConfig> resolveStoreConfig(StoreReference && storeURI)
+ref<StoreConfig> resolveStoreConfig(Settings & settings, StoreReference && storeURI)
 {
     auto & params = storeURI.params;
 
@@ -32,9 +32,9 @@ ref<StoreConfig> resolveStoreConfig(StoreReference && storeURI)
             [&](const StoreReference::Auto &) -> ref<StoreConfig> {
                 auto stateDir = getOr(params, "state", settings.nixStateDir.string());
                 if (access(stateDir.c_str(), R_OK | W_OK) == 0)
-                    return make_ref<LocalStore::Config>(params);
+                    return make_ref<LocalStore::Config>(settings, params);
                 else if (pathExists(settings.nixDaemonSocketFile))
-                    return make_ref<UDSRemoteStore::Config>(params);
+                    return make_ref<UDSRemoteStore::Config>(settings, params);
 #ifdef __linux__
                 else if (
                     !pathExists(stateDir) && params.empty() && !isRootUser() && !getEnv("NIX_STORE_DIR").has_value()
@@ -47,21 +47,21 @@ ref<StoreConfig> resolveStoreConfig(StoreReference && storeURI)
                         try {
                             createDirs(chrootStore);
                         } catch (SystemError & e) {
-                            return make_ref<LocalStore::Config>(params);
+                            return make_ref<LocalStore::Config>(settings, params);
                         }
                         warn("'%s' does not exist, so Nix will use '%s' as a chroot store", stateDir, chrootStore);
                     } else
                         debug("'%s' does not exist, so Nix will use '%s' as a chroot store", stateDir, chrootStore);
-                    return make_ref<LocalStore::Config>("local", chrootStore, params);
+                    return make_ref<LocalStore::Config>(settings, "local", chrootStore, params);
                 }
 #endif
                 else
-                    return make_ref<LocalStore::Config>(params);
+                    return make_ref<LocalStore::Config>(settings, params);
             },
             [&](const StoreReference::Specified & g) {
                 for (const auto & [storeName, implem] : Implementations::registered())
                     if (implem.uriSchemes.count(g.scheme))
-                        return implem.parseConfig(g.scheme, g.authority, params);
+                        return implem.parseConfig(settings, g.scheme, g.authority, params);
 
                 throw Error("don't know how to open Nix store with scheme '%s'", g.scheme);
             },
@@ -74,9 +74,9 @@ ref<StoreConfig> resolveStoreConfig(StoreReference && storeURI)
     return storeConfig;
 }
 
-std::list<ref<Store>> getDefaultSubstituters()
+std::list<ref<Store>> getDefaultSubstituters(Settings & settings)
 {
-    static auto stores([]() {
+    static auto stores([&]() {
         std::list<ref<Store>> stores;
 
         std::set<StoreReference> done;
@@ -85,7 +85,7 @@ std::list<ref<Store>> getDefaultSubstituters()
             if (!done.insert(ref).second)
                 return;
             try {
-                stores.push_back(openStore(StoreReference{ref}));
+                stores.push_back(openStore(settings, StoreReference{ref}));
             } catch (Error & e) {
                 logWarning(e.info());
             }

src/libstore/uds-remote-store.cc

@@ -20,11 +20,14 @@
 namespace nix {
 
 UDSRemoteStoreConfig::UDSRemoteStoreConfig(
-    std::string_view scheme, std::string_view authority, const StoreReference::Params & params)
-    : Store::Config{params}
-    , LocalFSStore::Config{params}
-    , RemoteStore::Config{params}
-    , path{authority.empty() ? settings.nixDaemonSocketFile.string() : authority}
+    nix::Settings & settings,
+    std::string_view scheme,
+    std::string_view authority,
+    const StoreReference::Params & params)
+    : Store::Config{settings, params}
+    , LocalFSStore::Config{settings, "", params}
+    , RemoteStore::Config{settings, params}
+    , path{authority.empty() ? settings.nixDaemonSocketFile.string() : std::string{authority}}
 {
     if (uriSchemes().count(scheme) == 0) {
         throw UsageError("Scheme must be 'unix'");
@@ -42,8 +45,8 @@ std::string UDSRemoteStoreConfig::doc()
 // empty string will later default to the same nixDaemonSocketFile. Why
 // don't we just wire it all through? I believe there are cases where it
 // will live reload so we want to continue to account for that.
-UDSRemoteStoreConfig::UDSRemoteStoreConfig(const Params & params)
-    : UDSRemoteStoreConfig(*uriSchemes().begin(), "", params)
+UDSRemoteStoreConfig::UDSRemoteStoreConfig(nix::Settings & settings, const Params & params)
+    : UDSRemoteStoreConfig(settings, *uriSchemes().begin(), "", params)
 {
 }
 

src/libutil-test-support/include/nix/util/tests/json-characterization.hh

@@ -86,9 +86,11 @@ void checkpointJson(CharacterizationTest & test, PathView testStem, const T & go
 /**
  * Specialization for when we need to do "JSON -> `ref<T>`" in one
  * direction, but "`const T &` -> JSON" in the other direction.
+ *
+ * Additional arguments are forwarded to `from_json` (e.g., settings).
  */
 template<typename T>
-void checkpointJson(CharacterizationTest & test, PathView testStem, const ref<T> & got)
+void checkpointJson(CharacterizationTest & test, PathView testStem, const ref<T> & got, auto... args)
 {
     using namespace nlohmann;
 
@@ -103,7 +105,7 @@ void checkpointJson(CharacterizationTest & test, PathView testStem, const ref<T>
     } else {
         json expectedJson = json::parse(readFile(file));
         ASSERT_EQ(gotJson, expectedJson);
-        ref<T> expected = adl_serializer<ref<T>>::from_json(expectedJson);
+        ref<T> expected = adl_serializer<ref<T>>::from_json(args..., expectedJson);
         ASSERT_EQ(*got, *expected);
     }
 }
@@ -137,9 +139,10 @@ struct JsonCharacterizationTest : virtual CharacterizationTest
         nix::writeJsonTest(*this, testStem, value);
     }
 
-    void checkpointJson(PathView testStem, const T & value)
+    template<typename... Args>
+    void checkpointJson(PathView testStem, const T & value, Args &&... args)
     {
-        nix::checkpointJson(*this, testStem, value);
+        nix::checkpointJson(*this, testStem, value, std::forward<Args>(args)...);
     }
 };
 

src/nix/add-to-store.cc

@@ -40,8 +40,10 @@ struct CmdAddToStore : MixDryRun, StoreCommand
 
         auto sourcePath = PosixSourceAccessor::createAtRoot(makeParentCanonical(path));
 
-        auto storePath = dryRun ? store->computeStorePath(*namePart, sourcePath, caMethod, hashAlgo, {}).first
-                                : store->addToStoreSlow(*namePart, sourcePath, caMethod, hashAlgo, {}).path;
+        auto storePath =
+            dryRun
+                ? store->computeStorePath(store->config.settings, *namePart, sourcePath, caMethod, hashAlgo, {}).first
+                : store->addToStoreSlow(*namePart, sourcePath, caMethod, hashAlgo, {}).path;
 
         logger->cout("%s", store->printStorePath(storePath));
     }

src/nix/build-remote/build-remote.cc

@@ -13,7 +13,6 @@
 #include "nix/main/shared.hh"
 #include "nix/main/plugin.hh"
 #include "nix/store/pathlocks.hh"
-#include "nix/store/globals.hh"
 #include "nix/util/serialise.hh"
 #include "nix/store/build-result.hh"
 #include "nix/store/store-open.hh"
@@ -81,7 +80,7 @@ static int main_build_remote(int argc, char ** argv)
 
         initPlugins();
 
-        auto store = openStore();
+        auto store = openStore(settings);
 
         /* It would be more appropriate to use $XDG_RUNTIME_DIR, since
            that gets cleared on reboot, but it wouldn't work on macOS. */
@@ -234,7 +233,7 @@ static int main_build_remote(int argc, char ** argv)
 
                     Activity act(*logger, lvlTalkative, actUnknown, fmt("connecting to '%s'", storeUri));
 
-                    sshStore = bestMachine->openStore();
+                    sshStore = bestMachine->openStore(settings);
                     sshStore->connect();
                 } catch (std::exception & e) {
                     auto msg = chomp(drainFD(5, {.block = false}));

src/nix/derivation-add.cc

@@ -6,6 +6,7 @@
 #include "nix/util/archive.hh"
 #include "nix/store/derivations.hh"
 #include "nix/store/globals.hh"
+#include "nix/main/shared.hh"
 #include <nlohmann/json.hpp>
 
 using namespace nix;

src/nix/flake-prefetch-inputs.cc

@@ -1,11 +1,12 @@
-#include "flake-command.hh"
-#include "nix/fetchers/fetch-to-store.hh"
-#include "nix/util/thread-pool.hh"
-#include "nix/store/filetransfer.hh"
-#include "nix/util/exit.hh"
-
 #include <nlohmann/json.hpp>
 
+#include "nix/util/thread-pool.hh"
+#include "nix/util/exit.hh"
+#include "nix/store/filetransfer.hh"
+#include "nix/fetchers/fetch-to-store.hh"
+
+#include "flake-command.hh"
+
 using namespace nix;
 using namespace nix::flake;
 

src/nix/flake.cc

@@ -1127,7 +1127,7 @@ struct CmdFlakeArchive : FlakeCommand, MixJSON, MixDryRun, MixNoCheckSigs
         }
 
         if (!dryRun && dstUri) {
-            ref<Store> dstStore = openStore(StoreReference{*dstUri});
+            ref<Store> dstStore = openStore(settings, StoreReference{*dstUri});
 
             copyPaths(*store, *dstStore, sources, NoRepair, checkSigs, substitute);
         }