@opensip-cli/graph 0.1.0

package/dist/render/opensip-id-derivation.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Engine-side mirror of opensip's content-derived
+ * symbol-ID / edge-ID hashing. Byte-for-byte equivalent to
+ * `computeSymbolId` / `computeEdgeId` in
+ * `packages/code-graph/src/symbol-id.ts` so engine-emitted catalog
+ * rows collide with existing substrate rows under `ON CONFLICT DO
+ * UPDATE` (idempotent re-ingestion).
+ *
+ * Algorithm is intentionally trivial: canonicalize input fields into a
+ * `::`-separated string and sha256. Determinism (rename-invariant
+ * stability) is the load-bearing property — the ID changes when the
+ * symbol identity changes (rename, module move, arity change) but not
+ * when the file is renamed or lines shift.
+ *
+ * Cross-repo source-of-truth risk: if opensip's algorithm changes,
+ * this mirror desynchronizes silently. The local golden tests pin this
+ * package's implementation; a cross-repo parity test should compare it
+ * against opensip's `computeSymbolId` / `computeEdgeId` whenever that
+ * source is available. The engine-package version (carried in
+ * `CatalogExportProvenance.engineVersion`) documents the cutover boundary
+ * if the algorithm ever evolves.
+ *
+ * Phase 3 Task 3.2 per DEC-498.
+ */
+/**
+ * Input to opensip's symbol-ID hash. Mirrors `SymbolIdInput` in
+ * `packages/code-graph/src/symbol-id.ts`.
+ */
+export interface OpenSipSymbolIdInput {
+    readonly repoId: string;
+    readonly modulePath: string;
+    readonly kind: string;
+    readonly qualifiedName: string;
+    readonly arity: number | null;
+}
+/**
+ * Input to opensip's edge-ID hash. Mirrors `EdgeIdInput` in
+ * `packages/code-graph/src/symbol-id.ts`.
+ */
+export interface OpenSipEdgeIdInput {
+    readonly fromSymbolId: string;
+    readonly edgeKind: string;
+    readonly toSymbolId: string | null;
+    readonly toQualifiedNameUnresolved: string | null;
+}
+/**
+ * Derive opensip's symbol ID for a function / class / method / module.
+ *
+ * Mirrors `computeSymbolId(...)` byte-for-byte.
+ */
+export declare function deriveOpenSipSymbolId(input: OpenSipSymbolIdInput): string;
+/**
+ * Derive opensip's edge ID. Unresolved targets are canonicalized as
+ * `unresolved:<qname>` so two distinct unresolved calls don't collide
+ * on the same fromSymbolId + edgeKind.
+ *
+ * Mirrors `computeEdgeId(...)` byte-for-byte — including the subtle
+ * empty-string fallback when both `toSymbolId` and
+ * `toQualifiedNameUnresolved` are `null` (the key becomes
+ * `<fromSymbolId>::<edgeKind>::unresolved:`).
+ */
+export declare function deriveOpenSipEdgeId(input: OpenSipEdgeIdInput): string;
+/**
+ * Project a repo-relative file path to the canonical module path the
+ * opensip indexer stores in `code_symbols.module_path`. Mirrors
+ * `filePathToModulePath(...)` in
+ * `packages/code-graph/src/module-path.ts`.
+ *
+ * Rule: strip the extension if the last `.` lives in the basename;
+ * normalize Windows backslashes to POSIX `/`.
+ */
+export declare function deriveOpenSipModulePath(filePath: string): string;
+//# sourceMappingURL=opensip-id-derivation.d.ts.map

package/dist/render/opensip-id-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opensip-id-derivation.d.ts","sourceRoot":"","sources":["../../src/render/opensip-id-derivation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,yBAAyB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAGzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAIrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKhE"}

package/dist/render/opensip-id-derivation.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview Engine-side mirror of opensip's content-derived
+ * symbol-ID / edge-ID hashing. Byte-for-byte equivalent to
+ * `computeSymbolId` / `computeEdgeId` in
+ * `packages/code-graph/src/symbol-id.ts` so engine-emitted catalog
+ * rows collide with existing substrate rows under `ON CONFLICT DO
+ * UPDATE` (idempotent re-ingestion).
+ *
+ * Algorithm is intentionally trivial: canonicalize input fields into a
+ * `::`-separated string and sha256. Determinism (rename-invariant
+ * stability) is the load-bearing property — the ID changes when the
+ * symbol identity changes (rename, module move, arity change) but not
+ * when the file is renamed or lines shift.
+ *
+ * Cross-repo source-of-truth risk: if opensip's algorithm changes,
+ * this mirror desynchronizes silently. The local golden tests pin this
+ * package's implementation; a cross-repo parity test should compare it
+ * against opensip's `computeSymbolId` / `computeEdgeId` whenever that
+ * source is available. The engine-package version (carried in
+ * `CatalogExportProvenance.engineVersion`) documents the cutover boundary
+ * if the algorithm ever evolves.
+ *
+ * Phase 3 Task 3.2 per DEC-498.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Derive opensip's symbol ID for a function / class / method / module.
+ *
+ * Mirrors `computeSymbolId(...)` byte-for-byte.
+ */
+export function deriveOpenSipSymbolId(input) {
+    const key = `${input.repoId}::${input.modulePath}::${input.kind}::${input.qualifiedName}::${input.arity ?? ''}`;
+    return createHash('sha256').update(key).digest('hex');
+}
+/**
+ * Derive opensip's edge ID. Unresolved targets are canonicalized as
+ * `unresolved:<qname>` so two distinct unresolved calls don't collide
+ * on the same fromSymbolId + edgeKind.
+ *
+ * Mirrors `computeEdgeId(...)` byte-for-byte — including the subtle
+ * empty-string fallback when both `toSymbolId` and
+ * `toQualifiedNameUnresolved` are `null` (the key becomes
+ * `<fromSymbolId>::<edgeKind>::unresolved:`).
+ */
+export function deriveOpenSipEdgeId(input) {
+    const target = input.toSymbolId ?? `unresolved:${input.toQualifiedNameUnresolved ?? ''}`;
+    const key = `${input.fromSymbolId}::${input.edgeKind}::${target}`;
+    return createHash('sha256').update(key).digest('hex');
+}
+/**
+ * Project a repo-relative file path to the canonical module path the
+ * opensip indexer stores in `code_symbols.module_path`. Mirrors
+ * `filePathToModulePath(...)` in
+ * `packages/code-graph/src/module-path.ts`.
+ *
+ * Rule: strip the extension if the last `.` lives in the basename;
+ * normalize Windows backslashes to POSIX `/`.
+ */
+export function deriveOpenSipModulePath(filePath) {
+    const lastDot = filePath.lastIndexOf('.');
+    const lastSep = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'));
+    const noExt = lastDot > lastSep ? filePath.slice(0, lastDot) : filePath;
+    return noExt.replaceAll('\\', '/');
+}
+//# sourceMappingURL=opensip-id-derivation.js.map

package/dist/render/opensip-id-derivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opensip-id-derivation.js","sourceRoot":"","sources":["../../src/render/opensip-id-derivation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAyBzC;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAA2B;IAC/D,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,aAAa,KAAK,KAAK,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC;IAChH,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAyB;IAC3D,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU,IAAI,cAAc,KAAK,CAAC,yBAAyB,IAAI,EAAE,EAAE,CAAC;IACzF,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,YAAY,KAAK,KAAK,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;IAClE,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAgB;IACtD,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IAChF,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACxE,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AACrC,CAAC"}

package/dist/render/rule-id-mapping.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Rule-ID mapping — engine slug → OpenSIP-convention rule ID.
+ *
+ * The engine's `Rule.slug` follows the pattern `graph:<rule-slug>` (e.g.
+ * `graph:orphan-subtree`) per `engine/src/types.ts`. OpenSIP's rule-ID
+ * convention is `<package>.<rule-family>.<rule-id>` — a three-segment
+ * dot-separated form that lets the reconciler classify findings by family
+ * (dead-code vs duplication vs safety, etc.) without parsing message text.
+ *
+ * For graph-emitted findings, the first segment is always `graph` (the
+ * source package). The second segment is the rule family the engine rule
+ * belongs to (`dead-code`, `duplication`, `safety`). The third segment
+ * is the specific rule.
+ *
+ * The mapping is a frozen constant — adding a new rule to the engine
+ * requires updating this table explicitly. An unknown slug throws a typed
+ * error so a missing mapping fails loudly at SARIF emission rather than
+ * silently producing a wrong rule ID downstream.
+ *
+ * Co-located with the SARIF emitter (Task 2.2) so the conversion is
+ * testable in isolation. Phase 2 Task 2.1 per DEC-498.
+ */
+/**
+ * Mapping from engine `Rule.slug` to OpenSIP-convention rule ID.
+ *
+ * Every entry in `engine/src/rules/registry.ts`'s `BUILT_IN_RULES` MUST
+ * have an entry here. Tests in `__tests__/render/rule-id-mapping.test.ts`
+ * enforce coverage by iterating `currentRules()`.
+ */
+export declare const RULE_ID_MAPPING: Readonly<Record<string, string>>;
+/**
+ * OpenSIP-convention rule ID regex. Three dot-separated segments, lowercase
+ * kebab-case allowed in each segment. The SARIF emitter asserts every
+ * `result.ruleId` matches this; tests verify the regex against every
+ * mapping entry.
+ */
+export declare const OPENSIP_RULE_ID_REGEX: RegExp;
+/**
+ * Translate an engine slug to its OpenSIP-convention rule ID.
+ *
+ * @throws {ValidationError} when `slug` is not in `RULE_ID_MAPPING`. This
+ *   is a programmer error (a rule was added to the engine registry
+ *   without updating this table), not a runtime input issue — fail loudly
+ *   at SARIF emission rather than emit an invalid wire format.
+ */
+export declare function mapEngineSlugToOpenSipRuleId(slug: string): string;
+/**
+ * Inverse of {@link RULE_ID_MAPPING}: OpenSIP rule ID → engine slug. The
+ * mapping is 1:1, so the inverse is unambiguous. Used by the `--workspace`
+ * parent to recover engine slugs from child envelopes (whose signals carry
+ * the Option-A-mapped OpenSIP rule ID) before building the dashboard session
+ * payload, whose per-rule metric columns are keyed on engine slugs.
+ */
+export declare const OPENSIP_RULE_ID_TO_ENGINE_SLUG: Readonly<Record<string, string>>;
+/**
+ * Translate an OpenSIP-convention rule ID back to its engine slug. Returns
+ * the input unchanged when it is already an engine slug (or otherwise
+ * unmapped) so callers can pass through signals that were never remapped.
+ */
+export declare function mapOpenSipRuleIdToEngineSlug(ruleId: string): string;
+//# sourceMappingURL=rule-id-mapping.d.ts.map

package/dist/render/rule-id-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-id-mapping.d.ts","sourceRoot":"","sources":["../../src/render/rule-id-mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAY3D,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAA8B,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQjE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAE3E,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/render/rule-id-mapping.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Rule-ID mapping — engine slug → OpenSIP-convention rule ID.
+ *
+ * The engine's `Rule.slug` follows the pattern `graph:<rule-slug>` (e.g.
+ * `graph:orphan-subtree`) per `engine/src/types.ts`. OpenSIP's rule-ID
+ * convention is `<package>.<rule-family>.<rule-id>` — a three-segment
+ * dot-separated form that lets the reconciler classify findings by family
+ * (dead-code vs duplication vs safety, etc.) without parsing message text.
+ *
+ * For graph-emitted findings, the first segment is always `graph` (the
+ * source package). The second segment is the rule family the engine rule
+ * belongs to (`dead-code`, `duplication`, `safety`). The third segment
+ * is the specific rule.
+ *
+ * The mapping is a frozen constant — adding a new rule to the engine
+ * requires updating this table explicitly. An unknown slug throws a typed
+ * error so a missing mapping fails loudly at SARIF emission rather than
+ * silently producing a wrong rule ID downstream.
+ *
+ * Co-located with the SARIF emitter (Task 2.2) so the conversion is
+ * testable in isolation. Phase 2 Task 2.1 per DEC-498.
+ */
+import { ValidationError } from '@opensip-cli/core';
+/**
+ * Mapping from engine `Rule.slug` to OpenSIP-convention rule ID.
+ *
+ * Every entry in `engine/src/rules/registry.ts`'s `BUILT_IN_RULES` MUST
+ * have an entry here. Tests in `__tests__/render/rule-id-mapping.test.ts`
+ * enforce coverage by iterating `currentRules()`.
+ */
+export const RULE_ID_MAPPING = Object.freeze({
+    'graph:orphan-subtree': 'graph.dead-code.orphan-subtree',
+    'graph:duplicated-function-body': 'graph.duplication.duplicated-function-body',
+    'graph:no-side-effect-path': 'graph.dead-code.no-side-effect-path',
+    'graph:always-throws-branch': 'graph.safety.always-throws-branch',
+    'graph:test-only-reachable': 'graph.dead-code.test-only-reachable',
+    // Plan D structural rules (new slugs → reversible naming pre-baseline).
+    'graph:large-function': 'graph.complexity.large-function',
+    'graph:wide-function': 'graph.complexity.wide-function',
+    'graph:high-blast-untested': 'graph.coverage.high-blast-untested',
+    'graph:cycle': 'graph.architecture.cycle',
+    'graph:unexpected-coupling': 'graph.architecture.unexpected-coupling',
+});
+/**
+ * OpenSIP-convention rule ID regex. Three dot-separated segments, lowercase
+ * kebab-case allowed in each segment. The SARIF emitter asserts every
+ * `result.ruleId` matches this; tests verify the regex against every
+ * mapping entry.
+ */
+export const OPENSIP_RULE_ID_REGEX = /^graph\.[a-z-]+\.[a-z-]+$/;
+/**
+ * Translate an engine slug to its OpenSIP-convention rule ID.
+ *
+ * @throws {ValidationError} when `slug` is not in `RULE_ID_MAPPING`. This
+ *   is a programmer error (a rule was added to the engine registry
+ *   without updating this table), not a runtime input issue — fail loudly
+ *   at SARIF emission rather than emit an invalid wire format.
+ */
+export function mapEngineSlugToOpenSipRuleId(slug) {
+    const mapped = RULE_ID_MAPPING[slug];
+    if (mapped === undefined) {
+        throw new ValidationError(`No OpenSIP rule-ID mapping for engine slug "${slug}". Add an entry to RULE_ID_MAPPING in engine/src/render/rule-id-mapping.ts.`);
+    }
+    return mapped;
+}
+/**
+ * Inverse of {@link RULE_ID_MAPPING}: OpenSIP rule ID → engine slug. The
+ * mapping is 1:1, so the inverse is unambiguous. Used by the `--workspace`
+ * parent to recover engine slugs from child envelopes (whose signals carry
+ * the Option-A-mapped OpenSIP rule ID) before building the dashboard session
+ * payload, whose per-rule metric columns are keyed on engine slugs.
+ */
+export const OPENSIP_RULE_ID_TO_ENGINE_SLUG = Object.freeze(Object.fromEntries(Object.entries(RULE_ID_MAPPING).map(([slug, ruleId]) => [ruleId, slug])));
+/**
+ * Translate an OpenSIP-convention rule ID back to its engine slug. Returns
+ * the input unchanged when it is already an engine slug (or otherwise
+ * unmapped) so callers can pass through signals that were never remapped.
+ */
+export function mapOpenSipRuleIdToEngineSlug(ruleId) {
+    return OPENSIP_RULE_ID_TO_ENGINE_SLUG[ruleId] ?? ruleId;
+}
+//# sourceMappingURL=rule-id-mapping.js.map

package/dist/render/rule-id-mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-id-mapping.js","sourceRoot":"","sources":["../../src/render/rule-id-mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAqC,MAAM,CAAC,MAAM,CAAC;IAC7E,sBAAsB,EAAE,gCAAgC;IACxD,gCAAgC,EAAE,4CAA4C;IAC9E,2BAA2B,EAAE,qCAAqC;IAClE,4BAA4B,EAAE,mCAAmC;IACjE,2BAA2B,EAAE,qCAAqC;IAClE,wEAAwE;IACxE,sBAAsB,EAAE,iCAAiC;IACzD,qBAAqB,EAAE,gCAAgC;IACvD,2BAA2B,EAAE,oCAAoC;IACjE,aAAa,EAAE,0BAA0B;IACzC,2BAA2B,EAAE,wCAAwC;CACtE,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,2BAA2B,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAAC,IAAY;IACvD,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IACrC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,eAAe,CACvB,+CAA+C,IAAI,6EAA6E,CACjI,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAqC,MAAM,CAAC,MAAM,CAC3F,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAC5F,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAc;IACzD,OAAO,8BAA8B,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC;AAC1D,CAAC"}

package/dist/resolve-callee.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Package-aware callee resolution.
+ *
+ * A call edge stores its target as a `bodyHash`, which is a CONTENT hash:
+ * two functions with identical bodies in different packages share one hash.
+ * Looking a callee up by hash alone therefore mis-attributes its package
+ * whenever bodies collide (the cause of impossible coupling edges like
+ * `core→fitness`). `resolveCallee` disambiguates such a hash to the
+ * occurrence the caller can actually reach, deterministically.
+ *
+ * Pure, dependency-free (no node imports) so the same logic can be mirrored
+ * verbatim in the dashboard's browser-side coupling view.
+ */
+import type { FunctionOccurrence, Indexes } from './types.js';
+/**
+ * The first path segment under `packages/` — the unit the coupling grid
+ * groups by (so `packages/languages/lang-typescript/...` → `languages`,
+ * `packages/graph/graph-typescript/...` → `graph`). Returns `'<unknown>'`
+ * for paths outside `packages/`. Must match the dashboard's `packageOfPath`.
+ */
+export declare function packageOf(filePath: string): string;
+/**
+ * The package an occurrence belongs to. Prefers the build-time-stamped
+ * `occurrence.package` (nearest `package.json` name — accurate for any repo
+ * layout); falls back to the `packages/<segment>` path heuristic for
+ * legacy catalogs that predate the stamp.
+ */
+export declare function pkgOf(occ: Pick<FunctionOccurrence, 'package' | 'filePath'>): string;
+/**
+ * A package-unique, collision-free id for a single occurrence — its source
+ * location `${filePath}:${line}:${column}`. Unlike `bodyHash` (a CONTENT hash
+ * that two functions with identical bodies in different packages share), every
+ * occurrence has a unique declaration site, so occId never collapses distinct
+ * functions. Used as the SCC/cycle graph's node identity (the body-hash
+ * cross-package phantom fix) and keyed into `Indexes.byOccId`.
+ */
+export declare function occId(occ: Pick<FunctionOccurrence, 'filePath' | 'line' | 'column'>): string;
+/** The package groups the caller's module imports (empty in fast mode). */
+export declare function callerImportedPackages(callerOcc: FunctionOccurrence, indexes: Indexes): ReadonlySet<string>;
+/**
+ * Resolve a call edge's target `bodyHash` to the callee occurrence the
+ * caller can actually reach, disambiguating body-hash collisions across
+ * packages. Order:
+ *   1. an occurrence in the caller's own package;
+ *   2. an occurrence in a package the caller's module imports;
+ *   3. deterministic fallback — lowest `qualifiedName`.
+ * Returns `undefined` when the hash has no occurrences.
+ */
+export declare function resolveCallee(targetHash: string, callerOcc: FunctionOccurrence, indexes: Indexes): FunctionOccurrence | undefined;
+//# sourceMappingURL=resolve-callee.d.ts.map

package/dist/resolve-callee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-callee.d.ts","sourceRoot":"","sources":["../src/resolve-callee.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAI9D;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,UAAU,CAAC,GAAG,MAAM,CAEnF;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC,GAAG,MAAM,CAE3F;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,OAAO,GACf,WAAW,CAAC,MAAM,CAAC,CAErB;AAID;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAgBhC"}

package/dist/resolve-callee.js

@@ -0,0 +1,80 @@
+/**
+ * Package-aware callee resolution.
+ *
+ * A call edge stores its target as a `bodyHash`, which is a CONTENT hash:
+ * two functions with identical bodies in different packages share one hash.
+ * Looking a callee up by hash alone therefore mis-attributes its package
+ * whenever bodies collide (the cause of impossible coupling edges like
+ * `core→fitness`). `resolveCallee` disambiguates such a hash to the
+ * occurrence the caller can actually reach, deterministically.
+ *
+ * Pure, dependency-free (no node imports) so the same logic can be mirrored
+ * verbatim in the dashboard's browser-side coupling view.
+ */
+const PACKAGE_RE = /^packages\/([^/]+)\//;
+/**
+ * The first path segment under `packages/` — the unit the coupling grid
+ * groups by (so `packages/languages/lang-typescript/...` → `languages`,
+ * `packages/graph/graph-typescript/...` → `graph`). Returns `'<unknown>'`
+ * for paths outside `packages/`. Must match the dashboard's `packageOfPath`.
+ */
+export function packageOf(filePath) {
+    const m = PACKAGE_RE.exec(filePath);
+    return m ? m[1] : '<unknown>';
+}
+/**
+ * The package an occurrence belongs to. Prefers the build-time-stamped
+ * `occurrence.package` (nearest `package.json` name — accurate for any repo
+ * layout); falls back to the `packages/<segment>` path heuristic for
+ * legacy catalogs that predate the stamp.
+ */
+export function pkgOf(occ) {
+    return occ.package ?? packageOf(occ.filePath);
+}
+/**
+ * A package-unique, collision-free id for a single occurrence — its source
+ * location `${filePath}:${line}:${column}`. Unlike `bodyHash` (a CONTENT hash
+ * that two functions with identical bodies in different packages share), every
+ * occurrence has a unique declaration site, so occId never collapses distinct
+ * functions. Used as the SCC/cycle graph's node identity (the body-hash
+ * cross-package phantom fix) and keyed into `Indexes.byOccId`.
+ */
+export function occId(occ) {
+    return `${occ.filePath}:${String(occ.line)}:${String(occ.column)}`;
+}
+/** The package groups the caller's module imports (empty in fast mode). */
+export function callerImportedPackages(callerOcc, indexes) {
+    return indexes.importedPackagesByFile.get(callerOcc.filePath) ?? EMPTY_SET;
+}
+const EMPTY_SET = new Set();
+/**
+ * Resolve a call edge's target `bodyHash` to the callee occurrence the
+ * caller can actually reach, disambiguating body-hash collisions across
+ * packages. Order:
+ *   1. an occurrence in the caller's own package;
+ *   2. an occurrence in a package the caller's module imports;
+ *   3. deterministic fallback — lowest `qualifiedName`.
+ * Returns `undefined` when the hash has no occurrences.
+ */
+export function resolveCallee(targetHash, callerOcc, indexes) {
+    const candidates = indexes.occurrencesByHash.get(targetHash);
+    if (!candidates || candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return candidates[0];
+    const callerPkg = pkgOf(callerOcc);
+    const samePackage = candidates.filter((c) => pkgOf(c) === callerPkg);
+    if (samePackage.length > 0)
+        return lowestByQualifiedName(samePackage);
+    const imported = callerImportedPackages(callerOcc, indexes);
+    if (imported.size > 0) {
+        const inImported = candidates.filter((c) => imported.has(pkgOf(c)));
+        if (inImported.length > 0)
+            return lowestByQualifiedName(inImported);
+    }
+    return lowestByQualifiedName(candidates);
+}
+function lowestByQualifiedName(occs) {
+    return occs.reduce((lo, c) => (c.qualifiedName < lo.qualifiedName ? c : lo));
+}
+//# sourceMappingURL=resolve-callee.js.map

package/dist/resolve-callee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-callee.js","sourceRoot":"","sources":["../src/resolve-callee.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,QAAgB;IACxC,MAAM,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACpC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;AAChC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,GAAqD;IACzE,OAAO,GAAG,CAAC,OAAO,IAAI,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,GAA6D;IACjF,OAAO,GAAG,GAAG,CAAC,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;AACrE,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,sBAAsB,CACpC,SAA6B,EAC7B,OAAgB;IAEhB,OAAO,OAAO,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC;AAC7E,CAAC;AAED,MAAM,SAAS,GAAwB,IAAI,GAAG,EAAU,CAAC;AAEzD;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC3B,UAAkB,EAClB,SAA6B,EAC7B,OAAgB;IAEhB,MAAM,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7D,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC7D,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;IAElD,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IACnC,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;IACrE,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAEtE,MAAM,QAAQ,GAAG,sBAAsB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC5D,IAAI,QAAQ,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpE,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,qBAAqB,CAAC,UAAU,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,qBAAqB,CAAC,IAAmC;IAChE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/E,CAAC"}

package/dist/rules/__tests__/__fixtures__/catalog.fixture.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Shared rule-trigger fixture for the golden-fingerprint and
+ * signal-output snapshot tests.
+ *
+ * Builds one `Catalog` whose occurrences collectively trigger the original
+ * five-rule golden set:
+ *   - `graph:orphan-subtree`         — `orphanFn` (unreachable, no callers)
+ *   - `graph:test-only-reachable`    — `testHelperFn` (reached only from a test file)
+ *   - `graph:no-side-effect-path`    — `pureFn` (pure, ≥2 calls, span ≥10, discarded caller)
+ *   - `graph:always-throws-branch`   — `throwerFn` (every call is a `throw new …`)
+ *   - `graph:duplicated-function-body` — `dupA`/`dupB`/`dupC` (same bodyHash across 3 packages)
+ *
+ * The shape mirrors `rule-behaviors.test.ts`'s builders. Locations are fixed
+ * so the fingerprint multiset (`ruleId|file|line|col`) is deterministic.
+ */
+import type { Catalog } from '../../../types.js';
+/**
+ * Build the all-rules trigger catalog. Each occurrence's location is fixed so
+ * the emitted fingerprints are stable.
+ */
+export declare function buildAllRulesFixture(): Catalog;
+//# sourceMappingURL=catalog.fixture.d.ts.map

package/dist/rules/__tests__/__fixtures__/catalog.fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.fixture.d.ts","sourceRoot":"","sources":["../../../../src/rules/__tests__/__fixtures__/catalog.fixture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAgC,MAAM,mBAAmB,CAAC;AA6C/E;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAuF9C"}

package/dist/rules/__tests__/__fixtures__/catalog.fixture.js

@@ -0,0 +1,143 @@
+/**
+ * @fileoverview Shared rule-trigger fixture for the golden-fingerprint and
+ * signal-output snapshot tests.
+ *
+ * Builds one `Catalog` whose occurrences collectively trigger the original
+ * five-rule golden set:
+ *   - `graph:orphan-subtree`         — `orphanFn` (unreachable, no callers)
+ *   - `graph:test-only-reachable`    — `testHelperFn` (reached only from a test file)
+ *   - `graph:no-side-effect-path`    — `pureFn` (pure, ≥2 calls, span ≥10, discarded caller)
+ *   - `graph:always-throws-branch`   — `throwerFn` (every call is a `throw new …`)
+ *   - `graph:duplicated-function-body` — `dupA`/`dupB`/`dupC` (same bodyHash across 3 packages)
+ *
+ * The shape mirrors `rule-behaviors.test.ts`'s builders. Locations are fixed
+ * so the fingerprint multiset (`ruleId|file|line|col`) is deterministic.
+ */
+function occ(over) {
+    return {
+        qualifiedName: `${over.filePath}.${over.simpleName}`,
+        line: 1,
+        column: 0,
+        endLine: 2,
+        kind: 'function-declaration',
+        params: [],
+        returnType: null,
+        enclosingClass: null,
+        decorators: [],
+        visibility: 'exported',
+        inTestFile: false,
+        definedInGenerated: false,
+        calls: [],
+        ...over,
+    };
+}
+function edge(to, over = {}) {
+    return { to: [to], line: 2, column: 1, resolution: 'static', confidence: 'high', text: `${to}()`, ...over };
+}
+function catalogOf(occs) {
+    const functions = {};
+    for (const o of occs) {
+        const bucket = functions[o.simpleName];
+        if (bucket)
+            bucket.push(o);
+        else
+            functions[o.simpleName] = [o];
+    }
+    return {
+        version: '3.0',
+        tool: 'graph',
+        language: 'typescript',
+        builtAt: 'x',
+        cacheKey: 'k',
+        resolutionMode: 'exact',
+        functions,
+    };
+}
+/**
+ * Build the all-rules trigger catalog. Each occurrence's location is fixed so
+ * the emitted fingerprints are stable.
+ */
+export function buildAllRulesFixture() {
+    // ── orphan-subtree: a module-local function with no callers and no
+    //    incoming reachability. Not exported (exported orphans are skipped),
+    //    no decorators, not in a test file.
+    const orphanFn = occ({
+        bodyHash: 'ORPHAN',
+        simpleName: 'orphanFn',
+        filePath: 'packages/a/src/orphan.ts',
+        line: 10,
+        column: 2,
+        visibility: 'module-local',
+    });
+    // ── test-only-reachable: a module-local production function whose only
+    //    caller lives in a test file.
+    const testHelperFn = occ({
+        bodyHash: 'TESTHELP',
+        simpleName: 'testHelperFn',
+        filePath: 'packages/a/src/helper.ts',
+        line: 20,
+        column: 4,
+        visibility: 'module-local',
+    });
+    const testCaller = occ({
+        bodyHash: 'TESTCALLER',
+        simpleName: 'testCaller',
+        filePath: 'packages/a/src/helper.test.ts',
+        line: 5,
+        column: 0,
+        inTestFile: true,
+        visibility: 'module-local',
+        calls: [edge('TESTHELP')],
+    });
+    // ── no-side-effect-path: a pure exported function (≥2 calls, span ≥10, no
+    //    unresolved edges, pure callees) whose caller discards the return value.
+    const pureFn = occ({
+        bodyHash: 'PURE',
+        simpleName: 'pureCompute',
+        filePath: 'packages/a/src/pure.ts',
+        line: 30,
+        column: 0,
+        endLine: 45,
+        calls: [edge('LEAF1'), edge('LEAF2')],
+    });
+    const leaf1 = occ({ bodyHash: 'LEAF1', simpleName: 'leaf1', filePath: 'packages/a/src/pure.ts', line: 50, column: 0, visibility: 'module-local' });
+    const leaf2 = occ({ bodyHash: 'LEAF2', simpleName: 'leaf2', filePath: 'packages/a/src/pure.ts', line: 55, column: 0, visibility: 'module-local' });
+    const pureCaller = occ({
+        bodyHash: 'PURECALLER',
+        simpleName: 'pureDriver',
+        filePath: 'packages/a/src/pure.ts',
+        line: 60,
+        column: 0,
+        visibility: 'module-local',
+        calls: [edge('PURE', { discarded: true })],
+    });
+    // ── always-throws-branch: every documented call site is a `throw new …`.
+    const throwerFn = occ({
+        bodyHash: 'THROWER',
+        simpleName: 'alwaysThrows',
+        filePath: 'packages/a/src/throws.ts',
+        line: 70,
+        column: 0,
+        visibility: 'module-local',
+        calls: [edge('Error', { resolution: 'unknown', confidence: 'low', text: 'throw new Error("boom")' })],
+    });
+    // ── duplicated-function-body: same bodyHash across THREE distinct packages
+    //    (≥ default minCrossPackageDuplicatePackages = 3) → one aggregate signal.
+    const dupA = occ({ bodyHash: 'DUP', simpleName: 'shared', filePath: 'packages/a/src/dup.ts', line: 80, column: 0, endLine: 90 });
+    const dupB = occ({ bodyHash: 'DUP', simpleName: 'shared', filePath: 'packages/b/src/dup.ts', line: 80, column: 0, endLine: 90 });
+    const dupC = occ({ bodyHash: 'DUP', simpleName: 'shared', filePath: 'packages/c/src/dup.ts', line: 80, column: 0, endLine: 90 });
+    return catalogOf([
+        orphanFn,
+        testHelperFn,
+        testCaller,
+        pureFn,
+        leaf1,
+        leaf2,
+        pureCaller,
+        throwerFn,
+        dupA,
+        dupB,
+        dupC,
+    ]);
+}
+//# sourceMappingURL=catalog.fixture.js.map

package/dist/rules/__tests__/__fixtures__/catalog.fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.fixture.js","sourceRoot":"","sources":["../../../../src/rules/__tests__/__fixtures__/catalog.fixture.ts"],"names":[],"mappings":"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"}

package/dist/rules/__tests__/create-graph-signal.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * createGraphSignal — stamps source/ruleId + applies the override, reproducing the
+ * signal a rule used to hand-assemble (release 2.13.0, §5.9). Byte-equality with
+ * the former `createSignal({ source:'graph', ruleId, severity:
+ * applySeverityOverride(...) })` shape (modulo the generated id/timestamp).
+ */
+export {};
+//# sourceMappingURL=create-graph-signal.test.d.ts.map

package/dist/rules/__tests__/create-graph-signal.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-graph-signal.test.d.ts","sourceRoot":"","sources":["../../../src/rules/__tests__/create-graph-signal.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}