@descryy/core 0.6.3 → 0.7.0

package/dist/query/index.d.ts

@@ -31,5 +31,7 @@ export { rankRootCause, DEFAULT_ROOT_CAUSE_WEIGHTS, ROOT_CAUSE_TRACE_EDGE_TYPES,
 export type { RootCauseWeights, RootCauseOptions, RankedRootCauseCandidate, RootCauseRanking, ChangeCouplingEvidence, } from "./root-cause-score.ts";
 export { createResolutionFloor } from "./resolution-floor.ts";
 export type { ResolutionFloor } from "./resolution-floor.ts";
-export { tableForModel, modelsForTable } from "./model-table.ts";
+export { tableForModel, modelsForTable, tableIdForModel } from "./model-table.ts";
+export { endpointsReachingTable, MODEL_ACCESS_EDGE_TYPES, WRITE_MEANING_NOTE } from "./persistence-reach.ts";
+export type { AccessDirection, EndpointTableAccess, PersistenceHopGap, PersistencePath, PersistenceReach, PersistenceReachOptions, } from "./persistence-reach.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/query/index.d.ts.map

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

package/dist/query/index.js

@@ -15,5 +15,6 @@ export { applyDeclaredValues, DECLARED_VALUE_RELIABILITY } from "./declared-valu
 export { describeRowClosures } from "./row-closure-picture.js";
 export { rankRootCause, DEFAULT_ROOT_CAUSE_WEIGHTS, ROOT_CAUSE_TRACE_EDGE_TYPES, INCIDENT_SATURATION } from "./root-cause-score.js";
 export { createResolutionFloor } from "./resolution-floor.js";
-export { tableForModel, modelsForTable } from "./model-table.js";
+export { tableForModel, modelsForTable, tableIdForModel } from "./model-table.js";
+export { endpointsReachingTable, MODEL_ACCESS_EDGE_TYPES, WRITE_MEANING_NOTE } from "./persistence-reach.js";
 //# sourceMappingURL=index.js.map

package/dist/query/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAQjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGxG,OAAO,EACL,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,WAAW,GACZ,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AASrG,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQ7G,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAIrG,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAO9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQ/D,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AASpI,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAQjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGxG,OAAO,EACL,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,WAAW,GACZ,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AASrG,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQ7G,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAIrG,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAO9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQ/D,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AASpI,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElF,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/query/model-table.d.ts

@@ -16,6 +16,13 @@
  *  time, not stored" precedent as `contracts/orphans.ts`'s `keyOf()`. */
 import { type IdentityScope, type IRNode } from "@descryy/ir";
 import type { AdjacencyProvider } from "./provider.ts";
+/** The table id a `MODEL` node's own declared shape computes to, or
+ *  `undefined` when it names no table — refused rather than guessed at mint
+ *  time (`model-tables.ts`), so this is a real absence, not a lookup miss.
+ *  Exported so a composed query can enumerate `MODEL` once and both filter and
+ *  probe from that one enumeration; a second `nodesOfType` call to recover the
+ *  same set is a scan the store does not need to repeat. */
+export declare function tableIdForModel(model: IRNode, scope: IdentityScope): string | undefined;
 /** A `MODEL` node's `DATABASE_TABLE` counterpart, or `undefined` when the
  *  model names no table, or when the table it names was never observed in
  *  this graph (no adapter emitted it, or it belongs to a different scope).

package/dist/query/model-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-table.d.ts","sourceRoot":"","sources":["../../src/query/model-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;yEAeyE;AAEzE,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,MAAM,EACZ,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,iBAAiB,EAAW,MAAM,eAAe,CAAC;AAYhE;;;;;8EAK8E;AAC9E,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,GACnB,MAAM,GAAG,SAAS,CAGpB;AAED;;;;mCAImC;AACnC,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,MAAM,GACb;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAIrE"}
+{"version":3,"file":"model-table.d.ts","sourceRoot":"","sources":["../../src/query/model-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;yEAeyE;AAEzE,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,MAAM,EACZ,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,iBAAiB,EAAW,MAAM,eAAe,CAAC;AAEhE;;;;;4DAK4D;AAC5D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CAKvF;AAED;;;;;8EAK8E;AAC9E,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,GACnB,MAAM,GAAG,SAAS,CAGpB;AAED;;;;mCAImC;AACnC,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,MAAM,GACb;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAIrE"}

package/dist/query/model-table.js

@@ -17,8 +17,11 @@
 import { DEFAULT_MODEL_SCHEMA, nodeId, tableQsp, } from "@descryy/ir";
 /** The table id a `MODEL` node's own declared shape computes to, or
  *  `undefined` when it names no table — refused rather than guessed at mint
- *  time (`model-tables.ts`), so this is a real absence, not a lookup miss. */
-function declaredTableId(model, scope) {
+ *  time (`model-tables.ts`), so this is a real absence, not a lookup miss.
+ *  Exported so a composed query can enumerate `MODEL` once and both filter and
+ *  probe from that one enumeration; a second `nodesOfType` call to recover the
+ *  same set is a scan the store does not need to repeat. */
+export function tableIdForModel(model, scope) {
     const table = model.attrs["table"];
     if (typeof table !== "string" || table === "")
         return undefined;
@@ -32,7 +35,7 @@ function declaredTableId(model, scope) {
  *  same `IdentityScope` the graph was built with; `DATABASE_TABLE` is
  *  workspace-scoped (`NODE_SCOPE`), so a mismatched scope silently misses. */
 export function tableForModel(provider, model, scope) {
-    const tableId = declaredTableId(model, scope);
+    const tableId = tableIdForModel(model, scope);
     return tableId === undefined ? undefined : provider.node(tableId);
 }
 /** The reverse direction: every `MODEL` node in this graph whose declared
@@ -42,7 +45,7 @@ export function tableForModel(provider, model, scope) {
  *  walk in the other direction. */
 export function modelsForTable(provider, table, scope, limit) {
     const set = limit === undefined ? provider.nodesOfType("MODEL") : provider.nodesOfType("MODEL", limit);
-    const models = set.nodes.filter((model) => declaredTableId(model, scope) === table.id);
+    const models = set.nodes.filter((model) => tableIdForModel(model, scope) === table.id);
     return { models, truncated: set.truncated };
 }
 //# sourceMappingURL=model-table.js.map

package/dist/query/model-table.js.map

@@ -1 +1 @@
-{"version":3,"file":"model-table.js","sourceRoot":"","sources":["../../src/query/model-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;yEAeyE;AAEzE,OAAO,EACL,oBAAoB,EACpB,MAAM,EACN,QAAQ,GAGT,MAAM,aAAa,CAAC;AAIrB;;8EAE8E;AAC9E,SAAS,eAAe,CAAC,KAAa,EAAE,KAAoB;IAC1D,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAChE,MAAM,MAAM,GAAG,OAAO,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC;IACxG,OAAO,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;AACxE,CAAC;AAED;;;;;8EAK8E;AAC9E,MAAM,UAAU,aAAa,CAC3B,QAA2B,EAC3B,KAAa,EACb,KAAoB;IAEpB,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC9C,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACpE,CAAC;AAED;;;;mCAImC;AACnC,MAAM,UAAU,cAAc,CAC5B,QAA2B,EAC3B,KAAa,EACb,KAAoB,EACpB,KAAc;IAEd,MAAM,GAAG,GAAY,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAChH,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC,CAAC;IACvF,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;AAC9C,CAAC"}
+{"version":3,"file":"model-table.js","sourceRoot":"","sources":["../../src/query/model-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;yEAeyE;AAEzE,OAAO,EACL,oBAAoB,EACpB,MAAM,EACN,QAAQ,GAGT,MAAM,aAAa,CAAC;AAIrB;;;;;4DAK4D;AAC5D,MAAM,UAAU,eAAe,CAAC,KAAa,EAAE,KAAoB;IACjE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAChE,MAAM,MAAM,GAAG,OAAO,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC;IACxG,OAAO,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;AACxE,CAAC;AAED;;;;;8EAK8E;AAC9E,MAAM,UAAU,aAAa,CAC3B,QAA2B,EAC3B,KAAa,EACb,KAAoB;IAEpB,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC9C,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACpE,CAAC;AAED;;;;mCAImC;AACnC,MAAM,UAAU,cAAc,CAC5B,QAA2B,EAC3B,KAAa,EACb,KAAoB,EACpB,KAAc;IAEd,MAAM,GAAG,GAAY,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAChH,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC,CAAC;IACvF,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;AAC9C,CAAC"}

package/dist/query/persistence-reach.d.ts

@@ -0,0 +1,150 @@
+/** "Which endpoints reach this table, and which of them write to it" — the
+ *  persistence half of the bug-relevant subgraph, made askable.
+ *
+ *  Until this query existed the question could not be asked in any language:
+ *  `DATABASE_TABLE`/`DATABASE_COLUMN` are in no edge, of any type, in either
+ *  direction. That is not a defect — it is the consequence of a ruling. The
+ *  model-to-table join was deliberately built **by shared node identity rather
+ *  than by an edge** (`databaseTableNodesFromModel`, `@descryy/ir`, DEC-240),
+ *  so an ORM-derived producer and a raw-DDL-derived producer land on the same
+ *  id for the same real table with no coordination. Identity merging and
+ *  reachability are different problems, and solving the first left the second
+ *  untouched. This module solves the second **without touching the first**:
+ *  no new edge type, no new node type, no adapter change
+ *  (`DEC-NEXT-database-table-column-traversability-vs-queryability.md`,
+ *  `DEC-NEXT-persistence-half-of-the-bug-relevant-subgraph-is-unreachable.md`
+ *  option 1).
+ *
+ *  ## The three hops, walked backwards from the table
+ *
+ *  1. **table -> model** — `modelsForTable` (`model-table.ts`), an O(1) exact
+ *     id match per model, recomputed from the model's own declared table name.
+ *     **This leg has no edge under it.** Its evidence is two declarations: a
+ *     string in the model and the table node's identity. That is why the whole
+ *     composed claim is name-level and can never reach reliability class A,
+ *     however well-resolved the other two hops are.
+ *  2. **model -> accessor** — `READS`/`ASSIGNS` edges pointing at the model.
+ *  3. **accessor -> route -> endpoint** — one budgeted inbound `CALLS` walk
+ *     seeded on every accessor at once (never one walk per accessor), carrying
+ *     the set of accessors each node reaches, then
+ *     `API_ROUTE --SERVES_API--> API_ENDPOINT`.
+ *
+ *  ## The write gate, and why it names no language
+ *
+ *  A developer acting on "this endpoint writes to your users table" changes
+ *  code. Only some producers distinguish an assignment from a read; the rest
+ *  emit every field access as `READS`, so answering the write question from a
+ *  `READS` edge would state the opposite of what the code does for those
+ *  producers. It must therefore be gated — but gating on a language name above
+ *  the IR is a boundary breach (rule 1), and the mechanical boundary lint is
+ *  right to forbid it.
+ *
+ *  So the gate is **evidence, not configuration**: a producer is
+ *  direction-aware iff it is observed emitting at least one `ASSIGNS` edge
+ *  into a `MODEL` in this graph. An `ASSIGNS` edge is self-evidencing and
+ *  needs no gate at all. A `READS` edge from a direction-aware producer is a
+ *  genuine read. A `READS` edge from a producer never seen emitting `ASSIGNS`
+ *  is `unknown-direction` — reported as not analysable, folded into neither
+ *  the read set nor the write set. The failure mode is one-directional by
+ *  construction: the worst this rule can do is decline to answer, and it can
+ *  never manufacture a write. */
+import { type EdgeType, type IdentityScope, type IREdge, type IRNode, type ReliabilityClass } from "@descryy/ir";
+import type { AdjacencyProvider, QueryResult } from "./provider.ts";
+/** The two edge types that carry a function's access to a model's fields.
+ *  Named once so the accessor read and the direction probe cannot drift. */
+export declare const MODEL_ACCESS_EDGE_TYPES: readonly EdgeType[];
+/** What this query is willing to say about an endpoint's access to a table.
+ *
+ *  `writes` means **an assignment to a mapped column of the model backing this
+ *  table**, which is what the underlying edge actually records. It is not a
+ *  witnessed database write: whether the assignment reaches the database
+ *  depends on the object being session-attached and the session being flushed,
+ *  and nothing in the graph establishes either. Rule 4 governs the difference —
+ *  this is a behavioural prediction until a runtime run confirms it, and the
+ *  reliability cap and `WRITE_MEANING_NOTE` both say so.
+ *
+ *  `unknown-direction` is a real answer, not a missing one: the endpoint
+ *  demonstrably reaches the table, and the direction is not analysable from
+ *  the evidence the producer emitted. */
+export type AccessDirection = "writes" | "reads" | "unknown-direction";
+/** Which hop stopped, and where. A missing hop is disclosed rather than
+ *  silently yielding a shorter answer — an endpoint absent from the result
+ *  because hop 2 had nothing to walk is not an endpoint that does not touch
+ *  the table. */
+export interface PersistenceHopGap {
+    readonly hop: "model-for-table" | "accessor-for-model" | "route-for-accessor" | "endpoint-for-route";
+    /** The node the hop was walked from. */
+    readonly node: IRNode;
+    readonly reason: string;
+}
+/** One traced route from an endpoint to the table, with every edge under it. */
+export interface PersistencePath {
+    readonly endpoint: IRNode;
+    readonly route: IRNode;
+    /** The function carrying the model-access edge — the end of the call chain. */
+    readonly accessor: IRNode;
+    readonly model: IRNode;
+    readonly direction: AccessDirection;
+    /** Columns the access edge names, where it names any. */
+    readonly columns: readonly string[];
+    /** `CALLS` hops from the route to the accessor. 1 when the route calls it directly. */
+    readonly callDepth: number;
+    /** Every edge this claim rests on, in path order: route->endpoint,
+     *  route->..->accessor, accessor->model. The model->table leg is absent by
+     *  construction — it is an identity match, not an edge. */
+    readonly edges: readonly IREdge[];
+}
+export interface EndpointTableAccess {
+    readonly endpoint: IRNode;
+    /** Precedence is `writes` > `unknown-direction` > `reads`: one undetermined
+     *  path is enough to forbid the claim that this endpoint only reads. */
+    readonly direction: AccessDirection;
+    readonly columns: readonly string[];
+    readonly paths: readonly PersistencePath[];
+}
+export interface PersistenceReach {
+    readonly table: IRNode;
+    /** The `MODEL` nodes whose declared table is this one. More than one is
+     *  legitimate — two entities intentionally sharing a table. */
+    readonly models: readonly IRNode[];
+    readonly endpoints: readonly EndpointTableAccess[];
+    readonly hopGaps: readonly PersistenceHopGap[];
+    /** Producers observed emitting `ASSIGNS` into a `MODEL` in this graph:
+     *  their `READS` edges are genuine reads. */
+    readonly directionAwareProducers: readonly string[];
+    /** Producers on a path here that were never observed emitting `ASSIGNS`:
+     *  their `READS` edges carry no direction, and are reported as such. */
+    readonly directionBlindProducers: readonly string[];
+    /** Capped at B unconditionally — see the module doc's hop 1. */
+    readonly reliability: ReliabilityClass;
+}
+export interface PersistenceReachOptions {
+    /** `CALLS` hops from a route to an accessor. Default 4. */
+    readonly maxCallDepth?: number;
+    /** Budget for the inbound `CALLS` walk, counted in (node, accessor) pairs
+     *  rather than nodes — the walk re-enters a node for a new accessor, so
+     *  pairs are what actually bound it. DEC-007's 200/1,000/5,000. Default 1,000. */
+    readonly budget?: number;
+    /** Fan-out cap per hop, and the cap on accessors read per model. Default 200. */
+    readonly perNodeLimit?: number;
+    /** Cap on `MODEL` nodes enumerated, for both the table join and the
+     *  direction probe. Default 5,000 — the provider's own default. */
+    readonly modelLimit?: number;
+}
+/** Emitted whenever a write is reported. The distinction it draws is the one a
+ *  reader will otherwise collapse, and collapsing it turns a provable
+ *  statement about source into an unproven one about a running database. */
+export declare const WRITE_MEANING_NOTE: string;
+/**
+ * Every `API_ENDPOINT` that reaches `table`, and which of them write to it.
+ *
+ * `scope` must be the `IdentityScope` the graph was built with —
+ * `DATABASE_TABLE` is workspace-scoped, so a mismatched scope misses silently
+ * rather than erroring, and the miss surfaces as a `model-for-table` gap.
+ *
+ * Never throws on graph content. A node of the wrong type, a model whose
+ * declared table is not a string, a dangling edge — each degrades to a named
+ * reason in `hopGaps` or `notes`.
+ */
+export declare function endpointsReachingTable(provider: AdjacencyProvider, table: IRNode, scope: IdentityScope, options?: PersistenceReachOptions): QueryResult<PersistenceReach>;
+//# sourceMappingURL=persistence-reach.d.ts.map

package/dist/query/persistence-reach.d.ts.map

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

package/dist/query/persistence-reach.js

@@ -0,0 +1,393 @@
+/** "Which endpoints reach this table, and which of them write to it" — the
+ *  persistence half of the bug-relevant subgraph, made askable.
+ *
+ *  Until this query existed the question could not be asked in any language:
+ *  `DATABASE_TABLE`/`DATABASE_COLUMN` are in no edge, of any type, in either
+ *  direction. That is not a defect — it is the consequence of a ruling. The
+ *  model-to-table join was deliberately built **by shared node identity rather
+ *  than by an edge** (`databaseTableNodesFromModel`, `@descryy/ir`, DEC-240),
+ *  so an ORM-derived producer and a raw-DDL-derived producer land on the same
+ *  id for the same real table with no coordination. Identity merging and
+ *  reachability are different problems, and solving the first left the second
+ *  untouched. This module solves the second **without touching the first**:
+ *  no new edge type, no new node type, no adapter change
+ *  (`DEC-NEXT-database-table-column-traversability-vs-queryability.md`,
+ *  `DEC-NEXT-persistence-half-of-the-bug-relevant-subgraph-is-unreachable.md`
+ *  option 1).
+ *
+ *  ## The three hops, walked backwards from the table
+ *
+ *  1. **table -> model** — `modelsForTable` (`model-table.ts`), an O(1) exact
+ *     id match per model, recomputed from the model's own declared table name.
+ *     **This leg has no edge under it.** Its evidence is two declarations: a
+ *     string in the model and the table node's identity. That is why the whole
+ *     composed claim is name-level and can never reach reliability class A,
+ *     however well-resolved the other two hops are.
+ *  2. **model -> accessor** — `READS`/`ASSIGNS` edges pointing at the model.
+ *  3. **accessor -> route -> endpoint** — one budgeted inbound `CALLS` walk
+ *     seeded on every accessor at once (never one walk per accessor), carrying
+ *     the set of accessors each node reaches, then
+ *     `API_ROUTE --SERVES_API--> API_ENDPOINT`.
+ *
+ *  ## The write gate, and why it names no language
+ *
+ *  A developer acting on "this endpoint writes to your users table" changes
+ *  code. Only some producers distinguish an assignment from a read; the rest
+ *  emit every field access as `READS`, so answering the write question from a
+ *  `READS` edge would state the opposite of what the code does for those
+ *  producers. It must therefore be gated — but gating on a language name above
+ *  the IR is a boundary breach (rule 1), and the mechanical boundary lint is
+ *  right to forbid it.
+ *
+ *  So the gate is **evidence, not configuration**: a producer is
+ *  direction-aware iff it is observed emitting at least one `ASSIGNS` edge
+ *  into a `MODEL` in this graph. An `ASSIGNS` edge is self-evidencing and
+ *  needs no gate at all. A `READS` edge from a direction-aware producer is a
+ *  genuine read. A `READS` edge from a producer never seen emitting `ASSIGNS`
+ *  is `unknown-direction` — reported as not analysable, folded into neither
+ *  the read set nor the write set. The failure mode is one-directional by
+ *  construction: the worst this rule can do is decline to answer, and it can
+ *  never manufacture a write. */
+import { reliabilityCap, } from "@descryy/ir";
+import { createResolutionFloor } from "./resolution-floor.js";
+import { tableIdForModel } from "./model-table.js";
+/** The two edge types that carry a function's access to a model's fields.
+ *  Named once so the accessor read and the direction probe cannot drift. */
+export const MODEL_ACCESS_EDGE_TYPES = ["READS", "ASSIGNS"];
+const DEFAULT_MAX_CALL_DEPTH = 4;
+const DEFAULT_BUDGET = 1_000;
+const DEFAULT_PER_NODE_LIMIT = 200;
+const DEFAULT_MODEL_LIMIT = 5_000;
+const NAME_MATCH_NOTE = "The step from a model to its table is a name match on a declared string, not a graph edge — " +
+    "two producers agree on a table because they hash the same name, and nothing verifies that the " +
+    "name is the table the code reaches at run time. This claim is therefore name-level and is " +
+    "capped at reliability class B however well the call path under it resolves.";
+/** Emitted whenever a write is reported. The distinction it draws is the one a
+ *  reader will otherwise collapse, and collapsing it turns a provable
+ *  statement about source into an unproven one about a running database. */
+export const WRITE_MEANING_NOTE = "A write here means the handler assigns a mapped column of the model that backs this table. " +
+    "That is read from the source, and it is not the same claim as a database write being issued: " +
+    "whether the assignment reaches the table depends on the object being attached to a live " +
+    "session and that session being flushed, and neither is established here. Treat it as a " +
+    "prediction to confirm at run time, not as an observed update.";
+function empty(provider, table, floor, notes, overrides = {}) {
+    const structural = reliabilityCap(floor, true);
+    return {
+        data: {
+            table,
+            models: [],
+            endpoints: [],
+            hopGaps: [],
+            directionAwareProducers: [],
+            directionBlindProducers: [],
+            reliability: structural === "A" ? "B" : structural,
+            ...overrides,
+        },
+        stamp: stampFor(provider, floor),
+        truncated: false,
+        notes,
+    };
+}
+function stampFor(provider, resolutionFloor) {
+    return { ...provider.baseStamp(), resolutionFloor };
+}
+/** `attrs.fields` on an access edge, where the producer names the columns. */
+function columnsOf(edge) {
+    const fields = edge.attrs?.["fields"];
+    if (!Array.isArray(fields))
+        return [];
+    return fields.filter((f) => typeof f === "string");
+}
+/** Producers observed emitting at least one `ASSIGNS` into a `MODEL`. The
+ *  probe is bounded and it reports its own incompleteness: a producer missed
+ *  because the probe stopped early is reported as direction-blind, which
+ *  under-claims rather than over-claims. */
+function probeDirectionAwareProducers(provider, models, limit) {
+    const producers = new Set();
+    const examined = Math.min(models.length, limit);
+    for (let i = 0; i < examined; i += 1) {
+        for (const edge of provider.incoming(models[i].id, { types: ["ASSIGNS"], limit: 1 })) {
+            producers.add(edge.producedBy);
+        }
+    }
+    return { producers, complete: examined === models.length };
+}
+/**
+ * Every `API_ENDPOINT` that reaches `table`, and which of them write to it.
+ *
+ * `scope` must be the `IdentityScope` the graph was built with —
+ * `DATABASE_TABLE` is workspace-scoped, so a mismatched scope misses silently
+ * rather than erroring, and the miss surfaces as a `model-for-table` gap.
+ *
+ * Never throws on graph content. A node of the wrong type, a model whose
+ * declared table is not a string, a dangling edge — each degrades to a named
+ * reason in `hopGaps` or `notes`.
+ */
+export function endpointsReachingTable(provider, table, scope, options = {}) {
+    const maxCallDepth = options.maxCallDepth ?? DEFAULT_MAX_CALL_DEPTH;
+    const budget = options.budget ?? DEFAULT_BUDGET;
+    const perNodeLimit = options.perNodeLimit ?? DEFAULT_PER_NODE_LIMIT;
+    const modelLimit = options.modelLimit ?? DEFAULT_MODEL_LIMIT;
+    const floor = createResolutionFloor();
+    const notes = [];
+    if (table === null || typeof table !== "object" || table.type !== "DATABASE_TABLE") {
+        return empty(provider, table, 0, [
+            `This query answers about a DATABASE_TABLE node; it was given a ${typeof table === "object" && table !== null ? String(table.type) : "non-node value"}. Nothing was examined, and nothing here says the table is unreached.`,
+        ]);
+    }
+    // The table's own resolution is evidence under every claim below: the join
+    // rests on this node's identity, and no edge carries it.
+    floor.observe(table.resolution);
+    // --- hop 1: table -> models, plus the direction probe over the same set ---
+    const modelSet = provider.nodesOfType("MODEL", modelLimit);
+    let truncated = modelSet.truncated;
+    if (modelSet.truncated) {
+        notes.push("More models exist than were enumerated, so a model mapping to this table may have been " +
+            "missed. Endpoints absent from this answer are not reported as absent from the code.");
+    }
+    const models = modelSet.nodes.filter((model) => tableIdForModel(model, scope) === table.id);
+    for (const model of models)
+        floor.observe(model.resolution);
+    const probe = probeDirectionAwareProducers(provider, modelSet.nodes, modelLimit);
+    if (!probe.complete) {
+        truncated = true;
+        notes.push("The probe for which producers distinguish an assignment from a read did not cover every " +
+            "model. A producer it did not reach is reported as unable to answer the write question, " +
+            "never as having answered it.");
+    }
+    if (models.length === 0) {
+        notes.push(NAME_MATCH_NOTE);
+        return empty(provider, table, floor.value(), notes, {
+            hopGaps: [
+                {
+                    hop: "model-for-table",
+                    node: table,
+                    reason: "No model in this graph declares this table. Either nothing read the mapping for its " +
+                        "language, or the code names the table only where a mapping was refused rather than guessed.",
+                },
+            ],
+        });
+    }
+    // --- hop 2: models -> accessors (the functions holding READS/ASSIGNS) -----
+    const hopGaps = [];
+    /** accessor function id -> the access edges on it, and the model each reaches. */
+    const accessByFunction = new Map();
+    for (const model of models) {
+        const access = provider.incoming(model.id, {
+            types: MODEL_ACCESS_EDGE_TYPES,
+            limit: perNodeLimit,
+        });
+        if (access.length === 0) {
+            hopGaps.push({
+                hop: "accessor-for-model",
+                node: model,
+                reason: "No function in this graph reads or assigns a field of this model. Code reaching the " +
+                    "table by raw query text, or through a field access nothing resolved, is invisible here.",
+            });
+            continue;
+        }
+        if (access.length === perNodeLimit) {
+            truncated = true;
+            notes.push(`More than ${perNodeLimit} functions access one of this table's models; the rest were not examined.`);
+        }
+        for (const edge of access) {
+            const bucket = accessByFunction.get(edge.from);
+            if (bucket === undefined)
+                accessByFunction.set(edge.from, [{ edge, model }]);
+            else
+                bucket.push({ edge, model });
+        }
+    }
+    if (accessByFunction.size === 0) {
+        notes.push(NAME_MATCH_NOTE);
+        return empty(provider, table, floor.value(), notes, { models, hopGaps });
+    }
+    // --- hop 3: accessors -> routes -> endpoints ------------------------------
+    //
+    // One inbound `CALLS` walk carrying, for each node it reaches, the **set of
+    // accessors** that node can reach. A plain multi-source BFS cannot be used
+    // here and the difference is not cosmetic: it marks each node seen once, so
+    // a route calling both a reading helper and a writing one is attributed to
+    // whichever the walk happened to discover first, and the write is silently
+    // lost. "Which endpoint writes to this table" must not depend on traversal
+    // order, so a node is re-entered when a *new* accessor reaches it, and the
+    // budget counts (node, accessor) pairs rather than nodes.
+    const seeds = [...accessByFunction.keys()];
+    /** `${node}\u0000${accessor}` -> the edge that reached it, null at a seed. */
+    const via = new Map();
+    const pairKey = (node, seed) => `${node}\u0000${seed}`;
+    const queue = [];
+    for (const seed of seeds) {
+        via.set(pairKey(seed, seed), null);
+        queue.push({ id: seed, seed, depth: 0 });
+    }
+    for (let head = 0; head < queue.length; head += 1) {
+        const current = queue[head];
+        if (current.depth >= maxCallDepth)
+            continue;
+        for (const edge of provider.incoming(current.id, { types: ["CALLS"], limit: perNodeLimit })) {
+            const key = pairKey(edge.from, current.seed);
+            if (via.has(key))
+                continue;
+            if (via.size >= budget) {
+                truncated = true;
+                break;
+            }
+            via.set(key, edge);
+            queue.push({ id: edge.from, seed: current.seed, depth: current.depth + 1 });
+        }
+        if (truncated)
+            break;
+    }
+    /** The `CALLS` chain from `node` back to `seed`, route-first. `undefined`
+     *  when that accessor does not reach this node. */
+    function chainTo(node, seed) {
+        const edges = [];
+        let cursor = node;
+        // Bounded by the walk's own depth; the guard is against a malformed chain,
+        // not an expected case.
+        for (let step = 0; step <= maxCallDepth + 1; step += 1) {
+            const key = pairKey(cursor, seed);
+            if (!via.has(key))
+                return undefined;
+            const edge = via.get(key);
+            if (edge === null || edge === undefined)
+                return edges;
+            edges.push(edge);
+            cursor = edge.from === cursor ? edge.to : edge.from;
+        }
+        return undefined;
+    }
+    /** Every node the walk touched, once, regardless of how many accessors reached it. */
+    const touched = new Set();
+    for (const key of via.keys())
+        touched.add(key.slice(0, key.indexOf("\u0000")));
+    const accessorsWithARoute = new Set();
+    const byEndpoint = new Map();
+    for (const nodeId of touched) {
+        const route = provider.node(nodeId);
+        if (route === undefined || route.type !== "API_ROUTE")
+            continue;
+        // Every accessor this route reaches, not only the first one found.
+        const chains = [];
+        for (const seed of seeds) {
+            const chain = chainTo(route.id, seed);
+            if (chain === undefined)
+                continue;
+            const accessor = provider.node(seed);
+            if (accessor === undefined)
+                continue;
+            accessorsWithARoute.add(seed);
+            // `chainTo` is accessor-first; path order runs route -> .. -> accessor.
+            chains.push({ accessor, callEdges: [...chain].reverse() });
+        }
+        if (chains.length === 0)
+            continue;
+        const serves = provider.outgoing(route.id, { types: ["SERVES_API"], limit: perNodeLimit });
+        if (serves.length === 0) {
+            hopGaps.push({
+                hop: "endpoint-for-route",
+                node: route,
+                reason: "This route reaches the table but is joined to no endpoint, so it cannot be named by " +
+                    "the method and path a caller would use.",
+            });
+            continue;
+        }
+        for (const servesEdge of serves) {
+            const endpoint = provider.node(servesEdge.to);
+            if (endpoint === undefined)
+                continue;
+            for (const { accessor, callEdges } of chains) {
+                for (const { edge: accessEdge, model } of accessByFunction.get(accessor.id) ?? []) {
+                    const direction = accessEdge.type === "ASSIGNS"
+                        ? "writes"
+                        : probe.producers.has(accessEdge.producedBy)
+                            ? "reads"
+                            : "unknown-direction";
+                    // Path order: route -> endpoint, then route -> .. -> accessor, then accessor -> model.
+                    const edges = [servesEdge, ...callEdges, accessEdge];
+                    for (const e of edges)
+                        floor.observe(e.resolution);
+                    const path = {
+                        endpoint,
+                        route,
+                        accessor,
+                        model,
+                        direction,
+                        columns: columnsOf(accessEdge),
+                        callDepth: callEdges.length,
+                        edges,
+                    };
+                    const bucket = byEndpoint.get(endpoint.id);
+                    if (bucket === undefined)
+                        byEndpoint.set(endpoint.id, { endpoint, paths: [path] });
+                    else
+                        bucket.paths.push(path);
+                }
+            }
+        }
+    }
+    for (const accessorId of seeds) {
+        if (accessorsWithARoute.has(accessorId))
+            continue;
+        const accessor = provider.node(accessorId);
+        if (accessor === undefined)
+            continue;
+        hopGaps.push({
+            hop: "route-for-accessor",
+            node: accessor,
+            reason: `No route reaches this function within ${maxCallDepth} call hops. It may be reached only ` +
+                "by a longer chain, by a caller nothing resolved, or by no request path at all.",
+        });
+    }
+    // --- assemble -------------------------------------------------------------
+    const endpoints = [];
+    const directionBlind = new Set();
+    for (const { endpoint, paths } of byEndpoint.values()) {
+        const direction = paths.some((p) => p.direction === "writes")
+            ? "writes"
+            : paths.some((p) => p.direction === "unknown-direction")
+                ? "unknown-direction"
+                : "reads";
+        for (const p of paths) {
+            if (p.direction === "unknown-direction") {
+                const producer = p.edges[p.edges.length - 1]?.producedBy;
+                if (producer !== undefined)
+                    directionBlind.add(producer);
+            }
+        }
+        const columns = [...new Set(paths.flatMap((p) => p.columns))].sort();
+        endpoints.push({ endpoint, direction, columns, paths });
+    }
+    endpoints.sort((a, b) => a.endpoint.id.localeCompare(b.endpoint.id));
+    notes.push(NAME_MATCH_NOTE);
+    if (endpoints.some((e) => e.direction === "writes"))
+        notes.push(WRITE_MEANING_NOTE);
+    if (directionBlind.size > 0) {
+        notes.push(`${directionBlind.size} producer(s) under this answer emit every field access as a read, so ` +
+            "this answer does not distinguish a write from a read on the paths resting on them. Those " +
+            "endpoints are reported as reaching the table with the direction not analysable: not as " +
+            "readers, and never as writers — a write is never inferred from a read.");
+    }
+    if (truncated) {
+        notes.push("The node budget was reached, so this answer is partial. Nodes beyond the budget were not " +
+            "examined and are not reported as clean.");
+    }
+    const structural = reliabilityCap(floor.value(), true);
+    return {
+        data: {
+            table,
+            models,
+            endpoints,
+            hopGaps,
+            directionAwareProducers: [...probe.producers].sort(),
+            directionBlindProducers: [...directionBlind].sort(),
+            // Cap, never a promotion: the name-match leg forbids class A outright.
+            reliability: structural === "A" ? "B" : structural,
+        },
+        stamp: stampFor(provider, floor.value()),
+        truncated,
+        notes,
+    };
+}
+//# sourceMappingURL=persistence-reach.js.map