@opensip-cli/graph 0.1.0

package/dist/cross-package/resolve.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared cross-package call resolver — the ONE resolution model both graph
+ * engines link cross-package (workspace `@scope/pkg`) calls through.
+ *
+ * Background (ADR — exact↔sharded convergence). The graph tool builds the call
+ * graph two ways:
+ *   - SHARDED (default): per-package shards emit {@link CrossBoundaryCall}
+ *     descriptors (import specifier + callee name) which the cross-shard linker
+ *     resolves against the merged catalog's {@link ExportIndex}.
+ *   - EXACT (`--exact`): one `ts.Program` over all source, resolved by the
+ *     TypeScript type checker.
+ *
+ * The exact engine used to follow the type-checker alias straight into a
+ * workspace package's BUILT `dist/*.d.ts` (Node16 resolves `@opensip-cli/*` to
+ * the published declaration, not the source `.ts`). The `.d.ts` carries only a
+ * bodiless signature, so hashing it never matched the SOURCE body the catalog
+ * holds → the real cross-package edge was dropped (under-resolution); and the
+ * downstream name-only catalog fallback then fabricated phantom edges by matching
+ * a bare simple name with no import binding (over-resolution).
+ *
+ * This module factors the sharded linker's `(import specifier + callee name) →
+ * unique exported SOURCE occurrence` resolution into one place BOTH engines call,
+ * so the exact engine resolves cross-package calls the SAME way sharded does:
+ * binding-required, decline-beats-guess. There is exactly one resolution model,
+ * never two drifting copies.
+ *
+ * Engine-layer and language-agnostic: plain catalog + map/path math, no parser.
+ */
+import type { ExportIndex, PackageManifestIndex } from './export-index.js';
+import type { FunctionOccurrence } from '../types.js';
+/**
+ * Choose the single exported occurrence an import specifier + callee name link
+ * to, or `undefined` to DECLINE. Exactly one export → it. More than one (the
+ * same simple name exported from multiple files in the package) → narrow to the
+ * lone export whose project-relative file path matches the addressed subpath; if
+ * that does not collapse the set to exactly one, DECLINE rather than guess. Zero
+ * exports → decline (the name is not exported by this package — e.g. a re-export
+ * chain the V1 linker does not follow).
+ *
+ * A missing edge is safe; a phantom cross-package edge fails the gate.
+ */
+export declare function linkExported(exported: readonly FunctionOccurrence[], subpath: string | undefined): FunctionOccurrence | undefined;
+/** Inputs for {@link resolveCrossPackageCall}: the call's binding + the indexes. */
+export interface CrossPackageCallInput {
+    /** The RAW import specifier the callee name arrived through (`@scope/pkg[/sub]`). */
+    readonly importSpecifier: string | undefined;
+    /** The callee's simple name (`getSharedSourceFile`, `walkNodes`, …). */
+    readonly calleeName: string;
+    /** Per-package export symbol table built from the (merged / single) catalog. */
+    readonly exportIndex: ExportIndex;
+    /** Package `name` → manifest, turning a specifier into a package group. */
+    readonly manifestIndex: PackageManifestIndex;
+}
+/**
+ * Resolve a workspace (bare `@scope/pkg`) cross-package call to the UNIQUE
+ * exported SOURCE occurrence the TypeScript type checker would pick — or
+ * `undefined` to decline. The single seam both the sharded linker and the exact
+ * adapter use for `@scope/pkg` calls:
+ *
+ *   1. no specifier, or a relative (`./x`) specifier → not a bare workspace
+ *      import; return `undefined` (the caller handles relative/local pinning);
+ *   2. specifier resolves to no tracked workspace package (external npm, or an
+ *      unmappable subpath) → `undefined`;
+ *   3. otherwise look the callee name up in that package's export bucket and
+ *      {@link linkExported} it to a unique occurrence (else decline).
+ */
+export declare function resolveCrossPackageCall(input: CrossPackageCallInput): FunctionOccurrence | undefined;
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/cross-package/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,kBAAkB,GAAG,SAAS,CAWhC;AAED,oFAAoF;AACpF,MAAM,WAAW,qBAAqB;IACpC,qFAAqF;IACrF,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,aAAa,EAAE,oBAAoB,CAAC;CAC9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,qBAAqB,GAC3B,kBAAkB,GAAG,SAAS,CAQhC"}

package/dist/cross-package/resolve.js

@@ -0,0 +1,83 @@
+/**
+ * Shared cross-package call resolver — the ONE resolution model both graph
+ * engines link cross-package (workspace `@scope/pkg`) calls through.
+ *
+ * Background (ADR — exact↔sharded convergence). The graph tool builds the call
+ * graph two ways:
+ *   - SHARDED (default): per-package shards emit {@link CrossBoundaryCall}
+ *     descriptors (import specifier + callee name) which the cross-shard linker
+ *     resolves against the merged catalog's {@link ExportIndex}.
+ *   - EXACT (`--exact`): one `ts.Program` over all source, resolved by the
+ *     TypeScript type checker.
+ *
+ * The exact engine used to follow the type-checker alias straight into a
+ * workspace package's BUILT `dist/*.d.ts` (Node16 resolves `@opensip-cli/*` to
+ * the published declaration, not the source `.ts`). The `.d.ts` carries only a
+ * bodiless signature, so hashing it never matched the SOURCE body the catalog
+ * holds → the real cross-package edge was dropped (under-resolution); and the
+ * downstream name-only catalog fallback then fabricated phantom edges by matching
+ * a bare simple name with no import binding (over-resolution).
+ *
+ * This module factors the sharded linker's `(import specifier + callee name) →
+ * unique exported SOURCE occurrence` resolution into one place BOTH engines call,
+ * so the exact engine resolves cross-package calls the SAME way sharded does:
+ * binding-required, decline-beats-guess. There is exactly one resolution model,
+ * never two drifting copies.
+ *
+ * Engine-layer and language-agnostic: plain catalog + map/path math, no parser.
+ */
+import { resolveSpecifierToPackage } from './export-index.js';
+/**
+ * Choose the single exported occurrence an import specifier + callee name link
+ * to, or `undefined` to DECLINE. Exactly one export → it. More than one (the
+ * same simple name exported from multiple files in the package) → narrow to the
+ * lone export whose project-relative file path matches the addressed subpath; if
+ * that does not collapse the set to exactly one, DECLINE rather than guess. Zero
+ * exports → decline (the name is not exported by this package — e.g. a re-export
+ * chain the V1 linker does not follow).
+ *
+ * A missing edge is safe; a phantom cross-package edge fails the gate.
+ */
+export function linkExported(exported, subpath) {
+    if (exported.length === 1)
+        return exported[0];
+    if (exported.length === 0 || subpath === undefined)
+        return undefined;
+    // Subpath is `./rest` addressing a file within the imported package; keep only
+    // exports whose file path matches that subpath stem (extension-insensitive).
+    const stem = stripExt(subpath.replace(/^\.\//, ''));
+    const narrowed = exported.filter((o) => {
+        const fp = stripExt(o.filePath);
+        return fp === stem || fp.endsWith(`/${stem}`) || fp.endsWith(`/${stem}/index`);
+    });
+    return narrowed.length === 1 ? narrowed[0] : undefined;
+}
+/**
+ * Resolve a workspace (bare `@scope/pkg`) cross-package call to the UNIQUE
+ * exported SOURCE occurrence the TypeScript type checker would pick — or
+ * `undefined` to decline. The single seam both the sharded linker and the exact
+ * adapter use for `@scope/pkg` calls:
+ *
+ *   1. no specifier, or a relative (`./x`) specifier → not a bare workspace
+ *      import; return `undefined` (the caller handles relative/local pinning);
+ *   2. specifier resolves to no tracked workspace package (external npm, or an
+ *      unmappable subpath) → `undefined`;
+ *   3. otherwise look the callee name up in that package's export bucket and
+ *      {@link linkExported} it to a unique occurrence (else decline).
+ */
+export function resolveCrossPackageCall(input) {
+    const { importSpecifier, calleeName, exportIndex, manifestIndex } = input;
+    if (importSpecifier === undefined || importSpecifier.length === 0)
+        return undefined;
+    if (importSpecifier.startsWith('.'))
+        return undefined; // relative — not this seam's job
+    const resolved = resolveSpecifierToPackage(importSpecifier, manifestIndex);
+    if (resolved === undefined)
+        return undefined;
+    const exported = exportIndex.get(resolved.packageGroup)?.get(calleeName) ?? [];
+    return linkExported(exported, resolved.subpath);
+}
+function stripExt(p) {
+    return p.replace(/\.[A-Za-z0-9]+$/, '');
+}
+//# sourceMappingURL=resolve.js.map

package/dist/cross-package/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/cross-package/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAK9D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAuC,EACvC,OAA2B;IAE3B,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACrE,+EAA+E;IAC/E,6EAA6E;IAC7E,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACpD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QACrC,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QAChC,OAAO,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,CAAC;IACjF,CAAC,CAAC,CAAC;IACH,OAAO,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAcD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAA4B;IAE5B,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC;IAC1E,IAAI,eAAe,KAAK,SAAS,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACpF,IAAI,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC,CAAC,iCAAiC;IACxF,MAAM,QAAQ,GAAG,yBAAyB,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;IAC3E,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC7C,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IAC/E,OAAO,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,QAAQ,CAAC,CAAS;IACzB,OAAO,CAAC,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;AAC1C,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @opensip-cli/graph — public barrel.
+ *
+ * The graph tool implements a strict six-stage pipeline:
+ * discover → inventory → edges → indexes → rules → render.
+ */
+import './scope-augmentation.js';
+export type { GraphSubscope } from './scope-augmentation.js';
+export { graphTool, graphTool as tool } from './tool.js';
+export { GRAPH_CONTRACT_VERSION } from './tool.js';
+export { GRAPH_ENV_SPECS } from './cli/pressure-monitor.js';
+export type { Catalog, ReExportRecord, FunctionOccurrence, CallEdge, DependencyEdge, Param, Indexes, Rule, RuleHints, ResolutionStats, ResolverVerdict, ParseError, FunctionKind, CallResolution, CallConfidence, ResolutionMode, CrossBoundaryCall, Visibility, FeatureTable, FunctionFeatures, PackageFeatures, SccFeatures, PackageEdgeFeature, BlastScore, FeatureColumn, PersistedFeatures, PersistedFunctionFeatures, } from './types.js';
+export type { GraphLanguageAdapter, DiscoverInput, DiscoverOutput, ParseInput, ParseOutput, WalkInput, WalkOutput, ResolveInput, ResolveOutput, CallSiteRecord, DependencySiteRecord, CacheKeyInput, ParsedProject, } from './lang-adapter/types.js';
+export type { CallConfidence as AdapterCallConfidence } from './types.js';
+export { pickAdapter, createAdapterRegistry, currentAdapterRegistry, GraphAdapterRegistry, } from './lang-adapter/registry.js';
+export { GraphAdapterSelector } from './lang-adapter/selector.js';
+export { truncateForCallEdge, CALL_EDGE_TEXT_MAX, CREATION_EDGE_PREFIX, CREATION_EDGE_TEXT_MAX, appendEdge, createMutableStats, pushCreationEdge, } from './lang-adapter/edge-helpers.js';
+export type { EdgePosition, EdgeSink, MutableStats } from './lang-adapter/edge-helpers.js';
+export { normalizeWhitespace, hashBody } from './lang-adapter/body-digest.js';
+export type { BodyDigest } from './lang-adapter/body-digest.js';
+export { ownerEdgeKey } from './owner-key.js';
+export { buildExportIndex, buildPackageManifestIndex, buildPackageManifestIndexFromRoots, resolveSpecifierToPackage, } from './cross-package/export-index.js';
+export type { ExportIndex, PackageManifest, PackageManifestIndex, ResolvedSpecifier, } from './cross-package/export-index.js';
+export { resolveCrossPackageCall, linkExported } from './cross-package/resolve.js';
+export type { CrossPackageCallInput } from './cross-package/resolve.js';
+export { defineRule } from './rules/define-rule.js';
+export type { RuleDataset, GraphFeatures, DefineRuleConfig } from './rules/define-rule.js';
+export { defineGraphRecipe } from './recipes/types.js';
+export type { GraphRecipe, GraphRecipeDefinition, RuleSelector, RuleConfigMap, } from './recipes/types.js';
+export { builtInGraphRecipes, builtInGraphRecipesByName, defaultGraphRecipe, deadCodeGraphRecipe, isBuiltInGraphRecipe, } from './recipes/built-in-recipes.js';
+export { GraphRecipeRegistry, createRecipeRegistry, currentGraphRecipes, } from './recipes/registry.js';
+export { resolveRecipeToRules } from './recipes/resolve.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAKH,OAAO,yBAAyB,CAAC;AACjC,YAAY,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAM7D,OAAO,EAAE,SAAS,EAAE,SAAS,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAGnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAgB5D,YAAY,EACV,OAAO,EACP,cAAc,EACd,kBAAkB,EAClB,QAAQ,EACR,cAAc,EACd,KAAK,EACL,OAAO,EACP,IAAI,EACJ,SAAS,EACT,eAAe,EACf,eAAe,EACf,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AA0BpB,YAAY,EACV,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,UAAU,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,YAAY,EACZ,aAAa,EACb,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,aAAa,GACd,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,cAAc,IAAI,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,gCAAgC,CAAC;AASxC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAS3F,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9E,YAAY,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAUhE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAY9C,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,kCAAkC,EAClC,yBAAyB,GAC1B,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACV,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AACnF,YAAY,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAIxE,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE3F,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EACV,WAAW,EACX,qBAAqB,EACrB,YAAY,EACZ,aAAa,GACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,61 @@
+// @fitness-ignore-file module-coupling-fan-out -- Public barrel: re-exports the surface of each pipeline stage; fan-out is the contract of this file
+/**
+ * @opensip-cli/graph — public barrel.
+ *
+ * The graph tool implements a strict six-stage pipeline:
+ * discover → inventory → edges → indexes → rules → render.
+ */
+// Side-effect import: surfaces the `scope.graph` augmentation on
+// @opensip-cli/core's RunScope interface (D7 — tool subscopes via
+// module augmentation).
+import './scope-augmentation.js';
+// Re-exported as `tool` so the third-party plugin-discovery walker
+// (which keys on `mod.tool`) treats first-party and third-party Tool
+// packages uniformly; dedup at register-tools.ts handles the
+// duplicate-id case.
+export { graphTool, graphTool as tool } from './tool.js';
+export { GRAPH_CONTRACT_VERSION } from './tool.js';
+// Graph-engine environment-variable specs (launch, §5.12) — the CLI
+// composition root imports these to aggregate the env-surface reference doc.
+export { GRAPH_ENV_SPECS } from './cli/pressure-monitor.js';
+export { pickAdapter, createAdapterRegistry, currentAdapterRegistry, GraphAdapterRegistry, } from './lang-adapter/registry.js';
+export { GraphAdapterSelector } from './lang-adapter/selector.js';
+export { truncateForCallEdge, CALL_EDGE_TEXT_MAX, CREATION_EDGE_PREFIX, CREATION_EDGE_TEXT_MAX, appendEdge, createMutableStats, pushCreationEdge, } from './lang-adapter/edge-helpers.js';
+// ── Shared body-digest primitives ─────────────────────────────────
+//
+// The normalize-to-hash tail of the `bodyHash` pipeline (BodyDigest
+// shape + whitespace normalizer + hash/size step) was byte-identical
+// across the tree-sitter adapter packs. Hoisted here so each pack keeps
+// only its language-specific comment stripper / normalizer (round-3
+// audit 2026-05-30, finding D). Mirrors the edge-helpers rationale.
+export { normalizeWhitespace, hashBody } from './lang-adapter/body-digest.js';
+// PR 3 of plan 2026-05-23-plan-graph-adapter-package-split.md:
+// first-party adapters live in their own graph-* packages, so the
+// engine no longer re-exports any adapter, parsed-project type, or
+// rule-hints constant. Cross-package tests import directly from each
+// adapter pack.
+// `ownerEdgeKey` is public API: the tree-sitter adapter packs consume it to
+// emit owner edges consistently with the engine (part of the adapter contract).
+export { ownerEdgeKey } from './owner-key.js';
+// ── Cross-package resolution primitives ────────────────────────────
+//
+// The SINGLE (import specifier + callee name) → unique exported SOURCE
+// occurrence resolution model both graph engines link `@scope/pkg` calls
+// through. The sharded orchestrator's cross-shard linker uses it; the
+// TypeScript adapter's exact resolvers use it too, so the exact engine
+// resolves cross-package calls the SAME way sharded does (binding-required,
+// decline-beats-guess) instead of following the type-checker alias into a
+// bodiless `dist/*.d.ts`. Pure, language-agnostic — part of the adapter
+// contract surface alongside the edge-helpers and body-digest primitives.
+export { buildExportIndex, buildPackageManifestIndex, buildPackageManifestIndexFromRoots, resolveSpecifierToPackage, } from './cross-package/export-index.js';
+export { resolveCrossPackageCall, linkExported } from './cross-package/resolve.js';
+// `buildIndexes` and the individual built-in rule instances are NOT public —
+// they're consumed only by the cross-package rule tests and moved to
+// `@opensip-cli/graph/internal` (rules run via recipes by id). See ADR-0009.
+export { defineRule } from './rules/define-rule.js';
+// ── Graph recipes (Plan B — symmetric with fitness recipes) ────────
+export { defineGraphRecipe } from './recipes/types.js';
+export { builtInGraphRecipes, builtInGraphRecipesByName, defaultGraphRecipe, deadCodeGraphRecipe, isBuiltInGraphRecipe, } from './recipes/built-in-recipes.js';
+export { GraphRecipeRegistry, createRecipeRegistry, currentGraphRecipes, } from './recipes/registry.js';
+export { resolveRecipeToRules } from './recipes/resolve.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qJAAqJ;AACrJ;;;;;GAKG;AAEH,iEAAiE;AACjE,kEAAkE;AAClE,wBAAwB;AACxB,OAAO,yBAAyB,CAAC;AAGjC,mEAAmE;AACnE,qEAAqE;AACrE,6DAA6D;AAC7D,qBAAqB;AACrB,OAAO,EAAE,SAAS,EAAE,SAAS,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,oEAAoE;AACpE,6EAA6E;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAsF5D,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,gCAAgC,CAAC;AAWxC,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,qEAAqE;AACrE,wEAAwE;AACxE,oEAAoE;AACpE,oEAAoE;AACpE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAG9E,+DAA+D;AAC/D,kEAAkE;AAClE,mEAAmE;AACnE,qEAAqE;AACrE,gBAAgB;AAEhB,4EAA4E;AAC5E,gFAAgF;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,sEAAsE;AACtE,EAAE;AACF,uEAAuE;AACvE,yEAAyE;AACzE,sEAAsE;AACtE,uEAAuE;AACvE,4EAA4E;AAC5E,0EAA0E;AAC1E,wEAAwE;AACxE,0EAA0E;AAC1E,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,kCAAkC,EAClC,yBAAyB,GAC1B,MAAM,iCAAiC,CAAC;AAOzC,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAEnF,6EAA6E;AAC7E,qEAAqE;AACrE,6EAA6E;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,sEAAsE;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAOvD,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/internal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview `@opensip-cli/graph/internal` — engine internals exposed
+ * ONLY for the cross-package adapter test suites (graph-typescript et al.).
+ *
+ * This is NOT public API. Production code in other packages must not import
+ * from `@opensip-cli/graph/internal` (enforced by dependency-cruiser per
+ * ADR-0009). The individual built-in rule instances live here because the
+ * public way to run a rule is via a recipe (by id); only the rule unit tests
+ * need the raw rule object to call `.evaluate(...)` directly.
+ */
+export { buildIndexes } from './pipeline/indexes.js';
+export type { GraphConfig } from './types.js';
+export { alwaysThrowsBranchRule } from './rules/always-throws-branch.js';
+export { noSideEffectPathRule } from './rules/no-side-effect-path.js';
+export { duplicatedFunctionBodyRule } from './rules/duplicated-function-body.js';
+export { orphanSubtreeRule } from './rules/orphan-subtree.js';
+export { runGraph, GRAPH_STAGES } from './cli/orchestrate.js';
+export type { GraphStage, GraphProgressEvent, GraphProgressCallback, RunGraphInput, RunGraphResult, } from './cli/orchestrate.js';
+export { executeGraph, buildUnifiedReportLines } from './cli/graph.js';
+export type { UnifiedReportInput } from './cli/graph.js';
+export { CatalogRepo } from './persistence/catalog-repo.js';
+export { MemoryPressureError } from './cli/pressure-monitor.js';
+export { HEAP_TARGETS, decideHeapTargetMb, systemHasMemoryFor, runHeapPreflight, totalSystemMemoryMb, } from './cli/heap-preflight.js';
+export type { Shard, ShardBuildResult } from './cli/orchestrate/shard-model.js';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAKrD,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAU9D,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC9D,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACvE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAQzD,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/internal.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview `@opensip-cli/graph/internal` — engine internals exposed
+ * ONLY for the cross-package adapter test suites (graph-typescript et al.).
+ *
+ * This is NOT public API. Production code in other packages must not import
+ * from `@opensip-cli/graph/internal` (enforced by dependency-cruiser per
+ * ADR-0009). The individual built-in rule instances live here because the
+ * public way to run a rule is via a recipe (by id); only the rule unit tests
+ * need the raw rule object to call `.evaluate(...)` directly.
+ */
+// Index builder — used by the adapter rule tests to assemble a catalog's
+// indexes before invoking a rule's `.evaluate(...)`. The dashboard has its own
+// index builder; nothing in production consumes the engine's.
+export { buildIndexes } from './pipeline/indexes.js';
+export { alwaysThrowsBranchRule } from './rules/always-throws-branch.js';
+export { noSideEffectPathRule } from './rules/no-side-effect-path.js';
+export { duplicatedFunctionBodyRule } from './rules/duplicated-function-body.js';
+export { orphanSubtreeRule } from './rules/orphan-subtree.js';
+// ── Orchestration / CLI-handler surface (ADR-0009, Finding 3) ──────
+//
+// These drive the six-stage pipeline and the `graph` CLI command. The
+// production path reaches them via `graphTool.commandSpecs` (host-mounted,
+// and the parent repo via the `catalog-export` subcommand), never by importing these
+// symbols — so they are private. Only the cross-package adapter and CLI
+// telemetry test suites import them, exercising the orchestrator end to
+// end without going through Commander.
+export { runGraph, GRAPH_STAGES } from './cli/orchestrate.js';
+export { executeGraph, buildUnifiedReportLines } from './cli/graph.js';
+// `CatalogRepo` — the engine's SQLite/Drizzle catalog persistence repo. Used
+// internally by graph (orchestrator cache, `tool.ts` report contribution,
+// `lookup`/`catalog-export`). It was briefly on the public barrel for fitness's
+// report command; with that coupling gone it is demoted here — a concrete
+// repository is not a module contract (boundary audit 2026-06-05). Any future
+// out-of-package read should go through a narrow catalog-read contract, not this.
+export { CatalogRepo } from './persistence/catalog-repo.js';
+export { MemoryPressureError } from './cli/pressure-monitor.js';
+export { HEAP_TARGETS, decideHeapTargetMb, systemHasMemoryFor, runHeapPreflight, totalSystemMemoryMb, } from './cli/heap-preflight.js';
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,yEAAyE;AACzE,+EAA+E;AAC/E,8DAA8D;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAOrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,sEAAsE;AACtE,EAAE;AACF,sEAAsE;AACtE,2EAA2E;AAC3E,qFAAqF;AACrF,wEAAwE;AACxE,wEAAwE;AACxE,uCAAuC;AACvC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAQ9D,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAGvE,6EAA6E;AAC7E,0EAA0E;AAC1E,gFAAgF;AAChF,0EAA0E;AAC1E,8EAA8E;AAC9E,kFAAkF;AAClF,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,yBAAyB,CAAC"}

package/dist/lang-adapter/body-digest.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Shared body-digest primitives for GraphLanguageAdapters.
+ *
+ * The catalog's `bodyHash` contract is "reduce a function body to a
+ * canonical string, then SHA-256 it." The normalize-to-hash TAIL of that
+ * pipeline — the `BodyDigest` shape, the whitespace-collapse normalizer,
+ * and the hash+size step — was byte-identical across every adapter that
+ * hashes bodies (go/java/rust real bodies, plus the synthetic-body path
+ * in all four tree-sitter packs). Per the round-3 modular-monolith audit
+ * (2026-05-30, finding D) it lives here on the contract layer instead of
+ * being copy-pasted into each pack.
+ *
+ * This mirrors edge-helpers.ts exactly: tiny utilities that used to be
+ * duplicated under each adapter now sit in lang-adapter/, which adapters
+ * already import types from — so importing one more helper is
+ * structurally consistent and violates no layering rule (lang-* adapters
+ * may not import each OTHER, but lang-adapter/ is fair game).
+ *
+ * What deliberately STAYS in each adapter pack: the language-specific
+ * comment stripper (Go rune literals vs Java text blocks vs Rust nested
+ * block comments) and any language-specific normalization. Python, for
+ * example, substitutes its own `normalizePythonBody` for real bodies
+ * because indentation is semantically significant there — it still
+ * composes `hashBody` + `normalizeWhitespace` for synthetic bodies. The
+ * primitives are intentionally low-level (not a single `digestBody(text,
+ * stripFn)`) precisely so a pack can swap the normalization step.
+ */
+/** Catalog body fingerprint: SHA-256 hex hash + canonical-text length. */
+export interface BodyDigest {
+    readonly hash: string;
+    readonly size: number;
+}
+/**
+ * Collapse every run of whitespace to a single space and trim. The
+ * default body normalization for whitespace-insensitive languages
+ * (Go/Java/Rust) and for synthetic (module-init) bodies in every pack.
+ */
+export declare function normalizeWhitespace(s: string): string;
+/**
+ * SHA-256 an already-normalized ("canonical") body string into a
+ * `BodyDigest`. `size` is the canonical-text length so it tracks the
+ * hashed content, not the raw source. Callers normalize first — via
+ * `normalizeWhitespace` or a language-specific normalizer.
+ */
+export declare function hashBody(canonical: string): BodyDigest;
+//# sourceMappingURL=body-digest.d.ts.map

package/dist/lang-adapter/body-digest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-digest.d.ts","sourceRoot":"","sources":["../../src/lang-adapter/body-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAKtD"}

package/dist/lang-adapter/body-digest.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Shared body-digest primitives for GraphLanguageAdapters.
+ *
+ * The catalog's `bodyHash` contract is "reduce a function body to a
+ * canonical string, then SHA-256 it." The normalize-to-hash TAIL of that
+ * pipeline — the `BodyDigest` shape, the whitespace-collapse normalizer,
+ * and the hash+size step — was byte-identical across every adapter that
+ * hashes bodies (go/java/rust real bodies, plus the synthetic-body path
+ * in all four tree-sitter packs). Per the round-3 modular-monolith audit
+ * (2026-05-30, finding D) it lives here on the contract layer instead of
+ * being copy-pasted into each pack.
+ *
+ * This mirrors edge-helpers.ts exactly: tiny utilities that used to be
+ * duplicated under each adapter now sit in lang-adapter/, which adapters
+ * already import types from — so importing one more helper is
+ * structurally consistent and violates no layering rule (lang-* adapters
+ * may not import each OTHER, but lang-adapter/ is fair game).
+ *
+ * What deliberately STAYS in each adapter pack: the language-specific
+ * comment stripper (Go rune literals vs Java text blocks vs Rust nested
+ * block comments) and any language-specific normalization. Python, for
+ * example, substitutes its own `normalizePythonBody` for real bodies
+ * because indentation is semantically significant there — it still
+ * composes `hashBody` + `normalizeWhitespace` for synthetic bodies. The
+ * primitives are intentionally low-level (not a single `digestBody(text,
+ * stripFn)`) precisely so a pack can swap the normalization step.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Collapse every run of whitespace to a single space and trim. The
+ * default body normalization for whitespace-insensitive languages
+ * (Go/Java/Rust) and for synthetic (module-init) bodies in every pack.
+ */
+export function normalizeWhitespace(s) {
+    return s.replaceAll(/\s+/g, ' ').trim();
+}
+/**
+ * SHA-256 an already-normalized ("canonical") body string into a
+ * `BodyDigest`. `size` is the canonical-text length so it tracks the
+ * hashed content, not the raw source. Callers normalize first — via
+ * `normalizeWhitespace` or a language-specific normalizer.
+ */
+export function hashBody(canonical) {
+    return {
+        hash: createHash('sha256').update(canonical, 'utf8').digest('hex'),
+        size: canonical.length,
+    };
+}
+//# sourceMappingURL=body-digest.js.map

package/dist/lang-adapter/body-digest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-digest.js","sourceRoot":"","sources":["../../src/lang-adapter/body-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQzC;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,CAAS;IAC3C,OAAO,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,SAAiB;IACxC,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;QAClE,IAAI,EAAE,SAAS,CAAC,MAAM;KACvB,CAAC;AACJ,CAAC"}

package/dist/lang-adapter/edge-helpers.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Shared resolver helpers usable by any GraphLanguageAdapter.
+ *
+ * These tiny utilities used to live duplicated under each lang-*
+ * adapter (`appendEdge`, `pushCreationEdge`, the `MutableStats`
+ * counter shape). The duplicated-function-body rule flagged the
+ * duplication, which is correct — the bodies really are identical
+ * and the rule has no false-positive heuristic that would skip them.
+ *
+ * Putting these in lang-adapter/ keeps them on the contract layer:
+ * adapters already import types from `./types.js`, so importing one
+ * more helper is structurally consistent. The layering rules forbid
+ * lang-* adapters from importing each other but say nothing about
+ * lang-adapter/.
+ */
+import type { CallEdge } from '../types.js';
+/** Maximum length of a `CallEdge.text` field. Per types.ts contract. */
+export declare const CALL_EDGE_TEXT_MAX = 80;
+/** Prefix prepended to creation-edge text (`[creates] `). */
+export declare const CREATION_EDGE_PREFIX = "[creates] ";
+/**
+ * Maximum length of the inner source-text slice that gets prefixed
+ * with `[creates] ` to form a creation edge. The total edge text
+ * after prefixing is bounded by `CALL_EDGE_TEXT_MAX`.
+ */
+export declare const CREATION_EDGE_TEXT_MAX: number;
+/**
+ * Truncate raw call-site source text to fit within `CallEdge.text`'s
+ * 80-char contract. Long strings get sliced and ellipsized; short
+ * strings pass through unchanged. Single source of truth for the
+ * truncation contract — adapters call this instead of inlining the
+ * length math.
+ */
+export declare function truncateForCallEdge(text: string): string;
+/**
+ * Append a CallEdge to the per-owner edge list, creating the list on
+ * first append. Trivial — but small functions deserve a single home.
+ */
+export declare function appendEdge(edgesByOwner: Map<string, CallEdge[]>, ownerHash: string, edge: CallEdge): void;
+/**
+ * Per-confidence stat counters mutated as edges are appended. Same
+ * shape every adapter resolver assembles inline; consolidated here
+ * with an `apply(edge)` method that classifies and bumps the right
+ * counter so resolvers don't repeat the if-ladder.
+ *
+ * Use {@link createMutableStats} for a fresh zeroed instance.
+ */
+export interface MutableStats {
+    totalCallSites: number;
+    resolvedHigh: number;
+    resolvedMedium: number;
+    resolvedLow: number;
+    unresolved: number;
+    /**
+     * Classify `edge` by its `to.length` and `confidence` and bump the
+     * matching counter. Does NOT touch `totalCallSites` — call sites
+     * include unresolved-by-shape decisions that don't always produce
+     * an edge, so call-site counting stays the resolver's job.
+     */
+    apply(edge: CallEdge): void;
+}
+/**
+ * The two output accumulators a resolver threads through edge emission:
+ * the per-owner edge map and the running confidence stats. Grouping them
+ * names the "resolution output" a resolver allocates once per pass and
+ * keeps the edge-push helpers (and the adapter `pushCallEdge` functions)
+ * under the wide-function parameter budget.
+ */
+export interface EdgeSink {
+    /** Per-owner-hash edge list, appended via {@link appendEdge}. */
+    readonly edgesByOwner: Map<string, CallEdge[]>;
+    /** Running per-confidence counters, bumped as edges are appended. */
+    readonly stats: MutableStats;
+}
+/** Constructs a fresh {@link MutableStats} accumulator for edge resolver bookkeeping. */
+export declare function createMutableStats(): MutableStats;
+/**
+ * Position info every adapter must derive from its node/file pair to
+ * build a CallEdge. Adapters supply this via the `position` callback
+ * to {@link pushCreationEdge}, keeping the helper agnostic to the
+ * underlying parser shape (TS Node + SourceFile, tree-sitter Node +
+ * source string, etc.).
+ */
+export interface EdgePosition {
+    /** 1-based line number. */
+    readonly line: number;
+    /** 0-based column. */
+    readonly column: number;
+    /** Source text of the call site, untruncated. */
+    readonly text: string;
+}
+/**
+ * Append a synthetic creation edge — the parent owner contains an
+ * inline-callable child, so its enclosing scope's reachability flows
+ * to the child unconditionally. Static, high-confidence by
+ * construction.
+ *
+ * Parser-agnostic: the caller resolves the call site's {@link EdgePosition}
+ * (the only thing the helper needs from the adapter's node/file pair) and
+ * passes it in, so this helper never touches a parser-specific node shape.
+ * Bumps `totalCallSites` and `resolvedHigh` on the sink's stats.
+ */
+export declare function pushCreationEdge(pos: EdgePosition, ownerHash: string, childHash: string, sink: EdgeSink): void;
+//# sourceMappingURL=edge-helpers.d.ts.map

package/dist/lang-adapter/edge-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-helpers.d.ts","sourceRoot":"","sources":["../../src/lang-adapter/edge-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAU5C,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAQrC,6DAA6D;AAC7D,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAmD,CAAC;AAIvF;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIxD;AAaD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,EACrC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,GACb,IAAI,CAIN;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC/C,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,IAAI,YAAY,CAkBjD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sBAAsB;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,GACb,IAAI,CAcN"}