@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/mutation/file-mutation-discovery.js

@@ -0,0 +1,674 @@
+"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.discoverFileMutationConsumers = discoverFileMutationConsumers;
+exports.discoverFileMutationConsumersWithProjectIndex = discoverFileMutationConsumersWithProjectIndex;
+exports.discoverFileMutationConsumersWithProjectIndexLease = discoverFileMutationConsumersWithProjectIndexLease;
+exports.computeFileMutationWorkspaceFingerprint = computeFileMutationWorkspaceFingerprint;
+exports.computeFileMutationWorkspaceFingerprintWithProjectIndex = computeFileMutationWorkspaceFingerprintWithProjectIndex;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const typescript_1 = __importDefault(require("typescript"));
+const workspace_project_index_1 = require("../topology/workspace-project-index");
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+function discoverFileMutationConsumers(input) {
+    const startedAt = node_perf_hooks_1.performance.now();
+    const root = path.resolve(input.workspaceRoot);
+    const projectIndexStartedAt = node_perf_hooks_1.performance.now();
+    const projectIndex = new workspace_project_index_1.WorkspaceProjectIndex(root);
+    try {
+        const indexSnapshot = projectIndex.snapshot;
+        const projectIndexMs = node_perf_hooks_1.performance.now() - projectIndexStartedAt;
+        return discoverWithProjectIndex(projectIndex, root, input.sourceFiles, {
+            maxFiles: input.maxFiles ?? Number.POSITIVE_INFINITY,
+            maxFileBytes: input.maxFileBytes ?? 16 * 1024 * 1024,
+            startedAt,
+            projectIndexMs,
+            indexTimings: indexSnapshot.timings
+        });
+    }
+    finally {
+        projectIndex.dispose();
+    }
+}
+function discoverFileMutationConsumersWithProjectIndex(projectIndex, input) {
+    const startedAt = node_perf_hooks_1.performance.now();
+    const root = path.resolve(input.workspaceRoot);
+    const projectIndexStartedAt = node_perf_hooks_1.performance.now();
+    const indexSnapshot = projectIndex.snapshot;
+    const projectIndexMs = node_perf_hooks_1.performance.now() - projectIndexStartedAt;
+    if (projectIndex.identityForFile(root).key !== indexSnapshot.root.key) {
+        throw new Error("Workspace project index root does not match file mutation discovery root.");
+    }
+    return discoverWithProjectIndex(projectIndex, root, input.sourceFiles, {
+        maxFiles: input.maxFiles ?? Number.POSITIVE_INFINITY,
+        maxFileBytes: input.maxFileBytes ?? 16 * 1024 * 1024,
+        startedAt,
+        projectIndexMs,
+        indexTimings: indexSnapshot.timings
+    });
+}
+function discoverFileMutationConsumersWithProjectIndexLease(lease, input) {
+    const startedAt = node_perf_hooks_1.performance.now();
+    const result = lease.withWorkspaceProjectIndex((index) => discoverFileMutationConsumersWithProjectIndex(index, input));
+    const durationMs = node_perf_hooks_1.performance.now() - startedAt;
+    const leaseMs = Math.max(0, durationMs - result.durationMs);
+    return {
+        ...result,
+        durationMs,
+        timings: {
+            ...result.timings,
+            projectIndexMs: result.timings.projectIndexMs + leaseMs,
+            totalMs: durationMs
+        }
+    };
+}
+function computeFileMutationWorkspaceFingerprint(workspaceRoot) {
+    const projectIndex = new workspace_project_index_1.WorkspaceProjectIndex(path.resolve(workspaceRoot));
+    try {
+        return computeWorkspaceFingerprint(projectIndex);
+    }
+    finally {
+        projectIndex.dispose();
+    }
+}
+function computeFileMutationWorkspaceFingerprintWithProjectIndex(projectIndex, workspaceRoot) {
+    const root = path.resolve(workspaceRoot);
+    if (projectIndex.identityForFile(root).key !== projectIndex.snapshot.root.key) {
+        throw new Error("Workspace project index root does not match file mutation fingerprint root.");
+    }
+    return computeWorkspaceFingerprint(projectIndex);
+}
+function discoverWithProjectIndex(projectIndex, root, rawSourceFiles, limits) {
+    const fingerprintStartedAt = node_perf_hooks_1.performance.now();
+    const workspaceFingerprint = computeWorkspaceFingerprint(projectIndex);
+    const workspaceFingerprintMs = node_perf_hooks_1.performance.now() - fingerprintStartedAt;
+    const packageManifests = projectIndex.snapshot.packages;
+    const sourceIdentities = uniqueIdentities(rawSourceFiles.map((file) => projectIndex.identityForFile(path.resolve(root, file))));
+    const allOwnedFiles = projectIndex.ownedFiles().filter((identity) => isSourceFile(identity.lexicalPath));
+    const ownedFilesByKey = new Map(allOwnedFiles.map((identity) => [identity.key, identity]));
+    const truncated = allOwnedFiles.length > limits.maxFiles;
+    const filesToScan = allOwnedFiles.slice(0, limits.maxFiles);
+    const uncertainties = [];
+    const rawEdges = [];
+    const semanticEnvironmentIdentities = [];
+    let bytesScanned = 0;
+    let sourceReadMs = 0;
+    let edgeCollectionMs = 0;
+    for (const identity of filesToScan) {
+        const sourceReadStartedAt = node_perf_hooks_1.performance.now();
+        const text = readSource(identity.lexicalPath, limits.maxFileBytes);
+        sourceReadMs += node_perf_hooks_1.performance.now() - sourceReadStartedAt;
+        if (typeof text !== "string") {
+            uncertainties.push({
+                file: identity.lexicalPath,
+                moduleSpecifier: "",
+                kind: "unreadable-source",
+                details: [text.reason]
+            });
+            continue;
+        }
+        bytesScanned += Buffer.byteLength(text);
+        const edgeCollectionStartedAt = node_perf_hooks_1.performance.now();
+        const collected = collectModuleEdges(identity.lexicalPath, text);
+        rawEdges.push(...collected.edges);
+        if (!collected.externalModule)
+            semanticEnvironmentIdentities.push(identity);
+        edgeCollectionMs += node_perf_hooks_1.performance.now() - edgeCollectionStartedAt;
+    }
+    const ownerCache = new Map();
+    const configCache = new Map();
+    const moduleResolutionStartedAt = node_perf_hooks_1.performance.now();
+    const resolvedEdges = rawEdges.map((edge) => resolveEdge(projectIndex, edge, ownerCache, configCache));
+    const moduleResolutionMs = node_perf_hooks_1.performance.now() - moduleResolutionStartedAt;
+    const sourceKeys = new Set(sourceIdentities.map((identity) => identity.key));
+    const closureKeys = new Set(sourceKeys);
+    const consumerByKey = new Map();
+    const directConsumerKeys = new Set();
+    const acceptedEdges = new Map();
+    const relevantUncertaintyKeys = new Set();
+    const packageNames = new Map();
+    for (const source of sourceIdentities) {
+        packageNames.set(source.key, projectIndex.packageForFile(source.lexicalPath)?.name ?? null);
+    }
+    const reverseClosureStartedAt = node_perf_hooks_1.performance.now();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const edge of resolvedEdges) {
+            const matchedTargets = edge.targetIdentities.filter((target) => closureKeys.has(target.key));
+            if (matchedTargets.length === 0) {
+                if (edge.targetIdentities.length === 0 && unresolvedCouldReachClosure(edge, closureKeys, ownedFilesByKey, packageNames)) {
+                    addRelevantUncertainty(edge, "unresolved");
+                }
+                continue;
+            }
+            const fromIdentity = projectIndex.identityForFile(edge.fromFile);
+            const incompleteOwnerResolutions = edge.ownerResolutions.filter((outcome) => outcome.status !== "resolved" && outcome.status !== "missing-generated-projection");
+            if (incompleteOwnerResolutions.length > 0) {
+                addRelevantUncertainty(edge, "owner-resolution-incomplete", incompleteOwnerResolutions.map((outcome) => `${outcome.configFile}:${outcome.status}`));
+            }
+            const projectionTargets = conditionalProjectionTargets(projectIndex, edge, closureKeys);
+            const conditionalProjection = projectionTargets.length > 1;
+            if (allProjectionTargetFiles(edge).length > 1 && !conditionalProjection) {
+                addRelevantUncertainty(edge, "owner-resolution-divergence", allProjectionTargetFiles(edge));
+            }
+            if (matchedTargets.some((target) => sourceKeys.has(target.key)) && !sourceKeys.has(fromIdentity.key)) {
+                directConsumerKeys.add(fromIdentity.key);
+            }
+            if (!consumerByKey.has(fromIdentity.key) && !sourceKeys.has(fromIdentity.key)) {
+                consumerByKey.set(fromIdentity.key, fromIdentity);
+            }
+            if (edge.propagates && !closureKeys.has(fromIdentity.key)) {
+                closureKeys.add(fromIdentity.key);
+                packageNames.set(fromIdentity.key, projectIndex.packageForFile(fromIdentity.lexicalPath)?.name ?? null);
+                changed = true;
+            }
+            const target = matchedTargets[0];
+            const key = `${fromIdentity.key}\0${target.key}\0${edge.kind}\0${edge.line}\0${edge.moduleSpecifier}`;
+            acceptedEdges.set(key, {
+                fromFile: fromIdentity.lexicalPath,
+                targetFile: target.lexicalPath,
+                moduleSpecifier: edge.moduleSpecifier,
+                kind: edge.kind,
+                line: edge.line,
+                specifierStart: edge.specifierStart,
+                specifierLength: edge.specifierLength,
+                propagates: edge.propagates,
+                ownerConfigs: edge.ownerConfigs,
+                ownerResolutions: edge.ownerResolutions.map(({ targetIdentity: _targetIdentity, ...outcome }) => outcome),
+                ...(conditionalProjection ? {
+                    alternateTargetFiles: projectionTargets
+                        .filter((file) => canonical(file) !== canonical(target.lexicalPath))
+                } : {})
+            });
+        }
+    }
+    const reverseClosureMs = node_perf_hooks_1.performance.now() - reverseClosureStartedAt;
+    const ownerCollectionStartedAt = node_perf_hooks_1.performance.now();
+    const relevantFiles = uniqueIdentities([...sourceIdentities, ...consumerByKey.values()]);
+    const ownerConfigs = new Set();
+    const fileOwners = [];
+    for (const identity of relevantFiles) {
+        const owners = readOwners(projectIndex, identity.lexicalPath, ownerCache);
+        if (owners.length === 0) {
+            uncertainties.push({
+                file: identity.lexicalPath,
+                moduleSpecifier: "",
+                kind: "missing-owner"
+            });
+            fileOwners.push({ file: identity.lexicalPath, ownerConfigs: [] });
+            continue;
+        }
+        owners.forEach((owner) => ownerConfigs.add(owner.identity.lexicalPath));
+        fileOwners.push({
+            file: identity.lexicalPath,
+            ownerConfigs: owners.map((owner) => owner.identity.lexicalPath).sort()
+        });
+    }
+    const relevantOwnerKeys = new Set([...ownerConfigs].map((config) => canonical(config)));
+    const semanticEnvironmentFiles = semanticEnvironmentIdentities.flatMap((identity) => {
+        const matchingOwners = readOwners(projectIndex, identity.lexicalPath, ownerCache)
+            .map((owner) => owner.identity.lexicalPath)
+            .filter((config) => relevantOwnerKeys.has(canonical(config)))
+            .sort();
+        return matchingOwners.length > 0 ? [{ file: identity.lexicalPath, ownerConfigs: matchingOwners }] : [];
+    });
+    const ownerCollectionMs = node_perf_hooks_1.performance.now() - ownerCollectionStartedAt;
+    const relevantUncertainties = uncertainties.filter((item) => item.kind === "missing-owner" ||
+        item.kind === "unreadable-source" ||
+        relevantUncertaintyKeys.has(uncertaintyKey(item.file, item.line ?? 0, item.kind, item.moduleSpecifier)));
+    const totalMs = node_perf_hooks_1.performance.now() - limits.startedAt;
+    return {
+        sourceFiles: sourceIdentities.map((identity) => identity.lexicalPath).sort(),
+        consumerFiles: [...consumerByKey.values()].map((identity) => identity.lexicalPath).sort(),
+        directConsumerFiles: [...consumerByKey.entries()]
+            .filter(([key]) => directConsumerKeys.has(key))
+            .map(([, identity]) => identity.lexicalPath)
+            .sort(),
+        ownerConfigs: [...ownerConfigs].sort(),
+        fileOwners: fileOwners.sort((left, right) => left.file.localeCompare(right.file)),
+        semanticEnvironmentFiles: semanticEnvironmentFiles.sort((left, right) => left.file.localeCompare(right.file)),
+        packageManifests,
+        edges: [...acceptedEdges.values()].sort(compareEdges),
+        uncertainties: relevantUncertainties.sort(compareUncertainties),
+        complete: !truncated && relevantUncertainties.length === 0,
+        truncated,
+        filesScanned: filesToScan.length,
+        bytesScanned,
+        edgeCount: rawEdges.length,
+        statesVisited: closureKeys.size,
+        programBuildCount: 0,
+        workspaceFingerprint,
+        timings: {
+            projectIndexMs: limits.projectIndexMs,
+            topologyScopeMs: limits.indexTimings.topologyScopeMs,
+            tsconfigDiscoveryMs: limits.indexTimings.topologyTsconfigDiscoveryMs,
+            topologyTsconfigMs: limits.indexTimings.topologyTsconfigMs,
+            topologyPackageMs: limits.indexTimings.topologyPackageMs,
+            topologyDependencyMs: limits.indexTimings.topologyDependencyMs,
+            topologyTotalMs: limits.indexTimings.topologyTotalMs,
+            exactOwnershipMs: limits.indexTimings.exactOwnershipMs,
+            packageIndexMs: limits.indexTimings.packageIndexMs,
+            workspaceFingerprintMs,
+            sourceReadMs,
+            edgeCollectionMs,
+            moduleResolutionMs,
+            reverseClosureMs,
+            ownerCollectionMs,
+            totalMs
+        },
+        durationMs: totalMs
+    };
+    function addRelevantUncertainty(edge, kind, details) {
+        const key = uncertaintyKey(edge.fromFile, edge.line, kind, edge.moduleSpecifier);
+        if (relevantUncertaintyKeys.has(key)) {
+            return;
+        }
+        relevantUncertaintyKeys.add(key);
+        uncertainties.push({
+            file: edge.fromFile,
+            moduleSpecifier: edge.moduleSpecifier,
+            kind,
+            line: edge.line,
+            ...(details ? { details } : {})
+        });
+    }
+}
+function computeWorkspaceFingerprint(projectIndex) {
+    const snapshot = projectIndex.snapshot;
+    const entries = [
+        ...projectIndex.ownedFiles().map((identity) => ({ kind: "owned", file: identity.lexicalPath })),
+        ...snapshot.configs.map((config) => ({ kind: "config", file: config.identity.lexicalPath })),
+        ...snapshot.packages.map((pkg) => ({ kind: "package", file: pkg.packageJson.lexicalPath }))
+    ].sort((left, right) => {
+        const fileOrder = canonical(left.file).localeCompare(canonical(right.file));
+        return fileOrder === 0 ? left.kind.localeCompare(right.kind) : fileOrder;
+    });
+    const hash = crypto.createHash("sha256");
+    hash.update("file-mutation-workspace-v1\0");
+    for (const entry of entries) {
+        hash.update(entry.kind).update("\0").update(path.normalize(entry.file)).update("\0");
+        try {
+            const bytes = fs.readFileSync(entry.file);
+            hash.update(String(bytes.length)).update("\0").update(bytes).update("\0");
+        }
+        catch (error) {
+            hash.update("unreadable\0").update(error instanceof Error ? error.name : "unknown").update("\0");
+        }
+    }
+    return hash.digest("hex");
+}
+function collectModuleEdges(file, text) {
+    const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true, scriptKind(file));
+    const edges = [];
+    const add = (node, specifier, kind, propagates = false) => {
+        const literalStart = node.getStart(source);
+        const literalWidth = node.getWidth(source);
+        edges.push({
+            fromFile: file,
+            moduleSpecifier: specifier,
+            kind,
+            line: source.getLineAndCharacterOfPosition(literalStart).line + 1,
+            specifierStart: literalStart + 1,
+            specifierLength: Math.max(0, literalWidth - 2),
+            propagates
+        });
+    };
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node) && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            const bindings = node.importClause?.namedBindings;
+            add(node.moduleSpecifier, node.moduleSpecifier.text, bindings && typescript_1.default.isNamespaceImport(bindings) ? "namespace" : "import");
+        }
+        else if (typescript_1.default.isExportDeclaration(node) && node.moduleSpecifier && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            const kind = !node.exportClause
+                ? "exportStar"
+                : typescript_1.default.isNamespaceExport(node.exportClause)
+                    ? "namespace"
+                    : "reexport";
+            add(node.moduleSpecifier, node.moduleSpecifier.text, kind, true);
+        }
+        else if (typescript_1.default.isImportEqualsDeclaration(node) && typescript_1.default.isExternalModuleReference(node.moduleReference)) {
+            const expression = node.moduleReference.expression;
+            if (expression && typescript_1.default.isStringLiteralLike(expression)) {
+                add(expression, expression.text, "importEquals");
+            }
+        }
+        else if (typescript_1.default.isCallExpression(node) && node.arguments.length === 1 && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            if (node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword) {
+                add(node.arguments[0], node.arguments[0].text, "dynamic");
+            }
+            else if (typescript_1.default.isIdentifier(node.expression) && node.expression.text === "require") {
+                add(node.arguments[0], node.arguments[0].text, "require");
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return { edges, externalModule: typescript_1.default.isExternalModule(source) };
+}
+function resolveEdge(projectIndex, edge, ownerCache, configCache) {
+    const owners = readOwners(projectIndex, edge.fromFile, ownerCache);
+    const targets = new Map();
+    const ownerResolutions = [];
+    for (const owner of owners) {
+        const context = readConfigContext(owner, configCache);
+        if (!context) {
+            ownerResolutions.push({
+                configFile: owner.identity.lexicalPath,
+                status: "config-parse-failed"
+            });
+            continue;
+        }
+        const resolved = typescript_1.default.resolveModuleName(edge.moduleSpecifier, edge.fromFile, context.parsed.parsed.options, typescript_1.default.sys, context.cache).resolvedModule?.resolvedFileName;
+        if (!resolved) {
+            const missingProjection = resolveMissingGeneratedProjection(projectIndex, edge, context);
+            if (missingProjection) {
+                ownerResolutions.push({
+                    configFile: owner.identity.lexicalPath,
+                    status: "missing-generated-projection",
+                    targetFile: missingProjection
+                });
+                continue;
+            }
+            ownerResolutions.push({
+                configFile: owner.identity.lexicalPath,
+                status: "unresolved"
+            });
+            continue;
+        }
+        try {
+            const identity = projectIndex.identityForFile(realPath(resolved));
+            targets.set(identity.key, identity);
+            ownerResolutions.push({
+                configFile: owner.identity.lexicalPath,
+                status: "resolved",
+                targetFile: identity.lexicalPath,
+                targetIdentity: identity
+            });
+        }
+        catch {
+            ownerResolutions.push({
+                configFile: owner.identity.lexicalPath,
+                status: "unresolved"
+            });
+        }
+    }
+    return {
+        ...edge,
+        targetIdentities: [...targets.values()].sort((left, right) => left.lexicalPath.localeCompare(right.lexicalPath)),
+        ownerConfigs: owners.map((owner) => owner.identity.lexicalPath).sort(),
+        ownerResolutions: ownerResolutions.sort((left, right) => left.configFile.localeCompare(right.configFile))
+    };
+}
+function resolveMissingGeneratedProjection(projectIndex, edge, context) {
+    if (edge.moduleSpecifier.startsWith(".") || edge.moduleSpecifier.startsWith("#"))
+        return null;
+    const pkg = projectIndex.snapshot.packages
+        .filter((candidate) => candidate.name && (edge.moduleSpecifier === candidate.name || edge.moduleSpecifier.startsWith(`${candidate.name}/`)))
+        .sort((left, right) => (right.name?.length ?? 0) - (left.name?.length ?? 0))[0];
+    if (!pkg)
+        return null;
+    const candidates = resolvePackageExportTargets(pkg, edge.moduleSpecifier)
+        .filter((file) => isDeclarationProjection(file) && !typescript_1.default.sys.fileExists(file));
+    for (const candidate of candidates) {
+        const resolved = typescript_1.default.resolveModuleName(edge.moduleSpecifier, edge.fromFile, context.parsed.parsed.options, virtualProjectionHost(candidate)).resolvedModule?.resolvedFileName;
+        if (resolved && canonical(resolved) === canonical(candidate))
+            return path.normalize(candidate);
+    }
+    return null;
+}
+function virtualProjectionHost(candidate) {
+    const target = path.resolve(candidate);
+    return {
+        fileExists: (file) => canonical(file) === canonical(target) || typescript_1.default.sys.fileExists(file),
+        readFile: typescript_1.default.sys.readFile,
+        directoryExists: (dir) => isInsideOrSame(path.resolve(dir), target) || Boolean(typescript_1.default.sys.directoryExists?.(dir)),
+        getDirectories: typescript_1.default.sys.getDirectories,
+        realpath: (file) => canonical(file) === canonical(target) ? target : typescript_1.default.sys.realpath?.(file) ?? file,
+        useCaseSensitiveFileNames: typescript_1.default.sys.useCaseSensitiveFileNames
+    };
+}
+function isDeclarationProjection(file) {
+    return /\.d\.(?:ts|mts|cts)$/i.test(file);
+}
+function isInsideOrSame(parent, file) {
+    const relative = path.relative(parent, file);
+    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function readOwners(projectIndex, file, cache) {
+    const key = canonical(file);
+    const cached = cache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const owners = projectIndex.exactOwnersForFile(file).filter((owner) => owner.configRole === "project");
+    cache.set(key, owners);
+    return owners;
+}
+function readConfigContext(owner, cache) {
+    if (cache.has(owner.identity.key)) {
+        return cache.get(owner.identity.key) ?? null;
+    }
+    const diagnostics = [];
+    const parsed = (0, tsconfig_loader_1.parseTsConfig)(owner.identity.lexicalPath, diagnostics);
+    const context = parsed
+        ? {
+            parsed,
+            cache: typescript_1.default.createModuleResolutionCache(path.dirname(owner.identity.lexicalPath), canonical, parsed.parsed.options)
+        }
+        : null;
+    cache.set(owner.identity.key, context);
+    return context;
+}
+function unresolvedCouldReachClosure(edge, closureKeys, ownedFilesByKey, packageNames) {
+    if (edge.moduleSpecifier.startsWith(".")) {
+        const candidate = path.resolve(path.dirname(edge.fromFile), edge.moduleSpecifier);
+        for (const key of closureKeys) {
+            const identity = ownedFilesByKey.get(key);
+            if (identity && sameModuleBase(candidate, identity.lexicalPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    for (const key of closureKeys) {
+        const packageName = packageNames.get(key);
+        if (packageName && edge.moduleSpecifier === packageName) {
+            return true;
+        }
+    }
+    return false;
+}
+function conditionalProjectionTargets(projectIndex, edge, closureKeys) {
+    if (edge.moduleSpecifier.startsWith(".") || edge.moduleSpecifier.startsWith("#")) {
+        return [];
+    }
+    const packages = edge.targetIdentities.map((target) => projectIndex.packageForFile(target.lexicalPath));
+    const first = packages[0];
+    if (!first?.name || packages.some((pkg) => !pkg || pkg.identity.key !== first.identity.key)) {
+        return [];
+    }
+    if (edge.moduleSpecifier !== first.name && !edge.moduleSpecifier.startsWith(`${first.name}/`)) {
+        return [];
+    }
+    const closureTargets = edge.targetIdentities.filter((target) => closureKeys.has(target.key));
+    if (closureTargets.length !== 1) {
+        return [];
+    }
+    const exportTargets = resolvePackageExportTargets(first, edge.moduleSpecifier);
+    // The one closure target is the exact TS source projection proven by an owner resolution.
+    // Every other owner target must be an explicit package export leaf for the same subpath.
+    const targets = allProjectionTargetFiles(edge);
+    return exportTargets.length > 0 && targets.length > 1 && targets.every((target) => canonical(target) === canonical(closureTargets[0].lexicalPath) ||
+        exportTargets.some((candidate) => canonical(candidate) === canonical(target))) ? targets : [];
+}
+function allProjectionTargetFiles(edge) {
+    const files = [
+        ...edge.targetIdentities.map((target) => target.lexicalPath),
+        ...edge.ownerResolutions.flatMap((resolution) => resolution.status === "missing-generated-projection" && resolution.targetFile ? [resolution.targetFile] : [])
+    ];
+    return files.filter((file, index) => files.findIndex((candidate) => canonical(candidate) === canonical(file)) === index);
+}
+function resolvePackageExportTargets(pkg, moduleSpecifier) {
+    if (!pkg.name || pkg.exports === undefined) {
+        return [];
+    }
+    const subpath = moduleSpecifier === pkg.name ? "." : `.${moduleSpecifier.slice(pkg.name.length)}`;
+    const selected = selectPackageExport(pkg.exports, subpath);
+    if (!selected) {
+        return [];
+    }
+    return collectExportLeaves(selected.value)
+        .map((leaf) => leaf.replace(/\*/g, selected.wildcard ?? ""))
+        .filter((leaf) => leaf.startsWith("./"))
+        .map((leaf) => path.resolve(pkg.identity.lexicalPath, leaf));
+}
+function selectPackageExport(exportsValue, subpath) {
+    if (!isJsonObject(exportsValue)) {
+        return subpath === "." ? { value: exportsValue } : null;
+    }
+    const entries = Object.entries(exportsValue);
+    const subpathEntries = entries.filter(([key]) => key === "." || key.startsWith("./"));
+    if (subpathEntries.length === 0) {
+        return subpath === "." ? { value: exportsValue } : null;
+    }
+    if (Object.prototype.hasOwnProperty.call(exportsValue, subpath)) {
+        return { value: exportsValue[subpath] };
+    }
+    const wildcardMatches = [];
+    for (const [key, value] of subpathEntries) {
+        const star = key.indexOf("*");
+        if (star < 0) {
+            continue;
+        }
+        const prefix = key.slice(0, star);
+        const suffix = key.slice(star + 1);
+        if (subpath.startsWith(prefix) && subpath.endsWith(suffix)) {
+            wildcardMatches.push({ key, value, prefix, suffix });
+        }
+    }
+    wildcardMatches.sort((left, right) => right.prefix.length - left.prefix.length ||
+        right.key.length - left.key.length ||
+        left.key.localeCompare(right.key));
+    const selected = wildcardMatches[0];
+    return selected
+        ? {
+            value: selected.value,
+            wildcard: subpath.slice(selected.prefix.length, subpath.length - selected.suffix.length)
+        }
+        : null;
+}
+function collectExportLeaves(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(collectExportLeaves);
+    }
+    return isJsonObject(value) ? Object.values(value).flatMap(collectExportLeaves) : [];
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readSource(file, maxBytes) {
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile()) {
+            return { reason: "not-a-file" };
+        }
+        if (stat.size > maxBytes) {
+            return { reason: `file-exceeds-${maxBytes}-bytes` };
+        }
+        return fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        return { reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+function sameModuleBase(candidate, target) {
+    const candidateBase = stripKnownExtension(path.resolve(candidate));
+    const targetBase = stripKnownExtension(path.resolve(target));
+    return canonical(candidateBase) === canonical(targetBase) ||
+        canonical(path.join(candidateBase, "index")) === canonical(targetBase);
+}
+function stripKnownExtension(file) {
+    return file.replace(/(?:\.d)?\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs|json)$/i, "");
+}
+function isSourceFile(file) {
+    return SOURCE_EXTENSIONS.has(path.extname(file).toLowerCase());
+}
+function scriptKind(file) {
+    switch (path.extname(file).toLowerCase()) {
+        case ".tsx": return typescript_1.default.ScriptKind.TSX;
+        case ".jsx": return typescript_1.default.ScriptKind.JSX;
+        case ".js":
+        case ".mjs":
+        case ".cjs": return typescript_1.default.ScriptKind.JS;
+        default: return typescript_1.default.ScriptKind.TS;
+    }
+}
+function realPath(file) {
+    return typeof typescript_1.default.sys.realpath === "function" ? typescript_1.default.sys.realpath(file) : path.normalize(file);
+}
+function uniqueIdentities(identities) {
+    return [...new Map(identities.map((identity) => [identity.key, identity])).values()]
+        .sort((left, right) => left.lexicalPath.localeCompare(right.lexicalPath));
+}
+function canonical(file) {
+    const normalized = path.normalize(file);
+    return typescript_1.default.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function uncertaintyKey(file, line, kind, specifier) {
+    return `${canonical(file)}\0${line}\0${kind}\0${specifier}`;
+}
+function compareEdges(left, right) {
+    return left.fromFile.localeCompare(right.fromFile) ||
+        left.line - right.line ||
+        left.kind.localeCompare(right.kind) ||
+        left.moduleSpecifier.localeCompare(right.moduleSpecifier);
+}
+function compareUncertainties(left, right) {
+    return left.file.localeCompare(right.file) ||
+        (left.line ?? 0) - (right.line ?? 0) ||
+        left.kind.localeCompare(right.kind) ||
+        left.moduleSpecifier.localeCompare(right.moduleSpecifier);
+}