@voltro/testing 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -39,6 +39,44 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.11.2] — 2026-07-24
+
+### Added
+
+- **@voltro/i18n** — Two escapes for adopting typed messages (`createTypedMessages`, #16) app-wide (#19):
+
+  - **`t.dynamic(runtimeKey, values?)`** — a first-class escape for a genuinely runtime-computed key, on both `useT` and the `useTFn()` result. It takes a plain string with NO forced ICU args, so it doesn't fight the strict literal-key surface. Until now the natural escape — casting a computed key to the catalog key union — made things WORSE: that union spans placeholder-bearing keys, so the call then demanded a spurious 2nd ICU arg. `t.dynamic` is the documented, discoverable alternative. - **`LooseTFunction`** — the widened `(id: string, values?) => string` signature to type a `t` pass-through across a package boundary that can't import the app catalog, instead of falling back to `(...args: any[]) => string`. A strict `TypedTFunction` is deliberately NOT assignable to it (a narrowed key param can't satisfy a wider one — that would erase the checking); pass `t.dynamic` at the boundary, which IS a `LooseTFunction`.
+
+  Additive: `TypedTFunction<C>` gains a `.dynamic` member (the callable surface is unchanged, so `Parameters<TypedTFunction<C>>[0]` and existing typed call sites still resolve). `createTypedMessages` attaches `.dynamic` in place on the two translate functions — no new per-render closure, so a captured `t`'s identity stays stable.
+- **@voltro/testing, @voltro/database** — `fixtureRow(table, overrides)` (`@voltro/testing`) completes a partial test row so it satisfies the 0.11.1 required-column insert validation — WITHOUT disabling the check. It fills every NOT-NULL, no-default, non-auto-stamped column the payload omits with a schema-typed placeholder (a `oneOf` column takes its first allowed value; a `unique` column gets a distinct value per call so two fixtures don't collide; `timestamp`/`date` get a fixed epoch), then merges your overrides on top (an explicit value always wins). It leaves out exactly what a caller may omit — nullable, defaulted, and framework auto-stamped columns (id / tenant / audit) — and refuses to guess a structured type (`json` / `bytes` / `vector` / `array` / `interval` / `raw`), throwing a message that names the column and says to pass it explicitly.
+
+  The motivating case: 0.11.1 made the in-memory/test store reject the same partial inserts real Postgres always would (correct — it surfaced a latent prod bug), which turned lean fixtures (`insert(users, { id })`, an omitted required FK) into `TableValidationFailed`. The wrong fix is a `validateInserts: false` knob — it re-hides that bug class, and a test store laxer than production is a fake testing itself. `fixtureRow` is the right one: it makes the fixture COMPLETE.
+
+  ```ts
+  await ctx.store.insert('journal_entries', fixtureRow(journalEntries, {
+    tenantId, amount: '100.00',   // the columns THIS test cares about
+  }))                             // entryNumber, postedAt, … auto-filled + unique
+  ```
+
+  It is a runtime filler for the loose `store.insert(name, row)` path (what fixtures use). For COMPILE-time payload typing, use `insertRow` / `upsertRow` from `@voltro/database`. The auto-stamped column set it skips is now exported as `AUTO_FILLED_COLUMNS` from `@voltro/database` — the same list `InferInsertRow` derives its optional columns from, single-sourced so the two can't drift.
+
+### Changed
+
+- **@voltro/cli** — `voltro build` now emits **directly-executable** boot bundles for BOTH app kinds: the web start bundle (`.framework/dist-web/startBundle/startEntry.js`) and the api serve bundle (`.framework/dist-api/serveBundle/serveEntry.js`) each carry a main-guard that boots the app when run as `node <entry>.js`, and stays inert when imported (the `voltro start` / `voltro serve` dev fast paths are unchanged). Production containers can now use `CMD ["node", "…/startEntry.js"]` (or `serveEntry.js`) instead of `pnpm voltro start` / `pnpm voltro serve` — no pnpm process, no `@voltro/cli` bin at runtime — which is what makes `voltro prune-runtime` safe to enable on both: with the self-contained bundle as the real entrypoint, the @vercel/nft trace roots there and legitimately drops `@voltro/cli` and the whole inlined framework tree (a static site's `node_modules` collapses to ~0; a memory api's 146 MB → 11 MB). `prune-runtime` now also roots the trace at the serve bundle. The serve entry chdir's to the app root BEFORE its app-module registry keys are computed from cwd, preserving relocation-safety. Existing `pnpm voltro start` / `pnpm voltro serve` entrypoints keep working. The standalone Dockerfiles gain a build-time boot smoke that fails the build unless the pruned tree reaches ready.
+
+### Fixed
+
+- **@voltro/i18n** — `createTypedMessages` (#16) no longer extracts phantom required vars from a nested plural/select message (#19). For `'{count, plural, one {# day} other {# days total duration}}'`, the type-level `ICUVars` parse was reading a branch's TEXT (`"# days total duration"`) as a bogus required arg name, so `useT('key', { count })` failed to typecheck even though it renders perfectly — and a real var nested inside a branch was dropped. `ICUArgName` now resolves to `never` for any candidate that isn't a valid ICU identifier (`^[A-Za-z0-9_]+$`), so branch text — which contains spaces / `#` / `—` — is never mistaken for a var. Only the top-level arg (`count`) is required, matching what the message actually needs.
+
+  Scope note: a REAL var nested inside a plural branch (`other {# — {discipline}}`) is still not collected, so it reads as not-required rather than wrongly-required — the safe direction. Apps that pluralise in JS over simple `{count}` messages (the Voltro idiom) were already fully typed and are unaffected.
+- **@voltro/database, @voltro/runtime** — `InferInsertRow` (and thus `insertRow` / `upsertRow`, #15) no longer requires a non-nullable DB-generated (`generatedAs`) column (#20). A stored/virtual generated column declared without `.nullable()` and without a default was typed **required**, but MariaDB/Postgres REJECT an explicit value for a generated column — so the type forced the caller to pass a value the database refuses at runtime. `.generatedAs()` now marks the column optional-for-insert exactly like a `.default()` column (the DB supplies it), so it may be omitted; the whole payload guard on every real column stays intact.
+
+  Two runtime halves complete it, so the loose `store.insert(name, row)` path agrees: the required-column validation (`missingRequiredColumns`) skips generated columns — omitting one is correct, never a missing-column error — and the store write path now STRIPS any value a caller supplied for a generated column before the INSERT reaches the dialect (tracked on the schema registry as `generatedColumns`), so a value from an untyped insert can't blow up on MariaDB. A generated column is never caller-supplied; the framework and the DB own it end to end.
+
+  The `.generatedAs()` return type narrows from `this` to `ColumnBuilder<…, true>` (the HasDefault flag) — a purely more-permissive refinement: it only makes the column omittable, so no existing code stops compiling.
+
+---
+
 ## [0.11.1] — 2026-07-23
 
 ### Added
@@ -71,6 +109,8 @@ _Changes staged for the next release accumulate here (rolled up from
 - **@voltro/database, @voltro/runtime** — `store.insert` / `upsert` / `insertIgnore` now raise a clear, typed `TableValidationFailed` naming the column when the payload omits one that is NOT NULL, has no default, and isn't auto-stamped — instead of a raw dialect `SqlError: Failed to execute statement` (`Field '…' doesn't have a default value`) surfaced only on the INSERT path (so it lay dormant until the first row with no existing cache entry). An upsert / insertIgnore whose payload is missing one of its own `conflictColumns` is likewise named at the call (an absent conflict key can't match its target). The check runs AFTER stamping, so auto-id / tenant / audit columns never trip it, and skips nullable, defaulted, and id (`idScheme`) columns — exactly the ones a caller may legitimately omit.
 
   Two pure helpers back it — `missingRequiredColumns(table, row)` and `missingConflictColumns(conflictColumns, row)` (exported from `@voltro/database`). This is the runtime half of the "handler data silently disagrees with the schema" class; a compile-time payload type needs the column DSL to track `hasDefault` at the type level, which is a separate change.
+
+  **Migration impact — behaviour-breaking for lenient test fixtures.** The in-memory/test store now rejects the same partial inserts a real Postgres always would, so it stops being laxer than production — which is the point (it surfaced at least one latent prod bug where a NOT-NULL `text().unique()` column was written without a value). But a fixture that inserted a partial row (`{ id }` parents, an omitted required FK) and passed against the old lenient memory store now throws `TableValidationFailed`. There is no code-level codemod — the fix is fixture DATA: fill the required columns. Use the new `fixtureRow(table, overrides)` helper in `@voltro/testing`, which fills every NOT-NULL-no-default column with a schema-typed placeholder and merges your overrides on top, so a fixture complies without disabling the check. There is deliberately no opt-out to turn the validation off: a test store that accepts rows production rejects is a fake testing itself.
 - **@voltro/database, @voltro/plugin-ai-flows, @voltro/plugin-audit, @voltro/plugin-deactivation, @voltro/plugin-soft-delete** — Compile-time payload typing for writes (#15) — the type-level half that the runtime `TableValidationFailed` guard flagged as a separate change. `insertRow` / `upsertRow` take the TABLE OBJECT (not a string name), so the payload is checked against `InferInsertRow<T>`: every column is required EXCEPT nullable ones, columns with a default, and the framework-filled id/tenant/audit columns. A missing NOT-NULL-no-default column — the exact `lastRefreshedAt` / `teamId` omission from the report — is now a COMPILE error at the call, not a runtime SqlError only on the INSERT path; `upsertRow`'s `conflictColumns` are constrained to the table's own columns too.
 
   import { insertRow } from '@voltro/database' await insertRow(ctx.store, roadmapEpicStats, { teamId, lastRefreshedAt: new Date() })

package/dist/dialect.js

@@ -1,5 +1,5 @@
-import { _voltroUndoLogTable as e, applyInverses as t, synthesizeInverse as n } from "@voltro/runtime";
-import { boolean as r, eq as i, id as a, integer as o, table as s, text as c, timestamp as l } from "@voltro/database";
+import { boolean as e, eq as t, id as n, integer as r, table as i, text as a, timestamp as o } from "@voltro/database";
+import { _voltroUndoLogTable as s, applyInverses as c, synthesizeInverse as l } from "@voltro/runtime";
 import { afterEach as u, beforeEach as d, describe as f, expect as p, it as m } from "vitest";
 import { applySchema as h } from "@voltro/database/sql";
 //#region src/dialectParity.ts
@@ -10,33 +10,33 @@ var g = (e) => ({
 	take: void 0,
 	skip: void 0,
 	projection: void 0
-}), _ = s("voltro_parity_a", {
-	id: a(),
-	title: c(),
-	count: o()
-}), v = s("voltro_parity_b", {
-	id: a(),
-	title: c()
-}), y = s("voltro_parity_c", {
-	id: a(),
-	title: c(),
-	count: o(),
-	flag: r().default(!1)
-}), b = s("voltro_parity_d", {
-	id: a(),
-	title: c(),
-	at: l().nullable(),
-	n: o().nullable()
-}), x = (r) => {
-	f(`dialect parity: ${r.name ?? r.dialect.id}`, () => {
-		let a = null;
+}), _ = i("voltro_parity_a", {
+	id: n(),
+	title: a(),
+	count: r()
+}), v = i("voltro_parity_b", {
+	id: n(),
+	title: a()
+}), y = i("voltro_parity_c", {
+	id: n(),
+	title: a(),
+	count: r(),
+	flag: e().default(!1)
+}), b = i("voltro_parity_d", {
+	id: n(),
+	title: a(),
+	at: o().nullable(),
+	n: r().nullable()
+}), x = (e) => {
+	f(`dialect parity: ${e.name ?? e.dialect.id}`, () => {
+		let n = null;
 		d(async () => {
-			await r.setup(), a = await r.make(), await a.migrate([
+			await e.setup(), n = await e.make(), await n.migrate([
 				_,
 				v,
 				y,
 				b,
-				e
+				s
 			]);
 			for (let e of [
 				"voltro_parity_a",
@@ -45,15 +45,15 @@ var g = (e) => ({
 				"voltro_parity_d",
 				"_voltro_undo_log"
 			]) {
-				let t = await a.store.query(g(e));
-				for (let n of t) await a.store.delete(e, n.id);
+				let t = await n.store.query(g(e));
+				for (let r of t) await n.store.delete(e, r.id);
 			}
 		}), u(async () => {
-			await a?.dispose(), await r.teardown(), a = null;
+			await n?.dispose(), await e.teardown(), n = null;
 		}), m("DDL is idempotent — re-applying the schema is a no-op", async () => {
-			await a.migrate([_, v]);
+			await n.migrate([_, v]);
 		}), m("insert + query round-trips a row", async () => {
-			p(await a.store.insert("voltro_parity_a", {
+			p(await n.store.insert("voltro_parity_a", {
 				id: "a1",
 				title: "one",
 				count: 1
@@ -62,23 +62,23 @@ var g = (e) => ({
 				title: "one",
 				count: 1
 			});
-			let e = await a.store.query(g("voltro_parity_a"));
+			let e = await n.store.query(g("voltro_parity_a"));
 			p(e.length).toBe(1), p(e[0]?.id).toBe("a1");
 		}), m("update returns the post-image", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "a2",
 				title: "pre",
 				count: 1
-			}), p(await a.store.update("voltro_parity_a", "a2", { title: "post" })).toMatchObject({
+			}), p(await n.store.update("voltro_parity_a", "a2", { title: "post" })).toMatchObject({
 				id: "a2",
 				title: "post"
 			});
 		}), m("delete removes the row + reports true", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "a3",
 				title: "x",
 				count: 1
-			}), p(await a.store.delete("voltro_parity_a", "a3")).toBe(!0), p((await a.store.query(g("voltro_parity_a"))).length).toBe(0);
+			}), p(await n.store.delete("voltro_parity_a", "a3")).toBe(!0), p((await n.store.query(g("voltro_parity_a"))).length).toBe(0);
 		}), m("undo: the _voltro_undo_log TEXT changes column round-trips a JSON ChangeSet", async () => {
 			let e = [{
 				table: "voltro_parity_c",
@@ -97,7 +97,7 @@ var g = (e) => ({
 					flag: !1
 				}
 			}];
-			await a.store.insert("_voltro_undo_log", {
+			await n.store.insert("_voltro_undo_log", {
 				id: "undo_p1",
 				tag: "parityC.update",
 				label: null,
@@ -109,7 +109,7 @@ var g = (e) => ({
 				undone: !1,
 				createdAt: /* @__PURE__ */ new Date()
 			});
-			let t = await a.store.query(g("_voltro_undo_log"));
+			let t = await n.store.query(g("_voltro_undo_log"));
 			p(t.length).toBe(1), p(JSON.parse(t[0].changes)).toEqual(e);
 		}), m("undo: reverts an INSERT (inverse delete) on this dialect", async () => {
 			let e = {
@@ -118,7 +118,7 @@ var g = (e) => ({
 				changes: [{
 					table: "voltro_parity_c",
 					op: "insert",
-					next: await a.store.insert("voltro_parity_c", {
+					next: await n.store.insert("voltro_parity_c", {
 						id: "c2",
 						title: "new",
 						count: 1,
@@ -126,23 +126,23 @@ var g = (e) => ({
 					})
 				}]
 			};
-			await t(a.store, n(e)), p((await a.store.query(g("voltro_parity_c"))).find((e) => e.id === "c2")).toBeUndefined();
+			await c(n.store, l(e)), p((await n.store.query(g("voltro_parity_c"))).find((e) => e.id === "c2")).toBeUndefined();
 		}), m("undo: reverts an UPDATE including the BOOLEAN, restoring the captured value FAITHFULLY", async () => {
-			await a.store.insert("voltro_parity_c", {
+			await n.store.insert("voltro_parity_c", {
 				id: "c3",
 				title: "t",
 				count: 1,
 				flag: !0
 			});
-			let e = (await a.store.query({
+			let e = (await n.store.query({
 				...g("voltro_parity_c"),
-				predicate: i("id", "c3")
-			}))[0], r = await a.store.update("voltro_parity_c", "c3", {
+				predicate: t("id", "c3")
+			}))[0], r = await n.store.update("voltro_parity_c", "c3", {
 				count: 2,
 				flag: !1
 			});
 			p(r.flag).not.toEqual(e.flag);
-			let o = {
+			let i = {
 				invocationId: "inv2",
 				subject: null,
 				changes: [{
@@ -153,20 +153,20 @@ var g = (e) => ({
 					next: r
 				}]
 			};
-			await t(a.store, n(o));
-			let s = (await a.store.query({
+			await c(n.store, l(i));
+			let a = (await n.store.query({
 				...g("voltro_parity_c"),
-				predicate: i("id", "c3")
+				predicate: t("id", "c3")
 			}))[0];
-			p(s.flag).toEqual(e.flag), p(s.count).toEqual(e.count);
+			p(a.flag).toEqual(e.flag), p(a.count).toEqual(e.count);
 		}), m("undo: reverts a DELETE (inverse re-insert) on this dialect", async () => {
-			let e = await a.store.insert("voltro_parity_c", {
+			let e = await n.store.insert("voltro_parity_c", {
 				id: "c4",
 				title: "gone",
 				count: 9,
 				flag: !0
 			});
-			await a.store.delete("voltro_parity_c", "c4");
+			await n.store.delete("voltro_parity_c", "c4");
 			let r = {
 				invocationId: "inv3",
 				subject: null,
@@ -177,19 +177,19 @@ var g = (e) => ({
 					prev: e
 				}]
 			};
-			await t(a.store, n(r));
-			let o = (await a.store.query({
+			await c(n.store, l(r));
+			let i = (await n.store.query({
 				...g("voltro_parity_c"),
-				predicate: i("id", "c4")
+				predicate: t("id", "c4")
 			}))[0];
-			p(o.id).toBe("c4"), p(o.title).toBe("gone"), p(o.flag).toEqual(e.flag);
+			p(i.id).toBe("c4"), p(i.title).toBe("gone"), p(i.flag).toEqual(e.flag);
 		}), m("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", {
+			let e = [], t = n.store.onChange((t) => e.push(t.op));
+			await n.store.insert("voltro_parity_a", {
 				id: "a4",
 				title: "a",
 				count: 1
-			}), await a.store.update("voltro_parity_a", "a4", { title: "b" }), await a.store.delete("voltro_parity_a", "a4"), t(), p(e).toEqual([
+			}), await n.store.update("voltro_parity_a", "a4", { title: "b" }), await n.store.delete("voltro_parity_a", "a4"), t(), p(e).toEqual([
 				"insert",
 				"update",
 				"delete"
@@ -199,22 +199,22 @@ var g = (e) => ({
 				e.push(t.name);
 			};
 			process.on("warning", t);
-			let n = Array.from({ length: 32 }, () => a.store.onChange(() => {}));
+			let r = Array.from({ length: 32 }, () => n.store.onChange(() => {}));
 			await new Promise((e) => setImmediate(e));
-			for (let e of n) e();
+			for (let e of r) e();
 			process.off("warning", t), p(e.filter((e) => e === "MaxListenersExceededWarning"), "the change bus still warns at 11 listeners — `raiseChangeListenerCeiling` is not wired into this dialect’s store").toEqual([]);
 		}), m("transactional rolls back on throw + drops queued events", async () => {
-			let e = [], t = a.store.onChange((t) => e.push(t.op));
-			await p(a.store.transactional(async (e) => {
+			let e = [], t = n.store.onChange((t) => e.push(t.op));
+			await p(n.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(), p(e).toEqual([]), p((await a.store.query(g("voltro_parity_a"))).length).toBe(0);
+			})).rejects.toThrow("intentional rollback"), t(), p(e).toEqual([]), p((await n.store.query(g("voltro_parity_a"))).length).toBe(0);
 		}), m("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) => {
+			let e = [], t = n.store.onChange((t) => e.push(t.op));
+			await n.store.transactional(async (e) => {
 				await e.insert("voltro_parity_a", {
 					id: "commit1",
 					title: "a",
@@ -226,11 +226,11 @@ var g = (e) => ({
 				});
 			}), t(), p(e).toEqual(["insert", "insert"]);
 		}), m("upsert inserts a new row, then updates on conflict — no duplicate", async () => {
-			await a.store.upsert("voltro_parity_a", {
+			await n.store.upsert("voltro_parity_a", {
 				id: "u1",
 				title: "first",
 				count: 1
-			}, { conflictColumns: ["id"] }), await a.store.upsert("voltro_parity_a", {
+			}, { conflictColumns: ["id"] }), await n.store.upsert("voltro_parity_a", {
 				id: "u1",
 				title: "second",
 				count: 2
@@ -238,14 +238,14 @@ var g = (e) => ({
 				conflictColumns: ["id"],
 				update: ["title", "count"]
 			});
-			let e = await a.store.query(g("voltro_parity_a"));
+			let e = await n.store.query(g("voltro_parity_a"));
 			p(e.length).toBe(1), p(e[0]).toMatchObject({
 				id: "u1",
 				title: "second",
 				count: 2
 			});
 		}), m("insert + update bind an explicit NULL into a datetime2/int column", async () => {
-			p(await a.store.insert("voltro_parity_d", {
+			p(await n.store.insert("voltro_parity_d", {
 				id: "nd1",
 				title: "nulls",
 				at: null,
@@ -255,12 +255,12 @@ var g = (e) => ({
 				title: "nulls",
 				at: null,
 				n: null
-			}), await a.store.insert("voltro_parity_d", {
+			}), await n.store.insert("voltro_parity_d", {
 				id: "nd2",
 				title: "set",
 				at: /* @__PURE__ */ new Date(),
 				n: 7
-			}), p(await a.store.update("voltro_parity_d", "nd2", {
+			}), p(await n.store.update("voltro_parity_d", "nd2", {
 				at: null,
 				n: null
 			})).toMatchObject({
@@ -269,23 +269,23 @@ var g = (e) => ({
 				n: null
 			});
 		}), m("updateMany updates only the rows matching the predicate + returns the count", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "m1",
 				title: "x",
 				count: 5
-			}), await a.store.insert("voltro_parity_a", {
+			}), await n.store.insert("voltro_parity_a", {
 				id: "m2",
 				title: "y",
 				count: 5
-			}), await a.store.insert("voltro_parity_a", {
+			}), await n.store.insert("voltro_parity_a", {
 				id: "m3",
 				title: "z",
 				count: 9
-			}), p(await a.store.updateMany("voltro_parity_a", { title: "hit" }, { where: {
+			}), p(await n.store.updateMany("voltro_parity_a", { title: "hit" }, { where: {
 				column: "count",
 				op: "eq",
 				value: 5
-			} })).toBe(2), p((await a.store.query({
+			} })).toBe(2), p((await n.store.query({
 				...g("voltro_parity_a"),
 				predicate: {
 					column: "title",
@@ -294,7 +294,7 @@ var g = (e) => ({
 				}
 			})).length).toBe(2);
 		}), m("updateMany with an AND predicate is an atomic compare-and-set (the wakeup-claim pattern)", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "cas",
 				title: "pending",
 				count: 1
@@ -308,63 +308,63 @@ var g = (e) => ({
 				op: "eq",
 				value: e
 			}] });
-			p(await a.store.updateMany("voltro_parity_a", { title: "claimed" }, { where: e("pending") })).toBe(1), p(await a.store.updateMany("voltro_parity_a", { title: "claimed-again" }, { where: e("pending") })).toBe(0);
+			p(await n.store.updateMany("voltro_parity_a", { title: "claimed" }, { where: e("pending") })).toBe(1), p(await n.store.updateMany("voltro_parity_a", { title: "claimed-again" }, { where: e("pending") })).toBe(0);
 		}), m("deleteMany removes only the rows matching the predicate + returns the count", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "d1",
 				title: "x",
 				count: 5
-			}), await a.store.insert("voltro_parity_a", {
+			}), await n.store.insert("voltro_parity_a", {
 				id: "d2",
 				title: "y",
 				count: 5
-			}), await a.store.insert("voltro_parity_a", {
+			}), await n.store.insert("voltro_parity_a", {
 				id: "d3",
 				title: "z",
 				count: 9
-			}), p(await a.store.deleteMany("voltro_parity_a", { where: {
+			}), p(await n.store.deleteMany("voltro_parity_a", { where: {
 				column: "count",
 				op: "eq",
 				value: 5
-			} })).toBe(2), p((await a.store.query(g("voltro_parity_a"))).map((e) => e.id)).toEqual(["d3"]);
+			} })).toBe(2), p((await n.store.query(g("voltro_parity_a"))).map((e) => e.id)).toEqual(["d3"]);
 		}), m("deleteMany emits one delete ChangeEvent per removed row (old-image)", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "e1",
 				title: "gone",
 				count: 1
-			}), await a.store.insert("voltro_parity_a", {
+			}), await n.store.insert("voltro_parity_a", {
 				id: "e2",
 				title: "gone",
 				count: 1
-			}), await a.store.insert("voltro_parity_a", {
+			}), await n.store.insert("voltro_parity_a", {
 				id: "e3",
 				title: "stay",
 				count: 2
 			});
-			let e = [], t = a.store.onChange((t) => e.push({
+			let e = [], t = n.store.onChange((t) => e.push({
 				op: t.op,
 				id: t.old?.id
-			})), n = await a.store.deleteMany("voltro_parity_a", { where: {
+			})), r = await n.store.deleteMany("voltro_parity_a", { where: {
 				column: "title",
 				op: "eq",
 				value: "gone"
 			} });
-			t(), p(n).toBe(2);
-			let r = e.filter((e) => e.op === "delete");
-			p(r).toHaveLength(2), p(r.map((e) => e.id).sort()).toEqual(["e1", "e2"]);
+			t(), p(r).toBe(2);
+			let i = e.filter((e) => e.op === "delete");
+			p(i).toHaveLength(2), p(i.map((e) => e.id).sort()).toEqual(["e1", "e2"]);
 		}), m("deleteMany with no match returns 0 and removes nothing", async () => {
-			await a.store.insert("voltro_parity_a", {
+			await n.store.insert("voltro_parity_a", {
 				id: "k1",
 				title: "keep",
 				count: 1
-			}), p(await a.store.deleteMany("voltro_parity_a", { where: {
+			}), p(await n.store.deleteMany("voltro_parity_a", { where: {
 				column: "title",
 				op: "eq",
 				value: "absent"
-			} })).toBe(0), p((await a.store.query(g("voltro_parity_a"))).length).toBe(1);
+			} })).toBe(0), p((await n.store.query(g("voltro_parity_a"))).length).toBe(1);
 		}), m("retryFilter recognises the dialect's own transient codes", () => {
-			let e = r.dialect.retryFilter(/* @__PURE__ */ Error("garbage"));
-			p(["retry", "noRetry"]).toContain(e);
+			let t = e.dialect.retryFilter(/* @__PURE__ */ Error("garbage"));
+			p(["retry", "noRetry"]).toContain(t);
 		});
 	});
 };

package/dist/index.d.ts

@@ -23,6 +23,15 @@ import { VoltroPlugin } from '@voltro/protocol';
  *  ergonomic without an `any` in the public type. */
 declare type ErasedWorkflowEffect = Effect.Effect<unknown, unknown, never>;
 
+/**
+ * Complete a partial row for `table` so it satisfies the required-column insert
+ * validation. Fills every NOT-NULL, no-default, non-auto-stamped column that
+ * `overrides` doesn't already supply, then merges `overrides` on top (an explicit
+ * value — including `null` — always wins). Returns a plain row for the loose
+ * `store.insert(name, row)` path.
+ */
+export declare const fixtureRow: (table: TableLike, overrides?: Row) => Row;
+
 /**
  * What `invoke` resolves to for a handler returning `Result`: an `Effect`'s
  * SUCCESS value, an awaited `Promise`, or the value itself.

package/dist/index.js

@@ -1,11 +1,36 @@
-import { Cause as e, Effect as t, Exit as n, Layer as r, Schema as i } from "effect";
-import { SubjectService as a, anonymousSubject as o, checkGuardsEffect as s, composeRpcInterceptors as c } from "@voltro/protocol";
-import { InMemoryDataStore as l, applyRowFilterToDescriptor as u, clearSystemStoreHandle as d, getRowFilter as f, getSystemStoreHandle as p, makeAppAccess as m, makeDataLoader as h, makeEffectStoreLayer as g, makeOutboxFacade as _, makeSchemaRegistry as v, resolveRowFilterScopeFor as y, runProvidedEffect as b, runWithDeadlockRetry as x, setSystemStoreHandle as S, wrapStoreWithMixinBehaviour as C } from "@voltro/runtime";
-import { allRegisteredTables as w, clearRelationsRegistry as T, registerRelations as E } from "@voltro/database";
-import { installEnvSnapshot as D } from "@voltro/env";
-import { CurrentWorkflowRunId as O, inMemoryWorkflowEngineLayer as k, makeInMemoryRecorder as A } from "@voltro/workflow";
-//#region src/mockClock.ts
-var j = class {
+import { AUTO_FILLED_COLUMNS as e, allRegisteredTables as t, clearRelationsRegistry as n, missingRequiredColumns as r, registerRelations as i } from "@voltro/database";
+import { Cause as a, Effect as o, Exit as s, Layer as c, Schema as l } from "effect";
+import { SubjectService as u, anonymousSubject as d, checkGuardsEffect as f, composeRpcInterceptors as p } from "@voltro/protocol";
+import { InMemoryDataStore as m, applyRowFilterToDescriptor as h, clearSystemStoreHandle as g, getRowFilter as _, getSystemStoreHandle as v, makeAppAccess as y, makeDataLoader as b, makeEffectStoreLayer as ee, makeOutboxFacade as x, makeSchemaRegistry as S, resolveRowFilterScopeFor as C, runProvidedEffect as w, runWithDeadlockRetry as T, setSystemStoreHandle as E, wrapStoreWithMixinBehaviour as D } from "@voltro/runtime";
+import { installEnvSnapshot as O } from "@voltro/env";
+import { CurrentWorkflowRunId as k, inMemoryWorkflowEngineLayer as A, makeInMemoryRecorder as j } from "@voltro/workflow";
+//#region src/fixtureRow.ts
+var M = new Set(e), N = 0, P = (e, t) => {
+	if (t.oneOf && t.oneOf.length > 0) return t.oneOf[0];
+	if (t.enumValues && t.enumValues.length > 0) return t.enumValues[0];
+	let n = t.unique === !0;
+	switch (t.type) {
+		case "text":
+		case "reference":
+		case "id":
+		case "enum": return n ? `${e}-${++N}` : e;
+		case "integer":
+		case "real": return n ? ++N : 0;
+		case "decimal":
+		case "bigint": return n ? String(++N) : "0";
+		case "boolean": return !1;
+		case "timestamp":
+		case "date": return /* @__PURE__ */ new Date(0);
+		default: throw Error(`fixtureRow: column '${e}' is a required '${t.type}' with no default, and fixtureRow can't synthesize a safe placeholder for that type. Pass it explicitly: fixtureRow(table, { ${e}: … }).`);
+	}
+}, F = (e, t = {}) => {
+	let n = {};
+	for (let i of r(e, t)) M.has(i) || (n[i] = P(i, e.fields[i]));
+	return {
+		...n,
+		...t
+	};
+}, I = class {
 	currentMs;
 	constructor(e = /* @__PURE__ */ new Date("2026-01-01T00:00:00Z")) {
 		this.currentMs = typeof e == "number" ? e : e.getTime();
@@ -17,9 +42,9 @@ var j = class {
 		return new Date(this.currentMs);
 	}
 	advance(e) {
-		this.currentMs += typeof e == "number" ? e : M(e);
+		this.currentMs += typeof e == "number" ? e : L(e);
 	}
-}, M = (e) => {
+}, L = (e) => {
 	let t = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)\s*$/.exec(e);
 	if (!t) throw Error(`mockClock: cannot parse duration '${e}'`);
 	let n = Number(t[1]), r = t[2];
@@ -31,7 +56,7 @@ var j = class {
 		case "d": return n * 864e5;
 		default: throw Error(`mockClock: unknown unit '${r}'`);
 	}
-}, N = class {
+}, R = class {
 	sent = [];
 	send(e) {
 		this.sent.push({
@@ -45,7 +70,7 @@ var j = class {
 	clear() {
 		this.sent.length = 0;
 	}
-}, P = class {
+}, z = class {
 	queue;
 	calls = [];
 	constructor(e) {
@@ -60,29 +85,29 @@ var j = class {
 	remaining() {
 		return this.queue.length;
 	}
-}, F = (e) => e, I = "00000000000000000000000000000000", L = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap(), z = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), V = (e, t) => {
-	let n = B.get(e) ?? [], r = t === "mutation" ? "interceptMutation" : t === "query" ? "interceptQuery" : "interceptAction", i = [];
+}, B = (e) => e, V = "00000000000000000000000000000000", H = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new WeakMap(), W = /* @__PURE__ */ new WeakMap(), G = /* @__PURE__ */ new WeakMap(), K = (e, t) => {
+	let n = G.get(e) ?? [], r = t === "mutation" ? "interceptMutation" : t === "query" ? "interceptQuery" : "interceptAction", i = [];
 	for (let e of n) {
 		let t = e[r];
 		typeof t == "function" && i.push(t);
 	}
-	return c(i);
-}, H = (e) => {
-	let t = R.get(e);
+	return p(i);
+}, q = (e) => {
+	let t = U.get(e);
 	t !== void 0 && (t.length = 0);
-}, U = async (e) => {
-	let t = R.get(e);
+}, J = async (e) => {
+	let t = U.get(e);
 	if (t === void 0 || t.length === 0) return;
 	let n = [...t];
 	t.length = 0;
 	for (let e of n) await e();
-}, W = (e) => z.get(e) ?? [], G = async (e, t) => {
-	let n = L.get(e);
+}, Y = (e) => W.get(e) ?? [], X = async (e, t) => {
+	let n = H.get(e);
 	return n === void 0 ? e.store.transactional(async (n) => t({
 		...e,
 		store: n
 	})) : n(t);
-}, K = (e) => {
+}, Z = (e) => {
 	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = (n) => {
 		let r = t.get(n);
 		return r === void 0 ? !1 : r.expiresAt !== null && r.expiresAt <= e() ? (t.delete(n), !1) : !0;
@@ -121,7 +146,7 @@ var j = class {
 			return i(e, o, n.ttlMs, n.tags), o;
 		}
 	};
-}, q = (e) => {
+}, Q = (e) => {
 	let t = /* @__PURE__ */ new Map(), n = (n) => {
 		let r = t.get(n);
 		return r === void 0 ? !1 : r.expiresAt !== null && r.expiresAt <= e() ? (t.delete(n), !1) : !0;
@@ -149,116 +174,116 @@ var j = class {
 			t.clear();
 		}
 	};
-}, J = async (e, t) => {
-	let n = p();
-	S(e);
+}, te = async (e, t) => {
+	let n = v();
+	E(e);
 	try {
 		return await t();
 	} finally {
-		n === void 0 ? d() : S(n);
+		n === void 0 ? g() : E(n);
 	}
-}, Y = (e, t, n) => {
-	let r = X, i;
+}, ne = (e, t, n) => {
+	let r = re, i;
 	return () => {
-		let a = t ?? f();
-		return (i === void 0 || a !== r) && (r = a, i = J(n, () => b(y(a, e, (e) => {
+		let a = t ?? _();
+		return (i === void 0 || a !== r) && (r = a, i = te(n, () => w(C(a, e, (e) => {
 			console.error("[voltro:testing] row filter failed to load — reads refused for this subject", e);
 		})))), i;
 	};
-}, X = Symbol("unresolved"), Z = (e, t) => new Proxy(e, { get: (e, n) => {
-	if (n === "query") return async (n) => e.query(u(await t(), n));
+}, re = Symbol("unresolved"), ie = (e, t) => new Proxy(e, { get: (e, n) => {
+	if (n === "query") return async (n) => e.query(h(await t(), n));
 	let r = Reflect.get(e, n, e);
 	return typeof r == "function" ? r.bind(e) : r;
-} }), Q = (e = {}) => {
-	if (D({
+} }), ae = (e = {}) => {
+	if (O({
 		...process.env,
 		...e.env ?? {}
 	}), e.relations !== void 0) {
-		T();
-		for (let t of e.relations) E(t);
+		n();
+		for (let t of e.relations) i(t);
 	}
-	let t = v(e.tables ?? w()), n = new l(e.store ?? {}), r = {
-		dataStore: n,
-		schemaRegistry: t
+	let r = S(e.tables ?? t()), a = new m(e.store ?? {}), o = {
+		dataStore: a,
+		schemaRegistry: r
 	};
-	S(r);
-	let i = new j(e.clockStart), a = new N(), s = new P(e.llmResponses ?? []), c = K(() => i.now()), u = q(() => i.now()), d = (o, l = n, f) => {
-		let p = {
-			subject: o,
-			traceId: I
-		}, g = f?.queued ?? [], v = f?.nudges ?? [], y = h({ store: l }), b = Y(o, e.rowFilter, r), x = {
-			clock: i,
-			email: a,
-			llm: s,
+	E(o);
+	let s = new I(e.clockStart), c = new R(), l = new z(e.llmResponses ?? []), u = Z(() => s.now()), f = Q(() => s.now()), p = (t, n = a, i) => {
+		let d = {
+			subject: t,
+			traceId: V
+		}, m = i?.queued ?? [], h = i?.nudges ?? [], g = b({ store: n }), _ = ne(t, e.rowFilter, o), v = {
+			clock: s,
+			email: c,
+			llm: l,
 			...e.ai === void 0 ? {} : { ai: e.ai },
-			request: p,
-			access: m(o),
-			cache: c,
-			kv: u,
-			store: C(Z(l, b), {
-				subject: o,
-				schemaRegistry: t
+			request: d,
+			access: y(t),
+			cache: u,
+			kv: f,
+			store: D(ie(n, _), {
+				subject: t,
+				schemaRegistry: r
 			}),
-			outbox: _({
-				store: l,
-				subject: o,
-				traceId: I,
+			outbox: x({
+				store: n,
+				subject: t,
+				traceId: V,
 				nudge: () => {
-					v.push(I);
+					h.push(V);
 				},
 				afterCommit: (e) => {
-					g.push(e);
+					m.push(e);
 				}
 			}),
-			load: y.load,
-			loadMany: y.loadMany,
-			withSubject: (e, t) => Promise.resolve(t(d(e, l, {
-				queued: g,
-				nudges: v
+			load: g.load,
+			loadMany: g.loadMany,
+			withSubject: (e, t) => Promise.resolve(t(p(e, n, {
+				queued: m,
+				nudges: h
 			}))),
-			withTenant: (e, t) => Promise.resolve(t(d({
-				...o,
+			withTenant: (e, r) => Promise.resolve(r(p({
+				...t,
 				tenantId: e
-			}, l, {
-				queued: g,
-				nudges: v
+			}, n, {
+				queued: m,
+				nudges: h
 			})))
 		};
-		return R.set(x, g), z.set(x, v), B.set(x, e.plugins ?? []), L.set(x, (e) => l.transactional((t) => e(d(o, t, {
-			queued: g,
-			nudges: v
-		})))), x;
+		return U.set(v, m), W.set(v, h), G.set(v, e.plugins ?? []), H.set(v, (e) => n.transactional((n) => e(p(t, n, {
+			queued: m,
+			nudges: h
+		})))), v;
 	};
-	return d(e.subject ?? o(null));
-}, $ = (e, n) => e.pipe(t.provide(g(n.store)), t.provideService(a, n.request.subject)), ee = async (r, a, o, c) => {
-	let l = r.input, u = await i.decodeUnknownPromise(l)(o), d = r.kind, f = async (e) => {
-		let n = a(u, e);
-		return t.isEffect(n) ? b($(n, e)) : n;
+	return p(e.subject ?? d(null));
+}, oe = (e, t) => e.pipe(o.provide(ee(t.store)), o.provideService(u, t.request.subject)), $ = async (e, t, n, r) => {
+	let i = e.input, c = await l.decodeUnknownPromise(i)(n), u = e.kind, d = async (e) => {
+		let n = t(c, e);
+		return o.isEffect(n) ? w(oe(n, e)) : n;
 	}, p = async () => {
-		let e = r.guards;
-		if (e !== void 0 && e.length > 0) {
-			let n = await t.runPromise(s(c.request.subject, e, u));
-			if (n !== null) throw n;
+		let t = e.guards;
+		if (t !== void 0 && t.length > 0) {
+			let e = await o.runPromise(f(r.request.subject, t, c));
+			if (e !== null) throw e;
 		}
-		if (d !== "mutation") return f(c);
-		let n = await x(async () => (H(c), G(c, async (e) => f(e))), { delay: () => Promise.resolve() });
-		return await U(c), n;
-	}, m = d === "mutation" || d === "query" || d === "action" ? d : void 0, h = m === void 0 ? void 0 : V(c, m);
+		if (u !== "mutation") return d(r);
+		let n = await T(async () => (q(r), X(r, async (e) => d(e))), { delay: () => Promise.resolve() });
+		return await J(r), n;
+	}, m = u === "mutation" || u === "query" || u === "action" ? u : void 0, h = m === void 0 ? void 0 : K(r, m);
 	if (h === void 0 || m === void 0) return await p();
-	let g = h(t.tryPromise({
+	let g = h(o.tryPromise({
 		try: () => p(),
 		catch: (e) => e
 	}), {
-		tag: r.name ?? "",
+		tag: e.name ?? "",
 		kind: m,
-		input: u,
-		subject: c.request.subject,
-		traceId: c.request.traceId,
-		...c.request.spanId === void 0 ? {} : { spanId: c.request.spanId }
-	}), _ = await t.runPromiseExit(g);
-	if (n.isSuccess(_)) return _.value;
-	throw e.squash(_.cause);
-}, te = (e) => {
+		input: c,
+		subject: r.request.subject,
+		traceId: r.request.traceId,
+		...r.request.spanId === void 0 ? {} : { spanId: r.request.spanId }
+	}), _ = await o.runPromiseExit(g);
+	if (s.isSuccess(_)) return _.value;
+	throw a.squash(_.cause);
+}, se = (e) => {
 	let t = /* @__PURE__ */ new Map();
 	for (let n of e) {
 		let e = t.get(n.stepName);
@@ -284,13 +309,13 @@ var j = class {
 		});
 	}
 	return n.sort((e, t) => e._startedAt - t._startedAt), n.map(({ _startedAt: e, ...t }) => t);
-}, ne = (e) => {
-	let n = e.workflows ?? [], i = /* @__PURE__ */ new Map(), a = 0;
+}, ce = (e) => {
+	let t = e.workflows ?? [], n = /* @__PURE__ */ new Map(), r = 0;
 	return {
-		start: async (o, s) => {
-			let c = n.find((e) => e.workflow.name === o);
-			if (c === void 0) throw Error(`makeWorkflowRunner: no workflow named '${o}' — pass it in makeWorkflowRunner({ ctx, workflows: [{ workflow, execute }] }).`);
-			let l = `wfrun_test_${++a}`, u = A(), d = c.workflow.toLayer(c.execute).pipe(r.provideMerge(k)), f = /* @__PURE__ */ new Date(), p = c.workflow.execute(s).pipe(t.locally(O, l), t.provide(u.layer), t.provide(d), t.either), m = await t.runPromise(p), h = te(u.readSteps()), g = /* @__PURE__ */ new Date(), _;
+		start: async (i, a) => {
+			let s = t.find((e) => e.workflow.name === i);
+			if (s === void 0) throw Error(`makeWorkflowRunner: no workflow named '${i}' — pass it in makeWorkflowRunner({ ctx, workflows: [{ workflow, execute }] }).`);
+			let l = `wfrun_test_${++r}`, u = j(), d = s.workflow.toLayer(s.execute).pipe(c.provideMerge(A)), f = /* @__PURE__ */ new Date(), p = s.workflow.execute(a).pipe(o.locally(k, l), o.provide(u.layer), o.provide(d), o.either), m = await o.runPromise(p), h = se(u.readSteps()), g = /* @__PURE__ */ new Date(), _;
 			if (m._tag === "Right") _ = {
 				status: "succeeded",
 				output: m.right,
@@ -311,12 +336,12 @@ var j = class {
 					runId: l
 				};
 			}
-			return i.set(l, {
+			return n.set(l, {
 				id: l,
 				executionId: l,
-				name: o,
+				name: i,
 				status: _.status,
-				input: s,
+				input: a,
 				output: _.output,
 				subject: e.ctx.request.subject,
 				source: "test-runner",
@@ -328,8 +353,8 @@ var j = class {
 				parentClosePolicy: null
 			}), _;
 		},
-		inspect: async (e) => i.get(e) ?? null
+		inspect: async (e) => n.get(e) ?? null
 	};
-}, re = 1;
+}, le = 1;
 //#endregion
-export { j as MockClock, N as MockEmail, P as MockLLM, re as TESTING_PRESET_VERSION, ee as invoke, Q as makeTestContext, ne as makeWorkflowRunner, F as mockStore, W as outboxNudgesOf, H as resetAfterCommit, V as rpcInterceptorFor, U as runAfterCommit, G as runInStoreTransaction };
+export { I as MockClock, R as MockEmail, z as MockLLM, le as TESTING_PRESET_VERSION, F as fixtureRow, $ as invoke, ae as makeTestContext, ce as makeWorkflowRunner, B as mockStore, Y as outboxNudgesOf, q as resetAfterCommit, K as rpcInterceptorFor, J as runAfterCommit, X as runInStoreTransaction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/testing",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Test utilities for Voltro apps — deterministic clock, captured emails, queued LLM responses, scoped subject/tenant runners, and a cross-dialect parity harness.",
   "keywords": [
     "voltro",
@@ -42,16 +42,16 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.11.1",
-    "@voltro/env": "0.11.1",
-    "@voltro/protocol": "0.11.1",
-    "@voltro/runtime": "0.11.1",
-    "@voltro/workflow": "0.11.1"
+    "@voltro/database": "0.11.2",
+    "@voltro/env": "0.11.2",
+    "@voltro/protocol": "0.11.2",
+    "@voltro/runtime": "0.11.2",
+    "@voltro/workflow": "0.11.2"
   },
   "peerDependencies": {
     "effect": "^3.21.4",
     "react": "^19.0.0",
-    "@voltro/client": "0.11.1"
+    "@voltro/client": "0.11.2"
   },
   "peerDependenciesMeta": {
     "react": {