@mnemonica/tactica 0.1.14 → 0.2.0

package/lib/creation-graph.js

@@ -0,0 +1,568 @@
+'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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreationGraphBuilder = void 0;
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+/**
+ * Inside-out creation walker (instrumentation walker plan, Phase 3).
+ *
+ * Starts at the certain points — instantiation usages carrying a
+ * holderScopeId — then walks OUTWARD: who invokes or references the holder,
+ * crossing files through the module graph (barrels chased the same way
+ * ModuleGraphBuilder.resolveOrigin does), until no callers remain. Terminals
+ * are the starters (application entry points). The walk never assumes a
+ * linear Trie (decision 1: strictChain:false permits cycles/out-of-order
+ * construction), so traversal is cycle-guarded DFS, and every anchor records
+ * which constructor expression was actually used.
+ *
+ * Deliberate approximations (no getTypeChecker(), name-based only):
+ * - Namespace imports (`import * as ns`): when the namespace's source module
+ *   exposes the holder's export, ANY reference to the alias counts as a
+ *   caller reference.
+ * - Method scopes bind to their CLASS name (callers reference the class);
+ *   instance-method call sites (`obj.method()`) are not distinguishable
+ *   without the checker.
+ * - Any non-declaration identifier counts as a reference (invocations,
+ *   pass-as-arg, rebinding); type-position references are not filtered.
+ * - Module scopes end the invocation walk, but a terminal module still
+ *   gains its IMPORTERS as callers: entry modules hand classes to the
+ *   framework as values (a bootstrap call receiving the root module),
+ *   which no call-walk can see — the import relation bridges them to
+ *   the center.
+ */
+class CreationGraphBuilder {
+    constructor(moduleGraph, scopeAnalysis, scopeWalker, sourceFiles) {
+        /** filePath -> (identifier text -> reference locations), built lazily per file */
+        this.referencesByFile = new Map();
+        this.moduleGraph = moduleGraph;
+        this.scopeAnalysis = scopeAnalysis;
+        this.scopeWalker = scopeWalker;
+        this.sourceFiles = sourceFiles;
+    }
+    /**
+     * Build the creation graph from the analyzer's usages (holderScopeId
+     * already attached). Always returns a graph, empty arrays when nothing
+     * creates mnemonica instances.
+     */
+    build(usages) {
+        const anchors = this.collectAnchors(usages);
+        const nodes = new Map();
+        const edges = [];
+        const seenEdges = new Set();
+        // scopeIds with at least one caller — everyone else is a starter
+        const called = new Set();
+        const visited = new Set();
+        const work = anchors.map(anchor => anchor.holderScopeId);
+        const addEdge = (caller, callee) => {
+            const key = `${caller}\n${callee}`;
+            if (seenEdges.has(key)) {
+                return;
+            }
+            seenEdges.add(key);
+            edges.push({ caller, callee });
+            called.add(callee);
+        };
+        while (work.length > 0) {
+            const scopeId = work.pop();
+            if (!scopeId || visited.has(scopeId)) {
+                continue;
+            }
+            visited.add(scopeId);
+            const scope = this.scopeAnalysis.scopes.get(scopeId);
+            if (!scope) {
+                continue;
+            }
+            nodes.set(scopeId, CreationGraphBuilder.nodeOf(scope));
+            if (scope.kind === 'module') {
+                // Module scopes END the invocation walk — nobody invokes a
+                // module (a module-scope creation is labeled rooted on the
+                // anchor instead). But entry modules hand their classes to
+                // the framework as VALUES (a bootstrap call receiving the
+                // root module, or framework metadata listing controllers),
+                // invisible to
+                // call-walking — so a terminal module still gains its
+                // IMPORTERS as callers: main.ts importing AppModule yields
+                // the main.ts → app.module edge the pure call graph misses.
+                for (const importer of this.importersOf(scope.filePath)) {
+                    addEdge(importer, scopeId);
+                    if (!visited.has(importer)) {
+                        work.push(importer);
+                    }
+                }
+                continue;
+            }
+            const bindingName = CreationGraphBuilder.bindingNameOf(scope);
+            if (!bindingName) {
+                // Anonymous holder (file:line label): never referenced by name
+                continue;
+            }
+            // Plan-sketch refinement: same-file references are followed for
+            // EVERY holder, exported or not — an exported function can also be
+            // called from its own module, and both paths lead outward.
+            const sameFileCallers = this.callersOf(scope.filePath, bindingName);
+            const crossFileCallers = this.findCrossFileCallers(scope, bindingName);
+            for (const caller of [...sameFileCallers, ...crossFileCallers]) {
+                // Direct recursion (f calls f) adds no outward information
+                if (caller === scopeId) {
+                    continue;
+                }
+                addEdge(caller, scopeId);
+                if (!visited.has(caller)) {
+                    work.push(caller);
+                }
+            }
+        }
+        for (const node of nodes.values()) {
+            node.starter = !called.has(node.scopeId);
+        }
+        const result = {
+            nodes: Array.from(nodes.values()),
+            edges,
+            anchors,
+        };
+        return result;
+    }
+    /**
+     * One anchor per instantiation usage with a known holder scope.
+     */
+    collectAnchors(usages) {
+        const anchors = [];
+        for (const [typePath, usageList] of usages) {
+            for (const usage of usageList) {
+                if (usage.kind !== 'instantiation' || !usage.holderScopeId) {
+                    continue;
+                }
+                const holderScope = this.scopeAnalysis.scopes.get(usage.holderScopeId);
+                if (!holderScope) {
+                    continue;
+                }
+                const anchor = {
+                    location: usage.location,
+                    holderScopeId: usage.holderScopeId,
+                    typePath,
+                };
+                if (usage.constructorText) {
+                    anchor.constructorText = usage.constructorText;
+                }
+                if (holderScope.kind === 'module') {
+                    // Plan: module-scope creation is a rooted instance —
+                    // legitimate root or developer error; labeled, not policed
+                    anchor.rooted = true;
+                }
+                const variable = this.matchAnchorVariable(usage, typePath, holderScope);
+                if (variable) {
+                    anchor.variable = variable.name;
+                    const [terminatedAt] = variable.reassignments;
+                    if (terminatedAt) {
+                        anchor.terminatedAt = terminatedAt;
+                    }
+                }
+                anchors.push(anchor);
+            }
+        }
+        return anchors;
+    }
+    /**
+     * Same-line heuristic for the anchor's variable: the variable declared in
+     * the holder scope on the same line as the creation, whose typePath (when
+     * known) matches the created type.
+     */
+    matchAnchorVariable(usage, typePath, holderScope) {
+        const usageLine = CreationGraphBuilder.lineOf(usage.location);
+        if (usageLine === undefined) {
+            return undefined;
+        }
+        for (const variable of this.scopeAnalysis.variables.values()) {
+            if (variable.scopeId !== holderScope.scopeId) {
+                continue;
+            }
+            if (CreationGraphBuilder.lineOf(variable.declaration) !== usageLine) {
+                continue;
+            }
+            if (variable.typePath && variable.typePath !== typePath) {
+                continue;
+            }
+            return variable;
+        }
+        return undefined;
+    }
+    /**
+     * Parse the 1-based line out of a file.ts:Line:Col location string.
+     */
+    static lineOf(location) {
+        const lastColon = location.lastIndexOf(':');
+        const prevColon = location.lastIndexOf(':', lastColon - 1);
+        if (lastColon < 0 || prevColon < 0) {
+            return undefined;
+        }
+        const line = Number(location.slice(prevColon + 1, lastColon));
+        const result = Number.isFinite(line) ? line : undefined;
+        return result;
+    }
+    static nodeOf(scope) {
+        const node = {
+            scopeId: scope.scopeId,
+            name: scope.name,
+            kind: scope.kind,
+            filePath: scope.filePath,
+            location: scope.location,
+            starter: false,
+        };
+        return node;
+    }
+    /**
+     * The name a scope is reachable by: functions/arrows take their scope
+     * name; methods take their class (the part before '.') — that is what
+     * callers reference. Anonymous holders (file:line labels) and module
+     * scopes have no binding name.
+     */
+    static bindingNameOf(scope) {
+        if (scope.kind === 'module') {
+            return undefined;
+        }
+        // Anonymous label is `${filePath}:${line}` — a name can never contain '/'
+        if (scope.name.startsWith(`${scope.filePath}:`)) {
+            return undefined;
+        }
+        if (scope.kind === 'method') {
+            const dotIndex = scope.name.indexOf('.');
+            if (dotIndex < 0) {
+                // Method of an anonymous class — no binding name
+                return undefined;
+            }
+            const result = scope.name.slice(0, dotIndex);
+            return result;
+        }
+        return scope.name;
+    }
+    /**
+     * Scope ids referencing `bindingName` inside one file (invocations,
+     * pass-as-arg, rebindings — any non-declaration identifier).
+     */
+    callersOf(filePath, bindingName) {
+        const references = this.referencesIn(filePath, bindingName);
+        const callers = [];
+        for (const location of references) {
+            const callerScopeId = this.scopeWalker.findHolderScopeId(location);
+            if (callerScopeId) {
+                callers.push(callerScopeId);
+            }
+        }
+        return callers;
+    }
+    /**
+     * Callers in OTHER modules, followed through the module graph when the
+     * holder's binding is exported (the plan's "if f is exported" branch,
+     * including the barrel chase).
+     */
+    findCrossFileCallers(scope, bindingName) {
+        const holderModule = this.moduleGraph.modules.get(scope.filePath);
+        if (!holderModule) {
+            return [];
+        }
+        // The exported binding whose LOCAL name is the scope's binding name.
+        // Plain exports present under their own name; `export { X as Y }` and
+        // `export default X` carry the local name in importAlias.
+        const exported = holderModule.exportedBindings.find(binding => !binding.isReExport && (binding.importAlias ?? binding.name) === bindingName);
+        if (!exported) {
+            return [];
+        }
+        const callers = [];
+        for (const importer of this.moduleGraph.modules.values()) {
+            if (importer.filePath === scope.filePath) {
+                continue;
+            }
+            for (const imported of importer.importedBindings) {
+                // Re-exports create no local identifier to reference; external
+                // packages (node_modules) are never walked
+                if (imported.isReExport || imported.external) {
+                    continue;
+                }
+                const localName = this.importReferencesHolder(imported, exported, scope.filePath);
+                if (!localName) {
+                    continue;
+                }
+                const importerCallers = this.callersOf(importer.filePath, localName);
+                callers.push(...importerCallers);
+            }
+        }
+        return callers;
+    }
+    /**
+     * Modules importing bindings whose ORIGIN is `filePath` — the
+     * exports-and-usage bridge for terminal module scopes. Any binding kind
+     * counts (named, default, re-export): resolveImportOrigin chases barrels
+     * to the declaring module; namespace imports and external packages never
+     * resolve, so neither connects. Returned as module-scope scopeIds — a
+     * module's scopeId IS its resolved filePath.
+     */
+    importersOf(filePath) {
+        const importers = [];
+        for (const importer of this.moduleGraph.modules.values()) {
+            if (importer.filePath === filePath) {
+                continue;
+            }
+            const depends = importer.importedBindings.some(imported => {
+                const origin = this.resolveImportOrigin(imported);
+                const result = origin !== undefined && origin.module.filePath === filePath;
+                return result;
+            });
+            if (depends) {
+                importers.push(importer.filePath);
+            }
+        }
+        return importers;
+    }
+    /**
+     * The local identifier an import binding presents for reference search,
+     * when the binding resolves to the holder's export — undefined otherwise.
+     */
+    importReferencesHolder(imported, holderExport, holderFilePath) {
+        if (imported.importKind === 'namespace') {
+            // Namespace approximation: when the alias's source module exposes
+            // the holder's export, any reference to the alias counts
+            const exposes = this.namespaceExposes(imported.sourceModule, holderExport.name, holderFilePath);
+            const result = exposes ? imported.name : undefined;
+            return result;
+        }
+        const origin = this.resolveImportOrigin(imported);
+        if (!origin) {
+            return undefined;
+        }
+        if (origin.module.filePath !== holderFilePath || origin.binding.name !== holderExport.name) {
+            return undefined;
+        }
+        return imported.name;
+    }
+    /**
+     * True when a namespace import's source module exposes `exportedName`
+     * whose origin is the holder's module. Expressed as resolving a synthetic
+     * named binding, so star barrels and named re-exports are chased by the
+     * same machinery as plain imports.
+     */
+    namespaceExposes(sourceModule, exportedName, holderFilePath) {
+        const synthetic = {
+            name: exportedName,
+            kind: 'unknown',
+            sourceModule,
+            isReExport: true,
+        };
+        const origin = this.resolveImportOrigin(synthetic);
+        if (!origin) {
+            return false;
+        }
+        const result = origin.module.filePath === holderFilePath && origin.binding.name === exportedName;
+        return result;
+    }
+    /**
+     * Chase an import binding to the module that actually declares it,
+     * following re-export chains (barrels). Same shape as
+     * ModuleGraphBuilder.resolveOrigin, run here over the BUILT graph
+     * (sourceModule values are already resolved absolute paths).
+     * Cycle-guarded; undefined when the origin is external or the chain loops.
+     */
+    resolveImportOrigin(binding, visited = new Set()) {
+        const sourcePath = path.resolve(binding.sourceModule);
+        if (visited.has(sourcePath)) {
+            return undefined;
+        }
+        visited.add(sourcePath);
+        const sourceModuleInfo = this.moduleGraph.modules.get(sourcePath);
+        if (!sourceModuleInfo) {
+            return undefined;
+        }
+        // The name to look up in the source module's export list
+        const lookupKey = binding.importKind === 'default'
+            ? 'default'
+            : binding.importAlias ?? binding.name;
+        for (const exported of sourceModuleInfo.exportedBindings) {
+            if (exported.name !== lookupKey) {
+                continue;
+            }
+            if (!exported.isReExport) {
+                const result = { module: sourceModuleInfo, binding: exported };
+                return result;
+            }
+            const chased = this.resolveImportOrigin(exported, visited);
+            return chased;
+        }
+        // `export * from './y'` barrels: the name may live behind a star
+        for (const exported of sourceModuleInfo.exportedBindings) {
+            if (!exported.isReExport || exported.importKind !== 'namespace' || exported.name !== '*') {
+                continue;
+            }
+            const chased = this.resolveImportOrigin({
+                name: lookupKey,
+                kind: 'unknown',
+                sourceModule: exported.sourceModule,
+                isReExport: true,
+            }, visited);
+            if (chased) {
+                return chased;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * All references to `name` in a file as location strings. The per-file
+     * index is built lazily in ONE pass (every identifier bucketed by text)
+     * and cached.
+     */
+    referencesIn(filePath, name) {
+        let byName = this.referencesByFile.get(filePath);
+        if (!byName) {
+            byName = new Map();
+            const sourceFile = this.sourceFiles.get(filePath);
+            if (sourceFile) {
+                CreationGraphBuilder.collectReferences(sourceFile, byName);
+            }
+            this.referencesByFile.set(filePath, byName);
+        }
+        const result = byName.get(name) ?? [];
+        return result;
+    }
+    /**
+     * Bucket every identifier reference by name. Declaration and wiring
+     * positions are NOT references: import/export specifiers, declaration
+     * names, property-access `.name`, and property-assignment keys go into a
+     * skip set of NODES — program files can be unbound, so parent-pointer
+     * checks are impossible (the scopes walker precedent, Phase 2).
+     * ShorthandPropertyAssignment names DO count: `{ foo }` is a genuine
+     * reference to foo.
+     */
+    static collectReferences(sourceFile, byName) {
+        const skip = new Set();
+        const filePath = path.resolve(sourceFile.fileName);
+        const visit = (node) => {
+            CreationGraphBuilder.registerSkips(node, skip);
+            if (ts.isIdentifier(node) && !skip.has(node)) {
+                const list = byName.get(node.text) ?? [];
+                if (list.length === 0) {
+                    byName.set(node.text, list);
+                }
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+                list.push(`${filePath}:${line + 1}:${character + 1}`);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    /**
+     * Register the identifier nodes that must NOT count as references when
+     * `node` is a wiring/declaration construct. Runs on the parent before
+     * descending, so the skip set is populated before the identifier nodes
+     * themselves are visited.
+     */
+    static registerSkips(node, skip) {
+        // import … from './x'
+        if (ts.isImportDeclaration(node)) {
+            const { importClause } = node;
+            if (!importClause) {
+                return;
+            }
+            if (importClause.name) {
+                skip.add(importClause.name);
+            }
+            const { namedBindings } = importClause;
+            if (namedBindings && ts.isNamedImports(namedBindings)) {
+                for (const element of namedBindings.elements) {
+                    if (element.propertyName) {
+                        skip.add(element.propertyName);
+                    }
+                    skip.add(element.name);
+                }
+            }
+            if (namedBindings && ts.isNamespaceImport(namedBindings)) {
+                skip.add(namedBindings.name);
+            }
+            return;
+        }
+        // import x = require('./y')
+        if (ts.isImportEqualsDeclaration(node)) {
+            skip.add(node.name);
+            return;
+        }
+        // export { X } [from './y'] / export * as ns from './y' — export wiring
+        // alone is not a caller; an importer's usage creates the edge instead
+        if (ts.isExportDeclaration(node)) {
+            const { exportClause } = node;
+            if (exportClause && ts.isNamedExports(exportClause)) {
+                for (const element of exportClause.elements) {
+                    if (element.propertyName) {
+                        skip.add(element.propertyName);
+                    }
+                    skip.add(element.name);
+                }
+            }
+            if (exportClause && ts.isNamespaceExport(exportClause)) {
+                skip.add(exportClause.name);
+            }
+            return;
+        }
+        // export default foo — same export-wiring rule
+        if (ts.isExportAssignment(node) && ts.isIdentifier(node.expression)) {
+            skip.add(node.expression);
+            return;
+        }
+        // obj.name — the `.name` part is property wiring, not a reference
+        if (ts.isPropertyAccessExpression(node)) {
+            skip.add(node.name);
+            return;
+        }
+        // { name: value } — the key is not a reference. Shorthand `{ name }`
+        // IS a reference: ShorthandPropertyAssignment never matches here.
+        if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+            skip.add(node.name);
+            return;
+        }
+        if (ts.isShorthandPropertyAssignment(node)) {
+            return;
+        }
+        // { x: a } destructuring — `x` is property wiring (`a` is the declared
+        // name, skipped by the generic declaration branch below)
+        if (ts.isBindingElement(node) && node.propertyName && ts.isIdentifier(node.propertyName)) {
+            skip.add(node.propertyName);
+        }
+        // Declaration names: `function f`, `class C`, `const x`, parameters,
+        // methods, enum members… — being declared is not being referenced
+        const named = node;
+        if ('name' in node && named.name && ts.isIdentifier(named.name)) {
+            skip.add(named.name);
+        }
+    }
+}
+exports.CreationGraphBuilder = CreationGraphBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"creation-graph.js","sourceRoot":"","sources":["../src/creation-graph.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport * as path from 'path';\nimport * as ts from 'typescript';\nimport { LocalScopeWalker } from './scopes';\nimport {\n\tCreationAnchor, CreationGraph, CreationGraphEdge, CreationGraphNode, ModuleBinding, ModuleGraph, ModuleInfo,\n\tScopeAnalysis, ScopeInfo, ScopeVariable, UsageInfo\n} from './types';\n\n/**\n * Inside-out creation walker (instrumentation walker plan, Phase 3).\n *\n * Starts at the certain points — instantiation usages carrying a\n * holderScopeId — then walks OUTWARD: who invokes or references the holder,\n * crossing files through the module graph (barrels chased the same way\n * ModuleGraphBuilder.resolveOrigin does), until no callers remain. Terminals\n * are the starters (application entry points). The walk never assumes a\n * linear Trie (decision 1: strictChain:false permits cycles/out-of-order\n * construction), so traversal is cycle-guarded DFS, and every anchor records\n * which constructor expression was actually used.\n *\n * Deliberate approximations (no getTypeChecker(), name-based only):\n * - Namespace imports (`import * as ns`): when the namespace's source module\n *   exposes the holder's export, ANY reference to the alias counts as a\n *   caller reference.\n * - Method scopes bind to their CLASS name (callers reference the class);\n *   instance-method call sites (`obj.method()`) are not distinguishable\n *   without the checker.\n * - Any non-declaration identifier counts as a reference (invocations,\n *   pass-as-arg, rebinding); type-position references are not filtered.\n * - Module scopes end the invocation walk, but a terminal module still\n *   gains its IMPORTERS as callers: entry modules hand classes to the\n *   framework as values (a bootstrap call receiving the root module),\n *   which no call-walk can see — the import relation bridges them to\n *   the center.\n */\nexport class CreationGraphBuilder {\n\tprivate moduleGraph: ModuleGraph;\n\tprivate scopeAnalysis: ScopeAnalysis;\n\tprivate scopeWalker: LocalScopeWalker;\n\t/** Keyed by path.resolve(sourceFile.fileName), matching scopeIds */\n\tprivate sourceFiles: Map<string, ts.SourceFile>;\n\t/** filePath -> (identifier text -> reference locations), built lazily per file */\n\tprivate referencesByFile = new Map<string, Map<string, string[]>>();\n\n\tconstructor (\n\t\tmoduleGraph: ModuleGraph,\n\t\tscopeAnalysis: ScopeAnalysis,\n\t\tscopeWalker: LocalScopeWalker,\n\t\tsourceFiles: Map<string, ts.SourceFile>\n\t) {\n\t\tthis.moduleGraph = moduleGraph;\n\t\tthis.scopeAnalysis = scopeAnalysis;\n\t\tthis.scopeWalker = scopeWalker;\n\t\tthis.sourceFiles = sourceFiles;\n\t}\n\n\t/**\n\t * Build the creation graph from the analyzer's usages (holderScopeId\n\t * already attached). Always returns a graph, empty arrays when nothing\n\t * creates mnemonica instances.\n\t */\n\tbuild (usages: Map<string, UsageInfo[]>): CreationGraph {\n\t\tconst anchors = this.collectAnchors(usages);\n\n\t\tconst nodes = new Map<string, CreationGraphNode>();\n\t\tconst edges: CreationGraphEdge[] = [];\n\t\tconst seenEdges = new Set<string>();\n\t\t// scopeIds with at least one caller — everyone else is a starter\n\t\tconst called = new Set<string>();\n\t\tconst visited = new Set<string>();\n\t\tconst work: string[] = anchors.map(anchor => anchor.holderScopeId);\n\n\t\tconst addEdge = (caller: string, callee: string): void => {\n\t\t\tconst key = `${caller}\\n${callee}`;\n\t\t\tif (seenEdges.has(key)) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tseenEdges.add(key);\n\t\t\tedges.push({ caller, callee });\n\t\t\tcalled.add(callee);\n\t\t};\n\n\t\twhile (work.length > 0) {\n\t\t\tconst scopeId = work.pop();\n\t\t\tif (!scopeId || visited.has(scopeId)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tvisited.add(scopeId);\n\t\t\tconst scope = this.scopeAnalysis.scopes.get(scopeId);\n\t\t\tif (!scope) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tnodes.set(scopeId, CreationGraphBuilder.nodeOf(scope));\n\n\t\t\tif (scope.kind === 'module') {\n\t\t\t\t// Module scopes END the invocation walk — nobody invokes a\n\t\t\t\t// module (a module-scope creation is labeled rooted on the\n\t\t\t\t// anchor instead). But entry modules hand their classes to\n\t\t\t\t// the framework as VALUES (a bootstrap call receiving the\n\t\t\t\t// root module, or framework metadata listing controllers),\n\t\t\t\t// invisible to\n\t\t\t\t// call-walking — so a terminal module still gains its\n\t\t\t\t// IMPORTERS as callers: main.ts importing AppModule yields\n\t\t\t\t// the main.ts → app.module edge the pure call graph misses.\n\t\t\t\tfor (const importer of this.importersOf(scope.filePath)) {\n\t\t\t\t\taddEdge(importer, scopeId);\n\t\t\t\t\tif (!visited.has(importer)) {\n\t\t\t\t\t\twork.push(importer);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst bindingName = CreationGraphBuilder.bindingNameOf(scope);\n\t\t\tif (!bindingName) {\n\t\t\t\t// Anonymous holder (file:line label): never referenced by name\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Plan-sketch refinement: same-file references are followed for\n\t\t\t// EVERY holder, exported or not — an exported function can also be\n\t\t\t// called from its own module, and both paths lead outward.\n\t\t\tconst sameFileCallers = this.callersOf(scope.filePath, bindingName);\n\t\t\tconst crossFileCallers = this.findCrossFileCallers(scope, bindingName);\n\t\t\tfor (const caller of [ ...sameFileCallers, ...crossFileCallers ]) {\n\t\t\t\t// Direct recursion (f calls f) adds no outward information\n\t\t\t\tif (caller === scopeId) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\taddEdge(caller, scopeId);\n\t\t\t\tif (!visited.has(caller)) {\n\t\t\t\t\twork.push(caller);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tfor (const node of nodes.values()) {\n\t\t\tnode.starter = !called.has(node.scopeId);\n\t\t}\n\n\t\tconst result: CreationGraph = {\n\t\t\tnodes : Array.from(nodes.values()),\n\t\t\tedges,\n\t\t\tanchors,\n\t\t};\n\t\treturn result;\n\t}\n\n\t/**\n\t * One anchor per instantiation usage with a known holder scope.\n\t */\n\tprivate collectAnchors (usages: Map<string, UsageInfo[]>): CreationAnchor[] {\n\t\tconst anchors: CreationAnchor[] = [];\n\t\tfor (const [ typePath, usageList ] of usages) {\n\t\t\tfor (const usage of usageList) {\n\t\t\t\tif (usage.kind !== 'instantiation' || !usage.holderScopeId) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst holderScope = this.scopeAnalysis.scopes.get(usage.holderScopeId);\n\t\t\t\tif (!holderScope) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst anchor: CreationAnchor = {\n\t\t\t\t\tlocation      : usage.location,\n\t\t\t\t\tholderScopeId : usage.holderScopeId,\n\t\t\t\t\ttypePath,\n\t\t\t\t};\n\t\t\t\tif (usage.constructorText) {\n\t\t\t\t\tanchor.constructorText = usage.constructorText;\n\t\t\t\t}\n\t\t\t\tif (holderScope.kind === 'module') {\n\t\t\t\t\t// Plan: module-scope creation is a rooted instance —\n\t\t\t\t\t// legitimate root or developer error; labeled, not policed\n\t\t\t\t\tanchor.rooted = true;\n\t\t\t\t}\n\t\t\t\tconst variable = this.matchAnchorVariable(usage, typePath, holderScope);\n\t\t\t\tif (variable) {\n\t\t\t\t\tanchor.variable = variable.name;\n\t\t\t\t\tconst [ terminatedAt ] = variable.reassignments;\n\t\t\t\t\tif (terminatedAt) {\n\t\t\t\t\t\tanchor.terminatedAt = terminatedAt;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tanchors.push(anchor);\n\t\t\t}\n\t\t}\n\t\treturn anchors;\n\t}\n\n\t/**\n\t * Same-line heuristic for the anchor's variable: the variable declared in\n\t * the holder scope on the same line as the creation, whose typePath (when\n\t * known) matches the created type.\n\t */\n\tprivate matchAnchorVariable (\n\t\tusage: UsageInfo,\n\t\ttypePath: string,\n\t\tholderScope: ScopeInfo\n\t): ScopeVariable | undefined {\n\t\tconst usageLine = CreationGraphBuilder.lineOf(usage.location);\n\t\tif (usageLine === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\tfor (const variable of this.scopeAnalysis.variables.values()) {\n\t\t\tif (variable.scopeId !== holderScope.scopeId) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (CreationGraphBuilder.lineOf(variable.declaration) !== usageLine) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (variable.typePath && variable.typePath !== typePath) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\treturn variable;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Parse the 1-based line out of a file.ts:Line:Col location string.\n\t */\n\tprivate static lineOf (location: string): number | undefined {\n\t\tconst lastColon = location.lastIndexOf(':');\n\t\tconst prevColon = location.lastIndexOf(':', lastColon - 1);\n\t\tif (lastColon < 0 || prevColon < 0) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst line = Number(location.slice(prevColon + 1, lastColon));\n\t\tconst result = Number.isFinite(line) ? line : undefined;\n\t\treturn result;\n\t}\n\n\tprivate static nodeOf (scope: ScopeInfo): CreationGraphNode {\n\t\tconst node: CreationGraphNode = {\n\t\t\tscopeId  : scope.scopeId,\n\t\t\tname     : scope.name,\n\t\t\tkind     : scope.kind,\n\t\t\tfilePath : scope.filePath,\n\t\t\tlocation : scope.location,\n\t\t\tstarter  : false,\n\t\t};\n\t\treturn node;\n\t}\n\n\t/**\n\t * The name a scope is reachable by: functions/arrows take their scope\n\t * name; methods take their class (the part before '.') — that is what\n\t * callers reference. Anonymous holders (file:line labels) and module\n\t * scopes have no binding name.\n\t */\n\tprivate static bindingNameOf (scope: ScopeInfo): string | undefined {\n\t\tif (scope.kind === 'module') {\n\t\t\treturn undefined;\n\t\t}\n\t\t// Anonymous label is `${filePath}:${line}` — a name can never contain '/'\n\t\tif (scope.name.startsWith(`${scope.filePath}:`)) {\n\t\t\treturn undefined;\n\t\t}\n\t\tif (scope.kind === 'method') {\n\t\t\tconst dotIndex = scope.name.indexOf('.');\n\t\t\tif (dotIndex < 0) {\n\t\t\t\t// Method of an anonymous class — no binding name\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst result = scope.name.slice(0, dotIndex);\n\t\t\treturn result;\n\t\t}\n\t\treturn scope.name;\n\t}\n\n\t/**\n\t * Scope ids referencing `bindingName` inside one file (invocations,\n\t * pass-as-arg, rebindings — any non-declaration identifier).\n\t */\n\tprivate callersOf (filePath: string, bindingName: string): string[] {\n\t\tconst references = this.referencesIn(filePath, bindingName);\n\t\tconst callers: string[] = [];\n\t\tfor (const location of references) {\n\t\t\tconst callerScopeId = this.scopeWalker.findHolderScopeId(location);\n\t\t\tif (callerScopeId) {\n\t\t\t\tcallers.push(callerScopeId);\n\t\t\t}\n\t\t}\n\t\treturn callers;\n\t}\n\n\t/**\n\t * Callers in OTHER modules, followed through the module graph when the\n\t * holder's binding is exported (the plan's \"if f is exported\" branch,\n\t * including the barrel chase).\n\t */\n\tprivate findCrossFileCallers (scope: ScopeInfo, bindingName: string): string[] {\n\t\tconst holderModule = this.moduleGraph.modules.get(scope.filePath);\n\t\tif (!holderModule) {\n\t\t\treturn [];\n\t\t}\n\t\t// The exported binding whose LOCAL name is the scope's binding name.\n\t\t// Plain exports present under their own name; `export { X as Y }` and\n\t\t// `export default X` carry the local name in importAlias.\n\t\tconst exported = holderModule.exportedBindings.find(binding =>\n\t\t\t!binding.isReExport && (binding.importAlias ?? binding.name) === bindingName);\n\t\tif (!exported) {\n\t\t\treturn [];\n\t\t}\n\n\t\tconst callers: string[] = [];\n\t\tfor (const importer of this.moduleGraph.modules.values()) {\n\t\t\tif (importer.filePath === scope.filePath) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tfor (const imported of importer.importedBindings) {\n\t\t\t\t// Re-exports create no local identifier to reference; external\n\t\t\t\t// packages (node_modules) are never walked\n\t\t\t\tif (imported.isReExport || imported.external) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst localName = this.importReferencesHolder(imported, exported, scope.filePath);\n\t\t\t\tif (!localName) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst importerCallers = this.callersOf(importer.filePath, localName);\n\t\t\t\tcallers.push(...importerCallers);\n\t\t\t}\n\t\t}\n\t\treturn callers;\n\t}\n\n\t/**\n\t * Modules importing bindings whose ORIGIN is `filePath` — the\n\t * exports-and-usage bridge for terminal module scopes. Any binding kind\n\t * counts (named, default, re-export): resolveImportOrigin chases barrels\n\t * to the declaring module; namespace imports and external packages never\n\t * resolve, so neither connects. Returned as module-scope scopeIds — a\n\t * module's scopeId IS its resolved filePath.\n\t */\n\tprivate importersOf (filePath: string): string[] {\n\t\tconst importers: string[] = [];\n\t\tfor (const importer of this.moduleGraph.modules.values()) {\n\t\t\tif (importer.filePath === filePath) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst depends = importer.importedBindings.some(imported => {\n\t\t\t\tconst origin = this.resolveImportOrigin(imported);\n\t\t\t\tconst result = origin !== undefined && origin.module.filePath === filePath;\n\t\t\t\treturn result;\n\t\t\t});\n\t\t\tif (depends) {\n\t\t\t\timporters.push(importer.filePath);\n\t\t\t}\n\t\t}\n\t\treturn importers;\n\t}\n\n\t/**\n\t * The local identifier an import binding presents for reference search,\n\t * when the binding resolves to the holder's export — undefined otherwise.\n\t */\n\tprivate importReferencesHolder (\n\t\timported: ModuleBinding,\n\t\tholderExport: ModuleBinding,\n\t\tholderFilePath: string\n\t): string | undefined {\n\t\tif (imported.importKind === 'namespace') {\n\t\t\t// Namespace approximation: when the alias's source module exposes\n\t\t\t// the holder's export, any reference to the alias counts\n\t\t\tconst exposes = this.namespaceExposes(imported.sourceModule, holderExport.name, holderFilePath);\n\t\t\tconst result = exposes ? imported.name : undefined;\n\t\t\treturn result;\n\t\t}\n\t\tconst origin = this.resolveImportOrigin(imported);\n\t\tif (!origin) {\n\t\t\treturn undefined;\n\t\t}\n\t\tif (origin.module.filePath !== holderFilePath || origin.binding.name !== holderExport.name) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn imported.name;\n\t}\n\n\t/**\n\t * True when a namespace import's source module exposes `exportedName`\n\t * whose origin is the holder's module. Expressed as resolving a synthetic\n\t * named binding, so star barrels and named re-exports are chased by the\n\t * same machinery as plain imports.\n\t */\n\tprivate namespaceExposes (sourceModule: string, exportedName: string, holderFilePath: string): boolean {\n\t\tconst synthetic: ModuleBinding = {\n\t\t\tname       : exportedName,\n\t\t\tkind       : 'unknown',\n\t\t\tsourceModule,\n\t\t\tisReExport : true,\n\t\t};\n\t\tconst origin = this.resolveImportOrigin(synthetic);\n\t\tif (!origin) {\n\t\t\treturn false;\n\t\t}\n\t\tconst result = origin.module.filePath === holderFilePath && origin.binding.name === exportedName;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Chase an import binding to the module that actually declares it,\n\t * following re-export chains (barrels). Same shape as\n\t * ModuleGraphBuilder.resolveOrigin, run here over the BUILT graph\n\t * (sourceModule values are already resolved absolute paths).\n\t * Cycle-guarded; undefined when the origin is external or the chain loops.\n\t */\n\tprivate resolveImportOrigin (\n\t\tbinding: ModuleBinding,\n\t\tvisited = new Set<string>()\n\t): { module: ModuleInfo; binding: ModuleBinding } | undefined {\n\t\tconst sourcePath = path.resolve(binding.sourceModule);\n\t\tif (visited.has(sourcePath)) {\n\t\t\treturn undefined;\n\t\t}\n\t\tvisited.add(sourcePath);\n\n\t\tconst sourceModuleInfo = this.moduleGraph.modules.get(sourcePath);\n\t\tif (!sourceModuleInfo) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// The name to look up in the source module's export list\n\t\tconst lookupKey = binding.importKind === 'default'\n\t\t\t? 'default'\n\t\t\t: binding.importAlias ?? binding.name;\n\n\t\tfor (const exported of sourceModuleInfo.exportedBindings) {\n\t\t\tif (exported.name !== lookupKey) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (!exported.isReExport) {\n\t\t\t\tconst result = { module : sourceModuleInfo, binding : exported };\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\tconst chased = this.resolveImportOrigin(exported, visited);\n\t\t\treturn chased;\n\t\t}\n\n\t\t// `export * from './y'` barrels: the name may live behind a star\n\t\tfor (const exported of sourceModuleInfo.exportedBindings) {\n\t\t\tif (!exported.isReExport || exported.importKind !== 'namespace' || exported.name !== '*') {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst chased = this.resolveImportOrigin({\n\t\t\t\tname         : lookupKey,\n\t\t\t\tkind         : 'unknown',\n\t\t\t\tsourceModule : exported.sourceModule,\n\t\t\t\tisReExport   : true,\n\t\t\t}, visited);\n\t\t\tif (chased) {\n\t\t\t\treturn chased;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * All references to `name` in a file as location strings. The per-file\n\t * index is built lazily in ONE pass (every identifier bucketed by text)\n\t * and cached.\n\t */\n\tprivate referencesIn (filePath: string, name: string): string[] {\n\t\tlet byName = this.referencesByFile.get(filePath);\n\t\tif (!byName) {\n\t\t\tbyName = new Map<string, string[]>();\n\t\t\tconst sourceFile = this.sourceFiles.get(filePath);\n\t\t\tif (sourceFile) {\n\t\t\t\tCreationGraphBuilder.collectReferences(sourceFile, byName);\n\t\t\t}\n\t\t\tthis.referencesByFile.set(filePath, byName);\n\t\t}\n\t\tconst result = byName.get(name) ?? [];\n\t\treturn result;\n\t}\n\n\t/**\n\t * Bucket every identifier reference by name. Declaration and wiring\n\t * positions are NOT references: import/export specifiers, declaration\n\t * names, property-access `.name`, and property-assignment keys go into a\n\t * skip set of NODES — program files can be unbound, so parent-pointer\n\t * checks are impossible (the scopes walker precedent, Phase 2).\n\t * ShorthandPropertyAssignment names DO count: `{ foo }` is a genuine\n\t * reference to foo.\n\t */\n\tprivate static collectReferences (sourceFile: ts.SourceFile, byName: Map<string, string[]>): void {\n\t\tconst skip = new Set<ts.Node>();\n\t\tconst filePath = path.resolve(sourceFile.fileName);\n\n\t\tconst visit = (node: ts.Node): void => {\n\t\t\tCreationGraphBuilder.registerSkips(node, skip);\n\t\t\tif (ts.isIdentifier(node) && !skip.has(node)) {\n\t\t\t\tconst list = byName.get(node.text) ?? [];\n\t\t\t\tif (list.length === 0) {\n\t\t\t\t\tbyName.set(node.text, list);\n\t\t\t\t}\n\t\t\t\tconst { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));\n\t\t\t\tlist.push(`${filePath}:${line + 1}:${character + 1}`);\n\t\t\t}\n\t\t\tts.forEachChild(node, visit);\n\t\t};\n\t\tvisit(sourceFile);\n\t}\n\n\t/**\n\t * Register the identifier nodes that must NOT count as references when\n\t * `node` is a wiring/declaration construct. Runs on the parent before\n\t * descending, so the skip set is populated before the identifier nodes\n\t * themselves are visited.\n\t */\n\tprivate static registerSkips (node: ts.Node, skip: Set<ts.Node>): void {\n\t\t// import … from './x'\n\t\tif (ts.isImportDeclaration(node)) {\n\t\t\tconst { importClause } = node;\n\t\t\tif (!importClause) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (importClause.name) {\n\t\t\t\tskip.add(importClause.name);\n\t\t\t}\n\t\t\tconst { namedBindings } = importClause;\n\t\t\tif (namedBindings && ts.isNamedImports(namedBindings)) {\n\t\t\t\tfor (const element of namedBindings.elements) {\n\t\t\t\t\tif (element.propertyName) {\n\t\t\t\t\t\tskip.add(element.propertyName);\n\t\t\t\t\t}\n\t\t\t\t\tskip.add(element.name);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (namedBindings && ts.isNamespaceImport(namedBindings)) {\n\t\t\t\tskip.add(namedBindings.name);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\t// import x = require('./y')\n\t\tif (ts.isImportEqualsDeclaration(node)) {\n\t\t\tskip.add(node.name);\n\t\t\treturn;\n\t\t}\n\t\t// export { X } [from './y'] / export * as ns from './y' — export wiring\n\t\t// alone is not a caller; an importer's usage creates the edge instead\n\t\tif (ts.isExportDeclaration(node)) {\n\t\t\tconst { exportClause } = node;\n\t\t\tif (exportClause && ts.isNamedExports(exportClause)) {\n\t\t\t\tfor (const element of exportClause.elements) {\n\t\t\t\t\tif (element.propertyName) {\n\t\t\t\t\t\tskip.add(element.propertyName);\n\t\t\t\t\t}\n\t\t\t\t\tskip.add(element.name);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (exportClause && ts.isNamespaceExport(exportClause)) {\n\t\t\t\tskip.add(exportClause.name);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\t// export default foo — same export-wiring rule\n\t\tif (ts.isExportAssignment(node) && ts.isIdentifier(node.expression)) {\n\t\t\tskip.add(node.expression);\n\t\t\treturn;\n\t\t}\n\t\t// obj.name — the `.name` part is property wiring, not a reference\n\t\tif (ts.isPropertyAccessExpression(node)) {\n\t\t\tskip.add(node.name);\n\t\t\treturn;\n\t\t}\n\t\t// { name: value } — the key is not a reference. Shorthand `{ name }`\n\t\t// IS a reference: ShorthandPropertyAssignment never matches here.\n\t\tif (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {\n\t\t\tskip.add(node.name);\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isShorthandPropertyAssignment(node)) {\n\t\t\treturn;\n\t\t}\n\t\t// { x: a } destructuring — `x` is property wiring (`a` is the declared\n\t\t// name, skipped by the generic declaration branch below)\n\t\tif (ts.isBindingElement(node) && node.propertyName && ts.isIdentifier(node.propertyName)) {\n\t\t\tskip.add(node.propertyName);\n\t\t}\n\t\t// Declaration names: `function f`, `class C`, `const x`, parameters,\n\t\t// methods, enum members… — being declared is not being referenced\n\t\tconst named = node as ts.NamedDeclaration;\n\t\tif ('name' in node && named.name && ts.isIdentifier(named.name)) {\n\t\t\tskip.add(named.name);\n\t\t}\n\t}\n}\n"]}