@opensip-cli/graph-typescript 0.1.0

package/dist/edge-helpers/method-target.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Type-attested cross-package METHOD target resolution (ADR-0033 follow-up).
+ *
+ * For a method call `recv.m()` the boundary extractor needs the TYPE-resolved
+ * target file (not a syntactic name) to emit a cross-package boundary call. This
+ * mirrors the symbol resolution `resolvePropertyAccessCall` does, but returns the
+ * `m` decl's SOURCE file (the package's `dist/*.d.ts` mapped to source) rather
+ * than a catalog hash — so the cross-shard linker can pin it post-merge against
+ * the merged catalog, identically in both engines.
+ */
+import ts from 'typescript';
+/**
+ * The project-relative SOURCE file a method call's callee resolves to, when that
+ * callee's declaration is a workspace package's built `dist/*.d.ts` — `null`
+ * otherwise. `null` when: not a property-access call; the checker has no symbol;
+ * the decl is SOURCE (the in-shard/inline pass handles it) or a non-workspace
+ * `.d.ts` (`node_modules`, `lib.dom`, a non-`dist` ambient). The dist→src mapping
+ * follows the tsc `outDir:dist` / `rootDir:src` convention; a wrong mapping just
+ * fails to match an occurrence at the linker and declines (never fabricates).
+ */
+export declare function methodTargetFile(node: ts.Node, checker: ts.TypeChecker, projectDirAbs: string): string | null;
+//# sourceMappingURL=method-target.d.ts.map

package/dist/edge-helpers/method-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-target.d.ts","sourceRoot":"","sources":["../../src/edge-helpers/method-target.ts"],"names":[],"mappings":"AACA;;;;;;;;;GASG;AAIH,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,aAAa,EAAE,MAAM,GACpB,MAAM,GAAG,IAAI,CAkBf"}

package/dist/edge-helpers/method-target.js

@@ -0,0 +1,46 @@
+// @fitness-ignore-file batch-operation-limits -- iterates a bounded collection (one symbol's declarations for a single method-call resolution), mirroring the property-access resolver.
+/**
+ * Type-attested cross-package METHOD target resolution (ADR-0033 follow-up).
+ *
+ * For a method call `recv.m()` the boundary extractor needs the TYPE-resolved
+ * target file (not a syntactic name) to emit a cross-package boundary call. This
+ * mirrors the symbol resolution `resolvePropertyAccessCall` does, but returns the
+ * `m` decl's SOURCE file (the package's `dist/*.d.ts` mapped to source) rather
+ * than a catalog hash — so the cross-shard linker can pin it post-merge against
+ * the merged catalog, identically in both engines.
+ */
+import { relative, sep } from 'node:path';
+import ts from 'typescript';
+import { unaliasSymbol } from './unalias-symbol.js';
+/**
+ * The project-relative SOURCE file a method call's callee resolves to, when that
+ * callee's declaration is a workspace package's built `dist/*.d.ts` — `null`
+ * otherwise. `null` when: not a property-access call; the checker has no symbol;
+ * the decl is SOURCE (the in-shard/inline pass handles it) or a non-workspace
+ * `.d.ts` (`node_modules`, `lib.dom`, a non-`dist` ambient). The dist→src mapping
+ * follows the tsc `outDir:dist` / `rootDir:src` convention; a wrong mapping just
+ * fails to match an occurrence at the linker and declines (never fabricates).
+ */
+export function methodTargetFile(node, checker, projectDirAbs) {
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression))
+        return null;
+    const symbol = checker.getSymbolAtLocation(node.expression);
+    if (!symbol)
+        return null;
+    const real = unaliasSymbol(symbol, checker);
+    for (const d of real.getDeclarations() ?? []) {
+        const sf = d.getSourceFile();
+        // A SOURCE decl means the method lives in a file the in-shard/inline pass can
+        // hash directly — not a cross-package boundary. Stop (don't keep scanning
+        // other decls): the first declaration is the canonical one.
+        if (!sf.isDeclarationFile)
+            return null;
+        const rel = relative(projectDirAbs, sf.fileName).split(sep).join('/');
+        if (rel.includes('/node_modules/') || !rel.endsWith('.d.ts') || !rel.includes('/dist/')) {
+            return null;
+        }
+        return rel.replace('/dist/', '/src/').replace(/\.d\.ts$/, '.ts');
+    }
+    return null;
+}
+//# sourceMappingURL=method-target.js.map

package/dist/edge-helpers/method-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-target.js","sourceRoot":"","sources":["../../src/edge-helpers/method-target.ts"],"names":[],"mappings":"AAAA,wLAAwL;AACxL;;;;;;;;;GASG;AAEH,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAa,EACb,OAAuB,EACvB,aAAqB;IAErB,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/F,MAAM,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5D,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,EAAE,CAAC;QAC7C,MAAM,EAAE,GAAG,CAAC,CAAC,aAAa,EAAE,CAAC;QAC7B,8EAA8E;QAC9E,0EAA0E;QAC1E,4DAA4D;QAC5D,IAAI,CAAC,EAAE,CAAC,iBAAiB;YAAE,OAAO,IAAI,CAAC;QACvC,MAAM,GAAG,GAAG,QAAQ,CAAC,aAAa,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtE,IAAI,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxF,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACnE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/edge-helpers/resolution-trace.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Per-site resolution trace (debug-only). When `GRAPH_SITE_LOG` points at a
+ * file, every `resolveDeclToHash` decision appends one TSV row:
+ *   engine \t ownerFile \t callee \t decl=<file> \t dts=<bool> \t spec=<...> \t out=<hash|DECLINE-*>
+ *
+ * This is the harness that root-caused the exact↔sharded divergence classes
+ * (the decl-file discriminator + the matching-strictness asymmetry). It is OFF
+ * with zero production cost when the env var is unset; kept so the next
+ * divergence investigation starts from measurement, not a rebuilt harness.
+ */
+import type { ResolverContext } from '../edge-resolvers/types.js';
+import type ts from 'typescript';
+/** The inputs of one `resolveDeclToHash` decision, as traced by {@link traceResolveDecl}. */
+export interface ResolveDeclDecision {
+    readonly ctx: ResolverContext;
+    readonly candidateNames: readonly string[];
+    readonly bindingNames: readonly string[];
+    readonly declSourceFile: ts.SourceFile;
+    readonly dts: boolean;
+    readonly out: string | null;
+}
+/** Append one resolveDeclToHash decision row when GRAPH_SITE_LOG is set; else a no-op. */
+export declare function traceResolveDecl(decision: ResolveDeclDecision): void;
+//# sourceMappingURL=resolution-trace.d.ts.map

package/dist/edge-helpers/resolution-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-trace.d.ts","sourceRoot":"","sources":["../../src/edge-helpers/resolution-trace.ts"],"names":[],"mappings":"AACA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,6FAA6F;AAC7F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,cAAc,EAAE,EAAE,CAAC,UAAU,CAAC;IACvC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAoBpE"}

package/dist/edge-helpers/resolution-trace.js

@@ -0,0 +1,38 @@
+// @fitness-ignore-file env-via-registry -- debug-only diagnostic harness, opt-in via the GRAPH_SITE_LOG / GRAPH_ENGINE env vars; NOT production configuration. Reading process.env directly is intentional and isolated to this one module so the production resolvers stay registry-clean. See docs/internal/graph-resolution-trace.md.
+/**
+ * Per-site resolution trace (debug-only). When `GRAPH_SITE_LOG` points at a
+ * file, every `resolveDeclToHash` decision appends one TSV row:
+ *   engine \t ownerFile \t callee \t decl=<file> \t dts=<bool> \t spec=<...> \t out=<hash|DECLINE-*>
+ *
+ * This is the harness that root-caused the exact↔sharded divergence classes
+ * (the decl-file discriminator + the matching-strictness asymmetry). It is OFF
+ * with zero production cost when the env var is unset; kept so the next
+ * divergence investigation starts from measurement, not a rebuilt harness.
+ */
+/* v8 ignore start -- debug-only; exercised manually via GRAPH_SITE_LOG, never in the test suite */
+import { appendFileSync } from 'node:fs';
+import { relative, sep } from 'node:path';
+/** Append one resolveDeclToHash decision row when GRAPH_SITE_LOG is set; else a no-op. */
+export function traceResolveDecl(decision) {
+    const logPath = process.env.GRAPH_SITE_LOG;
+    if (logPath === undefined)
+        return;
+    const { ctx, candidateNames, bindingNames, declSourceFile, dts, out } = decision;
+    const owner = relative(ctx.projectDirAbs, ctx.sourceFile.fileName).split(sep).join('/');
+    const declRel = relative(ctx.projectDirAbs, declSourceFile.fileName).split(sep).join('/');
+    const specifiers = bindingNames.map((b) => ctx.importSpecifiers.get(b) ?? '-').join(',');
+    const declineStr = dts ? 'DECLINE-dts-hop' : 'DECLINE-source';
+    const outStr = out === null ? declineStr : out.slice(0, 10);
+    const line = [
+        process.env.GRAPH_ENGINE ?? '?',
+        owner,
+        candidateNames.join('|'),
+        `decl=${declRel}`,
+        `dts=${String(dts)}`,
+        `spec=${specifiers}`,
+        `out=${outStr}`,
+    ].join('\t') + '\n';
+    appendFileSync(logPath, line);
+}
+/* v8 ignore stop */
+//# sourceMappingURL=resolution-trace.js.map

package/dist/edge-helpers/resolution-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-trace.js","sourceRoot":"","sources":["../../src/edge-helpers/resolution-trace.ts"],"names":[],"mappings":"AAAA,yUAAyU;AACzU;;;;;;;;;GASG;AAEH,mGAAmG;AACnG,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAe1C,0FAA0F;AAC1F,MAAM,UAAU,gBAAgB,CAAC,QAA6B;IAC5D,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;IAC3C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO;IAClC,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;IACjF,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACxF,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1F,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzF,MAAM,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,gBAAgB,CAAC;IAC9D,MAAM,MAAM,GAAG,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC5D,MAAM,IAAI,GACR;QACE,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,GAAG;QAC/B,KAAK;QACL,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC;QACxB,QAAQ,OAAO,EAAE;QACjB,OAAO,MAAM,CAAC,GAAG,CAAC,EAAE;QACpB,QAAQ,UAAU,EAAE;QACpB,OAAO,MAAM,EAAE;KAChB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACtB,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAChC,CAAC;AACD,oBAAoB"}

package/dist/edge-helpers/resolve-decl.d.ts

@@ -0,0 +1,44 @@
+/**
+ * resolveDeclToHash — map a type-checker-resolved declaration to the catalog
+ * bodyHash of its SOURCE occurrence.
+ *
+ * The single seam every exact-engine resolver (direct-call, property-access,
+ * jsx-element, new-expression, polymorphic) routes a resolved declaration
+ * through. It unifies the two ways a declaration's source body is reached:
+ *
+ *   1. IN-PROJECT SOURCE — the declaration lives in a `.ts(x)` file the program
+ *      compiled from source. Hash the declaration body and match it in the
+ *      catalog (the original {@link findCatalogEntry} behavior).
+ *
+ *   2. WORKSPACE-PACKAGE BOUNDARY — Node16 resolves a `@scope/pkg` import to the
+ *      package's BUILT `dist/*.d.ts`, so the type checker hands back a BODILESS
+ *      declaration. Hashing it never matches the SOURCE body the catalog holds
+ *      → the real cross-package edge was dropped. Instead, re-resolve through
+ *      the SAME export-index model the sharded linker uses: (the call site's
+ *      import specifier for this name) + (callee name) → the UNIQUE exported
+ *      source occurrence. Binding-required, so a bare name with no import never
+ *      resolves (no phantom). Decline-beats-guess on ambiguity.
+ *
+ * A declaration in a `.d.ts` that is NOT a workspace package the importer bound
+ * to (e.g. a `@types/*` ambient global like Vitest's `describe`, or `lib.dom`)
+ * resolves to nothing — exactly right: those are not project functions.
+ */
+import type { ResolverContext } from '../edge-resolvers/types.js';
+import type ts from 'typescript';
+/**
+ * Resolve `declNode` (a function-shaped node returned by
+ * `functionLikeFromDeclaration`) to a catalog bodyHash, or `null` to decline.
+ *
+ * `candidateNames` is the simple name(s) the call site addressed — the EXPORTED
+ * callee name (e.g. `getSharedSourceFile`, `walkNodes`). Used both for the
+ * in-project hash lookup and the cross-package export lookup.
+ *
+ * `bindingNames` is the local binding name(s) that were IMPORTED in the call
+ * site's file (the namespace receiver for `ns.fn()`, or the callee name itself
+ * for a direct `fn()` / `<Fn/>` / `new Fn()`). The cross-package path requires
+ * one of these to carry a workspace import specifier — a binding-required check
+ * that rules out phantom same-name matches. When `bindingNames` is omitted it
+ * defaults to `candidateNames` (direct calls bind by the callee name).
+ */
+export declare function resolveDeclToHash(declNode: ts.Node, declSourceFile: ts.SourceFile, candidateNames: readonly string[], ctx: ResolverContext, bindingNames?: readonly string[]): string | null;
+//# sourceMappingURL=resolve-decl.d.ts.map

package/dist/edge-helpers/resolve-decl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-decl.d.ts","sourceRoot":"","sources":["../../src/edge-helpers/resolve-decl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AASH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,EAAE,CAAC,IAAI,EACjB,cAAc,EAAE,EAAE,CAAC,UAAU,EAC7B,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,GAAG,EAAE,eAAe,EACpB,YAAY,GAAE,SAAS,MAAM,EAAmB,GAC/C,MAAM,GAAG,IAAI,CA0Bf"}

package/dist/edge-helpers/resolve-decl.js

@@ -0,0 +1,170 @@
+/**
+ * resolveDeclToHash — map a type-checker-resolved declaration to the catalog
+ * bodyHash of its SOURCE occurrence.
+ *
+ * The single seam every exact-engine resolver (direct-call, property-access,
+ * jsx-element, new-expression, polymorphic) routes a resolved declaration
+ * through. It unifies the two ways a declaration's source body is reached:
+ *
+ *   1. IN-PROJECT SOURCE — the declaration lives in a `.ts(x)` file the program
+ *      compiled from source. Hash the declaration body and match it in the
+ *      catalog (the original {@link findCatalogEntry} behavior).
+ *
+ *   2. WORKSPACE-PACKAGE BOUNDARY — Node16 resolves a `@scope/pkg` import to the
+ *      package's BUILT `dist/*.d.ts`, so the type checker hands back a BODILESS
+ *      declaration. Hashing it never matches the SOURCE body the catalog holds
+ *      → the real cross-package edge was dropped. Instead, re-resolve through
+ *      the SAME export-index model the sharded linker uses: (the call site's
+ *      import specifier for this name) + (callee name) → the UNIQUE exported
+ *      source occurrence. Binding-required, so a bare name with no import never
+ *      resolves (no phantom). Decline-beats-guess on ambiguity.
+ *
+ * A declaration in a `.d.ts` that is NOT a workspace package the importer bound
+ * to (e.g. a `@types/*` ambient global like Vitest's `describe`, or `lib.dom`)
+ * resolves to nothing — exactly right: those are not project functions.
+ */
+import { relative, sep } from 'node:path';
+import { resolveCrossPackageCall } from '@opensip-cli/graph';
+import { findCatalogEntry } from './find-catalog-entry.js';
+import { traceResolveDecl } from './resolution-trace.js';
+/**
+ * Resolve `declNode` (a function-shaped node returned by
+ * `functionLikeFromDeclaration`) to a catalog bodyHash, or `null` to decline.
+ *
+ * `candidateNames` is the simple name(s) the call site addressed — the EXPORTED
+ * callee name (e.g. `getSharedSourceFile`, `walkNodes`). Used both for the
+ * in-project hash lookup and the cross-package export lookup.
+ *
+ * `bindingNames` is the local binding name(s) that were IMPORTED in the call
+ * site's file (the namespace receiver for `ns.fn()`, or the callee name itself
+ * for a direct `fn()` / `<Fn/>` / `new Fn()`). The cross-package path requires
+ * one of these to carry a workspace import specifier — a binding-required check
+ * that rules out phantom same-name matches. When `bindingNames` is omitted it
+ * defaults to `candidateNames` (direct calls bind by the callee name).
+ */
+export function resolveDeclToHash(declNode, declSourceFile, candidateNames, ctx, bindingNames = candidateNames) {
+    const dts = declSourceFile.isDeclarationFile;
+    const out = dts
+        ? // Boundary case: the alias led into a built `.d.ts`. Don't hash the bodiless
+            // signature. First try the export index (binding-required — for imported
+            // FUNCTIONS). If that declines (e.g. a METHOD call `recv.m()` carries no
+            // import binding for `m`), fall back to mapping the checker-attested
+            // `dist/*.d.ts` decl to its SOURCE file and pinning by (source file +
+            // name). The checker already disambiguated WHICH declaration (this class's
+            // method in this file), so the pin is type-anchored, not a name guess — and
+            // catalog-SCOPE-independent, so the exact (whole-repo) and sharded (per-
+            // shard) passes resolve it identically instead of one declining while the
+            // other resolves by an unsound unique-name-in-shard catalog fallback.
+            (resolveAcrossPackageBoundary(candidateNames, bindingNames, ctx) ??
+                pinByDtsDeclSource(declSourceFile, candidateNames, ctx))
+        : // In-project source: hash the body and match it in the catalog; if the
+            // body-hash match misses (e.g. arrow-property methods whose cataloged
+            // occurrence the hasher can't reproduce from this decl node), fall back to
+            // a file+name pin — the SAME unique-or-decline semantics sharded's
+            // pinBySpecifier uses, so the two engines converge (Phase 3, Option A).
+            (findCatalogEntry(declNode, declSourceFile, ctx.catalog, candidateNames) ??
+                pinByFileAndName(declSourceFile, candidateNames, ctx));
+    // Per-site decl-file discriminator trace — no-op unless GRAPH_SITE_LOG is set
+    // (debug-only; isolated in resolution-trace.ts so this resolver stays env-clean).
+    traceResolveDecl({ ctx, candidateNames, bindingNames, declSourceFile, dts, out });
+    return out;
+}
+/**
+ * File+name pin: the catalog occurrence in `declSourceFile` (the file the type
+ * checker attested the declaration lives in) whose simpleName matches one of
+ * `candidateNames`. UNIQUE match → its bodyHash; zero or >1 DISTINCT → null
+ * (decline). The lenient match sharded's `pinBySpecifier` uses, applied to the
+ * checker-attested file: it never guesses the file (only the matching step) and
+ * declines on same-name ambiguity — decline-beats-guess, identical semantics to
+ * the sharded engine.
+ */
+function pinByFileAndName(declSourceFile, candidateNames, ctx) {
+    const relPath = relative(ctx.projectDirAbs, declSourceFile.fileName).split(sep).join('/');
+    return pinBySourceRel(relPath, candidateNames, ctx);
+}
+/**
+ * The catalog occurrence in `relPath` (a project-relative SOURCE path) whose
+ * simpleName matches one of `candidateNames`. UNIQUE match → its bodyHash; zero
+ * or >1 DISTINCT → null (decline). The shared unique-or-decline core of the
+ * file+name pins.
+ */
+function pinBySourceRel(relPath, candidateNames, ctx) {
+    let found = null;
+    for (const name of candidateNames) {
+        const occs = ctx.catalog.functions[name];
+        if (!occs)
+            continue;
+        for (const o of occs) {
+            if (o.filePath !== relPath)
+                continue;
+            if (found !== null && found !== o.bodyHash)
+                return null; // >1 distinct → ambiguous → decline
+            found = o.bodyHash;
+        }
+    }
+    return found;
+}
+/**
+ * `.d.ts`→source pin: map the checker-attested `dist/*.d.ts` declaration file to
+ * its SOURCE counterpart (tsc `outDir:dist` / `rootDir:src` convention) and pin
+ * by (source file + name). Returns null when the path is not a `dist/*.d.ts`, or
+ * when the mapped source has no unique matching occurrence (decline). Guarded by
+ * the catalog match: a wrong mapping simply finds nothing and declines, so the
+ * heuristic never fabricates an edge.
+ *
+ * RESTRICTED TO INTRA-PACKAGE targets (owner's package === target's package). A
+ * method call whose receiver type flows through the OWNER package's OWN published
+ * `.d.ts` (e.g. `scope.graph?.rules.getAll()` where `scope`'s type references the
+ * graph package) resolves to a SOURCE occurrence in the same package — which is
+ * in-shard for the sharded engine too, so BOTH engines resolve it identically. A
+ * CROSS-package method target lives in another SHARD, which the sharded in-shard
+ * pass cannot reach (method calls carry no import binding, so they don't ride the
+ * cross-shard boundary linker); resolving those in exact alone would diverge.
+ * Cross-package method resolution is the separate, larger completeness item
+ * (guarded by the resolution-completeness floor), deliberately left declined in
+ * BOTH engines here.
+ */
+function pinByDtsDeclSource(declSourceFile, candidateNames, ctx) {
+    const rel = relative(ctx.projectDirAbs, declSourceFile.fileName).split(sep).join('/');
+    if (!rel.endsWith('.d.ts') || !rel.includes('/dist/'))
+        return null;
+    const srcRel = rel.replace('/dist/', '/src/').replace(/\.d\.ts$/, '.ts');
+    const ownerRel = relative(ctx.projectDirAbs, ctx.sourceFile.fileName).split(sep).join('/');
+    if (packageOf(srcRel) !== packageOf(ownerRel))
+        return null; // cross-package → decline (symmetry)
+    return pinBySourceRel(srcRel, candidateNames, ctx);
+}
+/** The package-root prefix of a project-relative source path — everything before
+ *  `/src/` (e.g. `packages/graph/engine/src/rules/registry.ts` → `packages/graph/engine`).
+ *  Used to gate the `.d.ts`→source pin to intra-package targets. */
+function packageOf(rel) {
+    const i = rel.indexOf('/src/');
+    return i === -1 ? rel : rel.slice(0, i);
+}
+/**
+ * Cross-package boundary resolution: find the workspace import specifier one of
+ * `bindingNames` was bound to IN THE CALL SITE'S FILE, then link (specifier +
+ * exported callee name) to the unique exported source occurrence via the shared
+ * resolver. Returns the first combination that resolves, or `null` (decline).
+ * An import binding is REQUIRED — a name with no import in this file is not a
+ * cross-package call (this is what eliminates the name-collision phantoms).
+ */
+function resolveAcrossPackageBoundary(candidateNames, bindingNames, ctx) {
+    for (const bindingName of bindingNames) {
+        const importSpecifier = ctx.importSpecifiers.get(bindingName);
+        if (importSpecifier === undefined)
+            continue; // not imported here → no binding
+        for (const calleeName of candidateNames) {
+            const linked = resolveCrossPackageCall({
+                importSpecifier,
+                calleeName,
+                exportIndex: ctx.crossPackage.exportIndex,
+                manifestIndex: ctx.crossPackage.manifestIndex,
+            });
+            if (linked !== undefined)
+                return linked.bodyHash;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=resolve-decl.js.map

package/dist/edge-helpers/resolve-decl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-decl.js","sourceRoot":"","sources":["../../src/edge-helpers/resolve-decl.ts"],"names":[],"mappings":"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"}

package/dist/edge-helpers/unalias-symbol.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Walk the alias chain to the original ts.Symbol.
+ *
+ * `import { foo } from './x'` produces an alias symbol whose
+ * declarations are the import specifier itself; getAliasedSymbol
+ * follows the chain to the actual declaration.
+ */
+import ts from 'typescript';
+export declare function unaliasSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): ts.Symbol;
+//# sourceMappingURL=unalias-symbol.d.ts.map

package/dist/edge-helpers/unalias-symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unalias-symbol.d.ts","sourceRoot":"","sources":["../../src/edge-helpers/unalias-symbol.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,wBAAgB,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,EAAE,CAAC,MAAM,CAgBnF"}

package/dist/edge-helpers/unalias-symbol.js

@@ -0,0 +1,29 @@
+/**
+ * Walk the alias chain to the original ts.Symbol.
+ *
+ * `import { foo } from './x'` produces an alias symbol whose
+ * declarations are the import specifier itself; getAliasedSymbol
+ * follows the chain to the actual declaration.
+ */
+import ts from 'typescript';
+export function unaliasSymbol(symbol, checker) {
+    let current = symbol;
+    // Cap iterations defensively; realistic chains are 1–2 hops.
+    /* v8 ignore start */
+    for (let i = 0; i < 8; i++) {
+        if ((current.flags & ts.SymbolFlags.Alias) === 0)
+            return current;
+        try {
+            const next = checker.getAliasedSymbol(current);
+            if (next === current)
+                return current;
+            current = next;
+        }
+        catch {
+            return current;
+        }
+    }
+    return current;
+    /* v8 ignore stop */
+}
+//# sourceMappingURL=unalias-symbol.js.map

package/dist/edge-helpers/unalias-symbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unalias-symbol.js","sourceRoot":"","sources":["../../src/edge-helpers/unalias-symbol.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,UAAU,aAAa,CAAC,MAAiB,EAAE,OAAuB;IACtE,IAAI,OAAO,GAAG,MAAM,CAAC;IACrB,6DAA6D;IAC7D,qBAAqB;IACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC;YAAE,OAAO,OAAO,CAAC;QACjE,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;YAC/C,IAAI,IAAI,KAAK,OAAO;gBAAE,OAAO,OAAO,CAAC;YACrC,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;IACf,oBAAoB;AACtB,CAAC"}

package/dist/edge-resolvers/__tests__/boundary.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cross-shard boundary-call extraction (boundary.ts).
+ *
+ * A boundary call is a call site whose callee name is IMPORTED but the in-shard
+ * resolver did NOT resolve THIS site to a target — by construction the target
+ * lives in another shard. Detection is keyed on the per-site RESOLUTION OUTCOME
+ * (`resolvedEdgesByOwner`), NOT on whether the callee name exists among the
+ * shard's occurrences — so a different local function sharing the name does not
+ * suppress an imported call (the name-collision fix), and a site already
+ * resolved in-shard is skipped (no double edge). These tests drive
+ * `extractBoundaryCalls` over real `CallSiteRecord`s and assert the emitted
+ * `CrossBoundaryCall` descriptors (and the cases it skips).
+ */
+export {};
+//# sourceMappingURL=boundary.test.d.ts.map

package/dist/edge-resolvers/__tests__/boundary.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.test.d.ts","sourceRoot":"","sources":["../../../src/edge-resolvers/__tests__/boundary.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}