@lzehrung/codegraph 2.3.30 → 2.4.0

package/dist/indexer/build-index.js

@@ -9,7 +9,9 @@ import { loadWorkspaceConfig, resolveWorkspacePackage } from "../util/workspace.
 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 { 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";
@@ -30,7 +32,7 @@ import { initNativeBackendReport } from "../native/native-backend-report.js";
 import { closeDuplicateUnitCacheDatabase } from "../duplicates.js";
 import { 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, createFallbackImportExtractionHandler, 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 +41,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 +149,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;
@@ -324,9 +434,102 @@ 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);
@@ -551,6 +754,260 @@ 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);
+            }
+        }
+    }
+    return { stale, deletedDeclarationFiles };
+}
+/**
+ * Languages that resolve imports through the declarations of other files
+ * (C# namespaces, JVM packages, PHP namespaces, C++ named modules).
+ * A content change in a dependency can move the target.
+ */
+const DECLARATION_RESOLVED_IMPORT_LANGUAGES = new Set(["cpp", "csharp", "java", "kotlin", "php"]);
+/** Files a cached module resolved: import targets and re-export sources. */
+function cachedModuleTargets(mod) {
+    const targets = mod.imports.flatMap((binding) => (typeof binding.resolved === "string" ? [binding.resolved] : []));
+    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) {
     clearResolutionCaches();
     await initializeFileIdentityCaseSensitivity(projectRoot);
@@ -629,6 +1086,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 +1160,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 +1177,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 +1252,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
@@ -942,6 +1454,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 +1492,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 });
             }
         }
-        if (manifestEntries) {
+        if (manifestEntries && !staleRowRemovalFailed) {
             await timeIndexBuildPhase({
                 opts,
                 timings,
@@ -1029,7 +1551,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,
@@ -1740,6 +2262,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 +2270,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 +2343,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.