@fuzdev/fuz_app 0.80.0 → 0.81.0

package/dist/testing/CLAUDE.md

@@ -209,7 +209,7 @@ 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`), and sequences. The `schema_version` migration tracker is always excluded — it's framework bookkeeping, not domain schema, and impls organize migration namespaces differently.
+- `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 enum types (`pg_enum` labels in declared `enumsortorder`, so a `cell_visibility` label-set/order drift is gated). The `schema_version` migration tracker is always excluded — it's framework bookkeeping, not domain schema, and impls organize migration namespaces differently. Twinned by `fuz_db::query_schema_snapshot` (Rust); the `_testing_schema_snapshot` RPC's wire validator is the shared `SchemaSnapshot`, so the enum field must serialize on both sides.
 - `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`
@@ -217,7 +217,9 @@ test-only by construction.
 - `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: `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`, `enum_only_in`, `enum_labels_differ` (enum labels compared positionally — declared order is significant).
+
+fuz_app's own spine gates this cross-process via the `cross_backend_schema_parity` project (`schema_parity.cross.test.ts` + the dual-spawn `global_setup_schema_parity.ts`), diffing the TS spine ↔ `testing_spine_stub` full schema — `npm run test:cross:schema-parity`. The forge has its own deno↔rust parity gate.
 
 **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/cell_relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cell_relations.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_relations.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAkE9B,OAAO,EAIN,KAAK,oBAAoB,EACzB,MAAM,yBAAyB,CAAC;AAGjC,eAAO,MAAM,mCAAmC,GAAI,SAAS,oBAAoB,KAAG,IAsfnF,CAAC"}
+{"version":3,"file":"cell_relations.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_relations.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAoF9B,OAAO,EAIN,KAAK,oBAAoB,EACzB,MAAM,yBAAyB,CAAC;AAsFjC,eAAO,MAAM,mCAAmC,GAAI,SAAS,oBAAoB,KAAG,IAyvBnF,CAAC"}

package/dist/testing/cross_backend/cell_relations.js

@@ -30,6 +30,17 @@ import '../assert_dev_env.js';
  * - **audit** — `cell_audit_list` is manage-tier: the owner reads the cell's
  *   timeline; a viewer-grant holder who can `cell_get` the cell still gets the
  *   IDOR 404 on the timeline (D14).
+ * - **relation-read visibility (D8)** — listing edges toward a cell the caller
+ *   can't view filters them out (no-existence-leak-via-edge): an anonymous
+ *   viewer of a public parent — and a viewer-grant holder of a private parent —
+ *   sees only independently-viewable children in the `cell_get` bundle and the
+ *   forward `cell_item_list` / `cell_field_list`. The cross twin of the
+ *   in-process `auth/cell_relation_visibility.db.test.ts`.
+ * - **clone D8** — a cloner who can view a public parent but not a private child
+ *   silently drops that child: an admin (who *can* view it) reading the clone
+ *   still sees only the viewable edge/child, and the `cell_clone` audit row
+ *   records no skipped-child count — so the source's hidden-child count can't
+ *   leak to the cloner. The cross twin of `auth/cell_actions.clone.db.test.ts`.
  *
  * Only **actor-shaped** grants are exercised — role-shaped principals need a
  * closed role registry the Rust spine deliberately lacks, so role-grant
@@ -42,7 +53,8 @@ import '../assert_dev_env.js';
  */
 import { describe, assert } from 'vitest';
 import { fractional_index_between } from '@fuzdev/fuz_util/fractional_index.js';
-import { CellCreateOutput, CellUpdateOutput, CellCloneOutput } from '../../auth/cell_action_specs.js';
+import { CellCreateOutput, CellUpdateOutput, CellCloneOutput, CellGetOutput, } from '../../auth/cell_action_specs.js';
+import { AuditLogListOutput } from '../../auth/admin_action_specs.js';
 import { CellGrantCreateOutput, CellGrantListOutput, CellGrantRevokeOutput, } from '../../auth/cell_grant_action_specs.js';
 import { CellFieldDeleteOutput, CellFieldListOutput, CellFieldSetOutput, } from '../../auth/cell_field_action_specs.js';
 import { CellItemDeleteOutput, CellItemInsertOutput, CellItemListOutput, CellItemMoveOutput, } from '../../auth/cell_item_action_specs.js';
@@ -50,6 +62,33 @@ import { CellAuditListOutput } from '../../auth/cell_audit_action_specs.js';
 import { test_if } from './capabilities.js';
 import { cross_rpc_call, error_reason, expect_output, } from './cell_cross_helpers.js';
 import { SPINE_RPC_PATH } from './default_spine_surface.js';
+/** Create a cell over the wire and return its id (the parity gate parses the output). */
+const create_cell = async (t, rpc_path, h, params) => expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', params, h), CellCreateOutput).cell
+    .id;
+/**
+ * Wire `pub_child` + `priv_child` under `parent` as both ordered items and
+ * named fields, using the owner's headers (owner can edit parent + view both
+ * children). The cross-process twin of the in-process `wire_children` in
+ * `auth/cell_relation_visibility.db.test.ts`.
+ */
+const wire_children = async (t, rpc_path, owner_h, parent, pub_child, priv_child) => {
+    const pos_a = fractional_index_between(null, null);
+    const pos_b = fractional_index_between(pos_a, null);
+    expect_output(await cross_rpc_call(t, rpc_path, 'cell_item_insert', { parent_id: parent, child_id: pub_child, position: pos_a }, owner_h), CellItemInsertOutput);
+    expect_output(await cross_rpc_call(t, rpc_path, 'cell_item_insert', { parent_id: parent, child_id: priv_child, position: pos_b }, owner_h), CellItemInsertOutput);
+    expect_output(await cross_rpc_call(t, rpc_path, 'cell_field_set', { source_id: parent, name: 'pub_link', target_id: pub_child }, owner_h), CellFieldSetOutput);
+    expect_output(await cross_rpc_call(t, rpc_path, 'cell_field_set', { source_id: parent, name: 'priv_link', target_id: priv_child }, owner_h), CellFieldSetOutput);
+};
+/**
+ * Await in-flight fire-and-forget audit writes so a following `audit_log_list`
+ * is authoritative on both spines (the real await on Rust; satisfied by
+ * construction on the TS spine's `await_pending_effects`). Mirrors the
+ * `account_lifecycle` cross suite's barrier.
+ */
+const drain_effects = async (td, rpc_path, daemon_h) => {
+    const drained = await cross_rpc_call(td, rpc_path, '_testing_drain_effects', undefined, daemon_h);
+    assert.ok(drained.ok, `_testing_drain_effects failed: ${JSON.stringify(drained.error)}`);
+};
 export const describe_cell_relations_cross_tests = (options) => {
     const { setup_test, capabilities } = options;
     const rpc_path = options.rpc_path ?? SPINE_RPC_PATH;
@@ -225,5 +264,130 @@ export const describe_cell_relations_cross_tests = (options) => {
             assert.ok(!denied.ok, 'viewer read the audit timeline');
             assert.strictEqual(error_reason(denied), 'cell_not_found');
         });
+        test_if(capabilities.cell_relations, 'relation reads filter non-viewable targets (D8): anon sees only public children', async () => {
+            const fixture = await setup_test();
+            const owner = await fixture.create_account({ username: 'cell_relvis_owner' });
+            const t = fixture.fresh_transport();
+            const owner_h = owner.create_session_headers();
+            // A public parent linking one public + one private child, as both
+            // items and fields. The private child is owned by `owner`, so only
+            // `owner` (and admin) can view it.
+            const parent = await create_cell(t, rpc_path, owner_h, {
+                data: { kind: 'collection' },
+                visibility: 'public',
+            });
+            const pub_child = await create_cell(t, rpc_path, owner_h, {
+                data: { kind: 'note' },
+                visibility: 'public',
+            });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            await wire_children(t, rpc_path, owner_h, parent, pub_child, priv_child);
+            // Anonymous: only the public child surfaces in the bundle …
+            const anon = fixture.fresh_transport({ origin: null });
+            const bundle = expect_output(await cross_rpc_call(anon, rpc_path, 'cell_get', { id: parent }, {}), CellGetOutput);
+            assert.deepStrictEqual(bundle.items.map((i) => i.child_id), [pub_child], 'anon bundle leaked the private child item');
+            assert.deepStrictEqual(bundle.fields.map((f) => f.target_id), [pub_child], 'anon bundle leaked the private child field');
+            // … and in the forward paginating list verbs.
+            const items = expect_output(await cross_rpc_call(anon, rpc_path, 'cell_item_list', { parent_id: parent }, {}), CellItemListOutput);
+            assert.deepStrictEqual(items.items.map((i) => i.child_id), [pub_child], 'anon item_list leaked the private child');
+            const fields = expect_output(await cross_rpc_call(anon, rpc_path, 'cell_field_list', { source_id: parent }, {}), CellFieldListOutput);
+            assert.deepStrictEqual(fields.fields.map((f) => f.target_id), [pub_child], 'anon field_list leaked the private child');
+        });
+        test_if(capabilities.cell_relations, 'relation reads filter non-viewable targets (D8): viewer-grant sees only independently-viewable children', async () => {
+            const fixture = await setup_test();
+            const owner = await fixture.create_account({ username: 'cell_relvis_grant_owner' });
+            const viewer = await fixture.create_account({ username: 'cell_relvis_viewer' });
+            const t = fixture.fresh_transport();
+            const owner_h = owner.create_session_headers();
+            const viewer_h = viewer.create_session_headers();
+            // Private parent; one child the viewer will be granted, one they won't.
+            const parent = await create_cell(t, rpc_path, owner_h, { data: { kind: 'collection' } });
+            const shared_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            await wire_children(t, rpc_path, owner_h, parent, shared_child, priv_child);
+            // Grant the viewer on parent AND shared_child — but not priv_child.
+            for (const cell_id of [parent, shared_child]) {
+                expect_output(await cross_rpc_call(t, rpc_path, 'cell_grant_create', { cell_id, level: 'viewer', principal: { kind: 'actor', actor_id: viewer.actor.id } }, owner_h), CellGrantCreateOutput);
+            }
+            // The viewer can reach the parent, but its bundle exposes only the
+            // child they can independently view.
+            const bundle = expect_output(await cross_rpc_call(t, rpc_path, 'cell_get', { id: parent }, viewer_h), CellGetOutput);
+            assert.deepStrictEqual(bundle.items.map((i) => i.child_id), [shared_child], 'viewer bundle leaked the un-granted child item');
+            assert.deepStrictEqual(bundle.fields.map((f) => f.target_id), [shared_child], 'viewer bundle leaked the un-granted child field');
+        });
+        test_if(capabilities.cell_relations, 'clone D8: shallow drops edges to non-viewable children (no count leak)', async () => {
+            const fixture = await setup_test();
+            const owner = await fixture.create_account({ username: 'cell_clone_d8_owner' });
+            const cloner = await fixture.create_account({ username: 'cell_clone_d8_cloner' });
+            const t = fixture.fresh_transport();
+            const owner_h = owner.create_session_headers();
+            const cloner_h = cloner.create_session_headers();
+            // The keeper holds [keeper, admin], so its headers are the admin probe.
+            const admin_h = fixture.create_session_headers();
+            const parent = await create_cell(t, rpc_path, owner_h, {
+                data: { kind: 'collection' },
+                visibility: 'public',
+            });
+            const pub_child = await create_cell(t, rpc_path, owner_h, {
+                data: { kind: 'note' },
+                visibility: 'public',
+            });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            await wire_children(t, rpc_path, owner_h, parent, pub_child, priv_child);
+            // The cloner can read the public parent but not the private child.
+            const clone = expect_output(await cross_rpc_call(t, rpc_path, 'cell_clone', { source_id: parent }, cloner_h), CellCloneOutput).cell;
+            assert.strictEqual(clone.created_by, cloner.actor.id);
+            // The ADMIN can view the private child, so an admin read of the clone
+            // would surface the private edge if it had been copied — it must not.
+            const admin_items = expect_output(await cross_rpc_call(t, rpc_path, 'cell_item_list', { parent_id: clone.id }, admin_h), CellItemListOutput);
+            assert.deepStrictEqual(admin_items.items.map((i) => i.child_id), [pub_child], 'shallow clone copied the non-viewable item edge');
+            const admin_fields = expect_output(await cross_rpc_call(t, rpc_path, 'cell_field_list', { source_id: clone.id }, admin_h), CellFieldListOutput);
+            assert.deepStrictEqual(admin_fields.fields.map((f) => f.target_id), [pub_child], 'shallow clone copied the non-viewable field edge');
+            // No skipped-child count surfaced in the clone's audit row — the
+            // hidden child's existence must not leak to the cloner. (`_testing_reset`
+            // wiped audit_log at setup, so this is the only cell_clone event.)
+            const td = fixture.fresh_transport({ origin: null });
+            await drain_effects(td, rpc_path, fixture.create_daemon_token_headers());
+            const events = expect_output(await cross_rpc_call(t, rpc_path, 'audit_log_list', { event_type: 'cell_clone' }, admin_h), AuditLogListOutput).events;
+            const ev = events.find((e) => e.metadata?.new_id === clone.id);
+            assert.ok(ev, 'no cell_clone audit row for the shallow clone');
+            assert.strictEqual(ev.metadata.skipped_item_count, undefined, 'shallow clone leaked the hidden-child count via skipped_item_count');
+        });
+        test_if(capabilities.cell_relations, 'clone D8: deep silently skips non-viewable children (no count leak)', async () => {
+            const fixture = await setup_test();
+            const owner = await fixture.create_account({ username: 'cell_clone_d8_deep_owner' });
+            const cloner = await fixture.create_account({ username: 'cell_clone_d8_deep_cloner' });
+            const t = fixture.fresh_transport();
+            const owner_h = owner.create_session_headers();
+            const cloner_h = cloner.create_session_headers();
+            const admin_h = fixture.create_session_headers();
+            const parent = await create_cell(t, rpc_path, owner_h, {
+                data: { kind: 'collection' },
+                visibility: 'public',
+            });
+            const pub_child = await create_cell(t, rpc_path, owner_h, {
+                data: { kind: 'note' },
+                visibility: 'public',
+            });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            await wire_children(t, rpc_path, owner_h, parent, pub_child, priv_child);
+            const clone = expect_output(await cross_rpc_call(t, rpc_path, 'cell_clone', { source_id: parent, deep: true }, cloner_h), CellCloneOutput).cell;
+            // Deep clone copies viewable children into fresh cells; the
+            // non-viewable child is dropped. The admin (who can view everything)
+            // reading the clone still sees exactly one item — proving the private
+            // child was never cloned, not merely filtered from the cloner's view.
+            const admin_items = expect_output(await cross_rpc_call(t, rpc_path, 'cell_item_list', { parent_id: clone.id }, admin_h), CellItemListOutput);
+            assert.strictEqual(admin_items.items.length, 1, 'deep clone cloned the non-viewable child');
+            assert.notStrictEqual(admin_items.items[0].child_id, pub_child, 'deep clone reused the original child instead of cloning it');
+            const td = fixture.fresh_transport({ origin: null });
+            await drain_effects(td, rpc_path, fixture.create_daemon_token_headers());
+            const events = expect_output(await cross_rpc_call(t, rpc_path, 'audit_log_list', { event_type: 'cell_clone' }, admin_h), AuditLogListOutput).events;
+            const ev = events.find((e) => e.metadata?.new_id === clone.id);
+            assert.ok(ev, 'no cell_clone audit row for the deep clone');
+            const meta = ev.metadata;
+            assert.strictEqual(meta.deep, true);
+            assert.strictEqual(meta.item_count, 1, 'deep clone counted a non-viewable child');
+            assert.strictEqual(meta.skipped_item_count, undefined, 'deep clone leaked the hidden-child count via skipped_item_count');
+        });
     });
 };

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

@@ -307,6 +307,9 @@ export declare const testing_schema_snapshot_action_spec: {
         sequences: z.ZodRecord<z.ZodString, z.ZodObject<{
             data_type: z.ZodString;
         }, z.core.$strip>>;
+        enums: z.ZodRecord<z.ZodString, z.ZodObject<{
+            labels: z.ZodArray<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.";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAGvE,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;AAmBvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;QAiBpC;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWyC,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;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAeK,CAAC;AAE/C;;;;;;;;;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,CAqIjB,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;AAItB,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAGvE,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;AAmBvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;QAiBpC;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWyC,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;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAeK,CAAC;AAE/C;;;;;;;;;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,CAqIjB,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,UAAmC,CAAC"}

package/dist/testing/schema_introspect.d.ts

@@ -10,6 +10,9 @@ import './assert_dev_env.js';
  * - Constraints (CHECK, FOREIGN KEY, PRIMARY KEY, UNIQUE, EXCLUSION)
  * - Sequences with data type — distinguishes `int4` (SERIAL) from `int8`
  *   (BIGSERIAL)
+ * - Enum types (`CREATE TYPE ... AS ENUM`) with labels in declared order —
+ *   so a label set / ordering drift (e.g. `cell_visibility`) is a gated fact,
+ *   not invisible
  *
  * Designed for `pg_catalog` introspection — works against both PostgreSQL
  * and PGlite. The snapshot is fully deterministic: every collection sorts by
@@ -60,6 +63,16 @@ export declare const SequenceSnapshot: z.ZodObject<{
     data_type: z.ZodString;
 }, z.core.$strip>;
 export type SequenceSnapshot = z.infer<typeof SequenceSnapshot>;
+/**
+ * Enum-type metadata — the labels of a `CREATE TYPE ... AS ENUM`, captured in
+ * `pg_enum.enumsortorder` (declaration) order. Order is significant: a Postgres
+ * enum's labels are an ordered set, and reordering them is a schema change, so
+ * the parity diff compares the arrays positionally.
+ */
+export declare const EnumTypeSnapshot: z.ZodObject<{
+    labels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type EnumTypeSnapshot = z.infer<typeof EnumTypeSnapshot>;
 /**
  * Normalized database schema snapshot for parity comparison — the single
  * source of truth for the snapshot shape across the introspection query
@@ -91,6 +104,9 @@ export declare const SchemaSnapshot: z.ZodObject<{
     sequences: z.ZodRecord<z.ZodString, z.ZodObject<{
         data_type: z.ZodString;
     }, z.core.$strip>>;
+    enums: z.ZodRecord<z.ZodString, z.ZodObject<{
+        labels: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SchemaSnapshot = z.infer<typeof SchemaSnapshot>;
 /** Filter options for `query_schema_snapshot`. */

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;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;GAsBG;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;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;iBAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,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;AA8DD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CAyHxB,CAAC"}

package/dist/testing/schema_introspect.js

@@ -10,6 +10,9 @@ import './assert_dev_env.js';
  * - Constraints (CHECK, FOREIGN KEY, PRIMARY KEY, UNIQUE, EXCLUSION)
  * - Sequences with data type — distinguishes `int4` (SERIAL) from `int8`
  *   (BIGSERIAL)
+ * - Enum types (`CREATE TYPE ... AS ENUM`) with labels in declared order —
+ *   so a label set / ordering drift (e.g. `cell_visibility`) is a gated fact,
+ *   not invisible
  *
  * Designed for `pg_catalog` introspection — works against both PostgreSQL
  * and PGlite. The snapshot is fully deterministic: every collection sorts by
@@ -51,6 +54,16 @@ export const TableSnapshot = z.object({
 export const SequenceSnapshot = z.object({
     data_type: z.string(),
 });
+/**
+ * Enum-type metadata — the labels of a `CREATE TYPE ... AS ENUM`, captured in
+ * `pg_enum.enumsortorder` (declaration) order. Order is significant: a Postgres
+ * enum's labels are an ordered set, and reordering them is a schema change, so
+ * the parity diff compares the arrays positionally.
+ */
+export const EnumTypeSnapshot = z.object({
+    /** Enum labels in declared order. */
+    labels: z.array(z.string()),
+});
 /**
  * Normalized database schema snapshot for parity comparison — the single
  * source of truth for the snapshot shape across the introspection query
@@ -65,6 +78,8 @@ export const SchemaSnapshot = z.object({
     tables: z.record(z.string(), TableSnapshot),
     /** Sequences keyed by name. */
     sequences: z.record(z.string(), SequenceSnapshot),
+    /** Enum types (`CREATE TYPE ... AS ENUM`) keyed by name; labels in declared order. */
+    enums: z.record(z.string(), EnumTypeSnapshot),
 });
 const sort_keys = (record) => {
     const sorted = {};
@@ -145,6 +160,14 @@ export const query_schema_snapshot = async (db, options = {}) => {
 		 FROM information_schema.sequences
 		 WHERE sequence_schema = $1
 		 ORDER BY sequence_name ASC`, [schema]);
+    // Enum types — one row per label, ordered by enumsortorder so labels
+    // accumulate in declared order. Grouped client-side, mirroring columns.
+    const enum_rows = await db.query(`SELECT t.typname AS enum_name, e.enumlabel AS label
+		 FROM pg_type t
+		 JOIN pg_enum e ON e.enumtypid = t.oid
+		 JOIN pg_namespace n ON n.oid = t.typnamespace
+		 WHERE n.nspname = $1
+		 ORDER BY t.typname ASC, e.enumsortorder ASC`, [schema]);
     const tables = {};
     for (const name of table_names) {
         const columns = {};
@@ -178,8 +201,13 @@ export const query_schema_snapshot = async (db, options = {}) => {
     for (const row of sequence_rows) {
         sequences[row.sequence_name] = { data_type: row.data_type };
     }
+    const enums = {};
+    for (const row of enum_rows) {
+        (enums[row.enum_name] ??= { labels: [] }).labels.push(row.label);
+    }
     return {
         tables: sort_keys(tables),
         sequences: sort_keys(sequences),
+        enums: sort_keys(enums),
     };
 };

package/dist/testing/schema_parity.d.ts

@@ -20,7 +20,6 @@ import './assert_dev_env.js';
  *
  * Non-coverage — drift the gate does **not** detect:
  *
- * - enum types (`CREATE TYPE ... AS ENUM`)
  * - regular triggers (`pg_trigger`); `CONSTRAINT TRIGGER` is captured via
  *   pg_constraint, but standalone `CREATE TRIGGER` is not
  * - views, materialized views, functions, procedures
@@ -95,6 +94,15 @@ export type SchemaDiff = {
     readonly sequence: string;
     readonly a: string;
     readonly b: string;
+} | {
+    readonly kind: 'enum_only_in';
+    readonly where: 'a' | 'b';
+    readonly enum_name: string;
+} | {
+    readonly kind: 'enum_labels_differ';
+    readonly enum_name: string;
+    readonly a: ReadonlyArray<string>;
+    readonly b: ReadonlyArray<string>;
 };
 /**
  * Structural diff between two snapshots — empty array means parity holds.

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":"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"}
+{"version":3,"file":"schema_parity.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_parity.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EACX,cAAc,EAEd,cAAc,EAGd,MAAM,wBAAwB,CAAC;AAEhC,6EAA6E;AAC7E,MAAM,MAAM,UAAU,GACnB;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,GACD;IAAC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAC,GACtF;IACA,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC,QAAQ,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,GAAG,cAAc,EAAE,GAAG,cAAc,KAAG,KAAK,CAAC,UAAU,CAiD5F,CAAC;AAqHF,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,MA4DF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,6BAA6B,GACzC,GAAG,cAAc,EACjB,GAAG,cAAc,EACjB,SAAQ,gBAAqB,KAC3B,IAQF,CAAC"}

package/dist/testing/schema_parity.js

@@ -36,6 +36,20 @@ export const diff_schema_snapshots = (a, b) => {
         }
         diff_sequence(sequence, sa, sb, diffs);
     }
+    const all_enums = new Set([...Object.keys(a.enums), ...Object.keys(b.enums)]);
+    for (const enum_name of [...all_enums].sort()) {
+        const ea = a.enums[enum_name];
+        const eb = b.enums[enum_name];
+        if (!ea) {
+            diffs.push({ kind: 'enum_only_in', where: 'b', enum_name });
+            continue;
+        }
+        if (!eb) {
+            diffs.push({ kind: 'enum_only_in', where: 'a', enum_name });
+            continue;
+        }
+        diff_enum(enum_name, ea, eb, diffs);
+    }
     return diffs;
 };
 const COLUMN_FIELDS = [
@@ -124,6 +138,14 @@ const diff_sequence = (sequence, a, b, out) => {
         });
     }
 };
+const diff_enum = (enum_name, a, b, out) => {
+    // Labels are an ordered set — compare positionally, so both a missing/extra
+    // label and a reorder (a real schema change) surface as drift.
+    const differ = a.labels.length !== b.labels.length || a.labels.some((l, i) => l !== b.labels[i]);
+    if (differ) {
+        out.push({ kind: 'enum_labels_differ', enum_name, a: a.labels, b: b.labels });
+    }
+};
 /**
  * Render a diff list as a human-readable multi-line string. Empty diffs
  * produce an empty string.
@@ -164,6 +186,12 @@ export const format_schema_diffs = (diffs, labels = {}) => {
             case 'sequence_data_type_differs':
                 lines.push(`  sequence ${d.sequence} data_type differs: ${label_a}=${d.a}, ${label_b}=${d.b}`);
                 break;
+            case 'enum_only_in':
+                lines.push(`  enum ${d.enum_name} only in ${where_label(d.where)}`);
+                break;
+            case 'enum_labels_differ':
+                lines.push(`  enum ${d.enum_name} labels differ: ${label_a}=${JSON.stringify(d.a)}, ${label_b}=${JSON.stringify(d.b)}`);
+                break;
             default:
                 // Compile-time exhaustiveness — a new SchemaDiff variant without a
                 // case here makes `d` non-never and fails type-check.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.80.0",
+  "version": "0.81.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",
@@ -16,6 +16,7 @@
     "test": "gro test",
     "test:cross": "FUZ_TEST_CROSS_BACKEND=1 vitest run --project cross_backend_ts_node --project cross_backend_ts_deno --project cross_backend_ts_bun",
     "test:cross:spine-stub": "FUZ_TEST_CROSS_BACKEND=1 vitest run --project cross_backend_spine_stub",
+    "test:cross:schema-parity": "FUZ_TEST_CROSS_BACKEND=1 vitest run --project cross_backend_schema_parity",
     "benchmark:cross-impl": "gro run src/benchmarks/cross_impl.bench.ts",
     "preview": "vite preview",
     "deploy": "gro deploy"