@fuzdev/fuz_app 0.70.0 → 0.71.0

package/dist/db/CLAUDE.md

@@ -80,10 +80,10 @@ Content-addressed byte store. Cells reference facts by blake3 hash
 (`cell.refs`, auto-extracted from `data`); the fact layer stores the bytes.
 Optional — minimal consumers never migrate it.
 
-- **`fact_ddl.ts`** — `facts` (content-addressed bytes: embedded `bytes` xor
-  `external_url`, CHECK enforces exactly one) + `fact_refs` (declared
+- **`fact_ddl.ts`** — `fact` (content-addressed bytes: embedded `bytes` xor
+  `external_url`, CHECK enforces exactly one) + `fact_ref` (declared
   dependency edges; `target_hash` deliberately not an FK, for federation) +
-  `memos` (`(fn_id, input_hash) → output_hash`). `FACT_MIGRATION_NS`, namespace
+  `memo` (`(fn_id, input_hash) → output_hash`). `FACT_MIGRATION_NS`, namespace
   `fuz_facts`.
 - **`fact_queries.ts`** — mechanical `query_put_fact` (idempotent `ON CONFLICT
 DO NOTHING`), `_put_fact_refs`, `_get_fact` / `_get_fact_meta` / `_has_fact`

package/dist/db/cell_history_ddl.d.ts

@@ -8,7 +8,7 @@
  * downstream code can target a stable schema. The table ships
  * present-but-unwritten.
  *
- * `fact_hash` is intentionally **not** a foreign key to `facts(hash)` —
+ * `fact_hash` is intentionally **not** a foreign key to `fact(hash)` —
  * snapshots may be evicted by GC policy while history rows remain as audit
  * traces, and federation may target facts on another instance.
  *

package/dist/db/cell_history_ddl.js

@@ -8,7 +8,7 @@
  * downstream code can target a stable schema. The table ships
  * present-but-unwritten.
  *
- * `fact_hash` is intentionally **not** a foreign key to `facts(hash)` —
+ * `fact_hash` is intentionally **not** a foreign key to `fact(hash)` —
  * snapshots may be evicted by GC policy while history rows remain as audit
  * traces, and federation may target facts on another instance.
  *

package/dist/db/fact_ddl.d.ts

@@ -3,32 +3,32 @@
  *
  * Three tables:
  *
- * - `facts` — content-addressed bytes. `hash = 'blake3:<hex64>'`. Either
+ * - `fact` — content-addressed bytes. `hash = 'blake3:<hex64>'`. Either
  *   embedded (`bytes`) or referenced (`external_url`); the CHECK constraint
  *   enforces exactly one populated. Idempotent: same bytes always produce
  *   the same hash, so `INSERT … ON CONFLICT DO NOTHING` is the put primitive.
- * - `fact_refs` — declared dependency edges (source fact → target fact).
+ * - `fact_ref` — declared dependency edges (source fact → target fact).
  *   `target_hash` is intentionally **not** a foreign key: in federation a
  *   reference may target a fact stored on another instance.
- * - `memos` — `(fn_id, input_hash) → output_hash` for memoized computations.
+ * - `memo` — `(fn_id, input_hash) → output_hash` for memoized computations.
  *
  * @module
  */
 import type { Migration, MigrationNamespace } from './migrate.js';
-/** `facts` table — content-addressed byte store. */
-export declare const FACTS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS facts (\n\thash TEXT PRIMARY KEY,\n\tbytes BYTEA,\n\texternal_url TEXT,\n\tcontent_type TEXT,\n\tsize BIGINT NOT NULL,\n\tcreated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n\tCONSTRAINT facts_storage_present CHECK (bytes IS NOT NULL OR external_url IS NOT NULL)\n)";
+/** `fact` table — content-addressed byte store. */
+export declare const FACTS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS fact (\n\thash TEXT PRIMARY KEY,\n\tbytes BYTEA,\n\texternal_url TEXT,\n\tcontent_type TEXT,\n\tsize BIGINT NOT NULL,\n\tcreated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n\tCONSTRAINT fact_storage_present CHECK (bytes IS NOT NULL OR external_url IS NOT NULL)\n)";
 /**
- * `fact_refs` table — declared dependency edges between facts.
+ * `fact_ref` table — declared dependency edges between facts.
  *
  * `target_hash` is not a foreign key (federation: target may live remotely).
  */
-export declare const FACT_REFS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS fact_refs (\n\tsource_hash TEXT NOT NULL REFERENCES facts(hash) ON DELETE CASCADE,\n\ttarget_hash TEXT NOT NULL,\n\tPRIMARY KEY (source_hash, target_hash)\n)";
+export declare const FACT_REFS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS fact_ref (\n\tsource_hash TEXT NOT NULL REFERENCES fact(hash) ON DELETE CASCADE,\n\ttarget_hash TEXT NOT NULL,\n\tPRIMARY KEY (source_hash, target_hash)\n)";
 /** Reverse lookup: which facts reference a given target? */
-export declare const FACT_REFS_TARGET_INDEX = "\nCREATE INDEX IF NOT EXISTS idx_fact_refs_target ON fact_refs(target_hash)";
-/** `memos` table — `(fn_id, input_hash) → output_hash` for memoized computations. */
-export declare const MEMOS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS memos (\n\tfn_id TEXT NOT NULL,\n\tinput_hash TEXT NOT NULL,\n\toutput_hash TEXT NOT NULL,\n\tcreated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n\tPRIMARY KEY (fn_id, input_hash)\n)";
+export declare const FACT_REFS_TARGET_INDEX = "\nCREATE INDEX IF NOT EXISTS idx_fact_ref_target ON fact_ref(target_hash)";
+/** `memo` table — `(fn_id, input_hash) → output_hash` for memoized computations. */
+export declare const MEMOS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS memo (\n\tfn_id TEXT NOT NULL,\n\tinput_hash TEXT NOT NULL,\n\toutput_hash TEXT NOT NULL,\n\tcreated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n\tPRIMARY KEY (fn_id, input_hash)\n)";
 /** Tables created by `FACT_MIGRATION_NS`, in drop order (children first). */
-export declare const FACT_DROP_TABLES: readonly ["memos", "fact_refs", "facts"];
+export declare const FACT_DROP_TABLES: readonly ["memo", "fact_ref", "fact"];
 /** Fact + memo migrations. */
 export declare const FACT_MIGRATIONS: Array<Migration>;
 /** Namespace identifier for fact + memo migrations. */

package/dist/db/fact_ddl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fact_ddl.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/fact_ddl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAC,SAAS,EAAE,kBAAkB,EAAC,MAAM,cAAc,CAAC;AAEhE,oDAAoD;AACpD,eAAO,MAAM,YAAY,uSASvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,+LAK3B,CAAC;AAEH,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,gFACuC,CAAC;AAE3E,qFAAqF;AACrF,eAAO,MAAM,YAAY,oNAOvB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,0CAA2C,CAAC;AAEzE,8BAA8B;AAC9B,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,SAAS,CAU5C,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,wBAAwB,cAAc,CAAC;AAEpD,wDAAwD;AACxD,eAAO,MAAM,iBAAiB,EAAE,kBAG/B,CAAC"}
+{"version":3,"file":"fact_ddl.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/fact_ddl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAC,SAAS,EAAE,kBAAkB,EAAC,MAAM,cAAc,CAAC;AAEhE,mDAAmD;AACnD,eAAO,MAAM,YAAY,qSASvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,6LAK3B,CAAC;AAEH,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,8EACqC,CAAC;AAEzE,oFAAoF;AACpF,eAAO,MAAM,YAAY,mNAOvB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,uCAAwC,CAAC;AAEtE,8BAA8B;AAC9B,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,SAAS,CAU5C,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,wBAAwB,cAAc,CAAC;AAEpD,wDAAwD;AACxD,eAAO,MAAM,iBAAiB,EAAE,kBAG/B,CAAC"}

package/dist/db/fact_ddl.js

@@ -3,45 +3,45 @@
  *
  * Three tables:
  *
- * - `facts` — content-addressed bytes. `hash = 'blake3:<hex64>'`. Either
+ * - `fact` — content-addressed bytes. `hash = 'blake3:<hex64>'`. Either
  *   embedded (`bytes`) or referenced (`external_url`); the CHECK constraint
  *   enforces exactly one populated. Idempotent: same bytes always produce
  *   the same hash, so `INSERT … ON CONFLICT DO NOTHING` is the put primitive.
- * - `fact_refs` — declared dependency edges (source fact → target fact).
+ * - `fact_ref` — declared dependency edges (source fact → target fact).
  *   `target_hash` is intentionally **not** a foreign key: in federation a
  *   reference may target a fact stored on another instance.
- * - `memos` — `(fn_id, input_hash) → output_hash` for memoized computations.
+ * - `memo` — `(fn_id, input_hash) → output_hash` for memoized computations.
  *
  * @module
  */
-/** `facts` table — content-addressed byte store. */
+/** `fact` table — content-addressed byte store. */
 export const FACTS_SCHEMA = `
-CREATE TABLE IF NOT EXISTS facts (
+CREATE TABLE IF NOT EXISTS fact (
 	hash TEXT PRIMARY KEY,
 	bytes BYTEA,
 	external_url TEXT,
 	content_type TEXT,
 	size BIGINT NOT NULL,
 	created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-	CONSTRAINT facts_storage_present CHECK (bytes IS NOT NULL OR external_url IS NOT NULL)
+	CONSTRAINT fact_storage_present CHECK (bytes IS NOT NULL OR external_url IS NOT NULL)
 )`;
 /**
- * `fact_refs` table — declared dependency edges between facts.
+ * `fact_ref` table — declared dependency edges between facts.
  *
  * `target_hash` is not a foreign key (federation: target may live remotely).
  */
 export const FACT_REFS_SCHEMA = `
-CREATE TABLE IF NOT EXISTS fact_refs (
-	source_hash TEXT NOT NULL REFERENCES facts(hash) ON DELETE CASCADE,
+CREATE TABLE IF NOT EXISTS fact_ref (
+	source_hash TEXT NOT NULL REFERENCES fact(hash) ON DELETE CASCADE,
 	target_hash TEXT NOT NULL,
 	PRIMARY KEY (source_hash, target_hash)
 )`;
 /** Reverse lookup: which facts reference a given target? */
 export const FACT_REFS_TARGET_INDEX = `
-CREATE INDEX IF NOT EXISTS idx_fact_refs_target ON fact_refs(target_hash)`;
-/** `memos` table — `(fn_id, input_hash) → output_hash` for memoized computations. */
+CREATE INDEX IF NOT EXISTS idx_fact_ref_target ON fact_ref(target_hash)`;
+/** `memo` table — `(fn_id, input_hash) → output_hash` for memoized computations. */
 export const MEMOS_SCHEMA = `
-CREATE TABLE IF NOT EXISTS memos (
+CREATE TABLE IF NOT EXISTS memo (
 	fn_id TEXT NOT NULL,
 	input_hash TEXT NOT NULL,
 	output_hash TEXT NOT NULL,
@@ -49,7 +49,7 @@ CREATE TABLE IF NOT EXISTS memos (
 	PRIMARY KEY (fn_id, input_hash)
 )`;
 /** Tables created by `FACT_MIGRATION_NS`, in drop order (children first). */
-export const FACT_DROP_TABLES = ['memos', 'fact_refs', 'facts'];
+export const FACT_DROP_TABLES = ['memo', 'fact_ref', 'fact'];
 /** Fact + memo migrations. */
 export const FACT_MIGRATIONS = [
     {

package/dist/db/fact_queries.d.ts

@@ -1,5 +1,5 @@
 /**
- * Raw queries against the `facts` and `fact_refs` tables.
+ * Raw queries against the `fact` and `fact_ref` tables.
  *
  * Convention: `deps: QueryDeps` first, no audit side effects, mutations are
  * idempotent (`ON CONFLICT DO NOTHING`) so the same hash can be written by
@@ -13,7 +13,7 @@
  */
 import type { QueryDeps } from './query_deps.js';
 import type { FactHash } from '@fuzdev/fuz_util/fact_hash.js';
-/** Row shape for `SELECT … FROM facts`. */
+/** Row shape for `SELECT … FROM fact`. */
 export interface FactRow {
     hash: FactHash;
     bytes: Uint8Array | null;
@@ -33,11 +33,11 @@ export interface FactMetaRow {
 /**
  * Idempotently insert a fact row.
  *
- * `bytes` xor `external_url` per the `facts_storage_present` CHECK
+ * `bytes` xor `external_url` per the `fact_storage_present` CHECK
  * constraint; the caller is responsible for satisfying it (the queries
  * layer does not second-guess). Returns `true` when a new row was
  * inserted, `false` when a row already existed (caller can use this to
- * decide whether to also write `fact_refs`).
+ * decide whether to also write `fact_ref`).
  */
 export declare const query_put_fact: (deps: QueryDeps, input: {
     hash: FactHash;
@@ -62,7 +62,7 @@ export declare const query_get_fact: (deps: QueryDeps, hash: FactHash) => Promis
  */
 export declare const query_get_fact_meta: (deps: QueryDeps, hash: FactHash) => Promise<FactMetaRow | null>;
 /**
- * Cheap existence check. Backed by the `facts` PK index.
+ * Cheap existence check. Backed by the `fact` PK index.
  */
 export declare const query_has_fact: (deps: QueryDeps, hash: FactHash) => Promise<boolean>;
 /**
@@ -71,7 +71,7 @@ export declare const query_has_fact: (deps: QueryDeps, hash: FactHash) => Promis
  */
 export declare const query_get_fact_refs: (deps: QueryDeps, source_hash: FactHash) => Promise<Array<FactHash>>;
 /**
- * Drop a fact row. Cascades `fact_refs` rows via the `ON DELETE CASCADE`
+ * Drop a fact row. Cascades `fact_ref` rows via the `ON DELETE CASCADE`
  * FK on `source_hash`. Returns the deleted row's `(size, external_url)`
  * so the caller can unlink the disk file (if any) and tally freed bytes,
  * or `null` when no row matched (idempotent: deleting an absent fact is
@@ -104,17 +104,17 @@ export interface OrphanFactsListResult {
     }>;
 }
 /**
- * Compute the "orphan facts" set: rows in `facts` where no active
+ * Compute the "orphan facts" set: rows in `fact` where no active
  * (non-tombstone) `cell.refs` array contains the hash.
  *
- * The `cell` join is deliberately app-coupled — `facts` lives in the
+ * The `cell` join is deliberately app-coupled — `fact` lives in the
  * `fuz_facts` namespace and `cell.refs` lives in `fuz_cell`, but the
  * orphan predicate only makes sense in apps that route content through
  * cells. When a non-cell fact consumer ever appears (signed memo
  * outputs? external fact mirrors?) the predicate moves to a generic
  * `fact_consumers` registry; today the cell layer is the only consumer.
  *
- * The `older_than` filter applies to `facts.created_at`. Pass `null`
+ * The `older_than` filter applies to `fact.created_at`. Pass `null`
  * to skip the filter (used by the list-summary preview); the delete
  * handler always passes a non-null cutoff (default 0, meaning "any
  * orphan").

package/dist/db/fact_queries.d.ts.map

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

package/dist/db/fact_queries.js

@@ -1,5 +1,5 @@
 /**
- * Raw queries against the `facts` and `fact_refs` tables.
+ * Raw queries against the `fact` and `fact_ref` tables.
  *
  * Convention: `deps: QueryDeps` first, no audit side effects, mutations are
  * idempotent (`ON CONFLICT DO NOTHING`) so the same hash can be written by
@@ -14,14 +14,14 @@
 /**
  * Idempotently insert a fact row.
  *
- * `bytes` xor `external_url` per the `facts_storage_present` CHECK
+ * `bytes` xor `external_url` per the `fact_storage_present` CHECK
  * constraint; the caller is responsible for satisfying it (the queries
  * layer does not second-guess). Returns `true` when a new row was
  * inserted, `false` when a row already existed (caller can use this to
- * decide whether to also write `fact_refs`).
+ * decide whether to also write `fact_ref`).
  */
 export const query_put_fact = async (deps, input) => {
-    const row = await deps.db.query_one(`INSERT INTO facts (hash, bytes, external_url, content_type, size)
+    const row = await deps.db.query_one(`INSERT INTO fact (hash, bytes, external_url, content_type, size)
 		 VALUES ($1, $2, $3, $4, $5)
 		 ON CONFLICT (hash) DO NOTHING
 		 RETURNING hash`, [input.hash, input.bytes, input.external_url, input.content_type, input.size]);
@@ -35,7 +35,7 @@ export const query_put_fact = async (deps, input) => {
 export const query_put_fact_refs = async (deps, source_hash, target_hashes) => {
     if (target_hashes.length === 0)
         return;
-    await deps.db.query(`INSERT INTO fact_refs (source_hash, target_hash)
+    await deps.db.query(`INSERT INTO fact_ref (source_hash, target_hash)
 		 SELECT $1::text, unnest($2::text[])
 		 ON CONFLICT (source_hash, target_hash) DO NOTHING`, [source_hash, target_hashes]);
 };
@@ -45,7 +45,7 @@ export const query_put_fact_refs = async (deps, source_hash, target_hashes) => {
  */
 export const query_get_fact = async (deps, hash) => {
     const row = await deps.db.query_one(`SELECT hash, bytes, external_url, content_type, size, created_at
-		 FROM facts WHERE hash = $1`, [hash]);
+		 FROM fact WHERE hash = $1`, [hash]);
     return row ?? null;
 };
 /**
@@ -53,14 +53,14 @@ export const query_get_fact = async (deps, hash) => {
  */
 export const query_get_fact_meta = async (deps, hash) => {
     const row = await deps.db.query_one(`SELECT hash, external_url, content_type, size, created_at
-		 FROM facts WHERE hash = $1`, [hash]);
+		 FROM fact WHERE hash = $1`, [hash]);
     return row ?? null;
 };
 /**
- * Cheap existence check. Backed by the `facts` PK index.
+ * Cheap existence check. Backed by the `fact` PK index.
  */
 export const query_has_fact = async (deps, hash) => {
-    const row = await deps.db.query_one(`SELECT EXISTS(SELECT 1 FROM facts WHERE hash = $1) AS exists`, [hash]);
+    const row = await deps.db.query_one(`SELECT EXISTS(SELECT 1 FROM fact WHERE hash = $1) AS exists`, [hash]);
     return row?.exists ?? false;
 };
 /**
@@ -68,11 +68,11 @@ export const query_has_fact = async (deps, hash) => {
  * that need stable ordering should sort.
  */
 export const query_get_fact_refs = async (deps, source_hash) => {
-    const rows = await deps.db.query(`SELECT target_hash FROM fact_refs WHERE source_hash = $1`, [source_hash]);
+    const rows = await deps.db.query(`SELECT target_hash FROM fact_ref WHERE source_hash = $1`, [source_hash]);
     return rows.map((r) => r.target_hash);
 };
 /**
- * Drop a fact row. Cascades `fact_refs` rows via the `ON DELETE CASCADE`
+ * Drop a fact row. Cascades `fact_ref` rows via the `ON DELETE CASCADE`
  * FK on `source_hash`. Returns the deleted row's `(size, external_url)`
  * so the caller can unlink the disk file (if any) and tally freed bytes,
  * or `null` when no row matched (idempotent: deleting an absent fact is
@@ -84,24 +84,24 @@ export const query_get_fact_refs = async (deps, source_hash) => {
  * `PgFactStore.delete` handles the disk-file unlink.
  */
 export const query_delete_fact = async (deps, hash) => {
-    const row = await deps.db.query_one(`DELETE FROM facts WHERE hash = $1
+    const row = await deps.db.query_one(`DELETE FROM fact WHERE hash = $1
 		 RETURNING size, external_url`, [hash]);
     if (!row)
         return null;
     return { size: Number(row.size), external_url: row.external_url };
 };
 /**
- * Compute the "orphan facts" set: rows in `facts` where no active
+ * Compute the "orphan facts" set: rows in `fact` where no active
  * (non-tombstone) `cell.refs` array contains the hash.
  *
- * The `cell` join is deliberately app-coupled — `facts` lives in the
+ * The `cell` join is deliberately app-coupled — `fact` lives in the
  * `fuz_facts` namespace and `cell.refs` lives in `fuz_cell`, but the
  * orphan predicate only makes sense in apps that route content through
  * cells. When a non-cell fact consumer ever appears (signed memo
  * outputs? external fact mirrors?) the predicate moves to a generic
  * `fact_consumers` registry; today the cell layer is the only consumer.
  *
- * The `older_than` filter applies to `facts.created_at`. Pass `null`
+ * The `older_than` filter applies to `fact.created_at`. Pass `null`
  * to skip the filter (used by the list-summary preview); the delete
  * handler always passes a non-null cutoff (default 0, meaning "any
  * orphan").
@@ -113,7 +113,7 @@ export const query_delete_fact = async (deps, hash) => {
  */
 export const query_orphan_facts_list = async (deps, older_than, sample_limit) => {
     const summary = await deps.db.query_one(`SELECT COUNT(*)::bigint AS count, COALESCE(SUM(size), 0)::bigint AS total
-		 FROM facts f
+		 FROM fact f
 		 WHERE NOT EXISTS (
 		   SELECT 1 FROM cell c
 		   WHERE c.refs @> ARRAY[f.hash]::text[]
@@ -121,7 +121,7 @@ export const query_orphan_facts_list = async (deps, older_than, sample_limit) =>
 		 )
 		 AND ($1::timestamptz IS NULL OR f.created_at < $1::timestamptz)`, [older_than]);
     const sample_rows = await deps.db.query(`SELECT hash, size, created_at, external_url
-		 FROM facts f
+		 FROM fact f
 		 WHERE NOT EXISTS (
 		   SELECT 1 FROM cell c
 		   WHERE c.refs @> ARRAY[f.hash]::text[]
@@ -150,7 +150,7 @@ export const query_orphan_facts_list = async (deps, older_than, sample_limit) =>
  */
 export const query_orphan_facts_select_for_delete = async (deps, older_than) => {
     const rows = await deps.db.query(`SELECT hash, size, external_url
-		 FROM facts f
+		 FROM fact f
 		 WHERE NOT EXISTS (
 		   SELECT 1 FROM cell c
 		   WHERE c.refs @> ARRAY[f.hash]::text[]

package/dist/db/fact_store.d.ts

@@ -42,7 +42,7 @@ export declare const create_default_fetcher: () => FactExternalFetcher;
  * Construction-time deps for `PgFactStore`.
  *
  * `embedded_threshold` (bytes) is the inline-vs-external cutoff: payloads
- * at or under it store embedded in the `facts` row, larger ones route to
+ * at or under it store embedded in the `fact` row, larger ones route to
  * the external fetcher. Defaults to `FACT_EMBEDDED_THRESHOLD_DEFAULT`
  * (1 MiB). Consumers tune it per workload — e.g. a much lower bound
  * (~16 KiB) keeps only small JSON inline and routes image originals +
@@ -86,8 +86,8 @@ export declare class PgFactStore implements FactStore {
     get_meta(hash: FactHash): Promise<FactMeta | null>;
     get_refs(hash: FactHash): Promise<Array<FactHash>>;
     /**
-     * Drop a fact row. `fact_refs` rows referencing this hash as a source
-     * cascade via the FK; `fact_refs` targeting this hash do **not** —
+     * Drop a fact row. `fact_ref` rows referencing this hash as a source
+     * cascade via the FK; `fact_ref` targeting this hash do **not** —
      * they remain as dangling pointers, consistent with the federation
      * model where `target_hash` is intentionally not a FK.
      *

package/dist/db/fact_store.js

@@ -157,8 +157,8 @@ export class PgFactStore {
         return query_get_fact_refs(this.#deps, hash);
     }
     /**
-     * Drop a fact row. `fact_refs` rows referencing this hash as a source
-     * cascade via the FK; `fact_refs` targeting this hash do **not** —
+     * Drop a fact row. `fact_ref` rows referencing this hash as a source
+     * cascade via the FK; `fact_ref` targeting this hash do **not** —
      * they remain as dangling pointers, consistent with the federation
      * model where `target_hash` is intentionally not a FK.
      *

package/dist/testing/CLAUDE.md

@@ -209,15 +209,15 @@ test-only by construction.
 
 ### `schema_introspect.ts` — `query_schema_snapshot`
 
-- `query_schema_snapshot(db, options?)` — introspects a live DB into a deterministic `SchemaSnapshot` via `pg_catalog` + `information_schema`. Captures tables, columns (with `udt_name` to distinguish int4/int8), indexes (`indexdef`), constraints (`pg_get_constraintdef`), sequences, and `schema_version` rows.
-- `SchemaSnapshot` — fully JSON-serializable; every collection deterministically sorted on capture so structural equality is stable across runs. `applied_at` is excluded from `schema_version` rows so timestamps don't drift the snapshot.
+- `query_schema_snapshot(db, options?)` — introspects a live DB into a deterministic `SchemaSnapshot` via `pg_catalog` + `information_schema`. Captures tables, columns (with `udt_name` to distinguish int4/int8), indexes (`indexdef`), constraints (`pg_get_constraintdef`), and sequences. The `schema_version` migration tracker is always excluded — it's framework bookkeeping, not domain schema, and impls organize migration namespaces differently.
+- `SchemaSnapshot` — the Zod schema is canonical (co-located in `schema_introspect.ts`; the cross-impl `_testing_schema_snapshot` RPC action reuses it as its wire validator, and the type is `z.infer`'d from it). Fully JSON-serializable; every collection deterministically sorted on capture so structural equality is stable across runs.
 
 ### `schema_parity.ts` — `assert_schema_snapshots_equal`
 
 - `diff_schema_snapshots(a, b)` — structured `Array<SchemaDiff>` between two snapshots; empty array means parity holds.
 - `format_schema_diffs(diffs, labels?)` — human-readable multi-line rendering; labels name the impl on each side (e.g., `{a: 'deno', b: 'rust'}`).
 - `assert_schema_snapshots_equal(a, b, labels?)` — throws on drift with a fully-formatted diff message.
-- `SchemaDiff` — tagged-union per drift kind: `schema_version_only_in`, `schema_version_sequence_differs`, `table_only_in`, `column_only_in`, `column_field_differs`, `index_only_in`, `index_definition_differs`, `constraint_only_in`, `constraint_differs`, `sequence_only_in`, `sequence_data_type_differs`.
+- `SchemaDiff` — tagged-union per drift kind: `table_only_in`, `column_only_in`, `column_field_differs`, `index_only_in`, `index_definition_differs`, `constraint_only_in`, `constraint_differs`, `sequence_only_in`, `sequence_data_type_differs`.
 
 **Cross-impl gate pattern** — a dual-impl consumer running two backends
 (a TS Hono server and a Rust spine server) against a shared schema, plus

package/dist/testing/cross_backend/create_schema_parity_global_setup.d.ts

@@ -0,0 +1,59 @@
+import '../assert_dev_env.js';
+/**
+ * Vitest `globalSetup` factory for cross-impl **schema-parity** projects.
+ *
+ * The per-backend `create_cross_backend_global_setup` spawns one backend
+ * (derived from the project name). A schema-parity gate instead needs
+ * *two* backends alive at once so the test process can capture each one's
+ * schema (via `capture_schema_snapshot`) and diff them with
+ * `assert_schema_snapshots_equal`. This factory spawns + bootstraps both
+ * configs and `provide`s both serialized handles.
+ *
+ * A consumer's parity `global_setup.ts` collapses to:
+ *
+ * ```ts
+ * import {create_schema_parity_global_setup} from
+ *   '@fuzdev/fuz_app/testing/cross_backend/create_schema_parity_global_setup.js';
+ * import {deno_backend_config, rust_backend_config} from './my_backend_config.js';
+ * import './cross_test_types.js'; // augments the two provide keys
+ *
+ * export default create_schema_parity_global_setup({
+ *   configs: {a: deno_backend_config, b: rust_backend_config},
+ * });
+ * ```
+ *
+ * The parity `.cross.test.ts` `inject`s both keys, rebuilds each with
+ * `reconstruct_bootstrapped_handle`, and asserts. Run this project in a
+ * later `groupOrder` than the single-backend projects (or with distinct
+ * ports) — it reuses both configs' ports, so it must not run concurrently
+ * with the per-backend projects.
+ *
+ * @module
+ */
+import type { TestProject } from 'vitest/node';
+import type { BackendConfig } from './backend_config.js';
+export interface SchemaParityGlobalSetupOptions {
+    /**
+     * The two backend config factories to spawn. `a` is spawned first; on
+     * its success `b` is spawned (with `a` torn down if `b` throws). Label
+     * them in the parity test via `assert_schema_snapshots_equal`'s labels.
+     */
+    readonly configs: {
+        readonly a: () => BackendConfig;
+        readonly b: () => BackendConfig;
+    };
+    /**
+     * `project.provide` keys for the two serialized handles (read by
+     * `inject` in the parity test). Default `parity_handle_a` /
+     * `parity_handle_b`. Augment vitest's `ProvidedContext` for them.
+     */
+    readonly provide_keys?: {
+        readonly a: string;
+        readonly b: string;
+    };
+}
+/**
+ * Build a vitest `globalSetup` default export that spawns both backends.
+ */
+export declare const create_schema_parity_global_setup: ({ configs, provide_keys, }: SchemaParityGlobalSetupOptions) => ((project: TestProject) => Promise<() => Promise<void>>);
+//# sourceMappingURL=create_schema_parity_global_setup.d.ts.map

package/dist/testing/cross_backend/create_schema_parity_global_setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_schema_parity_global_setup.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/create_schema_parity_global_setup.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAIvD,MAAM,WAAW,8BAA8B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,aAAa,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,aAAa,CAAA;KAAC,CAAC;IACrF;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;CACjE;AAED;;GAEG;AACH,eAAO,MAAM,iCAAiC,GAAI,4BAG/C,8BAA8B,KAAG,CAAC,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAmB1F,CAAC"}

package/dist/testing/cross_backend/create_schema_parity_global_setup.js

@@ -0,0 +1,27 @@
+import '../assert_dev_env.js';
+import { bootstrap_backend } from './bootstrap_backend.js';
+import { serialize_bootstrapped_handle } from './setup.js';
+/**
+ * Build a vitest `globalSetup` default export that spawns both backends.
+ */
+export const create_schema_parity_global_setup = ({ configs, provide_keys = { a: 'parity_handle_a', b: 'parity_handle_b' }, }) => {
+    return async (project) => {
+        const a = await bootstrap_backend(configs.a());
+        // Tear `a` down if `b` fails to spawn — no orphaned child process.
+        let b;
+        try {
+            b = await bootstrap_backend(configs.b());
+        }
+        catch (err) {
+            await a.teardown();
+            throw err;
+        }
+        const provide = project.provide;
+        provide(provide_keys.a, serialize_bootstrapped_handle(a));
+        provide(provide_keys.b, serialize_bootstrapped_handle(b));
+        return async () => {
+            await b.teardown();
+            await a.teardown();
+        };
+    };
+};

package/dist/testing/cross_backend/setup.d.ts

@@ -8,6 +8,7 @@ import { type RpcEndpointsSuiteOption } from '../rpc_helpers.js';
 import { type BackendCapabilities } from './capabilities.js';
 import type { AppSurfaceSpec } from '../../http/surface.js';
 import { type FetchTransport } from '../transports/fetch_transport.js';
+import type { SchemaSnapshot } from '../schema_introspect.js';
 import type { BackendHandle } from './spawn_backend.js';
 /**
  * Options for `TestFixture.create_account` — mints an additional
@@ -321,6 +322,21 @@ export interface CrossProcessSetupOptions {
      */
     readonly extra_accounts?: ReadonlyArray<ExtraAccountSpec>;
 }
+/**
+ * Capture a backend's schema snapshot over the `_testing_schema_snapshot`
+ * RPC action (keeper daemon-token channel). The canonical way for a
+ * cross-impl parity gate to read each backend's live schema — pair two
+ * calls with `assert_schema_snapshots_equal` (`testing/schema_parity.js`).
+ *
+ * `exclude_tables` drops documented divergences from both sides before
+ * comparison (e.g. a cell-primary Rust backend lacks tables the TS schema
+ * has). Each impl answers from its own introspection — TS via
+ * `query_schema_snapshot`, Rust via `fuz_db::query_schema_snapshot` — and
+ * the snapshot shapes match by design.
+ */
+export declare const capture_schema_snapshot: (handle: ReconstructedBootstrappedBackendHandle, options?: {
+    exclude_tables?: ReadonlyArray<string>;
+}) => Promise<SchemaSnapshot>;
 /**
  * Build a `SetupTest` against a spawned + bootstrapped backend.
  *

package/dist/testing/cross_backend/setup.d.ts.map

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

package/dist/testing/cross_backend/setup.js

@@ -233,6 +233,22 @@ const rpc_via_transport = async (transport, rpc_path, method, params, backend_na
     }
     return raw.result;
 };
+/**
+ * Capture a backend's schema snapshot over the `_testing_schema_snapshot`
+ * RPC action (keeper daemon-token channel). The canonical way for a
+ * cross-impl parity gate to read each backend's live schema — pair two
+ * calls with `assert_schema_snapshots_equal` (`testing/schema_parity.js`).
+ *
+ * `exclude_tables` drops documented divergences from both sides before
+ * comparison (e.g. a cell-primary Rust backend lacks tables the TS schema
+ * has). Each impl answers from its own introspection — TS via
+ * `query_schema_snapshot`, Rust via `fuz_db::query_schema_snapshot` — and
+ * the snapshot shapes match by design.
+ */
+export const capture_schema_snapshot = async (handle, options = {}) => {
+    const raw = await rpc_via_transport(handle.keeper_transport, handle.config.rpc_path, '_testing_schema_snapshot', { exclude_tables: [...(options.exclude_tables ?? [])] }, handle.config.name, { [DAEMON_TOKEN_HEADER]: handle.daemon_token });
+    return raw;
+};
 /**
  * Backdating offset (seconds) the `mint_expired_session` seam passes to
  * `mint_test_session` / `_testing_mint_session`. A minute in the past is

package/dist/testing/cross_backend/testing_reset_actions.d.ts

@@ -2,11 +2,12 @@ import '../assert_dev_env.js';
 /**
  * Test-binary RPC actions for cross-process integration tests.
  *
- * Three daemon-token-authed actions, bundled by `create_testing_actions`:
+ * Four daemon-token-authed actions, bundled by `create_testing_actions`:
  * **`_testing_reset`** (DB wipe + keeper re-seed), **`_testing_drain_effects`**
- * (audit barrier), and **`_testing_mint_session`** (forge an
+ * (audit barrier), **`_testing_mint_session`** (forge an
  * expired-by-construction server-side session for the expiry conformance
- * cases).
+ * cases), and **`_testing_schema_snapshot`** (introspect the live schema for
+ * cross-impl parity diffing against a Rust backend's `fuz_db` snapshot).
  *
  * `_testing_reset` — full DB wipe + keeper re-seed + optional
  * secondary-account seeding. The
@@ -213,6 +214,61 @@ export declare const testing_mint_session_action_spec: {
  * `create_testing_actions`; in-process suites mount it directly).
  */
 export declare const create_testing_drain_effects_action: () => RpcAction;
+/**
+ * `_testing_schema_snapshot` — introspect the live database into a normalized
+ * `SchemaSnapshot` for cross-impl parity diffing. The cross-backend harness
+ * calls this on each backend, then `assert_schema_snapshots_equal`s the
+ * results (a Rust backend answers from `fuz_db::query_schema_snapshot`; the
+ * shapes match by design). Optional `exclude_tables` drops documented
+ * divergences from both sides before comparison.
+ *
+ * `auth` gates on the daemon-token credential, matching `_testing_reset`.
+ */
+export declare const testing_schema_snapshot_action_spec: {
+    readonly method: "_testing_schema_snapshot";
+    readonly kind: "request_response";
+    readonly initiator: "frontend";
+    readonly auth: {
+        readonly account: "required";
+        readonly actor: "none";
+        readonly credential_types: readonly ["daemon_token"];
+    };
+    readonly side_effects: false;
+    readonly input: z.ZodObject<{
+        exclude_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly output: z.ZodObject<{
+        tables: z.ZodRecord<z.ZodString, z.ZodObject<{
+            columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+                data_type: z.ZodString;
+                udt_name: z.ZodString;
+                is_nullable: z.ZodBoolean;
+                column_default: z.ZodNullable<z.ZodString>;
+                is_identity: z.ZodBoolean;
+            }, z.core.$strip>>;
+            indexes: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                definition: z.ZodString;
+            }, z.core.$strip>>;
+            constraints: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                definition: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        sequences: z.ZodRecord<z.ZodString, z.ZodObject<{
+            data_type: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly async: true;
+    readonly description: "Test-binary only — introspect the live schema into a normalized snapshot for cross-impl parity diffing.";
+};
+/**
+ * Build the standalone `_testing_schema_snapshot` action. No deps —
+ * introspects `ctx.db` via `query_schema_snapshot`. Bundled by
+ * `create_testing_actions`; mount directly for in-process use.
+ */
+export declare const create_testing_schema_snapshot_action: () => RpcAction;
 /** Options for `create_testing_actions`. */
 export interface CreateTestingActionsOptions {
     /**

package/dist/testing/cross_backend/testing_reset_actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAEvE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,gBAAgB,CAAC;AAiBvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBQ,CAAC;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;CAWA,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;CAeC,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,QAAO,SACiB,CAAC;AAEzE,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,SAAS,2BAA2B,KAClC,KAAK,CAAC,SAAS,CA0GjB,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,UAAmC,CAAC"}
+{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAEvE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,gBAAgB,CAAC;AAkBvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBQ,CAAC;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;CAWA,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;CAeC,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,QAAO,SACiB,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWF,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,QAAO,SAGvD,CAAC;AAEH,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,SAAS,2BAA2B,KAClC,KAAK,CAAC,SAAS,CA2GjB,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,UAAmC,CAAC"}

package/dist/testing/cross_backend/testing_reset_actions.js

@@ -2,11 +2,12 @@ import '../assert_dev_env.js';
 /**
  * Test-binary RPC actions for cross-process integration tests.
  *
- * Three daemon-token-authed actions, bundled by `create_testing_actions`:
+ * Four daemon-token-authed actions, bundled by `create_testing_actions`:
  * **`_testing_reset`** (DB wipe + keeper re-seed), **`_testing_drain_effects`**
- * (audit barrier), and **`_testing_mint_session`** (forge an
+ * (audit barrier), **`_testing_mint_session`** (forge an
  * expired-by-construction server-side session for the expiry conformance
- * cases).
+ * cases), and **`_testing_schema_snapshot`** (introspect the live schema for
+ * cross-impl parity diffing against a Rust backend's `fuz_db` snapshot).
  *
  * `_testing_reset` — full DB wipe + keeper re-seed + optional
  * secondary-account seeding. The
@@ -62,6 +63,7 @@ import { Uuid } from '@fuzdev/fuz_util/id.js';
 import { rpc_action } from '../../actions/action_rpc.js';
 import { ROLE_ADMIN, ROLE_KEEPER } from '../../auth/role_schema.js';
 import { auth_integration_truncate_tables } from '../db.js';
+import { query_schema_snapshot, SchemaSnapshot } from '../schema_introspect.js';
 import { create_test_account_with_credentials, mint_test_session, DEFAULT_TEST_PASSWORD, } from '../app_server.js';
 /** Output shape for an individual seeded account (keeper or extra). */
 const SeededAccountShape = z.strictObject({
@@ -188,6 +190,33 @@ export const testing_mint_session_action_spec = {
  * `create_testing_actions`; in-process suites mount it directly).
  */
 export const create_testing_drain_effects_action = () => rpc_action(testing_drain_effects_action_spec, async () => ({ ok: true }));
+/**
+ * `_testing_schema_snapshot` — introspect the live database into a normalized
+ * `SchemaSnapshot` for cross-impl parity diffing. The cross-backend harness
+ * calls this on each backend, then `assert_schema_snapshots_equal`s the
+ * results (a Rust backend answers from `fuz_db::query_schema_snapshot`; the
+ * shapes match by design). Optional `exclude_tables` drops documented
+ * divergences from both sides before comparison.
+ *
+ * `auth` gates on the daemon-token credential, matching `_testing_reset`.
+ */
+export const testing_schema_snapshot_action_spec = {
+    method: '_testing_schema_snapshot',
+    kind: 'request_response',
+    initiator: 'frontend',
+    auth: { account: 'required', actor: 'none', credential_types: ['daemon_token'] },
+    side_effects: false,
+    input: z.strictObject({ exclude_tables: z.array(z.string()).optional() }),
+    output: SchemaSnapshot,
+    async: true,
+    description: 'Test-binary only — introspect the live schema into a normalized snapshot for cross-impl parity diffing.',
+};
+/**
+ * Build the standalone `_testing_schema_snapshot` action. No deps —
+ * introspects `ctx.db` via `query_schema_snapshot`. Bundled by
+ * `create_testing_actions`; mount directly for in-process use.
+ */
+export const create_testing_schema_snapshot_action = () => rpc_action(testing_schema_snapshot_action_spec, async (input, ctx) => query_schema_snapshot(ctx.db, { exclude_tables: input.exclude_tables }));
 /**
  * Build the testing RPC actions for a test binary's registry.
  *
@@ -298,6 +327,7 @@ export const create_testing_actions = (deps, options) => {
             return { session_cookie };
         }),
         create_testing_drain_effects_action(),
+        create_testing_schema_snapshot_action(),
     ];
 };
 /** Set of auth-namespace tables `_testing_reset` wipes. Mirrored by the coverage test. */

package/dist/testing/schema_introspect.d.ts

@@ -5,8 +5,6 @@ import './assert_dev_env.js';
  *
  * The snapshot covers:
  *
- * - `schema_version` rows (`namespace`, `name`, `sequence`) — captures
- *   migration set state across impls
  * - Tables with columns (data type, nullability, default, identity)
  * - Indexes with canonical Postgres-rendered definitions
  * - Constraints (CHECK, FOREIGN KEY, PRIMARY KEY, UNIQUE, EXCLUSION)
@@ -21,60 +19,80 @@ import './assert_dev_env.js';
  *
  * @module
  */
+import { z } from 'zod';
 import type { Db } from '../db/db.js';
-/** Per-column structural metadata. */
-export interface ColumnSnapshot {
-    /** SQL standard type name from `information_schema.columns.data_type`. */
-    readonly data_type: string;
-    /** Postgres-native type name from `information_schema.columns.udt_name`. */
-    readonly udt_name: string;
-    /** `true` when the column accepts NULL. */
-    readonly is_nullable: boolean;
-    /** Default-value expression as Postgres reports it, or `null` if none. */
-    readonly column_default: string | null;
-    /** `true` when the column was declared GENERATED ... AS IDENTITY. */
-    readonly is_identity: boolean;
-}
+/**
+ * Per-column structural metadata. The Zod schema is the canonical source
+ * for the column shape — `SchemaSnapshot` reuses it as the cross-impl
+ * `_testing_schema_snapshot` RPC action's wire validator, so the
+ * introspection type and the wire contract can't drift apart.
+ */
+export declare const ColumnSnapshot: z.ZodObject<{
+    data_type: z.ZodString;
+    udt_name: z.ZodString;
+    is_nullable: z.ZodBoolean;
+    column_default: z.ZodNullable<z.ZodString>;
+    is_identity: z.ZodBoolean;
+}, z.core.$strip>;
+export type ColumnSnapshot = z.infer<typeof ColumnSnapshot>;
 /** Per-table structural metadata. */
-export interface TableSnapshot {
-    /** Column metadata keyed by column name (sorted on serialization). */
-    readonly columns: Record<string, ColumnSnapshot>;
-    /** Index definitions as Postgres renders them via `pg_indexes.indexdef`. */
-    readonly indexes: ReadonlyArray<{
-        readonly name: string;
-        readonly definition: string;
-    }>;
-    /** Constraint definitions as Postgres renders them via `pg_get_constraintdef`. */
-    readonly constraints: ReadonlyArray<{
-        readonly name: string;
-        readonly type: string;
-        readonly definition: string;
-    }>;
-}
+export declare const TableSnapshot: z.ZodObject<{
+    columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+        data_type: z.ZodString;
+        udt_name: z.ZodString;
+        is_nullable: z.ZodBoolean;
+        column_default: z.ZodNullable<z.ZodString>;
+        is_identity: z.ZodBoolean;
+    }, z.core.$strip>>;
+    indexes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        definition: z.ZodString;
+    }, z.core.$strip>>;
+    constraints: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        definition: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TableSnapshot = z.infer<typeof TableSnapshot>;
 /** Sequence metadata — `data_type` is `bigint` (BIGSERIAL) or `integer` (SERIAL). */
-export interface SequenceSnapshot {
-    readonly data_type: string;
-}
-/** One row in the `schema_version` migration tracker. */
-export interface SchemaVersionRow {
-    readonly namespace: string;
-    readonly name: string;
-    readonly sequence: number;
-}
+export declare const SequenceSnapshot: z.ZodObject<{
+    data_type: z.ZodString;
+}, z.core.$strip>;
+export type SequenceSnapshot = z.infer<typeof SequenceSnapshot>;
 /**
- * Normalized database schema snapshot for parity comparison.
+ * Normalized database schema snapshot for parity comparison — the single
+ * source of truth for the snapshot shape across the introspection query
+ * (`query_schema_snapshot`), the diff comparator (`schema_parity.ts`), and
+ * the cross-impl RPC action's wire validator (`testing_reset_actions.ts`).
  *
  * All fields are deterministically ordered on capture so structural equality
  * via `JSON.stringify` or per-key comparison yields stable results.
  */
-export interface SchemaSnapshot {
-    /** Migration tracker rows, sorted by `(namespace, sequence)`. */
-    readonly schema_version: ReadonlyArray<SchemaVersionRow>;
-    /** Tables keyed by name. */
-    readonly tables: Record<string, TableSnapshot>;
-    /** Sequences keyed by name. */
-    readonly sequences: Record<string, SequenceSnapshot>;
-}
+export declare const SchemaSnapshot: z.ZodObject<{
+    tables: z.ZodRecord<z.ZodString, z.ZodObject<{
+        columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+            data_type: z.ZodString;
+            udt_name: z.ZodString;
+            is_nullable: z.ZodBoolean;
+            column_default: z.ZodNullable<z.ZodString>;
+            is_identity: z.ZodBoolean;
+        }, z.core.$strip>>;
+        indexes: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            definition: z.ZodString;
+        }, z.core.$strip>>;
+        constraints: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            definition: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    sequences: z.ZodRecord<z.ZodString, z.ZodObject<{
+        data_type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SchemaSnapshot = z.infer<typeof SchemaSnapshot>;
 /** Filter options for `query_schema_snapshot`. */
 export interface QuerySchemaSnapshotOptions {
     /**
@@ -83,8 +101,10 @@ export interface QuerySchemaSnapshotOptions {
      */
     readonly schema?: string;
     /**
-     * Tables to exclude from the snapshot. The `schema_version` table itself
-     * is always excluded (its content is captured separately).
+     * Tables to exclude from the snapshot. The `schema_version` migration
+     * tracker is always excluded — it's framework bookkeeping created by the
+     * migration runner, identical across impls, and not part of any
+     * consumer's domain schema.
      */
     readonly exclude_tables?: ReadonlyArray<string>;
 }
@@ -92,15 +112,11 @@ export interface QuerySchemaSnapshotOptions {
  * Introspect a live database into a deterministic `SchemaSnapshot`.
  *
  * Reads `information_schema` and `pg_catalog` to capture tables, columns,
- * indexes, constraints, sequences, and `schema_version` migration tracker
- * rows. The `applied_at` timestamp is deliberately excluded — only the set
- * of applied migrations matters for parity.
- *
- * The `schema_version` table itself never appears in the `tables` field;
- * its structure is identical across consumers and would only add noise.
+ * indexes, constraints, and sequences.
  *
- * @throws Error when the `schema_version` table is missing — callers must
- *   ensure migrations have run before introspecting.
+ * The `schema_version` migration tracker never appears in the `tables`
+ * field — it's framework bookkeeping created by the migration runner,
+ * identical across consumers, and would only add noise.
  */
 export declare const query_schema_snapshot: (db: Db, options?: QuerySchemaSnapshotOptions) => Promise<SchemaSnapshot>;
 //# sourceMappingURL=schema_introspect.d.ts.map

package/dist/testing/schema_introspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AAEpC,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,qEAAqE;IACrE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC9B;AAED,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACjD,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACtF,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;QACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;KAC5B,CAAC,CAAC;CACH;AAED,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC3B;AAED,yDAAyD;AACzD,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,cAAc,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACzD,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC/C,+BAA+B;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACrD;AAED,kDAAkD;AAClD,MAAM,WAAW,0BAA0B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChD;AAyDD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CA+GxB,CAAC"}
+{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;iBAWzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,qCAAqC;AACrC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;iBAOxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;iBAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,kDAAkD;AAClD,MAAM,WAAW,0BAA0B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChD;AAyDD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CAuGxB,CAAC"}

package/dist/testing/schema_introspect.js

@@ -1,4 +1,71 @@
 import './assert_dev_env.js';
+/**
+ * PostgreSQL schema introspection — produces a normalized, JSON-serializable
+ * snapshot of a database's structure for cross-impl parity checks.
+ *
+ * The snapshot covers:
+ *
+ * - Tables with columns (data type, nullability, default, identity)
+ * - Indexes with canonical Postgres-rendered definitions
+ * - Constraints (CHECK, FOREIGN KEY, PRIMARY KEY, UNIQUE, EXCLUSION)
+ * - Sequences with data type — distinguishes `int4` (SERIAL) from `int8`
+ *   (BIGSERIAL)
+ *
+ * Designed for `pg_catalog` introspection — works against both PostgreSQL
+ * and PGlite. The snapshot is fully deterministic: every collection sorts by
+ * a stable key and excludes time-varying fields like `applied_at`.
+ *
+ * Paired with `schema_parity.ts` for comparison + assertion helpers.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * Per-column structural metadata. The Zod schema is the canonical source
+ * for the column shape — `SchemaSnapshot` reuses it as the cross-impl
+ * `_testing_schema_snapshot` RPC action's wire validator, so the
+ * introspection type and the wire contract can't drift apart.
+ */
+export const ColumnSnapshot = z.object({
+    /** SQL standard type name from `information_schema.columns.data_type`. */
+    data_type: z.string(),
+    /** Postgres-native type name from `information_schema.columns.udt_name`. */
+    udt_name: z.string(),
+    /** `true` when the column accepts NULL. */
+    is_nullable: z.boolean(),
+    /** Default-value expression as Postgres reports it, or `null` if none. */
+    column_default: z.string().nullable(),
+    /** `true` when the column was declared GENERATED ... AS IDENTITY. */
+    is_identity: z.boolean(),
+});
+/** Per-table structural metadata. */
+export const TableSnapshot = z.object({
+    /** Column metadata keyed by column name (sorted on serialization). */
+    columns: z.record(z.string(), ColumnSnapshot),
+    /** Index definitions as Postgres renders them via `pg_indexes.indexdef`. */
+    indexes: z.array(z.object({ name: z.string(), definition: z.string() })),
+    /** Constraint definitions as Postgres renders them via `pg_get_constraintdef`. */
+    constraints: z.array(z.object({ name: z.string(), type: z.string(), definition: z.string() })),
+});
+/** Sequence metadata — `data_type` is `bigint` (BIGSERIAL) or `integer` (SERIAL). */
+export const SequenceSnapshot = z.object({
+    data_type: z.string(),
+});
+/**
+ * Normalized database schema snapshot for parity comparison — the single
+ * source of truth for the snapshot shape across the introspection query
+ * (`query_schema_snapshot`), the diff comparator (`schema_parity.ts`), and
+ * the cross-impl RPC action's wire validator (`testing_reset_actions.ts`).
+ *
+ * All fields are deterministically ordered on capture so structural equality
+ * via `JSON.stringify` or per-key comparison yields stable results.
+ */
+export const SchemaSnapshot = z.object({
+    /** Tables keyed by name. */
+    tables: z.record(z.string(), TableSnapshot),
+    /** Sequences keyed by name. */
+    sequences: z.record(z.string(), SequenceSnapshot),
+});
 const sort_keys = (record) => {
     const sorted = {};
     for (const key of Object.keys(record).sort()) {
@@ -28,26 +95,16 @@ const contype_to_kind = (contype) => {
  * Introspect a live database into a deterministic `SchemaSnapshot`.
  *
  * Reads `information_schema` and `pg_catalog` to capture tables, columns,
- * indexes, constraints, sequences, and `schema_version` migration tracker
- * rows. The `applied_at` timestamp is deliberately excluded — only the set
- * of applied migrations matters for parity.
- *
- * The `schema_version` table itself never appears in the `tables` field;
- * its structure is identical across consumers and would only add noise.
+ * indexes, constraints, and sequences.
  *
- * @throws Error when the `schema_version` table is missing — callers must
- *   ensure migrations have run before introspecting.
+ * The `schema_version` migration tracker never appears in the `tables`
+ * field — it's framework bookkeeping created by the migration runner,
+ * identical across consumers, and would only add noise.
  */
 export const query_schema_snapshot = async (db, options = {}) => {
     const schema = options.schema ?? 'public';
     const exclude_tables = new Set(options.exclude_tables ?? []);
     exclude_tables.add('schema_version');
-    // schema_version rows — the migration tracker. Exclude `applied_at`
-    // because timestamps differ across bootstraps even when the migration
-    // set is identical.
-    const schema_version_rows = await db.query(`SELECT namespace, name, sequence
-		 FROM schema_version
-		 ORDER BY namespace ASC, sequence ASC`);
     // All tables in the target schema, minus the excludes.
     const table_rows = await db.query(`SELECT table_name
 		 FROM information_schema.tables
@@ -68,6 +125,11 @@ export const query_schema_snapshot = async (db, options = {}) => {
 		 WHERE schemaname = $1
 		 ORDER BY tablename ASC, indexname ASC`, [schema]);
     // Constraints — pg_get_constraintdef produces a canonical text rendering.
+    // Skip NOT NULL constraints (`contype = 'n'`): PG17+ catalogs them as
+    // named `pg_constraint` rows while PGlite / older PG don't, and
+    // nullability is already captured per-column by `is_nullable` — including
+    // them would report a pure engine-cataloging artifact as cross-backend
+    // drift between a PGlite and a real-Postgres backend.
     const constraint_rows = await db.query(`SELECT c.conrelid::regclass::text AS table_name,
 		        c.conname,
 		        c.contype::text,
@@ -76,6 +138,7 @@ export const query_schema_snapshot = async (db, options = {}) => {
 		 JOIN pg_namespace n ON n.oid = c.connamespace
 		 WHERE n.nspname = $1
 		   AND c.conrelid != 0
+		   AND c.contype != 'n'
 		 ORDER BY table_name ASC, conname ASC`, [schema]);
     // Sequences — data_type distinguishes bigint (BIGSERIAL) from integer (SERIAL).
     const sequence_rows = await db.query(`SELECT sequence_name, data_type
@@ -116,7 +179,6 @@ export const query_schema_snapshot = async (db, options = {}) => {
         sequences[row.sequence_name] = { data_type: row.data_type };
     }
     return {
-        schema_version: schema_version_rows,
         tables: sort_keys(tables),
         sequences: sort_keys(sequences),
     };

package/dist/testing/schema_parity.d.ts

@@ -6,7 +6,7 @@ import './assert_dev_env.js';
  * Two live impls (TS fuz_app vs Rust spine) are each other's parity
  * reference. After both bootstrap, snapshot each, diff, fail loudly on
  * drift. The diff entries name the specific divergence (column type,
- * missing index, schema_version row absent on one side) so the error
+ * missing index, constraint absent on one side) so the error
  * message points at the source.
  *
  * Consumer pattern (in zzz's integration runner or fuz_app's own
@@ -29,8 +29,8 @@ import './assert_dev_env.js';
  *   impls with the same columns in different declaration order compare
  *   equal (functional parity is preserved; `SELECT *` ordering is not)
  * - `COMMENT ON ...`
- * - the `schema_version` table's own structure (only its rows are
- *   captured)
+ * - the `schema_version` migration tracker (always excluded — framework
+ *   bookkeeping, not domain schema)
  * - permissions / `GRANT`s
  *
  * None of these are used by the current fuz_app auth schema. Extend
@@ -40,19 +40,9 @@ import './assert_dev_env.js';
  *
  * @module
  */
-import type { ColumnSnapshot, SchemaSnapshot, SchemaVersionRow } from './schema_introspect.js';
+import type { ColumnSnapshot, SchemaSnapshot } from './schema_introspect.js';
 /** Structured drift entry. `where` is the named source impl ('a' or 'b'). */
 export type SchemaDiff = {
-    readonly kind: 'schema_version_only_in';
-    readonly where: 'a' | 'b';
-    readonly row: SchemaVersionRow;
-} | {
-    readonly kind: 'schema_version_sequence_differs';
-    readonly namespace: string;
-    readonly name: string;
-    readonly a: number;
-    readonly b: number;
-} | {
     readonly kind: 'table_only_in';
     readonly where: 'a' | 'b';
     readonly table: string;
@@ -109,9 +99,9 @@ export type SchemaDiff = {
 /**
  * Structural diff between two snapshots — empty array means parity holds.
  *
- * Order of diffs is deterministic: schema_version first, then tables in
- * sorted order (with column/index/constraint sub-diffs grouped per table),
- * then sequences. Consumers can rely on this for stable diff output.
+ * Order of diffs is deterministic: tables in sorted order (with
+ * column/index/constraint sub-diffs grouped per table), then sequences.
+ * Consumers can rely on this for stable diff output.
  */
 export declare const diff_schema_snapshots: (a: SchemaSnapshot, b: SchemaSnapshot) => Array<SchemaDiff>;
 /** Labels used in formatted output — defaults to `'a'` and `'b'`. */

package/dist/testing/schema_parity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema_parity.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_parity.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EACX,cAAc,EACd,cAAc,EACd,gBAAgB,EAGhB,MAAM,wBAAwB,CAAC;AAEhC,6EAA6E;AAC7E,MAAM,MAAM,UAAU,GACnB;IACA,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;CAC9B,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,iCAAiC,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CAClB,GACD;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GACnF;IACA,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACvB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,cAAc,CAAC;IACrC,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;CACnB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACtB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CAClB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC3B,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC;IAC/C,QAAQ,CAAC,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC;CAC9C,GACD;IAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,GACzF;IACA,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,GAAG,cAAc,EAAE,GAAG,cAAc,KAAG,KAAK,CAAC,UAAU,CAoC5F,CAAC;AAuIF,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC/B,OAAO,aAAa,CAAC,UAAU,CAAC,EAChC,SAAQ,gBAAqB,KAC3B,MA8DF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,6BAA6B,GACzC,GAAG,cAAc,EACjB,GAAG,cAAc,EACjB,SAAQ,gBAAqB,KAC3B,IAQF,CAAC"}
+{"version":3,"file":"schema_parity.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_parity.ts"],"names":[],"mappings":"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"}

package/dist/testing/schema_parity.js

@@ -2,13 +2,12 @@ import './assert_dev_env.js';
 /**
  * Structural diff between two snapshots — empty array means parity holds.
  *
- * Order of diffs is deterministic: schema_version first, then tables in
- * sorted order (with column/index/constraint sub-diffs grouped per table),
- * then sequences. Consumers can rely on this for stable diff output.
+ * Order of diffs is deterministic: tables in sorted order (with
+ * column/index/constraint sub-diffs grouped per table), then sequences.
+ * Consumers can rely on this for stable diff output.
  */
 export const diff_schema_snapshots = (a, b) => {
     const diffs = [];
-    diff_schema_version(a.schema_version, b.schema_version, diffs);
     const all_tables = new Set([...Object.keys(a.tables), ...Object.keys(b.tables)]);
     for (const table of [...all_tables].sort()) {
         const ta = a.tables[table];
@@ -39,33 +38,6 @@ export const diff_schema_snapshots = (a, b) => {
     }
     return diffs;
 };
-const diff_schema_version = (a, b, out) => {
-    const key = (r) => `${r.namespace}\x00${r.name}`;
-    const a_by_key = new Map(a.map((r) => [key(r), r]));
-    const b_by_key = new Map(b.map((r) => [key(r), r]));
-    const keys = new Set([...a_by_key.keys(), ...b_by_key.keys()]);
-    for (const k of [...keys].sort()) {
-        const row_a = a_by_key.get(k);
-        const row_b = b_by_key.get(k);
-        if (!row_a) {
-            out.push({ kind: 'schema_version_only_in', where: 'b', row: row_b });
-            continue;
-        }
-        if (!row_b) {
-            out.push({ kind: 'schema_version_only_in', where: 'a', row: row_a });
-            continue;
-        }
-        if (row_a.sequence !== row_b.sequence) {
-            out.push({
-                kind: 'schema_version_sequence_differs',
-                namespace: row_a.namespace,
-                name: row_a.name,
-                a: row_a.sequence,
-                b: row_b.sequence,
-            });
-        }
-    }
-};
 const COLUMN_FIELDS = [
     'data_type',
     'udt_name',
@@ -165,12 +137,6 @@ export const format_schema_diffs = (diffs, labels = {}) => {
     const lines = [];
     for (const d of diffs) {
         switch (d.kind) {
-            case 'schema_version_only_in':
-                lines.push(`  schema_version row only in ${where_label(d.where)}: ${d.row.namespace}/${d.row.name} (sequence ${d.row.sequence})`);
-                break;
-            case 'schema_version_sequence_differs':
-                lines.push(`  schema_version sequence differs for ${d.namespace}/${d.name}: ${label_a}=${d.a}, ${label_b}=${d.b}`);
-                break;
             case 'table_only_in':
                 lines.push(`  table ${d.table} only in ${where_label(d.where)}`);
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.70.0",
+  "version": "0.71.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",