@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/mutation/semantic-workspace.js

@@ -0,0 +1,804 @@
+"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.createSemanticWorkspace = createSemanticWorkspace;
+exports.resolveSemanticModule = resolveSemanticModule;
+exports.resolveExportedSemanticSymbol = resolveExportedSemanticSymbol;
+exports.resolveSemanticNodeIdentity = resolveSemanticNodeIdentity;
+exports.resolveSemanticSymbolIdentity = resolveSemanticSymbolIdentity;
+exports.ownersForSemanticFile = ownersForSemanticFile;
+exports.findSemanticReferences = findSemanticReferences;
+exports.collectSemanticModuleEdges = collectSemanticModuleEdges;
+exports.scopeRelevantSemanticModuleEdges = scopeRelevantSemanticModuleEdges;
+exports.classifySemanticUsage = classifySemanticUsage;
+exports.canonicalPathIdentity = canonicalPathIdentity;
+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 tsconfig_discovery_1 = require("../config/tsconfig-discovery");
+const core_1 = require("../topology/core");
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+function createSemanticWorkspace(input) {
+    const root = path.resolve(input.workspaceRoot);
+    const focusFiles = uniqueSorted(input.focusFiles.map((file) => path.resolve(root, file)));
+    const discovery = (0, tsconfig_discovery_1.discoverTsconfigFiles)(root);
+    const parseFailures = [];
+    const parsedConfigs = discovery.visible
+        .map((file) => parseConfig(file, root, parseFailures))
+        .filter((config) => config !== null);
+    const configByPath = new Map(parsedConfigs.map((config) => [normalizePath(config.file), config]));
+    const referenceGraph = buildReferenceGraph(parsedConfigs, configByPath);
+    const selected = new Set();
+    const unresolvedFiles = [];
+    const incompleteReasons = [...parseFailures];
+    for (const file of focusFiles) {
+        if (!fs.existsSync(file)) {
+            unresolvedFiles.push(file);
+            incompleteReasons.push({ code: "focusFileNotFound", file: toRepoPath(root, file) });
+            continue;
+        }
+        const owners = parsedConfigs.filter((config) => ownsFile(config, file));
+        if (owners.length === 0) {
+            unresolvedFiles.push(file);
+            incompleteReasons.push({ code: "owningProjectNotFound", file: toRepoPath(root, file) });
+            continue;
+        }
+        for (const owner of owners) {
+            selected.add(normalizePath(owner.file));
+        }
+    }
+    expandRelevantProjects(selected, referenceGraph, configByPath);
+    for (const configKey of selected) {
+        for (const unresolved of referenceGraph.unresolved.get(configKey) ?? []) {
+            incompleteReasons.push({
+                code: "projectReferenceUnresolved",
+                tsconfig: toRepoPath(root, configByPath.get(configKey)?.file ?? configKey),
+                reference: toRepoPath(root, unresolved)
+            });
+        }
+    }
+    const selectedConfigs = [...selected]
+        .map((key) => configByPath.get(key))
+        .filter((config) => config !== undefined)
+        .sort((left, right) => left.file.localeCompare(right.file));
+    incompleteReasons.push(...collectAmbiguousOwnershipReasons(root, selectedConfigs));
+    const projects = selectedConfigs.map((config) => createProjectContext(config, collectForwardSourceFiles(normalizePath(config.file), referenceGraph.edges, configByPath)));
+    incompleteReasons.push(...collectUnresolvedModuleReasons(root, projects));
+    for (const file of focusFiles) {
+        const owners = projects.filter((project) => ownsFile(project.config, file));
+        for (const owner of owners) {
+            if (!owner.program.getSourceFile(file)) {
+                unresolvedFiles.push(file);
+                incompleteReasons.push({
+                    code: "sourceFileMissingFromProgram",
+                    file: toRepoPath(root, file),
+                    tsconfig: toRepoPath(root, owner.config.file)
+                });
+            }
+        }
+    }
+    const analyzedSourceFiles = uniqueSorted(projects.flatMap((project) => project.config.parsed.fileNames)
+        .filter((file) => isInside(root, file) && !file.includes(`${path.sep}node_modules${path.sep}`)));
+    const excludedFiles = collectExcludedSourceFiles(discovery.configExcluded, root);
+    const topology = (0, core_1.buildProjectTopologySnapshot)(root);
+    const analyzedPackages = uniquePackages(analyzedSourceFiles.map((file) => (0, core_1.describeTopologyFile)(topology, file)));
+    const inventories = projects.map((project) => {
+        const representative = project.config.parsed.fileNames.find((file) => isInside(root, file));
+        const ownership = representative ? (0, core_1.describeTopologyFile)(topology, representative) : undefined;
+        return {
+            tsconfig: toRepoPath(root, project.config.file),
+            configFingerprint: fileHash(project.config.file),
+            ...(ownership?.packageRoot ? { packageRoot: ownership.packageRoot } : {}),
+            ...(ownership?.packageName ? { packageName: ownership.packageName } : {}),
+            projectReferences: (referenceGraph.edges.get(normalizePath(project.config.file)) ?? [])
+                .map((file) => toRepoPath(root, configByPath.get(file)?.file ?? file))
+                .sort(),
+            sourceFiles: uniqueSorted(project.config.parsed.fileNames
+                .filter((file) => isInside(root, file))
+                .map((file) => toRepoPath(root, file)))
+        };
+    });
+    const coverage = {
+        complete: incompleteReasons.length === 0 && unresolvedFiles.length === 0,
+        analyzedTsconfigs: projects.map((project) => toRepoPath(root, project.config.file)),
+        analyzedPackages,
+        analyzedSourceFiles: analyzedSourceFiles.map((file) => toRepoPath(root, file)),
+        excludedFiles: excludedFiles.map((file) => toRepoPath(root, file)),
+        unresolvedFiles: uniqueSorted(unresolvedFiles).map((file) => toRepoPath(root, file)),
+        projects: inventories,
+        incompleteReasons: dedupeReasons(incompleteReasons)
+    };
+    return { root, projects, coverage };
+}
+function resolveSemanticModule(workspace, fromFile, specifier) {
+    const absoluteFrom = path.resolve(workspace.root, fromFile);
+    const owners = workspace.projects.filter((candidate) => ownsFile(candidate.config, absoluteFrom));
+    if (owners.length === 0) {
+        return {
+            status: "unresolved",
+            fromFile: toRepoPath(workspace.root, absoluteFrom),
+            specifier,
+            reason: { code: "owningProjectNotFound", file: toRepoPath(workspace.root, absoluteFrom) }
+        };
+    }
+    const outcomes = owners.map((project) => ({
+        project,
+        resolved: typescript_1.default.resolveModuleName(specifier, absoluteFrom, project.config.parsed.options, typescript_1.default.sys).resolvedModule?.resolvedFileName ?? null
+    }));
+    const distinct = new Set(outcomes.map((outcome) => outcome.resolved ? canonicalPathIdentity(outcome.resolved) : null));
+    const projects = outcomes.map((outcome) => toRepoPath(workspace.root, outcome.project.config.file)).sort();
+    if (distinct.size > 1) {
+        const reason = {
+            code: "ambiguousOwningProjects",
+            file: toRepoPath(workspace.root, absoluteFrom),
+            operation: "moduleResolution",
+            projects,
+            outcomes: outcomes.map((outcome) => ({
+                project: toRepoPath(workspace.root, outcome.project.config.file),
+                result: outcome.resolved ? toRepoPath(workspace.root, outcome.resolved) : null
+            })).sort((left, right) => left.project.localeCompare(right.project))
+        };
+        return {
+            status: "ambiguous",
+            fromFile: toRepoPath(workspace.root, absoluteFrom),
+            specifier,
+            tsconfigs: projects,
+            reason
+        };
+    }
+    const resolved = outcomes[0]?.resolved ?? null;
+    if (!resolved) {
+        return {
+            status: "unresolved",
+            fromFile: toRepoPath(workspace.root, absoluteFrom),
+            specifier,
+            ...(projects[0] ? { tsconfig: projects[0] } : {}),
+            tsconfigs: projects,
+            reason: { code: "moduleResolutionFailed", fromFile: toRepoPath(workspace.root, absoluteFrom), specifier }
+        };
+    }
+    return {
+        status: "resolved",
+        fromFile: toRepoPath(workspace.root, absoluteFrom),
+        specifier,
+        resolvedFile: toRepoPath(workspace.root, resolved),
+        ...(projects[0] ? { tsconfig: projects[0] } : {}),
+        tsconfigs: projects
+    };
+}
+function resolveExportedSemanticSymbol(workspace, sourceFile, exportName) {
+    const absoluteFile = path.resolve(workspace.root, sourceFile);
+    const owners = workspace.projects.filter((project) => ownsFile(project.config, absoluteFile));
+    if (owners.length === 0) {
+        return {
+            status: "unresolved",
+            reason: { code: "owningProjectNotFound", file: toRepoPath(workspace.root, absoluteFile) }
+        };
+    }
+    const outcomes = owners.map((project) => {
+        const source = project.program.getSourceFile(absoluteFile);
+        if (!source) {
+            return { project, symbol: null };
+        }
+        const moduleSymbol = project.checker.getSymbolAtLocation(source);
+        const exported = moduleSymbol && project.checker.getExportsOfModule(moduleSymbol).find((symbol) => symbol.getName() === exportName);
+        if (!exported) {
+            return { project, symbol: null };
+        }
+        return { project, symbol: toSymbolIdentity(workspace.root, resolveAlias(project.checker, exported)) };
+    });
+    const distinct = new Set(outcomes.map((outcome) => outcome.symbol?.key ?? null));
+    if (distinct.size > 1) {
+        const projects = outcomes.map((outcome) => toRepoPath(workspace.root, outcome.project.config.file)).sort();
+        return {
+            status: "ambiguous",
+            reason: {
+                code: "ambiguousOwningProjects",
+                file: toRepoPath(workspace.root, absoluteFile),
+                operation: "exportResolution",
+                projects,
+                outcomes: outcomes.map((outcome) => ({
+                    project: toRepoPath(workspace.root, outcome.project.config.file),
+                    result: outcome.symbol?.key ?? null
+                })).sort((left, right) => left.project.localeCompare(right.project))
+            }
+        };
+    }
+    const symbol = outcomes[0]?.symbol ?? null;
+    return symbol
+        ? { status: "resolved", symbol }
+        : {
+            status: "unresolved",
+            reason: { code: "symbolResolutionFailed", file: toRepoPath(workspace.root, absoluteFile), exportName }
+        };
+}
+function resolveSemanticNodeIdentity(workspace, project, node) {
+    const symbol = project.checker.getSymbolAtLocation(node);
+    return symbol ? toSymbolIdentity(workspace.root, resolveAlias(project.checker, symbol)) : null;
+}
+function resolveSemanticSymbolIdentity(workspace, project, symbol) {
+    return toSymbolIdentity(workspace.root, resolveAlias(project.checker, symbol));
+}
+function ownersForSemanticFile(workspace, file) {
+    const absolute = path.resolve(workspace.root, file);
+    return workspace.projects
+        .filter((project) => ownsFile(project.config, absolute))
+        .sort((left, right) => left.config.file.localeCompare(right.config.file));
+}
+function findSemanticReferences(workspace, target) {
+    const sites = new Map();
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            const source = project.program.getSourceFile(file);
+            if (!source || !isInside(workspace.root, source.fileName) || source.fileName.includes(`${path.sep}node_modules${path.sep}`)) {
+                continue;
+            }
+            const visit = (node) => {
+                if (typescript_1.default.isIdentifier(node)) {
+                    const symbol = typescript_1.default.isShorthandPropertyAssignment(node.parent)
+                        ? project.checker.getShorthandAssignmentValueSymbol(node.parent) ?? project.checker.getSymbolAtLocation(node)
+                        : project.checker.getSymbolAtLocation(node);
+                    if (symbol) {
+                        const identity = toSymbolIdentity(workspace.root, resolveAlias(project.checker, symbol));
+                        if (identity?.key === target.key) {
+                            const file = toRepoPath(workspace.root, source.fileName);
+                            const key = `${normalizePath(source.fileName)}:${node.getStart(source)}:${node.end}`;
+                            const site = {
+                                symbol: target,
+                                file,
+                                start: node.getStart(source),
+                                end: node.end,
+                                text: node.getText(source),
+                                kinds: classifySemanticUsage(node, path.resolve(workspace.root, target.declarationFile)),
+                                project: toRepoPath(workspace.root, project.config.file)
+                            };
+                            const previous = sites.get(key);
+                            if (!previous || site.project.localeCompare(previous.project) < 0) {
+                                sites.set(key, site);
+                            }
+                        }
+                    }
+                }
+                typescript_1.default.forEachChild(node, visit);
+            };
+            visit(source);
+        }
+    }
+    return [...sites.values()].sort((left, right) => left.file.localeCompare(right.file) || left.start - right.start || left.end - right.end);
+}
+function collectSemanticModuleEdges(workspace) {
+    const edges = new Map();
+    const incompleteReasons = [];
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            const source = project.program.getSourceFile(file);
+            if (!source || !isInside(workspace.root, source.fileName)) {
+                continue;
+            }
+            const candidates = collectModuleEdgeCandidates(source);
+            for (const candidate of candidates) {
+                const resolved = typescript_1.default.resolveModuleName(candidate.specifier, source.fileName, project.config.parsed.options, typescript_1.default.sys).resolvedModule?.resolvedFileName;
+                if (!resolved) {
+                    incompleteReasons.push({
+                        code: "moduleResolutionFailed",
+                        fromFile: toRepoPath(workspace.root, source.fileName),
+                        specifier: candidate.specifier
+                    });
+                    continue;
+                }
+                if (!isInside(workspace.root, resolved)) {
+                    continue;
+                }
+                const edge = {
+                    fromFile: toRepoPath(workspace.root, source.fileName),
+                    toFile: toRepoPath(workspace.root, resolved),
+                    specifier: candidate.specifier,
+                    kind: candidate.kind
+                };
+                edges.set(`${edge.fromFile}\0${edge.toFile}\0${edge.specifier}\0${edge.kind}`, edge);
+            }
+        }
+    }
+    return {
+        complete: incompleteReasons.length === 0,
+        edges: [...edges.values()].sort((left, right) => left.fromFile.localeCompare(right.fromFile) || left.toFile.localeCompare(right.toFile) ||
+            left.specifier.localeCompare(right.specifier) || left.kind.localeCompare(right.kind)),
+        incompleteReasons: dedupeReasons(incompleteReasons)
+    };
+}
+function scopeRelevantSemanticModuleEdges(workspace, collection, input) {
+    const sourceFiles = new Set(input.sourceFiles.map((file) => semanticRepoPath(workspace.root, file)));
+    const relevant = new Set([
+        ...sourceFiles,
+        ...(input.affectedFiles ?? []).map((file) => semanticRepoPath(workspace.root, file))
+    ]);
+    const incoming = new Map();
+    const outgoing = new Map();
+    for (const edge of collection.edges) {
+        appendMapValue(incoming, edge.toFile, edge.fromFile);
+        appendMapValue(outgoing, edge.fromFile, edge.toFile);
+    }
+    // Importers and re-export chains can expose the selected API even when they do
+    // not contain a checker reference to an individual selected member.
+    expandFileClosure(relevant, sourceFiles, incoming);
+    // Dependencies of the source and affected consumers are relevant to runtime
+    // cycle evidence. Forward-only expansion avoids poisoning the scope with
+    // unrelated siblings that merely share a dependency.
+    expandFileClosure(relevant, [...relevant], outgoing);
+    const relevantModuleReasons = collection.incompleteReasons.filter((reason) => reason.code === "moduleResolutionFailed" && relevant.has(reason.fromFile));
+    const structuralReasons = workspace.coverage.incompleteReasons.filter((reason) => reason.code !== "moduleResolutionFailed");
+    const incompleteReasons = dedupeReasons([...structuralReasons, ...relevantModuleReasons]);
+    const coverage = {
+        ...workspace.coverage,
+        complete: incompleteReasons.length === 0 && workspace.coverage.unresolvedFiles.length === 0,
+        incompleteReasons
+    };
+    const edges = collection.edges.filter((edge) => relevant.has(edge.fromFile) && relevant.has(edge.toFile));
+    return {
+        complete: relevantModuleReasons.length === 0,
+        edges,
+        incompleteReasons: dedupeReasons(relevantModuleReasons),
+        coverage,
+        relevantFiles: [...relevant].sort()
+    };
+}
+function classifySemanticUsage(node, declarationFile) {
+    const kinds = new Set();
+    const parent = node.parent;
+    if (declarationFile && normalizePath(node.getSourceFile().fileName) === normalizePath(declarationFile)) {
+        kinds.add("source-local");
+    }
+    if (isTypePosition(node) || isTypeOnlyImportExport(node)) {
+        kinds.add("type-position/type-query");
+    }
+    if (findAncestor(node, typescript_1.default.isExportSpecifier)) {
+        kinds.add("re-export");
+    }
+    if (parent && typescript_1.default.isShorthandPropertyAssignment(parent)) {
+        kinds.add("shorthand");
+    }
+    if (isNamespaceReceiver(node)) {
+        kinds.add("namespace");
+    }
+    if (isPropertyWrite(node)) {
+        kinds.add("property-write");
+    }
+    if (isUpdateOrDelete(node)) {
+        kinds.add("update/delete");
+    }
+    if (isDestructurePosition(node)) {
+        kinds.add("destructure");
+    }
+    if (isDirectCall(node)) {
+        kinds.add("direct-call");
+    }
+    if (!hasBehaviorKind(kinds) && parent && (typescript_1.default.isCallExpression(parent) || typescript_1.default.isNewExpression(parent)) &&
+        parent.arguments?.includes(node)) {
+        kinds.add("value-pass");
+    }
+    if (!hasBehaviorKind(kinds) && parent && (typescript_1.default.isReturnStatement(parent) || typescript_1.default.isPropertyAssignment(parent) ||
+        typescript_1.default.isArrayLiteralExpression(parent) || typescript_1.default.isBinaryExpression(parent) ||
+        typescript_1.default.isVariableDeclaration(parent) && parent.initializer === node)) {
+        kinds.add("escape/identity");
+    }
+    if (!hasBehaviorKind(kinds)) {
+        kinds.add("read/reference");
+    }
+    return [...kinds];
+}
+function createProjectContext(config, forwardSourceFiles) {
+    const program = typescript_1.default.createProgram({
+        rootNames: uniqueSorted([...config.parsed.fileNames, ...forwardSourceFiles]),
+        options: config.parsed.options
+    });
+    return { config, program, checker: program.getTypeChecker() };
+}
+function collectForwardSourceFiles(start, edges, configByPath) {
+    const visited = new Set();
+    const pending = [...(edges.get(start) ?? [])];
+    const files = [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        files.push(...(configByPath.get(current)?.parsed.fileNames ?? []));
+        pending.push(...(edges.get(current) ?? []));
+    }
+    return uniqueSorted(files);
+}
+function parseConfig(file, root, failures) {
+    const diagnostics = [];
+    const parsed = (0, tsconfig_loader_1.parseTsConfig)(file, diagnostics);
+    if (diagnostics.length > 0) {
+        failures.push({
+            code: "tsconfigParseFailed",
+            tsconfig: toRepoPath(root, file),
+            message: diagnostics.map((item) => item.message).join("; ")
+        });
+    }
+    if (!parsed) {
+        if (diagnostics.length === 0) {
+            failures.push({ code: "tsconfigParseFailed", tsconfig: toRepoPath(root, file), message: "Unable to parse tsconfig." });
+        }
+    }
+    return parsed;
+}
+function collectUnresolvedModuleReasons(root, projects) {
+    const reasons = [];
+    for (const project of projects) {
+        for (const file of project.config.parsed.fileNames) {
+            const source = project.program.getSourceFile(file);
+            if (!source || !isInside(root, source.fileName)) {
+                continue;
+            }
+            for (const specifier of collectModuleSpecifiers(source)) {
+                if (!typescript_1.default.resolveModuleName(specifier, source.fileName, project.config.parsed.options, typescript_1.default.sys).resolvedModule) {
+                    reasons.push({
+                        code: "moduleResolutionFailed",
+                        fromFile: toRepoPath(root, source.fileName),
+                        specifier
+                    });
+                }
+            }
+        }
+    }
+    return dedupeReasons(reasons);
+}
+function collectAmbiguousOwnershipReasons(root, configs) {
+    const ownersByFile = new Map();
+    for (const config of configs) {
+        const semanticOptions = { ...config.parsed.options };
+        delete semanticOptions.configFilePath;
+        const options = stableStringify(semanticOptions);
+        for (const file of config.parsed.fileNames) {
+            const key = canonicalPathIdentity(file);
+            const entry = ownersByFile.get(key) ?? { file, owners: [] };
+            entry.owners.push({ config, options });
+            ownersByFile.set(key, entry);
+        }
+    }
+    const reasons = [];
+    for (const { file, owners } of ownersByFile.values()) {
+        if (owners.length < 2 || new Set(owners.map((owner) => owner.options)).size < 2) {
+            continue;
+        }
+        const projects = owners.map((owner) => toRepoPath(root, owner.config.file)).sort();
+        reasons.push({
+            code: "ambiguousOwningProjects",
+            file: toRepoPath(root, file),
+            operation: "referenceCoverage",
+            projects,
+            outcomes: owners.map((owner) => ({
+                project: toRepoPath(root, owner.config.file),
+                result: crypto.createHash("sha256").update(owner.options).digest("hex")
+            })).sort((left, right) => left.project.localeCompare(right.project))
+        });
+    }
+    return reasons;
+}
+function collectModuleSpecifiers(source) {
+    const specifiers = [];
+    const visit = (node) => {
+        if ((typescript_1.default.isImportDeclaration(node) || typescript_1.default.isExportDeclaration(node)) &&
+            node.moduleSpecifier && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            specifiers.push(node.moduleSpecifier.text);
+        }
+        else if (typescript_1.default.isCallExpression(node) && node.arguments.length > 0 && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            const expression = node.expression;
+            if (expression.kind === typescript_1.default.SyntaxKind.ImportKeyword) {
+                specifiers.push(node.arguments[0].text);
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return uniqueSorted(specifiers);
+}
+function collectModuleEdgeCandidates(source) {
+    const candidates = [];
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node) && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            const clause = node.importClause;
+            const named = clause?.namedBindings && typescript_1.default.isNamedImports(clause.namedBindings)
+                ? clause.namedBindings.elements
+                : [];
+            const typeOnly = clause?.isTypeOnly === true ||
+                Boolean(clause && !clause.name && named.length > 0 && named.every((element) => element.isTypeOnly));
+            candidates.push({ specifier: node.moduleSpecifier.text, kind: typeOnly ? "type" : "runtime" });
+        }
+        else if (typescript_1.default.isExportDeclaration(node) && node.moduleSpecifier && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            candidates.push({ specifier: node.moduleSpecifier.text, kind: node.isTypeOnly ? "type" : "runtime" });
+        }
+        else if (typescript_1.default.isCallExpression(node) && node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword &&
+            node.arguments.length === 1 && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            candidates.push({ specifier: node.arguments[0].text, kind: "dynamic" });
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return candidates;
+}
+function buildReferenceGraph(configs, configByPath) {
+    const edges = new Map();
+    const reverse = new Map();
+    const unresolved = new Map();
+    for (const config of configs) {
+        const key = normalizePath(config.file);
+        for (const reference of config.parsed.projectReferences ?? []) {
+            const target = resolveProjectReference(reference.path);
+            const targetKey = normalizePath(target);
+            if (!configByPath.has(targetKey)) {
+                unresolved.set(key, [...(unresolved.get(key) ?? []), target]);
+                continue;
+            }
+            edges.set(key, [...(edges.get(key) ?? []), targetKey]);
+            reverse.set(targetKey, [...(reverse.get(targetKey) ?? []), key]);
+        }
+    }
+    return { edges, reverse, unresolved };
+}
+function expandRelevantProjects(selected, graph, configByPath) {
+    const pending = [...selected];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const forward = graph.edges.get(current) ?? [];
+        const sourceOwningConsumers = (graph.reverse.get(current) ?? [])
+            .filter((config) => (configByPath.get(config)?.parsed.fileNames.length ?? 0) > 0);
+        for (const related of [...forward, ...sourceOwningConsumers]) {
+            if (!selected.has(related)) {
+                selected.add(related);
+                pending.push(related);
+            }
+        }
+    }
+}
+function resolveProjectReference(referencePath) {
+    const absolute = path.resolve(referencePath);
+    if (/\.json$/i.test(absolute)) {
+        return absolute;
+    }
+    return path.join(absolute, "tsconfig.json");
+}
+function collectExcludedSourceFiles(configFiles, root) {
+    const files = [];
+    for (const configFile of configFiles) {
+        const diagnostics = [];
+        const parsed = (0, tsconfig_loader_1.parseTsConfig)(configFile, diagnostics);
+        if (parsed) {
+            files.push(...parsed.parsed.fileNames.filter((file) => isInside(root, file)));
+        }
+    }
+    return uniqueSorted(files);
+}
+function toSymbolIdentity(root, symbol) {
+    const declarations = [...(symbol.getDeclarations() ?? [])].sort((left, right) => left.getSourceFile().fileName.localeCompare(right.getSourceFile().fileName) || left.getStart() - right.getStart());
+    const declaration = declarations[0];
+    if (!declaration) {
+        return null;
+    }
+    const declarationFile = toRepoPath(root, declaration.getSourceFile().fileName);
+    const declarationStart = declaration.getStart();
+    const declarationEnd = declaration.end;
+    const name = symbol.getName();
+    return {
+        key: `${canonicalPathIdentity(declaration.getSourceFile().fileName)}:${declarationStart}:${declarationEnd}:${name}`,
+        name,
+        declarationFile,
+        declarationStart,
+        declarationEnd,
+        flags: symbol.flags
+    };
+}
+function resolveAlias(checker, symbol) {
+    let current = symbol;
+    const seen = new Set();
+    while ((current.flags & typescript_1.default.SymbolFlags.Alias) !== 0 && !seen.has(current)) {
+        seen.add(current);
+        const next = checker.getAliasedSymbol(current);
+        if (next === current) {
+            break;
+        }
+        current = next;
+    }
+    return current;
+}
+function ownsFile(config, file) {
+    const normalized = normalizePath(file);
+    return config.parsed.fileNames.some((candidate) => normalizePath(candidate) === normalized);
+}
+function isTypePosition(node) {
+    let current = node;
+    while (current?.parent && !typescript_1.default.isStatement(current.parent)) {
+        if (typescript_1.default.isTypeNode(current.parent) || typescript_1.default.isTypeQueryNode(current.parent)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isTypeOnlyImportExport(node) {
+    const importSpecifier = findAncestor(node, typescript_1.default.isImportSpecifier);
+    if (importSpecifier) {
+        const importClause = findAncestor(importSpecifier, typescript_1.default.isImportClause);
+        return importSpecifier.isTypeOnly || importClause?.isTypeOnly === true;
+    }
+    const exportSpecifier = findAncestor(node, typescript_1.default.isExportSpecifier);
+    if (exportSpecifier) {
+        const exportDeclaration = findAncestor(exportSpecifier, typescript_1.default.isExportDeclaration);
+        return exportSpecifier.isTypeOnly || exportDeclaration?.isTypeOnly === true;
+    }
+    return false;
+}
+function isPropertyWrite(node) {
+    const target = propertyContainer(node);
+    const parent = target.parent;
+    if (!parent || !typescript_1.default.isBinaryExpression(parent) || parent.left !== target) {
+        return false;
+    }
+    return parent.operatorToken.kind >= typescript_1.default.SyntaxKind.FirstAssignment &&
+        parent.operatorToken.kind <= typescript_1.default.SyntaxKind.LastAssignment;
+}
+function isUpdateOrDelete(node) {
+    const target = propertyContainer(node);
+    const parent = target.parent;
+    return Boolean(parent && (typescript_1.default.isPrefixUnaryExpression(parent) || typescript_1.default.isPostfixUnaryExpression(parent) ||
+        typescript_1.default.isDeleteExpression(parent)));
+}
+function isDirectCall(node) {
+    const target = propertyContainer(node);
+    return Boolean(target.parent && typescript_1.default.isCallExpression(target.parent) && target.parent.expression === target);
+}
+function propertyContainer(node) {
+    const parent = node.parent;
+    if (parent && (typescript_1.default.isPropertyAccessExpression(parent) && (parent.expression === node || parent.name === node) ||
+        typescript_1.default.isElementAccessExpression(parent) && (parent.expression === node || parent.argumentExpression === node))) {
+        return parent;
+    }
+    return node;
+}
+function isNamespaceReceiver(node) {
+    const parent = node.parent;
+    return Boolean(parent && (typescript_1.default.isPropertyAccessExpression(parent) || typescript_1.default.isElementAccessExpression(parent)) &&
+        parent.expression === node);
+}
+function isDestructurePosition(node) {
+    let current = node;
+    while (current?.parent && !typescript_1.default.isStatement(current.parent)) {
+        if (typescript_1.default.isBindingElement(current.parent) || typescript_1.default.isObjectBindingPattern(current.parent) ||
+            typescript_1.default.isArrayBindingPattern(current.parent)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function hasBehaviorKind(kinds) {
+    return [...kinds].some((kind) => kind !== "source-local");
+}
+function findAncestor(node, predicate) {
+    let current = node.parent;
+    while (current) {
+        if (predicate(current)) {
+            return current;
+        }
+        if (typescript_1.default.isStatement(current)) {
+            break;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function uniquePackages(ownership) {
+    const packages = new Map();
+    for (const item of ownership) {
+        if (item.packageRoot) {
+            packages.set(item.packageRoot, { root: item.packageRoot, ...(item.packageName ? { name: item.packageName } : {}) });
+        }
+    }
+    return [...packages.values()].sort((left, right) => left.root.localeCompare(right.root));
+}
+function semanticRepoPath(root, file) {
+    return toRepoPath(root, path.isAbsolute(file) ? file : path.resolve(root, file));
+}
+function appendMapValue(map, key, value) {
+    const values = map.get(key);
+    if (values) {
+        values.push(value);
+    }
+    else {
+        map.set(key, [value]);
+    }
+}
+function expandFileClosure(target, seeds, adjacency) {
+    const queue = [...seeds];
+    for (let index = 0; index < queue.length; index += 1) {
+        for (const next of adjacency.get(queue[index]) ?? []) {
+            if (target.has(next)) {
+                continue;
+            }
+            target.add(next);
+            queue.push(next);
+        }
+    }
+}
+function dedupeReasons(reasons) {
+    const seen = new Set();
+    return reasons.filter((reason) => {
+        const key = JSON.stringify(reason);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function fileHash(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).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).filter((key) => record[key] !== undefined).sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function canonicalPathIdentity(file, platform = process.platform) {
+    const resolved = path.resolve(file).replace(/\\/g, "/");
+    return platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function normalizePath(file) {
+    return canonicalPathIdentity(file);
+}
+function toRepoPath(root, file) {
+    const relative = path.relative(root, path.resolve(file)).replace(/\\/g, "/");
+    return relative || ".";
+}
+function isInside(root, file) {
+    const relative = path.relative(path.resolve(root), path.resolve(file));
+    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}