@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/exports-star-expand-preview.js

@@ -0,0 +1,807 @@
+"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.ExportsStarPreviewSession = void 0;
+exports.planExportsStarExpandPreview = planExportsStarExpandPreview;
+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/semantic-context-provider");
+const workspace_project_index_1 = require("../topology/workspace-project-index");
+const semantic_export_index_1 = require("./semantic-export-index");
+function planExportsStarExpandPreview(cwd, input) {
+    const session = new ExportsStarPreviewSession(cwd);
+    try {
+        return session.plan(input);
+    }
+    finally {
+        session.dispose();
+    }
+}
+class ExportsStarPreviewSession {
+    semanticContextPool;
+    root;
+    projectIndex;
+    semanticProvider;
+    leases = new Map();
+    structuralIndexMs;
+    programsBuilt = 0;
+    overlaysBuilt = 0;
+    poolHits = 0;
+    poolMisses = 0;
+    poolBypasses = 0;
+    poolFallbacks = 0;
+    disposed = false;
+    constructor(cwd, semanticContextPool) {
+        this.semanticContextPool = semanticContextPool;
+        this.root = path.resolve(cwd);
+        const structuralStarted = performance.now();
+        this.projectIndex = new workspace_project_index_1.WorkspaceProjectIndex(this.root);
+        this.structuralIndexMs = roundMs(performance.now() - structuralStarted);
+        this.semanticProvider = new semantic_context_provider_1.SemanticContextProvider(this.root, this.projectIndex);
+    }
+    get resources() {
+        return {
+            structuralIndexesBuilt: 1,
+            semanticProvidersCreated: 1,
+            distinctContextsAcquired: this.leases.size,
+            programsBuilt: this.programsBuilt,
+            overlaysBuilt: this.overlaysBuilt,
+            poolHits: this.poolHits,
+            poolMisses: this.poolMisses,
+            poolBypasses: this.poolBypasses,
+            poolFallbacks: this.poolFallbacks
+        };
+    }
+    plan(input) {
+        if (this.disposed)
+            throw new Error("ExportsStarPreviewSession is disposed.");
+        const totalStarted = performance.now();
+        const root = this.root;
+        const projectIndex = this.projectIndex;
+        const semanticProvider = this.semanticProvider;
+        const leases = this.leases;
+        const absoluteSource = path.resolve(root, input.sourceFile);
+        const sourceFile = repoPath(root, absoluteSource);
+        if (!isInside(root, absoluteSource) || !fs.existsSync(absoluteSource)) {
+            return emptyPreview(sourceFile, "sourceNotFound", "The requested barrel is not an existing workspace file.", { structuralIndexMs: this.structuralIndexMs }, this.resources, totalStarted);
+        }
+        if (!/\.(?:ts|tsx|mts|cts)$/i.test(sourceFile) || /\.d\.ts$/i.test(sourceFile)) {
+            return emptyPreview(sourceFile, "sourceKindUnsupported", "exports.star.expand preview supports TypeScript source modules only.", { structuralIndexMs: this.structuralIndexMs }, this.resources, totalStarted);
+        }
+        const timings = { structuralIndexMs: this.structuralIndexMs };
+        const semanticStarted = performance.now();
+        const barrelOwners = projectIndex.exactOwnersForFile(sourceFile);
+        if (barrelOwners.length === 0) {
+            return emptyPreview(sourceFile, "barrelNotOwned", "No exact TypeScript project owns the barrel.", timings, this.resources, totalStarted);
+        }
+        for (const owner of barrelOwners) {
+            acquireOwner(root, semanticProvider, sourceFile, owner, leases, this.semanticContextPool, (acquisition) => {
+                if (acquisition.source === "request-local") {
+                    this.programsBuilt += 1;
+                }
+                else if (acquisition.source === "pool-fallback") {
+                    this.programsBuilt += 1;
+                    this.poolFallbacks += 1;
+                }
+                else if (acquisition.cache.status === "hit") {
+                    this.poolHits += 1;
+                }
+                else if (acquisition.cache.status === "miss") {
+                    this.programsBuilt += 1;
+                    this.poolMisses += 1;
+                }
+                else {
+                    this.programsBuilt += 1;
+                    this.poolBypasses += 1;
+                }
+            });
+        }
+        const barrelRecords = barrelOwners.map((owner) => leases.get(owner.identity.key));
+        const source = barrelRecords[0]?.lease.program.getSourceFile(path.resolve(root, sourceFile));
+        if (!source) {
+            return emptyPreview(sourceFile, "barrelMissingFromProgram", "The barrel is missing from its owning TypeScript program.", timings, this.resources, totalStarted);
+        }
+        timings.semanticContextsMs = roundMs(performance.now() - semanticStarted);
+        const coverageStarted = performance.now();
+        const rawSelected = selectRawStarEdges(source, input.selectors, sourceFile);
+        const consumerEvidence = collectConsumerEvidence(root, sourceFile, barrelOwners, leases, projectIndex);
+        const publicBarrel = isPackageExportedBarrel(root, sourceFile, projectIndex);
+        const cjs = isCommonJsSource(source, barrelRecords[0].lease.program.getCompilerOptions());
+        const relevantCoverageIssue = consumerEvidence.flatMap((evidence) => [
+            ...evidence.unresolved.map((item) => retainedReason(sourceFile, "*", "relevantCoverageIncomplete", `Relevant consumer ${item.file} has unresolved ${item.specifier}.`)),
+            ...evidence.multiOwnerFiles.map((item) => retainedReason(sourceFile, "*", "consumerMultipleOwners", `Relevant consumer ${item.file} has multiple owners: ${item.owners.join(", ")}.`))
+        ])[0];
+        const namespaceFiles = unique(consumerEvidence.flatMap((item) => item.namespaceFiles));
+        const dynamicFiles = unique(consumerEvidence.flatMap((item) => item.dynamicFiles));
+        const barrelOwnerKeys = new Set(barrelOwners.map((owner) => owner.identity.key));
+        const uncoveredConfig = projectIndex.snapshot.configs.find((config) => !barrelOwnerKeys.has(config.identity.key));
+        const decisive = cjs && namespaceFiles.length + dynamicFiles.length > 0
+            ? retainedReason(sourceFile, "*", "namespaceShapeObserved", `CJS namespace shape is observed by ${[...namespaceFiles, ...dynamicFiles].slice(0, 3).join(", ")}.`)
+            : cjs && publicBarrel && input.namespaceShape !== "allow"
+                ? retainedReason(sourceFile, "*", "namespaceShapeConsentRequired", "Public/package CJS barrel requires namespaceShape=allow.")
+                : relevantCoverageIssue
+                    ? relevantCoverageIssue
+                    : cjs && uncoveredConfig
+                        ? retainedReason(sourceFile, "*", "consumerCoverageIncomplete", `CJS consumer coverage is not proven outside barrel owners; uncovered project ${repoPath(root, uncoveredConfig.identity.lexicalPath)}.`)
+                        : null;
+        if (rawSelected.specifiers.length === 0 || decisive) {
+            timings.exportIndexMs = 0;
+            timings.coveragePlannerMs = roundMs(performance.now() - coverageStarted);
+            timings.totalMs = roundMs(this.structuralIndexMs + performance.now() - totalStarted);
+            return earlyRetainedPreview({
+                sourceFile,
+                requestedCount: rawSelected.requestedCount,
+                selectedSpecifiers: rawSelected.specifiers,
+                retained: decisive
+                    ? [...rawSelected.retained, ...rawSelected.specifiers.map((specifier) => ({ ...decisive, selector: specifier }))]
+                    : rawSelected.retained,
+                owners: barrelOwners.map((owner) => repoPath(root, owner.identity.lexicalPath)).sort(),
+                consumers: consumerEvidence,
+                timings,
+                resources: this.resources,
+                input
+            });
+        }
+        const exportProvider = createExportProvider(root, barrelRecords);
+        const exportStarted = performance.now();
+        const index = (0, semantic_export_index_1.buildSemanticExportIndexFromProvider)(exportProvider, { barrelFiles: [sourceFile] });
+        timings.exportIndexMs = roundMs(performance.now() - exportStarted);
+        const barrel = index.barrels[0];
+        const selected = selectEdges(barrel, input.selectors, sourceFile);
+        const retained = [...selected.retained];
+        const replacements = [];
+        const surfaces = [];
+        const renderedNames = new Set();
+        for (const edge of selected.edges) {
+            const local = validateEdge(edge, sourceFile);
+            if (local) {
+                retained.push(local);
+                continue;
+            }
+            const rendered = renderEdge(source, edge, renderedNames);
+            if (!rendered) {
+                retained.push(retainedReason(sourceFile, edge.specifier, "runtimeEvaluationWouldBeLost", "The selected runtime star has no exposed runtime binding; expansion would remove target evaluation."));
+                continue;
+            }
+            replacements.push({ edge, text: rendered });
+            for (const binding of edge.bindings.filter((item) => item.exposed && !item.shadowed && !item.collision && !item.isDefault)) {
+                renderedNames.add(binding.publicName);
+            }
+            surfaces.push({
+                selector: selected.selectorByEdge.get(edge.id) ?? edge.specifier,
+                specifier: edge.specifier,
+                ...(edge.resolvedFile ? { target: edge.resolvedFile } : {}),
+                runtime: edge.bindings.filter(isExposedRuntime).map((item) => item.publicName).sort(),
+                typeOnly: edge.bindings.filter(isExposedTypeOnly).map((item) => item.publicName).sort()
+            });
+        }
+        let nextText = applyReplacements(source.text, replacements);
+        let addedDiagnostics = [];
+        if (replacements.length > 0) {
+            addedDiagnostics = collectAddedDiagnostics(root, sourceFile, nextText, barrelOwners, semanticProvider, leases, consumerEvidence, () => { this.overlaysBuilt += 1; });
+            if (addedDiagnostics.length > 0) {
+                for (const replacement of replacements) {
+                    retained.push(retainedReason(sourceFile, replacement.edge.specifier, "virtualDiagnosticsAdded", `Combined barrel rewrite adds diagnostic TS${addedDiagnostics[0].code} in ${addedDiagnostics[0].file}.`));
+                }
+                replacements.length = 0;
+                surfaces.length = 0;
+                nextText = source.text;
+            }
+        }
+        timings.coveragePlannerMs = roundMs(performance.now() - coverageStarted);
+        const filesTouched = replacements.length > 0 ? [sourceFile] : [];
+        const edits = replacements.length > 0
+            ? [{ file: sourceFile, start: 0, end: source.text.length, text: nextText, reason: "exports.star.expand preview" }]
+            : [];
+        const beforeHashes = replacements.length > 0
+            ? [{ file: sourceFile, beforeHash: sha256(source.text) }]
+            : [];
+        const requestedCount = selected.requestedCount;
+        const retainedRows = dedupeRetained(retained).filter((item) => item.selector !== "*" || requestedCount === 0);
+        const plannedCount = replacements.length;
+        timings.totalMs = roundMs(this.structuralIndexMs + performance.now() - totalStarted);
+        const evidence = {
+            sourceFile,
+            owners: barrel.owners,
+            selectors: input.selectors ?? [],
+            replacements: replacements.map((item) => ({ id: item.edge.id, specifier: item.edge.specifier, text: item.text })),
+            retained: retainedRows,
+            surfaces,
+            consumers: consumerEvidence,
+            diagnostics: addedDiagnostics,
+            beforeHashes
+        };
+        return {
+            ok: true,
+            operation: "exports.star.expand.preview",
+            applyAvailable: false,
+            partial: plannedCount > 0 && retainedRows.length > 0,
+            sourceFile,
+            requestedCount,
+            plannedCount,
+            retainedCount: retainedRows.length,
+            filesTouched,
+            filesWritten: [],
+            retained: retainedRows,
+            rows: [{ ok: true, sourceFile, requestedCount, plannedCount, retainedCount: retainedRows.length }],
+            edits,
+            beforeHashes,
+            owners: barrel.owners,
+            surfaces,
+            diagnostics: { added: addedDiagnostics },
+            cycleEvidence: { status: "available", runtimeEdgesChanged: false, cyclesAdded: [] },
+            consumers: consumerEvidence.map(({ unresolved: _unresolved, multiOwnerFiles: _multiOwnerFiles, ...item }) => item),
+            timings,
+            resources: this.resources,
+            semanticFingerprint: sha256(stableStringify(evidence)),
+            next: "Review exports.star.expand view evidence; apply/execute is not available yet."
+        };
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const record of this.leases.values())
+            record.lease.release();
+        this.leases.clear();
+        this.semanticProvider.dispose();
+        this.projectIndex.dispose();
+    }
+}
+exports.ExportsStarPreviewSession = ExportsStarPreviewSession;
+function emptyPreview(sourceFile, code, reason, timings, resources, totalStarted) {
+    timings.totalMs = roundMs((timings.structuralIndexMs ?? 0) + performance.now() - totalStarted);
+    const retained = [retainedReason(sourceFile, "*", code, reason)];
+    return {
+        ok: true,
+        operation: "exports.star.expand.preview",
+        applyAvailable: false,
+        partial: false,
+        sourceFile,
+        requestedCount: 0,
+        plannedCount: 0,
+        retainedCount: 1,
+        filesTouched: [],
+        filesWritten: [],
+        retained,
+        rows: [{ ok: true, sourceFile, requestedCount: 0, plannedCount: 0, retainedCount: 1 }],
+        edits: [],
+        beforeHashes: [],
+        owners: [],
+        surfaces: [],
+        diagnostics: { added: [] },
+        cycleEvidence: { status: "available", runtimeEdgesChanged: false, cyclesAdded: [] },
+        consumers: [],
+        timings,
+        resources,
+        semanticFingerprint: sha256(stableStringify({ sourceFile, retained })),
+        next: "Review retained exports.star.expand evidence; apply/execute is not available yet."
+    };
+}
+function acquireOwner(root, provider, focusFile, owner, leases, pool, onAcquired) {
+    const existing = leases.get(owner.identity.key);
+    if (existing) {
+        return existing;
+    }
+    let lease;
+    let acquisition;
+    if (pool) {
+        try {
+            const pooled = pool.acquireProgram({
+                focusFile,
+                ownerConfig: owner.identity.lexicalPath,
+                projectScope: "owner-with-forward-references"
+            });
+            lease = pooled;
+            acquisition = { source: "pool", cache: pooled.cache };
+        }
+        catch (error) {
+            lease = provider.acquireProgram({ focusFile, ownerConfig: owner.identity.lexicalPath, projectScope: "owner-with-forward-references" });
+            acquisition = { source: "pool-fallback", error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    else {
+        lease = provider.acquireProgram({ focusFile, ownerConfig: owner.identity.lexicalPath, projectScope: "owner-with-forward-references" });
+        acquisition = { source: "request-local" };
+    }
+    onAcquired(acquisition);
+    const handle = {
+        id: repoPath(root, owner.identity.lexicalPath),
+        checker: lease.checker,
+        getSourceFile: (file) => lease.program.getSourceFile(path.resolve(file)),
+        resolveModule: (fromFile, specifier) => resolveModule(lease.program, fromFile, specifier),
+        symbolIdentity: (symbol) => symbolIdentity(root, lease.checker, symbol),
+        diagnosticsForFile: (file) => {
+            const source = lease.program.getSourceFile(path.resolve(file));
+            return source ? lease.program.getSemanticDiagnostics(source) : [];
+        }
+    };
+    const record = { owner, lease, handle, acquisition };
+    leases.set(owner.identity.key, record);
+    return record;
+}
+function createExportProvider(root, records) {
+    return {
+        root,
+        projectsForFile: (file) => records
+            .filter((record) => Boolean(record.lease.program.getSourceFile(path.resolve(file))))
+            .map((record) => record.handle)
+    };
+}
+function selectRawStarEdges(source, selectors, sourceFile) {
+    const specifiers = collectStarSpecifiers(source);
+    if (!selectors || selectors.length === 0) {
+        return {
+            specifiers,
+            retained: specifiers.length === 0
+                ? [retainedReason(sourceFile, "*", "starEdgeNotFound", "The barrel has no export-star edges to expand.")]
+                : [],
+            requestedCount: specifiers.length
+        };
+    }
+    const selected = [];
+    const retained = [];
+    const requested = unique(selectors.map((item) => item.trim()).filter(Boolean));
+    for (const selector of requested) {
+        const exact = specifiers.filter((specifier) => specifier === selector);
+        const matches = exact.length > 0
+            ? exact
+            : specifiers.filter((specifier) => (0, semantic_export_index_1.normalizeExportEdgeSelector)(specifier) === (0, semantic_export_index_1.normalizeExportEdgeSelector)(selector));
+        if (matches.length === 1) {
+            if (!selected.includes(matches[0]))
+                selected.push(matches[0]);
+        }
+        else if (matches.length > 1) {
+            retained.push({
+                ...retainedReason(sourceFile, selector, "selectorAmbiguous", "Selector matches multiple existing export-star edges."),
+                candidates: [...matches].sort()
+            });
+        }
+        else {
+            retained.push(retainedReason(sourceFile, selector, "selectorNotFound", "No existing export-star edge matches this selector."));
+        }
+    }
+    return { specifiers: selected, retained, requestedCount: requested.length };
+}
+function earlyRetainedPreview(input) {
+    const retained = dedupeRetained(input.retained);
+    const evidence = {
+        sourceFile: input.sourceFile,
+        selectors: input.input.selectors ?? [],
+        selectedSpecifiers: input.selectedSpecifiers,
+        owners: input.owners,
+        retained,
+        consumers: input.consumers
+    };
+    return {
+        ok: true,
+        operation: "exports.star.expand.preview",
+        applyAvailable: false,
+        partial: false,
+        sourceFile: input.sourceFile,
+        requestedCount: input.requestedCount,
+        plannedCount: 0,
+        retainedCount: retained.length,
+        filesTouched: [],
+        filesWritten: [],
+        retained,
+        rows: [{ ok: true, sourceFile: input.sourceFile, requestedCount: input.requestedCount, plannedCount: 0, retainedCount: retained.length }],
+        edits: [],
+        beforeHashes: [],
+        owners: input.owners,
+        surfaces: [],
+        diagnostics: { added: [] },
+        cycleEvidence: { status: "available", runtimeEdgesChanged: false, cyclesAdded: [] },
+        consumers: input.consumers.map(({ unresolved: _unresolved, multiOwnerFiles: _multiOwnerFiles, ...item }) => item),
+        timings: input.timings,
+        resources: input.resources,
+        semanticFingerprint: sha256(stableStringify(evidence)),
+        next: "Review retained exports.star.expand evidence; apply/execute is not available yet."
+    };
+}
+function selectEdges(barrel, selectors, sourceFile) {
+    const selectorByEdge = new Map();
+    if (!selectors || selectors.length === 0) {
+        const edges = barrel.edges.filter((edge) => edge.mode === "runtime-star" || edge.mode === "type-star");
+        for (const edge of edges) {
+            selectorByEdge.set(edge.id, edge.specifier);
+        }
+        return {
+            edges,
+            retained: edges.length === 0
+                ? [retainedReason(sourceFile, "*", "starEdgeNotFound", "The barrel has no export-star edges to expand.")]
+                : [],
+            requestedCount: edges.length,
+            selectorByEdge
+        };
+    }
+    const edges = [];
+    const retained = [];
+    for (const selector of unique(selectors.map((item) => item.trim()).filter(Boolean))) {
+        const resolved = (0, semantic_export_index_1.resolveSemanticExportEdgeSelector)(barrel, selector);
+        if (resolved.status === "resolved") {
+            if (!selectorByEdge.has(resolved.edge.id)) {
+                edges.push(resolved.edge);
+                selectorByEdge.set(resolved.edge.id, selector);
+            }
+        }
+        else if (resolved.status === "ambiguous") {
+            retained.push({
+                ...retainedReason(sourceFile, selector, "selectorAmbiguous", "Selector matches multiple existing export-star edges."),
+                candidates: resolved.candidates.map((item) => item.specifier).sort()
+            });
+        }
+        else {
+            retained.push(retainedReason(sourceFile, selector, "selectorNotFound", "No existing export-star edge matches this selector."));
+        }
+    }
+    return { edges, retained, requestedCount: unique(selectors).length, selectorByEdge };
+}
+function validateEdge(edge, sourceFile) {
+    if (edge.resolution !== "resolved" || !edge.resolvedFile) {
+        return retainedReason(sourceFile, edge.specifier, "edgeUnresolved", "The selected export-star target is not resolved equivalently for every owner.");
+    }
+    if (/\.(?:jsx?|mjs|cjs)$/i.test(edge.resolvedFile)) {
+        return retainedReason(sourceFile, edge.specifier, "targetKindUnsupported", "Raw JavaScript/CommonJS export targets are unsupported.");
+    }
+    if (edge.collisions.length > 0) {
+        return retainedReason(sourceFile, edge.specifier, "exportCollision", `Colliding exports: ${edge.collisions.join(", ")}.`);
+    }
+    if (edge.issues.length > 0) {
+        return retainedReason(sourceFile, edge.specifier, edge.issues[0].code, "The selected edge has unresolved semantic evidence.");
+    }
+    return null;
+}
+function renderEdge(source, edge, excludedNames) {
+    const statement = source.statements.find((item) => item.getStart(source) === edge.start && item.end === edge.end);
+    if (!statement || !typescript_1.default.isExportDeclaration(statement) || !statement.moduleSpecifier) {
+        return null;
+    }
+    const exposed = edge.bindings.filter((binding) => binding.exposed && !binding.shadowed && !binding.collision && !binding.isDefault && !excludedNames.has(binding.publicName));
+    const runtime = exposed.filter(isExposedRuntime);
+    const typeOnly = exposed.filter(isExposedTypeOnly);
+    if (edge.mode === "runtime-star" && runtime.length === 0) {
+        return null;
+    }
+    if (exposed.length === 0) {
+        return null;
+    }
+    const moduleText = source.text.slice(statement.moduleSpecifier.getStart(source), statement.moduleSpecifier.end);
+    const tail = source.text.slice(statement.moduleSpecifier.end, statement.end);
+    const names = edge.mode === "type-star"
+        ? exposed.map((binding) => renderExportName(binding.publicName))
+        : [
+            ...runtime.map((binding) => renderExportName(binding.publicName)),
+            ...typeOnly.map((binding) => `type ${renderExportName(binding.publicName)}`)
+        ];
+    const prefix = edge.mode === "type-star" ? "export type" : "export";
+    return `${prefix} { ${names.join(", ")} } from ${moduleText}${tail}`;
+}
+function applyReplacements(text, replacements) {
+    let result = text;
+    for (const replacement of [...replacements].sort((left, right) => right.edge.start - left.edge.start)) {
+        result = result.slice(0, replacement.edge.start) + replacement.text + result.slice(replacement.edge.end);
+    }
+    return result;
+}
+function collectConsumerEvidence(root, sourceFile, owners, leases, projectIndex) {
+    const absoluteBarrel = path.resolve(root, sourceFile);
+    const barrelOwnerKeys = new Set(owners.map((owner) => owner.identity.key));
+    return owners.map((owner) => {
+        const record = leases.get(owner.identity.key);
+        const graph = buildModuleGraph(root, record.lease.program);
+        const closure = reverseClosure(graph.resolved, absoluteBarrel);
+        const closureKeys = new Set([...closure].map((file) => canonical(file)));
+        const files = [...closure].filter((file) => file !== absoluteBarrel).map((file) => repoPath(root, file)).sort();
+        const namespaceFiles = files.filter((file) => hasNamespaceImportOf(record.lease.program.getSourceFile(path.resolve(root, file)), absoluteBarrel, record.lease.program));
+        const dynamicFiles = files.filter((file) => hasDynamicImportOf(record.lease.program.getSourceFile(path.resolve(root, file)), absoluteBarrel, record.lease.program));
+        const unresolved = graph.unresolved
+            .filter((item) => closureKeys.has(canonical(item.file)))
+            .map((item) => ({ file: repoPath(root, item.file), specifier: item.specifier }));
+        const multiOwnerFiles = files.flatMap((file) => {
+            const fileOwners = projectIndex.exactOwnersForFile(file);
+            const uncoveredOwners = fileOwners.filter((item) => !barrelOwnerKeys.has(item.identity.key));
+            return fileOwners.length > 1 && uncoveredOwners.length > 0
+                ? [{ file, owners: fileOwners.map((item) => repoPath(root, item.identity.lexicalPath)).sort() }]
+                : [];
+        });
+        return {
+            owner: repoPath(root, owner.identity.lexicalPath),
+            files,
+            namespaceFiles,
+            dynamicFiles,
+            unresolved,
+            multiOwnerFiles
+        };
+    });
+}
+function buildModuleGraph(root, program) {
+    const resolved = new Map();
+    const unresolved = [];
+    for (const source of program.getSourceFiles()) {
+        if (!isInside(root, source.fileName) || source.isDeclarationFile) {
+            continue;
+        }
+        for (const specifier of collectModuleSpecifiers(source)) {
+            const target = resolveModule(program, source.fileName, specifier);
+            if (target) {
+                const targets = resolved.get(source.fileName) ?? new Set();
+                targets.add(path.resolve(target));
+                resolved.set(source.fileName, targets);
+            }
+            else if (specifier.startsWith(".") || specifier.startsWith("@")) {
+                unresolved.push({ file: source.fileName, specifier });
+            }
+        }
+    }
+    return { resolved, unresolved };
+}
+function reverseClosure(graph, seed) {
+    const result = new Set([path.resolve(seed)]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [from, targets] of graph) {
+            if (![...targets].some((target) => result.has(path.resolve(target))) || result.has(path.resolve(from))) {
+                continue;
+            }
+            result.add(path.resolve(from));
+            changed = true;
+        }
+    }
+    return result;
+}
+function collectAddedDiagnostics(root, sourceFile, afterText, owners, provider, leases, consumers, onOverlayBuilt) {
+    const added = [];
+    for (const owner of owners) {
+        const relevant = new Set([sourceFile, ...(consumers.find((item) => item.owner === repoPath(root, owner.identity.lexicalPath))?.files ?? [])]);
+        const baseline = leases.get(owner.identity.key).lease.program;
+        const overlay = provider.acquireProgram({
+            focusFile: sourceFile,
+            ownerConfig: owner.identity.lexicalPath,
+            overlays: [{ file: sourceFile, text: afterText }]
+        });
+        onOverlayBuilt();
+        try {
+            const before = diagnosticKeys(root, baseline, relevant);
+            for (const diagnostic of diagnosticsForFiles(root, overlay.program, relevant)) {
+                const key = diagnosticKey(root, diagnostic);
+                if (!before.has(key)) {
+                    added.push({
+                        owner: repoPath(root, owner.identity.lexicalPath),
+                        file: diagnostic.file ? repoPath(root, diagnostic.file.fileName) : sourceFile,
+                        code: diagnostic.code,
+                        message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, " ")
+                    });
+                }
+            }
+        }
+        finally {
+            overlay.release();
+        }
+    }
+    return added.sort((left, right) => left.owner.localeCompare(right.owner) || left.file.localeCompare(right.file) || left.code - right.code);
+}
+function diagnosticsForFiles(root, program, files) {
+    return [...files].flatMap((file) => {
+        const source = program.getSourceFile(path.resolve(root, file));
+        return source ? [...program.getSyntacticDiagnostics(source), ...program.getSemanticDiagnostics(source)] : [];
+    });
+}
+function diagnosticKeys(root, program, files) {
+    return new Set(diagnosticsForFiles(root, program, files).map((item) => diagnosticKey(root, item)));
+}
+function diagnosticKey(root, diagnostic) {
+    return [
+        diagnostic.file ? repoPath(root, diagnostic.file.fileName) : "",
+        diagnostic.start ?? -1,
+        diagnostic.length ?? -1,
+        diagnostic.code,
+        typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, " ")
+    ].join(":");
+}
+function collectStarSpecifiers(source) {
+    return source.statements.flatMap((statement) => typescript_1.default.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier && typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)
+        ? [statement.moduleSpecifier.text]
+        : []);
+}
+function collectModuleSpecifiers(source) {
+    const result = [];
+    const visit = (node) => {
+        if ((typescript_1.default.isImportDeclaration(node) || typescript_1.default.isExportDeclaration(node)) && node.moduleSpecifier && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            result.push(node.moduleSpecifier.text);
+        }
+        else if (typescript_1.default.isImportEqualsDeclaration(node) && typescript_1.default.isExternalModuleReference(node.moduleReference) && node.moduleReference.expression && typescript_1.default.isStringLiteralLike(node.moduleReference.expression)) {
+            result.push(node.moduleReference.expression.text);
+        }
+        else if (typescript_1.default.isCallExpression(node) && node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword && node.arguments[0] && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            result.push(node.arguments[0].text);
+        }
+        else if (typescript_1.default.isCallExpression(node) && typescript_1.default.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments[0] && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            result.push(node.arguments[0].text);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return unique(result);
+}
+function hasNamespaceImportOf(source, target, program) {
+    if (!source)
+        return false;
+    let found = false;
+    const visit = (node) => {
+        const namespaceImport = typescript_1.default.isImportDeclaration(node) &&
+            Boolean(node.importClause?.namedBindings && typescript_1.default.isNamespaceImport(node.importClause.namedBindings)) &&
+            typescript_1.default.isStringLiteralLike(node.moduleSpecifier)
+            ? node.moduleSpecifier.text
+            : null;
+        const namespaceExport = typescript_1.default.isExportDeclaration(node) && node.exportClause && typescript_1.default.isNamespaceExport(node.exportClause) && node.moduleSpecifier && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)
+            ? node.moduleSpecifier.text
+            : null;
+        const importEquals = typescript_1.default.isImportEqualsDeclaration(node) && typescript_1.default.isExternalModuleReference(node.moduleReference) && node.moduleReference.expression && typescript_1.default.isStringLiteralLike(node.moduleReference.expression)
+            ? node.moduleReference.expression.text
+            : null;
+        const requireCall = typescript_1.default.isCallExpression(node) && typescript_1.default.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments[0] && typescript_1.default.isStringLiteralLike(node.arguments[0])
+            ? node.arguments[0].text
+            : null;
+        const specifier = namespaceImport ?? namespaceExport ?? importEquals ?? requireCall;
+        if (specifier && canonical(resolveModule(program, source.fileName, specifier)) === canonical(target))
+            found = true;
+        if (!found)
+            typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function hasDynamicImportOf(source, target, program) {
+    if (!source)
+        return false;
+    let found = false;
+    const visit = (node) => {
+        if (typescript_1.default.isCallExpression(node) && node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword && node.arguments[0] && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            found ||= canonical(resolveModule(program, source.fileName, node.arguments[0].text)) === canonical(target);
+        }
+        if (!found)
+            typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function resolveModule(program, fromFile, specifier) {
+    return typescript_1.default.resolveModuleName(specifier, fromFile, program.getCompilerOptions(), typescript_1.default.sys).resolvedModule?.resolvedFileName ?? null;
+}
+function symbolIdentity(root, checker, symbol) {
+    const target = (symbol.flags & typescript_1.default.SymbolFlags.Alias) !== 0 ? safeAliasedSymbol(checker, symbol) : symbol;
+    const declaration = target.valueDeclaration ?? target.declarations?.[0];
+    if (!declaration)
+        return null;
+    const declarationFile = repoPath(root, declaration.getSourceFile().fileName);
+    const declarationStart = declaration.getStart(declaration.getSourceFile());
+    const declarationEnd = declaration.end;
+    return {
+        key: `${canonical(declarationFile)}:${declarationStart}:${declarationEnd}:${target.flags}`,
+        name: target.getName(),
+        declarationFile,
+        declarationStart,
+        declarationEnd,
+        flags: target.flags
+    };
+}
+function safeAliasedSymbol(checker, symbol) {
+    try {
+        return checker.getAliasedSymbol(symbol);
+    }
+    catch {
+        return symbol;
+    }
+}
+function isCommonJsSource(source, options) {
+    if (source.fileName.toLowerCase().endsWith(".cts"))
+        return true;
+    if (source.fileName.toLowerCase().endsWith(".mts"))
+        return false;
+    if (options.module === typescript_1.default.ModuleKind.CommonJS)
+        return true;
+    return source.impliedNodeFormat === typescript_1.default.ModuleKind.CommonJS;
+}
+function isPackageExportedBarrel(root, sourceFile, index) {
+    const pkg = index.packageForFile(sourceFile);
+    if (!pkg?.exports)
+        return false;
+    const relative = `./${path.relative(pkg.identity.lexicalPath, path.resolve(root, sourceFile)).replace(/\\/g, "/")}`;
+    const emitted = relative.replace(/\.(?:tsx?|mts|cts)$/i, (suffix) => suffix === ".mts" ? ".mjs" : suffix === ".cts" ? ".cjs" : ".js");
+    return collectJsonStrings(pkg.exports).some((value) => value === relative || value === emitted || value.endsWith(`/${path.basename(emitted)}`));
+}
+function collectJsonStrings(value) {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(collectJsonStrings);
+    if (value && typeof value === "object")
+        return Object.values(value).flatMap(collectJsonStrings);
+    return [];
+}
+function isExposedRuntime(binding) {
+    return binding.exposed && !binding.shadowed && !binding.collision && !binding.isDefault && binding.exposure === "runtime";
+}
+function isExposedTypeOnly(binding) {
+    return binding.exposed && !binding.shadowed && !binding.collision && !binding.isDefault && binding.exposure === "typeOnly";
+}
+function renderExportName(name) {
+    return /^[$A-Z_a-z][$\w]*$/u.test(name) ? name : JSON.stringify(name);
+}
+function retainedReason(sourceFile, selector, code, reason) {
+    return { sourceFile, selector, code, reason };
+}
+function dedupeRetained(items) {
+    const map = new Map();
+    for (const item of items)
+        map.set(stableStringify(item), item);
+    return [...map.values()].sort((left, right) => left.selector.localeCompare(right.selector) || left.code.localeCompare(right.code));
+}
+function repoPath(root, file) {
+    const relative = path.relative(root, path.resolve(file));
+    return relative && !relative.startsWith("..") && !path.isAbsolute(relative)
+        ? relative.replace(/\\/g, "/")
+        : path.resolve(file).replace(/\\/g, "/");
+}
+function isInside(root, file) {
+    const relative = path.relative(root, path.resolve(file));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function canonical(file) {
+    return file ? path.resolve(file).replace(/\\/g, "/").toLowerCase() : "";
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+}
+function roundMs(value) {
+    return Math.round(value * 100) / 100;
+}