@mnemonica/tactica 0.1.14 → 0.2.0

package/lib/module-graph.js

@@ -0,0 +1,690 @@
+'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.ModuleGraphBuilder = void 0;
+const module_1 = require("module");
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+// Bare builtin names from node:module; both 'path' and 'node:path' accepted
+const BUILTIN_MODULES = new Set(module_1.builtinModules);
+/**
+ * Module-scope walker (instrumentation walker plan, Phase 1).
+ *
+ * Builds the cross-file module graph: every export/import binding (functions,
+ * classes, consts, types — not only mnemonica types), resolved with
+ * `ts.resolveModuleName` driven by the program's compilerOptions (tsconfig
+ * `paths`, extensionless imports, index files). This is module resolution,
+ * NOT the type checker — the no-`getTypeChecker()` precedent stays intact.
+ *
+ * Usage: addFile() per source file during the definitions pass, then
+ * build(definedTypesByFile) once definitions are known.
+ */
+class ModuleGraphBuilder {
+    constructor(program, compilerOptions) {
+        this.modules = new Map();
+        // filePath -> (local name -> kind) for every named top-level declaration
+        this.localDecls = new Map();
+        // filePath -> import/export specifier sites, for build()-time resolution
+        this.importSites = new Map();
+        // `${filePath}\n${specifier}` -> resolution (undefined = failed)
+        this.resolutionCache = new Map();
+        const options = compilerOptions ?? program?.getCompilerOptions() ?? {};
+        this.compilerOptions = options;
+    }
+    /**
+     * Track one source file. Re-adding the same file replaces its record,
+     * so a builder may safely be reused across passes.
+     */
+    addFile(sourceFile) {
+        const filePath = path.resolve(sourceFile.fileName);
+        const moduleInfo = {
+            filePath,
+            definedTypes: [],
+            exportedBindings: [],
+            importedBindings: [],
+            dependencies: [],
+            unresolvedSpecifiers: [],
+            builtinSpecifiers: [],
+        };
+        const decls = new Map();
+        const sites = [];
+        this.modules.set(filePath, moduleInfo);
+        this.localDecls.set(filePath, decls);
+        this.importSites.set(filePath, sites);
+        // Pass 1: collect every named top-level declaration, so later
+        // `export { X }` statements can be classified regardless of order
+        for (const statement of sourceFile.statements) {
+            this.collectLocalDecl(statement, decls);
+        }
+        // Pass 2: process imports, exports, and exported declarations
+        for (const statement of sourceFile.statements) {
+            this.processStatement(statement, sourceFile, moduleInfo, decls, sites);
+        }
+        return moduleInfo;
+    }
+    /**
+     * Resolve all specifiers, backfill binding kinds from origin modules,
+     * derive dependencies, cross-module mnemonica-type edges, and cycles.
+     * `definedTypesByFile` maps absolute file path -> mnemonica type fullPaths
+     * defined there (from the analyzer's definitions).
+     */
+    build(definedTypesByFile) {
+        if (definedTypesByFile) {
+            for (const [file, types] of definedTypesByFile) {
+                const moduleInfo = this.modules.get(path.resolve(file));
+                if (moduleInfo) {
+                    moduleInfo.definedTypes = types;
+                }
+            }
+        }
+        // Resolution pass: rewrite sourceModule to the resolved absolute path
+        for (const [filePath, sites] of this.importSites) {
+            const moduleInfo = this.modules.get(filePath);
+            if (!moduleInfo) {
+                continue;
+            }
+            for (const site of sites) {
+                const resolution = this.resolveModule(site.specifier, filePath);
+                if (!resolution?.resolvedPath) {
+                    if (!moduleInfo.unresolvedSpecifiers.includes(site.specifier)) {
+                        moduleInfo.unresolvedSpecifiers.push(site.specifier);
+                    }
+                    continue;
+                }
+                const { resolvedPath, isExternal } = resolution;
+                for (const binding of site.bindings) {
+                    binding.sourceModule = resolvedPath;
+                    if (isExternal) {
+                        binding.external = true;
+                    }
+                }
+                // Dependencies stay project-internal: external (node_modules)
+                // modules are never addFile()'d, so modules.has() gates them out
+                if (this.modules.has(resolvedPath) && !moduleInfo.dependencies.includes(resolvedPath)) {
+                    moduleInfo.dependencies.push(resolvedPath);
+                }
+            }
+        }
+        // Kind backfill + edge collection
+        const edges = [];
+        for (const [filePath, sites] of this.importSites) {
+            const moduleInfo = this.modules.get(filePath);
+            if (!moduleInfo) {
+                continue;
+            }
+            for (const site of sites) {
+                for (const binding of site.bindings) {
+                    const origin = this.resolveOrigin(binding);
+                    if (origin && binding.kind === 'unknown') {
+                        binding.kind = origin.binding.kind;
+                    }
+                    if (!origin || origin.module.filePath === filePath) {
+                        continue;
+                    }
+                    const typePath = this.matchDefinedType(origin.module, binding);
+                    if (typePath) {
+                        edges.push({
+                            typePath,
+                            definitionModule: origin.module.filePath,
+                            usageModule: filePath,
+                            usageLocation: site.location,
+                        });
+                    }
+                }
+            }
+        }
+        const cycles = this.detectCycles();
+        const graph = {
+            modules: this.modules,
+            edges,
+            cycles,
+        };
+        return graph;
+    }
+    /**
+     * Resolve a specifier to an absolute file path via ts.resolveModuleName
+     * with the program's compilerOptions. Returns undefined on failure.
+     */
+    resolveModule(specifier, fromFile) {
+        const cacheKey = `${fromFile}\n${specifier}`;
+        if (this.resolutionCache.has(cacheKey)) {
+            const cached = this.resolutionCache.get(cacheKey);
+            return cached;
+        }
+        const result = ts.resolveModuleName(specifier, fromFile, this.compilerOptions, ts.sys);
+        const resolution = result.resolvedModule
+            ? {
+                resolvedPath: path.resolve(result.resolvedModule.resolvedFileName),
+                isExternal: result.resolvedModule.isExternalLibraryImport === true,
+            }
+            : undefined;
+        this.resolutionCache.set(cacheKey, resolution);
+        return resolution;
+    }
+    /**
+     * True for Node.js builtins in both bare and `node:`-prefixed forms
+     * ('path', 'node:path', 'fs/promises', 'node:fs/promises', …).
+     */
+    static isBuiltinSpecifier(specifier) {
+        const bare = specifier.startsWith('node:') ? specifier.slice('node:'.length) : specifier;
+        const result = BUILTIN_MODULES.has(bare);
+        return result;
+    }
+    /**
+     * Record a builtin import on the module (honesty marker) and skip it
+     * entirely: no bindings, no site, no dependency, no edge.
+     * Returns true when the specifier was a builtin (caller must return early).
+     */
+    static skipBuiltin(moduleInfo, specifier) {
+        if (!ModuleGraphBuilder.isBuiltinSpecifier(specifier)) {
+            return false;
+        }
+        if (!moduleInfo.builtinSpecifiers.includes(specifier)) {
+            moduleInfo.builtinSpecifiers.push(specifier);
+        }
+        return true;
+    }
+    /**
+     * Chase a binding to the module that actually declares it, following
+     * re-export chains (barrels). Cycle-guarded. Returns undefined when the
+     * origin is external or the chain loops.
+     */
+    resolveOrigin(binding, visited = new Set()) {
+        const sourcePath = path.resolve(binding.sourceModule);
+        if (visited.has(sourcePath)) {
+            return undefined;
+        }
+        visited.add(sourcePath);
+        const sourceModuleInfo = this.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.resolveOrigin(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.resolveOrigin({
+                name: lookupKey,
+                kind: 'unknown',
+                sourceModule: exported.sourceModule,
+                isReExport: true,
+            }, visited);
+            if (chased) {
+                return chased;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Match a binding against a module's defined mnemonica types.
+     * Returns the matched fullPath, or undefined when the binding is not a
+     * mnemonica type of that module.
+     */
+    matchDefinedType(moduleInfo, binding) {
+        const candidate = binding.importAlias ?? binding.name;
+        for (const definedType of moduleInfo.definedTypes) {
+            // Custom-collection types are keyed `collectionId::Path`
+            const bare = definedType.includes('::')
+                ? definedType.slice(definedType.indexOf('::') + 2)
+                : definedType;
+            if (bare === candidate || bare.startsWith(`${candidate}.`)) {
+                return definedType;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Three-color DFS over project-internal dependencies. Cycles are recorded
+     * (mnemonica strictChain:false permits non-linear construction), never
+     * treated as errors.
+     */
+    detectCycles() {
+        const cycles = [];
+        const seenCycles = new Set();
+        // 1 = on the current stack, 2 = fully explored
+        const state = new Map();
+        const visit = (filePath, stack) => {
+            state.set(filePath, 1);
+            stack.push(filePath);
+            const moduleInfo = this.modules.get(filePath);
+            for (const dep of moduleInfo?.dependencies ?? []) {
+                if (state.get(dep) === 1) {
+                    const cycle = stack.slice(stack.indexOf(dep));
+                    const key = ModuleGraphBuilder.cycleKey(cycle);
+                    if (!seenCycles.has(key)) {
+                        seenCycles.add(key);
+                        cycles.push(cycle);
+                    }
+                    continue;
+                }
+                if (!state.get(dep)) {
+                    visit(dep, stack);
+                }
+            }
+            stack.pop();
+            state.set(filePath, 2);
+        };
+        for (const filePath of this.modules.keys()) {
+            if (!state.get(filePath)) {
+                visit(filePath, []);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * Rotation-independent cycle key: smallest path first.
+     */
+    static cycleKey(cycle) {
+        let minIndex = 0;
+        for (let i = 1; i < cycle.length; i++) {
+            if (cycle[i] < cycle[minIndex]) {
+                minIndex = i;
+            }
+        }
+        const rotated = cycle.slice(minIndex).concat(cycle.slice(0, minIndex));
+        const key = rotated.join('\n');
+        return key;
+    }
+    /**
+     * Pass 1: record every named top-level declaration's kind.
+     */
+    collectLocalDecl(statement, decls) {
+        if (ts.isFunctionDeclaration(statement) && statement.name) {
+            decls.set(statement.name.text, 'function');
+            return;
+        }
+        if (ts.isClassDeclaration(statement) && statement.name) {
+            decls.set(statement.name.text, 'class');
+            return;
+        }
+        if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+            decls.set(statement.name.text, 'type');
+            return;
+        }
+        if (ts.isEnumDeclaration(statement)) {
+            decls.set(statement.name.text, 'type');
+            return;
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    decls.set(decl.name.text, ModuleGraphBuilder.variableKind(decl));
+                }
+            }
+        }
+    }
+    /**
+     * Classify a variable declaration: arrow/function initializers are
+     * 'function' (holder functions the walker follows), class expressions
+     * are 'class', everything else is 'const'.
+     */
+    static variableKind(decl) {
+        const { initializer } = decl;
+        if (initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))) {
+            return 'function';
+        }
+        if (initializer && ts.isClassExpression(initializer)) {
+            return 'class';
+        }
+        return 'const';
+    }
+    /**
+     * Pass 2: imports, exports, requires, exported declarations.
+     */
+    processStatement(statement, sourceFile, moduleInfo, decls, sites) {
+        if (ts.isImportDeclaration(statement)) {
+            this.processImport(statement, sourceFile, moduleInfo, sites);
+            return;
+        }
+        if (ts.isExportDeclaration(statement)) {
+            this.processExportDeclaration(statement, sourceFile, moduleInfo, decls, sites);
+            return;
+        }
+        if (ts.isImportEqualsDeclaration(statement)) {
+            this.processImportEquals(statement, sourceFile, moduleInfo, sites);
+            return;
+        }
+        if (ts.isExportAssignment(statement)) {
+            this.processExportAssignment(statement, moduleInfo, decls);
+            return;
+        }
+        this.processMaybeExportedDecl(statement, moduleInfo, decls);
+        this.processRequireCall(statement, sourceFile, moduleInfo, sites);
+    }
+    processImport(importDecl, sourceFile, moduleInfo, sites) {
+        const { moduleSpecifier } = importDecl;
+        if (!ts.isStringLiteral(moduleSpecifier)) {
+            return;
+        }
+        if (ModuleGraphBuilder.skipBuiltin(moduleInfo, moduleSpecifier.text)) {
+            return;
+        }
+        const site = {
+            specifier: moduleSpecifier.text,
+            location: this.locationOf(moduleSpecifier, sourceFile),
+            bindings: [],
+        };
+        sites.push(site);
+        const { importClause } = importDecl;
+        if (!importClause) {
+            // Side-effect import: dependency only, no bindings
+            return;
+        }
+        // Default import: import Type from './module'
+        if (importClause.name) {
+            const binding = {
+                name: importClause.name.text,
+                kind: 'unknown',
+                sourceModule: site.specifier,
+                importKind: 'default',
+                isReExport: false,
+            };
+            moduleInfo.importedBindings.push(binding);
+            site.bindings.push(binding);
+        }
+        const { namedBindings } = importClause;
+        if (namedBindings && ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+                const originalName = element.propertyName?.text;
+                const binding = {
+                    name: element.name.text,
+                    kind: 'unknown',
+                    sourceModule: site.specifier,
+                    importKind: 'named',
+                    isReExport: false,
+                };
+                if (originalName) {
+                    binding.importAlias = originalName;
+                }
+                moduleInfo.importedBindings.push(binding);
+                site.bindings.push(binding);
+            }
+            return;
+        }
+        // Namespace import: import * as Types from './module'
+        if (namedBindings && ts.isNamespaceImport(namedBindings)) {
+            const binding = {
+                name: namedBindings.name.text,
+                kind: 'unknown',
+                sourceModule: site.specifier,
+                importKind: 'namespace',
+                isReExport: false,
+            };
+            moduleInfo.importedBindings.push(binding);
+            site.bindings.push(binding);
+        }
+    }
+    processExportDeclaration(exportDecl, sourceFile, moduleInfo, decls, sites) {
+        const { moduleSpecifier } = exportDecl;
+        const { exportClause } = exportDecl;
+        // Re-export forms carry a module specifier: `export … from './y'`
+        if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+            if (ModuleGraphBuilder.skipBuiltin(moduleInfo, moduleSpecifier.text)) {
+                return;
+            }
+            const site = {
+                specifier: moduleSpecifier.text,
+                location: this.locationOf(moduleSpecifier, sourceFile),
+                bindings: [],
+            };
+            sites.push(site);
+            if (!exportClause) {
+                // `export * from './y'`
+                const binding = {
+                    name: '*',
+                    kind: 'unknown',
+                    sourceModule: site.specifier,
+                    importKind: 'namespace',
+                    isReExport: true,
+                };
+                moduleInfo.exportedBindings.push(binding);
+                moduleInfo.importedBindings.push(binding);
+                site.bindings.push(binding);
+                return;
+            }
+            if (ts.isNamespaceExport(exportClause)) {
+                // `export * as ns from './y'`
+                const binding = {
+                    name: exportClause.name.text,
+                    kind: 'unknown',
+                    sourceModule: site.specifier,
+                    importKind: 'namespace',
+                    isReExport: true,
+                };
+                moduleInfo.exportedBindings.push(binding);
+                moduleInfo.importedBindings.push(binding);
+                site.bindings.push(binding);
+                return;
+            }
+            // `export { X, Y as Z } from './y'`
+            for (const element of exportClause.elements) {
+                const originalName = element.propertyName?.text;
+                const binding = {
+                    name: element.name.text,
+                    kind: 'unknown',
+                    sourceModule: site.specifier,
+                    importKind: 'named',
+                    isReExport: true,
+                };
+                if (originalName) {
+                    binding.importAlias = originalName;
+                }
+                moduleInfo.exportedBindings.push(binding);
+                moduleInfo.importedBindings.push(binding);
+                site.bindings.push(binding);
+            }
+            return;
+        }
+        // Plain `export { X, Y as Z }` — local declarations
+        if (exportClause && ts.isNamedExports(exportClause)) {
+            for (const element of exportClause.elements) {
+                const originalName = element.propertyName?.text ?? element.name.text;
+                const binding = {
+                    name: element.name.text,
+                    kind: decls.get(originalName) ?? 'unknown',
+                    sourceModule: moduleInfo.filePath,
+                    isReExport: false,
+                };
+                if (element.propertyName) {
+                    binding.importAlias = element.propertyName.text;
+                }
+                moduleInfo.exportedBindings.push(binding);
+            }
+        }
+    }
+    /**
+     * `import foo = require('./y')`
+     */
+    processImportEquals(importDecl, sourceFile, moduleInfo, sites) {
+        const { moduleReference } = importDecl;
+        if (!ts.isExternalModuleReference(moduleReference)) {
+            return;
+        }
+        const { expression } = moduleReference;
+        if (!ts.isStringLiteral(expression)) {
+            return;
+        }
+        if (ModuleGraphBuilder.skipBuiltin(moduleInfo, expression.text)) {
+            return;
+        }
+        const binding = {
+            name: importDecl.name.text,
+            kind: 'unknown',
+            sourceModule: expression.text,
+            importKind: 'require',
+            isReExport: false,
+        };
+        moduleInfo.importedBindings.push(binding);
+        sites.push({
+            specifier: expression.text,
+            location: this.locationOf(expression, sourceFile),
+            bindings: [binding],
+        });
+    }
+    /**
+     * `export default <expression>`
+     */
+    processExportAssignment(statement, moduleInfo, decls) {
+        const { expression } = statement;
+        const kind = ts.isIdentifier(expression)
+            ? decls.get(expression.text) ?? 'unknown'
+            : 'unknown';
+        const binding = {
+            name: 'default',
+            kind,
+            sourceModule: moduleInfo.filePath,
+            importKind: 'default',
+            isReExport: false,
+        };
+        if (ts.isIdentifier(expression)) {
+            binding.importAlias = expression.text;
+        }
+        moduleInfo.exportedBindings.push(binding);
+    }
+    /**
+     * `export function/class/const/interface/type …` declarations.
+     */
+    processMaybeExportedDecl(statement, moduleInfo, decls) {
+        const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+        const hasExport = modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        const hasDefault = modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+        if (!hasExport) {
+            return;
+        }
+        const addExport = (localName, kind) => {
+            const binding = {
+                name: hasDefault ? 'default' : localName ?? 'default',
+                kind,
+                sourceModule: moduleInfo.filePath,
+                isReExport: false,
+            };
+            if (hasDefault) {
+                binding.importKind = 'default';
+                if (localName) {
+                    binding.importAlias = localName;
+                }
+            }
+            moduleInfo.exportedBindings.push(binding);
+        };
+        if (ts.isFunctionDeclaration(statement)) {
+            addExport(statement.name?.text, 'function');
+            return;
+        }
+        if (ts.isClassDeclaration(statement)) {
+            addExport(statement.name?.text, 'class');
+            return;
+        }
+        if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+            addExport(statement.name.text, 'type');
+            return;
+        }
+        if (ts.isEnumDeclaration(statement)) {
+            addExport(statement.name.text, 'type');
+            return;
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    addExport(decl.name.text, decls.get(decl.name.text) ?? 'const');
+                }
+            }
+        }
+    }
+    /**
+     * CommonJS `const x = require('./y')` (JS sources with allowJs).
+     */
+    processRequireCall(statement, sourceFile, moduleInfo, sites) {
+        if (!ts.isVariableStatement(statement)) {
+            return;
+        }
+        for (const decl of statement.declarationList.declarations) {
+            const { initializer } = decl;
+            if (!initializer || !ts.isCallExpression(initializer)) {
+                continue;
+            }
+            if (!ts.isIdentifier(initializer.expression) || initializer.expression.text !== 'require') {
+                continue;
+            }
+            const [firstArg] = initializer.arguments;
+            if (!firstArg || !ts.isStringLiteral(firstArg)) {
+                continue;
+            }
+            if (ModuleGraphBuilder.skipBuiltin(moduleInfo, firstArg.text)) {
+                continue;
+            }
+            const localName = ts.isIdentifier(decl.name) ? decl.name.text : decl.name.getText();
+            const binding = {
+                name: localName,
+                kind: 'unknown',
+                sourceModule: firstArg.text,
+                importKind: 'require',
+                isReExport: false,
+            };
+            moduleInfo.importedBindings.push(binding);
+            sites.push({
+                specifier: firstArg.text,
+                location: this.locationOf(firstArg, sourceFile),
+                bindings: [binding],
+            });
+        }
+    }
+    /**
+     * Format a node's position as file.ts:Line:Col (1-based), matching the
+     * location format of the other .tactica outputs.
+     */
+    locationOf(node, sourceFile) {
+        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const location = `${path.resolve(sourceFile.fileName)}:${position.line + 1}:${position.character + 1}`;
+        return location;
+    }
+}
+exports.ModuleGraphBuilder = ModuleGraphBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module-graph.js","sourceRoot":"","sources":["../src/module-graph.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport { builtinModules } from 'module';\nimport * as path from 'path';\nimport * as ts from 'typescript';\nimport {\n\tModuleBinding, ModuleBindingKind, ModuleGraph, ModuleInfo, CrossModuleUsage\n} from './types';\n\n/**\n * Internal record of one import/export site: the specifier as written, its\n * location, and the binding objects it produced (shared by reference with\n * ModuleInfo, so build()-time resolution rewrites them in place).\n */\ninterface ImportSite {\n\tspecifier: string;\n\tlocation: string;\n\tbindings: ModuleBinding[];\n}\n\n/**\n * Result of resolving one specifier: the absolute path (undefined when\n * unresolvable) and whether it landed in node_modules.\n */\ninterface ModuleResolution {\n\tresolvedPath?: string;\n\tisExternal: boolean;\n}\n\n// Bare builtin names from node:module; both 'path' and 'node:path' accepted\nconst BUILTIN_MODULES = new Set(builtinModules);\n\n/**\n * Module-scope walker (instrumentation walker plan, Phase 1).\n *\n * Builds the cross-file module graph: every export/import binding (functions,\n * classes, consts, types — not only mnemonica types), resolved with\n * `ts.resolveModuleName` driven by the program's compilerOptions (tsconfig\n * `paths`, extensionless imports, index files). This is module resolution,\n * NOT the type checker — the no-`getTypeChecker()` precedent stays intact.\n *\n * Usage: addFile() per source file during the definitions pass, then\n * build(definedTypesByFile) once definitions are known.\n */\nexport class ModuleGraphBuilder {\n\tprivate compilerOptions: ts.CompilerOptions;\n\tprivate modules = new Map<string, ModuleInfo>();\n\t// filePath -> (local name -> kind) for every named top-level declaration\n\tprivate localDecls = new Map<string, Map<string, ModuleBindingKind>>();\n\t// filePath -> import/export specifier sites, for build()-time resolution\n\tprivate importSites = new Map<string, ImportSite[]>();\n\t// `${filePath}\\n${specifier}` -> resolution (undefined = failed)\n\tprivate resolutionCache = new Map<string, ModuleResolution | undefined>();\n\n\tconstructor (program?: ts.Program, compilerOptions?: ts.CompilerOptions) {\n\t\tconst options = compilerOptions ?? program?.getCompilerOptions() ?? {};\n\t\tthis.compilerOptions = options;\n\t}\n\n\t/**\n\t * Track one source file. Re-adding the same file replaces its record,\n\t * so a builder may safely be reused across passes.\n\t */\n\taddFile (sourceFile: ts.SourceFile): ModuleInfo {\n\t\tconst filePath = path.resolve(sourceFile.fileName);\n\n\t\tconst moduleInfo: ModuleInfo = {\n\t\t\tfilePath,\n\t\t\tdefinedTypes         : [],\n\t\t\texportedBindings     : [],\n\t\t\timportedBindings     : [],\n\t\t\tdependencies         : [],\n\t\t\tunresolvedSpecifiers : [],\n\t\t\tbuiltinSpecifiers    : [],\n\t\t};\n\t\tconst decls = new Map<string, ModuleBindingKind>();\n\t\tconst sites: ImportSite[] = [];\n\n\t\tthis.modules.set(filePath, moduleInfo);\n\t\tthis.localDecls.set(filePath, decls);\n\t\tthis.importSites.set(filePath, sites);\n\n\t\t// Pass 1: collect every named top-level declaration, so later\n\t\t// `export { X }` statements can be classified regardless of order\n\t\tfor (const statement of sourceFile.statements) {\n\t\t\tthis.collectLocalDecl(statement, decls);\n\t\t}\n\n\t\t// Pass 2: process imports, exports, and exported declarations\n\t\tfor (const statement of sourceFile.statements) {\n\t\t\tthis.processStatement(statement, sourceFile, moduleInfo, decls, sites);\n\t\t}\n\n\t\treturn moduleInfo;\n\t}\n\n\t/**\n\t * Resolve all specifiers, backfill binding kinds from origin modules,\n\t * derive dependencies, cross-module mnemonica-type edges, and cycles.\n\t * `definedTypesByFile` maps absolute file path -> mnemonica type fullPaths\n\t * defined there (from the analyzer's definitions).\n\t */\n\tbuild (definedTypesByFile?: Map<string, string[]>): ModuleGraph {\n\t\tif (definedTypesByFile) {\n\t\t\tfor (const [ file, types ] of definedTypesByFile) {\n\t\t\t\tconst moduleInfo = this.modules.get(path.resolve(file));\n\t\t\t\tif (moduleInfo) {\n\t\t\t\t\tmoduleInfo.definedTypes = types;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Resolution pass: rewrite sourceModule to the resolved absolute path\n\t\tfor (const [ filePath, sites ] of this.importSites) {\n\t\t\tconst moduleInfo = this.modules.get(filePath);\n\t\t\tif (!moduleInfo) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tfor (const site of sites) {\n\t\t\t\tconst resolution = this.resolveModule(site.specifier, filePath);\n\t\t\t\tif (!resolution?.resolvedPath) {\n\t\t\t\t\tif (!moduleInfo.unresolvedSpecifiers.includes(site.specifier)) {\n\t\t\t\t\t\tmoduleInfo.unresolvedSpecifiers.push(site.specifier);\n\t\t\t\t\t}\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst { resolvedPath, isExternal } = resolution;\n\t\t\t\tfor (const binding of site.bindings) {\n\t\t\t\t\tbinding.sourceModule = resolvedPath;\n\t\t\t\t\tif (isExternal) {\n\t\t\t\t\t\tbinding.external = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Dependencies stay project-internal: external (node_modules)\n\t\t\t\t// modules are never addFile()'d, so modules.has() gates them out\n\t\t\t\tif (this.modules.has(resolvedPath) && !moduleInfo.dependencies.includes(resolvedPath)) {\n\t\t\t\t\tmoduleInfo.dependencies.push(resolvedPath);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Kind backfill + edge collection\n\t\tconst edges: CrossModuleUsage[] = [];\n\t\tfor (const [ filePath, sites ] of this.importSites) {\n\t\t\tconst moduleInfo = this.modules.get(filePath);\n\t\t\tif (!moduleInfo) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tfor (const site of sites) {\n\t\t\t\tfor (const binding of site.bindings) {\n\t\t\t\t\tconst origin = this.resolveOrigin(binding);\n\t\t\t\t\tif (origin && binding.kind === 'unknown') {\n\t\t\t\t\t\tbinding.kind = origin.binding.kind;\n\t\t\t\t\t}\n\t\t\t\t\tif (!origin || origin.module.filePath === filePath) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst typePath = this.matchDefinedType(origin.module, binding);\n\t\t\t\t\tif (typePath) {\n\t\t\t\t\t\tedges.push({\n\t\t\t\t\t\t\ttypePath,\n\t\t\t\t\t\t\tdefinitionModule : origin.module.filePath,\n\t\t\t\t\t\t\tusageModule      : filePath,\n\t\t\t\t\t\t\tusageLocation    : site.location,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst cycles = this.detectCycles();\n\n\t\tconst graph: ModuleGraph = {\n\t\t\tmodules : this.modules,\n\t\t\tedges,\n\t\t\tcycles,\n\t\t};\n\t\treturn graph;\n\t}\n\n\t/**\n\t * Resolve a specifier to an absolute file path via ts.resolveModuleName\n\t * with the program's compilerOptions. Returns undefined on failure.\n\t */\n\tprivate resolveModule (specifier: string, fromFile: string): ModuleResolution | undefined {\n\t\tconst cacheKey = `${fromFile}\\n${specifier}`;\n\t\tif (this.resolutionCache.has(cacheKey)) {\n\t\t\tconst cached = this.resolutionCache.get(cacheKey);\n\t\t\treturn cached;\n\t\t}\n\n\t\tconst result = ts.resolveModuleName(specifier, fromFile, this.compilerOptions, ts.sys);\n\t\tconst resolution: ModuleResolution | undefined = result.resolvedModule\n\t\t\t? {\n\t\t\t\tresolvedPath : path.resolve(result.resolvedModule.resolvedFileName),\n\t\t\t\tisExternal   : result.resolvedModule.isExternalLibraryImport === true,\n\t\t\t}\n\t\t\t: undefined;\n\t\tthis.resolutionCache.set(cacheKey, resolution);\n\t\treturn resolution;\n\t}\n\n\t/**\n\t * True for Node.js builtins in both bare and `node:`-prefixed forms\n\t * ('path', 'node:path', 'fs/promises', 'node:fs/promises', …).\n\t */\n\tprivate static isBuiltinSpecifier (specifier: string): boolean {\n\t\tconst bare = specifier.startsWith('node:') ? specifier.slice('node:'.length) : specifier;\n\t\tconst result = BUILTIN_MODULES.has(bare);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Record a builtin import on the module (honesty marker) and skip it\n\t * entirely: no bindings, no site, no dependency, no edge.\n\t * Returns true when the specifier was a builtin (caller must return early).\n\t */\n\tprivate static skipBuiltin (moduleInfo: ModuleInfo, specifier: string): boolean {\n\t\tif (!ModuleGraphBuilder.isBuiltinSpecifier(specifier)) {\n\t\t\treturn false;\n\t\t}\n\t\tif (!moduleInfo.builtinSpecifiers.includes(specifier)) {\n\t\t\tmoduleInfo.builtinSpecifiers.push(specifier);\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * Chase a binding to the module that actually declares it, following\n\t * re-export chains (barrels). Cycle-guarded. Returns undefined when the\n\t * origin is external or the chain loops.\n\t */\n\tprivate resolveOrigin (\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.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.resolveOrigin(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.resolveOrigin({\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 * Match a binding against a module's defined mnemonica types.\n\t * Returns the matched fullPath, or undefined when the binding is not a\n\t * mnemonica type of that module.\n\t */\n\tprivate matchDefinedType (moduleInfo: ModuleInfo, binding: ModuleBinding): string | undefined {\n\t\tconst candidate = binding.importAlias ?? binding.name;\n\t\tfor (const definedType of moduleInfo.definedTypes) {\n\t\t\t// Custom-collection types are keyed `collectionId::Path`\n\t\t\tconst bare = definedType.includes('::')\n\t\t\t\t? definedType.slice(definedType.indexOf('::') + 2)\n\t\t\t\t: definedType;\n\t\t\tif (bare === candidate || bare.startsWith(`${candidate  }.`)) {\n\t\t\t\treturn definedType;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Three-color DFS over project-internal dependencies. Cycles are recorded\n\t * (mnemonica strictChain:false permits non-linear construction), never\n\t * treated as errors.\n\t */\n\tprivate detectCycles (): string[][] {\n\t\tconst cycles: string[][] = [];\n\t\tconst seenCycles = new Set<string>();\n\t\t// 1 = on the current stack, 2 = fully explored\n\t\tconst state = new Map<string, number>();\n\n\t\tconst visit = (filePath: string, stack: string[]): void => {\n\t\t\tstate.set(filePath, 1);\n\t\t\tstack.push(filePath);\n\n\t\t\tconst moduleInfo = this.modules.get(filePath);\n\t\t\tfor (const dep of moduleInfo?.dependencies ?? []) {\n\t\t\t\tif (state.get(dep) === 1) {\n\t\t\t\t\tconst cycle = stack.slice(stack.indexOf(dep));\n\t\t\t\t\tconst key = ModuleGraphBuilder.cycleKey(cycle);\n\t\t\t\t\tif (!seenCycles.has(key)) {\n\t\t\t\t\t\tseenCycles.add(key);\n\t\t\t\t\t\tcycles.push(cycle);\n\t\t\t\t\t}\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (!state.get(dep)) {\n\t\t\t\t\tvisit(dep, stack);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tstack.pop();\n\t\t\tstate.set(filePath, 2);\n\t\t};\n\n\t\tfor (const filePath of this.modules.keys()) {\n\t\t\tif (!state.get(filePath)) {\n\t\t\t\tvisit(filePath, []);\n\t\t\t}\n\t\t}\n\n\t\treturn cycles;\n\t}\n\n\t/**\n\t * Rotation-independent cycle key: smallest path first.\n\t */\n\tprivate static cycleKey (cycle: string[]): string {\n\t\tlet minIndex = 0;\n\t\tfor (let i = 1; i < cycle.length; i++) {\n\t\t\tif (cycle[ i ] < cycle[ minIndex ]) {\n\t\t\t\tminIndex = i;\n\t\t\t}\n\t\t}\n\t\tconst rotated = cycle.slice(minIndex).concat(cycle.slice(0, minIndex));\n\t\tconst key = rotated.join('\\n');\n\t\treturn key;\n\t}\n\n\t/**\n\t * Pass 1: record every named top-level declaration's kind.\n\t */\n\tprivate collectLocalDecl (statement: ts.Statement, decls: Map<string, ModuleBindingKind>): void {\n\t\tif (ts.isFunctionDeclaration(statement) && statement.name) {\n\t\t\tdecls.set(statement.name.text, 'function');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isClassDeclaration(statement) && statement.name) {\n\t\t\tdecls.set(statement.name.text, 'class');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {\n\t\t\tdecls.set(statement.name.text, 'type');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isEnumDeclaration(statement)) {\n\t\t\tdecls.set(statement.name.text, 'type');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isVariableStatement(statement)) {\n\t\t\tfor (const decl of statement.declarationList.declarations) {\n\t\t\t\tif (ts.isIdentifier(decl.name)) {\n\t\t\t\t\tdecls.set(decl.name.text, ModuleGraphBuilder.variableKind(decl));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Classify a variable declaration: arrow/function initializers are\n\t * 'function' (holder functions the walker follows), class expressions\n\t * are 'class', everything else is 'const'.\n\t */\n\tprivate static variableKind (decl: ts.VariableDeclaration): ModuleBindingKind {\n\t\tconst { initializer } = decl;\n\t\tif (initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))) {\n\t\t\treturn 'function';\n\t\t}\n\t\tif (initializer && ts.isClassExpression(initializer)) {\n\t\t\treturn 'class';\n\t\t}\n\t\treturn 'const';\n\t}\n\n\t/**\n\t * Pass 2: imports, exports, requires, exported declarations.\n\t */\n\tprivate processStatement (\n\t\tstatement: ts.Statement,\n\t\tsourceFile: ts.SourceFile,\n\t\tmoduleInfo: ModuleInfo,\n\t\tdecls: Map<string, ModuleBindingKind>,\n\t\tsites: ImportSite[]\n\t): void {\n\t\tif (ts.isImportDeclaration(statement)) {\n\t\t\tthis.processImport(statement, sourceFile, moduleInfo, sites);\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isExportDeclaration(statement)) {\n\t\t\tthis.processExportDeclaration(statement, sourceFile, moduleInfo, decls, sites);\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isImportEqualsDeclaration(statement)) {\n\t\t\tthis.processImportEquals(statement, sourceFile, moduleInfo, sites);\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isExportAssignment(statement)) {\n\t\t\tthis.processExportAssignment(statement, moduleInfo, decls);\n\t\t\treturn;\n\t\t}\n\t\tthis.processMaybeExportedDecl(statement, moduleInfo, decls);\n\t\tthis.processRequireCall(statement, sourceFile, moduleInfo, sites);\n\t}\n\n\tprivate processImport (\n\t\timportDecl: ts.ImportDeclaration,\n\t\tsourceFile: ts.SourceFile,\n\t\tmoduleInfo: ModuleInfo,\n\t\tsites: ImportSite[]\n\t): void {\n\t\tconst { moduleSpecifier } = importDecl;\n\t\tif (!ts.isStringLiteral(moduleSpecifier)) {\n\t\t\treturn;\n\t\t}\n\t\tif (ModuleGraphBuilder.skipBuiltin(moduleInfo, moduleSpecifier.text)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst site: ImportSite = {\n\t\t\tspecifier : moduleSpecifier.text,\n\t\t\tlocation  : this.locationOf(moduleSpecifier, sourceFile),\n\t\t\tbindings  : [],\n\t\t};\n\t\tsites.push(site);\n\n\t\tconst { importClause } = importDecl;\n\t\tif (!importClause) {\n\t\t\t// Side-effect import: dependency only, no bindings\n\t\t\treturn;\n\t\t}\n\n\t\t// Default import: import Type from './module'\n\t\tif (importClause.name) {\n\t\t\tconst binding: ModuleBinding = {\n\t\t\t\tname         : importClause.name.text,\n\t\t\t\tkind         : 'unknown',\n\t\t\t\tsourceModule : site.specifier,\n\t\t\t\timportKind   : 'default',\n\t\t\t\tisReExport   : false,\n\t\t\t};\n\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\tsite.bindings.push(binding);\n\t\t}\n\n\t\tconst { namedBindings } = importClause;\n\t\tif (namedBindings && ts.isNamedImports(namedBindings)) {\n\t\t\tfor (const element of namedBindings.elements) {\n\t\t\t\tconst originalName = element.propertyName?.text;\n\t\t\t\tconst binding: ModuleBinding = {\n\t\t\t\t\tname         : element.name.text,\n\t\t\t\t\tkind         : 'unknown',\n\t\t\t\t\tsourceModule : site.specifier,\n\t\t\t\t\timportKind   : 'named',\n\t\t\t\t\tisReExport   : false,\n\t\t\t\t};\n\t\t\t\tif (originalName) {\n\t\t\t\t\tbinding.importAlias = originalName;\n\t\t\t\t}\n\t\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\t\tsite.bindings.push(binding);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// Namespace import: import * as Types from './module'\n\t\tif (namedBindings && ts.isNamespaceImport(namedBindings)) {\n\t\t\tconst binding: ModuleBinding = {\n\t\t\t\tname         : namedBindings.name.text,\n\t\t\t\tkind         : 'unknown',\n\t\t\t\tsourceModule : site.specifier,\n\t\t\t\timportKind   : 'namespace',\n\t\t\t\tisReExport   : false,\n\t\t\t};\n\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\tsite.bindings.push(binding);\n\t\t}\n\t}\n\n\tprivate processExportDeclaration (\n\t\texportDecl: ts.ExportDeclaration,\n\t\tsourceFile: ts.SourceFile,\n\t\tmoduleInfo: ModuleInfo,\n\t\tdecls: Map<string, ModuleBindingKind>,\n\t\tsites: ImportSite[]\n\t): void {\n\t\tconst { moduleSpecifier } = exportDecl;\n\t\tconst { exportClause } = exportDecl;\n\n\t\t// Re-export forms carry a module specifier: `export … from './y'`\n\t\tif (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {\n\t\t\tif (ModuleGraphBuilder.skipBuiltin(moduleInfo, moduleSpecifier.text)) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst site: ImportSite = {\n\t\t\t\tspecifier : moduleSpecifier.text,\n\t\t\t\tlocation  : this.locationOf(moduleSpecifier, sourceFile),\n\t\t\t\tbindings  : [],\n\t\t\t};\n\t\t\tsites.push(site);\n\n\t\t\tif (!exportClause) {\n\t\t\t\t// `export * from './y'`\n\t\t\t\tconst binding: ModuleBinding = {\n\t\t\t\t\tname         : '*',\n\t\t\t\t\tkind         : 'unknown',\n\t\t\t\t\tsourceModule : site.specifier,\n\t\t\t\t\timportKind   : 'namespace',\n\t\t\t\t\tisReExport   : true,\n\t\t\t\t};\n\t\t\t\tmoduleInfo.exportedBindings.push(binding);\n\t\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\t\tsite.bindings.push(binding);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (ts.isNamespaceExport(exportClause)) {\n\t\t\t\t// `export * as ns from './y'`\n\t\t\t\tconst binding: ModuleBinding = {\n\t\t\t\t\tname         : exportClause.name.text,\n\t\t\t\t\tkind         : 'unknown',\n\t\t\t\t\tsourceModule : site.specifier,\n\t\t\t\t\timportKind   : 'namespace',\n\t\t\t\t\tisReExport   : true,\n\t\t\t\t};\n\t\t\t\tmoduleInfo.exportedBindings.push(binding);\n\t\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\t\tsite.bindings.push(binding);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// `export { X, Y as Z } from './y'`\n\t\t\tfor (const element of exportClause.elements) {\n\t\t\t\tconst originalName = element.propertyName?.text;\n\t\t\t\tconst binding: ModuleBinding = {\n\t\t\t\t\tname         : element.name.text,\n\t\t\t\t\tkind         : 'unknown',\n\t\t\t\t\tsourceModule : site.specifier,\n\t\t\t\t\timportKind   : 'named',\n\t\t\t\t\tisReExport   : true,\n\t\t\t\t};\n\t\t\t\tif (originalName) {\n\t\t\t\t\tbinding.importAlias = originalName;\n\t\t\t\t}\n\t\t\t\tmoduleInfo.exportedBindings.push(binding);\n\t\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\t\tsite.bindings.push(binding);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// Plain `export { X, Y as Z }` — local declarations\n\t\tif (exportClause && ts.isNamedExports(exportClause)) {\n\t\t\tfor (const element of exportClause.elements) {\n\t\t\t\tconst originalName = element.propertyName?.text ?? element.name.text;\n\t\t\t\tconst binding: ModuleBinding = {\n\t\t\t\t\tname         : element.name.text,\n\t\t\t\t\tkind         : decls.get(originalName) ?? 'unknown',\n\t\t\t\t\tsourceModule : moduleInfo.filePath,\n\t\t\t\t\tisReExport   : false,\n\t\t\t\t};\n\t\t\t\tif (element.propertyName) {\n\t\t\t\t\tbinding.importAlias = element.propertyName.text;\n\t\t\t\t}\n\t\t\t\tmoduleInfo.exportedBindings.push(binding);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * `import foo = require('./y')`\n\t */\n\tprivate processImportEquals (\n\t\timportDecl: ts.ImportEqualsDeclaration,\n\t\tsourceFile: ts.SourceFile,\n\t\tmoduleInfo: ModuleInfo,\n\t\tsites: ImportSite[]\n\t): void {\n\t\tconst { moduleReference } = importDecl;\n\t\tif (!ts.isExternalModuleReference(moduleReference)) {\n\t\t\treturn;\n\t\t}\n\t\tconst { expression } = moduleReference;\n\t\tif (!ts.isStringLiteral(expression)) {\n\t\t\treturn;\n\t\t}\n\t\tif (ModuleGraphBuilder.skipBuiltin(moduleInfo, expression.text)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst binding: ModuleBinding = {\n\t\t\tname         : importDecl.name.text,\n\t\t\tkind         : 'unknown',\n\t\t\tsourceModule : expression.text,\n\t\t\timportKind   : 'require',\n\t\t\tisReExport   : false,\n\t\t};\n\t\tmoduleInfo.importedBindings.push(binding);\n\t\tsites.push({\n\t\t\tspecifier : expression.text,\n\t\t\tlocation  : this.locationOf(expression, sourceFile),\n\t\t\tbindings  : [ binding ],\n\t\t});\n\t}\n\n\t/**\n\t * `export default <expression>`\n\t */\n\tprivate processExportAssignment (\n\t\tstatement: ts.ExportAssignment,\n\t\tmoduleInfo: ModuleInfo,\n\t\tdecls: Map<string, ModuleBindingKind>\n\t): void {\n\t\tconst { expression } = statement;\n\t\tconst kind = ts.isIdentifier(expression)\n\t\t\t? decls.get(expression.text) ?? 'unknown'\n\t\t\t: 'unknown';\n\t\tconst binding: ModuleBinding = {\n\t\t\tname         : 'default',\n\t\t\tkind,\n\t\t\tsourceModule : moduleInfo.filePath,\n\t\t\timportKind   : 'default',\n\t\t\tisReExport   : false,\n\t\t};\n\t\tif (ts.isIdentifier(expression)) {\n\t\t\tbinding.importAlias = expression.text;\n\t\t}\n\t\tmoduleInfo.exportedBindings.push(binding);\n\t}\n\n\t/**\n\t * `export function/class/const/interface/type …` declarations.\n\t */\n\tprivate processMaybeExportedDecl (\n\t\tstatement: ts.Statement,\n\t\tmoduleInfo: ModuleInfo,\n\t\tdecls: Map<string, ModuleBindingKind>\n\t): void {\n\t\tconst modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;\n\t\tconst hasExport = modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;\n\t\tconst hasDefault = modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;\n\t\tif (!hasExport) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst addExport = (localName: string | undefined, kind: ModuleBindingKind): void => {\n\t\t\tconst binding: ModuleBinding = {\n\t\t\t\tname         : hasDefault ? 'default' : localName ?? 'default',\n\t\t\t\tkind,\n\t\t\t\tsourceModule : moduleInfo.filePath,\n\t\t\t\tisReExport   : false,\n\t\t\t};\n\t\t\tif (hasDefault) {\n\t\t\t\tbinding.importKind = 'default';\n\t\t\t\tif (localName) {\n\t\t\t\t\tbinding.importAlias = localName;\n\t\t\t\t}\n\t\t\t}\n\t\t\tmoduleInfo.exportedBindings.push(binding);\n\t\t};\n\n\t\tif (ts.isFunctionDeclaration(statement)) {\n\t\t\taddExport(statement.name?.text, 'function');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isClassDeclaration(statement)) {\n\t\t\taddExport(statement.name?.text, 'class');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {\n\t\t\taddExport(statement.name.text, 'type');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isEnumDeclaration(statement)) {\n\t\t\taddExport(statement.name.text, 'type');\n\t\t\treturn;\n\t\t}\n\t\tif (ts.isVariableStatement(statement)) {\n\t\t\tfor (const decl of statement.declarationList.declarations) {\n\t\t\t\tif (ts.isIdentifier(decl.name)) {\n\t\t\t\t\taddExport(decl.name.text, decls.get(decl.name.text) ?? 'const');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * CommonJS `const x = require('./y')` (JS sources with allowJs).\n\t */\n\tprivate processRequireCall (\n\t\tstatement: ts.Statement,\n\t\tsourceFile: ts.SourceFile,\n\t\tmoduleInfo: ModuleInfo,\n\t\tsites: ImportSite[]\n\t): void {\n\t\tif (!ts.isVariableStatement(statement)) {\n\t\t\treturn;\n\t\t}\n\t\tfor (const decl of statement.declarationList.declarations) {\n\t\t\tconst { initializer } = decl;\n\t\t\tif (!initializer || !ts.isCallExpression(initializer)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (!ts.isIdentifier(initializer.expression) || initializer.expression.text !== 'require') {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst [ firstArg ] = initializer.arguments;\n\t\t\tif (!firstArg || !ts.isStringLiteral(firstArg)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (ModuleGraphBuilder.skipBuiltin(moduleInfo, firstArg.text)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst localName = ts.isIdentifier(decl.name) ? decl.name.text : decl.name.getText();\n\t\t\tconst binding: ModuleBinding = {\n\t\t\t\tname         : localName,\n\t\t\t\tkind         : 'unknown',\n\t\t\t\tsourceModule : firstArg.text,\n\t\t\t\timportKind   : 'require',\n\t\t\t\tisReExport   : false,\n\t\t\t};\n\t\t\tmoduleInfo.importedBindings.push(binding);\n\t\t\tsites.push({\n\t\t\t\tspecifier : firstArg.text,\n\t\t\t\tlocation  : this.locationOf(firstArg, sourceFile),\n\t\t\t\tbindings  : [ binding ],\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Format a node's position as file.ts:Line:Col (1-based), matching the\n\t * location format of the other .tactica outputs.\n\t */\n\tprivate locationOf (node: ts.Node, sourceFile: ts.SourceFile): string {\n\t\tconst position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));\n\t\tconst location = `${path.resolve(sourceFile.fileName)}:${position.line + 1}:${position.character + 1}`;\n\t\treturn location;\n\t}\n}\n"]}