@voltro/testing 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -39,6 +39,42 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.3.0] — 2026-07-18
+
+### ⚠ BREAKING
+
+- **@voltro/cli** — `voltro build` precompiles the whole serve path (framework + effect + `@voltro` inlined, app modules as lazy chunks) into a single **serve bundle**, and `voltro serve` boots from it in-process — cutting `serve: ready` from ~1000 ms to ~180 ms (5–6×; the win is larger on a cold scale-to-zero container). The app's declared SQL driver is inlined (only the native leaf like `pg` stays external, resolved at runtime so it survives the deploy relocation). **Production now serves ONLY from the bundle and NEVER transpiles on demand:** the bundle build externalises unresolvable optional peers (e.g. `@react-email/render` behind `@voltro/plugin-mail`) so it always builds; a bundle-build failure is **fatal** (`voltro build` exits non-zero); and an unbuilt production `voltro serve` fails loud instead of falling back to tsx. The build toolchain (`tsx`, `esbuild`, `vite`, `@vitejs/plugin-react`, `@tailwindcss/vite` + their native tree: rolldown/lightningcss/postcss/jiti) moves to **`optionalDependencies`** of `@voltro/cli`, so `pnpm --prod --no-optional deploy` yields a serve image with none of it — a prod API image's `node_modules` drops ~305 MB → ~131 MB, structurally, with no fragile prune list. `voltro dev` and a non-production local `voltro serve` are unchanged (still tsx). **Migration:** in production (`NODE_ENV=production`) run `voltro build` before `voltro serve`. The generated Dockerfiles already do; a custom Dockerfile / start script adds a `voltro build .` step before `voltro serve .` (`voltro update` prints this — see the 0.3.0 codemod note).
+
+### Added
+
+- **@voltro/protocol, @voltro/runtime, @voltro/plugin-rbac** — Declarative authorization `guards:` on `defineMutation` / `defineQuery` / `defineAction`. The framework enforces the declared scope(s) in the dispatch spine BEFORE the executor (for a mutation, before the transaction opens), fails with a typed `ScopeError`, and auto-merges `ScopeError` into the wire error union so the client decodes the denial typed. Guards are browser-safe DATA (scope strings + a pure `resource: (input) => id` extractor). Checks run against the caller's EFFECTIVE scope set — raw subject scopes ∪ `@voltro/plugin-rbac` role-derived scopes — via a new canonical effective-scope seam in `@voltro/protocol` (`effectiveScopes` / `setEffectiveScopes` / `checkGuards`), which rbac now publishes to (so a role-granted scope satisfies a `guards:` entry and the in-handler `permission()` identically). Adds `ctx.access` (`has` / `hasAny` / `require` / `scopes`) — the cast-free typed authorization slice on every handler context. Enforcement is single-sourced in the shared serve pipeline, so `voltro dev` and `voltro serve` can't drift.
+- **@voltro/protocol, @voltro/client** — Nested / path-targeted auto-optimistic. A mutation `target` can now patch a nested array INSIDE a query's value — a JSON array column (`snapshot.projects`) or a computed/shaped result — at item granularity, via `path` (dot-path to the array), `by` (item key, default `id`), and `match` (a pure predicate that scopes the patch to the entries whose current value satisfies it, preventing a patch bleeding across sibling subscriptions that share a source table). Previously auto-optimistic only patched the flat top-level row array keyed by `id`; nested values needed a hand-written `.withOptimistic` reducer. `path`/`by`/`match` are browser-safe descriptor data (a dot-path string + pure predicate), same discipline as `identify`/`shape`. A path insert is applied even on a computed entry (it targets a known document, not a blind top-level add).
+- **@voltro/runtime** — `ctx.store.applyDefined(input, keys)` (and a standalone `applyDefined` export from `@voltro/runtime`) — builds a partial-update patch keeping only the listed keys whose value the caller actually provided (`!== undefined`; a defined falsy value like `0`/`''`/`false` is kept). Collapses the per-field `if (input.x !== undefined) patch.x = input.x` idiom every partial-update mutation hand-writes.
+- **@voltro/database** — `.uniqueActive([cols], opts?)` on the table builder — a portable partial-UNIQUE constraint that holds only among the rows matching a predicate (default `"deletedAt" IS NULL`, pairing with `.softDelete()`). Emits `CREATE UNIQUE INDEX … WHERE` on postgres / sqlite / mssql, so a soft-deleted row leaves the active set and a NEW row with the same key inserts cleanly — no hand-written `generatedAs("CASE WHEN …")` column and no resurrection footgun. On mysql / mariadb (no partial-index support) it FAILS LOUDLY at migrate time rather than silently emitting a full unique index that would forbid re-creating a soft-deleted key — the generated-STORED-column lowering for those dialects is a follow-up. Kept out of the declarative index snapshot (the incremental planner is predicate-blind and would misclassify a unique+partial index as a full constraint), so the fresh-schema DDL path is its sole emitter and there is no re-diff churn. Live-verified against postgres.
+- **@voltro/cli** — `voltro update` upgrades an app to the latest framework: it bumps every `@voltro/*` dependency, installs with the detected package manager, and runs the codemods shipped with the target version. Codemods are authored with `defineCodemod` + an import-scoped ts-morph helper toolkit (`renameImport`, `renameModuleSpecifier`, `renameJsxProp`, `renameObjectKey`, `add`/`removeImport`, structural `changeCallArgs`/`wrapCall`, `annotate`) and run against the app source; a `manual` kind surfaces written steps for changes that can't be automated. Breaking public-API changes now ship a codemod (or an explicit `codemod: none`), enforced by the changelog gate. Framework-owned `_voltro_*` table changes continue to ride the declarative differ on `voltro db apply` / `voltro dev` boot — `update` does not touch the database.
+
+### Fixed
+
+- **@voltro/database** — The core-table registry (`registerCoreTables` / `requireActors` / `requireTenants`) now stores its state on a process-global `Symbol.for` singleton, the same mechanism the main table registry already uses — instead of module-local `let` bindings. Module-local state splits when the `@voltro/database` module is duplicated in a process (e.g. resolved through both the `.` and `./sql` entry points, or a bundled framework copy alongside an externally-resolved one): one instance's `registerCoreTables` becomes invisible to the instance that reads it, surfacing as a spurious `core 'actors' table not registered` at store construction. Pinning it to `globalThis` makes every copy share one store, matching the table registry's already-global behaviour.
+
+---
+
+## [0.2.2] — 2026-07-17
+
+### Added
+
+- **@voltro/cli** — `voltro build` now precompiles the whole serve path (framework + effect + `@voltro` inlined, app modules as lazy chunks) into a single **serve bundle** (`.framework/dist-api/serveBundle/serveEntry.js`), and `voltro serve` boots from it in-process — no child `node --import tsx`, no CLI command graph, no per-module resolution of the ~2700-module framework graph. This cuts `serve: ready` from ~1000 ms to ~180 ms (~5–6×) on both driverless (memory) and driver-backed (postgres) apps; the win is larger on a cold scale-to-zero container where module resolution dominates. The app's declared SQL driver is inlined into the bundle so it shares the framework's single effect instance (only the native leaf like `pg` stays external, resolved at runtime so it survives the deploy relocation). Fully fallback-safe: a missing, stale, or corrupt bundle degrades to the standard tsx serve path, so it can never stop `voltro serve` from booting. Nothing to configure — building an API app produces the bundle and serving prefers it automatically.
+
+### Fixed
+
+- **@voltro/database** — The core-table registry (`registerCoreTables` / `requireActors` / `requireTenants`) now stores its state on a process-global `Symbol.for` singleton, the same mechanism the main table registry already uses — instead of module-local `let` bindings. Module-local state splits when the `@voltro/database` module is duplicated in a process (e.g. resolved through both the `.` and `./sql` entry points, or a bundled framework copy alongside an externally-resolved one): one instance's `registerCoreTables` becomes invisible to the instance that reads it, surfacing as a spurious `core 'actors' table not registered` at store construction. Pinning it to `globalThis` makes every copy share one store, matching the table registry's already-global behaviour.
+
+### Internal (no consumer-facing effect)
+
+- **@voltro/cli** — `appModuleLoader` now accepts lazy `() => import()` loaders alongside eager module namespaces (the eager path — today's `apiEntry.js` bundle — is unchanged). Groundwork for the serve bundle: app modules registered as lazy loaders evaluate on first `importAppModule` (during `runServe`, after `registerCoreTables`) rather than eagerly at bundle-import time. No consumer-facing effect on its own.
+
+---
+
 ## [0.2.1] — 2026-07-17
 
 ### Fixed

package/dist/index.js

@@ -1,14 +1,14 @@
 import { Effect as e, Layer as t, Schema as n } from "effect";
 import { allRegisteredTables as r } from "@voltro/database";
 import { installEnvSnapshot as i } from "@voltro/env";
-import { InMemoryDataStore as a, makeSchemaRegistry as o, wrapStoreWithMixinBehaviour as s } from "@voltro/runtime";
-import { anonymousSubject as c } from "@voltro/protocol";
-import { CurrentWorkflowRunId as l, inMemoryWorkflowEngineLayer as u, makeInMemoryRecorder as d } from "@voltro/workflow";
+import { InMemoryDataStore as a, makeAppAccess as o, makeSchemaRegistry as s, wrapStoreWithMixinBehaviour as c } from "@voltro/runtime";
+import { anonymousSubject as l } from "@voltro/protocol";
+import { CurrentWorkflowRunId as u, inMemoryWorkflowEngineLayer as d, makeInMemoryRecorder as f } from "@voltro/workflow";
 //#region src/invoke.ts
-var f = async (e, t, r, i) => {
+var p = async (e, t, r, i) => {
 	let a = e.input;
 	return t(await n.decodeUnknownPromise(a)(r), i);
-}, p = class {
+}, m = class {
 	currentMs;
 	constructor(e = /* @__PURE__ */ new Date("2026-01-01T00:00:00Z")) {
 		this.currentMs = typeof e == "number" ? e : e.getTime();
@@ -20,9 +20,9 @@ var f = async (e, t, r, i) => {
 		return new Date(this.currentMs);
 	}
 	advance(e) {
-		this.currentMs += typeof e == "number" ? e : m(e);
+		this.currentMs += typeof e == "number" ? e : h(e);
 	}
-}, m = (e) => {
+}, h = (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];
@@ -34,7 +34,7 @@ var f = async (e, t, r, i) => {
 		case "d": return n * 864e5;
 		default: throw Error(`mockClock: unknown unit '${r}'`);
 	}
-}, h = class {
+}, g = class {
 	sent = [];
 	send(e) {
 		this.sent.push({
@@ -48,7 +48,7 @@ var f = async (e, t, r, i) => {
 	clear() {
 		this.sent.length = 0;
 	}
-}, g = class {
+}, _ = class {
 	queue;
 	calls = [];
 	constructor(e) {
@@ -63,7 +63,7 @@ var f = async (e, t, r, i) => {
 	remaining() {
 		return this.queue.length;
 	}
-}, _ = (e) => e, v = "00000000000000000000000000000000", y = (e) => {
+}, v = (e) => e, y = "00000000000000000000000000000000", b = (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;
@@ -102,7 +102,7 @@ var f = async (e, t, r, i) => {
 			return i(e, o, n.ttlMs, n.tags), o;
 		}
 	};
-}, b = (e) => {
+}, x = (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;
@@ -130,37 +130,38 @@ var f = async (e, t, r, i) => {
 			t.clear();
 		}
 	};
-}, x = (e = {}) => {
+}, S = (e = {}) => {
 	i({
 		...process.env,
 		...e.env ?? {}
 	});
-	let t = o(e.tables ?? r()), n = new a(e.store ?? {}), l = new p(e.clockStart), u = new h(), d = new g(e.llmResponses ?? []), f = y(() => l.now()), m = b(() => l.now()), _ = (r) => {
+	let t = s(e.tables ?? r()), n = new a(e.store ?? {}), u = new m(e.clockStart), d = new g(), f = new _(e.llmResponses ?? []), p = b(() => u.now()), h = x(() => u.now()), v = (r) => {
 		let i = {
 			subject: r,
-			traceId: v
+			traceId: y
 		};
 		return {
-			clock: l,
-			email: u,
-			llm: d,
+			clock: u,
+			email: d,
+			llm: f,
 			...e.ai === void 0 ? {} : { ai: e.ai },
 			request: i,
-			cache: f,
-			kv: m,
-			store: s(n, {
+			access: o(r),
+			cache: p,
+			kv: h,
+			store: c(n, {
 				subject: r,
 				schemaRegistry: t
 			}),
-			withSubject: (e, t) => Promise.resolve(t(_(e))),
-			withTenant: (e, t) => Promise.resolve(t(_({
+			withSubject: (e, t) => Promise.resolve(t(v(e))),
+			withTenant: (e, t) => Promise.resolve(t(v({
 				...r,
 				tenantId: e
 			})))
 		};
 	};
-	return _(e.subject ?? c(null));
-}, S = (e) => {
+	return v(e.subject ?? l(null));
+}, C = (e) => {
 	let t = /* @__PURE__ */ new Map();
 	for (let n of e) {
 		let e = t.get(n.stepName);
@@ -186,19 +187,19 @@ var f = async (e, t, r, i) => {
 		});
 	}
 	return n.sort((e, t) => e._startedAt - t._startedAt), n.map(({ _startedAt: e, ...t }) => t);
-}, C = (n) => {
+}, w = (n) => {
 	let r = n.workflows ?? [], i = /* @__PURE__ */ new Map(), a = 0;
 	return {
 		start: async (o, s) => {
 			let c = r.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 f = `wfrun_test_${++a}`, p = d(), m = c.workflow.toLayer(c.execute).pipe(t.provideMerge(u)), h = /* @__PURE__ */ new Date(), g = c.workflow.execute(s).pipe(e.locally(l, f), e.provide(p.layer), e.provide(m), e.either), _ = await e.runPromise(g), v = S(p.readSteps()), y = /* @__PURE__ */ new Date(), b;
+			let l = `wfrun_test_${++a}`, p = f(), m = c.workflow.toLayer(c.execute).pipe(t.provideMerge(d)), h = /* @__PURE__ */ new Date(), g = c.workflow.execute(s).pipe(e.locally(u, l), e.provide(p.layer), e.provide(m), e.either), _ = await e.runPromise(g), v = C(p.readSteps()), y = /* @__PURE__ */ new Date(), b;
 			if (_._tag === "Right") b = {
 				status: "succeeded",
 				output: _.right,
 				error: null,
 				steps: v,
-				runId: f
+				runId: l
 			};
 			else {
 				let e = _.left;
@@ -210,12 +211,12 @@ var f = async (e, t, r, i) => {
 						message: e && typeof e == "object" && "message" in e && typeof e.message == "string" ? e.message : String(_.left)
 					},
 					steps: v,
-					runId: f
+					runId: l
 				};
 			}
-			return i.set(f, {
-				id: f,
-				executionId: f,
+			return i.set(l, {
+				id: l,
+				executionId: l,
 				name: o,
 				status: b.status,
 				input: s,
@@ -232,6 +233,6 @@ var f = async (e, t, r, i) => {
 		},
 		inspect: async (e) => i.get(e) ?? null
 	};
-}, w = 1;
+}, T = 1;
 //#endregion
-export { p as MockClock, h as MockEmail, g as MockLLM, w as TESTING_PRESET_VERSION, f as invoke, x as makeTestContext, C as makeWorkflowRunner, _ as mockStore };
+export { m as MockClock, g as MockEmail, _ as MockLLM, T as TESTING_PRESET_VERSION, p as invoke, S as makeTestContext, w as makeWorkflowRunner, v as mockStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/testing",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "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",
@@ -37,11 +37,11 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.2.1",
-    "@voltro/env": "0.2.1",
-    "@voltro/protocol": "0.2.1",
-    "@voltro/runtime": "0.2.1",
-    "@voltro/workflow": "0.2.1"
+    "@voltro/database": "0.3.0",
+    "@voltro/env": "0.3.0",
+    "@voltro/protocol": "0.3.0",
+    "@voltro/runtime": "0.3.0",
+    "@voltro/workflow": "0.3.0"
   },
   "peerDependencies": {
     "effect": "^3.21.4"