@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/indexer/build-index.js

@@ -4,12 +4,16 @@ import fsp from "node:fs/promises";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
 import { languageExtensionPatterns, supportForFile, supportForFileWithoutHeaderSample, } from "../languages.js";
+import { DECLARATION_RESOLVED_IMPORT_LANGUAGES } from "./import-resolution-tables.js";
 import { isJsTsLanguage } from "../languages/js-family.js";
 import { loadWorkspaceConfig, resolveWorkspacePackage } from "../util/workspace.js";
 import { DEFAULT_PROJECT_PATTERNS, createProjectDiscoveryContext, discoverProjectFilesWithGitCandidates, listProjectFilesWithGitCandidates, } from "../util/project-files.js";
 import { getGitHead, isGitRepo, getGitBlobHashes, listChangedFiles } from "../util/git.js";
 import { clearResolutionCaches, loadNearestTsconfigFor, resolveSpecifier, } from "../util/resolution.js";
-import { collectCppDeclaredModules } from "../util/resolution/cpp.js";
+import { collectCppDeclaredModules, isCppNamedModuleSpecifier } from "../util/resolution/cpp.js";
+import { resolveJvmPackageImportPaths } from "../util/resolution/jvm.js";
+import { loadTsconfigResolutionInputsFor } from "../util/resolution/tsconfig.js";
+import { resolveModuleSpecifierEdges } from "../graphs/edge-resolution.js";
 import { fileIdentityKey, initializeFileIdentityCaseSensitivity, isFilePathWithinRoot, normalizePath, } from "../util/paths.js";
 import { mapLimit } from "../util/concurrency.js";
 import { readConfinedUtf8File } from "../util/confined-file.js";
@@ -28,9 +32,9 @@ import { compareEdges, edgeKey, toRelativeEdge } from "./shared.js";
 import { BloomFilter, buildBloomFilterFromSource } from "../util/bloom-filter.js";
 import { initNativeBackendReport } from "../native/native-backend-report.js";
 import { closeDuplicateUnitCacheDatabase } from "../duplicates.js";
-import { isNativeRequiredUnavailableError } from "../native/tree-sitter-native.js";
+import { assertNativeRequiredAvailable, isNativeRequiredUnavailableError } from "../native/tree-sitter-native.js";
 import { isNodeSqliteUnavailableError } from "../sqlite-driver.js";
-import { buildBloomFilterForFile, cacheSignatureForFile, closeDiskCacheDatabase, diskModuleCacheExists, collectWorkspaceManifestDependencyEdges, computeConfigHash, createFallbackImportExtractionHandler, diffBuildOptions, fileSignature, fileSignatureFromSource, graphOptionsEqual, initFileReport, initManifestReport, loadManifest, normalizeGraphOptions, normalizeIndexedFileInputs, normalizeIndexedFileInputsWithinRoot, normalizeLanguageExtensions, projectSnapshotFilesSignature, recordConfigHashResult, recordFileFailure, sanitizeManifestEntriesForRoot, sanitizeManifestTransientFilesForRoot, tryLoadFromCache, tryLoadPersistedBloomFilters, tryLoadProjectIndexSnapshot, tryLoadProjectSnapshotModules, verifyManifestEntries, writeModulesToCache, writeProjectIndexSnapshot, } from "./build-cache.js";
+import { buildBloomFilterForFile, cacheSignatureForFile, closeDiskCacheDatabase, diskModuleCacheExists, collectWorkspaceManifestDependencyEdges, computeConfigHash, diffBuildOptions, fileSignature, fileSignatureFromSource, graphOptionsEqual, initFileReport, initManifestReport, loadManifest, normalizeGraphOptions, normalizeIndexedFileInputs, normalizeIndexedFileInputsWithinRoot, normalizeLanguageExtensions, projectSnapshotFilesSignature, recordConfigHashResult, recordFileFailure, sanitizeManifestEntriesForRoot, sanitizeManifestTransientFilesForRoot, listDiskCachedModuleFiles, listMemoryCachedModuleFiles, loadModuleFromCache, memoryCacheEvictionSerial, memoryCacheLostPayloads, peekCachedModule, removeModulesFromCache, settleMemoryCacheEvictions, tryLoadFromCache, tryLoadPersistedBloomFilters, tryLoadProjectIndexSnapshot, tryLoadProjectSnapshotModules, verifyManifestEntries, writeModulesToCache, writeProjectIndexSnapshot, } from "./build-cache.js";
 import { computeResolverEnvironmentFingerprint } from "./build-cache/resolver-environment.js";
 import { cacheRoot } from "./build-cache/location.js";
 import { SymbolKind, } from "./types.js";
@@ -39,7 +43,7 @@ import { buildSqlFactCache, buildSqlModuleIndex, sqlCorpusSignature } from "../s
 import { finalizeProjectIndex } from "./finalize.js";
 import { toManifestFileEntry, writeIndexManifestSnapshot } from "./build-manifest.js";
 import { prepareFileContextForBuild, countNativeWorkerEligibleFiles, emptyWorkerPoolSetup, setupWorkerPool, teardownWorkerPool, } from "./build-workers.js";
-import { buildIncrementalGitDiffOptions, canUseIncrementalDiscoveryFastPath, buildTrackedFileReverseDependencies, collectDeletedTrackedFileDependents, collectTrackedFileDependents, isMissingGitRevisionError, listUntrackedProjectFiles, partitionTrackedManifestFiles, probePathExistence, } from "./incremental-plan.js";
+import { buildIncrementalGitDiffOptions, canUseIncrementalDiscoveryFastPath, buildTrackedFileReverseDependencies, addedResolutionStems, collectDeletedTrackedFileDependents, collectTrackedFileDependents, collectSpecifierEdgeCandidates, collectPythonPackageImporters, pythonImportersOfPackageInits, externalSpecifierMatchesAddedStem, tsconfigAliasMappedTails, isMissingGitRevisionError, listUntrackedProjectFiles, partitionTrackedManifestFiles, probePathExistence, } from "./incremental-plan.js";
 import { parsedCacheMaxEntries, setParsedCacheEntry } from "./parsed-cache.js";
 function initParserBackendDegradationReport(report) {
     if (!report)
@@ -147,6 +151,114 @@ function manifestDeclaredContainerIndex(manifest) {
         return new Map();
     return new Map(Object.entries(entries));
 }
+/**
+ * Declared C++ modules of added or changed files. The cache cannot supply them.
+ * A regex over the source finds them without a parse.
+ * Without them, a second file that declares an existing module name goes unnoticed,
+ * and the importer keeps its old target.
+ */
+async function collectCppMissDeclaredContainers(files, concurrency, confined) {
+    const byName = new Map();
+    await mapLimit([...files], concurrency, async (file) => {
+        let source = confined?.trustedSources?.get(file);
+        if (source === undefined) {
+            try {
+                source =
+                    confined?.confinedRoot && confined?.projectRoot
+                        ? await readConfinedUtf8File(confined.confinedRoot, confined.projectRoot, file)
+                        : await fsp.readFile(file, "utf8");
+            }
+            catch {
+                return;
+            }
+        }
+        for (const name of collectCppDeclaredModules(source)) {
+            let bucket = byName.get(name);
+            if (!bucket)
+                byName.set(name, (bucket = new Set()));
+            bucket.add(normalizePath(file));
+        }
+    });
+    const index = new Map();
+    for (const [name, declaringFiles] of byName) {
+        index.set(name, [...declaringFiles].sort((left, right) => left.localeCompare(right)));
+    }
+    return index;
+}
+/** Declared C++ modules in the previous rows of changed files, as module name to declaring files. */
+function previousCppDeclaredContainers(previousModules) {
+    const byName = new Map();
+    for (const [file, mod] of previousModules)
+        mergeDeclaredContainers(byName, file, mod.declaredContainers);
+    return byName;
+}
+/** Fold one file's declared containers into name-to-declaring-files buckets. */
+function mergeDeclaredContainers(byName, file, declared) {
+    if (!declared || !declared.length)
+        return;
+    const normalized = normalizePath(file);
+    for (const name of declared) {
+        let bucket = byName.get(name);
+        if (!bucket)
+            byName.set(name, (bucket = new Set()));
+        bucket.add(normalized);
+    }
+}
+/** Sort name-to-declaring-files buckets into the shape declaredContainerNamesChanged compares. */
+function sortedDeclaredContainerIndex(byName) {
+    const index = new Map();
+    for (const [name, files] of byName) {
+        index.set(name, [...files].sort((left, right) => left.localeCompare(right)));
+    }
+    return index;
+}
+/** Whether a cached module has an import binding the previous build left unresolved. */
+function cachedModuleHasExternalImport(mod) {
+    return mod.imports.some((binding) => typeof binding.resolved !== "string");
+}
+/**
+ * Declaration-language files that have a cached row, are not in the build, and no longer exist.
+ * A deleted file leaves no cache miss, so importers that it satisfied would stay stale.
+ * The existence probe separates deleted files from files outside the build scope.
+ * The manifest path does not need this: the manifest lists the previous files.
+ */
+async function collectNoManifestDeletedDeclarationFiles(args) {
+    const live = new Set(args.files.map(fileIdentityKey));
+    const rows = new Map();
+    for (const file of listMemoryCachedModuleFiles(args.projectRoot))
+        rows.set(fileIdentityKey(file), file);
+    if ((args.opts?.cache ?? "off") === "disk") {
+        const diskFiles = listDiskCachedModuleFiles(args.projectRoot, args.opts);
+        if (diskFiles) {
+            for (const relative of diskFiles) {
+                const file = normalizePath(path.resolve(args.projectRoot, relative));
+                // A cache row is persisted data. Ignore a row that names a path outside the project.
+                if (!isFilePathWithinRoot(args.projectRoot, file))
+                    continue;
+                if (!rows.has(fileIdentityKey(file)))
+                    rows.set(fileIdentityKey(file), file);
+            }
+        }
+    }
+    const candidates = [];
+    for (const [key, file] of rows) {
+        if (live.has(key))
+            continue;
+        const languageId = supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id;
+        if (languageId && DECLARATION_RESOLVED_IMPORT_LANGUAGES.has(languageId))
+            candidates.push({ file, languageId });
+    }
+    if (!candidates.length)
+        return [];
+    const existence = await probePathExistence(candidates.map((candidate) => candidate.file), args.concurrency);
+    return candidates
+        .filter((candidate) => !existence.get(candidate.file))
+        .map((candidate) => ({
+        file: candidate.file,
+        languageId: candidate.languageId,
+        mod: peekCachedModule(args.projectRoot, candidate.file, args.opts)?.mod ?? null,
+    }));
+}
 async function resolveCrossModuleSymbolExports(file, mod, support, projectRoot, graphOptions, workspaceConfig, matchPath) {
     if (!support.supportsCrossModuleSymbols || !isJsTsLanguage(support.id))
         return;
@@ -176,7 +288,7 @@ async function buildIndexedModuleForFile(args) {
     const prepared = await prepareFileContextForBuild(args.file, args.support, args.opts, args.workerSetup, args.report, args.confinedRoot, args.projectRoot, args.trustedSource, !!args.bloomFilterCache);
     const { source, sup, nativeQueries, embeddedBlocks } = prepared;
     let tree;
-    const graphOnlyLanguage = isGraphOnlyLanguage(sup.id), nativeSourceLimitFallback = prepared.nativeFallbackReason === "sourceTooLarge";
+    const graphOnlyLanguage = isGraphOnlyLanguage(sup.id), nativeSourceLimitSkip = prepared.nativeFallbackReason === "sourceTooLarge";
     if (prepared.syntaxTree) {
         const parsedTree = new ProjectedSyntaxTree(source, prepared.syntaxTree);
         tree = parsedTree;
@@ -188,7 +300,7 @@ async function buildIndexedModuleForFile(args) {
             nativeQueries,
         }, args.parsedCacheMaxEntries);
     }
-    else if (!nativeQueries && !graphOnlyLanguage && sup.id !== "sql" && !nativeSourceLimitFallback) {
+    else if (!nativeQueries && !graphOnlyLanguage && sup.id !== "sql" && !nativeSourceLimitSkip) {
         const parseAttempt = attemptParsePreparedFileContext(prepared);
         const parsed = parseAttempt.parsed;
         if (parsed) {
@@ -206,7 +318,7 @@ async function buildIndexedModuleForFile(args) {
         }
     }
     else if (nativeQueries && !graphOnlyLanguage && sup.id !== "sql") {
-        // Worker returned queries without a tree (older path/fallback): reconstruct once.
+        // A native query without a transferred tree can still use the native syntax tree.
         const parseAttempt = attemptParsePreparedFileContext(prepared);
         const parsed = parseAttempt.parsed;
         if (parsed) {
@@ -214,8 +326,8 @@ async function buildIndexedModuleForFile(args) {
             setParsedCacheEntry(args.parsedMap, args.file, parsed, args.parsedCacheMaxEntries);
         }
     }
-    const lacksParserContext = !nativeQueries && !tree;
-    if (args.bloomFilterCache && !nativeSourceLimitFallback) {
+    const lacksParserContext = !graphOnlyLanguage && !nativeQueries;
+    if (args.bloomFilterCache && !nativeSourceLimitSkip) {
         const filter = prepared.workerBloomFilter
             ? BloomFilter.fromBuffer(Buffer.from(prepared.workerBloomFilter.bits), prepared.workerBloomFilter.size, prepared.workerBloomFilter.hashCount, prepared.workerBloomFilter.itemCount)
             : buildBloomFilterFromSource(source, sup);
@@ -227,12 +339,11 @@ async function buildIndexedModuleForFile(args) {
         graphOptions: args.graphOptions,
         ...(args.workspaceConfig ? { workspaceConfig: args.workspaceConfig } : {}),
         ...(args.matchPath ? { matchPath: args.matchPath } : {}),
-        ...(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 } : {}),
+        ...(args.report ? { report: args.report } : {}),
     };
-    const imports = nativeSourceLimitFallback || sup.id === "sql"
+    const imports = nativeSourceLimitSkip || sup.id === "sql"
         ? []
         : await collectImportsForFile(args.file, args.projectRoot, {
             source,
@@ -240,12 +351,14 @@ async function buildIndexedModuleForFile(args) {
             ...(nativeQueries !== undefined ? { nativeQueries } : {}),
             ...sharedImportOptions,
         });
-    for (const block of embeddedBlocks ?? []) {
-        imports.push(...(await collectImportsForFile(args.file, args.projectRoot, {
-            source: block.source,
-            sup: block.sup,
-            ...sharedImportOptions,
-        })));
+    if (!nativeSourceLimitSkip) {
+        for (const block of embeddedBlocks ?? []) {
+            imports.push(...(await collectImportsForFile(args.file, args.projectRoot, {
+                source: block.source,
+                sup: block.sup,
+                ...sharedImportOptions,
+            })));
+        }
     }
     collectJsonDependencies(imports, args.jsonDependencies);
     let mod;
@@ -259,7 +372,6 @@ async function buildIndexedModuleForFile(args) {
         mod = collectLocalsAndExportsFromSource(args.file, source, sup, imports, {
             ...(tree ? { tree } : {}),
             ...(nativeQueries !== undefined ? { nativeQueries } : {}),
-            ...(args.opts?.native ? { nativeMode: args.opts.native } : {}),
             ...(args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {}),
         });
     }
@@ -324,12 +436,105 @@ function ensureJsonModule(modules, filePath) {
     });
 }
 function graphEdgeKey(edge) {
-    const from = fileIdentityKey(edge.from);
-    const target = edge.to.type === "file" ? `file:${fileIdentityKey(edge.to.path)}` : `external:${edge.to.name}`;
-    return `${from}::${target}::${edge.raw ?? ""}::${edge.typeOnly ? 1 : 0}`;
+    return edgeKey(edge, true, fileIdentityKey);
+}
+function externalEdgeTargetKey(to) {
+    return to.type === "file" ? `file:${fileIdentityKey(to.path)}` : `external:${to.name}`;
+}
+const PRECISE_SPECIFIER_RESOLUTION_LANGUAGES = {
+    c: true,
+    cpp: true,
+    js: true,
+    jsx: true,
+    python: true,
+    ts: true,
+    tsx: true,
+};
+async function specifierResolutionChanged(file, entry, projectRoot, workspaceConfig, graphOptions, languageExtensions, loadMatchPath, addedFiles, addedStemsForLanguage, loadTsconfigPaths) {
+    const support = supportForFileWithoutHeaderSample(file, languageExtensions);
+    if (!support)
+        return false;
+    // Declaration languages re-resolve through the extension rule in externalSpecifierMatchesAddedStem,
+    // so no filename stems are needed here.
+    const addedStems = addedStemsForLanguage(support.id);
+    const addedFileLanguageId = (file) => supportForFileWithoutHeaderSample(file, languageExtensions)?.id;
+    const specifierEdges = entry.edges;
+    if (!specifierEdges.length)
+        return false;
+    const specifierOf = (edge) => (edge.to.type === "external" ? edge.raw || edge.to.name : edge.raw);
+    const matching = [];
+    const needsAlias = [];
+    for (const edge of specifierEdges) {
+        const specifier = specifierOf(edge);
+        if (externalSpecifierMatchesAddedStem(specifier, support.id, addedStems, [], addedFiles, addedFileLanguageId)) {
+            matching.push(edge);
+            continue;
+        }
+        const relative = specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:[\\/]/.test(specifier);
+        if ((support.id === "ts" || support.id === "tsx") && specifier && !relative)
+            needsAlias.push(edge);
+    }
+    if (needsAlias.length) {
+        const paths = await loadTsconfigPaths(file);
+        if (paths && Object.keys(paths).length) {
+            for (const edge of needsAlias) {
+                const mapped = tsconfigAliasMappedTails(specifierOf(edge), paths);
+                if (mapped.length &&
+                    externalSpecifierMatchesAddedStem(specifierOf(edge), support.id, addedStems, mapped, addedFiles, addedFileLanguageId)) {
+                    matching.push(edge);
+                }
+            }
+        }
+    }
+    if (!matching.length)
+        return false;
+    // Stylesheet, document, and other unstored per-occurrence inputs cannot be
+    // re-resolved from the edge. The caller only reaches this on an add.
+    if (!PRECISE_SPECIFIER_RESOLUTION_LANGUAGES[support.id])
+        return true;
+    if ((support.id === "c" || support.id === "cpp") &&
+        matching.some((edge) => edge.includeForm === undefined && !isCppNamedModuleSpecifier(edge.raw))) {
+        return true;
+    }
+    const matchPath = support.id === "ts" || support.id === "tsx" ? await loadMatchPath(file) : undefined;
+    const groups = new Map();
+    for (const edge of matching) {
+        const key = `${edge.raw}\0${edge.includeForm ?? ""}\0${edge.typeOnly ? 1 : 0}`;
+        const group = groups.get(key);
+        if (group)
+            group.push(edge);
+        else
+            groups.set(key, [edge]);
+    }
+    for (const group of groups.values()) {
+        const sample = group[0];
+        const resolved = await resolveModuleSpecifierEdges({
+            spec: sample.raw,
+            ...(sample.typeOnly ? { typeOnly: true } : {}),
+            ...(sample.includeForm ? { includeForm: sample.includeForm } : {}),
+        }, {
+            support,
+            file,
+            projectRoot,
+            workspaceConfig,
+            matchPath,
+            resolveNodeModules: !!graphOptions.resolveNodeModules,
+            ...(graphOptions.resolutionHints ? { resolutionHints: graphOptions.resolutionHints } : {}),
+            ...(languageExtensions ? { languageExtensions } : {}),
+        });
+        const resolvedKeys = (resolved ?? []).map((item) => externalEdgeTargetKey(item.to)).sort();
+        const cachedKeys = group.map((edge) => externalEdgeTargetKey(edge.to)).sort();
+        if (resolvedKeys.length !== cachedKeys.length)
+            return true;
+        for (let index = 0; index < resolvedKeys.length; index += 1) {
+            if (resolvedKeys[index] !== cachedKeys[index])
+                return true;
+        }
+    }
+    return false;
 }
 async function moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint) {
-    const baseSignature = await cacheSignatureForFile(file, sigInfo, opts);
+    const baseSignature = await cacheSignatureForFile(file, sigInfo);
     const normalizedExtensions = normalizeLanguageExtensions(opts?.languageExtensions);
     const normalizedGraphOptions = normalizeGraphOptions(opts?.graph);
     const resolveNodeModules = normalizedGraphOptions.resolveNodeModules;
@@ -393,7 +598,6 @@ function createIndexBuildRunState(projectRoot, opts, graphOptions = normalizeGra
         cacheMode,
         cacheEnabled: cacheMode !== "off",
         graphOptions,
-        onFallbackImportExtraction: createFallbackImportExtractionHandler(report, opts),
     };
 }
 function emitIndexLifecycleProgress(opts, phase, mode, total, elapsedMs) {
@@ -551,10 +755,302 @@ async function prepareFileSignatures(args) {
 async function buildProjectIndexFromExport(projectRoot, opts, helperOpts) {
     return buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpts);
 }
+/**
+ * Cached modules to extract again because something they depend on changed.
+ * A cached module is keyed by its own content, but its import bindings depend on other files.
+ * A module is stale when:
+ * - it changed;
+ * - an import or re-export target no longer exists;
+ * - an added file can satisfy one of its specifiers;
+ * - it resolves imports through namespace or package declarations, and a file it depends on changed.
+ *
+ * With a manifest, the manifest gives the previous files and edges.
+ * Without one (a memory cache, or a disk cache that no manifest-writing build has seen),
+ * the cached import bindings replace the edges.
+ */
+async function collectStaleCachedModules(args) {
+    const { cachedModules, manifestFiles } = args;
+    if (!cachedModules.size)
+        return { stale: new Set(), deletedDeclarationFiles: [] };
+    const stale = await cachedModulesWithMissingTargets(cachedModules, args.concurrency);
+    const resolvesFromDeclarations = (file) => DECLARATION_RESOLVED_IMPORT_LANGUAGES.has(supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id ?? "");
+    const loadTsconfigPaths = (importer) => loadTsconfigResolutionInputsFor(importer, args.projectRoot, args.opts?.logLevel).then((inputs) => inputs?.paths);
+    // Deleted declaration files. Only the no-manifest path fills this list.
+    // The manifest path retires deletions when it rewrites the manifest.
+    const deletedDeclarationFiles = [];
+    if (manifestFiles) {
+        const currentKeys = new Set(args.files.map(fileIdentityKey));
+        // A cache miss proves a change, even when a non-strict manifest signature (mtime:size) matches.
+        const changed = new Set(args.cacheMisses.changed);
+        const added = [];
+        for (const file of args.files) {
+            const entry = manifestFiles[file];
+            if (!entry)
+                added.push(file);
+            const sigInfo = args.signatures.get(file);
+            if (!sigInfo)
+                continue;
+            const matchesGitSig = !!entry?.gitSig && !!sigInfo.gitSig && entry.gitSig === sigInfo.gitSig;
+            if (!entry || !(matchesGitSig || entry.sig === sigInfo.sig))
+                changed.add(file);
+        }
+        // Cache hits do not hold the declarations of added or changed files.
+        // Add the C++ module declarations of those files before the comparison.
+        // Otherwise a second file that declares an existing module name changes nothing,
+        // and the importer keeps its old target.
+        const nextDeclaredContainers = declaredContainerIndexFromModules([...cachedModules.values()].map((cached) => cached.mod));
+        const cppMisses = [...new Set([...added, ...changed])].filter((file) => supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id === "cpp");
+        if (cppMisses.length) {
+            const missDeclaredContainers = await collectCppMissDeclaredContainers(cppMisses, args.concurrency, {
+                ...(args.confinedRoot ? { confinedRoot: args.confinedRoot, projectRoot: args.projectRoot } : {}),
+                ...(args.trustedSources ? { trustedSources: args.trustedSources } : {}),
+            });
+            for (const [name, declaringFiles] of missDeclaredContainers) {
+                const merged = new Set([...(nextDeclaredContainers.get(name) ?? []), ...declaringFiles]);
+                nextDeclaredContainers.set(name, [...merged].sort((left, right) => left.localeCompare(right)));
+            }
+        }
+        const declaredContainerConsumers = collectDeclaredContainerConsumers(manifestFiles, declaredContainerNamesChanged(manifestDeclaredContainerIndex(args.manifest), nextDeclaredContainers));
+        const missingFromBuild = Object.keys(manifestFiles).filter((file) => !currentKeys.has(fileIdentityKey(file)));
+        const existence = await probePathExistence(missingFromBuild, args.concurrency);
+        const deleted = new Set(missingFromBuild.filter((file) => !existence.get(file)));
+        for (const file of [
+            ...changed,
+            ...collectDeletedTrackedFileDependents(manifestFiles, deleted),
+            ...declaredContainerConsumers,
+        ]) {
+            stale.add(file);
+        }
+        for (const file of collectTrackedFileDependents(manifestFiles, changed)) {
+            if (resolvesFromDeclarations(file))
+                stale.add(file);
+        }
+        // A changed or deleted declaration-language file can change which files declare a namespace
+        // or package that an importer names. A deleted duplicate can resolve an ambiguous import.
+        // Treat these files like added files.
+        const resolutionInputs = [...added, ...[...changed, ...deleted].filter((file) => resolvesFromDeclarations(file))];
+        if (resolutionInputs.length) {
+            const stemsByLanguage = new Map();
+            const addedStemsForLanguage = (languageId) => {
+                let stems = stemsByLanguage.get(languageId);
+                if (!stems)
+                    stemsByLanguage.set(languageId, (stems = addedResolutionStems(resolutionInputs, languageId)));
+                return stems;
+            };
+            const candidates = [...collectSpecifierEdgeCandidates(manifestFiles, true)].filter((file) => cachedModules.has(file) && !stale.has(file));
+            const changedResolution = await mapLimit(candidates, args.concurrency, async (candidate) => specifierResolutionChanged(candidate, manifestFiles[candidate], args.projectRoot, args.workspaceConfig, args.graphOptions, args.opts?.languageExtensions, args.loadMatchPathForFile, resolutionInputs, addedStemsForLanguage, loadTsconfigPaths));
+            candidates.forEach((candidate, index) => {
+                if (changedResolution[index])
+                    stale.add(candidate);
+            });
+            for (const importer of collectPythonPackageImporters(manifestFiles, added))
+                stale.add(importer);
+        }
+    }
+    else {
+        const added = [
+            ...args.cacheMisses.added,
+            ...args.cacheMisses.changed.filter((file) => resolvesFromDeclarations(file)),
+        ];
+        if (added.length) {
+            const stemsByLanguage = new Map();
+            for (const [file, { mod }] of cachedModules) {
+                if (stale.has(file))
+                    continue;
+                const languageId = supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id ?? "default";
+                let stems = stemsByLanguage.get(languageId);
+                if (!stems)
+                    stemsByLanguage.set(languageId, (stems = addedResolutionStems(added, languageId)));
+                const tsconfigPaths = languageId === "ts" || languageId === "tsx" ? await loadTsconfigPaths(file) : undefined;
+                const addedCanSatisfy = cachedModuleSpecifiers(mod).some((specifier) => externalSpecifierMatchesAddedStem(specifier, languageId, stems, tsconfigPaths ? tsconfigAliasMappedTails(specifier, tsconfigPaths) : [], added, (file) => supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id));
+                if (addedCanSatisfy)
+                    stale.add(file);
+            }
+            // `from . import mod` targets `__init__.py`, so no specifier names an added `mod.py`.
+            // Find these importers through their cached targets.
+            const packageImporters = pythonImportersOfPackageInits(Array.from(cachedModules, ([file, { mod }]) => [file, cachedModuleTargets(mod)]), added);
+            for (const file of packageImporters)
+                stale.add(file);
+        }
+        // C++ module specifiers name declarations, not file stems. The stem check cannot see
+        // a second declarer, a file that stopped declaring a module, or a deleted declarer.
+        // A deleted file leaves no cache miss, so the rows of omitted files are scanned separately.
+        // Cache hits cancel out of the comparison. Only stale rows, deleted files, and misses change it.
+        const cppPrevious = previousCppDeclaredContainers(args.previousModules);
+        const unknownDeclarationLanguages = new Set();
+        for (const deleted of await collectNoManifestDeletedDeclarationFiles({
+            files: args.files,
+            projectRoot: args.projectRoot,
+            opts: args.opts,
+            concurrency: args.concurrency,
+        })) {
+            deletedDeclarationFiles.push(deleted.file);
+            if (deleted.languageId === "cpp" && deleted.mod && deleted.mod.declaredContainers) {
+                mergeDeclaredContainers(cppPrevious, deleted.file, deleted.mod.declaredContainers);
+            }
+            else {
+                unknownDeclarationLanguages.add(deleted.languageId);
+            }
+        }
+        // Some previous declarations are unknown when a payload was evicted,
+        // or when the old row of a changed file cannot be decoded.
+        // Re-resolve every cached importer of the affected languages.
+        // This is rare: eviction starts past the cache limit, where builds miss the cache anyway.
+        const unknownDeclarationHistory = new Set();
+        if ((args.opts?.cache ?? "off") === "memory" && memoryCacheLostPayloads(args.projectRoot)) {
+            for (const languageId of DECLARATION_RESOLVED_IMPORT_LANGUAGES)
+                unknownDeclarationHistory.add(languageId);
+        }
+        // An unmapped `.h` file is C or C++ by its content, so classify with `supportForFile`.
+        for (const file of args.previousUnavailable) {
+            const languageId = supportForFile(file, args.opts?.languageExtensions)?.id;
+            if (languageId && DECLARATION_RESOLVED_IMPORT_LANGUAGES.has(languageId)) {
+                unknownDeclarationHistory.add(languageId);
+            }
+        }
+        if (unknownDeclarationHistory.size) {
+            for (const [file, { mod }] of cachedModules) {
+                if (stale.has(file) || !mod.imports.length)
+                    continue;
+                const languageId = supportForFile(file, args.opts?.languageExtensions)?.id ?? "";
+                if (unknownDeclarationHistory.has(languageId))
+                    stale.add(file);
+            }
+        }
+        const cppAdded = added.filter((file) => supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id === "cpp");
+        const missDeclaredContainers = cppAdded.length
+            ? await collectCppMissDeclaredContainers(cppAdded, args.concurrency, {
+                ...(args.confinedRoot ? { confinedRoot: args.confinedRoot, projectRoot: args.projectRoot } : {}),
+                ...(args.trustedSources ? { trustedSources: args.trustedSources } : {}),
+            })
+            : new Map();
+        const changedContainers = declaredContainerNamesChanged(sortedDeclaredContainerIndex(cppPrevious), missDeclaredContainers);
+        if (changedContainers.size || unknownDeclarationLanguages.size) {
+            for (const [file, { mod }] of cachedModules) {
+                if (stale.has(file))
+                    continue;
+                if (changedContainers.size &&
+                    cachedModuleSpecifiers(mod).some((specifier) => changedContainers.has(specifier))) {
+                    stale.add(file);
+                    continue;
+                }
+                if (unknownDeclarationLanguages.size) {
+                    const languageId = supportForFile(file, args.opts?.languageExtensions)?.id ?? "default";
+                    if (unknownDeclarationLanguages.has(languageId) && cachedModuleHasExternalImport(mod))
+                        stale.add(file);
+                }
+            }
+        }
+        // The cached modules' own targets are the reverse dependencies.
+        const reverseDependencies = new Map();
+        for (const [file, { mod }] of cachedModules) {
+            for (const target of cachedModuleTargets(mod)) {
+                const key = fileIdentityKey(target);
+                let dependents = reverseDependencies.get(key);
+                if (!dependents)
+                    reverseDependencies.set(key, (dependents = new Set()));
+                dependents.add(file);
+            }
+        }
+        const queue = args.cacheMisses.changed.map(fileIdentityKey);
+        const enqueued = new Set(queue);
+        for (let head = 0; head < queue.length; head += 1) {
+            for (const dependent of reverseDependencies.get(queue[head]) ?? []) {
+                if (resolvesFromDeclarations(dependent))
+                    stale.add(dependent);
+                const key = fileIdentityKey(dependent);
+                if (enqueued.has(key))
+                    continue;
+                enqueued.add(key);
+                queue.push(key);
+            }
+        }
+    }
+    // A package star depends on every package file, not just its representative edge. A type
+    // wildcard (`import p.C.*` naming class `p.C`) turns into a package star once package `p.C` exists.
+    const isJvmFile = (file) => {
+        const languageId = supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id;
+        return languageId === "java" || languageId === "kotlin";
+    };
+    const dependsOnJvmPackage = (imp) => imp.kind === "star" && (!!imp.jvmPackageFiles || !!imp.jvmTypeWildcardName || typeof imp.resolved !== "string");
+    if (args.cacheMisses.added.some(isJvmFile) || args.cacheMisses.changed.some(isJvmFile)) {
+        const packageImporters = [];
+        for (const [file, cached] of cachedModules) {
+            if (stale.has(file) || !isJvmFile(file))
+                continue;
+            if (cached.mod.imports.some(dependsOnJvmPackage))
+                packageImporters.push([file, cached.mod]);
+        }
+        const changed = await mapLimit(packageImporters, args.concurrency, async ([file, mod]) => {
+            for (const imp of mod.imports) {
+                if (imp.kind !== "star" || !dependsOnJvmPackage(imp))
+                    continue;
+                const current = await resolveJvmPackageImportPaths(args.projectRoot, imp.from, file);
+                const previous = imp.jvmPackageFiles ?? [];
+                if (current.length !== previous.length ||
+                    current.some((target, index) => fileIdentityKey(target) !== fileIdentityKey(previous[index]))) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        packageImporters.forEach(([file], index) => {
+            if (changed[index])
+                stale.add(file);
+        });
+    }
+    return { stale, deletedDeclarationFiles };
+}
+/** Files a cached module depends on, including every JVM wildcard package file. */
+function cachedModuleTargets(mod) {
+    const targets = [];
+    for (const binding of mod.imports) {
+        if (typeof binding.resolved === "string")
+            targets.push(binding.resolved);
+        if (binding.kind !== "star" || !binding.jvmPackageFiles)
+            continue;
+        for (const file of binding.jvmPackageFiles) {
+            if (file !== binding.resolved)
+                targets.push(file);
+        }
+    }
+    for (const entry of mod.exports) {
+        if (entry.type === "local" || !entry.moduleSpecifier || entry.fromModule === entry.moduleSpecifier)
+            continue;
+        targets.push(entry.fromModule);
+    }
+    return targets;
+}
+/** Specifiers a cached module wrote: import sources and re-export sources. */
+function cachedModuleSpecifiers(mod) {
+    const specifiers = mod.imports.map((binding) => binding.from);
+    for (const entry of mod.exports) {
+        if (entry.type !== "local")
+            specifiers.push(entry.moduleSpecifier ?? entry.fromModule);
+    }
+    return specifiers;
+}
+/** Cached modules with a resolved import or re-export target that no longer exists. */
+async function cachedModulesWithMissingTargets(cachedModules, concurrency) {
+    const targetsByFile = new Map();
+    for (const [file, { mod }] of cachedModules) {
+        const targets = cachedModuleTargets(mod);
+        if (targets.length)
+            targetsByFile.set(file, targets);
+    }
+    const targetExistence = await probePathExistence([...new Set([...targetsByFile.values()].flat())], concurrency);
+    const missing = new Set();
+    for (const [file, targets] of targetsByFile) {
+        if (targets.some((target) => !targetExistence.get(target)))
+            missing.add(file);
+    }
+    return missing;
+}
 async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperOpts) {
+    assertNativeRequiredAvailable();
     clearResolutionCaches();
     await initializeFileIdentityCaseSensitivity(projectRoot);
-    const { normalizedProjectRoot, report, timings, totalStart, cacheEnabled, graphOptions, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts);
+    const { normalizedProjectRoot, report, timings, totalStart, cacheEnabled, graphOptions } = createIndexBuildRunState(projectRoot, opts);
     const manifestMode = helperOpts?.manifestMode ?? "off";
     const useManifest = manifestMode !== "off";
     const shouldWriteManifest = manifestMode === "read-write";
@@ -629,6 +1125,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         ? createCountedCheckProgress(opts, "Checking file cache", normalizedFiles.length)
         : () => undefined;
     const cacheProbeStart = performance.now();
+    const evictionSerialAtStart = memoryCacheEvictionSerial();
     const gitAvailable = await isGitRepo(projectRoot, helperOpts?.discoveryContext?.git);
     const needsPersistentSignatures = cacheEnabled || useManifest;
     const useGitSignatures = gitAvailable && needsPersistentSignatures;
@@ -702,10 +1199,10 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 ? await moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint)
                 : sigInfo.cacheSig;
             const canReuseModuleCache = cacheEnabled && (!graphOptions.resolveNodeModules || resolverEnvironmentFingerprint !== null);
-            const mod = canReuseModuleCache
-                ? tryLoadFromCache(projectRoot, file, cacheSig, opts, report, moduleCacheAvailable)
-                : null;
-            return [file, { sigInfo, mod }];
+            const loaded = canReuseModuleCache
+                ? loadModuleFromCache(projectRoot, file, cacheSig, opts, report, moduleCacheAvailable)
+                : { mod: null, previouslyCached: false, staleMod: null };
+            return [file, { sigInfo, ...loaded }];
         }
         catch (error) {
             return [file, { error }];
@@ -719,6 +1216,70 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         timings.cacheProbeMs = cacheProbeMs;
         recordBuildTimingStep(timings, { name: "cache-probe", ms: cacheProbeMs });
     }
+    const tsconfigMatchPathByDirectory = new Map();
+    const loadMatchPathForFile = (file) => {
+        const directory = path.dirname(file);
+        let matchPath = tsconfigMatchPathByDirectory.get(directory);
+        if (!matchPath) {
+            matchPath = loadNearestTsconfigFor(file, projectRoot, opts?.logLevel).then((tsconfig) => tsconfig.matchPath);
+            tsconfigMatchPathByDirectory.set(directory, matchPath);
+        }
+        return matchPath;
+    };
+    let retiredDeletionFiles = [];
+    // Set when a stale importer row could not be deleted. The build then keeps its previous disk
+    // state (manifest, snapshot, deletion evidence), so the next build finds the same staleness.
+    let staleRowRemovalFailed = false;
+    if (cacheEnabled) {
+        const cachedModules = new Map();
+        const cacheMissesByState = { changed: [], added: [] };
+        // The stale rows of changed files hold the previous declarations.
+        // Deleted files leave no miss. The build finds their rows separately.
+        const previousModules = new Map();
+        const previousUnavailable = [];
+        for (const [file, probe] of cacheProbes) {
+            if ("error" in probe)
+                continue;
+            if (probe.mod)
+                cachedModules.set(file, { sigInfo: probe.sigInfo, mod: probe.mod });
+            else if (probe.previouslyCached) {
+                cacheMissesByState.changed.push(file);
+                if (probe.staleMod)
+                    previousModules.set(file, probe.staleMod);
+                else
+                    previousUnavailable.push(file);
+            }
+            else
+                cacheMissesByState.added.push(file);
+        }
+        const { stale: staleCachedModules, deletedDeclarationFiles: retiredDeletions } = await collectStaleCachedModules({
+            files: normalizedFiles,
+            cachedModules,
+            cacheMisses: cacheMissesByState,
+            previousModules,
+            previousUnavailable,
+            signatures: new Map(Array.from(cacheProbes, ([file, probe]) => ("error" in probe ? null : [file, probe.sigInfo])).filter((entry) => entry !== null)),
+            manifestFiles: manifest ? manifestFiles : null,
+            manifest,
+            projectRoot,
+            workspaceConfig,
+            graphOptions,
+            opts,
+            loadMatchPathForFile,
+            concurrency: conc,
+            ...(confinedRoot ? { confinedRoot, trustedSources } : {}),
+        });
+        retiredDeletionFiles = retiredDeletions;
+        // A stale importer's row still matches its source signature.
+        // If the rebuild or the cache write fails, a later build would reuse the row. Delete it now.
+        staleRowRemovalFailed = !removeModulesFromCache(projectRoot, [...staleCachedModules].filter((file) => cachedModules.has(file)), opts);
+        for (const file of staleCachedModules) {
+            const probe = cacheProbes.get(file);
+            if (probe && !("error" in probe))
+                cacheProbes.set(file, { ...probe, mod: null });
+            cachedGraphEntries?.delete(file);
+        }
+    }
     const cacheMisses = Array.from(cacheProbes, ([file, probe]) => !("error" in probe) && !probe.mod ? file : null).filter((file) => file !== null);
     const workerSetup = await setupWorkerPool(opts, countNativeWorkerEligibleFiles(cacheMisses, opts?.languageExtensions));
     try {
@@ -730,16 +1291,6 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             ? await tryLoadPersistedBloomFilters(projectRoot, opts, report)
             : null;
         const parsedMap = new Map();
-        const tsconfigMatchPathByDirectory = new Map();
-        const loadMatchPathForFile = (file) => {
-            const directory = path.dirname(file);
-            let matchPath = tsconfigMatchPathByDirectory.get(directory);
-            if (!matchPath) {
-                matchPath = loadNearestTsconfigFor(file, projectRoot, opts?.logLevel).then((tsconfig) => tsconfig.matchPath);
-                tsconfigMatchPathByDirectory.set(directory, matchPath);
-            }
-            return matchPath;
-        };
         const parseStart = performance.now();
         const graph = { nodes: new Set(normalizedFiles), edges: [] };
         const onFileEdges = manifestEntries
@@ -783,13 +1334,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 let edges = [];
                 if (mod && edgesCached) {
                     edges = await collectEdgesForFile(file, projectRoot, workspaceConfig, {
-                        fast: !!graphOptions.fast,
-                        ...(graphOptions.fastRegexDisabledLanguages
-                            ? { fastRegexDisabledLanguages: graphOptions.fastRegexDisabledLanguages }
-                            : {}),
                         resolveNodeModules: !!graphOptions.resolveNodeModules,
                         dynamicImportHeuristics: !!graphOptions.dynamicImportHeuristics,
-                        ...(opts?.native ? { native: opts.native } : {}),
                         ...(opts?.languageExtensions ? { languageExtensions: opts.languageExtensions } : {}),
                         ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
                         ...(graphOptions.resolutionHints ? { resolutionHints: graphOptions.resolutionHints } : {}),
@@ -798,7 +1344,6 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                         ...(cachedEdgesEntry ? { cachedFileEdges: cachedEdgesEntry } : {}),
                         ...(manifest?.projectRoot ? { cachedFileEdgesProjectRoot: manifest.projectRoot } : {}),
                         ...(onFileEdges ? { onFileEdges } : {}),
-                        ...(onFallbackImportExtraction ? { onFallbackImportExtraction } : {}),
                         allFiles: normalizedFiles,
                         ...(sqlFactCache ? { sqlFactCache } : {}),
                     });
@@ -840,7 +1385,6 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                         parsedCacheMaxEntries: parsedCacheMaxEntries(opts),
                         jsonDependencies,
                         bloomFilterCache,
-                        onFallbackImportExtraction,
                         fileSignatures,
                         cacheEnabled,
                         ...(confinedRoot ? { confinedRoot, trustedSource: trustedSources?.get(file) } : {}),
@@ -854,13 +1398,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 }
                 edges = await collectEdgesForFile(file, projectRoot, workspaceConfig, {
                     ...(graphContext ? { parsed: graphContext } : {}),
-                    fast: !!graphOptions.fast,
-                    ...(graphOptions.fastRegexDisabledLanguages
-                        ? { fastRegexDisabledLanguages: graphOptions.fastRegexDisabledLanguages }
-                        : {}),
                     resolveNodeModules: !!graphOptions.resolveNodeModules,
                     dynamicImportHeuristics: !!graphOptions.dynamicImportHeuristics,
-                    ...(opts?.native ? { native: opts.native } : {}),
                     ...(opts?.languageExtensions ? { languageExtensions: opts.languageExtensions } : {}),
                     ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
                     ...(graphOptions.resolutionHints ? { resolutionHints: graphOptions.resolutionHints } : {}),
@@ -869,7 +1408,6 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     ...(cachedEdgesEntry ? { cachedFileEdges: cachedEdgesEntry } : {}),
                     ...(manifest?.projectRoot ? { cachedFileEdgesProjectRoot: manifest.projectRoot } : {}),
                     ...(onFileEdges ? { onFileEdges } : {}),
-                    ...(onFallbackImportExtraction ? { onFallbackImportExtraction } : {}),
                     allFiles: normalizedFiles,
                     ...(sqlFactCache ? { sqlFactCache } : {}),
                 });
@@ -942,6 +1480,16 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 writeModulesToCache(projectRoot, pendingCacheWrites, opts);
             }
         }
+        // A full-discovery build re-resolved every importer and wrote its modules back.
+        // Clear the eviction state, unless another payload was evicted during the build.
+        if (opts?.cache === "memory" && projectFiles !== undefined) {
+            settleMemoryCacheEvictions(projectRoot, evictionSerialAtStart);
+        }
+        // Delete the rows of confirmed-deleted declaration files, so the next unchanged build is fully warm.
+        // Only a full-discovery build does this. A build over a file list can omit importers that still need the deletion.
+        if (!manifest && projectFiles !== undefined && retiredDeletionFiles.length && !staleRowRemovalFailed) {
+            removeModulesFromCache(projectRoot, retiredDeletionFiles, opts);
+        }
         const workspaceManifestEdges = await timeIndexBuildPhase({
             opts,
             timings,
@@ -970,7 +1518,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 });
             }
         }
-        if (manifestEntries) {
+        if (manifestEntries && !staleRowRemovalFailed) {
             await timeIndexBuildPhase({
                 opts,
                 timings,
@@ -1029,7 +1577,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             const finalizeMs = discoveredInsideFinalize ? Math.max(0, elapsed - discoveryMs) : elapsed;
             recordBuildTimingStep(timings, { name: "finalize", ms: finalizeMs });
         }
-        if (manifestEntries) {
+        if (manifestEntries && !staleRowRemovalFailed) {
             await timeIndexBuildPhase({
                 opts,
                 timings,
@@ -1056,6 +1604,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
 }
 async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpts) {
+    assertNativeRequiredAvailable();
     const timings = opts?.report ? (opts.report.timings ??= {}) : undefined;
     const discoveryContext = helperOpts?.discoveryContext;
     await initializeFileIdentityCaseSensitivity(projectRoot);
@@ -1178,6 +1727,7 @@ export async function buildProjectIndex(projectRoot, opts) {
  * under the project root.
  */
 export async function buildProjectIndexFromFiles(projectRoot, inputFiles, rawOpts) {
+    assertNativeRequiredAvailable();
     // Discovery, manifest loading, and cache checks all precede file processing, so stamp the
     // operation origin here and let the completion event report the caller's whole wait.
     const opts = { ...rawOpts, progressStartedAt: rawOpts?.progressStartedAt ?? performance.now() };
@@ -1233,6 +1783,7 @@ async function buildDeclaredScopeIndex(projectRoot, scopeFiles, opts, helperOpts
  * sentinels for review-agent workflows that analyze uncommitted changes.
  */
 export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
+    assertNativeRequiredAvailable();
     const opts = {
         ...rawOpts,
         progressStartedAt: rawOpts?.progressStartedAt ?? performance.now(),
@@ -1245,10 +1796,7 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         clearResolutionCaches();
     });
     const graphOptions = normalizeGraphOptions(opts?.graph);
-    const strictIncremental = opts?.incrementalStrict ?? false;
-    if (strictIncremental && graphOptions.fast)
-        graphOptions.fast = false;
-    const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts, graphOptions);
+    const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled } = createIndexBuildRunState(projectRoot, opts, graphOptions);
     let checkProgressActive = false;
     const startCheckProgress = () => {
         if (checkProgressActive)
@@ -1580,7 +2128,6 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                 modules: new Map(),
                 byFile: new Map(),
                 projectRoot: normalizedProjectRoot,
-                ...(opts?.native ? { nativeMode: opts.native } : {}),
                 exportCache: new Map(),
                 scopeCache: new Map(),
                 parsed: new Map(),
@@ -1652,8 +2199,6 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
             if (report) {
                 if (snapshotLoad.analysisReport?.backend)
                     report.backend = snapshotLoad.analysisReport.backend;
-                if (snapshotLoad.analysisReport?.graph)
-                    report.graph = snapshotLoad.analysisReport.graph;
                 if (!report.backend)
                     initNativeBackendReport(report);
                 snapshot.buildReport = report;
@@ -1740,6 +2285,7 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
             const bloomFilterCache = useBloomFilters
                 ? new (await import("../util/bloom-filter.js")).BloomFilterCache()
                 : undefined;
+            const addedFiles = [];
             for (const file of allFiles) {
                 const sigInfo = fileSignatures.get(file);
                 if (!sigInfo)
@@ -1747,6 +2293,8 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                 const entry = trackedEntries[file];
                 const hasMatchingGitSig = !!entry?.gitSig && !!sigInfo.gitSig && entry.gitSig === sigInfo.gitSig;
                 const hasMatchingSig = entry?.sig === sigInfo.sig;
+                if (!entry)
+                    addedFiles.push(file);
                 if (!entry || !(hasMatchingGitSig || hasMatchingSig)) {
                     changedFiles.add(file);
                 }
@@ -1818,6 +2366,52 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                 }
             }
             invalidateCachedDependents();
+            // A deletion cannot make an unresolved specifier start resolving. Dependents of a
+            // deleted file are already rebuilt by collectDeletedTrackedFileDependents. An added
+            // file can: re-resolve only specifiers whose stem matches an added file. Edges that
+            // cannot round-trip (unstored resolution kind, or a C/C++ include with no form) are
+            // reparsed instead of guessed.
+            if (addedFiles.length) {
+                const reparseCachedFile = (candidate) => {
+                    const key = fileIdentityKey(candidate);
+                    if (modules.has(key)) {
+                        modules.delete(key);
+                        if (fileReport) {
+                            fileReport.cached = Math.max(0, (fileReport.cached ?? 0) - 1);
+                        }
+                    }
+                    markAsChanged(candidate);
+                };
+                const addedStemsByLanguage = new Map();
+                const addedStemsForLanguage = (languageId) => {
+                    const existing = addedStemsByLanguage.get(languageId);
+                    if (existing)
+                        return existing;
+                    const stems = addedResolutionStems(addedFiles, languageId);
+                    addedStemsByLanguage.set(languageId, stems);
+                    return stems;
+                };
+                const specifierEdgeCandidates = collectSpecifierEdgeCandidates(trackedEntries, true);
+                if (specifierEdgeCandidates.size) {
+                    const candidateFiles = Array.from(specifierEdgeCandidates);
+                    const staleResolutions = await mapLimit(candidateFiles, conc, async (candidate) => {
+                        if (!allFiles.has(candidate) || changedFiles.has(candidate))
+                            return false;
+                        const entry = trackedEntries[candidate];
+                        if (!entry)
+                            return false;
+                        return specifierResolutionChanged(candidate, entry, projectRoot, workspaceConfig, graphOptions, opts?.languageExtensions, loadMatchPathForFile, addedFiles, addedStemsForLanguage, (importer) => loadTsconfigResolutionInputsFor(importer, projectRoot, opts?.logLevel).then((inputs) => inputs?.paths));
+                    });
+                    for (let index = 0; index < candidateFiles.length; index += 1) {
+                        if (staleResolutions[index])
+                            reparseCachedFile(candidateFiles[index]);
+                    }
+                }
+                for (const importer of collectPythonPackageImporters(trackedEntries, addedFiles)) {
+                    if (allFiles.has(importer) && !changedFiles.has(importer))
+                        reparseCachedFile(importer);
+                }
+            }
             const changedList = Array.from(changedFiles);
             // Sized by the work that remains rather than the size of the project: an incremental build
             // touching a handful of files gets a handful of threads, or none.
@@ -1855,7 +2449,6 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                             parsedCacheMaxEntries: parsedCacheMaxEntries(opts),
                             jsonDependencies,
                             bloomFilterCache,
-                            onFallbackImportExtraction,
                             fileSignatures,
                             cacheEnabled,
                             ...(resolverEnvironmentFingerprint !== undefined ? { resolverEnvironmentFingerprint } : {}),
@@ -1940,13 +2533,8 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                 ? { nodes: new Set(baseGraph.nodes), edges: [...baseGraph.edges] }
                 : await collectGraph(projectRoot, filesList, {
                     parsed: parsedMap,
-                    fast: !!graphOptions.fast,
-                    ...(graphOptions.fastRegexDisabledLanguages
-                        ? { fastRegexDisabledLanguages: graphOptions.fastRegexDisabledLanguages }
-                        : {}),
                     resolveNodeModules: !!graphOptions.resolveNodeModules,
                     dynamicImportHeuristics: !!graphOptions.dynamicImportHeuristics,
-                    ...(opts?.native ? { native: opts.native } : {}),
                     ...(opts?.languageExtensions ? { languageExtensions: opts.languageExtensions } : {}),
                     threads: conc,
                     ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
@@ -1954,7 +2542,6 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                     allFiles: Array.from(allFiles),
                     fileSignatures,
                     cachedFileEdges: cachedGraphEntries,
-                    ...(onFallbackImportExtraction ? { onFallbackImportExtraction } : {}),
                     ...(baseGraph ? { baseGraph } : {}),
                     replaceFiles: new Set(changedFiles),
                     onFileEdges: (file, entry) => {
@@ -2070,6 +2657,7 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
     }
 }
 export async function buildGraphDelta(projectRoot, opts) {
+    assertNativeRequiredAvailable();
     const manifest = await loadManifest(projectRoot, opts);
     const trackedEntries = sanitizeManifestEntriesForRoot(projectRoot, manifest?.files);
     const graphOptions = normalizeGraphOptions(opts?.graph);
@@ -2079,9 +2667,6 @@ export async function buildGraphDelta(projectRoot, opts) {
         ? diffBuildOptions(manifest.buildOptions, opts).includes("languageExtensions")
         : false;
     const languageSupportChangedForFile = (file) => supportForFile(file, previousLanguageExtensions)?.id !== supportForFile(file, currentLanguageExtensions)?.id;
-    const strictIncremental = opts?.incrementalStrict ?? false;
-    if (strictIncremental && graphOptions.fast)
-        graphOptions.fast = false;
     const explicitFiles = await normalizeIndexedFileInputsWithinRoot(projectRoot, opts?.files ?? [], "Graph delta file");
     const additionalFiles = await normalizeIndexedFileInputsWithinRoot(projectRoot, opts?.additionalFiles ?? [], "Additional graph delta file");
     const needsGitScan = !!opts?.gitBase || !!opts?.changedSince;