@opensip-cli/graph-typescript 0.1.0

package/dist/inventory-visitors/module-init.js

@@ -0,0 +1,40 @@
+/**
+ * Synthesizes one `<module-init>` occurrence per file.
+ *
+ * Per spec §2.2: "produces ONE module-init occurrence per file, owning
+ * all top-level call sites discovered in stage 2."
+ *
+ * PR-5 documents that this visitor is the deliberate outlier — it does
+ * not implement the InventoryVisitor signature because it walks all
+ * top-level statements rather than dispatching on a single node.
+ */
+import { digestSyntheticBody } from '../inventory-helpers/hash-body.js';
+import { synthesizeModuleInitName } from '../inventory-helpers/synthesize-name.js';
+export function synthesizeModuleInit(sourceFile, ctx) {
+    // Hash the file's top-level statement-text concatenation. Every
+    // top-level statement contributes; per-function bodies do not (they
+    // get their own occurrences).
+    const topLevelText = sourceFile.statements.map((s) => s.getText(sourceFile)).join('\n');
+    const name = synthesizeModuleInitName(ctx.filePathProjectRel);
+    const digest = digestSyntheticBody(`${ctx.filePathProjectRel}\n${topLevelText}`);
+    return {
+        bodyHash: digest.hash,
+        bodySize: digest.size,
+        simpleName: name,
+        qualifiedName: `${ctx.filePathProjectRel.replace(/\.tsx?$/, '')}.<module-init>`,
+        filePath: ctx.filePathProjectRel,
+        line: 1,
+        column: 0,
+        endLine: sourceFile.getLineAndCharacterOfPosition(sourceFile.getEnd()).line + 1,
+        kind: 'module-init',
+        params: [],
+        returnType: null,
+        enclosingClass: null,
+        decorators: [],
+        visibility: 'module-local',
+        inTestFile: ctx.inTestFile,
+        definedInGenerated: ctx.definedInGenerated,
+        calls: [],
+    };
+}
+//# sourceMappingURL=module-init.js.map

package/dist/inventory-visitors/module-init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-init.js","sourceRoot":"","sources":["../../src/inventory-visitors/module-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAMnF,MAAM,UAAU,oBAAoB,CAClC,UAAyB,EACzB,GAAmB;IAEnB,gEAAgE;IAChE,oEAAoE;IACpE,8BAA8B;IAC9B,MAAM,YAAY,GAAG,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxF,MAAM,IAAI,GAAG,wBAAwB,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IAC9D,MAAM,MAAM,GAAG,mBAAmB,CAAC,GAAG,GAAG,CAAC,kBAAkB,KAAK,YAAY,EAAE,CAAC,CAAC;IACjF,OAAO;QACL,QAAQ,EAAE,MAAM,CAAC,IAAI;QACrB,QAAQ,EAAE,MAAM,CAAC,IAAI;QACrB,UAAU,EAAE,IAAI;QAChB,aAAa,EAAE,GAAG,GAAG,CAAC,kBAAkB,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB;QAC/E,QAAQ,EAAE,GAAG,CAAC,kBAAkB;QAChC,IAAI,EAAE,CAAC;QACP,MAAM,EAAE,CAAC;QACT,OAAO,EAAE,UAAU,CAAC,6BAA6B,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC;QAC/E,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,EAAE;QACV,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,UAAU,EAAE,EAAE;QACd,UAAU,EAAE,cAAc;QAC1B,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,kBAAkB,EAAE,GAAG,CAAC,kBAAkB;QAC1C,KAAK,EAAE,EAAE;KACV,CAAC;AACJ,CAAC"}

package/dist/inventory-visitors/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * InventoryVisitor signature alias (PR-5).
+ *
+ * Six of the seven inventory visitors (function-declaration,
+ * arrow-function, method-declaration, constructor-declaration,
+ * getter-setter, function-expression) conform to this shape.
+ *
+ * `module-init.ts` is the deliberate outlier — it walks all top-level
+ * statements of a SourceFile and synthesizes one occurrence per file,
+ * rather than dispatching on a single node. It does not implement
+ * InventoryVisitor; PR-5 calls this out explicitly.
+ */
+import type { FunctionOccurrence } from '@opensip-cli/graph';
+import type ts from 'typescript';
+/** Per-source-file context carried through every inventory visitor invocation. */
+export interface VisitorContext {
+    readonly sourceFile: ts.SourceFile;
+    readonly projectDirAbs: string;
+    readonly filePathProjectRel: string;
+    readonly inTestFile: boolean;
+    readonly definedInGenerated: boolean;
+    /** Class node currently being walked (set when inside a class declaration). */
+    readonly enclosingClass: string | null;
+}
+export type InventoryVisitor<N extends ts.Node = ts.Node> = (node: N, ctx: VisitorContext) => FunctionOccurrence | null;
+//# sourceMappingURL=types.d.ts.map

package/dist/inventory-visitors/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/inventory-visitors/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,CAC1D,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,cAAc,KAChB,kBAAkB,GAAG,IAAI,CAAC"}

package/dist/inventory-visitors/types.js

@@ -0,0 +1,14 @@
+/**
+ * InventoryVisitor signature alias (PR-5).
+ *
+ * Six of the seven inventory visitors (function-declaration,
+ * arrow-function, method-declaration, constructor-declaration,
+ * getter-setter, function-expression) conform to this shape.
+ *
+ * `module-init.ts` is the deliberate outlier — it walks all top-level
+ * statements of a SourceFile and synthesizes one occurrence per file,
+ * rather than dispatching on a single node. It does not implement
+ * InventoryVisitor; PR-5 calls this out explicitly.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/inventory-visitors/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/inventory-visitors/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/normalize-project-dir.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared utility — normalize a project directory path.
+ *
+ * Two callers per spec §2.1: stage 0 (discover) and stage 2 (edges).
+ * Cache invalidation also normalizes tsConfigPath the same way, making
+ * three callers and justifying extraction (rule of three).
+ */
+/**
+ * Normalize a project directory: resolve to absolute, then realpath
+ * (follows symlinks). Throws ConfigurationError if missing or not a
+ * directory.
+ */
+export declare function normalizeProjectDir(input: string): string;
+//# sourceMappingURL=normalize-project-dir.d.ts.map

package/dist/normalize-project-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-project-dir.d.ts","sourceRoot":"","sources":["../src/normalize-project-dir.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBzD"}

package/dist/normalize-project-dir.js

@@ -0,0 +1,36 @@
+/**
+ * Shared utility — normalize a project directory path.
+ *
+ * Two callers per spec §2.1: stage 0 (discover) and stage 2 (edges).
+ * Cache invalidation also normalizes tsConfigPath the same way, making
+ * three callers and justifying extraction (rule of three).
+ */
+import { realpathSync, statSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { ConfigurationError } from '@opensip-cli/core';
+/**
+ * Normalize a project directory: resolve to absolute, then realpath
+ * (follows symlinks). Throws ConfigurationError if missing or not a
+ * directory.
+ */
+export function normalizeProjectDir(input) {
+    const absolute = isAbsolute(input) ? input : resolve(input);
+    let stat;
+    try {
+        stat = statSync(absolute);
+    }
+    catch {
+        throw new ConfigurationError(`Project directory does not exist: ${input}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new ConfigurationError(`Project path is not a directory: ${input}`);
+    }
+    try {
+        return realpathSync(absolute);
+    }
+    catch {
+        /* v8 ignore next */
+        return absolute;
+    }
+}
+//# sourceMappingURL=normalize-project-dir.js.map

package/dist/normalize-project-dir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-project-dir.js","sourceRoot":"","sources":["../src/normalize-project-dir.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC5D,IAAI,IAAI,CAAC;IACT,IAAI,CAAC;QACH,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,kBAAkB,CAAC,qCAAqC,KAAK,EAAE,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QACxB,MAAM,IAAI,kBAAkB,CAAC,oCAAoC,KAAK,EAAE,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,oBAAoB;QACpB,OAAO,QAAQ,CAAC;IAClB,CAAC;AACH,CAAC"}

package/dist/parse-fast.d.ts

@@ -0,0 +1,41 @@
+/**
+ * TypeScript fast (checker-free) parse implementation.
+ *
+ * The exact parse (`parse.ts`) calls `ts.createProgram` and forces
+ * `program.getTypeChecker()` — the single most expensive operation in a cold
+ * graph build (it binds every file: parent pointers for the walk + symbol
+ * tables for the resolver). Fast mode avoids both the Program and the checker.
+ *
+ * Fast mode needs the parent pointers but NOT the symbol table: it
+ * resolves edges syntactically (name + import graph) and never calls the
+ * checker. So this path skips `createProgram`/`getTypeChecker` entirely
+ * and parses each file standalone via
+ * `ts.createSourceFile(..., setParentNodes: true)` — `setParentNodes`
+ * populates parent pointers without binding or a checker, the cheap
+ * substitute for the forced `getTypeChecker()`.
+ *
+ * Per contract invariant I-7 (parseProject is total over `files`): every
+ * file either parses into the map or surfaces a structured ParseError.
+ * Standalone `createSourceFile` always returns a (possibly partial)
+ * tree; syntactic problems surface via the node's internal
+ * `parseDiagnostics`, which we read per file.
+ */
+import ts from 'typescript';
+import type { ParseInput, ParseOutput } from '@opensip-cli/graph';
+/**
+ * Fast-flavored parsed project: a per-file map of standalone
+ * `ts.SourceFile`s (abs path → SF), with no `ts.Program` and no type
+ * checker. The `kind: 'fast'` discriminant lets the walk and resolve
+ * stages branch against {@link import('./parse.js').TsParsed}.
+ */
+export interface TypescriptFastParsedProject {
+    readonly kind: 'fast';
+    /** Absolute file path → standalone source file (parent pointers set). */
+    readonly sourceFiles: ReadonlyMap<string, ts.SourceFile>;
+}
+/**
+ * Parse each input file into a standalone `ts.SourceFile` with parent
+ * pointers, building no Program and constructing no type checker.
+ */
+export declare function parseProjectFast(input: ParseInput): ParseOutput<TypescriptFastParsedProject>;
+//# sourceMappingURL=parse-fast.d.ts.map

package/dist/parse-fast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-fast.d.ts","sourceRoot":"","sources":["../src/parse-fast.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAc,MAAM,oBAAoB,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC;CAC1D;AAOD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC,2BAA2B,CAAC,CA4C5F"}

package/dist/parse-fast.js

@@ -0,0 +1,91 @@
+// @fitness-ignore-file unbounded-memory -- reads single source files for parsing; per-file memory bounded by source size
+/**
+ * TypeScript fast (checker-free) parse implementation.
+ *
+ * The exact parse (`parse.ts`) calls `ts.createProgram` and forces
+ * `program.getTypeChecker()` — the single most expensive operation in a cold
+ * graph build (it binds every file: parent pointers for the walk + symbol
+ * tables for the resolver). Fast mode avoids both the Program and the checker.
+ *
+ * Fast mode needs the parent pointers but NOT the symbol table: it
+ * resolves edges syntactically (name + import graph) and never calls the
+ * checker. So this path skips `createProgram`/`getTypeChecker` entirely
+ * and parses each file standalone via
+ * `ts.createSourceFile(..., setParentNodes: true)` — `setParentNodes`
+ * populates parent pointers without binding or a checker, the cheap
+ * substitute for the forced `getTypeChecker()`.
+ *
+ * Per contract invariant I-7 (parseProject is total over `files`): every
+ * file either parses into the map or surfaces a structured ParseError.
+ * Standalone `createSourceFile` always returns a (possibly partial)
+ * tree; syntactic problems surface via the node's internal
+ * `parseDiagnostics`, which we read per file.
+ */
+import { readFileSync } from 'node:fs';
+import { extname, relative } from 'node:path';
+import ts from 'typescript';
+/**
+ * Parse each input file into a standalone `ts.SourceFile` with parent
+ * pointers, building no Program and constructing no type checker.
+ */
+export function parseProjectFast(input) {
+    const compilerOptions = (input.compilerOptions ?? {});
+    const scriptTarget = compilerOptions.target ?? ts.ScriptTarget.Latest;
+    const sourceFiles = new Map();
+    const parseErrors = [];
+    for (const fileName of input.files) {
+        let text;
+        try {
+            text = readFileSync(fileName, 'utf8');
+        }
+        catch (error) {
+            /* v8 ignore next */
+            parseErrors.push({
+                filePath: relative(input.projectDirAbs, fileName),
+                message: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        const sourceFile = ts.createSourceFile(fileName, text, scriptTarget, 
+        // setParentNodes: the cheap substitute for the forced checker —
+        // populates parent pointers the walk's parent-chain visitors need.
+        true, scriptKindForFile(fileName));
+        sourceFiles.set(fileName, sourceFile);
+        const diagnostics = sourceFile.parseDiagnostics;
+        if (diagnostics && diagnostics.length > 0) {
+            const filePath = relative(input.projectDirAbs, fileName);
+            for (const diag of diagnostics) {
+                parseErrors.push({
+                    filePath,
+                    message: ts.flattenDiagnosticMessageText(diag.messageText, '\n'),
+                });
+            }
+        }
+    }
+    return { project: { kind: 'fast', sourceFiles }, parseErrors };
+}
+/**
+ * Pick the tsc ScriptKind from the file extension so `.tsx`/`.jsx` parse
+ * JSX correctly. Standalone `createSourceFile` does not infer the kind
+ * from the filename, so it must be supplied explicitly.
+ */
+function scriptKindForFile(fileName) {
+    switch (extname(fileName).toLowerCase()) {
+        case '.tsx': {
+            return ts.ScriptKind.TSX;
+        }
+        case '.jsx': {
+            return ts.ScriptKind.JSX;
+        }
+        case '.js':
+        case '.cjs':
+        case '.mjs': {
+            return ts.ScriptKind.JS;
+        }
+        default: {
+            // .ts, .cts, .mts and anything else the adapter admitted.
+            return ts.ScriptKind.TS;
+        }
+    }
+}
+//# sourceMappingURL=parse-fast.js.map

package/dist/parse-fast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-fast.js","sourceRoot":"","sources":["../src/parse-fast.ts"],"names":[],"mappings":"AAAA,yHAAyH;AACzH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,MAAM,YAAY,CAAC;AAqB5B;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAiB;IAChD,MAAM,eAAe,GAAG,CAAC,KAAK,CAAC,eAAe,IAAI,EAAE,CAAuB,CAAC;IAC5E,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM,IAAI,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC;IAEtE,MAAM,WAAW,GAAG,IAAI,GAAG,EAAyB,CAAC;IACrD,MAAM,WAAW,GAAiB,EAAE,CAAC;IAErC,KAAK,MAAM,QAAQ,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QACnC,IAAI,IAAY,CAAC;QACjB,IAAI,CAAC;YACH,IAAI,GAAG,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,oBAAoB;YACpB,WAAW,CAAC,IAAI,CAAC;gBACf,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,QAAQ,CAAC;gBACjD,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAChE,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QAED,MAAM,UAAU,GAAG,EAAE,CAAC,gBAAgB,CACpC,QAAQ,EACR,IAAI,EACJ,YAAY;QACZ,gEAAgE;QAChE,mEAAmE;QACnE,IAAI,EACJ,iBAAiB,CAAC,QAAQ,CAAC,CAC5B,CAAC;QACF,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAEtC,MAAM,WAAW,GAAI,UAA6C,CAAC,gBAAgB,CAAC;QACpF,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1C,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;YACzD,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;gBAC/B,WAAW,CAAC,IAAI,CAAC;oBACf,QAAQ;oBACR,OAAO,EAAE,EAAE,CAAC,4BAA4B,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC;iBACjE,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,WAAW,EAAE,CAAC;AACjE,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,QAAgB;IACzC,QAAQ,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;QACxC,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,OAAO,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QAC3B,CAAC;QACD,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,OAAO,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QAC3B,CAAC;QACD,KAAK,KAAK,CAAC;QACX,KAAK,MAAM,CAAC;QACZ,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC;QAC1B,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,0DAA0D;YAC1D,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/parse.d.ts

@@ -0,0 +1,42 @@
+/**
+ * TypeScript parseProject implementation.
+ *
+ * Lifts `ts.createProgram` + the eager `getTypeChecker()` call out of
+ * the orchestrator (where they used to live in cli/orchestrate.ts:
+ * buildAndResolveCatalog) into the adapter, so the orchestrator no
+ * longer imports `'typescript'` after PR 3 of plan
+ * docs/plans/10-graph-language-pluggability.md.
+ *
+ * Per contract invariant I-7 (parseProject is total over `files`):
+ * every file in `input.files` either parses successfully or surfaces
+ * in `parseErrors`. The TypeScript compiler reports parse problems
+ * via diagnostic streams rather than throwing; we surface those that
+ * the program emits at the file level into a structured ParseError
+ * list.
+ */
+import ts from 'typescript';
+import { type TypescriptFastParsedProject } from './parse-fast.js';
+import type { ParseInput, ParseOutput } from '@opensip-cli/graph';
+/** Parsed TS project (exact tier): the live tsc {@link ts.Program} instance. */
+export interface TypescriptParsedProject {
+    readonly program: ts.Program;
+}
+/**
+ * The adapter-internal parsed-project shape, discriminated by tier so the
+ * walk and resolve stages can branch:
+ *   - exact: `{ kind: 'exact', program }` — the live `ts.Program`; the checker
+ *     is constructed lazily by the resolve stage.
+ *   - fast:  `{ kind: 'fast', sourceFiles }` — standalone source files, no checker.
+ * The engine treats this as opaque `unknown`; only the TS adapter introspects it.
+ */
+export type TsParsed = ({
+    readonly kind: 'exact';
+} & TypescriptParsedProject) | TypescriptFastParsedProject;
+/**
+ * Parse the project for the requested resolution tier. `fast` skips the
+ * Program + checker entirely (see {@link parseProjectFast}); `exact`
+ * builds the Program and lets the resolve stage construct the checker only
+ * when semantic edge resolution actually needs it.
+ */
+export declare function parseProject(input: ParseInput): ParseOutput<TsParsed>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,EAAoB,KAAK,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAErF,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAc,MAAM,oBAAoB,CAAC;AAE9E,gFAAgF;AAChF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAChB,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,uBAAuB,CAAC,GACtD,2BAA2B,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,CAKrE"}

package/dist/parse.js

@@ -0,0 +1,75 @@
+/**
+ * TypeScript parseProject implementation.
+ *
+ * Lifts `ts.createProgram` + the eager `getTypeChecker()` call out of
+ * the orchestrator (where they used to live in cli/orchestrate.ts:
+ * buildAndResolveCatalog) into the adapter, so the orchestrator no
+ * longer imports `'typescript'` after PR 3 of plan
+ * docs/plans/10-graph-language-pluggability.md.
+ *
+ * Per contract invariant I-7 (parseProject is total over `files`):
+ * every file in `input.files` either parses successfully or surfaces
+ * in `parseErrors`. The TypeScript compiler reports parse problems
+ * via diagnostic streams rather than throwing; we surface those that
+ * the program emits at the file level into a structured ParseError
+ * list.
+ */
+import { relative } from 'node:path';
+import ts from 'typescript';
+import { parseProjectFast } from './parse-fast.js';
+/**
+ * Parse the project for the requested resolution tier. `fast` skips the
+ * Program + checker entirely (see {@link parseProjectFast}); `exact`
+ * builds the Program and lets the resolve stage construct the checker only
+ * when semantic edge resolution actually needs it.
+ */
+export function parseProject(input) {
+    if (input.resolutionMode === 'fast') {
+        return parseProjectFast(input);
+    }
+    return parseProjectExact(input);
+}
+/** Constructs a tsc Program for the TS source files in the input, returning parse errors if any. */
+function parseProjectExact(input) {
+    // Anchor the program to its origin tsconfig when discovery provided
+    // one. tsc reads `options.configFilePath` for project-reference and
+    // rootDir resolution; synthetic-partition discovery (flat monorepos)
+    // depends on each partition's program knowing its own tsconfig.
+    const compilerOptions = {
+        ...(input.compilerOptions ?? {}),
+        ...(input.configPathAbs ? { configFilePath: input.configPathAbs } : {}),
+    };
+    const program = ts.createProgram({
+        rootNames: [...input.files],
+        options: compilerOptions,
+    });
+    // Force the binder. getTypeChecker() binds every source file, which
+    // populates BOTH the AST parent pointers the structural walk reads (a
+    // Program parses with setParentNodes:false, so node.parent is otherwise
+    // undefined) AND the symbol tables the exact resolver needs. Deferring it
+    // saves nothing in exact mode: resolveEdgesFromRecords (edges.ts) calls
+    // getTypeChecker() unconditionally, so the bind happens either way — and
+    // the cached second call is a no-op. Forcing it here is what makes the
+    // walk's parent chains valid. (Fast mode skips all of this and substitutes
+    // createSourceFile(setParentNodes:true); see parse-fast.ts.)
+    program.getTypeChecker();
+    const parseErrors = [];
+    /* v8 ignore start */
+    const seenPaths = new Set();
+    for (const sf of program.getSourceFiles()) {
+        const diagnostics = program.getSyntacticDiagnostics(sf);
+        if (diagnostics.length === 0)
+            continue;
+        const filePath = relative(input.projectDirAbs, sf.fileName);
+        if (seenPaths.has(filePath))
+            continue;
+        seenPaths.add(filePath);
+        for (const diag of diagnostics) {
+            const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+            parseErrors.push({ filePath, message });
+        }
+    }
+    /* v8 ignore stop */
+    return { project: { kind: 'exact', program }, parseErrors };
+}
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,EAAE,gBAAgB,EAAoC,MAAM,iBAAiB,CAAC;AAqBrF;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAiB;IAC5C,IAAI,KAAK,CAAC,cAAc,KAAK,MAAM,EAAE,CAAC;QACpC,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,iBAAiB,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,oGAAoG;AACpG,SAAS,iBAAiB,CAAC,KAAiB;IAC1C,oEAAoE;IACpE,oEAAoE;IACpE,qEAAqE;IACrE,gEAAgE;IAChE,MAAM,eAAe,GAAuB;QAC1C,GAAI,CAAC,KAAK,CAAC,eAAe,IAAI,EAAE,CAAwB;QACxD,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxE,CAAC;IACF,MAAM,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC;QAC/B,SAAS,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;QAC3B,OAAO,EAAE,eAAe;KACzB,CAAC,CAAC;IACH,oEAAoE;IACpE,sEAAsE;IACtE,wEAAwE;IACxE,0EAA0E;IAC1E,wEAAwE;IACxE,yEAAyE;IACzE,uEAAuE;IACvE,2EAA2E;IAC3E,6DAA6D;IAC7D,OAAO,CAAC,cAAc,EAAE,CAAC;IAEzB,MAAM,WAAW,GAAiB,EAAE,CAAC;IACrC,qBAAqB;IACrB,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IACpC,KAAK,MAAM,EAAE,IAAI,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC;QAC1C,MAAM,WAAW,GAAG,OAAO,CAAC,uBAAuB,CAAC,EAAE,CAAC,CAAC;QACxD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACvC,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC;QAC5D,IAAI,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,SAAS;QACtC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxB,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;YAC/B,MAAM,OAAO,GAAG,EAAE,CAAC,4BAA4B,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;YACxE,WAAW,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IACD,oBAAoB;IAEpB,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,CAAC;AAC9D,CAAC"}

package/dist/test-file.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns true if `filePathProjectRel` is a TypeScript / JS test
+ * file (or test fixture) by path convention. Path is project-relative with `/`
+ * separators (the same shape `Catalog.functions[*].filePath` carries).
+ */
+export declare function isTypescriptTestFile(filePathProjectRel: string): boolean;
+//# sourceMappingURL=test-file.d.ts.map

package/dist/test-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-file.d.ts","sourceRoot":"","sources":["../src/test-file.ts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAMxE"}

package/dist/test-file.js

@@ -0,0 +1,42 @@
+/**
+ * Canonical TypeScript test-file predicate.
+ *
+ * Single source of truth for "is this project-relative path a test
+ * file?" within the TypeScript adapter. Callers used to roll their
+ * own copies:
+ *
+ *   - walk.ts (file-walker) — stamped `inTestFile` on every occurrence
+ *     during stage 1+2 descent.
+ *   - index.ts (RuleHints.isTestFile) — the canonical answer wired
+ *     into rule evaluation, with broader recall.
+ *
+ * The 2026-05-23 audit (M-1) flagged the divergence — at the time a
+ * third copy lived in the now-removed `inventory.ts` — three
+ * predicates at three layer altitudes drifting silently. This module
+ * is the one place to extend the rule.
+ *
+ * Anchored patterns instead of one alternation; avoids catastrophic
+ * backtracking on pathological inputs.
+ *
+ * `__fixtures__/` is included: it is test scaffolding by convention (synthetic
+ * inputs for tests, e.g. the orchestrator's `__fixtures__/multi-pkg/` mini-repo),
+ * not production code. Without this, reachability/size/cycle rules treat fixture
+ * functions as real code and over-trigger (e.g. a fixture helper with no caller
+ * reads as a `graph:orphan-subtree`). A `__fixtures__/` dir nested under
+ * `__tests__/` is already covered by the first pattern; this also catches the
+ * ones that sit beside the code under test.
+ */
+const TEST_TESTS_DIR_RE = /(?:^|\/)__tests__\//;
+const TEST_FIXTURES_DIR_RE = /(?:^|\/)__fixtures__\//;
+const TEST_FILE_SUFFIX_RE = /\.test\.(?:ts|tsx|js|jsx)$|_test\.(?:ts|tsx|js|jsx)$/;
+/**
+ * Returns true if `filePathProjectRel` is a TypeScript / JS test
+ * file (or test fixture) by path convention. Path is project-relative with `/`
+ * separators (the same shape `Catalog.functions[*].filePath` carries).
+ */
+export function isTypescriptTestFile(filePathProjectRel) {
+    return (TEST_TESTS_DIR_RE.test(filePathProjectRel) ||
+        TEST_FIXTURES_DIR_RE.test(filePathProjectRel) ||
+        TEST_FILE_SUFFIX_RE.test(filePathProjectRel));
+}
+//# sourceMappingURL=test-file.js.map

package/dist/test-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-file.js","sourceRoot":"","sources":["../src/test-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,iBAAiB,GAAG,qBAAqB,CAAC;AAChD,MAAM,oBAAoB,GAAG,wBAAwB,CAAC;AACtD,MAAM,mBAAmB,GAAG,sDAAsD,CAAC;AAEnF;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,kBAA0B;IAC7D,OAAO,CACL,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,CAAC;QAC1C,oBAAoB,CAAC,IAAI,CAAC,kBAAkB,CAAC;QAC7C,mBAAmB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAC7C,CAAC;AACJ,CAAC"}

package/dist/walk.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Stage 1+2 unified walk — Phase 4 of
+ * docs/plans/graph-performance-improvements.md.
+ *
+ * Legacy pipeline walked every source file twice: once for Stage 1
+ * (emit FunctionOccurrence records) and once for Stage 2 (locate +
+ * resolve call sites). The two walks descend in identical order and
+ * the only data flowing between them is each function-shape's
+ * bodyHash — which Stage 1 already computes. Stage 2 was *re-hashing*
+ * every function-shape to look it up in `fnByHash`.
+ *
+ * Phase 4 fuses both passes into one descent per file. The walker
+ * emits both:
+ *   - `occurrences` — what Stage 1 emitted (function/method/arrow/etc.
+ *     records, plus a synthesized module-init per file).
+ *   - `callSites` — flat list of nodes that Stage 2's resolvers care
+ *     about, paired with the bodyHash that owns them. Resolution
+ *     happens *outside* the walk, against this flat list.
+ *
+ * The orchestrator (`cli/orchestrate.ts`) drives the pipeline
+ * end-to-end. `edges.ts` exposes `resolveEdgesFromRecords` as the
+ * Stage 2 entry point, consuming the `callSites` this walk emits.
+ */
+import ts from 'typescript';
+import type { FunctionOccurrence, ParseError } from '@opensip-cli/graph';
+/**
+ * A node the unified walk identified as a candidate Stage 2 resolver
+ * target — pre-paired with the bodyHash of its enclosing function-shape
+ * occurrence so the resolver dispatcher doesn't need to re-walk the
+ * AST or re-hash to find ownership.
+ */
+export interface CallSiteRecord {
+    readonly node: ts.Node;
+    readonly sourceFile: ts.SourceFile;
+    /**
+     * The function occurrence that owns this site, identified by its
+     * `bodyHash`. Top-level (module-init) sites carry the synthesized
+     * module-init occurrence's hash.
+     */
+    readonly ownerHash: string;
+    /**
+     * 'call' for resolver dispatch (call/new/jsx/identifier-ref/
+     * shorthand). 'creation' for parent → nested-callable creation
+     * edges (arrows, function-expressions, methods, accessors,
+     * constructors); the resolver pass emits a static high-confidence
+     * edge for these without consulting any resolver.
+     */
+    readonly kind: 'call' | 'creation';
+    /**
+     * For 'creation' kind, the bodyHash of the nested callable.
+     */
+    readonly childHash?: string;
+}
+/**
+ * One module-level import site discovered by the walker. Resolved to
+ * a target module-init bodyHash by the resolver (Phase 4 of opensip's
+ * substrate consolidation — DEC-498).
+ *
+ * Covers `ImportDeclaration` and `ImportEqualsDeclaration` with a
+ * string moduleSpecifier. Re-exports (`ExportDeclaration` with
+ * `moduleSpecifier`) and dynamic imports (`import('…')` expressions)
+ * are out of scope at v1 — they can be added in a follow-up if
+ * dispatch grouping shows they matter.
+ */
+export interface DependencySiteRecord {
+    readonly node: ts.Node;
+    readonly sourceFile: ts.SourceFile;
+    /** bodyHash of the file's synthesized module-init occurrence. */
+    readonly ownerHash: string;
+    /** Raw import specifier — `'./foo'`, `'@opensip/core'`, etc. */
+    readonly specifier: string;
+    /** 1-based line of the import statement. */
+    readonly line: number;
+    /** 0-based column. */
+    readonly column: number;
+}
+/**
+ * One re-export the file declares, normalized to the data the engine's
+ * export index needs to make a re-exported name resolvable under the
+ * RE-EXPORTING package. Two TS forms produce these:
+ *
+ *   1. `export { a, b as c } from './y' | '@scope/pkg'` — an
+ *      `ExportDeclaration` WITH a `moduleSpecifier`.
+ *   2. `export { a, b }` (NO `from`) where `a`/`b` are bindings IMPORTED at
+ *      the top of the file — TS's import-then-re-export idiom (e.g.
+ *      `import { childrenOf } from '@opensip-cli/tree-sitter'; export
+ *      { childrenOf }`). Correlated against the file's named imports.
+ *
+ * A plain `export { localDef }` of a name DEFINED in this file is NOT a
+ * re-export — it is already an `'exported'` occurrence in the catalog — so it
+ * produces no record.
+ */
+export interface ReExportRecord {
+    /** Re-exporting file, project-relative POSIX (→ `packageOf` gives the group). */
+    readonly fromFile: string;
+    /** The name as exposed BY this module. `'*'` for `export * from`. */
+    readonly exportedName: string;
+    /** The name in the SOURCE module (== `exportedName` unless aliased via
+     *  `export { x as y }`; `'*'` for star). */
+    readonly sourceName: string;
+    /** The source module specifier — relative (`'./x'`) or workspace (`'@scope/pkg'`). */
+    readonly specifier: string;
+}
+export interface WalkInput {
+    /**
+     * The project's source files to walk. Supplied by the adapter from
+     * either tier: exact mode passes `program.getSourceFiles()`; fast mode
+     * passes the standalone source-file map's values. The walk is purely
+     * structural — it needs `ts.SourceFile`s with parent pointers (which
+     * both tiers provide) and nothing from the type checker — so it is
+     * mode-agnostic and never sees a `ts.Program`.
+     */
+    readonly sourceFiles: Iterable<ts.SourceFile>;
+    readonly files: readonly string[];
+    readonly projectDirAbs: string;
+}
+export interface WalkOutput {
+    readonly functions: Record<string, FunctionOccurrence[]>;
+    readonly callSites: readonly CallSiteRecord[];
+    readonly dependencySites: readonly DependencySiteRecord[];
+    readonly reExports: readonly ReExportRecord[];
+    readonly parseErrors: readonly ParseError[];
+}
+export declare function walkProgram(input: WalkInput): WalkOutput;
+//# sourceMappingURL=walk.d.ts.map

package/dist/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,EAAE,MAAM,YAAY,CAAC;AAa5B,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IACnC,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sBAAsB;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;gDAC4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;IACzD,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;IAC9C,QAAQ,CAAC,eAAe,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC1D,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CA6BxD"}