@fuzdev/fuz_app 0.69.0 → 0.71.0

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.69.0",
+  "version": "0.71.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",