@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/semantic/semantic-context-pool.js

@@ -0,0 +1,830 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticContextPool = exports.SemanticContextPoolCapacityError = void 0;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const semantic_context_provider_1 = require("./semantic-context-provider");
+const workspace_project_index_1 = require("../topology/workspace-project-index");
+const semantic_resident_admission_1 = require("./semantic-resident-admission");
+class SemanticContextPoolCapacityError extends Error {
+    maxResidentPrograms;
+    code = "SEMANTIC_CONTEXT_POOL_CAPACITY_ACTIVE";
+    constructor(maxResidentPrograms) {
+        super("Semantic context pool capacity is occupied by active Program leases.");
+        this.maxResidentPrograms = maxResidentPrograms;
+        this.name = "SemanticContextPoolCapacityError";
+    }
+}
+exports.SemanticContextPoolCapacityError = SemanticContextPoolCapacityError;
+const DEFAULT_MAX_ENTRIES = 2;
+const DEFAULT_IDLE_TTL_MS = 60_000;
+const DEFAULT_OVERSIZED_IDLE_TTL_MS = 5 * 60_000;
+const DEFAULT_RSS_SOFT_LIMIT_BYTES = 768 * 1024 * 1024;
+const DEFAULT_SINGLE_OVERSIZE_HARD_LIMIT_BYTES = 1280 * 1024 * 1024;
+const DEFAULT_COLD_BUILD_HEADROOM_BYTES = 256 * 1024 * 1024;
+/**
+ * Bounded cross-request Program reuse with exact on-acquire disk proof.
+ * LanguageService and overlay contexts intentionally remain request-local.
+ * A fresh structural index probe on each acquisition detects unreported
+ * config/package/source-set drift; source/dependency contents are hashed by
+ * bytes, never inferred from mtime or size.
+ */
+class SemanticContextPool {
+    root;
+    maxEntries;
+    idleTtlMs;
+    oversizedIdleTtlMs;
+    rssSoftLimitBytes;
+    singleOversizeHardLimitBytes;
+    coldBuildHeadroomBytes;
+    now;
+    readRssBytes;
+    residentAdmissionCoordinator;
+    admissionOwner = Symbol("semantic-context-pool");
+    entries = new Map();
+    retiredEntries = new Set();
+    requestLocalPrograms = 0;
+    languageServiceActiveLeases = 0;
+    index = null;
+    structuralDigest = "";
+    structuralFileDigest = "";
+    workspaceTreeDigest = "";
+    structuralGeneration = 0;
+    lastStructuralProbeMs = 0;
+    disposed = false;
+    stats = {
+        hits: 0,
+        misses: 0,
+        bypasses: 0,
+        evictions: 0,
+        invalidations: 0,
+        admissionRejected: 0,
+        structuralRebuilds: 0
+    };
+    constructor(workspaceRoot, options = {}) {
+        this.root = path.resolve(workspaceRoot);
+        this.maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_MAX_ENTRIES));
+        this.idleTtlMs = Math.max(0, options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS);
+        this.oversizedIdleTtlMs = Math.max(0, options.oversizedIdleTtlMs ?? DEFAULT_OVERSIZED_IDLE_TTL_MS);
+        this.rssSoftLimitBytes = Math.max(0, options.rssSoftLimitBytes ?? DEFAULT_RSS_SOFT_LIMIT_BYTES);
+        this.singleOversizeHardLimitBytes = Math.max(this.rssSoftLimitBytes, options.singleOversizeHardLimitBytes ?? DEFAULT_SINGLE_OVERSIZE_HARD_LIMIT_BYTES);
+        this.coldBuildHeadroomBytes = Math.max(0, options.coldBuildHeadroomBytes ?? DEFAULT_COLD_BUILD_HEADROOM_BYTES);
+        this.now = options.now ?? Date.now;
+        this.readRssBytes = options.readRssBytes ?? (() => process.memoryUsage().rss);
+        this.residentAdmissionCoordinator = options.residentAdmissionCoordinator ?? new semantic_resident_admission_1.SemanticResidentAdmissionCoordinator();
+    }
+    get state() {
+        const cachedActive = [...this.entries.values()].reduce((sum, entry) => sum + entry.activeLeases, 0);
+        const retiredActive = [...this.retiredEntries].reduce((sum, entry) => sum + entry.activeLeases, 0);
+        const residentPrograms = this.entries.size + this.retiredEntries.size + this.requestLocalPrograms;
+        const oversizedPrograms = [...this.entries.values(), ...this.retiredEntries]
+            .filter((entry) => entry.admission === "oversized").length;
+        return {
+            disposed: this.disposed,
+            structuralGeneration: this.structuralGeneration,
+            entries: this.entries.size,
+            cachedEntries: this.entries.size,
+            retiredPrograms: this.retiredEntries.size,
+            requestLocalPrograms: this.requestLocalPrograms,
+            residentPrograms,
+            oversizedPrograms,
+            activeLeases: cachedActive + retiredActive + this.requestLocalPrograms + this.languageServiceActiveLeases,
+            stats: { ...this.stats }
+        };
+    }
+    acquireProgram(request) {
+        this.assertActive();
+        this.sweepExpired();
+        const index = this.probeStructuralState();
+        const owner = resolveExactOwner(this.root, index, request);
+        const baseKey = buildBaseKey({
+            owner,
+            structuralGeneration: this.structuralGeneration,
+            structuralDigest: this.structuralDigest,
+            mode: "program",
+            projectScope: request.projectScope ?? "owner-with-forward-references"
+        });
+        if ((request.overlays?.length ?? 0) > 0) {
+            this.prepareForColdBuild();
+            this.stats.bypasses += 1;
+            const contextStartedAt = this.now();
+            const rssBeforeBuild = this.readRssBytes();
+            const provider = new semantic_context_provider_1.SemanticContextProvider(this.root, index);
+            const lease = provider.acquireProgram({ ...request, ownerConfig: owner.identity.lexicalPath });
+            this.requestLocalPrograms += 1;
+            const rssAfterBuild = this.readRssBytes();
+            return wrapEphemeralProgramLease(lease, provider, {
+                status: "bypass",
+                mode: "program",
+                key: `${baseKey}|overlay`,
+                admitted: false,
+                admission: "none",
+                reason: "overlay-isolated",
+                timings: {
+                    structuralProbeMs: this.lastStructuralProbeMs,
+                    sourceProofMs: 0,
+                    contextBuildMs: this.now() - contextStartedAt
+                },
+                memory: { rssBeforeBuild, rssAfterBuild }
+            }, () => { this.requestLocalPrograms -= 1; });
+        }
+        const cached = this.entries.get(baseKey);
+        if (cached) {
+            const proofStartedAt = this.now();
+            const currentDigest = fingerprintFiles(cached.sourceFiles);
+            const currentResolverDigest = fingerprintResolverInputs(cached.resolverFiles, cached.resolverDirectories);
+            const sourceProofMs = this.now() - proofStartedAt;
+            if (currentDigest === cached.sourceDigest && currentResolverDigest === cached.resolverDigest) {
+                this.stats.hits += 1;
+                cached.lastUsedAt = this.now();
+                cached.retireWhenIdle = false;
+                this.touch(cached);
+                return this.wrapCachedProgramLease(cached, "hit", sourceProofMs, 0);
+            }
+            this.stats.invalidations += 1;
+            this.retire(cached);
+        }
+        this.stats.misses += 1;
+        this.prepareForColdBuild();
+        const rssBeforeBuild = this.readRssBytes();
+        const contextStartedAt = this.now();
+        const provider = new semantic_context_provider_1.SemanticContextProvider(this.root, index);
+        const lease = provider.acquireProgram({ ...request, ownerConfig: owner.identity.lexicalPath });
+        const rssAfterBuild = this.readRssBytes();
+        const contextBuildMs = this.now() - contextStartedAt;
+        const proofStartedAt = this.now();
+        const sourceFiles = uniqueSorted(lease.program.getSourceFiles().map((source) => source.fileName));
+        const sourceDigest = fingerprintFiles(sourceFiles);
+        const resolverManifest = buildResolverInputManifest(this.root, lease.program);
+        const sourceProofMs = this.now() - proofStartedAt;
+        const key = `${baseKey}|source:${sourceDigest}|resolver:${resolverManifest.digest}`;
+        const rssAtAdmission = this.readRssBytes();
+        let admission = "normal";
+        let rejectionReason;
+        if (this.residentAdmissionCoordinator.state.oversizedResident) {
+            rejectionReason = "oversized-exclusive";
+        }
+        else if (rssAtAdmission > this.rssSoftLimitBytes) {
+            if (rssAtAdmission > this.singleOversizeHardLimitBytes) {
+                rejectionReason = "rss-hard-limit";
+            }
+            else {
+                this.retireNormalInactiveEntries();
+                if (this.residentProgramCount() > 0 || !this.residentAdmissionCoordinator.tryAcquireOversized(this.admissionOwner)) {
+                    rejectionReason = "oversized-exclusive";
+                }
+                else {
+                    admission = "oversized";
+                }
+            }
+        }
+        else if (!this.residentAdmissionCoordinator.tryAcquireNormal(this.admissionOwner)) {
+            rejectionReason = "oversized-exclusive";
+        }
+        if (rejectionReason) {
+            this.stats.admissionRejected += 1;
+            this.requestLocalPrograms += 1;
+            return wrapEphemeralProgramLease(lease, provider, {
+                status: "miss",
+                mode: "program",
+                key,
+                admitted: false,
+                admission: "none",
+                reason: rejectionReason,
+                timings: { structuralProbeMs: this.lastStructuralProbeMs, sourceProofMs, contextBuildMs },
+                memory: { rssBeforeBuild, rssAfterBuild }
+            }, () => { this.requestLocalPrograms -= 1; });
+        }
+        const entry = {
+            baseKey,
+            key,
+            provider,
+            lease,
+            sourceFiles,
+            sourceDigest,
+            resolverFiles: resolverManifest.files,
+            resolverDirectories: resolverManifest.directories,
+            resolverDigest: resolverManifest.digest,
+            lastUsedAt: this.now(),
+            activeLeases: 0,
+            retired: false,
+            retireWhenIdle: false,
+            disposed: false,
+            admission,
+            onDispose: admission === "oversized"
+                ? () => this.residentAdmissionCoordinator.releaseOversized(this.admissionOwner)
+                : () => this.residentAdmissionCoordinator.releaseNormal(this.admissionOwner)
+        };
+        this.entries.set(baseKey, entry);
+        this.enforceCapacity();
+        return this.wrapCachedProgramLease(entry, "miss", sourceProofMs, contextBuildMs, rssBeforeBuild, rssAfterBuild);
+    }
+    acquireLanguageService(request) {
+        this.assertActive();
+        const index = this.probeStructuralState();
+        const owner = resolveExactOwner(this.root, index, request);
+        const provider = new semantic_context_provider_1.SemanticContextProvider(this.root, index);
+        const contextStartedAt = this.now();
+        const rssBeforeBuild = this.readRssBytes();
+        const lease = provider.acquireLanguageService({ ...request, ownerConfig: owner.identity.lexicalPath });
+        this.languageServiceActiveLeases += 1;
+        const rssAfterBuild = this.readRssBytes();
+        const contextBuildMs = this.now() - contextStartedAt;
+        this.stats.bypasses += 1;
+        const cache = {
+            status: "bypass",
+            mode: "languageService",
+            key: buildBaseKey({
+                owner,
+                structuralGeneration: this.structuralGeneration,
+                structuralDigest: this.structuralDigest,
+                mode: "languageService",
+                projectScope: request.projectScope ?? "owner-with-forward-references"
+            }),
+            admitted: false,
+            admission: "none",
+            reason: "language-service-request-local",
+            timings: { structuralProbeMs: this.lastStructuralProbeMs, sourceProofMs: 0, contextBuildMs },
+            memory: { rssBeforeBuild, rssAfterBuild }
+        };
+        let released = false;
+        return {
+            mode: "languageService",
+            descriptor: lease.descriptor,
+            cache,
+            get languageService() { return lease.languageService; },
+            diagnostics: (scope) => lease.diagnostics(scope),
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                try {
+                    lease.release();
+                }
+                finally {
+                    try {
+                        provider.dispose();
+                    }
+                    finally {
+                        this.languageServiceActiveLeases -= 1;
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Borrows the session-owned structural authority for one synchronous read.
+     * The index must not escape the callback; lifecycle and invalidation remain pool-owned.
+     */
+    withWorkspaceProjectIndex(read) {
+        this.assertActive();
+        return read(this.probeStructuralState());
+    }
+    invalidate(_change) {
+        this.assertActive();
+        this.stats.invalidations += 1;
+        this.structuralGeneration += 1;
+        this.retireAll();
+        this.index?.dispose();
+        this.index = null;
+        this.structuralDigest = "";
+        this.structuralFileDigest = "";
+        this.workspaceTreeDigest = "";
+    }
+    /** Allows the session registry to release idle exclusivity across workspaces. */
+    sweepIdle() {
+        this.assertActive();
+        this.sweepExpired();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.retireAll();
+        this.index?.dispose();
+        this.index = null;
+        this.structuralDigest = "";
+        this.structuralFileDigest = "";
+        this.workspaceTreeDigest = "";
+        this.disposed = true;
+    }
+    probeStructuralState() {
+        const startedAt = this.now();
+        if (this.index) {
+            const snapshot = this.index.snapshot;
+            const structuralFileDigest = fingerprintFiles(structuralInputFiles(this.root, snapshot));
+            const workspaceTreeDigest = fingerprintWorkspaceTree(this.root);
+            if (structuralFileDigest === this.structuralFileDigest && workspaceTreeDigest === this.workspaceTreeDigest) {
+                this.lastStructuralProbeMs = this.now() - startedAt;
+                return this.index;
+            }
+        }
+        const probe = new workspace_project_index_1.WorkspaceProjectIndex(this.root);
+        this.stats.structuralRebuilds += 1;
+        const probeSnapshot = probe.snapshot;
+        const digest = fingerprintStructure(probeSnapshot);
+        const structuralFileDigest = fingerprintFiles(structuralInputFiles(this.root, probeSnapshot));
+        const workspaceTreeDigest = fingerprintWorkspaceTree(this.root);
+        this.lastStructuralProbeMs = this.now() - startedAt;
+        if (!this.index) {
+            this.index = probe;
+            this.structuralDigest = digest;
+            this.structuralFileDigest = structuralFileDigest;
+            this.workspaceTreeDigest = workspaceTreeDigest;
+            this.structuralGeneration = Math.max(1, this.structuralGeneration);
+            return probe;
+        }
+        if (digest === this.structuralDigest) {
+            probe.dispose();
+            this.structuralFileDigest = structuralFileDigest;
+            this.workspaceTreeDigest = workspaceTreeDigest;
+            return this.index;
+        }
+        this.stats.invalidations += 1;
+        this.structuralGeneration += 1;
+        this.retireAll();
+        this.index.dispose();
+        this.index = probe;
+        this.structuralDigest = digest;
+        this.structuralFileDigest = structuralFileDigest;
+        this.workspaceTreeDigest = workspaceTreeDigest;
+        return probe;
+    }
+    wrapCachedProgramLease(entry, status, sourceProofMs, contextBuildMs, rssBeforeBuild = this.readRssBytes(), rssAfterBuild = rssBeforeBuild) {
+        entry.activeLeases += 1;
+        let released = false;
+        return {
+            mode: "program",
+            descriptor: entry.lease.descriptor,
+            cache: {
+                status,
+                mode: "program",
+                key: entry.key,
+                admitted: true,
+                admission: entry.admission,
+                timings: { structuralProbeMs: this.lastStructuralProbeMs, sourceProofMs, contextBuildMs },
+                memory: { rssBeforeBuild, rssAfterBuild }
+            },
+            get program() { return entry.lease.program; },
+            get checker() { return entry.lease.checker; },
+            diagnostics: (scope) => entry.lease.diagnostics(scope),
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                entry.activeLeases -= 1;
+                if (entry.retired && entry.activeLeases === 0) {
+                    this.retiredEntries.delete(entry);
+                    disposeEntry(entry);
+                }
+                else if (entry.retireWhenIdle && entry.activeLeases === 0) {
+                    this.retire(entry);
+                }
+            }
+        };
+    }
+    touch(entry) {
+        this.entries.delete(entry.baseKey);
+        this.entries.set(entry.baseKey, entry);
+    }
+    sweepExpired() {
+        const now = this.now();
+        for (const entry of [...this.entries.values()]) {
+            const ttl = entry.admission === "oversized" ? this.oversizedIdleTtlMs : this.idleTtlMs;
+            if (entry.lastUsedAt <= now - ttl) {
+                if (entry.activeLeases > 0) {
+                    entry.retireWhenIdle = true;
+                }
+                else {
+                    this.retire(entry);
+                }
+            }
+        }
+    }
+    enforceCapacity() {
+        while (this.residentProgramCount() > this.maxEntries) {
+            const oldest = [...this.entries.values()].find((entry) => entry.activeLeases === 0);
+            if (!oldest)
+                return;
+            this.retire(oldest);
+        }
+    }
+    prepareForColdBuild() {
+        while (this.entries.size > 0 && this.readRssBytes() + this.coldBuildHeadroomBytes > this.rssSoftLimitBytes) {
+            const candidate = [...this.entries.values()].find((entry) => entry.activeLeases === 0 && entry.admission === "normal");
+            if (!candidate)
+                break;
+            this.retire(candidate);
+        }
+        while (this.residentProgramCount() >= this.maxEntries) {
+            const candidate = [...this.entries.values()].find((entry) => entry.activeLeases === 0 && entry.admission === "normal");
+            if (!candidate) {
+                this.stats.admissionRejected += 1;
+                throw new SemanticContextPoolCapacityError(this.maxEntries);
+            }
+            this.retire(candidate);
+        }
+    }
+    retireAll() {
+        for (const entry of [...this.entries.values()]) {
+            this.retire(entry);
+        }
+    }
+    retireNormalInactiveEntries() {
+        for (const entry of [...this.entries.values()]) {
+            if (entry.activeLeases === 0 && entry.admission === "normal")
+                this.retire(entry);
+        }
+    }
+    retire(entry) {
+        if (entry.retired)
+            return;
+        entry.retired = true;
+        this.entries.delete(entry.baseKey);
+        this.stats.evictions += 1;
+        if (entry.activeLeases === 0) {
+            disposeEntry(entry);
+        }
+        else {
+            this.retiredEntries.add(entry);
+        }
+    }
+    residentProgramCount() {
+        return this.entries.size + this.retiredEntries.size + this.requestLocalPrograms;
+    }
+    assertActive() {
+        if (this.disposed)
+            throw new Error("SemanticContextPool is disposed.");
+    }
+}
+exports.SemanticContextPool = SemanticContextPool;
+function resolveExactOwner(root, index, request) {
+    const focusFile = path.resolve(root, request.focusFile);
+    const owners = index.exactOwnersForFile(focusFile);
+    if (owners.length === 0) {
+        throw new semantic_context_provider_1.SemanticContextError("SEMANTIC_CONTEXT_OWNER_NOT_FOUND", "No exact parsed TypeScript project owns the focus file.", { focusFile });
+    }
+    if (!request.ownerConfig) {
+        if (owners.length > 1) {
+            throw new semantic_context_provider_1.SemanticContextError("SEMANTIC_CONTEXT_OWNER_AMBIGUOUS", "Multiple exact parsed TypeScript projects own the focus file; choose an owner explicitly.", { focusFile, owners: owners.map((owner) => owner.identity.lexicalPath) });
+        }
+        return owners[0];
+    }
+    const requested = index.identityForFile(path.resolve(root, request.ownerConfig));
+    const owner = owners.find((candidate) => candidate.identity.key === requested.key);
+    if (!owner) {
+        throw new semantic_context_provider_1.SemanticContextError("SEMANTIC_CONTEXT_OWNER_MISMATCH", "The requested TypeScript project is not an exact owner of the focus file.", { focusFile, ownerConfig: request.ownerConfig, exactOwners: owners.map((candidate) => candidate.identity.lexicalPath) });
+    }
+    return owner;
+}
+function buildBaseKey(input) {
+    return [
+        `owner:${input.owner.identity.key}`,
+        `generation:${input.structuralGeneration}`,
+        `compiler:${input.owner.compilerOptionsFingerprint}`,
+        `files:${input.owner.fileSetFingerprint}`,
+        `typescript:${typescript_1.default.version}`,
+        `mode:${input.mode}`,
+        `scope:${input.projectScope}`,
+        `conditions:${input.structuralDigest}`
+    ].join("|");
+}
+function fingerprintStructure(snapshot) {
+    const files = structuralInputFiles(snapshot.root.lexicalPath, snapshot);
+    const records = {
+        configs: snapshot.configs.map((config) => ({
+            key: config.identity.key,
+            role: config.configRole,
+            roleEvidence: config.roleEvidence,
+            compiler: config.compilerOptionsFingerprint,
+            files: config.fileSetFingerprint,
+            references: config.projectReferences.map((reference) => reference.key)
+        })),
+        packages: snapshot.packages.map((pkg) => ({ key: pkg.identity.key, fingerprint: pkg.fingerprint }))
+    };
+    return hashParts([stableStringify(records), fingerprintFiles(files)]);
+}
+function structuralInputFiles(root, snapshot) {
+    return uniqueSorted([
+        path.join(root, "aib.json"),
+        ...snapshot.configs.flatMap((config) => [
+            config.identity.lexicalPath,
+            ...(config.extends ? [config.extends.lexicalPath] : []),
+            ...config.projectReferences.map((reference) => reference.lexicalPath)
+        ]),
+        ...snapshot.packages.map((pkg) => pkg.packageJson.lexicalPath)
+    ]);
+}
+function fingerprintWorkspaceTree(root) {
+    const hash = crypto.createHash("sha256");
+    const pending = [path.resolve(root)];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const directory = pending.pop();
+        let realDirectory;
+        try {
+            realDirectory = (0, semantic_context_provider_1.canonicalSemanticFileKey)(directory);
+        }
+        catch {
+            realDirectory = path.resolve(directory);
+        }
+        if (visited.has(realDirectory))
+            continue;
+        visited.add(realDirectory);
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true })
+                .sort((left, right) => left.name.localeCompare(right.name));
+        }
+        catch {
+            hash.update(`${path.relative(root, directory)}\0unreadable\0`);
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === ".git" || entry.name === "node_modules" || entry.name === ".tmp")
+                continue;
+            const entryPath = path.join(directory, entry.name);
+            const relative = path.relative(root, entryPath);
+            let kind = entry.isDirectory() ? "d" : entry.isFile() ? "f" : entry.isSymbolicLink() ? "l" : "o";
+            let link = "";
+            let recurse = entry.isDirectory();
+            if (entry.isSymbolicLink()) {
+                try {
+                    const realTarget = fs.realpathSync.native(entryPath);
+                    link = `${fs.readlinkSync(entryPath)}=>${realTarget}`;
+                    // The structural tree proof owns workspace-local discovery only. External
+                    // junction targets are represented by link identity; exact Program source
+                    // and resolver dependencies are byte-fingerprinted by their own manifests.
+                    recurse = fs.statSync(entryPath).isDirectory() && isInsideOrEqual(realTarget, root);
+                }
+                catch {
+                    link = "broken";
+                }
+            }
+            hash.update(`${relative}\0${kind}\0${link}\0`);
+            if (recurse)
+                pending.push(entryPath);
+        }
+    }
+    return hash.digest("hex");
+}
+function fingerprintFiles(files) {
+    const hash = crypto.createHash("sha256");
+    for (const file of uniqueSorted(files)) {
+        hash.update((0, semantic_context_provider_1.canonicalSemanticFileKey)(file));
+        try {
+            const content = fs.readFileSync(file);
+            hash.update("\0present\0");
+            hash.update(content);
+        }
+        catch {
+            hash.update("\0missing\0");
+        }
+        hash.update("\0next\0");
+    }
+    return hash.digest("hex");
+}
+function wrapEphemeralProgramLease(lease, provider, cache, onRelease) {
+    let released = false;
+    return {
+        mode: "program",
+        descriptor: lease.descriptor,
+        cache,
+        get program() { return lease.program; },
+        get checker() { return lease.checker; },
+        diagnostics: (scope) => lease.diagnostics(scope),
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            try {
+                lease.release();
+            }
+            finally {
+                try {
+                    provider.dispose();
+                }
+                finally {
+                    onRelease();
+                }
+            }
+        }
+    };
+}
+function disposeEntry(entry) {
+    if (entry.disposed)
+        return;
+    entry.disposed = true;
+    try {
+        entry.lease.release();
+    }
+    finally {
+        try {
+            entry.provider.dispose();
+        }
+        finally {
+            entry.onDispose();
+            entry.sourceFiles.length = 0;
+            entry.resolverFiles.length = 0;
+            entry.resolverDirectories.length = 0;
+        }
+    }
+}
+const LOCK_AND_INSTALL_MARKERS = [
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "yarn.lock",
+    "bun.lock",
+    "bun.lockb",
+    "node_modules/.package-lock.json",
+    "node_modules/.modules.yaml",
+    "node_modules/.pnpm/lock.yaml"
+];
+function buildResolverInputManifest(workspaceRoot, program) {
+    const files = new Set(LOCK_AND_INSTALL_MARKERS.map((item) => path.join(workspaceRoot, item)));
+    const directories = new Set();
+    const packageRequests = [];
+    const sourceFiles = program.getSourceFiles();
+    for (const source of sourceFiles) {
+        const packageJson = packageJsonForNodeModulesFile(source.fileName);
+        if (packageJson)
+            files.add(packageJson);
+        for (const imported of typescript_1.default.preProcessFile(source.text, true, true).importedFiles) {
+            const packageName = barePackageName(imported.fileName);
+            if (packageName) {
+                packageRequests.push({
+                    start: packageJson ? path.dirname(packageJson) : path.dirname(source.fileName),
+                    packageName
+                });
+            }
+        }
+    }
+    const searchStarts = uniqueSorted([
+        workspaceRoot,
+        ...sourceFiles.map((source) => packageJsonForNodeModulesFile(source.fileName))
+            .filter((value) => value !== null)
+            .map(path.dirname),
+        ...sourceFiles
+            .filter((source) => isInsideOrEqual(source.fileName, workspaceRoot) && !source.fileName.includes(`${path.sep}node_modules${path.sep}`))
+            .map((source) => path.dirname(source.fileName))
+    ]);
+    for (const start of searchStarts) {
+        for (const nodeModules of nodeModulesSearchDirectories(start)) {
+            directories.add(nodeModules);
+        }
+    }
+    for (const request of packageRequests) {
+        for (const nodeModules of nodeModulesSearchDirectories(request.start)) {
+            directories.add(nodeModules);
+            files.add(path.join(nodeModules, request.packageName, "package.json"));
+        }
+    }
+    const fileList = uniqueSorted([...files]);
+    const directoryList = uniqueSorted([...directories]);
+    return {
+        files: fileList,
+        directories: directoryList,
+        digest: fingerprintResolverInputs(fileList, directoryList)
+    };
+}
+function fingerprintResolverInputs(files, directories) {
+    const hash = crypto.createHash("sha256");
+    hash.update(fingerprintFiles(files));
+    for (const directory of uniqueSorted(directories)) {
+        hash.update((0, semantic_context_provider_1.canonicalSemanticFileKey)(directory));
+        try {
+            const entries = fs.readdirSync(directory, { withFileTypes: true })
+                .map((entry) => {
+                const entryPath = path.join(directory, entry.name);
+                let link = "";
+                if (entry.isSymbolicLink()) {
+                    try {
+                        link = `${fs.readlinkSync(entryPath)}=>${fs.realpathSync.native(entryPath)}`;
+                    }
+                    catch {
+                        link = "broken";
+                    }
+                }
+                let scoped = "";
+                if (entry.name.startsWith("@") && entry.isDirectory()) {
+                    try {
+                        scoped = fs.readdirSync(entryPath, { withFileTypes: true })
+                            .map((child) => {
+                            const childPath = path.join(entryPath, child.name);
+                            let childLink = "";
+                            if (child.isSymbolicLink()) {
+                                try {
+                                    childLink = `${fs.readlinkSync(childPath)}=>${fs.realpathSync.native(childPath)}`;
+                                }
+                                catch {
+                                    childLink = "broken";
+                                }
+                            }
+                            return `${child.name}:${child.isDirectory() ? "d" : child.isFile() ? "f" : child.isSymbolicLink() ? "l" : "o"}:${childLink}`;
+                        })
+                            .sort()
+                            .join(",");
+                    }
+                    catch {
+                        scoped = "unreadable";
+                    }
+                }
+                return `${entry.name}:${entry.isDirectory() ? "d" : entry.isFile() ? "f" : entry.isSymbolicLink() ? "l" : "o"}:${link}:${scoped}`;
+            })
+                .sort();
+            hash.update(`\0present\0${entries.join("\0")}`);
+        }
+        catch {
+            hash.update("\0missing\0");
+        }
+    }
+    return hash.digest("hex");
+}
+function packageJsonForNodeModulesFile(file) {
+    const normalized = path.resolve(file);
+    const parts = normalized.split(path.sep);
+    const index = parts.lastIndexOf("node_modules");
+    if (index < 0 || index + 1 >= parts.length)
+        return null;
+    const packageEnd = parts[index + 1].startsWith("@") ? index + 3 : index + 2;
+    if (packageEnd > parts.length)
+        return null;
+    return path.join(...parts.slice(0, packageEnd), "package.json");
+}
+function barePackageName(specifier) {
+    if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(specifier)) {
+        return null;
+    }
+    const parts = specifier.split("/");
+    return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? null;
+}
+function nodeModulesSearchDirectories(start) {
+    const result = [];
+    let current = path.resolve(start);
+    while (true) {
+        result.push(path.join(current, "node_modules"));
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return result;
+}
+function isInsideOrEqual(candidate, parent) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function hashParts(parts) {
+    return crypto.createHash("sha256").update(parts.join("\0")).digest("hex");
+}
+function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function uniqueSorted(values) {
+    return [...new Set(values.map((value) => path.resolve(value)))].sort((left, right) => left.localeCompare(right));
+}