@voltro/testing 0.85.0 → 0.87.0

package/dist/dialect.js

@@ -1,81 +1,83 @@
-import { _voltroMigrationPlansTable as e, array as t, boolean as n, bulkInsertLimitsFor as r, dbEnum as i, decimal as a, dropped as o, eq as s, id as c, integer as l, json as u, reference as d, registerTable as f, registerWriteRecorder as p, runWithWriteAttribution as m, table as h, text as g, timestamp as _, unregisterTable as v, unregisterWriteRecorder as y } from "@voltro/database";
-import { Effect as b } from "effect";
-import { _voltroUndoLogTable as x, applyInverses as S, makeSchemaRegistry as C, synthesizeInverse as w, wrapStoreWithMixinBehaviour as T } from "@voltro/runtime";
-import { afterEach as E, beforeEach as D, describe as O, expect as k, it as A } from "vitest";
-import { SqlClient as j } from "effect/sql";
-import { applyPlan as M, applySchema as N, declaredSnapshot as P, fingerprintSchema as F, introspectSchema as I, planMigrations as L } from "@voltro/database/sql";
+import { runHotStoreSqlParity as e } from "./hotStoreSqlParity.js";
+import { _voltroMigrationPlansTable as t, array as n, avg as r, boolean as i, bulkInsertLimitsFor as a, ciphertextKeyId as o, column as s, count as c, countDistinct as l, dbEnum as u, decimal as d, dropped as f, eq as p, fieldBinding as m, id as h, integer as g, json as _, max as v, min as ee, real as y, reference as te, registerTable as b, registerWriteRecorder as x, runWithWriteAttribution as ne, sum as S, table as C, text as w, timestamp as T, unregisterTable as E, unregisterWriteRecorder as re } from "@voltro/database";
+import { Effect as D } from "effect";
+import { FIELD_KEYS_TABLE as O, FIELD_KEY_HOLDERS_TABLE as k, FieldKeyringRefusal as A, _voltroFieldKeyHoldersTable as j, _voltroFieldKeysTable as M, _voltroUndoLogTable as ie, applyInverses as N, deriveKey as ae, getFieldCipher as oe, heartbeatFieldKeys as se, makeAesCipher as ce, makeFieldKeyring as P, makeSchemaRegistry as F, readFieldKeys as I, releaseFieldKeyHolder as le, setFieldCipher as L, synthesizeInverse as R, verifyFieldKeyring as z, wrapStoreWithMixinBehaviour as B } from "@voltro/runtime";
+import { afterEach as ue, beforeEach as de, describe as V, expect as H, it as U } from "vitest";
+import { randomUUID as W } from "node:crypto";
+import { SqlClient as G } from "effect/sql";
+import { applyPlan as K, applySchema as q, declaredSnapshot as fe, fingerprintSchema as pe, introspectSchema as J, planMigrations as Y } from "@voltro/database/sql";
 //#region src/dialectParity.ts
-var R = (e) => ({
+var X = (e) => ({
 	table: e,
 	predicate: void 0,
 	order: [],
 	take: void 0,
 	skip: void 0,
 	projection: void 0
-}), z = h("voltro_parity_a", {
-	id: c(),
-	title: g(),
-	count: l()
-}), B = h("voltro_parity_b", {
-	id: c(),
-	title: g()
-}), V = h("voltro_parity_c", {
-	id: c(),
-	title: g(),
-	count: l(),
-	flag: n().default(!1)
-}), H = h("voltro_parity_d", {
-	id: c(),
-	title: g(),
-	at: _().nullable().onUpdate("now"),
-	n: l().nullable()
-}), U = h("voltro_parity_upsert", {
-	id: c(),
-	teamId: g(),
-	year: l(),
-	hours: l().nullable()
-}).unique("byTeamYear", ["teamId", "year"]), W = h("voltro_parity_values", {
-	id: c(),
-	title: g().onUpdate(() => "automatic"),
-	metadata: u().nullable(),
-	labels: t(g()).nullable()
+}), me = C("voltro_parity_a", {
+	id: h(),
+	title: w(),
+	count: g()
+}), he = C("voltro_parity_b", {
+	id: h(),
+	title: w()
+}), ge = C("voltro_parity_c", {
+	id: h(),
+	title: w(),
+	count: g(),
+	flag: i().default(!1)
+}), _e = C("voltro_parity_d", {
+	id: h(),
+	title: w(),
+	at: T().nullable().onUpdate("now"),
+	n: g().nullable()
+}), ve = C("voltro_parity_upsert", {
+	id: h(),
+	teamId: w(),
+	year: g(),
+	hours: g().nullable()
+}).unique("byTeamYear", ["teamId", "year"]), Z = C("voltro_parity_values", {
+	id: h(),
+	title: w().onUpdate(() => "automatic"),
+	metadata: _().nullable(),
+	labels: n(w()).nullable()
 });
-f(W);
-var G = h("voltro_parity_json_names", {
-	id: c(),
-	key: u(),
-	value: u()
+b(Z);
+var Q = C("voltro_parity_json_names", {
+	id: h(),
+	key: _(),
+	value: _()
 });
-f(G);
-var K = h("voltro_parity_composite", {
-	userId: g(),
-	orgId: g(),
-	role: g()
-}).primaryKey(["userId", "orgId"]), q = h("voltro_parity_bulk", {
-	id: c(),
-	title: g(),
-	count: l(),
-	flag: n().default(!1)
-}), J = (e) => {
-	let t = r(e);
+b(Q);
+var ye = C("voltro_parity_composite", {
+	userId: w(),
+	orgId: w(),
+	role: w()
+}).primaryKey(["userId", "orgId"]), be = C("voltro_parity_bulk", {
+	id: h(),
+	title: w(),
+	count: g(),
+	flag: i().default(!1)
+}), xe = (e) => {
+	let t = a(e);
 	if (t === void 0) return 0;
-	let n = Object.keys(q.fields).length;
+	let n = Object.keys(be.fields).length;
 	return Math.max(1, Math.min(Math.floor(t.maxBindParameters / n), t.maxRowsPerStatement ?? Infinity));
-}, Y = (n) => {
-	O(`dialect parity: ${n.name ?? n.dialect.id}`, () => {
-		let r = null;
-		D(async () => {
-			await n.setup(), r = await n.make(), await r.migrate([
-				z,
-				B,
-				V,
-				H,
-				q,
-				U,
-				K,
-				W,
-				G,
-				x
+}, $ = (e) => {
+	V(`dialect parity: ${e.name ?? e.dialect.id}`, () => {
+		let a = null;
+		de(async () => {
+			await e.setup(), a = await e.make(), await a.migrate([
+				me,
+				he,
+				ge,
+				_e,
+				be,
+				ve,
+				ye,
+				Z,
+				Q,
+				ie
 			]);
 			for (let e of [
 				"voltro_parity_a",
@@ -87,487 +89,883 @@ var K = h("voltro_parity_composite", {
 				"voltro_parity_json_names",
 				"_voltro_undo_log"
 			]) {
-				let t = await r.store.query(R(e));
-				for (let n of t) await r.store.delete(e, n.id);
+				let t = await a.store.query(X(e));
+				for (let n of t) await a.store.delete(e, n.id);
 			}
-			for (let e of await r.store.query(R("voltro_parity_composite"))) await r.store.delete("voltro_parity_composite", {
+			for (let e of await a.store.query(X("voltro_parity_composite"))) await a.store.delete("voltro_parity_composite", {
 				userId: e.userId,
 				orgId: e.orgId
 			});
-		}), E(async () => {
-			v("voltro_parity_evolve"), await r?.dispose(), await n.teardown(), r = null;
-		}), A("rename-table: the rows move, and the plan converges", async () => {
-			let t = "voltro_rename_src", i = "_voltro_rename_dst", a = r.run, o = async () => {
-				await a(b.gen(function* () {
-					let e = yield* j.SqlClient;
-					for (let n of [i, t]) yield* b.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${n}`), () => []);
+		}), ue(async () => {
+			E("voltro_parity_evolve"), await a?.dispose(), await e.teardown(), a = null;
+		}), V.each(["direct", "transactional"])("numeric and audit write contracts (%s)", (t) => {
+			let n = (e, n) => t === "transactional" ? e.transactional(n) : n(e), u = (e) => a.run(D.gen(function* () {
+				yield* (yield* G.SqlClient).unsafe(`DROP TABLE IF EXISTS ${e}`);
+			}));
+			U("aggregates return the types their declarations name", async () => {
+				let e = `voltro_aggtypes_${W().replaceAll("-", "").slice(0, 12)}`, t = C(e, {
+					id: h(),
+					title: w().maxLength(100),
+					entries: g(),
+					score: y(),
+					amount: d(10, 2)
+				}).nonReactive();
+				b(t);
+				try {
+					await a.migrate([t]);
+					let i = {
+						title: s("title"),
+						n: c(),
+						d: l("entries"),
+						total: S("entries"),
+						money: S("amount"),
+						mean: r("score"),
+						most: v("entries"),
+						least: ee("amount")
+					}, o = await n(a.store, (t) => t.query({
+						...X(e),
+						aggregations: Object.entries({
+							n: c(),
+							total: S("entries")
+						}).map(([e, t]) => ({
+							...t,
+							alias: e
+						}))
+					}));
+					H(o).toEqual([{
+						n: 0,
+						total: null
+					}]), await n(a.store, async (t) => {
+						await t.insert(e, {
+							id: "agg_1",
+							title: "a",
+							entries: 3,
+							score: 1.5,
+							amount: "2.25"
+						}), await t.insert(e, {
+							id: "agg_2",
+							title: "a",
+							entries: 4,
+							score: 2.5,
+							amount: "3.25"
+						});
+					});
+					let u = await n(a.store, (t) => t.query({
+						...X(e),
+						groupBy: ["title"],
+						aggregations: Object.entries(i).map(([e, t]) => ({
+							...t,
+							alias: e
+						}))
+					}));
+					H(u).toHaveLength(1);
+					let d = u[0];
+					H(d).toMatchObject({
+						title: "a",
+						n: 2,
+						d: 2,
+						total: 7,
+						mean: 2,
+						most: 4
+					});
+					for (let e of [
+						"n",
+						"d",
+						"total",
+						"mean",
+						"most"
+					]) H(typeof d[e], e).toBe("number");
+					H(d.money).toBe("5.50"), H(d.least).toBe("2.25");
+				} finally {
+					E(t.tableName), await u(e);
+				}
+			}), U("insertMany { returning: 'none' } writes every row, resolves to [] and keeps change events", async () => {
+				let t = W().replaceAll("-", "").slice(0, 12), r = `voltro_quiet_${t}`, o = `voltro_loud_${t}`, s = {
+					id: h(),
+					title: w(),
+					count: g(),
+					flag: i().default(!1)
+				}, c = C(r, s).nonReactive(), l = C(o, s);
+				b(c), b(l);
+				try {
+					await a.migrate([c, l]);
+					let i = xe(e.dialect.id) + 5, s = (e, t) => Array.from({ length: t }, (t, n) => ({
+						id: `${e.slice(7, 12)}_${String(n).padStart(6, "0")}`,
+						title: `row ${n}`,
+						count: n,
+						flag: n % 2 == 0
+					}));
+					H(await n(a.store, (e) => e.insertMany(r, s(r, i), { returning: "none" }))).toEqual([]);
+					let u = await a.store.query(X(r));
+					H(u).toHaveLength(i), H(u.find((e) => e.id === `${r.slice(7, 12)}_000007`)).toMatchObject({
+						count: 7,
+						flag: !1
+					});
+					let d = [], f = a.store.onChange((e) => {
+						e.table === o && e.op === "insert" && d.push(e.new);
+					});
+					try {
+						H(await n(a.store, (e) => e.insertMany(o, s(o, 3), { returning: "none" }))).toEqual([]);
+						for (let e = 0; d.length < 3 && e < 5e3; e += 50) await new Promise((e) => setTimeout(e, 50));
+						H(d.map((e) => e?.count).sort()).toEqual([
+							0,
+							1,
+							2
+						]);
+					} finally {
+						f();
+					}
+					let p = await n(a.store, (e) => e.insertMany(o, [{
+						id: `${t}_ctl`,
+						title: "control",
+						count: 9
+					}]));
+					H(p).toHaveLength(1), H(p[0]).toMatchObject({
+						id: `${t}_ctl`,
+						count: 9
+					});
+				} finally {
+					E(r), E(o), await u(r), await u(o);
+				}
+			}, 12e4), U(".encrypted() values name their key, old values still read, and a key change keeps both readable", async () => {
+				let e = `voltro_keyed_${W().replaceAll("-", "").slice(0, 12)}`, t = C(e, {
+					id: h({ prefix: "sec" }),
+					token: w().encrypted()
+				}).nonReactive();
+				b(t);
+				let r = oe(), i = "a".repeat(64), s = "b".repeat(64);
+				try {
+					await a.migrate([t]);
+					let r = F([{
+						tableName: t.tableName,
+						fields: t.fields
+					}]), c = B(a.store, {
+						subject: {
+							type: "user",
+							id: "keyed",
+							tenantId: "org_keyed"
+						},
+						schemaRegistry: r
+					}), l = async (t) => (await a.store.query({
+						...X(e),
+						predicate: p("id", t)
+					}))[0]?.token;
+					L(P({
+						active: "k2026a",
+						keys: [{
+							id: "k2026a",
+							secret: i
+						}]
+					}));
+					let u = await n(c, (t) => t.insert(e, {
+						id: "sec_first",
+						token: "pat-first"
+					}));
+					H(u.token).toBe("pat-first"), H(o(await l("sec_first"))).toBe("k2026a");
+					let d = ce(ae(i)).encrypt(JSON.stringify("pat-legacy"), m(e, "token", "sec_legacy"));
+					await a.store.insert(e, {
+						id: "sec_legacy",
+						token: d
+					}), H(o(await l("sec_legacy"))).toBeUndefined(), L(P({
+						active: "k2027",
+						keys: [{
+							id: "k2027",
+							secret: s
+						}, {
+							id: "k2026a",
+							secret: i
+						}]
+					}));
+					let f = await n(c, (t) => t.query(X(e)));
+					H(Object.fromEntries(f.map((e) => [e.id, e.token]))).toEqual({
+						sec_first: "pat-first",
+						sec_legacy: "pat-legacy"
+					}), await n(c, (t) => t.update(e, "sec_first", { token: "pat-rotated" })), H(o(await l("sec_first"))).toBe("k2027"), H((await n(c, (t) => t.query(X(e)))).find((e) => e.id === "sec_first")?.token).toBe("pat-rotated");
+				} finally {
+					L(r), E(e), await u(e);
+				}
+			}), U("the boot check refuses a wrong key, a key under a registered id and a missing key; racing activations leave one active key", async () => {
+				let e = `voltro_keycheck_${W().replaceAll("-", "").slice(0, 12)}`, t = C(e, {
+					id: h({ prefix: "sec" }),
+					token: w().encrypted()
+				}).nonReactive();
+				b(t), b(M), b(j);
+				let r = oe(), i = "c".repeat(64), o = "d".repeat(64), s = "e".repeat(64), c = (e, t) => P({
+					active: e,
+					keys: t.map(([e, t]) => ({
+						id: e,
+						secret: t
+					}))
+				}), l = async (e) => {
+					let t = await e.then(() => void 0, (e) => e);
+					return H(t).toBeInstanceOf(A), t.message;
+				};
+				try {
+					await u(O), await u(k), await a.migrate([
+						t,
+						M,
+						j
+					]);
+					let r = { holderId: "parity-app" }, d = F([{
+						tableName: t.tableName,
+						fields: t.fields
+					}]), f = B(a.store, {
+						subject: {
+							type: "user",
+							id: "keycheck",
+							tenantId: "org_keycheck"
+						},
+						schemaRegistry: d
+					});
+					L(c("ka", [["ka", i]]));
+					for (let t of [
+						"sec_1",
+						"sec_2",
+						"sec_3"
+					]) await n(f, (n) => n.insert(e, {
+						id: t,
+						token: `pat-${t}`
+					}));
+					H(await l(z(a.store, c("ka", [["ka", o]]), [t], r))).toContain(`${e}.token`), H(await I(a.store)).toEqual([]), H(await z(a.store, c("ka", [["ka", i]]), [t], r)).toMatchObject({
+						active: "ka",
+						registered: ["ka"]
+					}), H(await l(z(a.store, c("ka", [["ka", o]]), [], r))).toContain("is not the key this database registered as \"ka\""), await z(a.store, c("ka", [
+						["ka", i],
+						["kb", o],
+						["kc", s]
+					]), [t], r), await Promise.all([z(a.store, c("kb", [
+						["kb", o],
+						["ka", i],
+						["kc", s]
+					]), [t], { holderId: "parity-b" }), z(a.store, c("kc", [
+						["kc", s],
+						["ka", i],
+						["kb", o]
+					]), [t], { holderId: "parity-c" })]);
+					let p = await I(a.store);
+					H(p.filter((e) => e.state === "active"), JSON.stringify(p)).toHaveLength(1);
+					let m = p.find((e) => e.state === "active").keyId;
+					H(await l(z(a.store, c("ka", [["ka", i]]), [t], r))).toContain(`"${m}" (active)`), L(c(m, [
+						["ka", i],
+						["kb", o],
+						["kc", s]
+					])), H((await n(f, (t) => t.query(X(e)))).map((e) => e.token).sort()).toEqual([
+						"pat-sec_1",
+						"pat-sec_2",
+						"pat-sec_3"
+					]);
+				} finally {
+					L(r), E(e), E(O), E(k), await u(e), await u(O), await u(k);
+				}
+			}), U("a requested key waits for a live process that lacks it; a boot racing the activation is waited for or refused", async () => {
+				b(M), b(j);
+				let e = oe(), t = "f".repeat(64), n = "1".repeat(64), r = (e, t) => P({
+					active: e,
+					keys: t.map(([e, t]) => ({
+						id: e,
+						secret: t
+					}))
+				}), i = Date.parse("2026-10-30T10:00:00Z"), s = (e) => ({
+					holderId: e,
+					leaseMs: 3e4,
+					now: () => i
+				}), c = async () => {
+					await u(O), await u(k), await a.migrate([M, j]);
+				};
+				try {
+					await c();
+					let e = r("ka", [["ka", t]]);
+					await z(a.store, e, [], s("old"));
+					let l = r("kb", [["kb", n], ["ka", t]]);
+					H(await z(a.store, l, [], s("new"))).toMatchObject({
+						active: "ka",
+						waiting: {
+							keyId: "kb",
+							holders: ["old"]
+						}
+					}), H(o(l.encrypt("x"))).toBe("ka"), i += 1e4, H((await se(a.store, e, s("old"))).active).toBe("ka"), H((await se(a.store, l, s("new"))).active).toBe("ka"), i += 31e3, H(await se(a.store, l, s("new"))).toMatchObject({
+						active: "kb",
+						activated: {
+							from: "ka",
+							to: "kb"
+						}
+					}), H((await I(a.store)).map((e) => [e.keyId, e.state]).sort()).toEqual([["ka", "decrypt-only"], ["kb", "active"]]), await le(a.store, "new");
+					for (let e = 0; e < 4; e++) {
+						await c(), await z(a.store, r("ka", [["ka", t]]), [], s("seed")), await le(a.store, "seed");
+						let [i, o] = await Promise.allSettled([z(a.store, r("ka", [["ka", t]]), [], s("late")), z(a.store, r("kb", [["kb", n], ["ka", t]]), [], s("rotating"))]);
+						H(o.status).toBe("fulfilled");
+						let l = (await I(a.store)).find((e) => e.state === "active")?.keyId;
+						i.status === "fulfilled" ? H(l, `round ${e}: a live process without kb, and kb active`).toBe("ka") : H(String(i.reason.message), `round ${e}`).toContain("\"kb\" (active), which this process does not hold");
+					}
+				} finally {
+					L(e), E(O), E(k), await u(O), await u(k);
+				}
+			}), U("returns numeric ids consistently and accepts them for tenant-scoped keyed writes", async () => {
+				let e = `voltro_numeric_${W().replaceAll("-", "").slice(0, 12)}`, t = C(e, {
+					id: h({ scheme: "numeric" }),
+					tenantId: w().maxLength(100),
+					title: w().maxLength(100),
+					metadata: _()
+				}).nonReactive();
+				b(t);
+				try {
+					await a.migrate([t]);
+					let r = F([{
+						tableName: t.tableName,
+						fields: t.fields,
+						appliedMixins: [{ id: "voltro/tenant" }]
+					}]), i = (e) => B(a.store, {
+						subject: {
+							type: "user",
+							id: "numeric_writer",
+							tenantId: e
+						},
+						schemaRegistry: r
+					});
+					await n(i("owner"), async (t) => {
+						for (let n of [
+							"update",
+							"patchJson",
+							"delete"
+						]) {
+							let r = await t.insert(e, {
+								title: n,
+								metadata: {}
+							});
+							H(typeof r.id).toBe("number"), H(Number.isSafeInteger(r.id)).toBe(!0), n === "update" ? H(await t.update(e, r.id, { title: "edited" })).toMatchObject({
+								id: r.id,
+								title: "edited"
+							}) : n === "patchJson" ? H(await t.patchJson(e, r.id, "metadata.seen", !0)).toMatchObject({
+								id: r.id,
+								metadata: { seen: !0 }
+							}) : H(await t.delete(e, r.id)).toBe(!0);
+						}
+						let n = await t.query(X(e));
+						H(n).toHaveLength(2), H(n.every((e) => typeof e.id == "number")).toBe(!0);
+					});
+					let [o] = await a.store.query(X(e));
+					await H(i("other").update(e, o.id, { title: "stolen" })).rejects.toMatchObject({ _tag: "TenantRowNotFound" });
+				} finally {
+					E(e), await u(e);
+				}
+			}), U("preserves creation stamps during default audited upserts and still stamps updates", async () => {
+				let e = `voltro_audit_${W().replaceAll("-", "").slice(0, 12)}`, t = C(e, {
+					id: h({ prefix: "audit" }),
+					externalId: w().maxLength(100).unique(),
+					value: w(),
+					createdAt: T(),
+					createdBy: w().nullable(),
+					updatedAt: T(),
+					updatedBy: w().nullable()
+				}).nonReactive();
+				b(t);
+				try {
+					await a.migrate([t]);
+					let r = F([{
+						tableName: t.tableName,
+						fields: t.fields,
+						appliedMixins: [{ id: "voltro/audit" }]
+					}]), i = B(a.store, {
+						subject: {
+							type: "user",
+							id: "editor",
+							tenantId: "audit_scope"
+						},
+						schemaRegistry: r
+					}), o = /* @__PURE__ */ new Date("2026-01-01T00:00:00Z");
+					await n(i, async (t) => {
+						for (let n of ["upsert", "upsertWithOutcome"]) {
+							await t.insert(e, {
+								externalId: n,
+								value: "before",
+								createdAt: o,
+								createdBy: "creator",
+								updatedAt: o
+							});
+							let r = n === "upsert" ? await t.upsert(e, {
+								externalId: n,
+								value: "after"
+							}, { conflictColumns: ["externalId"] }) : (await t.upsertWithOutcome(e, {
+								externalId: n,
+								value: "after"
+							}, { conflictColumns: ["externalId"] })).row;
+							H(r).toMatchObject({
+								value: "after",
+								createdBy: "creator",
+								updatedBy: "editor"
+							}), H(new Date(String(r.createdAt)).toISOString()).toBe(o.toISOString()), H(new Date(String(r.updatedAt)).getTime()).toBeGreaterThan(o.getTime());
+						}
+					});
+				} finally {
+					E(e), await u(e);
+				}
+			});
+		}), U("rename-table: the rows move, and the plan converges", async () => {
+			let n = "voltro_rename_src", r = "_voltro_rename_dst", i = a.run, o = async () => {
+				await i(D.gen(function* () {
+					let e = yield* G.SqlClient;
+					for (let t of [r, n]) yield* D.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${t}`), () => []);
 				})).catch(() => {});
-			}, s = () => a(b.gen(function* () {
-				let e = yield* j.SqlClient, n = yield* I(e);
+			}, s = () => i(D.gen(function* () {
+				let e = yield* G.SqlClient, t = yield* J(e);
 				return {
-					...n,
-					tables: n.tables.filter((e) => e.name === t || e.name === i)
+					...t,
+					tables: t.tables.filter((e) => e.name === n || e.name === r)
 				};
-			})), l = async () => L({
-				declared: [d],
+			})), c = async () => Y({
+				declared: [u],
 				live: await s(),
-				dialect: n.dialect.id
+				dialect: e.dialect.id
 			});
 			await o();
-			let u = h(t, {
-				id: c({ prefix: "rn" }),
-				title: g()
-			}), d = h(i, {
-				id: c({ prefix: "rn" }),
-				title: g()
-			}).renamedFrom(t);
-			await r.migrate([u, e]), await r.store.insert(t, {
+			let l = C(n, {
+				id: h({ prefix: "rn" }),
+				title: w()
+			}), u = C(r, {
+				id: h({ prefix: "rn" }),
+				title: w()
+			}).renamedFrom(n);
+			await a.migrate([l, t]), await a.store.insert(n, {
 				id: "rn_1",
 				title: "one"
-			}), await r.store.insert(t, {
+			}), await a.store.insert(n, {
 				id: "rn_2",
 				title: "two"
 			});
-			let f = await l();
-			k(f.operations.some((e) => e.op.kind === "rename-table"), "the marker must fold").toBe(!0), k(f.operations.filter((e) => e.blocked !== void 0), "nothing may be blocked").toEqual([]), await a(b.gen(function* () {
-				let e = yield* j.SqlClient;
-				return yield* M(e, f, {
-					declared: [d],
+			let d = await c();
+			H(d.operations.some((e) => e.op.kind === "rename-table"), "the marker must fold").toBe(!0), H(d.operations.filter((e) => e.blocked !== void 0), "nothing may be blocked").toEqual([]), await i(D.gen(function* () {
+				let e = yield* G.SqlClient;
+				return yield* K(e, d, {
+					declared: [u],
 					appliedBy: "dialect-parity",
 					environment: "dev",
 					source: "auto-diff",
-					replan: () => b.promise(l)
+					replan: () => D.promise(c)
 				});
 			}));
-			let p = await r.store.query(R(i));
-			k(p.map((e) => e.id).sort(), "every row survived the rename").toEqual(["rn_1", "rn_2"]), k((await l()).operations, `${n.dialect.id}: the plan must converge`).toEqual([]), await o();
-		}), A("schema evolution: create → add column → add index → drop column, converging at each step", async () => {
-			let t = "voltro_parity_evolve", s = r.run, u = async () => {
-				await s(b.gen(function* () {
-					let e = yield* j.SqlClient;
-					yield* b.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${t}`), () => []), yield* b.orElseSucceed(e.unsafe("DROP TYPE IF EXISTS ev_status"), () => []), yield* b.orElseSucceed(e.unsafe("DELETE FROM _voltro_migration_ops"), () => []);
+			let f = await a.store.query(X(r));
+			H(f.map((e) => e.id).sort(), "every row survived the rename").toEqual(["rn_1", "rn_2"]), H((await c()).operations, `${e.dialect.id}: the plan must converge`).toEqual([]), await o();
+		}), U("schema evolution: create → add column → add index → drop column, converging at each step", async () => {
+			let n = "voltro_parity_evolve", r = a.run, i = async () => {
+				await r(D.gen(function* () {
+					let e = yield* G.SqlClient;
+					yield* D.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${n}`), () => []), yield* D.orElseSucceed(e.unsafe("DROP TYPE IF EXISTS ev_status"), () => []), yield* D.orElseSucceed(e.unsafe("DELETE FROM _voltro_migration_ops"), () => []);
 				})).catch(() => {});
-			}, p = () => s(b.gen(function* () {
-				let e = yield* j.SqlClient, n = yield* I(e);
+			}, o = () => r(D.gen(function* () {
+				let e = yield* G.SqlClient, t = yield* J(e);
 				return {
-					...n,
-					tables: n.tables.filter((e) => e.name === t)
-				};
-			})), m = async (e) => L({
-				declared: e,
-				live: await p(),
-				dialect: n.dialect.id
-			}), y = async () => (await p()).tables[0]?.columns.map((e) => e.name) ?? [], x = async (e, r) => {
-				let i = await m(e);
-				r && k(i.operations.length, `${n.dialect.id}: nothing to apply — the step asserts nothing`).toBeGreaterThan(0), k(i.operations.filter((e) => e.blocked !== void 0), `${n.dialect.id}: nothing may be blocked`).toEqual([]);
-				let a = () => {
-					for (let t of e) v(t.tableName), f(t);
+					...t,
+					tables: t.tables.filter((e) => e.name === n)
 				};
-				if (i.operations.length === 0) {
-					a();
-					return;
-				}
-				await s(b.gen(function* () {
-					let r = yield* j.SqlClient;
-					return yield* M(r, i, {
-						declared: e,
+			})), s = async (t) => Y({
+				declared: t,
+				live: await o(),
+				dialect: e.dialect.id
+			}), c = async () => (await o()).tables[0]?.columns.map((e) => e.name) ?? [], l = async (t, i) => {
+				let a = await s(t);
+				i && H(a.operations.length, `${e.dialect.id}: nothing to apply — the step asserts nothing`).toBeGreaterThan(0), H(a.operations.filter((e) => e.blocked !== void 0), `${e.dialect.id}: nothing may be blocked`).toEqual([]), a.operations.length === 0 || (await r(D.gen(function* () {
+					let r = yield* G.SqlClient;
+					return yield* K(r, a, {
+						declared: t,
 						appliedBy: "dialect-parity",
 						environment: "dev",
 						source: "auto-diff",
-						replan: (r) => b.map(I(r), (r) => L({
-							declared: e,
+						replan: (r) => D.map(J(r), (r) => Y({
+							declared: t,
 							live: {
 								...r,
-								tables: r.tables.filter((e) => e.name === t)
+								tables: r.tables.filter((e) => e.name === n)
 							},
-							dialect: n.dialect.id
+							dialect: e.dialect.id
 						}))
 					});
-				})), k((await m(e)).operations, `${n.dialect.id}: the plan must converge`).toEqual([]), a();
+				})), H((await s(t)).operations, `${e.dialect.id}: the plan must converge`).toEqual([])), (() => {
+					for (let e of t) E(e.tableName), b(e);
+				})();
 			};
-			await u(), await r.migrate([e]), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g()
-			})], !0), k(await y(), `${n.dialect.id}: v1 columns`).toEqual(["id", "name"]), await r.store.insert(t, {
+			await i(), await a.migrate([t]), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w()
+			})], !0), H(await c(), `${e.dialect.id}: v1 columns`).toEqual(["id", "name"]), await a.store.insert(n, {
 				id: "ev_1",
 				name: "one"
-			}), await r.store.insert(t, {
+			}), await a.store.insert(n, {
 				id: "ev_2",
 				name: "two"
-			}), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				qty: l().nullable()
-			})], !0), k(await y()).toContain("qty"), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				qty: l().nullable()
-			}).index(["qty"])], !0), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				qty: o()
-			})], !0), k(await y(), `${n.dialect.id}: v4 columns`).toEqual(["id", "name"]);
-			let S = n.dialect.id === "sqlite" || n.dialect.id === "turso", C = h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: a(10, 2).nullable()
+			}), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				qty: g().nullable()
+			})], !0), H(await c()).toContain("qty"), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				qty: g().nullable()
+			}).index(["qty"])], !0), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				qty: f()
+			})], !0), H(await c(), `${e.dialect.id}: v4 columns`).toEqual(["id", "name"]);
+			let p = e.dialect.id === "sqlite" || e.dialect.id === "turso", m = C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: d(10, 2).nullable()
 			});
-			await x([C], !0), await r.store.insert(t, {
+			await l([m], !0), await a.store.insert(n, {
 				id: "ev_3",
 				name: "three",
 				amount: "12.34"
 			});
-			let w = h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: a(12, 4).nullable()
+			let _ = C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: d(12, 4).nullable()
 			});
-			if (S) {
-				let e = await p(), n = await m([w]);
-				k(n.operations).toHaveLength(1), k(n.operations[0]).toMatchObject({
+			if (p) {
+				let e = await o(), t = await s([_]);
+				H(t.operations).toHaveLength(1), H(t.operations[0]).toMatchObject({
 					op: {
 						kind: "alter-column-type",
-						table: t,
+						table: n,
 						column: "amount",
 						from: "decimal",
 						to: "decimal"
 					},
 					classification: "multi-step",
-					blocked: { fix: k.stringContaining("preserves precision") }
-				}), k(await p(), "Planning conversion must leave the physical schema unchanged").toEqual(e);
-				let i = await r.store.query(R(t));
-				k(i.find((e) => e.id === "ev_3")?.amount).toBe("12.34"), k((await m([C])).operations, "The original precision must still converge").toEqual([]);
-			} else await x([w], !0);
-			let T = S ? 10 : 12, E = S ? 2 : 4, D = () => a(T, E).nullable(), O = (await p()).tables[0]?.columns.find((e) => e.name === "amount");
-			k({
-				p: O?.precision,
-				s: O?.scale
-			}, `${n.dialect.id}: the accepted size is live`).toEqual({
-				p: T,
-				s: E
+					blocked: { fix: H.stringContaining("preserves precision") }
+				}), H(await o(), "Planning conversion must leave the physical schema unchanged").toEqual(e);
+				let r = await a.store.query(X(n));
+				H(r.find((e) => e.id === "ev_3")?.amount).toBe("12.34"), H((await s([m])).operations, "The original precision must still converge").toEqual([]);
+			} else await l([_], !0);
+			let v = p ? 10 : 12, ee = p ? 2 : 4, y = () => d(v, ee).nullable(), x = (await o()).tables[0]?.columns.find((e) => e.name === "amount");
+			H({
+				p: x?.precision,
+				s: x?.scale
+			}, `${e.dialect.id}: the accepted size is live`).toEqual({
+				p: v,
+				s: ee
 			});
-			let A = i("ev_status", ["open", "closed"]), N = h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: A.column().nullable()
+			let ne = u("ev_status", ["open", "closed"]), S = C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: ne.column().nullable()
 			});
-			await x([N], !0), k(await y(), `${n.dialect.id}: the enum column is live`).toContain("status"), await r.store.insert(t, {
+			await l([S], !0), H(await c(), `${e.dialect.id}: the enum column is live`).toContain("status"), await a.store.insert(n, {
 				id: "ev_4",
 				name: "four",
 				status: "closed"
 			});
-			let z = (e) => F({ tables: [{
-				name: t,
+			let re = (e) => pe({ tables: [{
+				name: n,
 				columns: e.filter((e) => e.name === "status"),
 				indexes: []
-			}] }), B = (await p()).tables.find((e) => e.name === t)?.columns ?? [];
-			k(B.some((e) => e.name === "status"), `${n.dialect.id}: nothing to compare`).toBe(!0);
-			let V = P([N], n.dialect.id).tables[0].columns, H = (e) => JSON.stringify(e.find((e) => e.name === "status"));
-			k(z(B), `${n.dialect.id}: the enum column must not part the two readers\n  live:     ${H(B)}\n  declared: ${H(V)}`).toBe(z(V));
-			let U = i("ev_status", [
+			}] }), O = (await o()).tables.find((e) => e.name === n)?.columns ?? [];
+			H(O.some((e) => e.name === "status"), `${e.dialect.id}: nothing to compare`).toBe(!0);
+			let k = fe([S], e.dialect.id).tables[0].columns, A = (e) => JSON.stringify(e.find((e) => e.name === "status"));
+			H(re(O), `${e.dialect.id}: the enum column must not part the two readers\n  live:     ${A(O)}\n  declared: ${A(k)}`).toBe(re(k));
+			let j = u("ev_status", [
 				"open",
 				"closed",
 				"held"
-			]), W = h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: U.column().nullable()
+			]), M = C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: j.column().nullable()
 			});
-			await x([W], !0), await r.store.insert(t, {
+			await l([M], !0), await a.store.insert(n, {
 				id: "ev_5",
 				name: "five",
 				status: "held"
-			}), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: U.column().nullable(),
-				parentId: d(() => W).nullable()
-			})], !0), await r.store.insert(t, {
+			}), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: j.column().nullable(),
+				parentId: te(() => M).nullable()
+			})], !0), await a.store.insert(n, {
 				id: "ev_6",
 				name: "six",
 				parentId: "ev_1"
-			}), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: U.column().nullable(),
-				parentId: o()
-			})], !0), k(await y(), `${n.dialect.id}: v10 dropped the FK column`).not.toContain("parentId"), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: U.column().nullable(),
-				createdAt: _().nullable()
+			}), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: j.column().nullable(),
+				parentId: f()
+			})], !0), H(await c(), `${e.dialect.id}: v10 dropped the FK column`).not.toContain("parentId"), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: j.column().nullable(),
+				createdAt: T().nullable()
 			})], !0);
-			for (let [e, n] of Object.entries({
+			for (let [e, t] of Object.entries({
 				ev_1: "2024-03-04T05:06:07Z",
 				ev_2: "2025-01-01T00:00:00Z",
 				ev_3: "2026-09-15T05:48:00Z"
-			})) await r.store.update(t, e, { createdAt: new Date(n) });
-			await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: U.column().nullable(),
-				createdAt: _().nullable(),
-				createdYear: l().backfill((e) => e.createdAt instanceof Date ? e.createdAt.getUTCFullYear() : -1)
+			})) await a.store.update(n, e, { createdAt: new Date(t) });
+			await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: j.column().nullable(),
+				createdAt: T().nullable(),
+				createdYear: g().backfill((e) => e.createdAt instanceof Date ? e.createdAt.getUTCFullYear() : -1)
 			})], !0);
-			let G = Object.fromEntries((await r.store.query(R(t))).map((e) => [String(e.id), e.createdYear]));
-			k(G, `${n.dialect.id}: the backfill saw each row's createdAt as a Date`).toMatchObject({
+			let ie = Object.fromEntries((await a.store.query(X(n))).map((e) => [String(e.id), e.createdYear]));
+			H(ie, `${e.dialect.id}: the backfill saw each row's createdAt as a Date`).toMatchObject({
 				ev_1: 2024,
 				ev_2: 2025,
 				ev_3: 2026,
 				ev_4: -1,
 				ev_5: -1,
 				ev_6: -1
-			}), await x([h(t, {
-				id: c({ prefix: "ev" }),
-				name: g(),
-				amount: D(),
-				status: U.column().nullable(),
-				createdAt: _().nullable(),
-				createdYear: l().backfill((e) => e.createdAt instanceof Date ? e.createdAt.getUTCFullYear() : -1),
-				receiptKey: g().maxLength(191).unique().backfill((e) => `rk-${String(e.id)}`)
+			}), await l([C(n, {
+				id: h({ prefix: "ev" }),
+				name: w(),
+				amount: y(),
+				status: j.column().nullable(),
+				createdAt: T().nullable(),
+				createdYear: g().backfill((e) => e.createdAt instanceof Date ? e.createdAt.getUTCFullYear() : -1),
+				receiptKey: w().maxLength(191).unique().backfill((e) => `rk-${String(e.id)}`)
 			})], !0);
-			let K = (await p()).tables[0]?.columns.find((e) => e.name === "receiptKey");
-			k(K?.unique, `${n.dialect.id}: receiptKey carries its unique in the live schema`).toBe(!0);
-			let q = await r.store.query(R(t));
-			k(q.map((e) => e.id).sort(), `${n.dialect.id}: rows survived the evolution`).toEqual([
+			let N = (await o()).tables[0]?.columns.find((e) => e.name === "receiptKey");
+			H(N?.unique, `${e.dialect.id}: receiptKey carries its unique in the live schema`).toBe(!0);
+			let ae = await a.store.query(X(n));
+			H(ae.map((e) => e.id).sort(), `${e.dialect.id}: rows survived the evolution`).toEqual([
 				"ev_1",
 				"ev_2",
 				"ev_3",
 				"ev_4",
 				"ev_5",
 				"ev_6"
-			]), k(q.find((e) => e.id === "ev_3")?.amount, "The exact decimal survives subsequent schema changes").toMatch(/^12\.340*$/), await u();
-		}), A("the data half of a plan is atomic: a failing backfill rolls back every backfill of the plan", async () => {
-			let t = "voltro_parity_atomic", i = (e) => r.run(e), a = () => i(b.gen(function* () {
-				let e = yield* j.SqlClient;
-				yield* b.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${t}`), () => []), yield* b.orElseSucceed(e.unsafe("DELETE FROM _voltro_migration_ops"), () => []);
-			})).catch(() => {}), o = () => i(b.gen(function* () {
-				let e = yield* j.SqlClient, n = yield* I(e);
+			]), H(ae.find((e) => e.id === "ev_3")?.amount, "The exact decimal survives subsequent schema changes").toMatch(/^12\.340*$/), await i();
+		}, 6e4), U("the data half of a plan is atomic: a failing backfill rolls back every backfill of the plan", async () => {
+			let n = "voltro_parity_atomic", r = (e) => a.run(e), i = () => r(D.gen(function* () {
+				let e = yield* G.SqlClient;
+				yield* D.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${n}`), () => []), yield* D.orElseSucceed(e.unsafe("DELETE FROM _voltro_migration_ops"), () => []);
+			})).catch(() => {}), o = () => r(D.gen(function* () {
+				let e = yield* G.SqlClient, t = yield* J(e);
 				return {
-					...n,
-					tables: n.tables.filter((e) => e.name === t)
+					...t,
+					tables: t.tables.filter((e) => e.name === n)
 				};
-			})), s = (e) => i(b.gen(function* () {
-				let r = yield* j.SqlClient, i = L({
-					declared: e,
-					live: yield* b.promise(o),
-					dialect: n.dialect.id
+			})), s = (t) => r(D.gen(function* () {
+				let r = yield* G.SqlClient, i = Y({
+					declared: t,
+					live: yield* D.promise(o),
+					dialect: e.dialect.id
 				});
-				return yield* M(r, i, {
-					declared: e,
+				return yield* K(r, i, {
+					declared: t,
 					appliedBy: "dialect-parity",
 					environment: "dev",
 					source: "auto-diff",
-					replan: (r) => b.map(I(r), (r) => L({
-						declared: e,
+					replan: (r) => D.map(J(r), (r) => Y({
+						declared: t,
 						live: {
 							...r,
-							tables: r.tables.filter((e) => e.name === t)
+							tables: r.tables.filter((e) => e.name === n)
 						},
-						dialect: n.dialect.id
+						dialect: e.dialect.id
 					}))
 				});
 			}));
-			await a(), await r.migrate([e]), await s([h(t, {
-				id: c({ prefix: "at" }),
-				name: g()
+			await i(), await a.migrate([t]), await s([C(n, {
+				id: h({ prefix: "at" }),
+				name: w()
 			})]);
 			for (let e of [
 				"one",
 				"two",
 				"three"
-			]) await r.store.insert(t, {
+			]) await a.store.insert(n, {
 				id: `at_${e}`,
 				name: e
 			});
-			let u = h(t, {
-				id: c({ prefix: "at" }),
-				name: g(),
-				first: l().backfill(() => 1),
-				second: l().backfill((e) => {
+			let c = C(n, {
+				id: h({ prefix: "at" }),
+				name: w(),
+				first: g().backfill(() => 1),
+				second: g().backfill((e) => {
 					throw Error(`no value for ${String(e.name)}`);
 				})
 			});
-			await k(s([u])).rejects.toThrow(/no value for/);
-			let d = (await o()).tables[0]?.columns.map((e) => e.name) ?? [], f = await r.store.query(R(t));
-			k(f, `${n.dialect.id}: the rows survived`).toHaveLength(3), d.includes("first") ? k(f.map((e) => e.first), `${n.dialect.id}: no backfill of the failed group landed`).toEqual([
+			await H(s([c])).rejects.toThrow(/no value for/);
+			let l = (await o()).tables[0]?.columns.map((e) => e.name) ?? [], u = await a.store.query(X(n));
+			H(u, `${e.dialect.id}: the rows survived`).toHaveLength(3), l.includes("first") ? H(u.map((e) => e.first), `${e.dialect.id}: no backfill of the failed group landed`).toEqual([
 				null,
 				null,
 				null
-			]) : k(d, `${n.dialect.id}: the plan rolled back`).toEqual(["id", "name"]);
-			let p = h(t, {
-				id: c({ prefix: "at" }),
-				name: g(),
-				first: l().backfill(() => 1),
-				second: l().backfill((e) => String(e.name).length)
+			]) : H(l, `${e.dialect.id}: the plan rolled back`).toEqual(["id", "name"]);
+			let d = C(n, {
+				id: h({ prefix: "at" }),
+				name: w(),
+				first: g().backfill(() => 1),
+				second: g().backfill((e) => String(e.name).length)
 			});
-			await s([p]);
-			let m = await r.store.query(R(t));
-			k(m.map((e) => [e.first, e.second]).sort(), `${n.dialect.id}: both backfills landed`).toEqual([
+			await s([d]);
+			let f = await a.store.query(X(n));
+			H(f.map((e) => [e.first, e.second]).sort(), `${e.dialect.id}: both backfills landed`).toEqual([
 				[1, 3],
 				[1, 3],
 				[1, 5]
-			]), k(L({
-				declared: [p],
+			]), H(Y({
+				declared: [d],
 				live: await o(),
-				dialect: n.dialect.id
-			}).operations).toEqual([]), await a();
-		}), A("re-applying a create-table plan is a no-op, indexes included", async () => {
-			let t = "voltro_parity_reapply", i = r.run, a = async () => {
-				await i(b.gen(function* () {
-					let e = yield* j.SqlClient;
-					yield* b.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${t}`), () => []);
+				dialect: e.dialect.id
+			}).operations).toEqual([]), await i();
+		}), U("re-applying a create-table plan is a no-op, indexes included", async () => {
+			let n = "voltro_parity_reapply", r = a.run, i = async () => {
+				await r(D.gen(function* () {
+					let e = yield* G.SqlClient;
+					yield* D.orElseSucceed(e.unsafe(`DROP TABLE IF EXISTS ${n}`), () => []);
 				})).catch(() => {});
-			}, o = () => i(b.gen(function* () {
-				let e = yield* j.SqlClient, n = yield* I(e);
+			}, o = () => r(D.gen(function* () {
+				let e = yield* G.SqlClient, t = yield* J(e);
 				return {
-					...n,
-					tables: n.tables.filter((e) => e.name === t)
+					...t,
+					tables: t.tables.filter((e) => e.name === n)
 				};
-			})), s = h(t, {
-				id: c({ prefix: "ra" }),
-				name: g(),
-				qty: l().nullable()
-			}).index(["qty"]), u = async () => L({
+			})), s = C(n, {
+				id: h({ prefix: "ra" }),
+				name: w(),
+				qty: g().nullable()
+			}).index(["qty"]), c = async () => Y({
 				declared: [s],
 				live: await o(),
-				dialect: n.dialect.id
+				dialect: e.dialect.id
 			});
-			await a(), await r.migrate([e]);
-			let d = await u();
-			k(d.operations.some((e) => e.op.kind === "create-table"), `${n.dialect.id}: expected a create-table to re-apply`).toBe(!0);
-			for (let e = 0; e < 2; e++) await i(b.gen(function* () {
-				let e = yield* j.SqlClient;
-				return yield* M(e, d, {
+			await i(), await a.migrate([t]);
+			let l = await c();
+			H(l.operations.some((e) => e.op.kind === "create-table"), `${e.dialect.id}: expected a create-table to re-apply`).toBe(!0);
+			for (let t = 0; t < 2; t++) await r(D.gen(function* () {
+				let t = yield* G.SqlClient;
+				return yield* K(t, l, {
 					declared: [s],
 					appliedBy: "dialect-parity",
 					environment: "dev",
 					source: "auto-diff",
-					replan: (e) => b.map(I(e), (e) => L({
+					replan: (t) => D.map(J(t), (t) => Y({
 						declared: [s],
 						live: {
-							...e,
-							tables: e.tables.filter((e) => e.name === t)
+							...t,
+							tables: t.tables.filter((e) => e.name === n)
 						},
-						dialect: n.dialect.id
+						dialect: e.dialect.id
 					}))
 				});
 			}));
-			k((await u()).operations, `${n.dialect.id}: the re-applied plan must converge`).toEqual([]), await a();
+			H((await c()).operations, `${e.dialect.id}: the re-applied plan must converge`).toEqual([]), await i();
 		});
-		let N = "voltro_parity_bulk", Y = () => r.run(b.gen(function* () {
-			let e = yield* j.SqlClient;
-			yield* b.orElseSucceed(e.unsafe(`DELETE FROM ${N}`), () => []);
-		})), X = (e, t) => Array.from({ length: e }, (e, n) => ({
+		let q = "voltro_parity_bulk", $ = () => a.run(D.gen(function* () {
+			let e = yield* G.SqlClient;
+			yield* D.orElseSucceed(e.unsafe(`DELETE FROM ${q}`), () => []);
+		})), Se = (e, t) => Array.from({ length: e }, (e, n) => ({
 			id: `${t}_${String(n).padStart(6, "0")}`,
 			title: `row ${n}`,
 			count: n,
 			flag: !1
 		}));
-		A("insertMany past this dialect's one-statement ceiling lands EVERY row", async () => {
-			let e = J(n.dialect.id);
-			k(e, `no bulk-insert limits are declared for '${n.dialect.id}' — a dialect with no entry chunks at nothing, so this scenario would pass having tested nothing`).toBeGreaterThan(0);
-			let t = e + 5;
-			await Y();
-			let i = await r.store.insertMany(N, X(t, "bulk"));
-			k(i.length, `insertMany returned ${i.length} of ${t} post-images`).toBe(t), k(i[0]?.id).toBe("bulk_000000"), k(i[t - 1]?.id).toBe(`bulk_${String(t - 1).padStart(6, "0")}`);
-			let a = await r.store.query(R(N));
-			k(a.length, "the database holds fewer rows than insertMany reported").toBe(t), await Y();
-		}, 12e4), A("a chunked insertMany is still ALL-OR-NOTHING", async () => {
-			let e = J(n.dialect.id) + 5;
-			await Y();
-			let t = X(e, "atomic");
-			t[e - 1] = {
-				...t[e - 1],
-				id: t[0].id
-			}, await k(r.store.insertMany(N, t), "a duplicate primary key must still reject the whole call").rejects.toThrow();
-			let i = await r.store.query(R(N));
-			k(i.length, `${n.dialect.id}: ${i.length} rows survived a FAILED insertMany — chunking introduced partial success. The chunks must run inside one transaction when the caller holds none.`).toBe(0), await Y();
-		}, 12e4), A("DDL is idempotent — re-applying the schema is a no-op", async () => {
-			await r.migrate([z, B]);
-		}), A("insert + query round-trips a row", async () => {
-			let e = await r.store.insert("voltro_parity_a", {
+		U("insertMany past this dialect's one-statement ceiling lands EVERY row", async () => {
+			let t = xe(e.dialect.id);
+			H(t, `no bulk-insert limits are declared for '${e.dialect.id}' — a dialect with no entry chunks at nothing, so this scenario would pass having tested nothing`).toBeGreaterThan(0);
+			let n = t + 5;
+			await $();
+			let r = await a.store.insertMany(q, Se(n, "bulk"));
+			H(r.length, `insertMany returned ${r.length} of ${n} post-images`).toBe(n), H(r[0]?.id).toBe("bulk_000000"), H(r[n - 1]?.id).toBe(`bulk_${String(n - 1).padStart(6, "0")}`);
+			let i = await a.store.query(X(q));
+			H(i.length, "the database holds fewer rows than insertMany reported").toBe(n), await $();
+		}, 12e4), U("a chunked insertMany is still ALL-OR-NOTHING", async () => {
+			let t = xe(e.dialect.id) + 5;
+			await $();
+			let n = Se(t, "atomic");
+			n[t - 1] = {
+				...n[t - 1],
+				id: n[0].id
+			}, await H(a.store.insertMany(q, n), "a duplicate primary key must still reject the whole call").rejects.toThrow();
+			let r = await a.store.query(X(q));
+			H(r.length, `${e.dialect.id}: ${r.length} rows survived a FAILED insertMany — chunking introduced partial success. The chunks must run inside one transaction when the caller holds none.`).toBe(0), await $();
+		}, 12e4), U("DDL is idempotent — re-applying the schema is a no-op", async () => {
+			await a.migrate([me, he]);
+		}), U("insert + query round-trips a row", async () => {
+			let e = await a.store.insert("voltro_parity_a", {
 				id: "a1",
 				title: "one",
 				count: 1
 			});
-			k(e).toMatchObject({
+			H(e).toMatchObject({
 				id: "a1",
 				title: "one",
 				count: 1
 			});
-			let t = await r.store.query(R("voltro_parity_a"));
-			k(t.length).toBe(1), k(t[0]?.id).toBe("a1");
-		}), A("update returns the post-image", async () => {
-			await r.store.insert("voltro_parity_a", {
+			let t = await a.store.query(X("voltro_parity_a"));
+			H(t.length).toBe(1), H(t[0]?.id).toBe("a1");
+		}), U("update returns the post-image", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "a2",
 				title: "pre",
 				count: 1
 			});
-			let e = await r.store.update("voltro_parity_a", "a2", { title: "post" });
-			k(e).toMatchObject({
+			let e = await a.store.update("voltro_parity_a", "a2", { title: "post" });
+			H(e).toMatchObject({
 				id: "a2",
 				title: "post"
 			});
-		}), A("delete removes the row + reports true", async () => {
-			await r.store.insert("voltro_parity_a", {
+		}), U("delete removes the row + reports true", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "a3",
 				title: "x",
 				count: 1
-			}), k(await r.store.delete("voltro_parity_a", "a3")).toBe(!0);
-			let e = await r.store.query(R("voltro_parity_a"));
-			k(e.length).toBe(0);
-		}), A("a composite key addresses the row, and only that row", async () => {
-			await r.store.insert("voltro_parity_composite", {
+			}), H(await a.store.delete("voltro_parity_a", "a3")).toBe(!0);
+			let e = await a.store.query(X("voltro_parity_a"));
+			H(e.length).toBe(0);
+		}), U("a composite key addresses the row, and only that row", async () => {
+			await a.store.insert("voltro_parity_composite", {
 				userId: "u1",
 				orgId: "o1",
 				role: "admin"
-			}), await r.store.insert("voltro_parity_composite", {
+			}), await a.store.insert("voltro_parity_composite", {
 				userId: "u1",
 				orgId: "o2",
 				role: "viewer"
 			});
-			let e = await r.store.update("voltro_parity_composite", {
+			let e = await a.store.update("voltro_parity_composite", {
 				userId: "u1",
 				orgId: "o2"
 			}, { role: "member" });
-			k(e).toMatchObject({
+			H(e).toMatchObject({
 				userId: "u1",
 				orgId: "o2",
 				role: "member"
 			});
-			let t = await r.store.query(R("voltro_parity_composite")), n = new Map(t.map((e) => [e.orgId, e.role]));
-			k(n.get("o1")).toBe("admin"), k(n.get("o2")).toBe("member");
-		}), A("a composite key that matches nothing is `null` / `false`, not an error", async () => {
-			k(await r.store.update("voltro_parity_composite", {
+			let t = await a.store.query(X("voltro_parity_composite")), n = new Map(t.map((e) => [e.orgId, e.role]));
+			H(n.get("o1")).toBe("admin"), H(n.get("o2")).toBe("member");
+		}), U("a composite key that matches nothing is `null` / `false`, not an error", async () => {
+			H(await a.store.update("voltro_parity_composite", {
 				userId: "nobody",
 				orgId: "nowhere"
-			}, { role: "x" })).toBeNull(), k(await r.store.delete("voltro_parity_composite", {
+			}, { role: "x" })).toBeNull(), H(await a.store.delete("voltro_parity_composite", {
 				userId: "nobody",
 				orgId: "nowhere"
 			})).toBe(!1);
-		}), A("a composite key deletes exactly the row it names", async () => {
-			await r.store.insert("voltro_parity_composite", {
+		}), U("a composite key deletes exactly the row it names", async () => {
+			await a.store.insert("voltro_parity_composite", {
 				userId: "u2",
 				orgId: "o1",
 				role: "admin"
-			}), await r.store.insert("voltro_parity_composite", {
+			}), await a.store.insert("voltro_parity_composite", {
 				userId: "u2",
 				orgId: "o2",
 				role: "viewer"
-			}), k(await r.store.delete("voltro_parity_composite", {
+			}), H(await a.store.delete("voltro_parity_composite", {
 				userId: "u2",
 				orgId: "o1"
 			})).toBe(!0);
-			let e = (await r.store.query(R("voltro_parity_composite"))).filter((e) => e.userId === "u2").map((e) => e.orgId);
-			k(e).toEqual(["o2"]);
-		}), A("undo: the _voltro_undo_log TEXT changes column round-trips a JSON ChangeSet", async () => {
+			let e = (await a.store.query(X("voltro_parity_composite"))).filter((e) => e.userId === "u2").map((e) => e.orgId);
+			H(e).toEqual(["o2"]);
+		}), U("undo: the _voltro_undo_log TEXT changes column round-trips a JSON ChangeSet", async () => {
 			let e = [{
 				table: "voltro_parity_c",
 				op: "update",
@@ -585,7 +983,7 @@ var K = h("voltro_parity_composite", {
 					flag: !1
 				}
 			}];
-			await r.store.insert("_voltro_undo_log", {
+			await a.store.insert("_voltro_undo_log", {
 				id: "undo_p1",
 				tag: "parityC.update",
 				label: null,
@@ -597,16 +995,16 @@ var K = h("voltro_parity_composite", {
 				undone: !1,
 				createdAt: /* @__PURE__ */ new Date()
 			});
-			let t = await r.store.query(R("_voltro_undo_log"));
-			k(t.length).toBe(1), k(JSON.parse(t[0].changes)).toEqual(e);
-		}), A("undo: reverts an INSERT (inverse delete) on this dialect", async () => {
+			let t = await a.store.query(X("_voltro_undo_log"));
+			H(t.length).toBe(1), H(JSON.parse(t[0].changes)).toEqual(e);
+		}), U("undo: reverts an INSERT (inverse delete) on this dialect", async () => {
 			let e = {
 				invocationId: "inv1",
 				subject: null,
 				changes: [{
 					table: "voltro_parity_c",
 					op: "insert",
-					next: await r.store.insert("voltro_parity_c", {
+					next: await a.store.insert("voltro_parity_c", {
 						id: "c2",
 						title: "new",
 						count: 1,
@@ -614,24 +1012,24 @@ var K = h("voltro_parity_composite", {
 					})
 				}]
 			};
-			await S(r.store, w(e));
-			let t = await r.store.query(R("voltro_parity_c"));
-			k(t.find((e) => e.id === "c2")).toBeUndefined();
-		}), A("undo: reverts an UPDATE including the BOOLEAN, restoring the captured value FAITHFULLY", async () => {
-			await r.store.insert("voltro_parity_c", {
+			await N(a.store, R(e));
+			let t = await a.store.query(X("voltro_parity_c"));
+			H(t.find((e) => e.id === "c2")).toBeUndefined();
+		}), U("undo: reverts an UPDATE including the BOOLEAN, restoring the captured value FAITHFULLY", async () => {
+			await a.store.insert("voltro_parity_c", {
 				id: "c3",
 				title: "t",
 				count: 1,
 				flag: !0
 			});
-			let e = (await r.store.query({
-				...R("voltro_parity_c"),
-				predicate: s("id", "c3")
-			}))[0], t = await r.store.update("voltro_parity_c", "c3", {
+			let e = (await a.store.query({
+				...X("voltro_parity_c"),
+				predicate: p("id", "c3")
+			}))[0], t = await a.store.update("voltro_parity_c", "c3", {
 				count: 2,
 				flag: !1
 			});
-			k(t.flag).not.toEqual(e.flag);
+			H(t.flag).not.toEqual(e.flag);
 			let n = {
 				invocationId: "inv2",
 				subject: null,
@@ -643,20 +1041,20 @@ var K = h("voltro_parity_composite", {
 					next: t
 				}]
 			};
-			await S(r.store, w(n));
-			let i = (await r.store.query({
-				...R("voltro_parity_c"),
-				predicate: s("id", "c3")
+			await N(a.store, R(n));
+			let r = (await a.store.query({
+				...X("voltro_parity_c"),
+				predicate: p("id", "c3")
 			}))[0];
-			k(i.flag).toEqual(e.flag), k(i.count).toEqual(e.count);
-		}), A("undo: reverts a DELETE (inverse re-insert) on this dialect", async () => {
-			let e = await r.store.insert("voltro_parity_c", {
+			H(r.flag).toEqual(e.flag), H(r.count).toEqual(e.count);
+		}), U("undo: reverts a DELETE (inverse re-insert) on this dialect", async () => {
+			let e = await a.store.insert("voltro_parity_c", {
 				id: "c4",
 				title: "gone",
 				count: 9,
 				flag: !0
 			});
-			await r.store.delete("voltro_parity_c", "c4");
+			await a.store.delete("voltro_parity_c", "c4");
 			let t = {
 				invocationId: "inv3",
 				subject: null,
@@ -667,46 +1065,46 @@ var K = h("voltro_parity_composite", {
 					prev: e
 				}]
 			};
-			await S(r.store, w(t));
-			let n = (await r.store.query({
-				...R("voltro_parity_c"),
-				predicate: s("id", "c4")
+			await N(a.store, R(t));
+			let n = (await a.store.query({
+				...X("voltro_parity_c"),
+				predicate: p("id", "c4")
 			}))[0];
-			k(n.id).toBe("c4"), k(n.title).toBe("gone"), k(n.flag).toEqual(e.flag);
-		}), A("onChange fires insert + update + delete events", async () => {
-			let e = [], t = r.store.onChange((t) => e.push(t.op));
-			await r.store.insert("voltro_parity_a", {
+			H(n.id).toBe("c4"), H(n.title).toBe("gone"), H(n.flag).toEqual(e.flag);
+		}), U("onChange fires insert + update + delete events", async () => {
+			let e = [], t = a.store.onChange((t) => e.push(t.op));
+			await a.store.insert("voltro_parity_a", {
 				id: "a4",
 				title: "a",
 				count: 1
-			}), await r.store.update("voltro_parity_a", "a4", { title: "b" }), await r.store.delete("voltro_parity_a", "a4"), t(), k(e).toEqual([
+			}), await a.store.update("voltro_parity_a", "a4", { title: "b" }), await a.store.delete("voltro_parity_a", "a4"), t(), H(e).toEqual([
 				"insert",
 				"update",
 				"delete"
 			]);
-		}), A("binding more than 10 change listeners emits no MaxListeners warning", async () => {
+		}), U("binding more than 10 change listeners emits no MaxListeners warning", async () => {
 			let e = [], t = (t) => {
 				e.push(t.name);
 			};
 			process.on("warning", t);
-			let n = Array.from({ length: 32 }, () => r.store.onChange(() => {}));
+			let n = Array.from({ length: 32 }, () => a.store.onChange(() => {}));
 			await new Promise((e) => setImmediate(e));
 			for (let e of n) e();
-			process.off("warning", t), k(e.filter((e) => e === "MaxListenersExceededWarning"), "the change bus still warns at 11 listeners — `raiseChangeListenerCeiling` is not wired into this dialect’s store").toEqual([]);
-		}), A("transactional rolls back on throw + drops queued events", async () => {
-			let e = [], t = r.store.onChange((t) => e.push(t.op));
-			await k(r.store.transactional(async (e) => {
+			process.off("warning", t), H(e.filter((e) => e === "MaxListenersExceededWarning"), "the change bus still warns at 11 listeners — `raiseChangeListenerCeiling` is not wired into this dialect’s store").toEqual([]);
+		}), U("transactional rolls back on throw + drops queued events", async () => {
+			let e = [], t = a.store.onChange((t) => e.push(t.op));
+			await H(a.store.transactional(async (e) => {
 				throw await e.insert("voltro_parity_a", {
 					id: "rollback",
 					title: "r",
 					count: 0
 				}), Error("intentional rollback");
-			})).rejects.toThrow("intentional rollback"), t(), k(e).toEqual([]);
-			let n = await r.store.query(R("voltro_parity_a"));
-			k(n.length).toBe(0);
-		}), A("transactional commit drains queued events in order", async () => {
-			let e = [], t = r.store.onChange((t) => e.push(t.op));
-			await r.store.transactional(async (e) => {
+			})).rejects.toThrow("intentional rollback"), t(), H(e).toEqual([]);
+			let n = await a.store.query(X("voltro_parity_a"));
+			H(n.length).toBe(0);
+		}), U("transactional commit drains queued events in order", async () => {
+			let e = [], t = a.store.onChange((t) => e.push(t.op));
+			await a.store.transactional(async (e) => {
 				await e.insert("voltro_parity_a", {
 					id: "commit1",
 					title: "a",
@@ -716,13 +1114,13 @@ var K = h("voltro_parity_composite", {
 					title: "b",
 					count: 2
 				});
-			}), t(), k(e).toEqual(["insert", "insert"]);
-		}), A("upsert inserts a new row, then updates on conflict — no duplicate", async () => {
-			await r.store.upsert("voltro_parity_a", {
+			}), t(), H(e).toEqual(["insert", "insert"]);
+		}), U("upsert inserts a new row, then updates on conflict — no duplicate", async () => {
+			await a.store.upsert("voltro_parity_a", {
 				id: "u1",
 				title: "first",
 				count: 1
-			}, { conflictColumns: ["id"] }), await r.store.upsert("voltro_parity_a", {
+			}, { conflictColumns: ["id"] }), await a.store.upsert("voltro_parity_a", {
 				id: "u1",
 				title: "second",
 				count: 2
@@ -730,13 +1128,13 @@ var K = h("voltro_parity_composite", {
 				conflictColumns: ["id"],
 				update: ["title", "count"]
 			});
-			let e = await r.store.query(R("voltro_parity_a"));
-			k(e.length).toBe(1), k(e[0]).toMatchObject({
+			let e = await a.store.query(X("voltro_parity_a"));
+			H(e.length).toBe(1), H(e[0]).toMatchObject({
 				id: "u1",
 				title: "second",
 				count: 2
 			});
-		}), A.each([
+		}), U.each([
 			"done",
 			"",
 			"null",
@@ -746,47 +1144,47 @@ var K = h("voltro_parity_composite", {
 			"{\"a\":1}",
 			"\"quoted\""
 		])("JSON scalar string %j survives insert and update", async (e) => {
-			let t = W.tableName, n = await r.store.insert(t, {
+			let t = Z.tableName, n = await a.store.insert(t, {
 				id: "json-string",
 				title: "before",
 				metadata: e,
 				labels: []
 			});
-			k(n.metadata).toBe(e), k((await r.store.query(R(t)))[0]?.metadata).toBe(e), await r.store.transactional(async (n) => {
+			H(n.metadata).toBe(e), H((await a.store.query(X(t)))[0]?.metadata).toBe(e), await a.store.transactional(async (n) => {
 				let r = await n.update(t, "json-string", { metadata: `${e}\nupdated` });
-				k(r?.metadata).toBe(`${e}\nupdated`);
-			}), k((await r.store.query(R(t)))[0]?.metadata).toBe(`${e}\nupdated`);
-		}), A("JSON validity checks are not introspected as enum membership", async () => {
-			let e = (await r.run(b.gen(function* () {
-				let e = yield* j.SqlClient;
-				return yield* I(e);
-			}))).tables.find((e) => e.name === W.tableName)?.columns.find((e) => e.name === "metadata");
-			k(e).toBeDefined(), k(e?.oneOf).toBeUndefined(), n.dialect.id === "mssql" && (k(e?.jsonValidation).toBe("value"), k(e?.jsonChecks).toEqual([{
-				name: k.any(String),
+				H(r?.metadata).toBe(`${e}\nupdated`);
+			}), H((await a.store.query(X(t)))[0]?.metadata).toBe(`${e}\nupdated`);
+		}), U("JSON validity checks are not introspected as enum membership", async () => {
+			let t = (await a.run(D.gen(function* () {
+				let e = yield* G.SqlClient;
+				return yield* J(e);
+			}))).tables.find((e) => e.name === Z.tableName)?.columns.find((e) => e.name === "metadata");
+			H(t).toBeDefined(), H(t?.oneOf).toBeUndefined(), e.dialect.id === "mssql" && (H(t?.jsonValidation).toBe("value"), H(t?.jsonChecks).toEqual([{
+				name: H.any(String),
 				validation: "value",
 				enabled: !0,
 				trusted: !0
 			}]));
-		}), n.dialect.id === "mssql" && A("JSON check catalog includes table-level names and enforcement state", async () => {
-			let e = (e) => r.run(b.gen(function* () {
-				yield* (yield* j.SqlClient).unsafe(e);
-			})), t = () => r.run(b.gen(function* () {
-				let e = yield* j.SqlClient;
-				return (yield* I(e)).tables.find((e) => e.name === "voltro_parity_json_checks")?.columns.find((e) => e.name === "metadata")?.jsonChecks;
+		}), e.dialect.id === "mssql" && U("JSON check catalog includes table-level names and enforcement state", async () => {
+			let e = (e) => a.run(D.gen(function* () {
+				yield* (yield* G.SqlClient).unsafe(e);
+			})), t = () => a.run(D.gen(function* () {
+				let e = yield* G.SqlClient;
+				return (yield* J(e)).tables.find((e) => e.name === "voltro_parity_json_checks")?.columns.find((e) => e.name === "metadata")?.jsonChecks;
 			}));
 			await e("CREATE TABLE voltro_parity_json_checks (id INT PRIMARY KEY, metadata NVARCHAR(MAX), CONSTRAINT json_container_probe CHECK (metadata IS NULL OR ISJSON(metadata) = 1), CONSTRAINT custom_json_probe CHECK (metadata IS NULL OR LEN(metadata) > 2))");
 			try {
-				k(await t()).toEqual([{
+				H(await t()).toEqual([{
 					name: "json_container_probe",
 					validation: "container",
 					enabled: !0,
 					trusted: !0
-				}]), await e("ALTER TABLE voltro_parity_json_checks NOCHECK CONSTRAINT json_container_probe"), k(await t()).toEqual([{
+				}]), await e("ALTER TABLE voltro_parity_json_checks NOCHECK CONSTRAINT json_container_probe"), H(await t()).toEqual([{
 					name: "json_container_probe",
 					validation: "container",
 					enabled: !1,
 					trusted: !1
-				}]), await e("ALTER TABLE voltro_parity_json_checks CHECK CONSTRAINT json_container_probe"), k(await t()).toEqual([{
+				}]), await e("ALTER TABLE voltro_parity_json_checks CHECK CONSTRAINT json_container_probe"), H(await t()).toEqual([{
 					name: "json_container_probe",
 					validation: "container",
 					enabled: !0,
@@ -795,7 +1193,7 @@ var K = h("voltro_parity_composite", {
 			} finally {
 				await e("DROP TABLE voltro_parity_json_checks");
 			}
-		}), n.dialect.id === "mssql" && A.each([
+		}), e.dialect.id === "mssql" && U.each([
 			{
 				invalid: !1,
 				rename: !1
@@ -812,121 +1210,121 @@ var K = h("voltro_parity_composite", {
 				invalid: !0,
 				rename: !0
 			}
-		])("JSON check migration preserves data and is atomic (invalid=$invalid, rename=$rename)", async ({ invalid: t, rename: n }) => {
-			let i = "voltro_parity_json_upgrade", a = n ? "renamed_metadata" : "metadata", o = [h(i, {
-				id: c(),
-				[a]: n ? u().nullable().renamedFrom("metadata") : u().nullable()
-			})], s = (e) => r.run(b.gen(function* () {
-				return yield* (yield* j.SqlClient).unsafe(e);
-			})), l = (e) => I(e).pipe(b.map((e) => L({
+		])("JSON check migration preserves data and is atomic (invalid=$invalid, rename=$rename)", async ({ invalid: e, rename: n }) => {
+			let r = "voltro_parity_json_upgrade", i = n ? "renamed_metadata" : "metadata", o = [C(r, {
+				id: h(),
+				[i]: n ? _().nullable().renamedFrom("metadata") : _().nullable()
+			})], s = (e) => a.run(D.gen(function* () {
+				return yield* (yield* G.SqlClient).unsafe(e);
+			})), c = (e) => J(e).pipe(D.map((e) => Y({
 				declared: o,
 				dialect: "mssql",
-				live: { tables: e.tables.filter((e) => e.name === i) }
-			}))), d = () => r.run(j.SqlClient.pipe(b.flatMap(l)));
-			await r.migrate([e]), await s(`CREATE TABLE ${i} (id VARCHAR(64) PRIMARY KEY, metadata NVARCHAR(MAX) NULL, CONSTRAINT upgrade_json_old CHECK (metadata IS NULL OR ISJSON(metadata)=1), CONSTRAINT upgrade_json_custom CHECK NOT FOR REPLICATION (metadata IS NULL OR (LEN(metadata)<100 AND metadata<>N'"[metadata]"')))`);
+				live: { tables: e.tables.filter((e) => e.name === r) }
+			}))), l = () => a.run(G.SqlClient.pipe(D.flatMap(c)));
+			await a.migrate([t]), await s(`CREATE TABLE ${r} (id VARCHAR(64) PRIMARY KEY, metadata NVARCHAR(MAX) NULL, CONSTRAINT upgrade_json_old CHECK (metadata IS NULL OR ISJSON(metadata)=1), CONSTRAINT upgrade_json_custom CHECK NOT FOR REPLICATION (metadata IS NULL OR (LEN(metadata)<100 AND metadata<>N'"[metadata]"')))`);
 			try {
-				let e = () => s(`SELECT is_disabled AS disabled, is_not_trusted AS untrusted, is_not_for_replication AS notForReplication FROM sys.check_constraints WHERE parent_object_id=OBJECT_ID('${i}') AND name='upgrade_json_custom'`), c = await e();
-				k(c).toHaveLength(1), k(c[0]).toMatchObject({
+				let t = () => s(`SELECT is_disabled AS disabled, is_not_trusted AS untrusted, is_not_for_replication AS notForReplication FROM sys.check_constraints WHERE parent_object_id=OBJECT_ID('${r}') AND name='upgrade_json_custom'`), u = await t();
+				H(u).toHaveLength(1), H(u[0]).toMatchObject({
 					disabled: !1,
 					notForReplication: !0
-				}), t && await s(`ALTER TABLE ${i} NOCHECK CONSTRAINT upgrade_json_old`), await s(`INSERT INTO ${i} (id,metadata) VALUES ('kept','${t ? "invalid" : "{\"kept\":true}"}')`);
-				let u = await d();
-				k(u.operations.map((e) => e.op)).toEqual([...n ? [{
+				}), e && await s(`ALTER TABLE ${r} NOCHECK CONSTRAINT upgrade_json_old`), await s(`INSERT INTO ${r} (id,metadata) VALUES ('kept','${e ? "invalid" : "{\"kept\":true}"}')`);
+				let d = await l();
+				H(d.operations.map((e) => e.op)).toEqual([...n ? [{
 					kind: "rename-column",
-					table: i,
+					table: r,
 					from: "metadata",
-					to: a
+					to: i
 				}] : [], {
 					kind: "reconcile-json-check",
-					table: i,
-					column: a,
+					table: r,
+					column: i,
 					validation: "value",
-					previousValidation: t ? "unverified" : "container",
+					previousValidation: e ? "unverified" : "container",
 					dropConstraints: ["upgrade_json_old"]
 				}]);
-				let f = r.run(b.gen(function* () {
-					let e = yield* j.SqlClient;
-					return yield* M(e, u, {
+				let f = a.run(D.gen(function* () {
+					let e = yield* G.SqlClient;
+					return yield* K(e, d, {
 						declared: o,
 						appliedBy: "json-parity",
 						environment: "dev",
 						source: "auto-diff",
-						replan: l
+						replan: c
 					});
 				}));
-				t ? (await k(f).rejects.toThrow("op=reconcile-json-check"), k((await d()).operations.map((e) => e.op)).toEqual(u.operations.map((e) => e.op))) : (await f, k((await d()).operations).toEqual([]), await s(`INSERT INTO ${i} (id,${a}) VALUES ('scalar','"done"')`), await k(s(`INSERT INTO ${i} (id,${a}) VALUES ('too-long','"${"x".repeat(110)}"')`)).rejects.toThrow(), await k(s(`INSERT INTO ${i} (id,${a}) VALUES ('literal','"[metadata]"')`)).rejects.toThrow()), k(await s(`SELECT ${t ? "metadata" : a} AS metadata FROM ${i} WHERE id='kept'`)).toEqual([{ metadata: t ? "invalid" : "{\"kept\":true}" }]), k(await s(`SELECT name FROM sys.check_constraints WHERE parent_object_id=OBJECT_ID('${i}') AND name='upgrade_json_custom'`)).toEqual([{ name: "upgrade_json_custom" }]), k(await e()).toEqual(c);
+				e ? (await H(f).rejects.toThrow("op=reconcile-json-check"), H((await l()).operations.map((e) => e.op)).toEqual(d.operations.map((e) => e.op))) : (await f, H((await l()).operations).toEqual([]), await s(`INSERT INTO ${r} (id,${i}) VALUES ('scalar','"done"')`), await H(s(`INSERT INTO ${r} (id,${i}) VALUES ('too-long','"${"x".repeat(110)}"')`)).rejects.toThrow(), await H(s(`INSERT INTO ${r} (id,${i}) VALUES ('literal','"[metadata]"')`)).rejects.toThrow()), H(await s(`SELECT ${e ? "metadata" : i} AS metadata FROM ${r} WHERE id='kept'`)).toEqual([{ metadata: e ? "invalid" : "{\"kept\":true}" }]), H(await s(`SELECT name FROM sys.check_constraints WHERE parent_object_id=OBJECT_ID('${r}') AND name='upgrade_json_custom'`)).toEqual([{ name: "upgrade_json_custom" }]), H(await t()).toEqual(u);
 			} finally {
-				await s(`DROP TABLE ${i}`);
+				await s(`DROP TABLE ${r}`);
 			}
-		}), n.dialect.id === "mssql" && A.each([
+		}), e.dialect.id === "mssql" && U.each([
 			"trusted",
 			"untrusted",
 			"disabled"
-		])("column rename preserves %s application CHECK state", async (t) => {
-			let n = "voltro_parity_rename_checks", i = [h(n, {
-				id: c(),
-				renamed: g().nullable().renamedFrom("original")
-			})], a = (e) => r.run(b.gen(function* () {
-				return yield* (yield* j.SqlClient).unsafe(e);
-			})), o = (e) => I(e).pipe(b.map((e) => L({
-				declared: i,
+		])("column rename preserves %s application CHECK state", async (e) => {
+			let n = "voltro_parity_rename_checks", r = [C(n, {
+				id: h(),
+				renamed: w().nullable().renamedFrom("original")
+			})], i = (e) => a.run(D.gen(function* () {
+				return yield* (yield* G.SqlClient).unsafe(e);
+			})), o = (e) => J(e).pipe(D.map((e) => Y({
+				declared: r,
 				dialect: "mssql",
 				live: { tables: e.tables.filter((e) => e.name === n) }
 			})));
-			await r.migrate([e]), await a(`CREATE TABLE ${n} (id VARCHAR(64) PRIMARY KEY, original NVARCHAR(MAX) NULL, CONSTRAINT rename_state_check CHECK (LEN(original)<10))`);
+			await a.migrate([t]), await i(`CREATE TABLE ${n} (id VARCHAR(64) PRIMARY KEY, original NVARCHAR(MAX) NULL, CONSTRAINT rename_state_check CHECK (LEN(original)<10))`);
 			try {
-				t !== "trusted" && await a(`ALTER TABLE ${n} NOCHECK CONSTRAINT rename_state_check`), t === "untrusted" && await a(`ALTER TABLE ${n} CHECK CONSTRAINT rename_state_check`);
-				let e = () => a(`SELECT name,is_disabled AS disabled,is_not_trusted AS untrusted FROM sys.check_constraints WHERE parent_object_id=OBJECT_ID('${n}')`), s = await e();
-				k(s).toEqual([{
+				e !== "trusted" && await i(`ALTER TABLE ${n} NOCHECK CONSTRAINT rename_state_check`), e === "untrusted" && await i(`ALTER TABLE ${n} CHECK CONSTRAINT rename_state_check`);
+				let t = () => i(`SELECT name,is_disabled AS disabled,is_not_trusted AS untrusted FROM sys.check_constraints WHERE parent_object_id=OBJECT_ID('${n}')`), s = await t();
+				H(s).toEqual([{
 					name: "rename_state_check",
-					disabled: t === "disabled",
-					untrusted: t !== "trusted"
-				}]), await a(`INSERT INTO ${n} (id,original) VALUES ('kept','${t === "disabled" ? "long invalid existing value" : "valid"}')`), await r.run(b.gen(function* () {
-					let e = yield* j.SqlClient, t = yield* o(e);
-					k(t.operations.map((e) => e.op.kind)).toEqual(["rename-column"]), yield* M(e, t, {
-						declared: i,
+					disabled: e === "disabled",
+					untrusted: e !== "trusted"
+				}]), await i(`INSERT INTO ${n} (id,original) VALUES ('kept','${e === "disabled" ? "long invalid existing value" : "valid"}')`), await a.run(D.gen(function* () {
+					let e = yield* G.SqlClient, t = yield* o(e);
+					H(t.operations.map((e) => e.op.kind)).toEqual(["rename-column"]), yield* K(e, t, {
+						declared: r,
 						appliedBy: "rename-parity",
 						environment: "dev",
 						source: "auto-diff",
 						replan: o
-					}), k((yield* o(e)).operations).toEqual([]);
-				})), k(await e()).toEqual(s), k(await a(`SELECT renamed FROM ${n} WHERE id='kept'`)).toEqual([{ renamed: t === "disabled" ? "long invalid existing value" : "valid" }]);
-				let c = a(`INSERT INTO ${n} (id,renamed) VALUES ('probe','another invalid value')`);
-				t === "disabled" ? await c : await k(c).rejects.toThrow();
+					}), H((yield* o(e)).operations).toEqual([]);
+				})), H(await t()).toEqual(s), H(await i(`SELECT renamed FROM ${n} WHERE id='kept'`)).toEqual([{ renamed: e === "disabled" ? "long invalid existing value" : "valid" }]);
+				let c = i(`INSERT INTO ${n} (id,renamed) VALUES ('probe','another invalid value')`);
+				e === "disabled" ? await c : await H(c).rejects.toThrow();
 			} finally {
-				await a(`DROP TABLE ${n}`);
+				await i(`DROP TABLE ${n}`);
 			}
-		}), n.dialect.id === "mssql" && A.each(["create", "add"])("JSON checks are complete after %s-column DDL", async (n) => {
-			let i = "voltro_parity_json_ddl", a = [h(i, {
-				id: c(),
-				metadata: u().nullable(),
-				labels: t(g()).nullable()
-			})], o = (e) => r.run(b.gen(function* () {
-				return yield* (yield* j.SqlClient).unsafe(e);
-			})), s = (e) => I(e).pipe(b.map((e) => L({
-				declared: a,
+		}), e.dialect.id === "mssql" && U.each(["create", "add"])("JSON checks are complete after %s-column DDL", async (e) => {
+			let r = "voltro_parity_json_ddl", i = [C(r, {
+				id: h(),
+				metadata: _().nullable(),
+				labels: n(w()).nullable()
+			})], o = (e) => a.run(D.gen(function* () {
+				return yield* (yield* G.SqlClient).unsafe(e);
+			})), s = (e) => J(e).pipe(D.map((e) => Y({
+				declared: i,
 				dialect: "mssql",
-				live: { tables: e.tables.filter((e) => e.name === i) }
+				live: { tables: e.tables.filter((e) => e.name === r) }
 			})));
-			await r.migrate([e]), n === "add" && (await o(`CREATE TABLE ${i} (id VARCHAR(64) PRIMARY KEY)`), await o(`INSERT INTO ${i} (id) VALUES ('existing')`));
+			await a.migrate([t]), e === "add" && (await o(`CREATE TABLE ${r} (id VARCHAR(64) PRIMARY KEY)`), await o(`INSERT INTO ${r} (id) VALUES ('existing')`));
 			try {
-				await r.run(b.gen(function* () {
-					let e = yield* j.SqlClient, t = yield* s(e);
-					k(t.operations.map((e) => e.op.kind)).toEqual(n === "create" ? ["create-table"] : ["add-column", "add-column"]), yield* M(e, t, {
-						declared: a,
+				await a.run(D.gen(function* () {
+					let t = yield* G.SqlClient, n = yield* s(t);
+					H(n.operations.map((e) => e.op.kind)).toEqual(e === "create" ? ["create-table"] : ["add-column", "add-column"]), yield* K(t, n, {
+						declared: i,
 						appliedBy: "json-ddl",
 						environment: "dev",
 						source: "auto-diff",
 						replan: s
-					}), k((yield* s(e)).operations).toEqual([]);
-				})), await o(`INSERT INTO ${i} (id,metadata,labels) VALUES ('valid','"done"','["x"]')`), await k(o(`INSERT INTO ${i} (id,metadata) VALUES ('invalid','1,2')`)).rejects.toThrow(), await k(o(`INSERT INTO ${i} (id,labels) VALUES ('invalid-array','"x"')`)).rejects.toThrow(), n === "add" && k(await o(`SELECT metadata,labels FROM ${i} WHERE id='existing'`)).toEqual([{
+					}), H((yield* s(t)).operations).toEqual([]);
+				})), await o(`INSERT INTO ${r} (id,metadata,labels) VALUES ('valid','"done"','["x"]')`), await H(o(`INSERT INTO ${r} (id,metadata) VALUES ('invalid','1,2')`)).rejects.toThrow(), await H(o(`INSERT INTO ${r} (id,labels) VALUES ('invalid-array','"x"')`)).rejects.toThrow(), e === "add" && H(await o(`SELECT metadata,labels FROM ${r} WHERE id='existing'`)).toEqual([{
 					metadata: null,
 					labels: null
 				}]);
 			} finally {
-				await o(`DROP TABLE IF EXISTS ${i}`);
+				await o(`DROP TABLE IF EXISTS ${r}`);
 			}
-		}), A.each([
+		}), U.each([
 			"",
 			"1,2",
 			"1,\"other\":2",
@@ -934,12 +1332,12 @@ var K = h("voltro_parity_composite", {
 			"{bad}",
 			"undefined"
 		])("JSON check rejects raw invalid value %j", async (e) => {
-			await k(r.run(b.gen(function* () {
-				let t = yield* j.SqlClient;
-				yield* t`INSERT INTO ${t(W.tableName)} (${t("id")}, ${t("title")}, ${t("metadata")}) VALUES (${"invalid-json"}, ${"probe"}, ${e})`;
+			await H(a.run(D.gen(function* () {
+				let t = yield* G.SqlClient;
+				yield* t`INSERT INTO ${t(Z.tableName)} (${t("id")}, ${t("title")}, ${t("metadata")}) VALUES (${"invalid-json"}, ${"probe"}, ${e})`;
 			}))).rejects.toThrow();
-		}), O.each(["direct", "transactional"])("upsert recorder atomicity (%s)", (e) => {
-			A.each([
+		}), V.each(["direct", "transactional"])("upsert recorder atomicity (%s)", (t) => {
+			U.each([
 				{
 					kind: "native",
 					existing: !1
@@ -956,21 +1354,21 @@ var K = h("voltro_parity_composite", {
 					kind: "functional",
 					existing: !0
 				}
-			])("$kind upsert (existing=$existing) rolls back its write and recorder append", async ({ kind: t, existing: i }) => {
-				let a = r.store, o = "voltro_parity_a", s = {
+			])("$kind upsert (existing=$existing) rolls back its write and recorder append", async ({ kind: n, existing: r }) => {
+				let i = a.store, o = "voltro_parity_a", s = {
 					id: "recorded",
 					title: "before",
 					count: 0
 				};
-				i && await a.insert(o, s);
-				let c = `parity-upsert-${n.dialect.id}`, l = [], u = a.onChange((e) => {
+				r && await i.insert(o, s);
+				let c = `parity-upsert-${e.dialect.id}`, l = [], u = i.onChange((e) => {
 					e.table === o && l.push(e.op);
 				});
-				p(c, {
+				x(c, {
 					tables: [o],
 					ownTables: ["voltro_parity_b"],
 					recorder: async (e, t) => {
-						throw k(t.traceId).toBe("recorder-trace"), k(t.subjectId).toBe("recorder-subject"), await e.append("voltro_parity_b", {
+						throw H(t.traceId).toBe("recorder-trace"), H(t.subjectId).toBe("recorder-subject"), await e.append("voltro_parity_b", {
 							id: "recorder-append",
 							title: "trail"
 						}), Error("recorder refused");
@@ -982,39 +1380,39 @@ var K = h("voltro_parity_composite", {
 					count: 1
 				}, {
 					conflictColumns: ["id"],
-					update: t === "native" ? ["title"] : () => ({ title: "computed" })
+					update: n === "native" ? ["title"] : () => ({ title: "computed" })
 				});
 				try {
-					await k(m({
+					await H(ne({
 						traceId: "recorder-trace",
 						subjectId: "recorder-subject"
-					}, () => e === "direct" ? d(a) : a.transactional(d))).rejects.toThrow("recorder refused"), k(await a.query(R(o))).toEqual(i ? [s] : []), k(await a.query(R("voltro_parity_b"))).toEqual([]), k(l).toEqual([]);
+					}, () => t === "direct" ? d(i) : i.transactional(d))).rejects.toThrow("recorder refused"), H(await i.query(X(o))).toEqual(r ? [s] : []), H(await i.query(X("voltro_parity_b"))).toEqual([]), H(l).toEqual([]);
 				} finally {
-					y(c), u();
+					re(c), u();
 				}
 			});
-		}), A("structured write returns and change images decode exactly once", async () => {
-			let e = r.store, t = W.tableName, n = [], i = e.onChange((e) => {
+		}), U("structured write returns and change images decode exactly once", async () => {
+			let e = a.store, t = Z.tableName, n = [], r = e.onChange((e) => {
 				e.table === t && n.push((e.new ?? e.old)?.metadata);
-			}), a = (e) => ({
+			}), i = (e) => ({
 				id: e,
 				title: "before",
 				metadata: "null",
 				labels: ["x"]
 			});
 			try {
-				k((await e.insertMany(t, [a("one"), a("two")])).map((e) => e.metadata)).toEqual(["null", "null"]), k((await e.upsert(t, a("one"), {
+				H((await e.insertMany(t, [i("one"), i("two")])).map((e) => e.metadata)).toEqual(["null", "null"]), H((await e.upsert(t, i("one"), {
 					conflictColumns: ["id"],
 					update: ["metadata"]
-				})).metadata).toBe("null"), k((await e.insertIgnore(t, a("three"), { conflictColumns: ["id"] })).metadata).toBe("null"), k((await e.insertIgnore(t, a("three"), { conflictColumns: ["id"] })).metadata).toBe("null"), await e.upsert(t, a("one"), {
+				})).metadata).toBe("null"), H((await e.insertIgnore(t, i("three"), { conflictColumns: ["id"] })).metadata).toBe("null"), H((await e.insertIgnore(t, i("three"), { conflictColumns: ["id"] })).metadata).toBe("null"), await e.upsert(t, i("one"), {
 					conflictColumns: ["id"],
-					update: (e) => (k(e.metadata).toBe("null"), { metadata: "null" })
-				}), await e.updateMany(t, { metadata: "null" }, { where: s("id", "one") }), await e.delete(t, "two"), await e.deleteMany(t, { where: s("id", "three") }), k(n.length).toBeGreaterThanOrEqual(8), k(n.every((e) => e === "null")).toBe(!0);
+					update: (e) => (H(e.metadata).toBe("null"), { metadata: "null" })
+				}), await e.updateMany(t, { metadata: "null" }, { where: p("id", "one") }), await e.delete(t, "two"), await e.deleteMany(t, { where: p("id", "three") }), H(n.length).toBeGreaterThanOrEqual(8), H(n.every((e) => e === "null")).toBe(!0);
 			} finally {
-				i();
+				r();
 			}
-		}), O.each(["direct", "transactional"])("JSON patch and column onUpdate (%s)", (e) => {
-			let t = (t) => e === "transactional" ? r.store.transactional(t) : t(r.store), n = [
+		}), V.each(["direct", "transactional"])("JSON patch and column onUpdate (%s)", (e) => {
+			let t = (t) => e === "transactional" ? a.store.transactional(t) : t(a.store), n = [
 				{
 					name: "shallow object merge retains unrelated keys and nulls",
 					before: {
@@ -1232,7 +1630,7 @@ var K = h("voltro_parity_composite", {
 					}
 				}))
 			];
-			A.each(n)("$name with companion fields in the same write", async ({ before: e, path: n, value: r, after: i }) => {
+			U.each(n)("$name with companion fields in the same write", async ({ before: e, path: n, value: r, after: i }) => {
 				await t(async (t) => {
 					await t.insert("voltro_parity_values", {
 						id: "patch",
@@ -1244,19 +1642,19 @@ var K = h("voltro_parity_composite", {
 						title: "after",
 						labels: []
 					});
-					k(a).toMatchObject({
+					H(a).toMatchObject({
 						id: "patch",
 						title: "after",
 						metadata: i,
 						labels: []
-					}), k(await t.query(R("voltro_parity_values"))).toEqual([{
+					}), H(await t.query(X("voltro_parity_values"))).toEqual([{
 						id: "patch",
 						title: "after",
 						metadata: i,
 						labels: []
 					}]);
 				});
-			}), A("refuses companion primary-key or JSON-column replacement before writing", async () => {
+			}), U("refuses companion primary-key or JSON-column replacement before writing", async () => {
 				await t(async (e) => {
 					let t = {
 						id: "refuse",
@@ -1265,16 +1663,16 @@ var K = h("voltro_parity_composite", {
 						labels: []
 					};
 					await e.insert("voltro_parity_values", t);
-					for (let t of [{ id: "renamed" }, { metadata: {} }]) await k(e.patchJson("voltro_parity_values", "refuse", "metadata.value", 1, t)).rejects.toThrow("cannot rewrite");
-					k(await e.query(R("voltro_parity_values"))).toEqual([t]), k(await e.patchJson("voltro_parity_values", "missing", "metadata.value", 1, { title: "absent" })).toBeNull();
+					for (let t of [{ id: "renamed" }, { metadata: {} }]) await H(e.patchJson("voltro_parity_values", "refuse", "metadata.value", 1, t)).rejects.toThrow("cannot rewrite");
+					H(await e.query(X("voltro_parity_values"))).toEqual([t]), H(await e.patchJson("voltro_parity_values", "missing", "metadata.value", 1, { title: "absent" })).toBeNull();
 				});
-			}), A("does not confuse JSON columns named key/value with iterator columns", async () => {
+			}), U("does not confuse JSON columns named key/value with iterator columns", async () => {
 				await t(async (e) => {
-					await e.insert(G.tableName, {
+					await e.insert(Q.tableName, {
 						id: "names",
 						key: { "a\"b": { keep: !0 } },
 						value: { "c\\d": { keep: !1 } }
-					}), await e.patchJson(G.tableName, "names", "key.a\"b.changed", !1), await e.patchJson(G.tableName, "names", "value.c\\d.changed", !0), k(await e.query(R(G.tableName))).toEqual([{
+					}), await e.patchJson(Q.tableName, "names", "key.a\"b.changed", !1), await e.patchJson(Q.tableName, "names", "value.c\\d.changed", !0), H(await e.query(X(Q.tableName))).toEqual([{
 						id: "names",
 						key: { "a\"b": {
 							keep: !0,
@@ -1286,21 +1684,21 @@ var K = h("voltro_parity_composite", {
 						} }
 					}]);
 				});
-			}), A("executes application onUpdate across keyed, bulk, upsert and JSON writes", async () => {
-				let t = C([{
-					tableName: H.tableName,
-					fields: H.fields
+			}), U("executes application onUpdate across keyed, bulk, upsert and JSON writes", async () => {
+				let t = F([{
+					tableName: _e.tableName,
+					fields: _e.fields
 				}, {
-					tableName: W.tableName,
-					fields: W.fields
-				}]), n = T(r.store, {
+					tableName: Z.tableName,
+					fields: Z.fields
+				}]), n = B(a.store, {
 					subject: {
 						type: "anonymous",
 						id: null,
 						tenantId: null
 					},
 					schemaRegistry: t
-				}), i = async (e) => {
+				}), r = async (e) => {
 					let t = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"), n = Date.now();
 					for (let n of [
 						"keyed",
@@ -1312,29 +1710,29 @@ var K = h("voltro_parity_composite", {
 						title: "before",
 						at: t,
 						n: 9
-					}), n === "keyed" ? await e.update("voltro_parity_d", n, { title: "edited" }) : n === "bulk" ? await e.updateMany("voltro_parity_d", { title: "edited" }, { where: s("id", n) }) : await e.upsert("voltro_parity_d", {
+					}), n === "keyed" ? await e.update("voltro_parity_d", n, { title: "edited" }) : n === "bulk" ? await e.updateMany("voltro_parity_d", { title: "edited" }, { where: p("id", n) }) : await e.upsert("voltro_parity_d", {
 						id: n,
 						title: "edited"
 					}, {
 						conflictColumns: ["id"],
 						update: n === "callback" ? () => ({ title: "edited" }) : ["title"]
 					});
-					let r = await e.query(R("voltro_parity_d"));
-					k(r).toHaveLength(4);
+					let r = await e.query(X("voltro_parity_d"));
+					H(r).toHaveLength(4);
 					for (let e of r) {
-						k(e).toMatchObject({
+						H(e).toMatchObject({
 							title: "edited",
 							n: 9
 						});
 						let t = e.at instanceof Date ? e.at.getTime() : new Date(String(e.at)).getTime();
-						k(t).toBeGreaterThanOrEqual(n), k(t).toBeLessThanOrEqual(Date.now());
+						H(t).toBeGreaterThanOrEqual(n), H(t).toBeLessThanOrEqual(Date.now());
 					}
 					await e.insert("voltro_parity_values", {
 						id: "automatic",
 						title: "original",
 						metadata: { keep: !0 },
 						labels: []
-					}), await e.patchJson("voltro_parity_values", "automatic", "metadata.child.value", !1), k(await e.query(R("voltro_parity_values"))).toEqual([{
+					}), await e.patchJson("voltro_parity_values", "automatic", "metadata.child.value", !1), H(await e.query(X("voltro_parity_values"))).toEqual([{
 						id: "automatic",
 						title: "automatic",
 						metadata: {
@@ -1342,7 +1740,7 @@ var K = h("voltro_parity_composite", {
 							child: { value: !1 }
 						},
 						labels: []
-					}]), k(await e.upsert("voltro_parity_d", {
+					}]), H(await e.upsert("voltro_parity_d", {
 						id: "new",
 						title: "insert"
 					}, {
@@ -1350,35 +1748,35 @@ var K = h("voltro_parity_composite", {
 						update: []
 					})).toMatchObject({ at: null });
 				};
-				e === "transactional" ? await n.transactional(i) : await i(n);
+				e === "transactional" ? await n.transactional(r) : await r(n);
 			});
-		}), A("JSON patch companion failure rolls back the JSON write too", async () => {
+		}), U("JSON patch companion failure rolls back the JSON write too", async () => {
 			let e = {
 				id: "atomic-json",
 				title: "keep",
 				metadata: { keep: !0 },
 				labels: []
 			};
-			await r.store.insert("voltro_parity_values", e), await k(r.store.patchJson("voltro_parity_values", e.id, "metadata.changed", !0, { title: null })).rejects.toThrow(), k(await r.store.query(R("voltro_parity_values"))).toEqual([e]);
-		}), A("concurrent JSON patches preserve every sibling and the companion write", async () => {
-			await r.store.insert("voltro_parity_values", {
+			await a.store.insert("voltro_parity_values", e), await H(a.store.patchJson("voltro_parity_values", e.id, "metadata.changed", !0, { title: null })).rejects.toThrow(), H(await a.store.query(X("voltro_parity_values"))).toEqual([e]);
+		}), U("concurrent JSON patches preserve every sibling and the companion write", async () => {
+			await a.store.insert("voltro_parity_values", {
 				id: "concurrent-json",
 				title: "before",
 				metadata: {},
 				labels: []
-			}), await Promise.all(Array.from({ length: 8 }, (e, t) => r.store.transactional((e) => e.patchJson("voltro_parity_values", "concurrent-json", `metadata.key${t}`, t, { title: "after" })))), k(await r.store.query(R("voltro_parity_values"))).toEqual([{
+			}), await Promise.all(Array.from({ length: 8 }, (e, t) => a.store.transactional((e) => e.patchJson("voltro_parity_values", "concurrent-json", `metadata.key${t}`, t, { title: "after" })))), H(await a.store.query(X("voltro_parity_values"))).toEqual([{
 				id: "concurrent-json",
 				title: "after",
 				metadata: Object.fromEntries(Array.from({ length: 8 }, (e, t) => [`key${t}`, t])),
 				labels: []
 			}]);
-		}), A("upsert on a NON-primary-key unique constraint updates that row", async () => {
-			await r.store.upsert("voltro_parity_upsert", {
+		}), U("upsert on a NON-primary-key unique constraint updates that row", async () => {
+			await a.store.upsert("voltro_parity_upsert", {
 				id: "up_first",
 				teamId: "t-1",
 				year: 2026,
 				hours: 10
-			}, { conflictColumns: ["teamId", "year"] }), await r.store.upsert("voltro_parity_upsert", {
+			}, { conflictColumns: ["teamId", "year"] }), await a.store.upsert("voltro_parity_upsert", {
 				id: "up_second",
 				teamId: "t-1",
 				year: 2026,
@@ -1387,16 +1785,16 @@ var K = h("voltro_parity_composite", {
 				conflictColumns: ["teamId", "year"],
 				update: ["hours"]
 			});
-			let e = await r.store.query(R("voltro_parity_upsert"));
-			k(e.length, "the second upsert inserted a duplicate instead of updating").toBe(1), k(e[0]).toMatchObject({
+			let e = await a.store.query(X("voltro_parity_upsert"));
+			H(e.length, "the second upsert inserted a duplicate instead of updating").toBe(1), H(e[0]).toMatchObject({
 				id: "up_first",
 				teamId: "t-1",
 				year: 2026,
 				hours: 111
 			});
-		}), O.each(["direct", "transactional"])("upsert updateValues (%s)", (e) => {
-			let t = (t) => e === "transactional" ? r.store.transactional(t) : t(r.store);
-			A("keeps INSERT defaults and writes omitted columns only on conflict", async () => {
+		}), V.each(["direct", "transactional"])("upsert updateValues (%s)", (e) => {
+			let t = (t) => e === "transactional" ? a.store.transactional(t) : t(a.store);
+			U("keeps INSERT defaults and writes omitted columns only on conflict", async () => {
 				let e = /* @__PURE__ */ new Date("2026-09-05T10:20:30.000Z"), n = {
 					conflictColumns: ["id"],
 					update: [],
@@ -1410,7 +1808,7 @@ var K = h("voltro_parity_composite", {
 						id: "constant",
 						title: "Lobby"
 					}, n);
-					k(r).toMatchObject({
+					H(r).toMatchObject({
 						id: "constant",
 						title: "Lobby",
 						at: null,
@@ -1420,19 +1818,19 @@ var K = h("voltro_parity_composite", {
 						id: "constant",
 						title: "Do not overwrite"
 					}, n);
-					k(i).toMatchObject({
+					H(i).toMatchObject({
 						id: "constant",
 						title: "Lobby",
 						n: 42
-					}), k(new Date(String(i.at)).toISOString()).toBe(e.toISOString());
+					}), H(new Date(String(i.at)).toISOString()).toBe(e.toISOString());
 				});
-				let [i] = await r.store.query(R("voltro_parity_d"));
-				k(i).toMatchObject({
+				let [r] = await a.store.query(X("voltro_parity_d"));
+				H(r).toMatchObject({
 					id: "constant",
 					title: "Lobby",
 					n: 42
-				}), k(new Date(String(i.at)).toISOString()).toBe(e.toISOString());
-			}), A.each([
+				}), H(new Date(String(r.at)).toISOString()).toBe(e.toISOString());
+			}), U.each([
 				"omitted",
 				"empty",
 				"columns",
@@ -1455,19 +1853,19 @@ var K = h("voltro_parity_composite", {
 						...n === void 0 ? {} : { update: n },
 						updateValues: { hours: 42 }
 					});
-					k(r).toMatchObject({
+					H(r).toMatchObject({
 						id: "original",
 						teamId: "t1",
 						year: 2026,
 						hours: 42
 					});
-				}), k(await r.store.query(R("voltro_parity_upsert"))).toEqual([k.objectContaining({
+				}), H(await a.store.query(X("voltro_parity_upsert"))).toEqual([H.objectContaining({
 					id: "original",
 					teamId: "t1",
 					year: 2026,
 					hours: 42
 				})]);
-			}), A("binds explicit NULL to timestamp/int columns and omits undefined assignments", async () => {
+			}), U("binds explicit NULL to timestamp/int columns and omits undefined assignments", async () => {
 				await t(async (e) => {
 					await e.insert("voltro_parity_d", {
 						id: "nulls",
@@ -1489,12 +1887,12 @@ var K = h("voltro_parity_composite", {
 							n: void 0
 						}
 					});
-					k(n).toMatchObject({
+					H(n).toMatchObject({
 						id: "nulls",
 						title: "",
 						at: null,
 						n: 9
-					}), k(await e.upsert("voltro_parity_d", t, {
+					}), H(await e.upsert("voltro_parity_d", t, {
 						conflictColumns: ["id"],
 						update: [],
 						updateValues: { n: null }
@@ -1505,7 +1903,7 @@ var K = h("voltro_parity_composite", {
 						n: null
 					});
 				});
-			}), A("binds false and zero without treating them as omitted", async () => {
+			}), U("binds false and zero without treating them as omitted", async () => {
 				await t(async (e) => {
 					let t = {
 						id: "falsy",
@@ -1521,14 +1919,14 @@ var K = h("voltro_parity_composite", {
 							count: 0
 						}
 					});
-					let n = await e.query(R("voltro_parity_c"));
-					k(n).toEqual([k.objectContaining({
+					let n = await e.query(X("voltro_parity_c"));
+					H(n).toEqual([H.objectContaining({
 						id: "falsy",
 						title: "keep",
 						count: 0
-					})]), k([!1, 0]).toContain(n[0].flag);
+					})]), H([!1, 0]).toContain(n[0].flag);
 				});
-			}), A("encodes JSON/array assignments and binds SQL-looking strings as data", async () => {
+			}), U("encodes JSON/array assignments and binds SQL-looking strings as data", async () => {
 				await t(async (e) => {
 					let t = {
 						id: "structured",
@@ -1553,7 +1951,7 @@ var K = h("voltro_parity_composite", {
 						update: [],
 						updateValues: n
 					};
-					await e.upsert("voltro_parity_values", t, r), k(await e.query(R("voltro_parity_values"))).toEqual([t]), await e.upsert("voltro_parity_values", t, r), k(await e.query(R("voltro_parity_values"))).toEqual([{
+					await e.upsert("voltro_parity_values", t, r), H(await e.query(X("voltro_parity_values"))).toEqual([t]), await e.upsert("voltro_parity_values", t, r), H(await e.query(X("voltro_parity_values"))).toEqual([{
 						id: "structured",
 						...n
 					}]), await e.upsert("voltro_parity_values", t, {
@@ -1562,14 +1960,14 @@ var K = h("voltro_parity_composite", {
 							metadata: null,
 							labels: []
 						}
-					}), k(await e.query(R("voltro_parity_values"))).toEqual([{
+					}), H(await e.query(X("voltro_parity_values"))).toEqual([{
 						id: "structured",
 						title: n.title,
 						metadata: null,
 						labels: []
 					}]);
 				});
-			}), A("keeps structured raw-driver values working through all write verbs", async () => {
+			}), U("keeps structured raw-driver values working through all write verbs", async () => {
 				await t(async (e) => {
 					let t = {
 						title: "before",
@@ -1589,7 +1987,7 @@ var K = h("voltro_parity_composite", {
 					}, {
 						id: "callback",
 						...t
-					}]), await e.update("voltro_parity_values", "single", n), await e.updateMany("voltro_parity_values", n, { where: s("id", "bulk") }), await e.upsert("voltro_parity_values", {
+					}]), await e.update("voltro_parity_values", "single", n), await e.updateMany("voltro_parity_values", n, { where: p("id", "bulk") }), await e.upsert("voltro_parity_values", {
 						id: "callback",
 						...t
 					}, {
@@ -1602,8 +2000,8 @@ var K = h("voltro_parity_composite", {
 						id: "ignore-new",
 						...n
 					}, { conflictColumns: ["id"] });
-					let r = await e.query(R("voltro_parity_values"));
-					k([...r].sort((e, t) => String(e.id).localeCompare(String(t.id)))).toEqual([
+					let r = await e.query(X("voltro_parity_values"));
+					H([...r].sort((e, t) => String(e.id).localeCompare(String(t.id)))).toEqual([
 						{
 							id: "bulk",
 							...n
@@ -1622,7 +2020,7 @@ var K = h("voltro_parity_composite", {
 						}
 					]);
 				});
-			}), A.each([
+			}), U.each([
 				"id",
 				"teamId",
 				"year"
@@ -1638,20 +2036,20 @@ var K = h("voltro_parity_composite", {
 						update: [],
 						updateValues: { [e]: "different" }
 					};
-					await k(t.upsert("voltro_parity_upsert", n, r)).rejects.toThrow("identity"), k(await t.query(R("voltro_parity_upsert"))).toEqual([]), await t.insert("voltro_parity_upsert", n), await k(t.upsert("voltro_parity_upsert", n, r)).rejects.toThrow("identity"), k(await t.query(R("voltro_parity_upsert"))).toEqual([k.objectContaining(n)]);
+					await H(t.upsert("voltro_parity_upsert", n, r)).rejects.toThrow("identity"), H(await t.query(X("voltro_parity_upsert"))).toEqual([]), await t.insert("voltro_parity_upsert", n), await H(t.upsert("voltro_parity_upsert", n, r)).rejects.toThrow("identity"), H(await t.query(X("voltro_parity_upsert"))).toEqual([H.objectContaining(n)]);
 				});
 			});
-		}), A("upsert updateValues rolls back row changes and discards transaction events", async () => {
-			await r.store.insert("voltro_parity_a", {
+		}), U("upsert updateValues rolls back row changes and discards transaction events", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "rollback-values",
 				title: "keep",
 				count: 1
 			});
-			let e = [], t = r.store.onChange((t) => {
+			let e = [], t = a.store.onChange((t) => {
 				e.push(t);
 			});
 			try {
-				await k(r.store.transactional(async (e) => {
+				await H(a.store.transactional(async (e) => {
 					let t = await e.upsert("voltro_parity_a", {
 						id: "rollback-values",
 						title: "incoming",
@@ -1661,25 +2059,25 @@ var K = h("voltro_parity_composite", {
 						update: [],
 						updateValues: { count: 42 }
 					});
-					throw k(t).toMatchObject({
+					throw H(t).toMatchObject({
 						title: "keep",
 						count: 42
 					}), Error("rollback values");
-				})).rejects.toThrow("rollback values"), k(await r.store.query(R("voltro_parity_a"))).toEqual([k.objectContaining({
+				})).rejects.toThrow("rollback values"), H(await a.store.query(X("voltro_parity_a"))).toEqual([H.objectContaining({
 					id: "rollback-values",
 					title: "keep",
 					count: 1
-				})]), k(e).toEqual([]);
+				})]), H(e).toEqual([]);
 			} finally {
 				t();
 			}
-		}), A("and a DIFFERENT row is still not silently overwritten", async () => {
-			await r.store.upsert("voltro_parity_upsert", {
+		}), U("and a DIFFERENT row is still not silently overwritten", async () => {
+			await a.store.upsert("voltro_parity_upsert", {
 				id: "up_a",
 				teamId: "t-1",
 				year: 2026,
 				hours: 1
-			}, { conflictColumns: ["teamId", "year"] }), await r.store.upsert("voltro_parity_upsert", {
+			}, { conflictColumns: ["teamId", "year"] }), await a.store.upsert("voltro_parity_upsert", {
 				id: "up_b",
 				teamId: "t-2",
 				year: 2026,
@@ -1688,66 +2086,66 @@ var K = h("voltro_parity_composite", {
 				conflictColumns: ["teamId", "year"],
 				update: ["hours"]
 			});
-			let e = await r.store.query(R("voltro_parity_upsert"));
-			k(e.length).toBe(2), k([...e].map((e) => e.hours).sort()).toEqual([1, 2]);
-		}), A("insert + update bind an explicit NULL into a datetime2/int column", async () => {
-			let e = await r.store.insert("voltro_parity_d", {
+			let e = await a.store.query(X("voltro_parity_upsert"));
+			H(e.length).toBe(2), H([...e].map((e) => e.hours).sort()).toEqual([1, 2]);
+		}), U("insert + update bind an explicit NULL into a datetime2/int column", async () => {
+			let e = await a.store.insert("voltro_parity_d", {
 				id: "nd1",
 				title: "nulls",
 				at: null,
 				n: null
 			});
-			k(e).toMatchObject({
+			H(e).toMatchObject({
 				id: "nd1",
 				title: "nulls",
 				at: null,
 				n: null
-			}), await r.store.insert("voltro_parity_d", {
+			}), await a.store.insert("voltro_parity_d", {
 				id: "nd2",
 				title: "set",
 				at: /* @__PURE__ */ new Date(),
 				n: 7
 			});
-			let t = await r.store.update("voltro_parity_d", "nd2", {
+			let t = await a.store.update("voltro_parity_d", "nd2", {
 				at: null,
 				n: null
 			});
-			k(t).toMatchObject({
+			H(t).toMatchObject({
 				id: "nd2",
 				at: null,
 				n: null
 			});
-		}), A("updateMany updates only the rows matching the predicate + returns the count", async () => {
-			await r.store.insert("voltro_parity_a", {
+		}), U("updateMany updates only the rows matching the predicate + returns the count", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "m1",
 				title: "x",
 				count: 5
-			}), await r.store.insert("voltro_parity_a", {
+			}), await a.store.insert("voltro_parity_a", {
 				id: "m2",
 				title: "y",
 				count: 5
-			}), await r.store.insert("voltro_parity_a", {
+			}), await a.store.insert("voltro_parity_a", {
 				id: "m3",
 				title: "z",
 				count: 9
 			});
-			let e = await r.store.updateMany("voltro_parity_a", { title: "hit" }, { where: {
+			let e = await a.store.updateMany("voltro_parity_a", { title: "hit" }, { where: {
 				column: "count",
 				op: "eq",
 				value: 5
 			} });
-			k(e).toBe(2);
-			let t = await r.store.query({
-				...R("voltro_parity_a"),
+			H(e).toBe(2);
+			let t = await a.store.query({
+				...X("voltro_parity_a"),
 				predicate: {
 					column: "title",
 					op: "eq",
 					value: "hit"
 				}
 			});
-			k(t.length).toBe(2);
-		}), A("updateMany with an AND predicate is an atomic compare-and-set (the wakeup-claim pattern)", async () => {
-			await r.store.insert("voltro_parity_a", {
+			H(t.length).toBe(2);
+		}), U("updateMany with an AND predicate is an atomic compare-and-set (the wakeup-claim pattern)", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "cas",
 				title: "pending",
 				count: 1
@@ -1760,76 +2158,76 @@ var K = h("voltro_parity_composite", {
 				column: "title",
 				op: "eq",
 				value: e
-			}] }), t = await r.store.updateMany("voltro_parity_a", { title: "claimed" }, { where: e("pending") });
-			k(t).toBe(1);
-			let n = await r.store.updateMany("voltro_parity_a", { title: "claimed-again" }, { where: e("pending") });
-			k(n).toBe(0);
-		}), A("deleteMany removes only the rows matching the predicate + returns the count", async () => {
-			await r.store.insert("voltro_parity_a", {
+			}] }), t = await a.store.updateMany("voltro_parity_a", { title: "claimed" }, { where: e("pending") });
+			H(t).toBe(1);
+			let n = await a.store.updateMany("voltro_parity_a", { title: "claimed-again" }, { where: e("pending") });
+			H(n).toBe(0);
+		}), U("deleteMany removes only the rows matching the predicate + returns the count", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "d1",
 				title: "x",
 				count: 5
-			}), await r.store.insert("voltro_parity_a", {
+			}), await a.store.insert("voltro_parity_a", {
 				id: "d2",
 				title: "y",
 				count: 5
-			}), await r.store.insert("voltro_parity_a", {
+			}), await a.store.insert("voltro_parity_a", {
 				id: "d3",
 				title: "z",
 				count: 9
 			});
-			let e = await r.store.deleteMany("voltro_parity_a", { where: {
+			let e = await a.store.deleteMany("voltro_parity_a", { where: {
 				column: "count",
 				op: "eq",
 				value: 5
 			} });
-			k(e).toBe(2);
-			let t = await r.store.query(R("voltro_parity_a"));
-			k(t.map((e) => e.id)).toEqual(["d3"]);
-		}), A("deleteMany emits one delete ChangeEvent per removed row (old-image)", async () => {
-			await r.store.insert("voltro_parity_a", {
+			H(e).toBe(2);
+			let t = await a.store.query(X("voltro_parity_a"));
+			H(t.map((e) => e.id)).toEqual(["d3"]);
+		}), U("deleteMany emits one delete ChangeEvent per removed row (old-image)", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "e1",
 				title: "gone",
 				count: 1
-			}), await r.store.insert("voltro_parity_a", {
+			}), await a.store.insert("voltro_parity_a", {
 				id: "e2",
 				title: "gone",
 				count: 1
-			}), await r.store.insert("voltro_parity_a", {
+			}), await a.store.insert("voltro_parity_a", {
 				id: "e3",
 				title: "stay",
 				count: 2
 			});
-			let e = [], t = r.store.onChange((t) => e.push({
+			let e = [], t = a.store.onChange((t) => e.push({
 				op: t.op,
 				id: t.old?.id
-			})), n = await r.store.deleteMany("voltro_parity_a", { where: {
+			})), n = await a.store.deleteMany("voltro_parity_a", { where: {
 				column: "title",
 				op: "eq",
 				value: "gone"
 			} });
-			t(), k(n).toBe(2);
-			let i = e.filter((e) => e.op === "delete");
-			k(i).toHaveLength(2), k(i.map((e) => e.id).sort()).toEqual(["e1", "e2"]);
-		}), A("deleteMany with no match returns 0 and removes nothing", async () => {
-			await r.store.insert("voltro_parity_a", {
+			t(), H(n).toBe(2);
+			let r = e.filter((e) => e.op === "delete");
+			H(r).toHaveLength(2), H(r.map((e) => e.id).sort()).toEqual(["e1", "e2"]);
+		}), U("deleteMany with no match returns 0 and removes nothing", async () => {
+			await a.store.insert("voltro_parity_a", {
 				id: "k1",
 				title: "keep",
 				count: 1
 			});
-			let e = await r.store.deleteMany("voltro_parity_a", { where: {
+			let e = await a.store.deleteMany("voltro_parity_a", { where: {
 				column: "title",
 				op: "eq",
 				value: "absent"
 			} });
-			k(e).toBe(0);
-			let t = await r.store.query(R("voltro_parity_a"));
-			k(t.length).toBe(1);
-		}), A("retryFilter recognises the dialect's own transient codes", () => {
-			let e = n.dialect.retryFilter(/* @__PURE__ */ Error("garbage"));
-			k(["retry", "noRetry"]).toContain(e);
+			H(e).toBe(0);
+			let t = await a.store.query(X("voltro_parity_a"));
+			H(t.length).toBe(1);
+		}), U("retryFilter recognises the dialect's own transient codes", () => {
+			let t = e.dialect.retryFilter(/* @__PURE__ */ Error("garbage"));
+			H(["retry", "noRetry"]).toContain(t);
 		});
 	});
 };
 //#endregion
-export { N as applySchema, Y as runDialectParity };
+export { q as applySchema, $ as runDialectParity, e as runHotStoreSqlParity };