@lzehrung/codegraph 2.1.0 → 2.1.1

package/dist/indexer/build-index.js

@@ -8,7 +8,7 @@ import { loadWorkspaceConfig, resolveWorkspacePackage } from "../util/workspace.
 import { DEFAULT_PROJECT_PATTERNS, discoverProjectFiles, listProjectFiles, } from "../util/projectFiles.js";
 import { getGitHead, isGitRepo, getGitBlobHashes, listChangedFiles } from "../util/git.js";
 import { clearImportResolutionCaches, resolveSpecifier } from "../util/resolution.js";
-import { assertFilePathWithinRoot, fileIdentityKey, initializeFileIdentityCaseSensitivity, normalizePath, } from "../util/paths.js";
+import { assertFilePathWithinRoot, fileIdentityKey, initializeFileIdentityCaseSensitivity, isFilePathWithinRoot, normalizePath, } from "../util/paths.js";
 import { mapLimit } from "../util/concurrency.js";
 import { resolveWorkerThreadCount } from "../util/workerThreads.js";
 import { logWithLevel } from "../logging.js";
@@ -26,8 +26,9 @@ import { initNativeBackendReport } from "../native/nativeBackendReport.js";
 import { closeDuplicateUnitCacheDatabase } from "../duplicates.js";
 import { isNativeRequiredUnavailableError } from "../native/treeSitterNative.js";
 import { isNodeSqliteUnavailableError } from "../sqlite-driver.js";
-import { buildBloomFilterForFile, cacheSignatureForFile, closeDiskCacheDatabase, collectWorkspaceManifestDependencyEdges, computeConfigHash, createFallbackImportExtractionHandler, diffBuildOptions, fileSignature, graphOptionsEqual, initFileReport, initManifestReport, loadManifest, normalizeGraphOptions, normalizeIndexedFileInputs, normalizeLanguageExtensions, projectSnapshotFilesSignature, recordConfigHashResult, recordFileFailure, sanitizeManifestEntriesForRoot, sanitizeManifestTransientFilesForRoot, tryLoadFromCache, tryLoadPersistedBloomFilters, tryLoadProjectIndexSnapshot, verifyManifestEntries, writeProjectIndexSnapshot, writeToCache, } from "./build-cache.js";
-import { cacheRoot } from "./build-cache/module-cache.js";
+import { buildBloomFilterForFile, cacheSignatureForFile, closeDiskCacheDatabase, collectWorkspaceManifestDependencyEdges, computeConfigHash, createFallbackImportExtractionHandler, diffBuildOptions, fileSignature, graphOptionsEqual, initFileReport, initManifestReport, loadManifest, normalizeGraphOptions, normalizeIndexedFileInputs, normalizeLanguageExtensions, projectSnapshotFilesSignature, recordConfigHashResult, recordFileFailure, sanitizeManifestEntriesForRoot, sanitizeManifestTransientFilesForRoot, tryLoadFromCache, tryLoadPersistedBloomFilters, tryLoadProjectIndexSnapshot, tryLoadProjectSnapshotModules, verifyManifestEntries, writeModulesToCache, writeProjectIndexSnapshot, writeToCache, } from "./build-cache.js";
+import { computeResolverEnvironmentFingerprint } from "./build-cache/resolver-environment.js";
+import { cacheRoot } from "./build-cache/location.js";
 import { SymbolKind, } from "./types.js";
 import { isNonNativeParserUnavailableError, isParserSyntaxTree } from "../parserBackend.js";
 import { isUnsupportedParserInputError } from "../languages/filePrep.js";
@@ -88,17 +89,21 @@ async function resolveCrossModuleSymbolExports(file, mod, support, projectRoot,
             continue;
         }
         if (entry.fromModule.startsWith(".")) {
+            entry.moduleSpecifier ??= entry.fromModule;
             const resolved = await resolveSpecifier(file, entry.fromModule, projectRoot, matchPath, workspaceConfig, {
                 resolveNodeModules: !!graphOptions.resolveNodeModules,
                 ...(graphOptions.resolutionHints ? { resolutionHints: graphOptions.resolutionHints } : {}),
             });
-            if (typeof resolved === "string")
+            if (typeof resolved === "string" && isFilePathWithinRoot(projectRoot, resolved))
                 entry.fromModule = resolved;
             continue;
         }
         const pkgResolved = await resolveWorkspacePackage(entry.fromModule, workspaceConfig);
-        if (pkgResolved)
-            entry.fromModule = pkgResolved;
+        if (pkgResolved) {
+            entry.moduleSpecifier ??= entry.fromModule;
+            if (isFilePathWithinRoot(projectRoot, pkgResolved))
+                entry.fromModule = pkgResolved;
+        }
     }
 }
 async function buildIndexedModuleForFile(args) {
@@ -108,7 +113,16 @@ async function buildIndexedModuleForFile(args) {
     let tree;
     const graphOnlyLanguage = isGraphOnlyLanguage(sup.id);
     if (prepared.syntaxTree) {
-        tree = new ProjectedSyntaxTree(source, prepared.syntaxTree);
+        const parsedTree = new ProjectedSyntaxTree(source, prepared.syntaxTree);
+        tree = parsedTree;
+        setParsedCacheEntry(args.parsedMap, args.file, {
+            source,
+            tree: parsedTree,
+            sup,
+            ...(resolvedLang ? { lang: resolvedLang } : {}),
+            ...(embeddedBlocks ? { embeddedBlocks } : {}),
+            nativeQueries,
+        }, args.parsedCacheMaxEntries);
     }
     else if (!nativeQueries && !graphOnlyLanguage && sup.id !== "sql") {
         const parseAttempt = attemptParsePreparedFileContext(prepared);
@@ -135,13 +149,23 @@ async function buildIndexedModuleForFile(args) {
         if (parsed) {
             tree = parsed.tree;
             resolvedLang = parsed.lang ?? resolvedLang;
+            setParsedCacheEntry(args.parsedMap, args.file, parsed, args.parsedCacheMaxEntries);
         }
     }
     const lacksParserContext = !nativeQueries && !tree;
     if (args.bloomFilterCache) {
-        const filter = buildBloomFilterFromSource(source, sup.id);
+        const filter = buildBloomFilterFromSource(source, sup);
         args.bloomFilterCache.set(args.file, filter);
     }
+    // Single builder so an option added here always reaches both the primary source and
+    // every embedded (SFC) block, instead of one path silently missing a future option.
+    const sharedImportOptions = {
+        graphOptions: args.graphOptions,
+        ...(args.opts?.native ? { native: args.opts.native } : {}),
+        ...(args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {}),
+        ...(args.opts?.languageExtensions ? { languageExtensions: args.opts.languageExtensions } : {}),
+        ...(args.onFallbackImportExtraction ? { onFallbackImportExtraction: args.onFallbackImportExtraction } : {}),
+    };
     const imports = sup.id === "sql"
         ? []
         : await collectImportsForFile(args.file, args.projectRoot, {
@@ -150,21 +174,13 @@ async function buildIndexedModuleForFile(args) {
             sup,
             ...(resolvedLang ? { lang: resolvedLang } : {}),
             ...(nativeQueries !== undefined ? { nativeQueries } : {}),
-            graphOptions: args.graphOptions,
-            ...(args.opts?.native ? { native: args.opts.native } : {}),
-            ...(args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {}),
-            ...(args.opts?.languageExtensions ? { languageExtensions: args.opts.languageExtensions } : {}),
-            ...(args.onFallbackImportExtraction ? { onFallbackImportExtraction: args.onFallbackImportExtraction } : {}),
+            ...sharedImportOptions,
         });
     for (const block of embeddedBlocks ?? []) {
         imports.push(...(await collectImportsForFile(args.file, args.projectRoot, {
             source: block.source,
             sup: block.sup,
-            graphOptions: args.graphOptions,
-            ...(args.opts?.native ? { native: args.opts.native } : {}),
-            ...(args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {}),
-            ...(args.opts?.languageExtensions ? { languageExtensions: args.opts.languageExtensions } : {}),
-            ...(args.onFallbackImportExtraction ? { onFallbackImportExtraction: args.onFallbackImportExtraction } : {}),
+            ...sharedImportOptions,
         })));
     }
     collectJsonDependencies(imports, args.jsonDependencies);
@@ -187,14 +203,16 @@ async function buildIndexedModuleForFile(args) {
     await resolveCrossModuleSymbolExports(args.file, mod, sup, args.projectRoot, args.graphOptions, args.workspaceConfig, args.opts?.logLevel);
     const sigInfo = args.fileSignatures.get(args.file);
     const cacheable = !prepared.nativeFallbackReason && !lacksParserContext;
+    let cacheWrite;
     if (sigInfo && cacheable) {
         const cacheSig = args.cacheEnabled
-            ? await moduleCacheSignatureForFile(args.file, sigInfo, args.opts)
+            ? await moduleCacheSignatureForFile(args.file, sigInfo, args.opts, args.resolverEnvironmentFingerprint)
             : sigInfo.cacheSig;
-        writeToCache(args.projectRoot, args.file, cacheSig, mod, args.opts);
+        cacheWrite = { file: args.file, sig: cacheSig, mod };
     }
     return {
         module: mod,
+        ...(cacheWrite !== undefined ? { cacheWrite } : {}),
         graphContext: {
             source,
             sup,
@@ -242,19 +260,24 @@ function graphEdgeKey(edge) {
     const target = edge.to.type === "file" ? `file:${fileIdentityKey(edge.to.path)}` : `external:${edge.to.name}`;
     return `${from}::${target}::${edge.raw ?? ""}::${edge.typeOnly ? 1 : 0}`;
 }
-async function moduleCacheSignatureForFile(file, sigInfo, opts) {
+async function moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint) {
     const baseSignature = await cacheSignatureForFile(file, sigInfo, opts);
     const normalizedExtensions = normalizeLanguageExtensions(opts?.languageExtensions);
-    if (!normalizedExtensions)
+    const resolveNodeModules = normalizeGraphOptions(opts?.graph).resolveNodeModules;
+    if (!normalizedExtensions && !resolveNodeModules)
         return baseSignature;
     // Combine via a hash rather than raw concatenation: the disk cache stores this string in a
     // SQLite TEXT column, and node:sqlite's DatabaseSync silently truncates TEXT bind parameters
     // at embedded NUL bytes, so a raw separator character risks the stored and freshly-computed
     // signatures never matching (permanent cache miss) if either baseSignature or the serialized
-    // extensions ever contained one.
+    // extensions ever contained one. A cached ModuleIndex's ImportBinding.resolved values differ
+    // depending on whether resolveNodeModules was on at write time (resolved node_modules targets
+    // vs. external), so that state and the environment that produced it must be part of the key.
     const hash = crypto.createHash("sha1");
     hash.update(baseSignature);
-    hash.update(JSON.stringify(Object.entries(normalizedExtensions)));
+    hash.update(JSON.stringify(Object.entries(normalizedExtensions ?? {})));
+    hash.update(resolveNodeModules ? "\0resolveNodeModules" : "");
+    hash.update(resolverEnvironmentFingerprint === null ? "\0resolverEnvironmentTooLarge" : (resolverEnvironmentFingerprint ?? ""));
     return hash.digest("hex");
 }
 function projectPatternsForLanguageExtensions(opts) {
@@ -325,9 +348,14 @@ function expandStarImports(modules, opts) {
     }
 }
 function toProjectIndexManifestEntry(entry) {
+    // A git signature alone is already a strong content identity (`fileSignature()` derives
+    // `cacheSig` the same way: `gitSig ?? contentHash ?? sig`), so entries sourced from the disk
+    // manifest (which does not persist `cacheSig`) still get one whenever `gitSig` is available.
+    const cacheSig = entry.cacheSig ?? entry.gitSig;
     return {
         sig: entry.sig,
         ...(entry.gitSig ? { gitSig: entry.gitSig } : {}),
+        ...(cacheSig ? { cacheSig } : {}),
     };
 }
 function projectIndexManifestEntries(entries) {
@@ -339,7 +367,7 @@ function createIndexBuildRunState(projectRoot, opts, graphOptions = normalizeGra
         initNativeBackendReport(report);
     const cacheMode = opts?.cache ?? "off";
     return {
-        normalizedProjectRoot: normalizePath(projectRoot),
+        normalizedProjectRoot: normalizePath(path.resolve(projectRoot)),
         report,
         timings: report?.timings,
         totalStart: performance.now(),
@@ -371,7 +399,7 @@ function buildConcurrency(opts) {
 async function prepareFileSignatures(args) {
     const entries = await mapLimit(args.files, args.concurrency, async (file) => {
         const gitSig = args.gitSigMap.get(file);
-        const sigInfo = await fileSignature(file, args.opts?.cacheStrict, gitSig, {
+        const sigInfo = await fileSignature(file, args.needsContentHash ? args.opts?.cacheStrict : false, gitSig, {
             forceContentHash: args.cacheEnabled && !gitSig,
         });
         return [file, sigInfo];
@@ -403,6 +431,16 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const manifestOptionDiffs = manifest ? diffBuildOptions(manifest.buildOptions, opts) : [];
     const languageExtensionsChanged = manifestOptionDiffs.includes("languageExtensions");
     const implementationChanged = manifestOptionDiffs.includes("implementation");
+    let resolverEnvironmentFingerprint;
+    let resolverEnvironmentMatchesManifest = true;
+    if (cacheEnabled && graphOptions.resolveNodeModules) {
+        resolverEnvironmentFingerprint = await computeResolverEnvironmentFingerprint(projectRoot, normalizedFiles);
+        if (useManifest) {
+            resolverEnvironmentMatchesManifest =
+                resolverEnvironmentFingerprint !== null &&
+                    manifest?.resolverEnvironmentFingerprint === resolverEnvironmentFingerprint;
+        }
+    }
     if (timings && useManifest) {
         timings.manifestMs = Math.round(performance.now() - manifestStart);
     }
@@ -426,6 +464,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const cachedGraphEntries = manifest &&
         !languageExtensionsChanged &&
         !implementationChanged &&
+        resolverEnvironmentMatchesManifest &&
         graphOptionsEqual(manifest.graphOptions, graphOptions)
         ? new Map(Object.entries(manifestFiles).filter(([file]) => !staleCachedEdgeFiles.has(file)))
         : undefined;
@@ -459,6 +498,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         opts,
         gitSigMap,
         cacheEnabled,
+        needsContentHash: true,
         concurrency: conc,
     });
     const sqlCorpusSig = sqlCorpusSignature(sqlFiles, fileSignatures);
@@ -520,8 +560,13 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     if (initialManifestEntry)
                         manifestEntries.set(file, initialManifestEntry);
                 }
-                const cacheSig = cacheEnabled ? await moduleCacheSignatureForFile(file, sigInfo, opts) : sigInfo.cacheSig;
-                let mod = cacheEnabled ? tryLoadFromCache(projectRoot, file, cacheSig, opts, report) : null;
+                const cacheSig = cacheEnabled
+                    ? await moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint)
+                    : sigInfo.cacheSig;
+                const canReuseModuleCache = cacheEnabled && (!graphOptions.resolveNodeModules || resolverEnvironmentFingerprint !== null);
+                let mod = canReuseModuleCache
+                    ? tryLoadFromCache(projectRoot, file, cacheSig, opts, report)
+                    : null;
                 if (mod && fileReport) {
                     fileReport.cached = (fileReport.cached ?? 0) + 1;
                 }
@@ -555,7 +600,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                         ...(sqlFactCache ? { sqlFactCache } : {}),
                     });
                     if (bloomFilterCache) {
-                        const persistedFilter = persistedBloomFilters?.get(file);
+                        const persistedFilter = persistedBloomFilters?.get(file, sigInfo);
                         if (persistedFilter) {
                             bloomFilterCache.set(file, persistedFilter);
                         }
@@ -565,15 +610,16 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                                 bloomFilterCache.set(file, filter);
                         }
                     }
-                    return [file, mod, edges];
+                    return [file, mod, edges, undefined];
                 }
                 if (fileReport)
                     fileReport.parsed = (fileReport.parsed ?? 0) + 1;
                 const support = supportForFile(file, opts?.languageExtensions);
                 if (!support)
-                    return [file, createEmptyModuleIndex(file), []];
+                    return [file, createEmptyModuleIndex(file), [], undefined];
                 ensureBuildProgressStarted();
                 let graphContext;
+                let cacheWrite;
                 if (!mod) {
                     const built = await buildIndexedModuleForFile({
                         file,
@@ -584,6 +630,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                         graphOptions,
                         workspaceConfig,
                         workerSetup,
+                        ...(resolverEnvironmentFingerprint !== undefined ? { resolverEnvironmentFingerprint } : {}),
                         parsedMap,
                         parsedCacheMaxEntries: parsedCacheMaxEntries(opts),
                         jsonDependencies,
@@ -594,6 +641,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     });
                     mod = built.module;
                     graphContext = built.graphContext;
+                    cacheWrite = built.cacheWrite;
                 }
                 else {
                     collectJsonDependencies(mod.imports, jsonDependencies);
@@ -619,13 +667,13 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     allFiles: normalizedFiles,
                     ...(sqlFactCache ? { sqlFactCache } : {}),
                 });
-                return [file, mod ?? createEmptyModuleIndex(file), edges];
+                return [file, mod ?? createEmptyModuleIndex(file), edges, cacheWrite];
             }
             catch (error) {
                 if (isNativeRequiredUnavailableError(error) || isNodeSqliteUnavailableError(error))
                     throw error;
                 if (isUnsupportedParserInputError(error) || isNonNativeParserUnavailableError(error)) {
-                    return [file, createEmptyModuleIndex(file), []];
+                    return [file, createEmptyModuleIndex(file), [], undefined];
                 }
                 recordFileFailure(report, file, error);
                 logWithLevel(opts?.logLevel, "warn", `Warning: Failed to process file ${file}:`, error);
@@ -662,11 +710,17 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     graph.nodes.add(edge.to.path);
             }
         };
-        for (const [file, mod, edges] of fileResults) {
+        const pendingCacheWrites = [];
+        for (const [file, mod, edges, cacheWrite] of fileResults) {
             modules.set(fileIdentityKey(file), mod);
             appendUniqueGraphEdges(edges);
+            if (cacheWrite)
+                pendingCacheWrites.push(cacheWrite);
+        }
+        if (pendingCacheWrites.length) {
+            writeModulesToCache(projectRoot, pendingCacheWrites, opts);
         }
-        const workspaceManifestEdges = await collectWorkspaceManifestDependencyEdges(projectRoot, opts?.discovery, new Set(normalizedFiles), opts?.logLevel);
+        const workspaceManifestEdges = await collectWorkspaceManifestDependencyEdges(projectRoot, normalizedFiles.filter((file) => path.basename(file) === "package.json"), opts?.discovery, opts?.logLevel);
         appendUniqueGraphEdges(workspaceManifestEdges);
         if (timings)
             timings.graphMs = Math.round(performance.now() - graphStart);
@@ -679,6 +733,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 projectRoot,
                 opts,
                 graphOptions,
+                ...(resolverEnvironmentFingerprint ? { resolverEnvironmentFingerprint } : {}),
                 files: manifestEntries,
                 timings,
                 manifestReport: report?.manifest,
@@ -701,7 +756,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             manifestEntries: manifestEntriesForIndex,
         });
         if (manifestEntries) {
-            await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries));
+            await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot));
         }
         if (buildStartedAt !== undefined) {
             emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance.now() - buildStartedAt);
@@ -907,8 +962,21 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
         const currentConfigHashResult = await computeConfigHash(projectRoot, opts?.logLevel);
         const currentConfigHash = recordConfigHashResult(manifestReport, currentConfigHashResult, opts?.logLevel);
         const configChanged = !!currentConfigHashResult.error || !manifest?.configHash || currentConfigHash !== manifest.configHash;
+        let resolverEnvironmentFingerprint;
+        let resolverEnvironmentMatchesManifest = true;
+        if (manifest && graphOptions.resolveNodeModules) {
+            resolverEnvironmentFingerprint = await computeResolverEnvironmentFingerprint(projectRoot, Object.keys(manifest.files));
+            resolverEnvironmentMatchesManifest =
+                resolverEnvironmentFingerprint !== null &&
+                    manifest.resolverEnvironmentFingerprint === resolverEnvironmentFingerprint;
+        }
         const requiresFullRebuild = optionDiffs.some((diff) => diff === "discovery" || diff === "native" || diff === "implementation" || diff === "languageExtensions");
-        if (!manifest || !graphOptionsEqual(manifest.graphOptions, graphOptions) || configChanged || requiresFullRebuild) {
+        const graphOptionsChanged = !graphOptionsEqual(manifest?.graphOptions, graphOptions);
+        if (!manifest ||
+            graphOptionsChanged ||
+            configChanged ||
+            requiresFullRebuild ||
+            !resolverEnvironmentMatchesManifest) {
             if (manifest && configChanged) {
                 logWithLevel(opts?.logLevel, "warn", "Configuration changed, rebuilding index...");
             }
@@ -920,6 +988,9 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 else if (configChanged) {
                     reason = "configChanged";
                 }
+                else if (!graphOptionsChanged && !resolverEnvironmentMatchesManifest) {
+                    reason = "resolverEnvironmentChanged";
+                }
                 manifestReport.reason = reason;
                 manifestReport.reused = false;
             }
@@ -981,7 +1052,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
             manifestFileKeys.some((file) => !Object.hasOwn(trackedEntries, file));
         const explicitFiles = normalizeIndexedFileInputs(projectRoot, opts?.files ?? [], "Incremental file");
         const additionalFiles = normalizeIndexedFileInputs(projectRoot, opts?.additionalFiles ?? [], "Additional index file");
-        const previousTransientFiles = sanitizeManifestTransientFilesForRoot(projectRoot, manifest.transientFiles).filter((file) => Object.hasOwn(trackedEntries, file));
+        const previousTransientFiles = sanitizeManifestTransientFilesForRoot(projectRoot, projectRoot, manifest.transientFiles).filter((file) => Object.hasOwn(trackedEntries, file));
         const previousTransientFileSet = new Set(previousTransientFiles);
         const needsGitScan = !!opts?.gitBase || !!opts?.changedSince;
         const gitFiles = needsGitScan ? await listChangedFiles(projectRoot, buildIncrementalGitDiffOptions(opts)) : [];
@@ -1067,6 +1138,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 projectRoot,
                 opts,
                 graphOptions,
+                ...(resolverEnvironmentFingerprint ? { resolverEnvironmentFingerprint } : {}),
                 files: {},
                 timings,
                 manifestReport,
@@ -1087,6 +1159,10 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
             };
         }
         const changedFiles = new Set();
+        if (!resolverEnvironmentMatchesManifest) {
+            for (const file of allFiles)
+                changedFiles.add(file);
+        }
         const markAsChanged = (file) => {
             if (allFiles.has(file))
                 changedFiles.add(file);
@@ -1203,6 +1279,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 opts,
                 gitSigMap,
                 cacheEnabled,
+                needsContentHash: cacheEnabled || manifestUsed || opts?.cacheStrict === true,
                 concurrency: conc,
             });
             const modules = new Map();
@@ -1248,20 +1325,30 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 completeCheckProgress(allFiles.size);
                 return unchangedSnapshot;
             }
+            const snapshotModules = cacheEnabled
+                ? await tryLoadProjectSnapshotModules(projectRoot, opts, fileSignatures)
+                : null;
             const persistedBloomFilters = bloomFilterCache ? await tryLoadPersistedBloomFilters(projectRoot, opts) : null;
             for (const file of allFiles) {
                 if (changedFiles.has(file))
                     continue;
                 const sigInfo = fileSignatures.get(file);
-                const cacheSig = cacheEnabled ? await moduleCacheSignatureForFile(file, sigInfo, opts) : sigInfo.cacheSig;
-                const cached = cacheEnabled ? tryLoadFromCache(projectRoot, file, cacheSig, opts, report) : null;
+                let cached = null;
+                const snapshotMod = snapshotModules?.get(fileIdentityKey(file));
+                if (snapshotMod) {
+                    cached = snapshotMod;
+                }
+                else if (cacheEnabled) {
+                    const cacheSig = await moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint);
+                    cached = tryLoadFromCache(projectRoot, file, cacheSig, opts, report);
+                }
                 if (cached) {
                     if (fileReport)
                         fileReport.cached = (fileReport.cached ?? 0) + 1;
                     modules.set(fileIdentityKey(file), cached);
                     collectJsonDependencies(cached.imports, jsonDependencies);
                     if (bloomFilterCache) {
-                        const persistedFilter = persistedBloomFilters?.get(file);
+                        const persistedFilter = persistedBloomFilters?.get(file, sigInfo);
                         if (persistedFilter) {
                             bloomFilterCache.set(file, persistedFilter);
                         }
@@ -1312,8 +1399,9 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                             onFallbackImportExtraction,
                             fileSignatures,
                             cacheEnabled,
+                            ...(resolverEnvironmentFingerprint !== undefined ? { resolverEnvironmentFingerprint } : {}),
                         });
-                        return [file, built.module];
+                        return [file, built.module, built.cacheWrite];
                     }
                     catch (error) {
                         if (isNativeRequiredUnavailableError(error) || isNodeSqliteUnavailableError(error))
@@ -1323,7 +1411,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                         }
                         recordFileFailure(report, file, error);
                         logWithLevel(opts?.logLevel, "warn", `Warning: Failed to process file ${file}:`, error);
-                        return [file, createEmptyModuleIndex(file)];
+                        return [file, createEmptyModuleIndex(file), undefined];
                     }
                     finally {
                         if (opts?.onProgress) {
@@ -1338,8 +1426,14 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                         }
                     }
                 });
-                for (const [file, mod] of fileResults) {
+                const pendingIncrementalCacheWrites = [];
+                for (const [file, mod, cacheWrite] of fileResults) {
                     modules.set(fileIdentityKey(file), mod);
+                    if (cacheWrite)
+                        pendingIncrementalCacheWrites.push(cacheWrite);
+                }
+                if (pendingIncrementalCacheWrites.length) {
+                    writeModulesToCache(projectRoot, pendingIncrementalCacheWrites, opts);
                 }
                 if (timings)
                     timings.parseMs = Math.round(performance.now() - parseStart);
@@ -1349,7 +1443,9 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
             }
             expandStarImports(modules, opts);
             const retainedTrackedEntries = Object.entries(trackedEntries).filter(([file]) => !deletedTrackedFiles.has(file));
-            const cachedGraphEntries = new Map(retainedTrackedEntries);
+            const cachedGraphEntries = resolverEnvironmentMatchesManifest
+                ? new Map(retainedTrackedEntries)
+                : new Map();
             const manifestEntries = new Map(cachedGraphEntries);
             const baseGraph = cachedGraphEntries.size > 0 ? { nodes: new Set(), edges: [] } : undefined;
             if (baseGraph) {
@@ -1406,6 +1502,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 projectRoot,
                 opts,
                 graphOptions,
+                ...(resolverEnvironmentFingerprint ? { resolverEnvironmentFingerprint } : {}),
                 files: manifestEntries,
                 timings,
                 manifestReport,
@@ -1422,10 +1519,20 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 modules,
                 parsedMap,
                 bloomFilterCache,
-                manifestEntries: projectIndexManifestEntries(manifestEntries),
+                manifestEntries: projectIndexManifestEntries(
+                // `manifestEntries` (a `ManifestFileEntry`) never carries `cacheSig` -- that field
+                // only lives on `FileSignature`. Overlay each entry with the `cacheSig` this build
+                // actually computed (content-hash-derived for non-git files, since caching is enabled
+                // whenever this path runs) so incremental writes preserve the same strong identity a
+                // cold build produces, instead of leaving snapshot/bloom reuse to fall back to the
+                // weak `mtime:size` `sig`.
+                Array.from(manifestEntries, ([file, entry]) => {
+                    const cacheSig = fileSignatures.get(file)?.cacheSig;
+                    return [file, { ...entry, ...(cacheSig ? { cacheSig } : {}) }];
+                })),
                 buildReport: report,
             });
-            await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries));
+            await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot));
             if (updateStartedAt !== undefined) {
                 emitIndexLifecycleProgress(opts, "complete", "update", index.byFile.size, performance.now() - updateStartedAt);
             }