@fuzdev/fuz_app 0.69.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,25 +209,26 @@ 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** — consumers running two backends against a
-shared schema (zzz's `--backend=both`, fuz_app's cross-backend suite)
-bootstrap each impl against an isolated DB, snapshot, then compare:
+**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
+fuz_app's own cross-backend suite, bootstrap each impl against an isolated
+DB, snapshot, then compare:
 
 ```ts
-await drop_recreate_db('zzz_test');
+await drop_recreate_db('app_test');
 await spawn_backend(deno_config);
 const snapshot_deno = await query_schema_snapshot(db);
-await drop_recreate_db('zzz_test');
+await drop_recreate_db('app_test');
 await spawn_backend(rust_config);
 const snapshot_rust = await query_schema_snapshot(db);
 assert_schema_snapshots_equal(snapshot_deno, snapshot_rust, {a: 'deno', b: 'rust'});
@@ -789,8 +790,8 @@ points:
 The standard test suites take a unified
 `{setup_test, surface_source, capabilities}` shape so the same suite bodies
 run against an in-process Hono harness today and against a spawned backend
-over real HTTP — either the Rust spine (`zzz_server`, `fuz_forge_server`, or
-the non-domain `testing_spine_stub`) or a **TS** spine binary built on the
+over real HTTP — either the Rust spine (`zzz_server`, another consumer's
+spine server, or the non-domain `testing_spine_stub`) or a **TS** spine binary built on the
 test-server core below (fuz_app's own domain-free `testing_spine_server`, run
 on Node + Deno + Bun). In-process is the fast feedback path; cross-process is the
 source of truth for wire-shape conformance.
@@ -1094,7 +1095,11 @@ in-process legs (plain `gro test`) are `src/test/auth/cell_crud_parity.db.test.t
   same bootstrap-equivalent step (the only path for roles like
   `ROLE_KEEPER` whose `grant_paths` is bootstrap-only), refreshes
   `DaemonTokenState.keeper_account_id` to the new row, then fires the
-  consumer-supplied `reset_state` callback for domain-state reset. Auth
+  consumer-supplied `reset_state(db)` callback for domain-state reset —
+  passed the **transactional** `Db` the auth wipe ran on, so DB-domain
+  consumers (e.g. fuz_forge truncating its cell / fact / file tables) reset
+  on the same connection rather than a separately-pooled one that would
+  deadlock against this open transaction under PGlite. Auth
   gates on `credential_types: ['daemon_token']` — effectively keeper-only
   without forcing the `actor: 'required'` ⟺ `acting?: ActingActor`
   biconditional. No free-form runtime grant action exists — see the

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

@@ -0,0 +1,57 @@
+import '../assert_dev_env.js';
+/**
+ * Generic vitest `globalSetup` factory for cross-backend integration suites.
+ *
+ * Pairs with `make_cross_backend_project`: each cross-backend vitest project
+ * sets its own `test.name`, and this factory derives the backend name from
+ * that project name (vitest 4 passes the `TestProject` to globalSetup), picks
+ * the matching `BackendConfig`, spawns + bootstraps it via `bootstrap_backend`,
+ * and `provide`s a serializable handle that `*.cross.test.ts` files
+ * `inject` and rebuild with `reconstruct_bootstrapped_handle`.
+ *
+ * A consumer's `global_setup.ts` collapses to:
+ *
+ * ```ts
+ * import {create_cross_backend_global_setup} from
+ *   '@fuzdev/fuz_app/testing/cross_backend/create_cross_backend_global_setup.js';
+ * import {deno_backend_config, rust_backend_config} from './my_backend_config.js';
+ * import './cross_test_types.js'; // augments inject('backend_handle')
+ *
+ * export default create_cross_backend_global_setup({
+ *   configs: {deno: deno_backend_config, rust: rust_backend_config},
+ * });
+ * ```
+ *
+ * vitest 4's `provide` hard-rejects non-serializable values, so the live
+ * `child` / `teardown` / `keeper_transport` are stripped via
+ * `serialize_bootstrapped_handle`; the teardown closure stays in the
+ * globalSetup process and is returned for vitest to fire after the suite.
+ *
+ * @module
+ */
+import type { TestProject } from 'vitest/node';
+import type { BackendConfig } from './backend_config.js';
+export interface CrossBackendGlobalSetupOptions {
+    /**
+     * Map of derived backend name → `BackendConfig` factory. The derived
+     * name (see `derive_name`) selects the factory; unknown names throw with
+     * the full supported list so a misnamed project surfaces clearly.
+     */
+    readonly configs: Readonly<Record<string, () => BackendConfig>>;
+    /**
+     * Derive the backend name from the vitest project name. Default strips
+     * `cross_backend_(ts_)?`.
+     */
+    readonly derive_name?: (project_name: string) => string;
+    /**
+     * Key passed to `project.provide` (and read by `inject` in test files).
+     * Default `'backend_handle'`. Augment vitest's `ProvidedContext` for it.
+     */
+    readonly provide_key?: string;
+}
+/**
+ * Build a vitest `globalSetup` default export. Returns the
+ * `(project) => teardown` function vitest 4 expects.
+ */
+export declare const create_cross_backend_global_setup: ({ configs, derive_name, provide_key, }: CrossBackendGlobalSetupOptions) => ((project: TestProject) => Promise<() => Promise<void>>);
+//# sourceMappingURL=create_cross_backend_global_setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_cross_backend_global_setup.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/create_cross_backend_global_setup.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAYvD,MAAM,WAAW,8BAA8B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,aAAa,CAAC,CAAC,CAAC;IAChE;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;IACxD;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAAI,wCAI/C,8BAA8B,KAAG,CAAC,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAqB1F,CAAC"}

package/dist/testing/cross_backend/create_cross_backend_global_setup.js

@@ -0,0 +1,31 @@
+import '../assert_dev_env.js';
+import { bootstrap_backend } from './bootstrap_backend.js';
+import { serialize_bootstrapped_handle } from './setup.js';
+/**
+ * Default project-name → backend-name reduction: strips the
+ * `cross_backend_` prefix plus an optional `ts_` discriminator (the TS
+ * canonical backends carry it to distinguish JS runtimes). So
+ * `cross_backend_ts_deno` → `deno` and `cross_backend_rust` → `rust`.
+ */
+const DEFAULT_PROJECT_NAME_PREFIX = /^cross_backend_(?:ts_)?/;
+/**
+ * Build a vitest `globalSetup` default export. Returns the
+ * `(project) => teardown` function vitest 4 expects.
+ */
+export const create_cross_backend_global_setup = ({ configs, derive_name = (project_name) => project_name.replace(DEFAULT_PROJECT_NAME_PREFIX, ''), provide_key = 'backend_handle', }) => {
+    return async (project) => {
+        const name = derive_name(project.name);
+        const factory = configs[name];
+        if (!factory) {
+            throw new Error(`Could not derive backend config from vitest project '${project.name}' ` +
+                `(derived name '${name}') — expected one of: ${Object.keys(configs).join(', ')}`);
+        }
+        const bootstrapped = await bootstrap_backend(factory());
+        // vitest's `provide` is keyed on the consumer-augmented `ProvidedContext`;
+        // the generic key is a plain string, so cast past the keyof constraint.
+        project.provide(provide_key, serialize_bootstrapped_handle(bootstrapped));
+        return async () => {
+            await bootstrapped.teardown();
+        };
+    };
+};

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"}