@descryy/runtime-graph-correlator 0.3.0 → 0.4.0

package/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) Descry
+
+All rights reserved. This software is proprietary and confidential.
+No license, express or implied, to reproduce, distribute, modify, or
+create derivative works is granted except as explicitly agreed in
+writing.

package/dist/confirm-observed-caller.d.ts

@@ -1,60 +1,32 @@
 /**
- * The first production caller of `applyRuntimeObservations()` — architecture
- * §11B.3's R4 runtime confirmation, wired to a real observation source.
+ * First production caller of `applyRuntimeObservations()` — §11B.3's R4 runtime confirmation,
+ * wired to a real observation source. `observed_edges` and `edge_corrections` have existed in the
+ * schema since the store was written; nothing read or wrote either one until this.
  *
- * §11B.3 calls runtime confirmation *"the core technical moat rather than the
- * graph itself"*, and states the consequence plainly: *"a purely static
- * code-graph tool is capped at R3 permanently."* The mechanism has existed in
- * `@descryy/core` since it was built, and the two EARNED tables it writes
- * (`observed_edges`, `edge_corrections`) have been in the store's schema since
- * the store was first written — each with a comment explaining why they cannot
- * be regenerated from source at any price. **Nothing read or wrote either one.**
- * This is what makes the moat run.
+ * `resolveObservedFrontendCaller` does the hard half already — it resolves a captured stack to a
+ * FUNCTION and checks it against the endpoint's structural candidates. Its two observed outcomes
+ * map directly:
  *
- * ## Why this producer
- *
- * `resolveObservedFrontendCaller` already does the hard half. It takes a real
- * captured `fetch()` call-site stack, resolves its site of interest to a
- * `FUNCTION` node, and checks that node against the structural candidate set the
- * graph holds for the endpoint. Its two observed outcomes *are* two of §11B.3's
- * three arrows, and needed only to be spoken in the vocabulary
- * `applyRuntimeObservations` reads:
- *
- * | resolution outcome | arrow |
+ * | outcome | action |
  * | --- | --- |
- * | `observed` | the graph already holds this `USES_API` edge below R4 — **promote it** |
- * | `structural-observed-conflict` | a real node the structural side never named — **mint the edge at R4** (§11B.3's *"recall gap closed"*) |
- *
- * Everything else — no stack, an unresolvable frame, an ambiguous or missing
- * symbol — produces **no observation at all**. Not an empty confirmation that
- * looks like one; none.
- *
- * ## Why there is no denial arrow here, and why that is a decision
- *
- * `applyRuntimeObservations` accepts `held: false` — runtime saw that an edge
- * did not hold — and records a correction that demotes the edge's confidence.
- * **This producer never emits one, and must not.**
- *
- * A frontend caller resolution can establish that a call *happened*. It cannot
- * establish that one did not: a page visit exercises one code path, and the
- * absence of a captured stack for some other function is absence of evidence,
- * not evidence of absence. Minting a denial from that would demote a correct
- * edge on the strength of a route the run happened not to take — precisely the
- * wrong-direction failure rule 2 exists to prevent, arriving through the one
- * mechanism designed to make the graph *more* trustworthy.
- *
- * The denial arrow is real and stays available; it belongs to a producer that
- * can actually establish non-occurrence (an exhaustive call-graph trace over a
- * fully exercised path), not to this one.
- *
- * ## What this does not do
- *
- * - **It does not judge a finding.** Resolution has no opinion on confidence
- *   (RT-027). Nothing here reads or writes a finding, hypothesis or category.
- * - **It does not decide staleness.** An R4-vs-R4 disagreement is reported by
- *   the core function as `staleR4` and passed through untouched.
- * - **It does not invent a node.** That refusal is core's, and its `refused`
- *   list is passed through rather than swallowed.
+ * | `observed` | edge already held below R4 — promote it |
+ * | `structural-observed-conflict` | real node the structural side never named — mint the edge at R4 |
+ *
+ * Everything else (no stack, unresolvable frame, ambiguous/missing symbol) produces no observation
+ * at all — not an empty one, none.
+ *
+ * **No denial arrow here, deliberately.** `applyRuntimeObservations` accepts `held: false` to demote
+ * an edge's confidence, but a frontend caller resolution can only establish that a call happened,
+ * never that one didn't — a page visit exercises one path, and an uncaptured stack for some other
+ * function is absence of evidence, not evidence of absence. Minting a denial from that would demote
+ * a correct edge on the strength of a route the run didn't take (rule 2). Denial belongs to a
+ * producer that can establish non-occurrence (an exhaustive call-graph trace over a fully exercised
+ * path).
+ *
+ * **Does not judge a finding** (RT-027) — no opinion on confidence, nothing here touches a
+ * finding/hypothesis/category. **Does not decide staleness** — an R4-vs-R4 disagreement passes
+ * through as core's own `staleR4`. **Does not invent a node** — core's `refused` list passes
+ * through untouched.
  */
 import type { RuntimeEdgeObservation } from "@descryy/ir";
 import { type RuntimeConfirmationResult, type SqlDriver } from "@descryy/core";
@@ -73,20 +45,13 @@ export interface ConfirmObservedCallerInput {
     readonly repoRoot?: string;
 }
 export interface ConfirmObservedCallerOutcome {
-    /**
-     * The underlying resolution, unchanged and always present — including when it
-     * produced no observation. A caller that wants the structural answer still
-     * gets exactly what `resolveObservedFrontendCaller` would have returned.
-     */
+    /** The underlying resolution, always present, even when it produced no observation. */
     readonly resolution: ObservedFrontendCallerResolution;
     /** What was sent to the graph. Empty when the resolution observed nothing. */
     readonly observations: readonly RuntimeEdgeObservation[];
     /** Core's own result, passed through whole — refusals and `staleR4` included. */
     readonly confirmation: RuntimeConfirmationResult;
 }
-/**
- * Resolve one observed frontend call and, when it genuinely observed something,
- * record it as R4 evidence against the graph.
- */
+/** Resolve one observed frontend call and, when it genuinely observed something, record it as R4 evidence. */
 export declare function confirmObservedFrontendCaller(driver: SqlDriver, input: ConfirmObservedCallerInput): ConfirmObservedCallerOutcome;
 //# sourceMappingURL=confirm-observed-caller.d.ts.map

package/dist/confirm-observed-caller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"confirm-observed-caller.d.ts","sourceRoot":"","sources":["../src/confirm-observed-caller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,SAAS,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,0BAA0B;IACzC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,gFAAgF;IAChF,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mIAAmI;IACnI,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,gCAAgC,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACzD,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,yBAAyB,CAAC;CAClD;AAMD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,0BAA0B,GAChC,4BAA4B,CAyB9B"}
+{"version":3,"file":"confirm-observed-caller.d.ts","sourceRoot":"","sources":["../src/confirm-observed-caller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,SAAS,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,0BAA0B;IACzC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,gFAAgF;IAChF,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mIAAmI;IACnI,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,4BAA4B;IAC3C,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,gCAAgC,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACzD,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,yBAAyB,CAAC;CAClD;AAMD,8GAA8G;AAC9G,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,0BAA0B,GAChC,4BAA4B,CAsB9B"}

package/dist/confirm-observed-caller.js

@@ -1,78 +1,44 @@
 /**
- * The first production caller of `applyRuntimeObservations()` — architecture
- * §11B.3's R4 runtime confirmation, wired to a real observation source.
+ * First production caller of `applyRuntimeObservations()` — §11B.3's R4 runtime confirmation,
+ * wired to a real observation source. `observed_edges` and `edge_corrections` have existed in the
+ * schema since the store was written; nothing read or wrote either one until this.
  *
- * §11B.3 calls runtime confirmation *"the core technical moat rather than the
- * graph itself"*, and states the consequence plainly: *"a purely static
- * code-graph tool is capped at R3 permanently."* The mechanism has existed in
- * `@descryy/core` since it was built, and the two EARNED tables it writes
- * (`observed_edges`, `edge_corrections`) have been in the store's schema since
- * the store was first written — each with a comment explaining why they cannot
- * be regenerated from source at any price. **Nothing read or wrote either one.**
- * This is what makes the moat run.
+ * `resolveObservedFrontendCaller` does the hard half already — it resolves a captured stack to a
+ * FUNCTION and checks it against the endpoint's structural candidates. Its two observed outcomes
+ * map directly:
  *
- * ## Why this producer
- *
- * `resolveObservedFrontendCaller` already does the hard half. It takes a real
- * captured `fetch()` call-site stack, resolves its site of interest to a
- * `FUNCTION` node, and checks that node against the structural candidate set the
- * graph holds for the endpoint. Its two observed outcomes *are* two of §11B.3's
- * three arrows, and needed only to be spoken in the vocabulary
- * `applyRuntimeObservations` reads:
- *
- * | resolution outcome | arrow |
+ * | outcome | action |
  * | --- | --- |
- * | `observed` | the graph already holds this `USES_API` edge below R4 — **promote it** |
- * | `structural-observed-conflict` | a real node the structural side never named — **mint the edge at R4** (§11B.3's *"recall gap closed"*) |
- *
- * Everything else — no stack, an unresolvable frame, an ambiguous or missing
- * symbol — produces **no observation at all**. Not an empty confirmation that
- * looks like one; none.
- *
- * ## Why there is no denial arrow here, and why that is a decision
+ * | `observed` | edge already held below R4 — promote it |
+ * | `structural-observed-conflict` | real node the structural side never named — mint the edge at R4 |
  *
- * `applyRuntimeObservations` accepts `held: false` — runtime saw that an edge
- * did not hold — and records a correction that demotes the edge's confidence.
- * **This producer never emits one, and must not.**
+ * Everything else (no stack, unresolvable frame, ambiguous/missing symbol) produces no observation
+ * at all — not an empty one, none.
  *
- * A frontend caller resolution can establish that a call *happened*. It cannot
- * establish that one did not: a page visit exercises one code path, and the
- * absence of a captured stack for some other function is absence of evidence,
- * not evidence of absence. Minting a denial from that would demote a correct
- * edge on the strength of a route the run happened not to take — precisely the
- * wrong-direction failure rule 2 exists to prevent, arriving through the one
- * mechanism designed to make the graph *more* trustworthy.
+ * **No denial arrow here, deliberately.** `applyRuntimeObservations` accepts `held: false` to demote
+ * an edge's confidence, but a frontend caller resolution can only establish that a call happened,
+ * never that one didn't — a page visit exercises one path, and an uncaptured stack for some other
+ * function is absence of evidence, not evidence of absence. Minting a denial from that would demote
+ * a correct edge on the strength of a route the run didn't take (rule 2). Denial belongs to a
+ * producer that can establish non-occurrence (an exhaustive call-graph trace over a fully exercised
+ * path).
  *
- * The denial arrow is real and stays available; it belongs to a producer that
- * can actually establish non-occurrence (an exhaustive call-graph trace over a
- * fully exercised path), not to this one.
- *
- * ## What this does not do
- *
- * - **It does not judge a finding.** Resolution has no opinion on confidence
- *   (RT-027). Nothing here reads or writes a finding, hypothesis or category.
- * - **It does not decide staleness.** An R4-vs-R4 disagreement is reported by
- *   the core function as `staleR4` and passed through untouched.
- * - **It does not invent a node.** That refusal is core's, and its `refused`
- *   list is passed through rather than swallowed.
+ * **Does not judge a finding** (RT-027) — no opinion on confidence, nothing here touches a
+ * finding/hypothesis/category. **Does not decide staleness** — an R4-vs-R4 disagreement passes
+ * through as core's own `staleR4`. **Does not invent a node** — core's `refused` list passes
+ * through untouched.
  */
 import { applyRuntimeObservations, } from "@descryy/core";
 import { resolveObservedFrontendCaller, } from "./observed-frontend-caller.js";
 const EMPTY = {
     promoted: [], created: [], confirmed: [], contradictions: [], staleR4: [], refused: [],
 };
-/**
- * Resolve one observed frontend call and, when it genuinely observed something,
- * record it as R4 evidence against the graph.
- */
+/** Resolve one observed frontend call and, when it genuinely observed something, record it as R4 evidence. */
 export function confirmObservedFrontendCaller(driver, input) {
     const resolution = resolveObservedFrontendCaller(driver, input.endpointNodeId, input.stackTrace, input.repo, input.repoRoot === undefined ? {} : { repoRoot: input.repoRoot });
     const observations = observationsFor(resolution, input.endpointNodeId);
     if (observations.length === 0) {
-        // Nothing observed. Deliberately not a call with an empty list: an
-        // `adapter_runs` row would be minted for a run that witnessed nothing,
-        // which reads in the ledger exactly like a run that observed and found
-        // nothing to say. Those are different statements.
+        // Nothing observed. Deliberately not an empty-list call -- an `adapter_runs` row would then read like a run that observed and found nothing to say.
         return { resolution, observations, confirmation: EMPTY };
     }
     const confirmation = applyRuntimeObservations(driver, {
@@ -110,8 +76,7 @@ function observationsFor(resolution, endpointNodeId) {
             },
         ];
     }
-    // Every other outcome is a refusal or a purely structural answer. Neither is
-    // an observation, and neither becomes one by being written down.
+    // Every other outcome is a refusal or a purely structural answer -- neither is an observation.
     return [];
 }
 //# sourceMappingURL=confirm-observed-caller.js.map

package/dist/confirm-observed-caller.js.map

@@ -1 +1 @@
-{"version":3,"file":"confirm-observed-caller.js","sourceRoot":"","sources":["../src/confirm-observed-caller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAGH,OAAO,EACL,wBAAwB,GAGzB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,6BAA6B,GAE9B,MAAM,+BAA+B,CAAC;AA4BvC,MAAM,KAAK,GAA8B;IACvC,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE;CACvF,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,6BAA6B,CAC3C,MAAiB,EACjB,KAAiC;IAEjC,MAAM,UAAU,GAAG,6BAA6B,CAC9C,MAAM,EACN,KAAK,CAAC,cAAc,EACpB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CACjE,CAAC;IAEF,MAAM,YAAY,GAAG,eAAe,CAAC,UAAU,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IACvE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,mEAAmE;QACnE,uEAAuE;QACvE,uEAAuE;QACvE,kDAAkD;QAClD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;IAC3D,CAAC;IAED,MAAM,YAAY,GAAG,wBAAwB,CAAC,MAAM,EAAE;QACpD,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,YAAY;KACb,CAAC,CAAC;IAEH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;AACpD,CAAC;AAED,SAAS,eAAe,CACtB,UAA4C,EAC5C,cAAsB;IAEtB,IAAI,UAAU,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACtC,OAAO;YACL;gBACE,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,EAAE;gBACxB,EAAE,EAAE,cAAc;gBAClB,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE,IAAI;gBACV,MAAM,EACJ,kDAAkD,UAAU,CAAC,IAAI,CAAC,IAAI,GAAG;oBACzE,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,cAAc,wCAAwC;oBAClF,qCAAqC;aACxC;SACF,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC,OAAO,KAAK,8BAA8B,EAAE,CAAC;QAC1D,OAAO;YACL;gBACE,IAAI,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE;gBAChC,EAAE,EAAE,cAAc;gBAClB,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE,IAAI;gBACV,MAAM,EACJ,kDAAkD,UAAU,CAAC,YAAY,CAAC,IAAI,GAAG;oBACjF,IAAI,UAAU,CAAC,YAAY,CAAC,IAAI,IAAI,cAAc,wCAAwC;oBAC1F,iCAAiC,UAAU,CAAC,oBAAoB,CAAC,MAAM,cAAc;oBACrF,2FAA2F;aAC9F;SACF,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,iEAAiE;IACjE,OAAO,EAAE,CAAC;AACZ,CAAC"}
+{"version":3,"file":"confirm-observed-caller.js","sourceRoot":"","sources":["../src/confirm-observed-caller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EACL,wBAAwB,GAGzB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,6BAA6B,GAE9B,MAAM,+BAA+B,CAAC;AAwBvC,MAAM,KAAK,GAA8B;IACvC,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE;CACvF,CAAC;AAEF,8GAA8G;AAC9G,MAAM,UAAU,6BAA6B,CAC3C,MAAiB,EACjB,KAAiC;IAEjC,MAAM,UAAU,GAAG,6BAA6B,CAC9C,MAAM,EACN,KAAK,CAAC,cAAc,EACpB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CACjE,CAAC;IAEF,MAAM,YAAY,GAAG,eAAe,CAAC,UAAU,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IACvE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,oJAAoJ;QACpJ,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;IAC3D,CAAC;IAED,MAAM,YAAY,GAAG,wBAAwB,CAAC,MAAM,EAAE;QACpD,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,YAAY;KACb,CAAC,CAAC;IAEH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;AACpD,CAAC;AAED,SAAS,eAAe,CACtB,UAA4C,EAC5C,cAAsB;IAEtB,IAAI,UAAU,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACtC,OAAO;YACL;gBACE,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,EAAE;gBACxB,EAAE,EAAE,cAAc;gBAClB,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE,IAAI;gBACV,MAAM,EACJ,kDAAkD,UAAU,CAAC,IAAI,CAAC,IAAI,GAAG;oBACzE,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,cAAc,wCAAwC;oBAClF,qCAAqC;aACxC;SACF,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC,OAAO,KAAK,8BAA8B,EAAE,CAAC;QAC1D,OAAO;YACL;gBACE,IAAI,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE;gBAChC,EAAE,EAAE,cAAc;gBAClB,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE,IAAI;gBACV,MAAM,EACJ,kDAAkD,UAAU,CAAC,YAAY,CAAC,IAAI,GAAG;oBACjF,IAAI,UAAU,CAAC,YAAY,CAAC,IAAI,IAAI,cAAc,wCAAwC;oBAC1F,iCAAiC,UAAU,CAAC,oBAAoB,CAAC,MAAM,cAAc;oBACrF,2FAA2F;aAC9F;SACF,CAAC;IACJ,CAAC;IAED,+FAA+F;IAC/F,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/cross-service-call.d.ts

@@ -1,90 +1,38 @@
 /**
- * **A caller in one process, a route in another, joined without a browser.**
+ * A caller in one process, a route in another, joined without a browser.
  *
- * This is the arrow `observe-runtime`'s own header records as unreachable:
- * *"a backend-only run resolves both kinds of node and writes no edge... the
- * arrow is currently reachable only from a browser-driven run."* That was a
- * true statement about one collector, not about the wire. `NETWORK_REQUEST`
- * evidence carrying a call-site stack came from exactly one place —
- * `@descryhq-wq/runtime-browser`'s `fetch()` initiator capture — and every
- * backend collector set `stackTrace: null`, `ExternalRequestCollector`
- * included, *because the preload never captured one*. It does now
- * (`fetch-instrumentation.ts`), and this file is what turns that capture
- * into an edge.
+ * Closes the gap `observe-runtime` noted as unreachable: backend-only runs resolved both node kinds but
+ * wrote no edge, since `NETWORK_REQUEST` stacks only came from `runtime-browser`'s `fetch()` capture and
+ * every backend collector set `stackTrace: null`. `fetch-instrumentation.ts` now captures one
+ * backend-side too; this file turns it into an edge.
  *
- * ## The two ends, and why neither is inferred
+ * **Two ends, neither inferred.** Caller: `EXTERNAL_REQUEST` evidence carrying the outbound stack,
+ * resolved to a `FUNCTION` via `resolveSymbolNode`. Callee: `NETWORK_REQUEST` evidence from
+ * `InboundProxy` at the other process, resolved to an `API_ENDPOINT` via `resolveEndpointNode`
+ * (workspace-scoped, DEC-054). Both come from the observation; nothing here pairs attributions that
+ * merely co-occur.
  *
- * **The caller** is `EXTERNAL_REQUEST` evidence from the calling process,
- * carrying the stack the observed application's own `fetch` call site had at
- * the moment it called. Its site of interest (`primaryFrameLocation`, the
- * identical rule every other stack-to-evidence join here already uses)
- * resolves to a `FUNCTION` node via `resolveSymbolNode`.
+ * **The join, which is the precision question.** Two observations of one exchange must be shown to be
+ * the same exchange. Two joins accepted, each named in the result, never averaged:
  *
- * **The callee** is `NETWORK_REQUEST` evidence observed *at the other
- * process* — `InboundProxy`'s own capture of a request arriving. Its
- * `method`/`path` resolve to an `API_ENDPOINT` node via
- * `resolveEndpointNode`. `API_ENDPOINT` is workspace-scoped, not repo-scoped
- * (DEC-054, and `endpoint.ts`'s own header), so there is no "which repo's
- * route" question to answer and no repo filter to invent.
- *
- * Both ends come from the observation. Nothing here pairs up attributions
- * that merely co-occur in a run — the exact manufacture `observe-runtime`'s
- * header rules out — because a pair of co-occurring observations is not a
- * witnessed relationship.
- *
- * ## The join, which is the whole precision question
- *
- * Two observations of one HTTP exchange, from two processes, have to be
- * shown to be the *same* exchange. Two joins are accepted and each one is
- * named in the result, never averaged into a single confidence number:
- *
- * | join | what it rests on |
+ * | join | rests on |
  * | --- | --- |
- * | `correlation-id` | both observations carry the same non-null `traceId` or `requestId`, within one execution — the application propagated an id and both sides read it back |
- * | `run-owned-authority` | the outbound URL's authority is a listening post **Descry itself bound** for the named callee service in this run, and that callee independently observed the same method and path |
- *
- * `correlation-id` is preferred whenever it is available. It is the rule
- * `correlateBackendEvidence` (`@descryy/runtime-backend-observation`) already
- * applies to backend evidence, applied here to the same fields; this module
- * does not call that function because it needs a *join decision*, not a
- * `Correlation` record with a fresh UUID, and importing it would put an
- * unpublished-scope package into a published one's dependency list for no
- * gain.
- *
- * `run-owned-authority` exists because requiring `correlation-id` alone
- * would make this whole mechanism conditional on the application under test
- * already propagating trace headers — which the UAT workspace did not, and
- * which is the sort of precondition that turns a capability into a
- * disclosure. It is not a weaker guess: the authority is not matched against
- * a hostname this module recognises, it is matched against a `host:port`
- * **the caller declares Descry allocated for that service in this run**
- * (`observedAuthorities`). Declared, never inferred — the same discipline
- * RT-032 already applies to service start order. A call that reached a port
- * Descry itself bound for service B, answered successfully, and shows up in
- * B's own independent inbound observation of the same method and path, is a
- * call that reached that route.
- *
- * Both joins additionally require what `correlateBackendEvidence` requires:
- * one `executionId`. Evidence from two runs is never joined on a bare
- * identifier.
- *
- * ## What is refused, and why refusal is the point
- *
- * No stack, an unresolvable frame, an ambiguous symbol, an unresolvable or
- * ambiguous endpoint, an outbound call that reached nothing, an authority
- * nobody declared, no matching inbound observation — every one of these
- * returns a named refusal with a reason and **no edge**. Rule 2, stated in
- * the plan that asked for this file: *"a wrong cross-repo edge corrupts diff
- * scoping, impact scores and root-cause traversal in every layer above it.
- * If the join is uncertain, omit the edge and disclose."*
- *
- * ## What this does not do
- *
- * - **No denial arrow.** Identical reasoning to
- *   `confirm-observed-caller.ts`: a run establishes that a call happened and
- *   can never establish that one did not.
- * - **It does not judge a finding** (RT-027), decide staleness, or invent a
- *   node — core's refusals pass through whole.
+ * | `correlation-id` | both observations carry the same non-null `traceId`/`requestId` in one execution |
+ * | `run-owned-authority` | the outbound authority is a listening post Descry itself bound for the named callee, independently confirmed by that callee's own observation of the same method+path |
+ *
+ * `correlation-id` is preferred — same rule as `correlateBackendEvidence`, reimplemented rather than
+ * imported (needs a join decision, not a fresh `Correlation` record; avoids an unpublished-scope dependency).
+ * `run-owned-authority` exists because `correlation-id` alone requires the app under test to propagate
+ * trace headers, which the UAT workspace did not — the authority is matched against a `host:port` the
+ * caller declares Descry allocated for that service (`observedAuthorities`), declared never inferred
+ * (RT-032's discipline). Both joins require one shared `executionId` — never joined across runs.
+ *
+ * **Refusal is the point.** No stack, unresolvable frame/symbol/endpoint, a call that reached nothing, an
+ * undeclared authority, no matching inbound — every one is a named refusal, no edge (rule 2: a wrong
+ * cross-repo edge corrupts diff scoping, impact and root-cause traversal above it).
+ *
+ * **No denial arrow** — same reasoning as `confirm-observed-caller.ts`: can establish a call happened,
+ * never that it didn't. Also doesn't judge a finding (RT-027), decide staleness, or invent a node.
  */
 import type { IRNode, RuntimeEdgeObservation } from "@descryy/ir";
 import { type RuntimeConfirmationResult, type SqlDriver } from "@descryy/core";
@@ -92,7 +40,7 @@ import { type Evidence } from "@descryy/runtime-contracts";
 /** How the caller-side and callee-side observations were shown to be one exchange. Always named in the result; never collapsed into a number. */
 export type CrossServiceJoin = {
     readonly kind: "correlation-id";
-    /** Which id carried it. `trace-id` is checked first, exactly as `correlateBackendEvidence` orders them. */
+    /** Which id carried it -- trace-id checked first, same order as correlateBackendEvidence. */
     readonly idKind: "trace-id" | "request-id";
     readonly id: string;
 } | {
@@ -130,12 +78,9 @@ export interface ObservedCrossServiceCallInput {
     /** `EXTERNAL_REQUEST` evidence from the **calling** process, with `stackTrace` set by `ExternalRequestCollector`'s parser. */
     readonly outbound: Evidence;
     /**
-     * Every inbound observation from this run's other observed processes —
-     * `InboundProxy`'s `NETWORK_REQUEST` items. Passed as a list rather than a
-     * single pre-picked item on purpose: choosing which inbound observation
-     * corresponds to this outbound call **is** the join, and a caller that had
-     * already chosen would be making the precision decision this module exists
-     * to make.
+     * Every inbound observation from this run's other processes (`InboundProxy`'s `NETWORK_REQUEST`
+     * items) — a list, not a pre-picked item: choosing which one matches this outbound call **is**
+     * the join this module exists to make.
      */
     readonly inbound: readonly Evidence[];
     /** The repository the calling process's source belongs to. `FUNCTION` is repo-scoped and there is no honest default (see `symbol.ts`). */
@@ -143,16 +88,10 @@ export interface ObservedCrossServiceCallInput {
     /** The calling repository's absolute root, so an absolute frame path can be translated exactly rather than suffix-matched. */
     readonly callerRepoRoot?: string;
     /**
-     * `host:port` → callee service name, for every listening post **this run
-     * bound itself** (an `InboundProxy`'s own ephemeral port, the value
-     * `InstrumentedExecutionResult`'s `proxyPorts` already reports). Declared
-     * by the orchestrating caller, never discovered by this module: a hostname
-     * this module recognised on its own would be a lookup table standing in
-     * for evidence.
-     *
-     * Omitted means the `run-owned-authority` join is simply unavailable and
-     * only `correlation-id` can join — a disclosed reduction in recall, not a
-     * silent one.
+     * `host:port` -> callee service name, for every listening post this run bound itself
+     * (`InstrumentedExecutionResult`'s `proxyPorts`). Declared by the caller, never discovered here —
+     * a recognised hostname would be a lookup table standing in for evidence. Omitted means only
+     * `correlation-id` can join — disclosed recall loss.
      */
     readonly observedAuthorities?: Readonly<Record<string, string>>;
 }
@@ -178,13 +117,12 @@ export interface ConfirmObservedCrossServiceCallOutcome {
 }
 /**
  * Resolve one observed cross-service call and, when it genuinely observed
- * something, record it as R4 evidence against the graph.
+ * something, record it as R4 evidence.
  *
- * The `USES_API` edge this writes is the one a static adapter structurally
- * cannot produce when the target URL is assembled at runtime — the caller in
- * the fixture this was proven against builds it from an environment
- * variable — so this is `applyRuntimeObservations`' "recall gap closed" case
- * far more often than its promotion case.
+ * Writes the `USES_API` edge a static adapter structurally cannot produce
+ * when the target URL is assembled at runtime (the fixture this was proven
+ * against builds it from an env var) — so this is `applyRuntimeObservations`'
+ * "recall gap closed" case far more often than its promotion case.
  */
 export declare function confirmObservedCrossServiceCall(driver: SqlDriver, input: ConfirmObservedCrossServiceCallInput): ConfirmObservedCrossServiceCallOutcome;
 //# sourceMappingURL=cross-service-call.d.ts.map

package/dist/cross-service-call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cross-service-call.d.ts","sourceRoot":"","sources":["../src/cross-service-call.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cross-service-call.d.ts","sourceRoot":"","sources":["../src/cross-service-call.ts"],"names":[],"mappings":"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"}