src/libutil/include/nix/util/canon-path.hh (1)

263-264: Minor: mark hash_value noexcept

The hasher doesn’t throw; adding noexcept tightens the contract.

-    friend std::size_t hash_value(const CanonPath &);
+    friend std::size_t hash_value(const CanonPath &) noexcept;
@@
-inline std::size_t hash_value(const CanonPath & path)
+inline std::size_t hash_value(const CanonPath & path) noexcept
 {
     boost::hash<std::string_view> hasher;
     return hasher(path.path);
 }

Also applies to: 268-273

src/libstore/store-api.cc (3)

313-314: Constructor: ensure correct Sync wrapper construction and cache capacity type

Confirm that decltype(pathInfoCache)::element_type is the Sync wrapper type that forwards the (size_t) capacity to the underlying cache. If it is not forwarding args, the cache may be default-constructed, ignoring config.pathInfoCacheSize. If forwarding isn't guaranteed, prefer constructing the underlying cache explicitly via the Sync wrapper's factory or helper.

---

455-459: Client-side cache hit path looks good; minor perf tidy

LGTM on TTL-based early returns and stat accounting. To shave a few copies, consider precomputing auto key = storePath.to_string(); once per call and reuse it for get()/upsert() sites.

Also applies to: 538-545

---

814-815: Stats read is safe; consider exposing approximate size if lock-free needed later

Current readLock()->size() is fine. If this becomes a hot path, consider an approximate/atomic size to avoid reader lock contention.

src/libutil/mounted-source-accessor.cc (2)

65-68: getMount/resolve: verify ref-to-shared_ptr conversion and cvisit usage

• getMount() returns std::shared_ptr<SourceAccessor> but assigns ref<SourceAccessor> into optional and later returns *res. Ensure ref<T> is implicitly convertible to std::shared_ptr<T>; otherwise, unwrap explicitly.
• cvisit usage is fine; for clarity, capture by const auto & and return early when found.

Here’s a minimal, explicit return:

-        std::optional<ref<SourceAccessor>> res;
-        mounts.cvisit(mountPoint, [&](auto & x) { res = x.second; });
-        if (res)
-            return *res;
+        std::optional<ref<SourceAccessor>> res;
+        mounts.cvisit(mountPoint, [&](const auto & x) { res = x.second; });
+        if (res) {
+            // explicitly unwrap if implicit conversion is unavailable
+            return std::shared_ptr<SourceAccessor>(*res);
+        }

Also applies to: 87-95

---

16-20: Constructor: keep root mount invariant and avoid double-work

Asserting _mounts.contains(CanonPath::root) is good. Since you immediately call mount() in a loop, consider reserving in the concurrent map when available to reduce rehashing if _mounts is large.

src/libstore/local-store.cc (4)

432-441: Destructor: safe GC wait; minor nit on lock scope

Good pattern: capture gcFuture under lock, then wait without holding it. Nit: declare future inside the inner scope to narrow lifetime.

---

811-815: Lock churn: repeated _state->lock() inside tight loops

Multiple hot paths reacquire _state->lock() per call or per iteration (e.g., isValidPathUncached, queryAllValidPaths, queryValidDerivers, queryStaticPartialDerivationOutputMap, queryPathFromHashPart, registerValidPaths, invalidatePathChecked, addSignatures, queryRealisationUncached, verifyPath). Consider hoisting a single lock across each loop/transactional region to reduce mutex contention.

Example (pattern):

-    for (...) {
-        retrySQLite<void>([&]{ auto state(_state->lock()); ... });
-    }
+    retrySQLite<void>([&]{
+        auto state(_state->lock());
+        for (...) {
+            ...
+        }
+    });

Also applies to: 825-835, 845-849, 852-863, 868-879, 889-901, 953-1000, 1341-1357, 1566-1579, 1602-1631, 1527-1531

---

1441-1443: verifyStore: reuse single state lock for batched updates

Inside the content-check loop, each updatePathInfo(*_state->lock(), *info) re-locks. Cache a state lock once outside the loop to avoid repeated lock/unlock during DB updates.

Apply this small refactor:

-        for (auto & i : validPaths) {
+        auto state(_state->lock());
+        for (auto & i : validPaths) {
             ...
-            if (update)
-                updatePathInfo(*_state->lock(), *info);
+            if (update)
+                updatePathInfo(*state, *info);

---

1561-1562: VACUUM under lock (LGTM); consider exclusive DB phase warning

Running vacuum under the state lock is fine. If this is user-facing, consider a brief log line as it may block writers.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.