@descryy/core 0.8.0 → 0.9.0

package/dist/contracts/index.d.ts

@@ -10,4 +10,6 @@ export { checkContracts } from "./engine.ts";
 export type { ContractCheck, ContractOptions, ShapeCheck, ShapeDirection, ShapeMismatch, } from "./engine.ts";
 export { originMatchesRepo, repoOfEndpoint, resolveWorkspaceApiJoins } from "./workspace-join.ts";
 export type { AmbiguousApiJoin, ResolvedApiJoin, WorkspaceApiJoinOptions, WorkspaceApiJoinResult, } from "./workspace-join.ts";
+export { repoOfTable, resolveWorkspaceTableJoins } from "./workspace-table-join.ts";
+export type { AmbiguousTableJoin, ResolvedTableJoin, TableKey, WorkspaceTableJoinResult, } from "./workspace-table-join.ts";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7G,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEtE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EACV,KAAK,EACL,UAAU,EACV,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EACV,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,aAAa,GACd,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/E,YAAY,EACV,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,YAAY,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAClG,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7G,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEtE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EACV,KAAK,EACL,UAAU,EACV,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EACV,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,aAAa,GACd,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/E,YAAY,EACV,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,YAAY,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAClG,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACpF,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,QAAQ,EACR,wBAAwB,GACzB,MAAM,2BAA2B,CAAC"}

package/dist/contracts/index.js

@@ -4,4 +4,5 @@ export { findContractOrphans } from "./orphans.js";
 export { checkObservedRoutes, declaredRoutesFrom } from "./observed-routes.js";
 export { checkContracts } from "./engine.js";
 export { originMatchesRepo, repoOfEndpoint, resolveWorkspaceApiJoins } from "./workspace-join.js";
+export { repoOfTable, resolveWorkspaceTableJoins } from "./workspace-table-join.js";
 //# sourceMappingURL=index.js.map

package/dist/contracts/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAG7G,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AASvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AASnD,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAS/E,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAS7C,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAG7G,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AASvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AASnD,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAS/E,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAS7C,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAQlG,OAAO,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/contracts/workspace-table-join.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Cross-repo `DATABASE_TABLE`/`DATABASE_COLUMN` join — a sibling to
+ * `workspace-join.ts`'s frontend-to-backend `API_ENDPOINT` join, not an
+ * extension of it. Filed as a separate module rather than folded into that
+ * one: see "Why the endpoint design doesn't transfer whole" below for why
+ * the two resolution shapes genuinely differ, and every other file in this
+ * directory (`paths.ts`, `shapes.ts`, `orphans.ts`, `observed-routes.ts`,
+ * `engine.ts`) already owns one mechanism per file — this keeps that.
+ *
+ * Same repo-scoping ruling drives both:
+ * `documents/decisions-inbox/DEC-NEXT-endpoint-identity-repo-scoping.md`
+ * folded `repo` into `API_ENDPOINT`, `DATABASE_TABLE` and `DATABASE_COLUMN`
+ * ids unconditionally (`packages/ir/src/identity.ts`'s `NODE_SCOPE`). That
+ * flip is correct and stays — two backend services exposing the identical
+ * path, or two services each honestly owning their own `orders` table,
+ * must not silently collapse onto one node. But it also means two services
+ * that genuinely share one physical table now mint two unconnected nodes,
+ * with nothing downstream to re-join them. This module is that downstream
+ * join, run once per workspace build
+ * (`packages/mcp/src/workspace-index.ts`), the same composition point the
+ * `API_ENDPOINT` join already uses.
+ *
+ * ## Why the endpoint design doesn't transfer whole
+ *
+ * The endpoint join is tractable because of a real asymmetry: a frontend
+ * mints a *placeholder* `API_ENDPOINT` (an unconfirmed reference to
+ * something it calls) and a real backend mints the *served* one
+ * (`SERVES_API`-reachable from an `API_ROUTE`) — there is an obvious
+ * canonical target the moment exactly one backend serves a path.
+ *
+ * Two `DATABASE_TABLE` nodes from two repos have no such built-in
+ * asymmetry by default: both can be minted the exact same way, through the
+ * exact same shared function
+ * (`packages/ir/src/model-tables.ts`'s `databaseTableNodesFromModel`, used
+ * by every ORM/model reader). Table *name* alone is not evidence of
+ * physical identity — two unrelated services can each honestly own a
+ * `users` table in their own separate database, and joining on name alone
+ * would be exactly the wrong edge rule 2 warns about: it would tell a user
+ * two unrelated services share a table when they do not.
+ *
+ * ## What evidence the graph actually carries (checked against
+ * ## `descry-adapters`, not assumed)
+ *
+ *  - Every `DATABASE_TABLE`'s `attrs` is `{ name, schema }`, optionally
+ *    `missingFromLiveSchema`; every `DATABASE_COLUMN`'s is
+ *    `{ name, nullable, dataType? }`, optionally `liveObserved`/
+ *    `liveDivergence` (`adapter-sql/src/adapter.ts`) or nothing beyond
+ *    `{ name, nullable }` (`packages/ir/src/model-tables.ts`, the shared
+ *    ORM-model path). **Neither ever carries a connection string, database
+ *    name or host.** `adapter-sql`'s own `PgConnectionConfig`
+ *    (`adapter-sql/src/live-schema.ts`) does carry a real `database`/`host`
+ *    — but it is a *run configuration* passed into `createSqlAdapter`,
+ *    never propagated onto the node it produces. So there is no per-node
+ *    connection/database identity to join on today — a fact established by
+ *    reading every minting site, not assumed from the module doing the
+ *    minting.
+ *  - `producedBy` does distinguish two real kinds of table node, though.
+ *    `adapter-sql` (`ADAPTER_ID = "adapter-sql"`) is the one DDL/migration
+ *    reader in the corpus — its own module header calls it out: "reaches R3
+ *    with no language adapter at all, because a schema is *declared*, not
+ *    inferred." A table it mints (`producedBy` starting with
+ *    `"adapter-sql@"`) was read from an actual `CREATE TABLE`/migration —
+ *    a **declaration**. A table minted by any other adapter went through
+ *    `databaseTableNodesFromModel`, called from an ORM/model reader — a
+ *    **reference** to a table the reading repo does not itself declare (it
+ *    maps to it, nothing more). `producedBy` is IR-level provenance every
+ *    batch and node already carries (`IRBatch.producedBy`,
+ *    `IRNode.producedBy`, both typed in `packages/ir/src/ir.ts`) — reading
+ *    it is not a language check above the boundary (rule 1); it is reading
+ *    the one field the IR contract puts there for precisely this question.
+ *    Cross-checked against the conformance corpus too: golden pattern
+ *    `10-migration-adding-column` (`fixtures/golden/patterns.json`) is
+ *    explicit — "Produced by the SQL adapter, not the language adapter" —
+ *    R0, no edges, confirming this is the corpus's own stated distinction,
+ *    not one invented here.
+ *
+ * ## Design question 1 — what justifies joining two table nodes at all
+ *
+ * A declaration is real, disclosed evidence that a table with this exact
+ * (schema, name) exists somewhere in the workspace; a reference is only a
+ * claim that some repo talks to a table by that name. **Exactly one
+ * declaring node for a (schema, name) key, anywhere in the workspace, is
+ * the evidence this join accepts** — every other repo's *referencing* node
+ * for the same key is the same physical table by construction, because a
+ * reference names what it reads/writes and a workspace-wide unique
+ * declaration is the only thing it can be naming. Name alone, backed by
+ * zero or by more than one declaring node, is **not** accepted — that is
+ * exactly the "same name, different database" risk this module exists to
+ * avoid, and the honest outcome there is a disclosed ambiguity, never a
+ * guess (see the two ambiguous cases below).
+ *
+ * ## Design question 2 — is there a canonical side
+ *
+ * Yes — the declaring node (a real migration, read by `adapter-sql`) is
+ * canonical, the same role a backend's `SERVES_API`-reached node plays for
+ * endpoints. Every referencing repo's edges rewrite onto it.
+ *
+ * Unlike the endpoint join, **there is no caller-hint tier here.**
+ * `workspace-join.ts`'s `originMatchesRepo` works because a caller reports
+ * its own base URL (`USES_API.attrs.origin`) and a repo has a name to match
+ * it against. Tables have no table-side counterpart in the graph today — no
+ * connection or database identity is recorded anywhere (see above) — so
+ * building a hint matcher would mean inventing a signal, not reading one.
+ * That is a disclosed gap, not an oversight: if a future adapter starts
+ * recording a connection/database identity on these nodes, a hint tier can
+ * be added the same way `matchHint` is already overridable on the endpoint
+ * join. Until then, more than one declaring node for the same key is
+ * reported ambiguous, full stop — never picked by, say, repo-name
+ * similarity, which would be exactly the "confident wrong merge" rule 2
+ * forbids.
+ *
+ * ## Design question 3 — columns follow tables, never resolved alone
+ *
+ * Once a referencing table is joined onto a canonical one, its own
+ * `DATABASE_COLUMN` nodes are found by scanning the *same repo's* columns
+ * whose `name` is `"<table>.<column>"` (the shape both minting sites use —
+ * `adapter-sql/src/adapter.ts` and `model-tables.ts` alike). For each, the
+ * canonical table's column of the same bare name is computed directly —
+ * `nodeId({ repo: canonicalRepo }, "DATABASE_COLUMN", tableQsp(schema,
+ * table, bareName), null)` — never searched for, since a column's id is
+ * fully determined by (scope, schema, table, column). A referencing column
+ * with no same-named canonical counterpart is left exactly as its adapter
+ * minted it: rule 2's "when in doubt, omit" — never invented, never joined
+ * to a near-miss by similarity.
+ *
+ * ## What this never does
+ *
+ * No new node or edge type — the frozen 15/15 stays frozen. No node is
+ * ever deleted: an unresolved or ambiguous table/column stays exactly as
+ * its adapter minted it. A resolved rewrite touches `edge.from` **and**
+ * `edge.to`, unlike the endpoint join's `to`-only rewrite — a `DATABASE_
+ * TABLE`/`DATABASE_COLUMN` has no analogue to `SERVES_API` (a declaring
+ * edge that's already correct and must be left alone); `adapter-sql` emits
+ * *no* edges at all (`extractEdges(): return []`), so there is nothing to
+ * protect from being rewritten by accident.
+ *
+ * That said: **as of this writing, no adapter in `descry-adapters` emits
+ * any edge naming a `DATABASE_TABLE` or `DATABASE_COLUMN` at all** —
+ * checked across every adapter's source, not assumed, and confirmed by the
+ * conformance corpus itself (golden pattern `10-migration-adding-column`
+ * is `"edges": []`). So `rewrittenEdges`/`columnsJoined` read `0`/`0` on
+ * every real graph this runs against today — a disclosed, honest fact, not
+ * a bug in this module. What this resolves is *node* identity, so that
+ * whichever edge type a future producer chooses to connect a `FUNCTION` or
+ * `MODEL` to a table (`READS`/`ASSIGNS` are the two the frozen vocabulary
+ * offers for this — there is no `WRITES` edge type in
+ * `packages/ir/src/vocabulary.ts`) needs no second migration to join
+ * correctly the day it ships.
+ */
+import { type IRBatch, type IREdge, type IRNode } from "@descryy/ir";
+export interface TableKey {
+    readonly schema: string;
+    readonly table: string;
+}
+export interface ResolvedTableJoin {
+    readonly referencingTableId: string;
+    readonly canonicalTableId: string;
+    readonly key: TableKey;
+    /** The only tier this join has — see this module's header for why there is
+     *  no caller-hint tier the way `workspace-join.ts` has one. */
+    readonly via: "declaring-node";
+    /** How many edges (naming either the table or one of its joined columns,
+     *  on either `from` or `to`) were rewritten from the referencing node onto
+     *  the canonical one. Reads `0` on every graph today — see the module
+     *  header's "What this never does". */
+    readonly rewrittenEdges: number;
+    /** Referencing columns that found a same-named canonical column and were rewritten. */
+    readonly columnsJoined: number;
+    /** Referencing columns with no same-named canonical counterpart — left untouched, never guessed. */
+    readonly columnsUnjoined: number;
+}
+export interface AmbiguousTableJoin {
+    readonly key: TableKey;
+    readonly candidateTableIds: readonly string[];
+    /** The repo each candidate was minted by, `"unknown"` when `repoOf` had no entry for it. */
+    readonly candidateRepos: readonly string[];
+    /** How many of `candidateTableIds` were a declaration (`adapter-sql`), not a reference. */
+    readonly declaringCount: number;
+    readonly detail: string;
+}
+export interface WorkspaceTableJoinResult {
+    /** The input edges, with every resolved `DATABASE_TABLE`/`DATABASE_COLUMN`
+     *  reference rewritten (on both `from` and `to`) onto its canonical node.
+     *  Every other edge is returned unchanged. */
+    readonly edges: readonly IREdge[];
+    readonly resolved: readonly ResolvedTableJoin[];
+    readonly ambiguous: readonly AmbiguousTableJoin[];
+    /** `DATABASE_TABLE` nodes missing `attrs.name`/`attrs.schema` — defensive; every
+     *  real producer sets both (`model-tables.ts`, `adapter-sql/src/adapter.ts`). */
+    readonly unkeyed: number;
+    /** (schema, name) keys with exactly one table node in the whole workspace —
+     *  the ordinary case (most tables exist in one repo only). Counted for
+     *  visibility, never reported as an ambiguity. */
+    readonly singletons: number;
+}
+/** Which repo minted each `DATABASE_TABLE`/`DATABASE_COLUMN` node — read
+ *  directly off each batch's own (pre-merge) nodes, mirroring
+ *  `workspace-join.ts`'s `repoOfEndpoint`. */
+export declare function repoOfTable(batches: readonly IRBatch[]): ReadonlyMap<string, string>;
+/** Resolve every cross-repo `DATABASE_TABLE`/`DATABASE_COLUMN` reference in a
+ *  merged workspace graph against its declaring node, when exactly one
+ *  exists. Pure: no store, no IO, same posture as `resolveWorkspaceApiJoins`. */
+export declare function resolveWorkspaceTableJoins(nodes: readonly IRNode[], edges: readonly IREdge[], repoOf: ReadonlyMap<string, string>): WorkspaceTableJoinResult;
+//# sourceMappingURL=workspace-table-join.d.ts.map

package/dist/contracts/workspace-table-join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-table-join.d.ts","sourceRoot":"","sources":["../../src/contracts/workspace-table-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoJG;AAEH,OAAO,EAAoB,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAMvF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAqBD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB;mEAC+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B;;;2CAGuC;IACvC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,uFAAuF;IACvF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oGAAoG;IACpG,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,4FAA4F;IAC5F,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,2FAA2F;IAC3F,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC;;kDAE8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,QAAQ,CAAC,SAAS,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAClD;qFACiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;sDAEkD;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;8CAE8C;AAC9C,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAQpF;AA8CD;;iFAEiF;AACjF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,wBAAwB,CAmH1B"}

package/dist/contracts/workspace-table-join.js

@@ -0,0 +1,316 @@
+/**
+ * Cross-repo `DATABASE_TABLE`/`DATABASE_COLUMN` join — a sibling to
+ * `workspace-join.ts`'s frontend-to-backend `API_ENDPOINT` join, not an
+ * extension of it. Filed as a separate module rather than folded into that
+ * one: see "Why the endpoint design doesn't transfer whole" below for why
+ * the two resolution shapes genuinely differ, and every other file in this
+ * directory (`paths.ts`, `shapes.ts`, `orphans.ts`, `observed-routes.ts`,
+ * `engine.ts`) already owns one mechanism per file — this keeps that.
+ *
+ * Same repo-scoping ruling drives both:
+ * `documents/decisions-inbox/DEC-NEXT-endpoint-identity-repo-scoping.md`
+ * folded `repo` into `API_ENDPOINT`, `DATABASE_TABLE` and `DATABASE_COLUMN`
+ * ids unconditionally (`packages/ir/src/identity.ts`'s `NODE_SCOPE`). That
+ * flip is correct and stays — two backend services exposing the identical
+ * path, or two services each honestly owning their own `orders` table,
+ * must not silently collapse onto one node. But it also means two services
+ * that genuinely share one physical table now mint two unconnected nodes,
+ * with nothing downstream to re-join them. This module is that downstream
+ * join, run once per workspace build
+ * (`packages/mcp/src/workspace-index.ts`), the same composition point the
+ * `API_ENDPOINT` join already uses.
+ *
+ * ## Why the endpoint design doesn't transfer whole
+ *
+ * The endpoint join is tractable because of a real asymmetry: a frontend
+ * mints a *placeholder* `API_ENDPOINT` (an unconfirmed reference to
+ * something it calls) and a real backend mints the *served* one
+ * (`SERVES_API`-reachable from an `API_ROUTE`) — there is an obvious
+ * canonical target the moment exactly one backend serves a path.
+ *
+ * Two `DATABASE_TABLE` nodes from two repos have no such built-in
+ * asymmetry by default: both can be minted the exact same way, through the
+ * exact same shared function
+ * (`packages/ir/src/model-tables.ts`'s `databaseTableNodesFromModel`, used
+ * by every ORM/model reader). Table *name* alone is not evidence of
+ * physical identity — two unrelated services can each honestly own a
+ * `users` table in their own separate database, and joining on name alone
+ * would be exactly the wrong edge rule 2 warns about: it would tell a user
+ * two unrelated services share a table when they do not.
+ *
+ * ## What evidence the graph actually carries (checked against
+ * ## `descry-adapters`, not assumed)
+ *
+ *  - Every `DATABASE_TABLE`'s `attrs` is `{ name, schema }`, optionally
+ *    `missingFromLiveSchema`; every `DATABASE_COLUMN`'s is
+ *    `{ name, nullable, dataType? }`, optionally `liveObserved`/
+ *    `liveDivergence` (`adapter-sql/src/adapter.ts`) or nothing beyond
+ *    `{ name, nullable }` (`packages/ir/src/model-tables.ts`, the shared
+ *    ORM-model path). **Neither ever carries a connection string, database
+ *    name or host.** `adapter-sql`'s own `PgConnectionConfig`
+ *    (`adapter-sql/src/live-schema.ts`) does carry a real `database`/`host`
+ *    — but it is a *run configuration* passed into `createSqlAdapter`,
+ *    never propagated onto the node it produces. So there is no per-node
+ *    connection/database identity to join on today — a fact established by
+ *    reading every minting site, not assumed from the module doing the
+ *    minting.
+ *  - `producedBy` does distinguish two real kinds of table node, though.
+ *    `adapter-sql` (`ADAPTER_ID = "adapter-sql"`) is the one DDL/migration
+ *    reader in the corpus — its own module header calls it out: "reaches R3
+ *    with no language adapter at all, because a schema is *declared*, not
+ *    inferred." A table it mints (`producedBy` starting with
+ *    `"adapter-sql@"`) was read from an actual `CREATE TABLE`/migration —
+ *    a **declaration**. A table minted by any other adapter went through
+ *    `databaseTableNodesFromModel`, called from an ORM/model reader — a
+ *    **reference** to a table the reading repo does not itself declare (it
+ *    maps to it, nothing more). `producedBy` is IR-level provenance every
+ *    batch and node already carries (`IRBatch.producedBy`,
+ *    `IRNode.producedBy`, both typed in `packages/ir/src/ir.ts`) — reading
+ *    it is not a language check above the boundary (rule 1); it is reading
+ *    the one field the IR contract puts there for precisely this question.
+ *    Cross-checked against the conformance corpus too: golden pattern
+ *    `10-migration-adding-column` (`fixtures/golden/patterns.json`) is
+ *    explicit — "Produced by the SQL adapter, not the language adapter" —
+ *    R0, no edges, confirming this is the corpus's own stated distinction,
+ *    not one invented here.
+ *
+ * ## Design question 1 — what justifies joining two table nodes at all
+ *
+ * A declaration is real, disclosed evidence that a table with this exact
+ * (schema, name) exists somewhere in the workspace; a reference is only a
+ * claim that some repo talks to a table by that name. **Exactly one
+ * declaring node for a (schema, name) key, anywhere in the workspace, is
+ * the evidence this join accepts** — every other repo's *referencing* node
+ * for the same key is the same physical table by construction, because a
+ * reference names what it reads/writes and a workspace-wide unique
+ * declaration is the only thing it can be naming. Name alone, backed by
+ * zero or by more than one declaring node, is **not** accepted — that is
+ * exactly the "same name, different database" risk this module exists to
+ * avoid, and the honest outcome there is a disclosed ambiguity, never a
+ * guess (see the two ambiguous cases below).
+ *
+ * ## Design question 2 — is there a canonical side
+ *
+ * Yes — the declaring node (a real migration, read by `adapter-sql`) is
+ * canonical, the same role a backend's `SERVES_API`-reached node plays for
+ * endpoints. Every referencing repo's edges rewrite onto it.
+ *
+ * Unlike the endpoint join, **there is no caller-hint tier here.**
+ * `workspace-join.ts`'s `originMatchesRepo` works because a caller reports
+ * its own base URL (`USES_API.attrs.origin`) and a repo has a name to match
+ * it against. Tables have no table-side counterpart in the graph today — no
+ * connection or database identity is recorded anywhere (see above) — so
+ * building a hint matcher would mean inventing a signal, not reading one.
+ * That is a disclosed gap, not an oversight: if a future adapter starts
+ * recording a connection/database identity on these nodes, a hint tier can
+ * be added the same way `matchHint` is already overridable on the endpoint
+ * join. Until then, more than one declaring node for the same key is
+ * reported ambiguous, full stop — never picked by, say, repo-name
+ * similarity, which would be exactly the "confident wrong merge" rule 2
+ * forbids.
+ *
+ * ## Design question 3 — columns follow tables, never resolved alone
+ *
+ * Once a referencing table is joined onto a canonical one, its own
+ * `DATABASE_COLUMN` nodes are found by scanning the *same repo's* columns
+ * whose `name` is `"<table>.<column>"` (the shape both minting sites use —
+ * `adapter-sql/src/adapter.ts` and `model-tables.ts` alike). For each, the
+ * canonical table's column of the same bare name is computed directly —
+ * `nodeId({ repo: canonicalRepo }, "DATABASE_COLUMN", tableQsp(schema,
+ * table, bareName), null)` — never searched for, since a column's id is
+ * fully determined by (scope, schema, table, column). A referencing column
+ * with no same-named canonical counterpart is left exactly as its adapter
+ * minted it: rule 2's "when in doubt, omit" — never invented, never joined
+ * to a near-miss by similarity.
+ *
+ * ## What this never does
+ *
+ * No new node or edge type — the frozen 15/15 stays frozen. No node is
+ * ever deleted: an unresolved or ambiguous table/column stays exactly as
+ * its adapter minted it. A resolved rewrite touches `edge.from` **and**
+ * `edge.to`, unlike the endpoint join's `to`-only rewrite — a `DATABASE_
+ * TABLE`/`DATABASE_COLUMN` has no analogue to `SERVES_API` (a declaring
+ * edge that's already correct and must be left alone); `adapter-sql` emits
+ * *no* edges at all (`extractEdges(): return []`), so there is nothing to
+ * protect from being rewritten by accident.
+ *
+ * That said: **as of this writing, no adapter in `descry-adapters` emits
+ * any edge naming a `DATABASE_TABLE` or `DATABASE_COLUMN` at all** —
+ * checked across every adapter's source, not assumed, and confirmed by the
+ * conformance corpus itself (golden pattern `10-migration-adding-column`
+ * is `"edges": []`). So `rewrittenEdges`/`columnsJoined` read `0`/`0` on
+ * every real graph this runs against today — a disclosed, honest fact, not
+ * a bug in this module. What this resolves is *node* identity, so that
+ * whichever edge type a future producer chooses to connect a `FUNCTION` or
+ * `MODEL` to a table (`READS`/`ASSIGNS` are the two the frozen vocabulary
+ * offers for this — there is no `WRITES` edge type in
+ * `packages/ir/src/vocabulary.ts`) needs no second migration to join
+ * correctly the day it ships.
+ */
+import { nodeId, tableQsp } from "@descryy/ir";
+/** Matches `adapter-sql`'s own `ADAPTER_ID` (`packages/adapter-sql/src/adapter.ts` in
+ *  `descry-adapters`) — the one DDL/migration reader in the corpus today. */
+const SQL_ADAPTER_ID = "adapter-sql";
+function keyOf(table) {
+    const name = table.attrs["name"];
+    const schema = table.attrs["schema"];
+    return typeof name === "string" && typeof schema === "string" ? { schema, table: name } : null;
+}
+function keyString(key) {
+    return `${key.schema}.${key.table}`;
+}
+/** `producedBy` is `${adapterId}@${version}` (IR contract) — this reads the
+ *  id before the `@`, not a substring match, so a hypothetical
+ *  `adapter-nosql` is never mistaken for `adapter-sql`. */
+function isDeclared(node) {
+    const at = node.producedBy.indexOf("@");
+    const adapterId = at === -1 ? node.producedBy : node.producedBy.slice(0, at);
+    return adapterId === SQL_ADAPTER_ID;
+}
+/** Which repo minted each `DATABASE_TABLE`/`DATABASE_COLUMN` node — read
+ *  directly off each batch's own (pre-merge) nodes, mirroring
+ *  `workspace-join.ts`'s `repoOfEndpoint`. */
+export function repoOfTable(batches) {
+    const map = new Map();
+    for (const batch of batches) {
+        for (const node of batch.nodes) {
+            if (node.type === "DATABASE_TABLE" || node.type === "DATABASE_COLUMN")
+                map.set(node.id, batch.repo);
+        }
+    }
+    return map;
+}
+/** A referencing table's own columns (found by repo + `"<table>."` name
+ *  prefix, the shape both minting sites use), each joined onto the
+ *  canonical table's same-named column when one exists — never independently,
+ *  never invented (module header, design question 3). */
+function joinColumns(canonicalRepo, key, 
+// Pre-filtered by the caller to the referencing table's own repo — a
+// column from a different repo must never be matched here, even if it
+// happens to share a name prefix.
+referencingRepoColumns, nodeIds, rewrite) {
+    const prefix = `${key.table}.`;
+    const columnIds = [];
+    let joined = 0;
+    let unjoined = 0;
+    for (const column of referencingRepoColumns) {
+        if (!column.name.startsWith(prefix))
+            continue;
+        columnIds.push(column.id);
+        const bareName = column.attrs["name"];
+        if (typeof bareName !== "string") {
+            unjoined += 1;
+            continue;
+        }
+        const canonicalColumnId = nodeId({ repo: canonicalRepo }, "DATABASE_COLUMN", tableQsp(key.schema, key.table, bareName), null);
+        if (!nodeIds.has(canonicalColumnId) || canonicalColumnId === column.id) {
+            unjoined += 1;
+            continue;
+        }
+        rewrite.set(column.id, canonicalColumnId);
+        joined += 1;
+    }
+    return { joined, unjoined, columnIds };
+}
+/** Resolve every cross-repo `DATABASE_TABLE`/`DATABASE_COLUMN` reference in a
+ *  merged workspace graph against its declaring node, when exactly one
+ *  exists. Pure: no store, no IO, same posture as `resolveWorkspaceApiJoins`. */
+export function resolveWorkspaceTableJoins(nodes, edges, repoOf) {
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    const tables = nodes.filter((n) => n.type === "DATABASE_TABLE");
+    const columns = nodes.filter((n) => n.type === "DATABASE_COLUMN");
+    const byKey = new Map();
+    let unkeyed = 0;
+    for (const table of tables) {
+        const key = keyOf(table);
+        if (key === null) {
+            unkeyed += 1;
+            continue;
+        }
+        const list = byKey.get(keyString(key));
+        if (list === undefined)
+            byKey.set(keyString(key), [table]);
+        else
+            list.push(table);
+    }
+    const drafts = [];
+    const ambiguous = [];
+    let singletons = 0;
+    const rewrite = new Map();
+    for (const group of byKey.values()) {
+        if (group.length < 2) {
+            singletons += 1;
+            continue;
+        }
+        const key = keyOf(group[0]);
+        const declaring = group.filter(isDeclared);
+        const referencing = group.filter((n) => !isDeclared(n));
+        if (declaring.length === 1) {
+            const canonical = declaring[0];
+            const canonicalRepo = repoOf.get(canonical.id);
+            if (canonicalRepo === undefined) {
+                // No standing to resolve against — disclosed as ambiguous rather
+                // than silently skipped, since real referencing nodes exist for this key.
+                ambiguous.push({
+                    key,
+                    candidateTableIds: group.map((n) => n.id),
+                    candidateRepos: group.map((n) => repoOf.get(n.id) ?? "unknown"),
+                    declaringCount: declaring.length,
+                    detail: `${keyString(key)} has a declaring node but its repo could not be determined — reported as ` +
+                        "ambiguous rather than joining against an unattributed node.",
+                });
+                continue;
+            }
+            for (const ref of referencing) {
+                const refRepo = repoOf.get(ref.id);
+                if (refRepo === undefined)
+                    continue; // nothing to attribute this rewrite to
+                rewrite.set(ref.id, canonical.id);
+                const refColumns = columns.filter((c) => repoOf.get(c.id) === refRepo);
+                const { joined, unjoined, columnIds } = joinColumns(canonicalRepo, key, refColumns, nodeIds, rewrite);
+                drafts.push({
+                    referencingTableId: ref.id,
+                    canonicalTableId: canonical.id,
+                    key,
+                    columnIds,
+                    columnsJoined: joined,
+                    columnsUnjoined: unjoined,
+                });
+            }
+            continue;
+        }
+        ambiguous.push({
+            key,
+            candidateTableIds: group.map((n) => n.id),
+            candidateRepos: group.map((n) => repoOf.get(n.id) ?? "unknown"),
+            declaringCount: declaring.length,
+            detail: declaring.length === 0
+                ? `${group.length} repositories in this workspace each reference a table named ${keyString(key)}, ` +
+                    "and none of them declares it (no migration this workspace's SQL adapter parsed) — reported as " +
+                    "ambiguous rather than assuming they are the same physical table."
+                : `${declaring.length} repositories in this workspace each declare a table named ${keyString(key)} ` +
+                    "independently — reported as ambiguous rather than assuming they are the same physical table.",
+        });
+    }
+    const rewrittenEdges = edges.map((edge) => {
+        const to = rewrite.get(edge.to);
+        const from = rewrite.get(edge.from);
+        if (to === undefined && from === undefined)
+            return edge;
+        return { ...edge, ...(to === undefined ? {} : { to }), ...(from === undefined ? {} : { from }) };
+    });
+    const resolved = drafts.map((draft) => ({
+        referencingTableId: draft.referencingTableId,
+        canonicalTableId: draft.canonicalTableId,
+        key: draft.key,
+        via: "declaring-node",
+        rewrittenEdges: edges.filter((e) => e.to === draft.referencingTableId ||
+            e.from === draft.referencingTableId ||
+            draft.columnIds.includes(e.to) ||
+            draft.columnIds.includes(e.from)).length,
+        columnsJoined: draft.columnsJoined,
+        columnsUnjoined: draft.columnsUnjoined,
+    }));
+    return { edges: rewrittenEdges, resolved, ambiguous, unkeyed, singletons };
+}
+//# sourceMappingURL=workspace-table-join.js.map

package/dist/contracts/workspace-table-join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-table-join.js","sourceRoot":"","sources":["../../src/contracts/workspace-table-join.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@descryy/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "description": "Descry graph engine: storage, graph builder, query layer, traversal, diff scoping, git source, MCP server.",
   "license": "MIT",