circle-ir 4.17.0 → 4.18.1

package/dist/navigation/ts-call-edges.js

@@ -0,0 +1,2089 @@
+/**
+ * TypeScript/JavaScript call edges keyed by stable declaration ids.
+ *
+ * Every call site in a set of files becomes either an **edge** from the
+ * enclosing declaration to the declaration(s) it can run, labelled with the
+ * same tiers as the Java navigation index, or an **unresolved** site with a
+ * reason from the same closed vocabulary. Nothing is dropped silently: the
+ * two lists together account for every call and `new` expression walked.
+ *
+ * Tiers:
+ * - `exact` — the callee is a single declaration with a body, bound through
+ *   lexical scope, an import, a namespace, a class name, or a receiver whose
+ *   type is known (a type annotation, a `new` initializer, `this`, `super`)
+ *   and whose method no subtype in the tree overrides.
+ * - `polymorphic` — the receiver's type is known and dispatch is open: the
+ *   method is abstract or on an interface, or a subtype overrides it. One
+ *   edge per body that could run, each carrying `via` (the declaring member).
+ * - `inferred` — a member call on a receiver of unknown type, bound by the
+ *   method's name alone to every method of that name in the tree. Reported
+ *   and labelled, never promoted.
+ *
+ * Bounds of this version, each surfacing as an unresolved site rather than
+ * a guess: no type inference beyond the shapes above (a call's return type is
+ * not followed); `tsconfig` path aliases only through `moduleAliases`; JSX
+ * element rendering is not a call; module-level names are importable whether
+ * or not they are exported.
+ */
+import { disposeTree, parse } from '../core/parser.js';
+import { declLocator } from '../stable-ids/nodes.js';
+import { deriveTypeScriptIds } from '../stable-ids/typescript.js';
+import { DEFAULT_ENTRY_TABLES } from './ts-entry-tables.js';
+export const TS_CALL_EDGES_SCHEME = 'ts-call-edges@0.1';
+/** `methodName` of an unresolved site that loads a module by a computed specifier (`import(name)`). */
+export const COMPUTED_MODULE_LOAD = '<module>';
+// ---------------------------------------------------------------------------
+// Paths
+const EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.d.ts', '.js', '.jsx', '.mjs', '.cjs'];
+function normalizePath(p) {
+    const out = [];
+    for (const part of p.split('/')) {
+        if (part === '' || part === '.')
+            continue;
+        if (part === '..')
+            out.pop();
+        else
+            out.push(part);
+    }
+    return out.join('/');
+}
+function dirname(p) {
+    const i = p.lastIndexOf('/');
+    return i < 0 ? '' : p.slice(0, i);
+}
+function languageOf(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith('.tsx'))
+        return { grammar: 'tsx', ids: 'typescript' };
+    if (lower.endsWith('.jsx'))
+        return { grammar: 'tsx', ids: 'javascript' };
+    if (/\.[mc]?ts$/.test(lower))
+        return { grammar: 'typescript', ids: 'typescript' };
+    if (/\.[mc]?js$/.test(lower))
+        return { grammar: 'javascript', ids: 'javascript' };
+    return null;
+}
+const BUILTIN_TYPE_SHAPES = new Set([
+    'array_type', 'tuple_type', 'literal_type', 'template_literal_type', 'function_type', 'object_type',
+    'string', 'number', 'template_string', 'array', 'object', 'regex',
+]);
+const FUNCTION_NODES = new Set([
+    'function_declaration', 'generator_function_declaration', 'function_expression', 'function',
+    'generator_function', 'arrow_function', 'method_definition',
+]);
+function named(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type !== 'comment')
+            out.push(c);
+    }
+    return out;
+}
+function stringValue(node) {
+    if (!node || node.type !== 'string')
+        return null;
+    return named(node).map(c => c.text).join('');
+}
+function posKey(node, kind) {
+    return `${node.startPosition.row + 1}:${node.startPosition.column}:${kind}`;
+}
+/** A specifier written as a string or a template without substitutions. */
+function literalSpecifier(node) {
+    if (!node)
+        return null;
+    if (node.type === 'string')
+        return stringValue(node);
+    if (node.type === 'template_string' && !named(node).some(c => c.type === 'template_substitution')) {
+        return node.text.slice(1, -1);
+    }
+    return null;
+}
+/**
+ * A module load expression: `import(spec)` or `require(spec)`, under any
+ * `await` or parentheses. `spec` is null when the specifier is computed.
+ */
+function moduleLoad(node) {
+    let n = node;
+    while (n && (n.type === 'await_expression' || n.type === 'parenthesized_expression'))
+        n = named(n)[0] ?? null;
+    if (n?.type !== 'call_expression')
+        return null;
+    const fn = n.childForFieldName('function');
+    if (fn?.type !== 'import' && !(fn?.type === 'identifier' && fn.text === 'require'))
+        return null;
+    const args = n.childForFieldName('arguments');
+    const arg = args ? named(args)[0] ?? null : null;
+    return { call: n, spec: literalSpecifier(arg) };
+}
+function isRequire(node) {
+    if (node?.type !== 'call_expression')
+        return null;
+    const fn = node.childForFieldName('function');
+    if (fn?.type !== 'identifier' || fn.text !== 'require')
+        return null;
+    const arg = node.childForFieldName('arguments')?.namedChild(0) ?? null;
+    return arg?.type === 'string' ? arg : null;
+}
+/** Identifier leaves of a binding pattern. */
+function patternNames(node, out = []) {
+    if (!node)
+        return out;
+    if (node.type === 'identifier' || node.type === 'shorthand_property_identifier_pattern') {
+        out.push(node.text);
+        return out;
+    }
+    if (node.type === 'pair_pattern')
+        return patternNames(node.childForFieldName('value'), out);
+    if (node.type === 'assignment_pattern')
+        return patternNames(node.childForFieldName('left'), out);
+    for (const c of named(node)) {
+        if (c.type === 'type_annotation' || c.type === 'property_identifier')
+            continue;
+        patternNames(c, out);
+    }
+    return out;
+}
+const MAX_MOUNT_CHAINS = 16;
+/** Join route segments: one `/` between parts, none trailing (except the root). */
+export function joinRoutePath(parts) {
+    const segs = parts.flatMap(p => p.split('/')).filter(s => s !== '');
+    return '/' + segs.join('/');
+}
+/** Nested router paths: a segment starting with `/` restarts from the root. */
+function composeRelative(segments) {
+    let out = [];
+    for (const s of segments) {
+        if (s.startsWith('/'))
+            out = [s];
+        else
+            out.push(s);
+    }
+    return joinRoutePath(out);
+}
+/** A Next.js file path to a route: groups and parallel slots dropped, `[x]` / `[...x]` / `[[...x]]` to `{x}`. */
+function filePath(segments) {
+    const out = [];
+    for (const s of segments) {
+        if (s === '' || /^\(.*\)$/.test(s) || s.startsWith('@'))
+            continue;
+        const dyn = s.match(/^\[\[?(?:\.\.\.)?([^\]]+)\]\]?$/);
+        out.push(dyn ? `{${dyn[1]}}` : s);
+    }
+    return joinRoutePath(out);
+}
+class Graph {
+    options;
+    files = new Map();
+    edges = [];
+    unresolved = [];
+    sites = 0;
+    /** Type decl id → its class or interface node and file. */
+    typeNodes = new Map();
+    /** Type decl id → direct supertypes (resolved decls). */
+    supers = new Map();
+    /** Type decl id → direct subtypes. */
+    subs = new Map();
+    /** Declarations without a body: overload, interface and abstract signatures. */
+    bodiless = new Set();
+    /** Declarations that exist only for the type checker (interfaces, aliases, signatures, ambient). */
+    typeOnly = new Set();
+    /** Method declarations by name, across the tree, for `inferred`. */
+    methodsByName = new Map();
+    maxInferred;
+    references = [];
+    fieldUses = [];
+    loadEdges = [];
+    /** Fields and accessors by name (class members only). */
+    fieldsByName = new Map();
+    entries = [];
+    unresolvedRegistrations = [];
+    tables;
+    pendingRoutes = [];
+    mounts = [];
+    constructor(options) {
+        this.options = options;
+        this.maxInferred = options.maxInferred ?? 16;
+        this.tables = options.entryTables ?? DEFAULT_ENTRY_TABLES;
+    }
+    get siteCount() {
+        return this.sites;
+    }
+    // -- loading ---------------------------------------------------------------
+    add(path, tree, ids) {
+        const root = tree.rootNode;
+        const ctx = {
+            path, ids, root, module: ids.decls[0],
+            top: new Map(), topVars: new Map(), imports: new Map(), exports: new Map(),
+            defaultLocal: null, reexports: new Map(), stars: [], loads: [], esm: false,
+            locate: declLocator(ids), byStart: new Map(),
+        };
+        for (const d of ids.decls) {
+            if (d.parent === ctx.module.id) {
+                const list = ctx.top.get(d.name);
+                if (list)
+                    list.push(d);
+                else
+                    ctx.top.set(d.name, [d]);
+            }
+            const accessor = d.kind === 'method' && /^(static )?[gs]et /.test(d.signature);
+            if (d.kind === 'method' && !accessor) {
+                const list = this.methodsByName.get(d.name);
+                if (list)
+                    list.push(d);
+                else
+                    this.methodsByName.set(d.name, [d]);
+            }
+            if ((d.kind === 'field' || accessor) && d.parent !== null && d.parent !== ctx.module.id) {
+                const list = this.fieldsByName.get(d.name);
+                if (list)
+                    list.push(d);
+                else
+                    this.fieldsByName.set(d.name, [d]);
+            }
+        }
+        this.files.set(path, ctx);
+    }
+    /** Second pass, once every file is loaded: module tables, node positions, hierarchy. */
+    link() {
+        for (const ctx of this.sortedFiles())
+            this.scanModule(ctx);
+        for (const ctx of this.sortedFiles())
+            this.scanTypes(ctx, ctx.root);
+        for (const [id, s] of this.supers) {
+            const parents = [...(s.extends && s.extends !== 'external' ? [s.extends] : []), ...s.implements];
+            for (const p of parents) {
+                const list = this.subs.get(p.id);
+                const self = this.declById(id);
+                if (!self)
+                    continue;
+                if (list)
+                    list.push(self);
+                else
+                    this.subs.set(p.id, [self]);
+            }
+        }
+    }
+    sortedFiles() {
+        return [...this.files.values()].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    }
+    idIndex = new Map();
+    declById(id) {
+        if (this.idIndex.size === 0) {
+            for (const ctx of this.files.values())
+                for (const d of ctx.ids.decls)
+                    this.idIndex.set(d.id, d);
+        }
+        return this.idIndex.get(id);
+    }
+    resolveModule(from, specifier) {
+        let base = null;
+        if (specifier.startsWith('./') || specifier.startsWith('../') || specifier === '.' || specifier === '..') {
+            base = normalizePath(`${dirname(from)}/${specifier}`);
+        }
+        else {
+            for (const [prefix, target] of Object.entries(this.options.moduleAliases ?? {}).sort()) {
+                if (specifier.startsWith(prefix)) {
+                    base = normalizePath(target + specifier.slice(prefix.length));
+                    break;
+                }
+            }
+        }
+        if (base === null)
+            return null;
+        const stems = [base];
+        const js = base.match(/^(.*)\.(?:m|c)?jsx?$/);
+        if (js)
+            stems.push(js[1]);
+        for (const stem of stems) {
+            if (this.files.has(stem))
+                return stem;
+            for (const ext of EXTENSIONS)
+                if (this.files.has(stem + ext))
+                    return stem + ext;
+            for (const ext of EXTENSIONS)
+                if (this.files.has(`${stem}/index${ext}`))
+                    return `${stem}/index${ext}`;
+        }
+        return null;
+    }
+    scanModule(ctx) {
+        for (const d of ctx.ids.decls) {
+            // Index every declaration by the position its node starts at.
+            ctx.byStart.set(`${d.start_line}:${d.start_column}:${d.kind}`, d);
+        }
+        for (const stmt of named(ctx.root))
+            this.scanStatement(ctx, stmt);
+        this.markBodiless(ctx.root, ctx);
+    }
+    markBodiless(node, ctx, ambient = false) {
+        const t = node.type;
+        if (t === 'function_signature' || t === 'method_signature' || t === 'abstract_method_signature') {
+            const kind = t === 'function_signature' ? 'function' : 'method';
+            const d = ctx.byStart.get(posKey(node, kind));
+            if (d) {
+                this.bodiless.add(d.id);
+                this.typeOnly.add(d.id);
+            }
+        }
+        // Declarations that exist only for the type checker: nothing runs them.
+        const inAmbient = ambient || t === 'ambient_declaration';
+        const typeKinds = { interface_declaration: 'type', type_alias_declaration: 'type', property_signature: 'field' };
+        const tk = typeKinds[t];
+        if (tk || (inAmbient && t !== 'ambient_declaration')) {
+            for (const kind of tk ? [tk] : ['function', 'type', 'field', 'module', 'method']) {
+                const d = ctx.byStart.get(posKey(node, kind));
+                if (d)
+                    this.typeOnly.add(d.id);
+            }
+        }
+        for (const c of named(node))
+            this.markBodiless(c, ctx, inAmbient);
+    }
+    scanStatement(ctx, stmt) {
+        const t = stmt.type;
+        if (t === 'import_statement') {
+            const spec = stringValue(stmt.childForFieldName('source'));
+            if (spec === null)
+                return;
+            const module = this.resolveModule(ctx.path, spec);
+            if (module)
+                ctx.loads.push(module);
+            const clause = named(stmt).find(c => c.type === 'import_clause');
+            if (!clause)
+                return;
+            for (const c of named(clause)) {
+                if (c.type === 'identifier')
+                    ctx.imports.set(c.text, { kind: 'default', module, specifier: spec });
+                else if (c.type === 'namespace_import') {
+                    const id = named(c).find(x => x.type === 'identifier');
+                    if (id)
+                        ctx.imports.set(id.text, { kind: 'namespace', module, specifier: spec });
+                }
+                else if (c.type === 'named_imports') {
+                    for (const s of named(c)) {
+                        if (s.type !== 'import_specifier')
+                            continue;
+                        const name = s.childForFieldName('name')?.text;
+                        const alias = s.childForFieldName('alias')?.text ?? name;
+                        if (name && alias)
+                            ctx.imports.set(alias, name === 'default' ? { kind: 'default', module, specifier: spec } : { kind: 'named', module, name, specifier: spec });
+                    }
+                }
+            }
+            return;
+        }
+        if (t === 'export_statement') {
+            ctx.esm = true;
+            const source = stringValue(stmt.childForFieldName('source'));
+            const declaration = stmt.childForFieldName('declaration');
+            const value = stmt.childForFieldName('value');
+            const clause = named(stmt).find(c => c.type === 'export_clause');
+            if (source !== null) {
+                const module = this.resolveModule(ctx.path, source);
+                if (module)
+                    ctx.loads.push(module);
+                if (!clause) {
+                    ctx.stars.push(module);
+                    return;
+                }
+                for (const s of named(clause)) {
+                    const name = s.childForFieldName('name')?.text;
+                    const alias = s.childForFieldName('alias')?.text ?? name;
+                    if (name && alias)
+                        ctx.reexports.set(alias, { module, name });
+                }
+                return;
+            }
+            if (clause) {
+                for (const s of named(clause)) {
+                    const name = s.childForFieldName('name')?.text;
+                    const alias = s.childForFieldName('alias')?.text ?? name;
+                    if (name && alias) {
+                        if (alias === 'default')
+                            ctx.defaultLocal = name;
+                        else
+                            ctx.exports.set(alias, name);
+                    }
+                }
+                return;
+            }
+            if (declaration) {
+                let isDefault = false;
+                for (let i = 0; i < stmt.childCount; i++) {
+                    const c = stmt.child(i);
+                    if (c && !c.isNamed && c.text === 'default')
+                        isDefault = true;
+                }
+                const nameNode = declaration.childForFieldName('name');
+                if (isDefault && nameNode)
+                    ctx.defaultLocal = nameNode.text;
+                else if (nameNode)
+                    ctx.exports.set(nameNode.text, nameNode.text);
+                else if (declaration.type === 'lexical_declaration' || declaration.type === 'variable_declaration') {
+                    for (const d of named(declaration)) {
+                        for (const n of d.type === 'variable_declarator' ? patternNames(d.childForFieldName('name')) : [])
+                            ctx.exports.set(n, n);
+                    }
+                }
+                this.scanStatement(ctx, declaration);
+                return;
+            }
+            if (value) {
+                if (value.type === 'identifier')
+                    ctx.defaultLocal = value.text;
+                else {
+                    const own = value.childForFieldName('name');
+                    ctx.defaultLocal = own ? own.text : 'default';
+                }
+            }
+            return;
+        }
+        if (t === 'lexical_declaration' || t === 'variable_declaration') {
+            for (const d of named(stmt)) {
+                if (d.type !== 'variable_declarator')
+                    continue;
+                const nameNode = d.childForFieldName('name');
+                const value = d.childForFieldName('value');
+                const req = isRequire(value);
+                const specifier = stringValue(req) ?? '';
+                const reqModule = req ? this.resolveModule(ctx.path, specifier) : null;
+                if (reqModule)
+                    ctx.loads.push(reqModule);
+                if (nameNode?.type === 'identifier') {
+                    ctx.topVars.set(nameNode.text, d);
+                    if (req)
+                        ctx.imports.set(nameNode.text, { kind: 'namespace', module: reqModule, specifier });
+                }
+                else if (nameNode?.type === 'object_pattern' && req) {
+                    for (const p of named(nameNode)) {
+                        if (p.type === 'shorthand_property_identifier_pattern')
+                            ctx.imports.set(p.text, { kind: 'named', module: reqModule, name: p.text, specifier });
+                        else if (p.type === 'pair_pattern') {
+                            const key = p.childForFieldName('key')?.text;
+                            const local = p.childForFieldName('value');
+                            if (key && local?.type === 'identifier')
+                                ctx.imports.set(local.text, { kind: 'named', module: reqModule, name: key, specifier });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /** Classes and interfaces: their nodes and resolved supertypes. */
+    scanTypes(ctx, node) {
+        const t = node.type;
+        if (t === 'class_declaration' || t === 'abstract_class_declaration' || t === 'class' || t === 'interface_declaration') {
+            const decl = this.typeDeclAt(ctx, node);
+            if (decl) {
+                this.typeNodes.set(decl.id, { node, ctx });
+                let ext = null;
+                const impls = [];
+                const heritage = named(node).find(c => c.type === 'class_heritage');
+                const extendsNodes = [];
+                const implNodes = [];
+                if (heritage) {
+                    for (const c of named(heritage)) {
+                        if (c.type === 'extends_clause') {
+                            const v = c.childForFieldName('value') ?? named(c)[0];
+                            if (v)
+                                extendsNodes.push(v);
+                        }
+                        else if (c.type === 'implements_clause')
+                            implNodes.push(...named(c));
+                        else
+                            extendsNodes.push(c); // JavaScript: `class_heritage (identifier)`
+                    }
+                }
+                const ifaceExt = named(node).find(c => c.type === 'extends_type_clause');
+                if (ifaceExt)
+                    implNodes.push(...named(ifaceExt));
+                if (extendsNodes[0]) {
+                    const r = this.resolveTypeRef(ctx, extendsNodes[0]);
+                    ext = r === null ? null : r;
+                }
+                for (const n of implNodes) {
+                    const r = this.resolveTypeRef(ctx, n);
+                    if (r && r !== 'external')
+                        impls.push(r);
+                }
+                this.supers.set(decl.id, { extends: ext, implements: impls });
+                if (t !== 'interface_declaration')
+                    this.decoratorEntries(ctx, node, decl);
+            }
+        }
+        for (const c of named(node))
+            this.scanTypes(ctx, c);
+    }
+    typeDeclAt(ctx, node) {
+        const direct = ctx.byStart.get(posKey(node, 'type'));
+        if (direct)
+            return direct;
+        // `const C = class {}` / `export default class {}`: the declaration starts at the holder.
+        let best = null;
+        const line = node.startPosition.row + 1;
+        for (const d of ctx.ids.decls) {
+            if (d.kind !== 'type')
+                continue;
+            const inside = (line > d.start_line || (line === d.start_line && node.startPosition.column >= d.start_column))
+                && node.endPosition.row + 1 <= d.end_line;
+            if (inside && (!best || d.start_line > best.start_line || (d.start_line === best.start_line && d.start_column >= best.start_column)))
+                best = d;
+        }
+        return best;
+    }
+    // -- name resolution -------------------------------------------------------
+    resolveExport(ctx, name, depth) {
+        if (depth > 8)
+            return { kind: 'none' };
+        if (name === 'default') {
+            if (ctx.defaultLocal !== null) {
+                if (ctx.defaultLocal === 'default') {
+                    const d = ctx.top.get('default');
+                    return d ? { kind: 'decls', decls: d, ctx } : { kind: 'none' };
+                }
+                return this.resolveLocal(ctx, ctx.defaultLocal, depth + 1);
+            }
+            const d = ctx.top.get('default');
+            return d ? { kind: 'decls', decls: d, ctx } : { kind: 'none' };
+        }
+        const local = ctx.exports.get(name);
+        if (local !== undefined)
+            return this.resolveLocal(ctx, local, depth + 1);
+        const re = ctx.reexports.get(name);
+        if (re) {
+            const target = re.module === null ? undefined : this.files.get(re.module);
+            return target ? this.resolveExport(target, re.name, depth + 1) : { kind: 'external' };
+        }
+        if (ctx.top.has(name))
+            return this.resolveLocal(ctx, name, depth + 1);
+        for (const m of ctx.stars) {
+            const target = m === null ? undefined : this.files.get(m);
+            if (!target)
+                continue;
+            const r = this.resolveExport(target, name, depth + 1);
+            if (r.kind !== 'none')
+                return r;
+        }
+        return { kind: 'none' };
+    }
+    /** A module-level name: a declaration here, or an import followed to its file. */
+    resolveLocal(ctx, name, depth = 0) {
+        // An import wins: `const a = require('./a')` is also a module-level field.
+        const imp = ctx.imports.get(name);
+        if (!imp) {
+            const decls = ctx.top.get(name);
+            return decls ? { kind: 'decls', decls, ctx } : { kind: 'none' };
+        }
+        return this.resolveBinding(imp, depth);
+    }
+    /** What an import binding denotes: a namespace, or the export it names. */
+    resolveBinding(imp, depth = 0) {
+        const target = imp.module === null ? undefined : this.files.get(imp.module);
+        if (!target)
+            return { kind: 'external' };
+        if (imp.kind === 'namespace')
+            return { kind: 'namespace', ctx: target };
+        return this.resolveExport(target, imp.kind === 'default' ? 'default' : imp.name, depth + 1);
+    }
+    /**
+     * A local variable bound to a module load with a literal specifier:
+     * `const m = await import('./m')` is the namespace, `const { f } = await
+     * import('./m')` and `const { f } = require('./m')` name the export.
+     */
+    loadBinding(ctx, declarator, name) {
+        const load = moduleLoad(declarator.childForFieldName('value'));
+        if (!load || load.spec === null)
+            return null;
+        const specifier = load.spec;
+        const module = this.resolveModule(ctx.path, specifier);
+        const pattern = declarator.childForFieldName('name');
+        if (pattern?.type === 'identifier')
+            return pattern.text === name ? { kind: 'namespace', module, specifier } : null;
+        if (pattern?.type !== 'object_pattern')
+            return null;
+        for (const p of named(pattern)) {
+            let key;
+            if (p.type === 'shorthand_property_identifier_pattern' && p.text === name)
+                key = name;
+            else if (p.type === 'pair_pattern' && p.childForFieldName('value')?.text === name)
+                key = p.childForFieldName('key')?.text;
+            if (key === 'default')
+                return { kind: 'default', module, specifier };
+            if (key)
+                return { kind: 'named', module, name: key, specifier };
+        }
+        return null;
+    }
+    resolveTypeRef(ctx, node) {
+        let n = node;
+        if (n.type === 'type_annotation')
+            n = named(n)[0] ?? null;
+        if (n?.type === 'generic_type')
+            n = n.childForFieldName('name') ?? named(n)[0] ?? null;
+        if (!n)
+            return null;
+        // Built-in shapes have no declaration in the tree; `any` and `unknown` say nothing.
+        if (n.type === 'predefined_type')
+            return n.text === 'any' || n.text === 'unknown' ? null : 'external';
+        if (BUILTIN_TYPE_SHAPES.has(n.type))
+            return 'external';
+        if (n.type === 'nested_type_identifier' || n.type === 'member_expression') {
+            const parts = n.text.split('.');
+            if (parts.length !== 2)
+                return 'external';
+            const ns = this.resolveLocal(ctx, parts[0]);
+            if (ns.kind !== 'namespace')
+                return 'external';
+            const r = this.resolveExport(ns.ctx, parts[1], 0);
+            return r.kind === 'decls' ? (r.decls.find(d => d.kind === 'type') ?? 'external') : 'external';
+        }
+        if (n.type !== 'type_identifier' && n.type !== 'identifier')
+            return null;
+        const r = this.resolveLocal(ctx, n.text);
+        if (r.kind === 'decls')
+            return r.decls.find(d => d.kind === 'type') ?? null;
+        return 'external';
+    }
+    // -- lexical scope ---------------------------------------------------------
+    /**
+     * The nearest binding of `name` inside the enclosing functions and blocks
+     * (module level excluded): a parameter, a variable declarator, or a nested
+     * function declaration.
+     */
+    localBinding(start, name) {
+        for (let n = start.parent; n && n.type !== 'program'; n = n.parent) {
+            if (FUNCTION_NODES.has(n.type)) {
+                const params = n.childForFieldName('parameters');
+                const single = n.childForFieldName('parameter');
+                if (single && single.text === name)
+                    return { kind: 'param', node: single };
+                if (params) {
+                    for (const p of named(params)) {
+                        const pattern = p.childForFieldName('pattern') ?? p;
+                        if (patternNames(pattern).includes(name))
+                            return { kind: 'param', node: p };
+                    }
+                }
+            }
+            if (n.type === 'catch_clause' && patternNames(n.childForFieldName('parameter')).includes(name)) {
+                return { kind: 'param', node: n };
+            }
+            if (n.type === 'statement_block' || n.type === 'for_statement' || n.type === 'for_in_statement') {
+                for (const s of named(n)) {
+                    if ((s.type === 'function_declaration' || s.type === 'generator_function_declaration') && s.childForFieldName('name')?.text === name) {
+                        return { kind: 'fn', node: s };
+                    }
+                    if (s.type === 'lexical_declaration' || s.type === 'variable_declaration') {
+                        for (const d of named(s)) {
+                            if (d.type === 'variable_declarator' && patternNames(d.childForFieldName('name')).includes(name))
+                                return { kind: 'var', node: d };
+                        }
+                    }
+                }
+                if (n.type === 'for_in_statement' && patternNames(n.childForFieldName('left')).includes(name))
+                    return { kind: 'param', node: n };
+            }
+        }
+        return null;
+    }
+    nestedDeclAt(ctx, node) {
+        return ctx.byStart.get(posKey(node, 'function')) ?? null;
+    }
+    // -- receiver types --------------------------------------------------------
+    enclosingClass(ctx, node) {
+        for (let n = node.parent; n; n = n.parent) {
+            // A non-arrow function rebinds `this`; methods are the exception.
+            if ((n.type === 'function_expression' || n.type === 'function' || n.type === 'function_declaration') && n.parent?.type !== 'class_body')
+                return null;
+            if (n.type === 'class_declaration' || n.type === 'abstract_class_declaration' || n.type === 'class')
+                return this.typeDeclAt(ctx, n);
+        }
+        return null;
+    }
+    typeOfVar(ctx, declarator) {
+        const type = declarator.childForFieldName('type');
+        if (type)
+            return this.resolveTypeRef(ctx, type);
+        const value = declarator.childForFieldName('value');
+        if (value?.type === 'new_expression') {
+            const c = value.childForFieldName('constructor');
+            return c ? this.resolveTypeRef(ctx, c) : null;
+        }
+        // A literal's methods are the language's own.
+        if (value && BUILTIN_TYPE_SHAPES.has(value.type))
+            return 'external';
+        return null;
+    }
+    /** The class's own field or constructor parameter property named `name`, typed. */
+    typeOfField(cls, name) {
+        const entry = this.typeNodes.get(cls.id);
+        if (!entry)
+            return null;
+        const body = entry.node.childForFieldName('body');
+        if (!body)
+            return null;
+        for (const m of named(body)) {
+            if ((m.type === 'public_field_definition' || m.type === 'field_definition') && (m.childForFieldName('name') ?? m.childForFieldName('property'))?.text === name) {
+                const type = m.childForFieldName('type');
+                if (type)
+                    return this.resolveTypeRef(entry.ctx, type);
+                const value = m.childForFieldName('value');
+                if (value?.type === 'new_expression') {
+                    const c = value.childForFieldName('constructor');
+                    return c ? this.resolveTypeRef(entry.ctx, c) : null;
+                }
+                return null;
+            }
+            if (m.type === 'method_definition' && m.childForFieldName('name')?.text === 'constructor') {
+                const params = m.childForFieldName('parameters');
+                for (const p of params ? named(params) : []) {
+                    const hasModifier = named(p).some(c => c.type === 'accessibility_modifier' || c.type === 'override_modifier')
+                        || /^\s*readonly\b/.test(p.text);
+                    if (!hasModifier || p.childForFieldName('pattern')?.text !== name)
+                        continue;
+                    const type = p.childForFieldName('type');
+                    return type ? this.resolveTypeRef(entry.ctx, type) : null;
+                }
+            }
+        }
+        const sup = this.supers.get(cls.id)?.extends;
+        return sup && sup !== 'external' ? this.typeOfField(sup, name) : null;
+    }
+    typeOf(ctx, expr) {
+        if (expr.type === 'this')
+            return this.enclosingClass(ctx, expr);
+        if (BUILTIN_TYPE_SHAPES.has(expr.type))
+            return 'external';
+        if (expr.type === 'parenthesized_expression' || expr.type === 'non_null_expression') {
+            const inner = named(expr)[0];
+            return inner ? this.typeOf(ctx, inner) : null;
+        }
+        if (expr.type === 'new_expression') {
+            const c = expr.childForFieldName('constructor');
+            return c ? this.resolveTypeRef(ctx, c) : null;
+        }
+        if (expr.type === 'identifier') {
+            const b = this.localBinding(expr, expr.text);
+            if (b?.kind === 'param') {
+                const type = b.node.childForFieldName('type');
+                if (type)
+                    return this.resolveTypeRef(ctx, type);
+                const value = b.node.childForFieldName('value') ?? b.node.childForFieldName('right');
+                const c = value?.type === 'new_expression' ? value.childForFieldName('constructor') : null;
+                return c ? this.resolveTypeRef(ctx, c) : null;
+            }
+            if (b?.kind === 'var')
+                return this.typeOfVar(ctx, b.node);
+            if (b)
+                return null;
+            const top = ctx.topVars.get(expr.text);
+            return top ? this.typeOfVar(ctx, top) : null;
+        }
+        if (expr.type === 'member_expression') {
+            const object = expr.childForFieldName('object');
+            const property = expr.childForFieldName('property');
+            if (object?.type === 'this' && property) {
+                const cls = this.enclosingClass(ctx, expr);
+                return cls ? this.typeOfField(cls, property.text) : null;
+            }
+        }
+        return null;
+    }
+    // -- members and dispatch --------------------------------------------------
+    /** Methods named `name` declared on `type` or inherited through `extends`. */
+    findMember(type, name, seen = new Set()) {
+        if (seen.has(type.id))
+            return null;
+        seen.add(type.id);
+        const own = this.membersOf(type, name);
+        if (own.length > 0)
+            return { decls: own, owner: type };
+        const s = this.supers.get(type.id);
+        if (s?.extends === 'external')
+            return 'external';
+        if (s?.extends) {
+            const r = this.findMember(s.extends, name, seen);
+            if (r)
+                return r;
+        }
+        for (const i of s?.implements ?? []) {
+            const r = this.findMember(i, name, seen);
+            if (r && r !== 'external')
+                return r;
+        }
+        return null;
+    }
+    membersOf(type, name) {
+        return (this.methodsByName.get(name) ?? []).filter(d => d.parent === type.id);
+    }
+    /** Bodies overriding `name` in every subtype of `type`, sorted by id. */
+    overrides(type, name) {
+        const out = new Map();
+        const walk = (t, seen) => {
+            for (const s of this.subs.get(t.id) ?? []) {
+                if (seen.has(s.id))
+                    continue;
+                seen.add(s.id);
+                for (const m of this.membersOf(s, name))
+                    if (!this.bodiless.has(m.id))
+                        out.set(m.id, m);
+                walk(s, seen);
+            }
+        };
+        walk(type, new Set([type.id]));
+        return [...out.values()].sort((a, b) => (a.id < b.id ? -1 : 1));
+    }
+    // -- sites -----------------------------------------------------------------
+    walk(ctx, node) {
+        const t = node.type;
+        if (t === 'member_expression' && node.childForFieldName('object')?.type === 'this')
+            this.fieldUse(ctx, node);
+        if (t === 'call_expression' || t === 'new_expression') {
+            this.site(ctx, node);
+            if (t === 'call_expression') {
+                this.registration(ctx, node);
+                this.reactRouterFactory(ctx, node);
+            }
+            const args = node.childForFieldName('arguments');
+            if (args?.type === 'arguments')
+                for (const a of named(args))
+                    this.reference(ctx, a);
+        }
+        else if (t === 'pair')
+            this.reference(ctx, node.childForFieldName('value'));
+        else if (t === 'shorthand_property_identifier')
+            this.reference(ctx, node);
+        else if (t === 'array')
+            for (const c of named(node))
+                this.reference(ctx, c);
+        else if (t === 'return_statement')
+            this.reference(ctx, named(node)[0] ?? null);
+        else if (t === 'arrow_function') {
+            const body = node.childForFieldName('body');
+            if (body && body.type !== 'statement_block')
+                this.reference(ctx, body);
+        }
+        else if (t === 'assignment_expression')
+            this.reference(ctx, node.childForFieldName('right'));
+        else if (t === 'variable_declarator')
+            this.reference(ctx, node.childForFieldName('value'));
+        else if (t === 'export_statement')
+            this.reference(ctx, node.childForFieldName('value'));
+        else if (t === 'jsx_opening_element' || t === 'jsx_self_closing_element')
+            this.reference(ctx, node.childForFieldName('name'));
+        if (t === 'jsx_element' || t === 'jsx_self_closing_element')
+            this.reactRouteElement(ctx, node);
+        else if (t === 'jsx_expression')
+            this.reference(ctx, named(node)[0] ?? null);
+        for (const c of named(node))
+            this.walk(ctx, c);
+    }
+    // -- field uses (`this.x`) -------------------------------------------------
+    /** `this.x` in a class body: the class's own or inherited field (or accessor) `x` is in use. */
+    fieldUse(ctx, node) {
+        const name = node.childForFieldName('property')?.text;
+        if (!name)
+            return;
+        const candidates = this.fieldsByName.get(name);
+        if (!candidates)
+            return;
+        const cls = this.enclosingClass(ctx, node);
+        if (!cls)
+            return;
+        const targets = [];
+        const seen = new Set();
+        for (let t = cls; t && !seen.has(t.id);) {
+            seen.add(t.id);
+            const own = candidates.filter(d => d.parent === t.id);
+            if (own.length > 0) {
+                targets.push(...own);
+                break;
+            }
+            const s = this.supers.get(t.id)?.extends;
+            t = s && s !== 'external' ? s : null;
+        }
+        if (targets.length === 0)
+            return;
+        const site = { file: ctx.path, line: node.startPosition.row + 1, col: node.startPosition.column };
+        const from = (ctx.locate(site.line, site.col) ?? ctx.module).id;
+        for (const d of targets)
+            if (d.id !== from)
+                this.fieldUses.push({ from, to: d.id, site });
+    }
+    // -- references (functions and classes used as values) ---------------------
+    reference(ctx, node) {
+        if (!node)
+            return;
+        if (node.type === 'parenthesized_expression' || node.type === 'as_expression' || node.type === 'non_null_expression' || node.type === 'satisfies_expression') {
+            this.reference(ctx, named(node)[0] ?? null);
+            return;
+        }
+        const targets = this.valueTargets(ctx, node);
+        if (targets.length === 0)
+            return;
+        const site = { file: ctx.path, line: node.startPosition.row + 1, col: node.startPosition.column };
+        const from = (ctx.locate(site.line, site.col) ?? ctx.module).id;
+        for (const d of targets)
+            if (d.id !== from)
+                this.references.push({ from, to: d.id, site });
+    }
+    callables(decls) {
+        return decls.filter(d => (d.kind === 'function' || d.kind === 'type' || d.kind === 'method') && !this.bodiless.has(d.id));
+    }
+    memberBodies(type, name) {
+        const found = this.findMember(type, name);
+        if (!found || found === 'external')
+            return [];
+        return [...this.callables(found.decls), ...this.overrides(found.owner, name)];
+    }
+    /** The declarations a value expression denotes: a function, a class or a method. */
+    valueTargets(ctx, node) {
+        if (node.type === 'identifier' || node.type === 'shorthand_property_identifier') {
+            const name = node.text;
+            const local = this.localBinding(node, name);
+            if (local) {
+                const loaded = local.kind === 'var' ? this.loadBinding(ctx, local.node, name) : null;
+                if (loaded) {
+                    const t = this.resolveBinding(loaded);
+                    return t.kind === 'decls' ? this.callables(t.decls) : [];
+                }
+                const holder = local.kind === 'var' ? local.node.childForFieldName('value') : local.kind === 'fn' ? local.node : null;
+                const d = holder && FUNCTION_NODES.has(holder.type) ? this.nestedDeclAt(ctx, holder) : null;
+                return d ? [d] : [];
+            }
+            const t = this.resolveLocal(ctx, name);
+            return t.kind === 'decls' ? this.callables(t.decls) : [];
+        }
+        if (node.type !== 'member_expression')
+            return [];
+        const object = node.childForFieldName('object');
+        const name = node.childForFieldName('property')?.text;
+        if (!object || !name)
+            return [];
+        if (object.type === 'this') {
+            const cls = this.enclosingClass(ctx, node);
+            return cls ? this.memberBodies(cls, name) : [];
+        }
+        if (object.type === 'identifier' && !this.localBinding(object, object.text)) {
+            const t = this.resolveLocal(ctx, object.text);
+            if (t.kind === 'namespace') {
+                const m = this.resolveExport(t.ctx, name, 0);
+                return m.kind === 'decls' ? this.callables(m.decls) : [];
+            }
+            const type = t.kind === 'decls' ? t.decls.find(d => d.kind === 'type') : undefined;
+            if (type)
+                return this.memberBodies(type, name);
+        }
+        const type = this.typeOf(ctx, object);
+        return type && type !== 'external' ? this.memberBodies(type, name) : [];
+    }
+    // -- entry points ----------------------------------------------------------
+    entry(d, kind, certainty, file, line, evidence, extra = {}) {
+        this.entries.push({ id: d.id, kind, certainty, file, line, evidence, ...extra });
+    }
+    /** Route registrations (`app.get('/x', h)`) and test-runner callbacks at a call site. */
+    registration(ctx, node) {
+        const fn = node.childForFieldName('function');
+        const argsNode = node.childForFieldName('arguments');
+        const args = argsNode ? named(argsNode) : [];
+        if (!fn)
+            return;
+        const line = node.startPosition.row + 1;
+        if (this.tables.tests.filePattern.test(ctx.path)) {
+            const runnerNode = fn.type === 'identifier' ? fn : fn.type === 'member_expression' ? fn.childForFieldName('object') : null;
+            const runner = runnerNode?.type === 'identifier' ? runnerNode.text : null;
+            if (runner && runnerNode && this.tables.tests.functions.includes(runner) && !this.localBinding(runnerNode, runner)
+                && this.resolveLocal(ctx, runner).kind !== 'decls') {
+                for (const a of args) {
+                    const d = FUNCTION_NODES.has(a.type) ? this.nestedDeclAt(ctx, a) : null;
+                    if (d)
+                        this.entry(d, 'test', 'conventional', ctx.path, a.startPosition.row + 1, `${runner} callback in a test file`);
+                }
+            }
+        }
+        if (fn.type !== 'member_expression')
+            return;
+        const verb = fn.childForFieldName('property')?.text;
+        if (!verb)
+            return;
+        let receiver = fn.childForFieldName('object');
+        const routes = this.tables.routes;
+        if ((routes.mountVerbs ?? []).includes(verb)) {
+            this.mount(ctx, receiver, args, line);
+            return;
+        }
+        if (!routes.verbs.includes(verb))
+            return;
+        let path = stringValue(args[0] ?? null);
+        let handlers = args.slice(1);
+        // `router.route('/x').get(a).post(b)`: step back over earlier verbs to the scoping call.
+        while (receiver?.type === 'call_expression') {
+            const prev = receiver.childForFieldName('function');
+            if (prev?.type !== 'member_expression' || !routes.verbs.includes(prev.childForFieldName('property')?.text ?? ''))
+                break;
+            const inner = prev.childForFieldName('object');
+            if (inner?.type !== 'call_expression')
+                break;
+            receiver = inner;
+        }
+        if (receiver?.type === 'call_expression' && routes.routeChain) {
+            const scope = receiver.childForFieldName('function');
+            const scopeArgs = receiver.childForFieldName('arguments');
+            if (scope?.type === 'member_expression' && scope.childForFieldName('property')?.text === routes.routeChain && scopeArgs) {
+                path = stringValue(named(scopeArgs)[0] ?? null);
+                handlers = args;
+                receiver = scope.childForFieldName('object');
+            }
+        }
+        if (path === null || !(path.startsWith('/') || path === '*'))
+            return;
+        const origin = this.routerOrigin(ctx, receiver, 0);
+        for (const h of handlers) {
+            const targets = FUNCTION_NODES.has(h.type)
+                ? [this.nestedDeclAt(ctx, h)].filter((d) => d !== null)
+                : this.valueTargets(ctx, h);
+            if (targets.length === 0) {
+                this.unresolvedRegistrations.push({
+                    site: { file: ctx.path, line: h.startPosition.row + 1, col: h.startPosition.column },
+                    reason: 'handler-unresolved',
+                    evidence: `${verb.toUpperCase()} ${path}: handler ${h.text.slice(0, 40)} not tied to a declaration`,
+                });
+                continue;
+            }
+            for (const d of targets) {
+                this.pendingRoutes.push({
+                    decl: d, certainty: origin.certainty, framework: origin.framework, method: verb.toUpperCase(), path,
+                    file: ctx.path, line, router: origin.key, surface: undefined,
+                    evidence: origin.framework ? `${origin.framework} route registration` : 'route-shaped registration on a receiver of unknown origin',
+                });
+            }
+        }
+    }
+    /**
+     * `X.use([prefix,] ...items)`: a router item is mounted under the prefix;
+     * a function item is middleware for every route under it.
+     */
+    mount(ctx, receiver, args, line) {
+        const prefix = stringValue(args[0] ?? null);
+        if (prefix !== null && !prefix.startsWith('/'))
+            return;
+        const items = prefix === null ? args : args.slice(1);
+        if (items.length === 0)
+            return;
+        const parent = this.routerOrigin(ctx, receiver, 0);
+        // Only a receiver that is itself a router of a known framework mounts anything.
+        if (parent.certainty !== 'declared' || !parent.key)
+            return;
+        for (const item of items) {
+            const child = item.type === 'identifier' || item.type === 'member_expression' ? this.routerOrigin(ctx, item, 0) : null;
+            if (child?.certainty === 'declared' && child.key) {
+                this.mounts.push({ parent: parent.key, child: child.key, prefix: prefix ?? '' });
+                continue;
+            }
+            // `app.use(cors())`: a factory's call is an ordinary call site, and the
+            // function it returns is contained in the factory's body.
+            if (item.type === 'call_expression' || item.type === 'new_expression')
+                continue;
+            const targets = FUNCTION_NODES.has(item.type)
+                ? [this.nestedDeclAt(ctx, item)].filter((d) => d !== null)
+                : this.valueTargets(ctx, item);
+            if (targets.length === 0) {
+                this.unresolvedRegistrations.push({
+                    site: { file: ctx.path, line: item.startPosition.row + 1, col: item.startPosition.column },
+                    reason: 'mount-unresolved',
+                    evidence: `use ${prefix ?? ''}: ${item.text.slice(0, 40)} is neither a known router nor a declared function`,
+                });
+                continue;
+            }
+            for (const d of targets) {
+                this.pendingRoutes.push({
+                    decl: d, certainty: 'declared', framework: parent.framework, method: 'USE', path: prefix ?? '/',
+                    file: ctx.path, line, router: parent.key, surface: 'middleware', evidence: `${parent.framework} middleware`,
+                });
+            }
+        }
+    }
+    /** Every chain of mount prefixes from a root router down to `key`, outermost first. */
+    mountChains(key, seen = new Set()) {
+        if (key === undefined || seen.has(key))
+            return [[]];
+        const parents = this.mounts.filter(m => m.child === key);
+        if (parents.length === 0)
+            return [[]];
+        const next = new Set(seen).add(key);
+        const out = [];
+        for (const m of parents) {
+            for (const chain of this.mountChains(m.parent, next)) {
+                out.push(m.prefix === '' ? chain : [...chain, m.prefix]);
+                if (out.length >= MAX_MOUNT_CHAINS)
+                    return out;
+            }
+        }
+        return out;
+    }
+    /** Routes with their mount chains composed into full paths. */
+    composeRoutes() {
+        for (const r of this.pendingRoutes) {
+            for (const chain of this.mountChains(r.router)) {
+                const extra = { method: r.method, path: joinRoutePath([...chain, r.path]) };
+                if (chain.length > 0) {
+                    extra.registeredPath = r.path;
+                    extra.mounts = chain;
+                }
+                if (r.framework)
+                    extra.framework = r.framework;
+                if (r.surface)
+                    extra.surface = r.surface;
+                this.entry(r.decl, 'route', r.certainty, r.file, r.line, r.evidence, extra);
+            }
+        }
+    }
+    // -- React Router ------------------------------------------------------------
+    reactRouterPackage(ctx, name) {
+        const table = this.tables.reactRouter;
+        const imp = ctx.imports.get(name);
+        if (!table || !imp || imp.module !== null || !table.packages.includes(imp.specifier))
+            return null;
+        return imp.specifier;
+    }
+    jsxName(el) {
+        const opening = el.type === 'jsx_element' ? named(el).find(c => c.type === 'jsx_opening_element') ?? null : el;
+        return opening?.childForFieldName('name') ?? null;
+    }
+    jsxAttributes(el) {
+        const opening = el.type === 'jsx_element' ? named(el).find(c => c.type === 'jsx_opening_element') : el;
+        const out = new Map();
+        for (const a of opening ? named(opening) : []) {
+            if (a.type !== 'jsx_attribute')
+                continue;
+            const parts = named(a);
+            const key = parts[0]?.text;
+            if (key)
+                out.set(key, parts[1] ?? null);
+        }
+        return out;
+    }
+    /** The `path` of a `<Route>` element, `''` for an index route, `null` when not a Route. */
+    routeElementPath(ctx, el) {
+        const name = this.jsxName(el);
+        const table = this.tables.reactRouter;
+        if (name?.type !== 'identifier' || !table || !table.routeElements.includes(name.text))
+            return null;
+        const pkg = this.reactRouterPackage(ctx, name.text);
+        if (!pkg)
+            return null;
+        const attrs = this.jsxAttributes(el);
+        const p = attrs.get('path');
+        const path = p ? stringValue(p) ?? (p.type === 'jsx_expression' ? stringValue(named(p)[0] ?? null) : null) : null;
+        if (path === null && !attrs.has('index'))
+            return null;
+        return { path: path ?? '', pkg };
+    }
+    /** Components a route renders: `element={<Page/>}`, `Component={Page}`, `component={Page}`. */
+    routeComponents(ctx, valueOf) {
+        const out = [];
+        const element = valueOf('element');
+        const inner = element?.type === 'jsx_expression' ? named(element)[0] ?? null : element;
+        if (inner && (inner.type === 'jsx_self_closing_element' || inner.type === 'jsx_element')) {
+            const n = this.jsxName(inner);
+            if (n)
+                out.push(...this.valueTargets(ctx, n));
+        }
+        for (const key of ['Component', 'component']) {
+            const v = valueOf(key);
+            const expr = v?.type === 'jsx_expression' ? named(v)[0] ?? null : v;
+            if (expr)
+                out.push(...this.valueTargets(ctx, expr));
+        }
+        return out;
+    }
+    /** `<Route>` elements, composed with every enclosing `<Route>`. */
+    reactRouteElement(ctx, el) {
+        const own = this.routeElementPath(ctx, el);
+        if (!own)
+            return;
+        const segments = [own.path];
+        for (let n = el.parent; n; n = n.parent) {
+            if (n.type !== 'jsx_element')
+                continue;
+            const outer = this.routeElementPath(ctx, n);
+            if (outer)
+                segments.unshift(outer.path);
+        }
+        const attrs = this.jsxAttributes(el);
+        const targets = this.routeComponents(ctx, k => attrs.get(k) ?? null);
+        this.reactRoutes(ctx, el, segments, targets, own.pkg);
+    }
+    reactRoutes(ctx, at, segments, targets, pkg) {
+        const path = composeRelative(segments);
+        if (targets.length === 0) {
+            this.unresolvedRegistrations.push({
+                site: { file: ctx.path, line: at.startPosition.row + 1, col: at.startPosition.column },
+                reason: 'handler-unresolved',
+                evidence: `route ${path}: no component tied to a declaration`,
+            });
+            return;
+        }
+        for (const d of targets) {
+            this.entry(d, 'route', 'declared', ctx.path, at.startPosition.row + 1, `${pkg} route`, { method: 'GET', path, framework: pkg, surface: 'page' });
+        }
+    }
+    /** `createBrowserRouter([{ path, element, children }])` and the other factories. */
+    reactRouterFactory(ctx, node) {
+        const table = this.tables.reactRouter;
+        const fn = node.childForFieldName('function');
+        if (!table || fn?.type !== 'identifier' || !table.routerFactories.includes(fn.text))
+            return;
+        const pkg = this.reactRouterPackage(ctx, fn.text);
+        const argsNode = node.childForFieldName('arguments');
+        const list = argsNode ? named(argsNode)[0] : undefined;
+        if (!pkg || list?.type !== 'array')
+            return;
+        const walk = (arr, parents) => {
+            for (const obj of named(arr)) {
+                if (obj.type !== 'object')
+                    continue;
+                const fields = new Map();
+                for (const pair of named(obj)) {
+                    if (pair.type === 'pair') {
+                        const key = pair.childForFieldName('key');
+                        const k = key?.type === 'string' ? stringValue(key) : key?.text;
+                        if (k)
+                            fields.set(k, pair.childForFieldName('value'));
+                    }
+                    else if (pair.type === 'shorthand_property_identifier')
+                        fields.set(pair.text, pair);
+                }
+                const p = fields.get('path');
+                const own = p ? stringValue(p) : fields.has('index') ? '' : null;
+                const segments = own === null ? parents : [...parents, own];
+                const targets = this.routeComponents(ctx, k => fields.get(k) ?? null);
+                if (own !== null)
+                    this.reactRoutes(ctx, obj, segments, targets, pkg);
+                const children = fields.get('children');
+                if (children?.type === 'array')
+                    walk(children, segments);
+            }
+        };
+        walk(list, []);
+    }
+    // -- Next.js file routes -----------------------------------------------------
+    /** Next.js `pages/`, `app/` and `middleware` conventions under `root`. */
+    nextFileRoutes(root) {
+        const prefix = normalizePath(root);
+        for (const ctx of this.sortedFiles()) {
+            if (prefix !== '' && !ctx.path.startsWith(prefix + '/'))
+                continue;
+            const rel = prefix === '' ? ctx.path : ctx.path.slice(prefix.length + 1);
+            const m = rel.match(/^(?:src\/)?(pages|app)\/(.*)\.[cm]?[jt]sx?$/);
+            const mw = /^(?:src\/)?middleware\.[cm]?[jt]s$/.test(rel);
+            const exported = (name) => {
+                const t = this.resolveExport(ctx, name, 0);
+                return t.kind === 'decls' ? t.decls.filter(d => !this.bodiless.has(d.id)) : [];
+            };
+            const add = (d, kind, extra, evidence) => this.entry(d, kind, 'conventional', ctx.path, d.start_line, evidence, { framework: 'next', ...extra });
+            if (mw) {
+                for (const d of [...exported('middleware'), ...exported('default')])
+                    add(d, 'route', { method: 'USE', path: '/', surface: 'middleware' }, 'Next.js middleware');
+                continue;
+            }
+            if (!m)
+                continue;
+            const [, dir, rest] = m;
+            const segments = rest.split('/');
+            if (dir === 'pages') {
+                const last = segments[segments.length - 1];
+                if (/^_(app|document|error)$/.test(last)) {
+                    for (const d of exported('default'))
+                        add(d, 'lifecycle', {}, `Next.js ${last}`);
+                    continue;
+                }
+                if (last === 'index')
+                    segments.pop();
+                const path = filePath(segments);
+                const api = segments[0] === 'api';
+                for (const d of exported('default'))
+                    add(d, 'route', { method: api ? 'ANY' : 'GET', path, surface: api ? 'api' : 'page' }, `Next.js pages/${rest}`);
+                if (!api) {
+                    for (const n of ['getServerSideProps', 'getStaticProps', 'getStaticPaths', 'getInitialProps']) {
+                        for (const d of exported(n))
+                            add(d, 'lifecycle', { path }, `Next.js ${n}`);
+                    }
+                }
+                continue;
+            }
+            const file = segments.pop() ?? '';
+            const path = filePath(segments);
+            if (file === 'page') {
+                for (const d of exported('default'))
+                    add(d, 'route', { method: 'GET', path, surface: 'page' }, 'Next.js app page');
+            }
+            else if (file === 'layout' || file === 'template') {
+                for (const d of exported('default'))
+                    add(d, 'route', { method: 'GET', path, surface: 'layout' }, `Next.js app ${file}`);
+            }
+            else if (file === 'route') {
+                for (const method of ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']) {
+                    for (const d of exported(method))
+                        add(d, 'route', { method, path, surface: 'api' }, 'Next.js route handler');
+                }
+            }
+            else
+                continue;
+            if (file === 'page' || file === 'layout') {
+                for (const n of ['generateMetadata', 'generateStaticParams'])
+                    for (const d of exported(n))
+                        add(d, 'lifecycle', { path }, `Next.js ${n}`);
+            }
+        }
+    }
+    // -- React Native, Expo and Jest ---------------------------------------------
+    /** Files a tool loads by name or place, for the tools the package depends on. */
+    toolFileEntries(root, has) {
+        const rows = (this.tables.toolFiles ?? []).filter(r => has(r.dependencies));
+        if (rows.length === 0)
+            return;
+        const prefix = normalizePath(root);
+        for (const ctx of this.sortedFiles()) {
+            if (prefix !== '' && !ctx.path.startsWith(prefix + '/'))
+                continue;
+            const rel = prefix === '' ? ctx.path : ctx.path.slice(prefix.length + 1);
+            if (rel.split('/').includes('node_modules'))
+                continue;
+            const row = rows.find(r => r.pattern.test(rel));
+            if (row)
+                this.toolFile(ctx, row.kind, row.tool, `loaded by ${row.tool} (${rel})`);
+        }
+    }
+    /** The module and what it exports: the tool runs the file and uses its exports. */
+    toolFile(ctx, kind, tool, evidence) {
+        this.entry(ctx.module, kind, 'conventional', ctx.path, 1, evidence, { framework: tool });
+        for (const d of this.exportedDecls(ctx))
+            this.entry(d, kind, 'conventional', ctx.path, d.start_line, evidence, { framework: tool });
+    }
+    /** expo-router: every file under `app/` is a screen, `_layout` wraps them, `+` files are special. */
+    expoFileRoutes(root) {
+        const prefix = normalizePath(root);
+        for (const ctx of this.sortedFiles()) {
+            if (prefix !== '' && !ctx.path.startsWith(prefix + '/'))
+                continue;
+            const rel = prefix === '' ? ctx.path : ctx.path.slice(prefix.length + 1);
+            const m = rel.match(/^(?:src\/)?app\/(.*)\.[cm]?[jt]sx?$/);
+            if (!m || /\.d\.ts$/.test(rel))
+                continue;
+            const exported = (name) => {
+                const t = this.resolveExport(ctx, name, 0);
+                return t.kind === 'decls' ? t.decls.filter(d => !this.bodiless.has(d.id)) : [];
+            };
+            const add = (d, kind, extra, evidence) => this.entry(d, kind, 'conventional', ctx.path, d.start_line, evidence, { framework: 'expo-router', ...extra });
+            const segments = m[1].split('/');
+            const file = segments.pop() ?? '';
+            const path = filePath(segments);
+            const api = file.match(/^(.*)\+api$/);
+            if (api) {
+                const full = filePath([...segments, ...(api[1] === 'index' ? [] : [api[1]])]);
+                for (const method of ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']) {
+                    for (const d of exported(method))
+                        add(d, 'route', { method, path: full, surface: 'api' }, 'expo-router API route');
+                }
+            }
+            else if (file === '_layout') {
+                for (const d of exported('default'))
+                    add(d, 'route', { method: 'GET', path, surface: 'layout' }, 'expo-router layout');
+                for (const d of exported('ErrorBoundary'))
+                    add(d, 'lifecycle', { path }, 'expo-router ErrorBoundary');
+            }
+            else if (file === '+html' || file === '+native-intent') {
+                for (const d of exported('default'))
+                    add(d, 'lifecycle', { path }, `expo-router ${file}`);
+                for (const d of exported('redirectSystemPath'))
+                    add(d, 'lifecycle', { path }, `expo-router ${file}`);
+            }
+            else if (file.startsWith('+')) {
+                for (const d of exported('default'))
+                    add(d, 'route', { method: 'GET', path, surface: 'page' }, `expo-router ${file}`);
+            }
+            else if (!file.startsWith('_')) {
+                const full = filePath(file === 'index' ? segments : [...segments, file]);
+                for (const d of exported('default'))
+                    add(d, 'route', { method: 'GET', path: full, surface: 'page' }, 'expo-router screen');
+                for (const n of ['ErrorBoundary', 'generateStaticParams'])
+                    for (const d of exported(n))
+                        add(d, 'lifecycle', { path: full }, `expo-router ${n}`);
+            }
+        }
+    }
+    /** Config plugins named by a relative path in `app.json` or `app.config.*`. */
+    expoPlugins(pkg, where) {
+        const specs = [];
+        if (pkg.appJson !== undefined) {
+            try {
+                const j = (JSON.parse(pkg.appJson) ?? {});
+                const expo = (j.expo ?? j);
+                for (const p of Array.isArray(expo.plugins) ? expo.plugins : []) {
+                    const s = Array.isArray(p) ? p[0] : p;
+                    if (typeof s === 'string')
+                        specs.push(s);
+                }
+            }
+            catch {
+                this.unresolvedRegistrations.push({ site: { ...where, file: normalizePath(`${pkg.root}/app.json`) }, reason: 'manifest-unresolved', evidence: 'app.json does not parse' });
+            }
+        }
+        const config = this.findFile(normalizePath(`${pkg.root}/app.config.ts`));
+        const ctx = config ? this.files.get(config) : undefined;
+        if (ctx) {
+            const visit = (n) => {
+                if (n.type === 'pair') {
+                    const key = n.childForFieldName('key');
+                    const value = n.childForFieldName('value');
+                    const k = key?.type === 'string' ? stringValue(key) : key?.text;
+                    if (k === 'plugins' && value?.type === 'array') {
+                        for (const el of named(value)) {
+                            const first = el.type === 'array' ? named(el)[0] : el;
+                            const s = first && first.type === 'string' ? stringValue(first) : null;
+                            if (s)
+                                specs.push(s);
+                        }
+                    }
+                }
+                for (const c of named(n))
+                    visit(c);
+            };
+            visit(ctx.root);
+        }
+        for (const spec of [...new Set(specs)].filter(s => s.startsWith('.'))) {
+            const file = this.sourceFor(pkg.root, spec);
+            const plugin = file ? this.files.get(file) : undefined;
+            if (plugin)
+                this.toolFile(plugin, 'main', 'expo', `Expo config plugin (${spec})`);
+            else
+                this.unresolvedRegistrations.push({ site: where, reason: 'manifest-unresolved', evidence: `config plugin ${spec} not found in the tree` });
+        }
+    }
+    /**
+     * Where a router receiver comes from: a framework package (declared) or
+     * unknown (inferred). `key` names the router object across files.
+     */
+    routerOrigin(ctx, receiver, depth) {
+        if (receiver?.type !== 'identifier' || depth > 3)
+            return { certainty: 'inferred' };
+        const local = this.localBinding(receiver, receiver.text);
+        const declarator = local?.kind === 'var' ? local.node : local ? null : ctx.topVars.get(receiver.text) ?? null;
+        if (!declarator) {
+            const imp = ctx.imports.get(receiver.text);
+            if ((imp?.kind === 'named' || imp?.kind === 'default') && imp.module) {
+                const target = this.files.get(imp.module);
+                const name = imp.kind === 'named' ? imp.name : target?.defaultLocal;
+                const v = target && name ? target.topVars.get(name) : undefined;
+                if (target && v)
+                    return this.routerOrigin(target, v.childForFieldName('name'), depth + 1);
+            }
+            return { certainty: 'inferred' };
+        }
+        const value = declarator.childForFieldName('value');
+        if (value?.type !== 'call_expression' && value?.type !== 'new_expression')
+            return { certainty: 'inferred' };
+        let callee = value.type === 'call_expression' ? value.childForFieldName('function') : value.childForFieldName('constructor');
+        while (callee?.type === 'member_expression')
+            callee = callee.childForFieldName('object');
+        if (callee?.type !== 'identifier')
+            return { certainty: 'inferred' };
+        const imp = ctx.imports.get(callee.text);
+        if (imp && imp.module === null && this.tables.routes.packages.includes(imp.specifier)) {
+            const key = `${ctx.path}#${declarator.startPosition.row + 1}:${declarator.startPosition.column}`;
+            return { certainty: 'declared', framework: imp.specifier, key };
+        }
+        return { certainty: 'inferred' };
+    }
+    decoratorsOf(node) {
+        const own = named(node).filter(c => c.type === 'decorator');
+        const parent = node.parent?.type === 'export_statement' ? named(node.parent).filter(c => c.type === 'decorator') : [];
+        return [...parent, ...own];
+    }
+    decoratorCall(ctx, dec) {
+        const inner = named(dec)[0];
+        let callee = inner ?? null;
+        let args = [];
+        if (inner?.type === 'call_expression') {
+            callee = inner.childForFieldName('function');
+            const a = inner.childForFieldName('arguments');
+            args = a ? named(a) : [];
+        }
+        if (callee?.type !== 'identifier')
+            return null;
+        const imp = ctx.imports.get(callee.text);
+        if (!imp)
+            return null;
+        return { name: imp.kind === 'named' ? imp.name : callee.text, pkg: imp.specifier, args };
+    }
+    decoratorEntries(ctx, classNode, cls) {
+        const classDecs = this.decoratorsOf(classNode).map(d => this.decoratorCall(ctx, d)).filter(x => x !== null);
+        const rows = this.tables.decorators;
+        for (const row of rows) {
+            if (row.on !== 'class')
+                continue;
+            const hit = classDecs.find(d => d.pkg === row.package && row.names.includes(d.name));
+            if (!hit)
+                continue;
+            const ctor = this.membersOf(cls, 'constructor').find(d => !this.bodiless.has(d.id));
+            this.entry(ctor ?? cls, row.kind, 'declared', ctx.path, cls.start_line, `@${hit.name} from ${row.package}`, { framework: row.package });
+        }
+        const body = classNode.childForFieldName('body');
+        if (!body)
+            return;
+        let pending = [];
+        for (const m of named(body)) {
+            if (m.type === 'decorator') {
+                pending.push(m);
+                continue;
+            }
+            if (m.type === 'method_definition' && pending.length > 0) {
+                const decl = ctx.byStart.get(posKey(m, 'method'));
+                for (const dec of pending) {
+                    const info = this.decoratorCall(ctx, dec);
+                    const row = info ? rows.find(r => r.on === 'method' && r.package === info.pkg && r.names.includes(info.name)) : undefined;
+                    if (!info || !row || !decl)
+                        continue;
+                    const extra = { framework: row.package };
+                    if (row.kind === 'route') {
+                        const prefixDec = row.prefixFrom ? classDecs.find(d => d.pkg === row.package && d.name === row.prefixFrom) : undefined;
+                        const prefix = stringValue(prefixDec?.args[0] ?? null) ?? '';
+                        const own = stringValue(info.args[0] ?? null) ?? '';
+                        extra.method = info.name.toUpperCase();
+                        extra.path = '/' + [prefix, own].map(x => x.replace(/^\/+|\/+$/g, '')).filter(x => x !== '').join('/');
+                    }
+                    this.entry(decl, row.kind, 'declared', ctx.path, decl.start_line, `@${info.name} from ${row.package}`, extra);
+                }
+            }
+            pending = [];
+        }
+    }
+    findFile(stem) {
+        if (this.files.has(stem))
+            return stem;
+        const bare = stem.replace(/\.(?:d\.ts|[mc]?[jt]sx?)$/, '');
+        for (const ext of EXTENSIONS)
+            if (this.files.has(bare + ext))
+                return bare + ext;
+        for (const ext of EXTENSIONS)
+            if (this.files.has(`${bare}/index${ext}`))
+                return `${bare}/index${ext}`;
+        return null;
+    }
+    /** A manifest path to a source file: as written, else the build output mapped back to `src/`. */
+    sourceFor(root, p) {
+        const base = normalizePath(`${root}/${p}`);
+        const direct = this.findFile(base);
+        if (direct)
+            return direct;
+        const prefix = normalizePath(root);
+        const inner = prefix === '' ? base : base.slice(prefix.length + 1);
+        const mapped = inner.replace(/^(?:dist|lib|build|out)(?:\/(?:esm|cjs|src))?\//, 'src/');
+        return mapped === inner ? null : this.findFile(normalizePath(`${prefix}/${mapped}`));
+    }
+    /** Names a file exports, re-exports included; every module-level name for a file without ES exports. */
+    exportedDecls(ctx, seen = new Set()) {
+        if (seen.has(ctx.path))
+            return [];
+        seen.add(ctx.path);
+        const names = new Set([...ctx.exports.keys(), ...ctx.reexports.keys()]);
+        if (ctx.defaultLocal !== null || ctx.top.has('default'))
+            names.add('default');
+        if (!ctx.esm)
+            for (const n of ctx.top.keys())
+                names.add(n);
+        const out = [];
+        for (const n of [...names].sort()) {
+            const t = this.resolveExport(ctx, n, 0);
+            if (t.kind === 'decls')
+                out.push(...t.decls.filter(d => !this.bodiless.has(d.id)));
+        }
+        for (const m of ctx.stars) {
+            const target = m === null ? undefined : this.files.get(m);
+            if (target)
+                out.push(...this.exportedDecls(target, seen));
+        }
+        return out;
+    }
+    exportEntries(ctx, evidence) {
+        for (const d of this.exportedDecls(ctx))
+            this.entry(d, 'export', 'declared', ctx.path, d.start_line, evidence);
+    }
+    /** Entries from package manifests and the caller's lists. */
+    manifestEntries() {
+        for (const pkg of this.options.packages ?? []) {
+            const where = { file: normalizePath(`${pkg.root}/package.json`), line: 1, col: 0 };
+            let json;
+            try {
+                json = JSON.parse(pkg.packageJson);
+            }
+            catch {
+                this.unresolvedRegistrations.push({ site: where, reason: 'manifest-unresolved', evidence: 'package.json does not parse' });
+                continue;
+            }
+            const m = (json ?? {});
+            const strings = (v, out = []) => {
+                if (typeof v === 'string')
+                    out.push(v);
+                else if (Array.isArray(v))
+                    for (const x of v)
+                        strings(x, out);
+                else if (v && typeof v === 'object')
+                    for (const k of Object.keys(v).sort())
+                        strings(v[k], out);
+                return out;
+            };
+            const exportPaths = [...strings(m.main), ...strings(m.module), ...strings(m.exports)].filter(p => !p.endsWith('.json') && !p.endsWith('.d.ts') && !p.includes('*'));
+            for (const p of [...new Set(exportPaths)]) {
+                const file = this.sourceFor(pkg.root, p);
+                const ctx = file ? this.files.get(file) : undefined;
+                if (ctx)
+                    this.exportEntries(ctx, `exported by package.json (${p})`);
+                else
+                    this.unresolvedRegistrations.push({ site: where, reason: 'manifest-unresolved', evidence: `export path ${p} not found in the tree` });
+            }
+            const deps = { ...m.dependencies, ...m.devDependencies };
+            const next = this.tables.nextFileRoutes;
+            if (next && Object.prototype.hasOwnProperty.call(deps, next.dependency))
+                this.nextFileRoutes(pkg.root);
+            this.scriptEntries(pkg.root, m.scripts);
+            const has = (names) => names.some(n => Object.prototype.hasOwnProperty.call(deps, n));
+            this.toolFileEntries(pkg.root, has);
+            if (this.tables.expo && has(this.tables.expo.dependencies)) {
+                this.expoFileRoutes(pkg.root);
+                this.expoPlugins(pkg, where);
+            }
+            for (const p of [...new Set(strings(m.bin))]) {
+                const file = this.sourceFor(pkg.root, p);
+                const ctx = file ? this.files.get(file) : undefined;
+                if (ctx)
+                    this.entry(ctx.module, 'main', 'declared', ctx.path, 1, `package.json bin (${p})`);
+                else
+                    this.unresolvedRegistrations.push({ site: where, reason: 'manifest-unresolved', evidence: `bin ${p} not found in the tree` });
+            }
+        }
+        if (this.tables.nextFileRoutes)
+            for (const root of this.options.fileRouteRoots?.next ?? [])
+                this.nextFileRoutes(root);
+        this.composeRoutes();
+        for (const f of this.options.exportRoots ?? []) {
+            const ctx = this.files.get(normalizePath(f));
+            if (ctx)
+                this.exportEntries(ctx, 'export root given by the caller');
+        }
+        for (const f of this.options.mainFiles ?? []) {
+            const ctx = this.files.get(normalizePath(f));
+            if (ctx)
+                this.entry(ctx.module, 'main', 'declared', ctx.path, 1, 'program file given by the caller');
+        }
+        for (const ctx of this.sortedFiles()) {
+            if (this.tables.tests.filePattern.test(ctx.path))
+                this.entry(ctx.module, 'test', 'conventional', ctx.path, 1, 'test file loaded by the runner');
+        }
+        this.programFiles();
+    }
+    /** Files a `package.json` script runs (`node scripts/build.mjs`, `tsx bench/x.ts`): `main` entries. */
+    scriptEntries(root, scripts) {
+        const table = this.tables.scripts;
+        if (!table || !scripts || typeof scripts !== 'object')
+            return;
+        for (const name of Object.keys(scripts).sort()) {
+            const cmd = scripts[name];
+            if (typeof cmd !== 'string')
+                continue;
+            for (const raw of cmd.split(/\s+|&&|\|\||[;|()]/)) {
+                const token = raw.replace(/^['"]|['"]$/g, '').replace(/^\.\//, '');
+                if (!/\.[cm]?[jt]sx?$/.test(token) || token.startsWith('-') || token.includes('*'))
+                    continue;
+                const file = this.findFile(normalizePath(`${root}/${token}`));
+                const ctx = file ? this.files.get(file) : undefined;
+                if (ctx)
+                    this.entry(ctx.module, 'main', 'declared', ctx.path, 1, `package.json script ${name}`);
+            }
+        }
+    }
+    /** Files in script directories, and files starting with `#!`: run as programs (`main`, conventional). */
+    programFiles() {
+        const table = this.tables.scripts;
+        if (!table)
+            return;
+        const roots = [...new Set((this.options.packages ?? []).map(p => normalizePath(p.root)))];
+        if (roots.length === 0)
+            roots.push('');
+        for (const ctx of this.sortedFiles()) {
+            const inDir = roots.some(r => table.dirs.some(d => ctx.path.startsWith(normalizePath(`${r}/${d}`) + '/')));
+            const shebang = table.shebang && ctx.root.firstChild?.type === 'hash_bang_line';
+            if (inDir)
+                this.entry(ctx.module, 'main', 'conventional', ctx.path, 1, 'file in a script directory');
+            else if (shebang)
+                this.entry(ctx.module, 'main', 'conventional', ctx.path, 1, 'file starts with #!');
+        }
+    }
+    importEdges() {
+        const out = new Map();
+        for (const ctx of this.sortedFiles()) {
+            for (const m of ctx.loads) {
+                const to = this.files.get(m);
+                if (to && to !== ctx)
+                    out.set(`${ctx.module.id}>${to.module.id}`, { from: ctx.module.id, to: to.module.id });
+            }
+        }
+        return [...out.values()];
+    }
+    site(ctx, node) {
+        const fn = node.type === 'new_expression' ? node.childForFieldName('constructor') : node.childForFieldName('function');
+        if (!fn)
+            return;
+        const site = { file: ctx.path, line: node.startPosition.row + 1, col: node.startPosition.column };
+        // Module loading is not a call: a literal specifier is a load edge, a computed one an unresolved site.
+        const load = node.type === 'call_expression' && (fn.type === 'import' || !this.localBinding(fn, 'require')) ? moduleLoad(node) : null;
+        if (load) {
+            const owner = ctx.locate(site.line, site.col) ?? ctx.module;
+            if (load.spec !== null) {
+                const module = this.resolveModule(ctx.path, load.spec);
+                const to = module ? this.files.get(module) : undefined;
+                if (!module || !to)
+                    return;
+                if (owner === ctx.module)
+                    ctx.loads.push(module);
+                else
+                    this.loadEdges.push({ from: owner.id, to: to.module.id, site });
+                return;
+            }
+            this.sites++;
+            this.unresolved.push({ from: owner.id, methodName: COMPUTED_MODULE_LOAD, site, reason: 'dynamic', evidence: 'module loaded by a computed specifier' });
+            return;
+        }
+        this.sites++;
+        const from = (ctx.locate(site.line, site.col) ?? ctx.module).id;
+        const edge = (to, tier, methodName, evidence, via) => {
+            const e = { from, to: to.id, tier, methodName, site, evidence };
+            if (via)
+                e.via = via.id;
+            this.edges.push(e);
+        };
+        const unresolved = (methodName, reason, evidence) => {
+            this.unresolved.push({ from, methodName, site, reason, evidence });
+        };
+        if (node.type === 'new_expression') {
+            this.construct(ctx, fn, edge, unresolved);
+            return;
+        }
+        if (fn.type === 'super') {
+            const cls = this.enclosingClass(ctx, node);
+            const sup = cls ? this.supers.get(cls.id)?.extends : null;
+            if (sup === 'external')
+                unresolved('super', 'external', 'superclass outside the tree');
+            else if (sup)
+                this.constructType(sup, 'super', edge);
+            else
+                unresolved('super', 'unknown', 'no superclass found');
+            return;
+        }
+        if (fn.type === 'identifier') {
+            this.callName(ctx, fn, edge, unresolved);
+            return;
+        }
+        if (fn.type === 'parenthesized_expression') {
+            const inner = named(fn)[0];
+            const d = inner && FUNCTION_NODES.has(inner.type) ? this.nestedDeclAt(ctx, inner) : null;
+            if (d)
+                edge(d, 'exact', '<iife>', 'immediately invoked function');
+            else
+                unresolved('<expr>', 'dynamic', 'callee is an expression');
+            return;
+        }
+        if (fn.type === 'member_expression') {
+            this.callMember(ctx, fn, edge, unresolved);
+            return;
+        }
+        unresolved('<expr>', 'dynamic', `callee is a ${fn.type}`);
+    }
+    construct(ctx, fn, edge, unresolved) {
+        const name = fn.text;
+        if (fn.type !== 'identifier' && fn.type !== 'member_expression') {
+            unresolved(name, 'dynamic', 'constructed from an expression');
+            return;
+        }
+        if (fn.type === 'identifier' && this.localBinding(fn, fn.text)) {
+            unresolved(name, 'dynamic', 'class bound to a local value');
+            return;
+        }
+        const t = this.resolveTypeRef(ctx, fn);
+        if (t === 'external' || t === null)
+            unresolved(name, 'external', 'class outside the tree');
+        else
+            this.constructType(t, name, edge);
+    }
+    constructType(t, name, edge) {
+        const ctor = this.membersOf(t, 'constructor').find(d => !this.bodiless.has(d.id));
+        edge(ctor ?? t, 'exact', name, ctor ? 'constructor of a resolved class' : 'class without its own constructor');
+    }
+    callName(ctx, fn, edge, unresolved) {
+        const name = fn.text;
+        const local = this.localBinding(fn, name);
+        if (local) {
+            const loaded = local.kind === 'var' ? this.loadBinding(ctx, local.node, name) : null;
+            if (loaded) {
+                this.bindTarget(this.resolveBinding(loaded), name, edge, unresolved, 'bound from a module load');
+                return;
+            }
+            const holder = local.kind === 'var' ? local.node.childForFieldName('value') : local.kind === 'fn' ? local.node : null;
+            const d = holder && FUNCTION_NODES.has(holder.type) ? this.nestedDeclAt(ctx, holder) : null;
+            if (d)
+                edge(d, 'exact', name, 'nested function in lexical scope');
+            else
+                unresolved(name, 'dynamic', local.kind === 'param' ? 'callee is a parameter' : 'callee is a local value');
+            return;
+        }
+        this.bindTarget(this.resolveLocal(ctx, name), name, edge, unresolved, 'module scope or import');
+    }
+    bindTarget(target, name, edge, unresolved, how) {
+        if (target.kind === 'external') {
+            unresolved(name, 'external', 'imported from outside the tree');
+            return;
+        }
+        if (target.kind === 'none') {
+            unresolved(name, 'external', 'not declared in the tree (global or ambient)');
+            return;
+        }
+        if (target.kind === 'namespace') {
+            unresolved(name, 'dynamic', 'a module namespace is not callable');
+            return;
+        }
+        const fns = target.decls.filter(d => d.kind === 'function');
+        if (fns.length === 0) {
+            const type = target.decls.find(d => d.kind === 'type');
+            if (type)
+                unresolved(name, 'unknown', 'a class called without new');
+            else
+                unresolved(name, 'dynamic', 'callee is a value, not a declared function');
+            return;
+        }
+        const bodied = fns.filter(d => !this.bodiless.has(d.id));
+        if (bodied.length === 1)
+            edge(bodied[0], 'exact', name, how);
+        else if (bodied.length === 0)
+            unresolved(name, 'external', 'declared without a body (ambient)');
+        else
+            unresolved(name, 'overload-ambiguous', `${bodied.length} bodies with this name`);
+    }
+    /** The namespace a module load gives: a local bound to one, or the load expression itself. */
+    loadedNamespace(ctx, object) {
+        let binding = null;
+        if (object.type === 'identifier') {
+            const local = this.localBinding(object, object.text);
+            binding = local?.kind === 'var' ? this.loadBinding(ctx, local.node, object.text) : null;
+        }
+        else {
+            const load = moduleLoad(object);
+            if (load?.spec != null)
+                binding = { kind: 'namespace', module: this.resolveModule(ctx.path, load.spec), specifier: load.spec };
+        }
+        if (binding?.kind !== 'namespace')
+            return null;
+        const t = this.resolveBinding(binding);
+        return t.kind === 'namespace' || t.kind === 'external' ? t : null;
+    }
+    callMember(ctx, fn, edge, unresolved) {
+        const object = fn.childForFieldName('object');
+        const property = fn.childForFieldName('property');
+        if (!object || !property) {
+            unresolved(fn.text, 'dynamic', 'incomplete member expression');
+            return;
+        }
+        const name = property.text;
+        if (property.type === 'private_property_identifier' && object.type !== 'this') {
+            unresolved(name, 'unknown', 'private member on another receiver');
+            return;
+        }
+        // `super.m()`
+        if (object.type === 'super') {
+            const cls = this.enclosingClass(ctx, fn);
+            const sup = cls ? this.supers.get(cls.id)?.extends : null;
+            if (!sup || sup === 'external') {
+                unresolved(name, sup === 'external' ? 'external' : 'unknown', 'superclass method');
+                return;
+            }
+            const found = this.findMember(sup, name);
+            if (found === 'external' || !found)
+                unresolved(name, found === 'external' ? 'external' : 'unknown', 'superclass method not in the tree');
+            else
+                this.bindMembers(found.decls, name, 'exact', edge, unresolved, 'super call');
+            return;
+        }
+        // `m.f()` on `const m = await import('./m')`, `(await import('./m')).f()`
+        const loadedNs = this.loadedNamespace(ctx, object);
+        if (loadedNs) {
+            if (loadedNs.kind === 'namespace') {
+                const member = this.resolveExport(loadedNs.ctx, name, 0);
+                if (member.kind === 'none')
+                    unresolved(name, 'unknown', 'not exported by a module in the tree');
+                else
+                    this.bindTarget(member, name, edge, unresolved, 'module namespace from a module load');
+            }
+            else
+                unresolved(name, 'external', 'module loaded from outside the tree');
+            return;
+        }
+        // `ns.f()` on a module namespace, `C.m()` on a class name
+        if (object.type === 'identifier' && !this.localBinding(object, object.text)) {
+            const target = this.resolveLocal(ctx, object.text);
+            if (target.kind === 'namespace') {
+                const member = this.resolveExport(target.ctx, name, 0);
+                if (member.kind === 'none')
+                    unresolved(name, 'unknown', 'not exported by a module in the tree');
+                else
+                    this.bindTarget(member, name, edge, unresolved, 'module namespace');
+                return;
+            }
+            if (target.kind === 'external' || (target.kind === 'none' && !ctx.topVars.has(object.text))) {
+                unresolved(name, 'external', 'receiver declared outside the tree');
+                return;
+            }
+            if (target.kind === 'decls') {
+                const type = target.decls.find(d => d.kind === 'type');
+                if (type) {
+                    const found = this.findMember(type, name);
+                    if (found && found !== 'external')
+                        this.bindMembers(found.decls, name, 'exact', edge, unresolved, 'static member of a resolved class');
+                    else
+                        unresolved(name, found === 'external' ? 'external' : 'unknown', 'static member not found');
+                    return;
+                }
+            }
+        }
+        const type = this.typeOf(ctx, object);
+        if (type === 'external') {
+            unresolved(name, 'external', 'receiver type declared outside the tree');
+            return;
+        }
+        if (type) {
+            this.dispatch(type, name, edge, unresolved);
+            return;
+        }
+        this.infer(name, edge, unresolved);
+    }
+    dispatch(type, name, edge, unresolved) {
+        const found = this.findMember(type, name);
+        if (found === 'external') {
+            unresolved(name, 'external', 'member inherited from outside the tree');
+            return;
+        }
+        if (!found) {
+            unresolved(name, 'unknown', 'member not found on the receiver type');
+            return;
+        }
+        const bodied = found.decls.filter(d => !this.bodiless.has(d.id));
+        if (bodied.length > 1) {
+            unresolved(name, 'overload-ambiguous', `${bodied.length} bodies with this name`);
+            return;
+        }
+        const declaring = bodied[0] ?? found.decls[0];
+        const subs = this.overrides(found.owner, name);
+        if (bodied.length === 1 && subs.length === 0) {
+            edge(bodied[0], 'exact', name, 'receiver type known; no override in the tree');
+            return;
+        }
+        const bodies = [...(bodied.length === 1 ? [bodied[0]] : []), ...subs];
+        if (bodies.length === 0) {
+            unresolved(name, 'external', 'abstract or interface member with no implementation in the tree');
+            return;
+        }
+        for (const b of bodies)
+            edge(b, 'polymorphic', name, 'receiver type known; dispatch open', declaring);
+    }
+    bindMembers(decls, name, tier, edge, unresolved, evidence) {
+        const bodied = decls.filter(d => !this.bodiless.has(d.id));
+        if (bodied.length === 1)
+            edge(bodied[0], tier, name, evidence);
+        else if (bodied.length === 0)
+            unresolved(name, 'unknown', 'member declared without a body');
+        else
+            unresolved(name, 'overload-ambiguous', `${bodied.length} bodies with this name`);
+    }
+    infer(name, edge, unresolved) {
+        const all = (this.methodsByName.get(name) ?? []).filter(d => !this.bodiless.has(d.id));
+        if (all.length === 0) {
+            unresolved(name, 'unknown', 'receiver type unknown and no method of this name in the tree');
+            return;
+        }
+        if (all.length > this.maxInferred) {
+            unresolved(name, 'unknown', `receiver type unknown; ${all.length} methods of this name exceed the bound`);
+            return;
+        }
+        for (const d of [...all].sort((a, b) => (a.id < b.id ? -1 : 1)))
+            edge(d, 'inferred', name, 'bound by name alone');
+    }
+    run() {
+        for (const ctx of this.sortedFiles())
+            this.walk(ctx, ctx.root);
+    }
+}
+/**
+ * Call edges for a set of TypeScript/JavaScript files. Files of other
+ * extensions are ignored. Deterministic: the same files give the same graph.
+ */
+export async function buildTsCallGraph(files, options = {}) {
+    const graph = new Graph(options);
+    const trees = [];
+    const out = [];
+    const partial = [];
+    try {
+        const sorted = [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+        for (const f of sorted) {
+            const path = normalizePath(f.path.replace(/\\/g, '/'));
+            const lang = languageOf(path);
+            if (!lang)
+                continue;
+            const tree = await parse(f.code, lang.grammar);
+            trees.push(tree);
+            const ids = deriveTypeScriptIds(tree, path, lang.ids, f.ids ?? {});
+            if (ids.partial)
+                partial.push(path);
+            out.push(ids);
+            graph.add(path, tree, ids);
+        }
+        graph.link();
+        graph.run();
+        graph.manifestEntries();
+    }
+    finally {
+        for (const t of trees)
+            disposeTree(t);
+    }
+    const bySite = (a, b) => a.site.file < b.site.file ? -1 : a.site.file > b.site.file ? 1 : a.site.line - b.site.line || a.site.col - b.site.col;
+    return {
+        scheme: TS_CALL_EDGES_SCHEME,
+        ids: 'ids@0.1',
+        files: out,
+        edges: [...graph.edges].sort((a, b) => bySite(a, b) || (a.to < b.to ? -1 : a.to > b.to ? 1 : 0)),
+        unresolved: [...graph.unresolved].sort(bySite),
+        partial,
+        sites: graph.siteCount,
+        references: dedupe([...graph.references].sort((a, b) => bySite(a, b) || cmp(a.to, b.to)), r => `${r.from}>${r.to}@${r.site.file}:${r.site.line}:${r.site.col}`),
+        fieldUses: dedupe([...graph.fieldUses].sort((a, b) => bySite(a, b) || cmp(a.to, b.to)), r => `${r.from}>${r.to}@${r.site.file}:${r.site.line}:${r.site.col}`),
+        imports: graph.importEdges(),
+        loads: dedupe([...graph.loadEdges].sort((a, b) => bySite(a, b) || cmp(a.to, b.to)), l => `${l.from}>${l.to}`),
+        typeOnly: [...graph.typeOnly].sort(),
+        entryScheme: 'entry-index@0.1',
+        entries: dedupe([...graph.entries].sort((a, b) => cmp(a.file, b.file) || a.line - b.line || cmp(a.id, b.id) || cmp(a.kind, b.kind) || cmp(a.path ?? '', b.path ?? '') || cmp(a.method ?? '', b.method ?? '')), e => `${e.id}|${e.kind}|${e.method ?? ''}|${e.path ?? ''}`),
+        unresolvedRegistrations: [...graph.unresolvedRegistrations].sort(bySite),
+    };
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function dedupe(items, key) {
+    const seen = new Set();
+    return items.filter(t => {
+        const k = key(t);
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+//# sourceMappingURL=ts-call-edges.js.map