@voltro/testing 0.39.1 → 0.40.0

package/CHANGELOG.md

@@ -39,6 +39,164 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.40.0] — 2026-08-16
+
+### ⚠ BREAKING
+
+- **@voltro/client, @voltro/web** — A subscription whose COLD START failed is its own state — `failed: true`, `loading: false` — so "it is loading" is a true statement again.
+
+  The old shape left `loading: true` for a subscription where nothing was in flight and nothing more was coming. The type's own comment predicted the consequence:
+
+  > A cold-start failure leaves `loading` TRUE … so a component that branches on > `loading` alone renders a skeleton forever. Check `error` to break out of it.
+
+  A consumer quoted that back with the right conclusion: **a comment that predicts the misbehaviour of its own field is an API resting on discipline.** `loading` means "something is coming" everywhere else; here it meant "something is coming OR never again", and the escape hatch was a second field that the natural shape of a wrapper — pass `{ data, loading }` through — silently drops. They had three such wrappers. The framework had six, in `useWorkflow.ts`, and the compiler named all six the moment the state existed.
+
+  `failed` is a positive discriminant, so the check reads as one:
+
+  ```tsx
+  if (s.loading) return <Skeleton/>
+  if (s.failed)  return <RetryPanel error={s.error}/>
+  return <Table rows={s.data}/>
+  ```
+
+  **BREAKING**: `!loading` no longer proves `data` is present, so every call site that reads `data` after a bare `loading` check is a type error naming file and line. Nothing fails silently. The codemod is `manual` on purpose — a transform could add `|| s.failed` everywhere and would be wrong about half of them, since an infinite skeleton is precisely what this removes.
+
+  **Measured blast radius**, because the estimate was worse than the reality: 20 errors inside `@voltro/client` (mostly its own `useWorkflow` wrapper and the type-tests) and **zero** in `@voltro/web`, `devtools-ui`, the devtools app, the cloud app, and all 45 templates. Most consumers were already using a `fallback` or a wrapper, which is what made the original defect so quiet.
+
+  Unchanged: a failure AFTER the first snapshot still leaves good data on screen with `error` set — only the cold start is `failed`. A `fallback` subscription still has `data` always present, so `failed` reports there rather than gating. `idle` stays opt-in by overload; `failed` is not opt-in, because any subscription's cold start can fail. And the state is terminal for one TRANSPORT: a reconnect discards the error and re-subscribes.
+- **@voltro/protocol, @voltro/runtime, @voltro/voltro** — A guard refusing a caller whose credential was REJECTED now answers `Unauthenticated`, not `ScopeError`.
+
+  Measured by a consumer: a user's tab outlived their IdP's token lifetime. The strategy logged it plainly —
+
+  ```
+  WARN auth strategy "supabase" rejected request: supabase jwt expired
+  WARN mutation.tasks.update failed: missing required scope 'task:u:o'
+  ```
+
+  — and the wire said the caller lacked a scope. Technically true (an anonymous caller holds none) and it sends everyone who reads it into the permissions system while the problem is an expired session. They did that round; the subject was their administrator, and the same call with a fresh token worked.
+
+  **The obvious fix would have broken more than it fixed**, which is why this shape and not that one. Failing hard when a strategy rejects would break every `openAccess` procedure for anyone holding a stale cookie — a public page that needs no session at all would start refusing. So the FACT travels instead: a rejected credential stamps `credentialRejected` on the anonymous subject it falls back to, and only a guard that actually refuses spends it. `openAccess` never reaches that point and is untouched.
+
+  Three details worth knowing if you touch it:
+
+  - **The stamp happens AFTER the app's `fallback`.** That callback builds its own anonymous subject and knows nothing about the rejection; stamping before it would be silently discarded — the shape of every "wired on one path" defect in this codebase. - **ONE conversion point** (`asRefusal`), at the exit rather than at each `return`. Every branch builds the `ScopeError` it always built; one place decides what it MEANS. - **`Unauthenticated` is merged into the wire union** for guarded procedures AND guarded events, beside `ScopeError`. Without that it would be a tagged error the descriptor cannot represent, and the server would collapse it to `InternalError` — the defect another consumer reported the same week.
+
+  A caller who presented NO credential still gets `ScopeError`. Collapsing both would send a genuinely under-privileged user to the login page.
+
+  **Why this is BREAKING although nothing was removed.** Three published results gained a union member:
+
+  ```ts
+  checkGuards(…)        // ScopeError | Unauthenticated | null   (was ScopeError | null)
+  checkGuardsEffect(…)  // Effect<ScopeError | Unauthenticated | null>
+  bindEvent(…)          // Stream<…, ScopeError | Unauthenticated, …>
+  ```
+
+  The test for breaking is not "did a symbol disappear", it is whether code that COMPILED can stop compiling — and a widened return does that wherever the old union is named (`const refusal: ScopeError | null = checkGuards(…)`), or narrowed exhaustively. It was filed as `Added` first; the golden diff is what showed otherwise, and the rule is worth more than the classification that felt right. `anonymousSubject`'s new second parameter is OPTIONAL and breaks nothing.
+
+  `voltro update` carries you across it — codemod `0.40.0/02_rejected-credential-widens-guard-results`, a written note. A transform would widen each annotation, which compiles and keeps the reported behaviour: the decision at each site is what an expired session should do that a missing permission should not.
+
+### Added
+
+- **@voltro/client, @voltro/web** — The client re-resolves `authHeaders` when the server says the credential was rejected — and `client.refreshAuth()` for an app that knows earlier.
+
+  `authHeaders` is resolved once per CONNECTION and attached per frame, so a tab open longer than the IdP's token lifetime keeps presenting a dead token until something reconnects. A consumer measured it: dragging a card on a board failed, their ADMINISTRATOR's token had simply expired while the page stood, and nothing in `@voltro/client` could force the re-resolve.
+
+  The trigger is the `Unauthenticated` error — which only became distinguishable from `ScopeError` in this same release. Before that the client could not have told "your session died" from "you lack a permission", and reconnecting on the second would have been wrong.
+
+  `refreshAuth()` is a SAME-SUBJECT rebuild, and the difference from `reconnect()` is one flag and a security boundary: `reconnect()` exists for a login / logout / tenant switch, where the next subject may be entitled to strictly LESS, so the cache must not be seeded from the old one. A token refresh is the same person with a fresh credential, so seeding is correct and the screen keeps its rows instead of blanking for the round trip. Getting that backwards is silent in both directions — seed on a subject change and you paint one user's rows into another's; refuse to seed on a refresh and every open screen blinks on every rotation.
+
+  The policy lives in ONE function (`wireAuthRefresh`) that every host wires, because "when do we reconnect on an auth error" is exactly the kind of decision this repo has watched drift when it was written twice. Two guards, answering different questions: a **rate** ceiling (one rebuild per window — a rejected mutation arrives alongside every rejected subscription on the page) and a **total** ceiling (stop after N refreshes with no successful call between, because at that point the credential is not stale, it is refused, and the answer is a sign-in screen rather than another socket).
+- **@voltro/cli** — `middleware.ts` — a web app's one server-only hook, for renewing a credential before the SSR render uses it.
+
+  Reported: a consumer's SSR detail pages arrived empty on the first request of every day. Their cookie token had outlived the IdP's lifetime, the api resolved the caller to anonymous, and every `preload` on the page failed. They could not fix it in the app, and the reason is structural: `ctx.query` and every `preload` entry are bound from ONE cookie string **before any loader runs**, so a layout loader that renews the session cannot reach them — and a `type: 'web'` app has no auth middleware.
+
+  ```ts
+  // middleware.ts — web app root, server-only
+  export default async (req) => {
+    const fresh = await refreshSession(req.cookies['sb-session'])
+    if (!fresh) return
+    return {
+      headers:    { authorization: `Bearer ${fresh.accessToken}` },
+      setCookies: [{ name: 'sb-session', value: fresh.cookie, maxAge: 3600 }],
+    }
+  }
+  ```
+
+  **Why not `app.config.ts`.** That file is imported into the CLIENT bundle, verbatim, the moment any api declares `authHeaders` — the thunk is a function, so it cannot be serialised. A hook that renews a session reaches for an IdP SDK by definition, so putting it there drags the server graph into the browser. The consumer proposed exactly that shape (`serverAuthHeaders` beside `authHeaders`) and it is the one place it cannot go.
+
+  **Why `setCookies` is not optional.** We asked whether writing cookies back was in scope, expecting the answer to be about a round trip. It was about correctness: Supabase ROTATES refresh tokens and detects reuse, so a hook that renews server-side and does not write the result back leaves the browser holding a consumed token. Without it the hook is not "slower but correct" — it can destroy the session.
+
+  **Deliberately not a general middleware.** It can replace credentials and set cookies. It cannot redirect, return a response, or rewrite a route — because authorization belongs on the API, which is the only thing that sees the data, and a web-side hook that can refuse a request becomes a second authorization layer beside the real one. A hook that cannot refuse also cannot be mistaken for a guard. For a login redirect, a loader already throws `RedirectError`.
+
+  Details worth knowing: only auth-shaped headers (`authorization`, `x-tenant`, `x-voltro-*`) are forwarded to the api, so a returned `host` or `content-length` cannot produce a failure that looks like anything but a header copy; cookies default to `HttpOnly` + `Path=/` + `SameSite=lax`; multiple cookies are written as separate header lines, never comma-joined (a cookie's `Expires` contains a comma); the file is loaded ONCE per boot; a failure to IMPORT is fatal rather than degrading to "no middleware", and a middleware that THROWS fails the request — the render must not proceed on the credential it was told to replace.
+
+  Wired on BOTH SSR boot paths (`voltro dev` and `voltro start`), with the cookies written on every response arm — streamed, buffered, redirect and 404. A partial application would renew a rotating token and drop it.
+- **@voltro/testing** — `makeTestContext` supplies `ctx.events`, so an executor that publishes can be unit-tested at all.
+
+  `ctx.events` is a field PRODUCTION puts on every `AppContext`, and the test harness did not — so any handler containing `ctx.events.publish(...)` died on `Cannot read properties of undefined (reading 'publish')` the moment it ran under test.
+
+  **The shipped `api-durable` template demonstrates exactly that pattern** (publish inside the mutation's transaction, so it fires on COMMIT and not on rollback), and its own test passed anyway — because it called the executor with `await` instead of running it. An executor written in the Effect style RETURNS an Effect, and awaiting a non-thenable hands the object straight back, unrun. The assertion then failed on `row.status` being `undefined` and pointed at the assertion rather than at the call. Two defects propping each other up: the harness could not have run that handler, and the test never asked it to.
+
+  It is the REAL `makeEventPublisher` over a real `EventBus`, not a stub. A fake would re-implement the payload validation and the tenant stamping and would be wrong the first time either gains a case — the lesson `plugin-broadcast` paid for twice. `ctx.eventBus` is the read side:
+
+  ```ts
+  const seen = ctx.eventBus.subscribe(orderPlaced, { orderId })
+  await invoke(placeOrder, executor, input, ctx)
+  expect(seen.received).toHaveLength(1)
+  ```
+
+  One bus for the whole harness so a `withSubject` / `withTenant` re-scope still publishes where the test is listening; the PUBLISHER is per-subject, because the tenant it stamps is the caller's.
+
+### Fixed
+
+- **@voltro/cli** — `voltro agents-md --force` no longer exits 0 when it wrote nothing.
+
+  Reported: a consumer's `agent-docs/` is owned by the pod (root). They ran the command as `admin`, and it **overwrote nothing, said nothing, and exited 0**. They read the unchanged file as "the framework has not fixed this yet" — it had — and lost a full round to it.
+
+  The cause was three `orElseSucceed`s in the agent-docs copy. `makeDirectory`, `readDirectory` and every `copyFile` degraded to success, so a destination the process could not write produced an empty run that reported itself as done. An unreadable source directory came back as `[]` and did the same.
+
+  Failures are collected and reported now, and the command **exits 1** when the seed is incomplete:
+
+  ```
+  agents-md: 12 file(s) could NOT be written — the seed is INCOMPLETE.
+  The commonest cause is ownership: a container wrote these as root and you are
+  running as someone else.
+  ```
+
+  `--force` is an explicit instruction to overwrite, so silently not overwriting is the one outcome that must never be reported as done. `stat` is the single remaining silent degrade, deliberately: a source entry that vanished mid-walk is not a write failure and must not fail the run.
+
+  Pinned in both directions — a real unwritable directory yields failures, a clean copy yields none, and a source guard asserts that `stat` is the ONLY call on that path allowed to swallow. Red-verified by restoring the original `orElseSucceed`.
+- **@voltro/cli** — Every server-side loader context is now checked by the compiler, and the static prerender stopped handing loaders a context missing `search` and `headers`.
+
+  `ctx.isServer` shipped with a source-reading guard, and that guard had the defect it exists to prevent: it matched context literals by shape (`loader({` / `ctx: {`) and therefore found ONE of the two in `build.ts`, missing the one built as a typed arrow return. Its tripwire — "at least 5 sites" — passed, because a floor cannot tell 5-of-8 from 5-of-5. The gap was found by a parallel report, not by the guard.
+
+  The invariant moved from "the literal mentions `isServer`" to "the literal is CHECKED BY THE COMPILER": every server loader context is now `satisfies SegmentLoaderContext`, whose `isServer` is required. A site that forgets it is a type error naming the file and line — strictly stronger than any regex over shapes, and verified by removing one.
+
+  **It caught a second defect immediately.** The static prerender built its page loader context with only `params`, `pathname`, `signal` — no `search`, no `headers`, no `query` — while `LoaderContext.search` is declared `string`. A static page's loader reading `ctx.search` got `undefined` where the type promised a value. The segment context twenty lines above it in the same file already passed `search: ''` with a comment explaining why.
+
+  Two smaller things worth knowing if you touch the guard: the closing brace is part of its pattern because the bare phrase also appears in the comment explaining the rule (the first version counted its own documentation), and the CLI's `SegmentLoaderContext` mirror keeping `isServer` non-optional is what the whole enforcement rests on — `isServer?:` would make every `satisfies` pass while a forgetful site reports itself as the browser.
+- **@voltro/protocol, @voltro/cli** — A guard's `ScopeError` reaches the client as `ScopeError` on a mutation, not as `InternalError`.
+
+  Measured by a consumer over the wire, same session, same foreign team:
+
+  | kind | declared `error:` | denial arrived as | |---|---|---| | query `webhooks.list` | `AccessDeniedError` | `_tag: 'ScopeError'` ✓ | | mutation `…updateReferenceLabels` | `AccessDeniedError` | `InternalError` ✗ | | the same mutation, after adding `ScopeError` to its union | | `_tag: 'ScopeError'` ✓ |
+
+  Their client maps `ScopeError` to *forbidden* and `InternalError` to *something went wrong*, so a permissions refusal looked like a crash — on every relationship-guarded write in the app.
+
+  **Their observation was exact; the mechanism was not, and the difference is where the fix goes.** They diagnosed it as "the merge only happens on the streaming path". `withGuardError` is called by every lifter, so the wire union carries `ScopeError` on both. What differs is a SECOND reader: the server refuses to ship a tagged error the descriptor cannot represent, collapsing it to `InternalError` rather than emitting a raw defect tree — and it was handed `descriptor.error`, the RAW declaration, while the union it protects is the WIDENED one. It judged against a narrower set than it had advertised. A query never reaches that check (it is delivered through `wireErrorFromCause`, which preserves the tag), which is exactly why the split fell along query/mutation.
+
+  `wireErrorUnion(descriptor, kind)` is now the single owner of "what can this procedure put on the wire", used by the lifters AND by both bind sites.
+
+  **Two more error classes were collapsed the same way, and neither was reported:**
+
+  - **`BusinessRuleViolation`** — unconditional for mutations. `withRuleError`'s own comment says it MUST be in the union "or the violation crosses the wire as an untyped defect". It was in the union, and collapsed before it got there. - **The `requiresApproval` refusals** — `ApprovalRequired` / `ApprovalExpired` / `ApprovalUnavailable`, so "parked for approval" was indistinguishable from "the server broke".
+
+  `openAccess:` still merges nothing: a procedure advertising a denial it cannot produce is what makes an error union stop meaning anything.
+
+  If you worked around this by declaring `ScopeError` yourself, the declaration is now redundant rather than wrong — the union is the same either way, and you can delete it whenever you like.
+
+---
+
 ## [0.39.1] — 2026-08-16
 
 ### Fixed

package/dist/index.d.ts

@@ -747,6 +747,26 @@ export declare interface TestContext extends AppContext {
      *  and the harness did not, so a mutation written the documented way —
      *  `useWebhooks(ctx).emit(...)` — threw in every unit test. */
     readonly webhooks: MockWebhooks;
+    /**
+     * The event publisher, backed by a real in-process bus.
+     *
+     * `ctx.events` is a field PRODUCTION supplies on every `AppContext`, and this
+     * harness did not — so an executor containing `ctx.events.publish(...)` could
+     * not be unit-tested at all: it died on `Cannot read properties of undefined
+     * (reading 'publish')`. The shipped `api-durable` template demonstrates
+     * exactly that pattern (publish inside the mutation's transaction), so the
+     * example and the test helper contradicted each other, and the template's own
+     * test only passed because it awaited the Effect without running it.
+     *
+     * Real, not a stub: `makeEventPublisher` is the same constructor production
+     * uses, over a `testEventBus`. A fake would re-implement the validation and
+     * the tenant stamping, and would be wrong the first time either gains a case.
+     * `ctx.eventBus.received` is where a test reads what was published.
+     */
+    readonly events: EventPublisher;
+    /** The bus behind `ctx.events` — subscribe to it to assert what a handler
+     *  published. */
+    readonly eventBus: TestEventBus;
     readonly llm: MockLLM;
     readonly ai?: MockAi;
     /** Re-scope to a different subject for one block (real subject swap, not

package/dist/index.js

@@ -1,7 +1,7 @@
 import { AUTO_FILLED_COLUMNS as e, allRegisteredTables as t, changeDelete as n, changeInsert as r, changeSoftDelete as i, changeUpdate as a, clearRelationsRegistry as o, missingRequiredColumns as s, registerRelations as c } from "@voltro/database";
 import { Cause as l, Effect as u, Exit as d, Layer as f, Schema as p } from "effect";
-import { SubjectService as m, anonymousSubject as h, checkGuardsEffect as g, composeAuthStrategies as _, composeRpcInterceptors as v, eventRoute as ee, systemSubject as y, tenantScopedSubject as te } from "@voltro/protocol";
-import { EventBus as ne, InMemoryDataStore as re, NO_ROW_FILTER as b, applyRowFilterToDescriptor as ie, clearSystemStoreHandle as ae, getRowFilter as x, getSystemStoreHandle as oe, makeAppAccess as se, makeDataLoader as ce, makeEffectStoreLayer as le, makeOutboxFacade as ue, makeSchemaRegistry as de, publishEvent as fe, resolveRowFilterScopeFor as pe, runProvidedEffect as S, runWithDeadlockRetry as me, setSystemStoreHandle as C, wrapStoreWithMixinBehaviour as w } from "@voltro/runtime";
+import { SubjectService as m, anonymousSubject as h, checkGuardsEffect as g, composeAuthStrategies as _, composeRpcInterceptors as v, eventRoute as y, systemSubject as b, tenantScopedSubject as ee } from "@voltro/protocol";
+import { EventBus as te, InMemoryDataStore as ne, NO_ROW_FILTER as x, applyRowFilterToDescriptor as re, clearSystemStoreHandle as ie, getRowFilter as S, getSystemStoreHandle as ae, makeAppAccess as oe, makeDataLoader as se, makeEffectStoreLayer as ce, makeEventPublisher as le, makeOutboxFacade as ue, makeSchemaRegistry as de, publishEvent as fe, resolveRowFilterScopeFor as pe, runProvidedEffect as C, runWithDeadlockRetry as me, setSystemStoreHandle as w, wrapStoreWithMixinBehaviour as T } from "@voltro/runtime";
 import { installEnvSnapshot as he } from "@voltro/env";
 import ge from "node:net";
 import { describe as _e } from "vitest";
@@ -9,7 +9,7 @@ import { collectPublicApiRoutes as ve, dispatchSharedPath as ye, restRoutesToHtt
 import { createLogger as xe } from "@voltro/logger";
 import { CurrentWorkflowRunId as Se, inMemoryWorkflowEngineLayer as Ce, makeInMemoryRecorder as we } from "@voltro/workflow";
 //#region src/fixtureRow.ts
-var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
+var Te = new Set(e), E = 0, D = () => ++E, Ee = (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;
@@ -17,17 +17,17 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		case "text":
 		case "reference":
 		case "id":
-		case "enum": return n ? `${e}-${++T}` : e;
+		case "enum": return n ? `${e}-${++E}` : e;
 		case "integer":
-		case "real": return n ? ++T : 0;
+		case "real": return n ? ++E : 0;
 		case "decimal":
-		case "bigint": return n ? String(++T) : "0";
+		case "bigint": return n ? String(++E) : "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}: … }).`);
 	}
-}, D = (e, t = {}) => {
+}, O = (e, t = {}) => {
 	let n = {};
 	for (let r of s(e, t)) Te.has(r) || (n[r] = Ee(r, e.fields[r]));
 	return {
@@ -36,7 +36,7 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 	};
 }, De = (e) => {
 	let t = {};
-	for (let [n, r] of Object.entries(e)) t[n] = typeof r == "function" ? r(E()) : r;
+	for (let [n, r] of Object.entries(e)) t[n] = typeof r == "function" ? r(D()) : r;
 	return t;
 }, Oe = (e) => {
 	for (let [t, n] of Object.entries(e.fields)) if (n.type === "id") return t;
@@ -49,29 +49,29 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		let s = n.references();
 		if (i.includes(s.tableName)) throw Error(`defineFactory: creating '${t.tableName}' requires '${s.tableName}' via '${o}', and that reference is cyclic (${[...i, s.tableName].join(" → ")}). Insert one side first and pass the id: create(store, { ${o}: existing.id }).`);
 		let c = r[o];
-		a[o] = (c === void 0 ? await O(e, s, {}, {}, [...i, s.tableName]) : await c.create(e, {}))[Oe(s)];
+		a[o] = (c === void 0 ? await k(e, s, {}, {}, [...i, s.tableName]) : await c.create(e, {}))[Oe(s)];
 	}
 	return a;
-}, O = async (e, t, n, r, i) => {
+}, k = async (e, t, n, r, i) => {
 	let a = {
 		...await ke(e, t, n, r, i),
 		...n
 	};
-	return e.insert(t.tableName, D(t, a));
-}, k = (e, t) => typeof e == "function" ? e(t) : e ?? {}, Ae = (e, t = {}) => {
+	return e.insert(t.tableName, O(t, a));
+}, A = (e, t) => typeof e == "function" ? e(t) : e ?? {}, Ae = (e, t = {}) => {
 	let n = t.traits ?? {}, r = t.associations ?? {}, i = (t) => {
 		let a = (e = {}) => ({
 			...De(t),
 			...e
-		}), o = (t = {}) => D(e, a(t));
+		}), o = (t = {}) => O(e, a(t));
 		return {
 			table: e,
 			build: o,
-			buildList: (e, t) => Array.from({ length: e }, (e, n) => o(k(t, n))),
-			create: (t, n = {}) => O(t, e, a(n), r, [e.tableName]),
+			buildList: (e, t) => Array.from({ length: e }, (e, n) => o(A(t, n))),
+			create: (t, n = {}) => k(t, e, a(n), r, [e.tableName]),
 			createList: async (t, n, i) => {
 				let o = [];
-				for (let s = 0; s < n; s++) o.push(await O(t, e, a(k(i, s)), r, [e.tableName]));
+				for (let s = 0; s < n; s++) o.push(await k(t, e, a(A(i, s)), r, [e.tableName]));
 				return o;
 			},
 			with: (...r) => {
@@ -93,19 +93,19 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		};
 	};
 	return i(t.defaults ?? {});
-}, A = Symbol.for("voltro/testing/mockClock.installed"), j = () => globalThis, je = (e, t) => new Proxy(e, {
+}, j = Symbol.for("voltro/testing/mockClock.installed"), M = () => globalThis, je = (e, t) => new Proxy(e, {
 	construct: (e, n, r) => Reflect.construct(e, n.length === 0 ? [t()] : n, r),
 	apply: () => new e(t()).toString(),
 	get: (e, n, r) => n === "now" ? () => t() : Reflect.get(e, n, r)
-}), M = (e) => {
+}), N = (e) => {
 	if (typeof e == "number") return e;
 	let t = e instanceof Date ? e.getTime() : Date.parse(e);
 	if (Number.isNaN(t)) throw Error(`mockClock: cannot read an instant from '${String(e)}'`);
 	return t;
-}, N = class {
+}, P = class {
 	currentMs;
 	constructor(e = "2026-01-01T00:00:00Z") {
-		this.currentMs = M(e);
+		this.currentMs = N(e);
 	}
 	now() {
 		return this.currentMs;
@@ -117,16 +117,16 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		this.currentMs += typeof e == "number" ? e : Fe(e);
 	}
 	set(e) {
-		this.currentMs = M(e);
+		this.currentMs = N(e);
 	}
 	get installed() {
-		return j()[A]?.clock === this;
+		return M()[j]?.clock === this;
 	}
 	install() {
-		let e = j(), t = e[A];
+		let e = M(), t = e[j];
 		if (t !== void 0) throw Error("mockClock: global time is already faked" + (t.clock === this ? " by this same clock" : " by another MockClock") + ". Uninstall it before installing again — a nested install restores the outer fake on the way out, which leaves the realm frozen with nothing pointing at why. `withFrozenTime` always restores, including on a throw.");
 		let n = globalThis.Date;
-		return e[A] = {
+		return e[j] = {
 			realDate: n,
 			clock: this
 		}, globalThis.Date = je(n, () => this.currentMs), () => {
@@ -134,11 +134,11 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		};
 	}
 	uninstall() {
-		let e = j(), t = e[A];
-		t !== void 0 && t.clock === this && (globalThis.Date = t.realDate, delete e[A]);
+		let e = M(), t = e[j];
+		t !== void 0 && t.clock === this && (globalThis.Date = t.realDate, delete e[j]);
 	}
 }, Me = (e) => typeof e == "object" && !!e && typeof e.then == "function", Ne = (e, t) => {
-	let n = e instanceof N ? e : new N(e);
+	let n = e instanceof P ? e : new P(e);
 	n.install();
 	let r = !1;
 	try {
@@ -150,7 +150,7 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		r || n.uninstall();
 	}
 }, Pe = (e) => u.acquireRelease(u.sync(() => {
-	let t = e instanceof N ? e : new N(e);
+	let t = e instanceof P ? e : new P(e);
 	return t.install(), t;
 }), (e) => u.sync(() => {
 	e.uninstall();
@@ -166,7 +166,7 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		case "d": return n * 864e5;
 		default: throw Error(`mockClock: unknown unit '${r}'`);
 	}
-}, P = class {
+}, F = class {
 	emitted = [];
 	async emit(e, t) {
 		let n = typeof e == "string" ? e : e.id ?? e.event ?? "(unnamed event)";
@@ -185,7 +185,77 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 	clear() {
 		this.emitted.length = 0;
 	}
-}, F = class {
+}, I = (e = {}) => {
+	let t = e.tenantId ?? null, n = new te({
+		origin: e.origin ?? "test",
+		...e.ringSize === void 0 ? {} : { ringSize: e.ringSize }
+	});
+	return {
+		publish: async (e, r, i) => {
+			let a = await u.runPromise(u.either(fe({
+				bus: n,
+				tenantId: t
+			}, e, r, i)));
+			if (a._tag === "Left") {
+				let t = a.left;
+				throw Error(`testEventBus.publish(${e.name}) was rejected: ${t._tag}`, { cause: t });
+			}
+			return { n: a.right.n };
+		},
+		subscribe: (e, r, i) => {
+			let a = [], o = [];
+			return {
+				get received() {
+					return a.map((e) => e.payload);
+				},
+				get deliveries() {
+					return a;
+				},
+				get missed() {
+					return o;
+				},
+				get missedCount() {
+					return o.reduce((e, t) => e + t.count, 0);
+				},
+				stop: n.subscribe({
+					tenantId: i?.tenantId ?? t,
+					event: e.name,
+					key: r,
+					listener: (e) => {
+						if (e.kind === "gap") {
+							o.push({
+								count: e.missed,
+								reason: e.reason
+							});
+							return;
+						}
+						a.push({
+							payload: e.envelope.payload,
+							origin: e.envelope.origin,
+							n: e.envelope.n
+						});
+					},
+					...i?.resume === void 0 ? {} : { options: { resume: i.resume } }
+				})
+			};
+		},
+		skipSerials: (e, r, i, a) => {
+			let o = a?.tenantId ?? t, s = {
+				route: y(o, e.name, r),
+				event: e.name,
+				origin: "test-gap",
+				n: i + 1,
+				emittedAt: Date.now(),
+				payload: void 0
+			};
+			n.injectRemote(s);
+		},
+		bus: n,
+		reset: () => {
+			n.clear();
+		}
+	};
+}, L = class {
 	queue;
 	calls = [];
 	constructor(e) {
@@ -200,27 +270,27 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 	remaining() {
 		return this.queue.length;
 	}
-}, Ie = (e) => e, I = "00000000000000000000000000000000", L = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap(), z = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), H = (e, t) => {
-	let n = B.get(e) ?? [], r = t === "mutation" ? "interceptMutation" : t === "query" ? "interceptQuery" : "interceptAction", i = [];
+}, Ie = (e) => e, R = "00000000000000000000000000000000", z = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), H = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new WeakMap(), W = (e, t) => {
+	let n = H.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 v(i);
-}, U = (e) => {
-	let t = (B.get(e) ?? []).map((e) => e.services).filter((e) => e !== void 0), n = V.get(e) ?? [], r = [...t, ...n];
+}, G = (e) => {
+	let t = (H.get(e) ?? []).map((e) => e.services).filter((e) => e !== void 0), n = U.get(e) ?? [], r = [...t, ...n];
 	if (r.length !== 0) return f.mergeAll(...r);
-}, W = (e) => {
-	let t = R.get(e);
+}, K = (e) => {
+	let t = B.get(e);
 	t !== void 0 && (t.length = 0);
-}, G = async (e) => {
-	let t = R.get(e);
+}, q = async (e) => {
+	let t = B.get(e);
 	if (t === void 0 || t.length === 0) return;
 	let n = [...t];
 	t.length = 0;
 	for (let e of n) await e();
-}, Le = (e) => z.get(e) ?? [], K = async (e, t) => {
-	let n = L.get(e);
+}, Le = (e) => V.get(e) ?? [], J = async (e, t) => {
+	let n = z.get(e);
 	return n === void 0 ? e.store.transactional(async (n) => t({
 		...e,
 		store: n
@@ -293,28 +363,28 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		}
 	};
 }, Be = async (e, t) => {
-	let n = oe();
-	C(e);
+	let n = ae();
+	w(e);
 	try {
 		return await t();
 	} finally {
-		n === void 0 ? ae() : C(n);
+		n === void 0 ? ie() : w(n);
 	}
-}, q = /* @__PURE__ */ new Set(), Ve = (e) => {
-	q.has(e) || (q.add(e), console.warn(e));
+}, Y = /* @__PURE__ */ new Set(), Ve = (e) => {
+	Y.has(e) || (Y.add(e), console.warn(e));
 }, He = (e, t, n) => {
 	let r = Ue, i;
 	return () => {
-		let a = t ?? x();
-		return t !== void 0 && x() !== void 0 && t !== x() && Ve("[voltro:testing] this test passes `rowFilter:` while a DIFFERENT filter is registered via `setRowFilter`. The option wins, so this test does not exercise your app's registration. Drop `rowFilter:` to run the real process-global one."), (i === void 0 || a !== r) && (r = a, i = Be(n, () => S(pe(a, e, (e) => {
+		let a = t ?? S();
+		return t !== void 0 && S() !== void 0 && t !== S() && Ve("[voltro:testing] this test passes `rowFilter:` while a DIFFERENT filter is registered via `setRowFilter`. The option wins, so this test does not exercise your app's registration. Drop `rowFilter:` to run the real process-global one."), (i === void 0 || a !== r) && (r = a, i = Be(n, () => C(pe(a, e, (e) => {
 			console.error("[voltro:testing] row filter failed to load — reads refused for this subject", e);
 		})))), i;
 	};
-}, Ue = Symbol("unresolved"), J = (e, t) => new Proxy(e, { get: (e, n) => {
-	if (n === "query") return async (n) => e.query(ie(await t(), n));
+}, Ue = Symbol("unresolved"), We = (e, t) => new Proxy(e, { get: (e, n) => {
+	if (n === "query") return async (n) => e.query(re(await t(), n));
 	let r = Reflect.get(e, n, e);
 	return typeof r == "function" ? r.bind(e) : r;
-} }), We = (e = {}) => {
+} }), Ge = (e = {}) => {
 	if (he({
 		...process.env,
 		...e.env ?? {}
@@ -322,72 +392,77 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		o();
 		for (let t of e.relations) c(t);
 	}
-	let n = e.tables ?? t(), r = de(n), i = new re(e.store ?? {}), a = {
+	let n = e.tables ?? t(), r = de(n), i = new ne(e.store ?? {}), a = {
 		dataStore: i,
 		schemaRegistry: r
 	};
-	C(a);
-	let s = new N(e.clockStart), l = new P(), u = new F(e.llmResponses ?? []), d = Re(() => s.now()), f = ze(() => s.now()), p = (t, n = i, o) => {
+	w(a);
+	let s = new P(e.clockStart), l = new F(), u = I(), d = new L(e.llmResponses ?? []), f = Re(() => s.now()), p = ze(() => s.now()), m = (t, n = i, o) => {
 		let c = {
 			subject: t,
-			traceId: I
-		}, m = o?.queued ?? [], h = o?.nudges ?? [], g = ce({ store: n }), _ = He(t, e.rowFilter, a), v = {
+			traceId: R
+		}, h = le({
+			bus: u.bus,
+			tenantId: t.tenantId ?? null
+		}), g = o?.queued ?? [], _ = o?.nudges ?? [], v = se({ store: n }), y = He(t, e.rowFilter, a), b = {
 			clock: s,
 			webhooks: l,
-			llm: u,
+			events: h,
+			eventBus: u,
+			llm: d,
 			...e.ai === void 0 ? {} : { ai: e.ai },
 			request: c,
-			access: se(t),
-			cache: d,
-			kv: f,
-			store: w(J(n, _), {
+			access: oe(t),
+			cache: f,
+			kv: p,
+			store: T(We(n, y), {
 				subject: t,
 				schemaRegistry: r,
-				rowFilter: b
+				rowFilter: x
 			}),
-			storeForTenant: (e) => w(J(n, _), {
-				subject: te(t, e),
+			storeForTenant: (e) => T(We(n, y), {
+				subject: ee(t, e),
 				schemaRegistry: r,
-				rowFilter: b
+				rowFilter: x
 			}),
 			outbox: ue({
 				store: n,
 				subject: t,
-				traceId: I,
+				traceId: R,
 				nudge: () => {
-					h.push(I);
+					_.push(R);
 				},
 				afterCommit: (e) => {
-					m.push(e);
+					g.push(e);
 				}
 			}),
-			load: g.load,
-			loadMany: g.loadMany,
-			withSubject: (e, t) => Promise.resolve(t(p(e, n, {
-				queued: m,
-				nudges: h
+			load: v.load,
+			loadMany: v.loadMany,
+			withSubject: (e, t) => Promise.resolve(t(m(e, n, {
+				queued: g,
+				nudges: _
 			}))),
-			withTenant: (e, r) => Promise.resolve(r(p({
+			withTenant: (e, r) => Promise.resolve(r(m({
 				...t,
 				tenantId: e
 			}, n, {
-				queued: m,
-				nudges: h
+				queued: g,
+				nudges: _
 			})))
 		};
-		return R.set(v, m), z.set(v, h), B.set(v, e.plugins ?? []), V.set(v, e.layers ?? []), L.set(v, (e) => n.transactional((n) => e(p(t, n, {
-			queued: m,
-			nudges: h
-		})))), v;
+		return B.set(b, g), V.set(b, _), H.set(b, e.plugins ?? []), U.set(b, e.layers ?? []), z.set(b, (e) => n.transactional((n) => e(m(t, n, {
+			queued: g,
+			nudges: _
+		})))), b;
 	};
-	return p(e.subject ?? h(null));
-}, Ge = (e, t) => {
-	let n = U(t);
-	return (n === void 0 ? e : u.provide(e, n)).pipe(u.provide(le(t.store)), u.provideService(m, t.request.subject));
-}, Y = async (e, t, n, r) => {
+	return m(e.subject ?? h(null));
+}, Ke = (e, t) => {
+	let n = G(t);
+	return (n === void 0 ? e : u.provide(e, n)).pipe(u.provide(ce(t.store)), u.provideService(m, t.request.subject));
+}, qe = async (e, t, n, r) => {
 	let i = e.input, a = await p.decodeUnknownPromise(i)(n), o = e.kind, s = async (e) => {
 		let n = t(a, e);
-		return u.isEffect(n) ? S(Ge(n, e)) : n;
+		return u.isEffect(n) ? C(Ke(n, e)) : n;
 	}, c = async () => {
 		let t = e.guards;
 		if (t !== void 0 && t.length > 0) {
@@ -395,9 +470,9 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 			if (e !== null) throw e;
 		}
 		if (o !== "mutation") return s(r);
-		let n = await me(async () => (W(r), K(r, async (e) => s(e))), { delay: () => Promise.resolve() });
-		return await G(r), n;
-	}, f = o === "mutation" || o === "query" || o === "action" ? o : void 0, m = f === void 0 ? void 0 : H(r, f);
+		let n = await me(async () => (K(r), J(r, async (e) => s(e))), { delay: () => Promise.resolve() });
+		return await q(r), n;
+	}, f = o === "mutation" || o === "query" || o === "action" ? o : void 0, m = f === void 0 ? void 0 : W(r, f);
 	if (m === void 0 || f === void 0) return await c();
 	let h = m(u.tryPromise({
 		try: () => c(),
@@ -426,15 +501,15 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		i = !1;
 	}
 	_e.skipIf(!i)(i ? e : `${e} [SKIPPED: needs ${t}]`, r);
-}, Ke = async (e, t, n) => {
+}, Je = async (e, t, n) => {
 	await Z(e, `${t.name} at ${t.host}:${t.port}`, () => X(t), n);
-}, qe = "test-tenant", Q = (e, t, n) => ({
+}, Ye = "test-tenant", Q = (e, t, n) => ({
 	type: e,
 	id: t,
 	tenantId: n.tenantId ?? "test-tenant",
 	scopes: n.scopes ?? [],
 	...n.metadata === void 0 ? {} : { metadata: n.metadata }
-}), Je = (e, t = {}) => Q("user", e, t), Ye = (e, t = {}) => Q("apiKey", e, t), Xe = (e, t = {}) => Q("serviceAccount", e, t), Ze = (e = null) => h(e), Qe = (e = "job:test", t) => t === void 0 ? y(e) : y(e, t), $e = (e) => {
+}), Xe = (e, t = {}) => Q("user", e, t), Ze = (e, t = {}) => Q("apiKey", e, t), Qe = (e, t = {}) => Q("serviceAccount", e, t), $e = (e = null) => h(e), et = (e = "job:test", t) => t === void 0 ? b(e) : b(e, t), tt = (e) => {
 	let t = e.indexOf("?");
 	return t === -1 ? {
 		path: e,
@@ -443,17 +518,17 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		path: e.slice(0, t),
 		query: e.slice(t + 1)
 	};
-}, et = (e, t) => {
+}, nt = (e, t) => {
 	let n = e.split("/").filter((e) => e.length > 0), r = t.split("/").filter((e) => e.length > 0);
 	return n.length === r.length && n.every((e, t) => e.startsWith(":") || e === r[t]);
 }, $ = (e) => {
 	let t = {};
 	for (let [n, r] of Object.entries(e)) t[n.toLowerCase()] = r;
 	return t;
-}, tt = (e) => e === void 0 ? /* @__PURE__ */ new Uint8Array() : new TextEncoder().encode(JSON.stringify(e)), nt = (e) => e === void 0 ? "" : typeof e == "string" ? e : new TextDecoder().decode(e), rt = (e) => {
+}, rt = (e) => e === void 0 ? /* @__PURE__ */ new Uint8Array() : new TextEncoder().encode(JSON.stringify(e)), it = (e) => e === void 0 ? "" : typeof e == "string" ? e : new TextDecoder().decode(e), at = (e) => {
 	let { ctx: t } = e, n = ve((e.publicApi ?? []).map((e) => ({
 		descriptor: e.descriptor,
-		invoke: (n, r) => t.withSubject(r.subject, (t) => Y(e.descriptor, e.handler, n, t))
+		invoke: (n, r) => t.withSubject(r.subject, (t) => qe(e.descriptor, e.handler, n, t))
 	}))), r = [...e.restRoutes ?? [], ...n], i = _(e.strategies ?? [], {
 		...e.anonymousTenantRequired === void 0 ? {} : { anonymousTenantRequired: e.anonymousTenantRequired },
 		getStore: () => t.store
@@ -469,7 +544,7 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 			pattern: r[t].path,
 			route: e
 		})), l = async (e, n, i = {}) => {
-			let { path: a, query: s } = $e(n), l = c.filter((e) => et(e.pattern, a)).map((e) => e.route);
+			let { path: a, query: s } = tt(n), l = c.filter((e) => nt(e.pattern, a)).map((e) => e.route);
 			if (l.length === 0) return {
 				status: 404,
 				headers: {},
@@ -488,11 +563,11 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 					...$(o),
 					...$(i.headers ?? {})
 				},
-				rawBody: tt(i.body),
+				rawBody: rt(i.body),
 				store: t.store
 			}, d = await ye(l, u), f = $(d.headers ?? {});
 			d.contentType !== void 0 && (f["content-type"] = d.contentType);
-			let p = nt(d.body), m = (d.contentType ?? "").includes("json");
+			let p = it(d.body), m = (d.contentType ?? "").includes("json");
 			return {
 				status: d.status,
 				headers: f,
@@ -526,77 +601,7 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		};
 	};
 	return a(void 0, {});
-}, it = (e = {}) => {
-	let t = e.tenantId ?? null, n = new ne({
-		origin: e.origin ?? "test",
-		...e.ringSize === void 0 ? {} : { ringSize: e.ringSize }
-	});
-	return {
-		publish: async (e, r, i) => {
-			let a = await u.runPromise(u.either(fe({
-				bus: n,
-				tenantId: t
-			}, e, r, i)));
-			if (a._tag === "Left") {
-				let t = a.left;
-				throw Error(`testEventBus.publish(${e.name}) was rejected: ${t._tag}`, { cause: t });
-			}
-			return { n: a.right.n };
-		},
-		subscribe: (e, r, i) => {
-			let a = [], o = [];
-			return {
-				get received() {
-					return a.map((e) => e.payload);
-				},
-				get deliveries() {
-					return a;
-				},
-				get missed() {
-					return o;
-				},
-				get missedCount() {
-					return o.reduce((e, t) => e + t.count, 0);
-				},
-				stop: n.subscribe({
-					tenantId: i?.tenantId ?? t,
-					event: e.name,
-					key: r,
-					listener: (e) => {
-						if (e.kind === "gap") {
-							o.push({
-								count: e.missed,
-								reason: e.reason
-							});
-							return;
-						}
-						a.push({
-							payload: e.envelope.payload,
-							origin: e.envelope.origin,
-							n: e.envelope.n
-						});
-					},
-					...i?.resume === void 0 ? {} : { options: { resume: i.resume } }
-				})
-			};
-		},
-		skipSerials: (e, r, i, a) => {
-			let o = a?.tenantId ?? t, s = {
-				route: ee(o, e.name, r),
-				event: e.name,
-				origin: "test-gap",
-				n: i + 1,
-				emittedAt: Date.now(),
-				payload: void 0
-			};
-			n.injectRemote(s);
-		},
-		bus: n,
-		reset: () => {
-			n.clear();
-		}
-	};
-}, at = (e = {}) => {
+}, ot = (e = {}) => {
 	let t = e.id ?? "test", n = e.store ?? new Proxy({}, { get: (e, t) => {
 		throw Error(`makeSubscribeContext: this subscriber reached ctx.store.${String(t)} and the test passed no store. Pass \`{ store: makeTestContext().store }\` so the subscriber and the code under test share one — an empty stand-in would let a read of the wrong table pass.`);
 	} });
@@ -606,7 +611,7 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		store: n,
 		...e.publish === void 0 ? {} : { publish: e.publish }
 	};
-}, ot = (e) => {
+}, st = (e) => {
 	let t = /* @__PURE__ */ new Map();
 	for (let n of e) {
 		let e = t.get(n.stepName);
@@ -632,13 +637,13 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		});
 	}
 	return n.sort((e, t) => e._startedAt - t._startedAt), n.map(({ _startedAt: e, ...t }) => t);
-}, st = (e) => {
+}, ct = (e) => {
 	let t = e.workflows ?? [], n = /* @__PURE__ */ new Map(), r = 0;
 	return {
 		start: async (i, a) => {
 			let o = t.find((e) => e.workflow.name === i);
 			if (o === void 0) throw Error(`makeWorkflowRunner: no workflow named '${i}' — pass it in makeWorkflowRunner({ ctx, workflows: [{ workflow, execute }] }).`);
-			let s = `wfrun_test_${++r}`, c = we(), l = o.workflow.toLayer(o.execute).pipe(f.provideMerge(Ce)), d = /* @__PURE__ */ new Date(), p = o.workflow.execute(a).pipe(u.locally(Se, s), u.provide(c.layer), u.provide(l), u.either), m = await u.runPromise(p), h = ot(c.readSteps()), g = /* @__PURE__ */ new Date(), _;
+			let s = `wfrun_test_${++r}`, c = we(), l = o.workflow.toLayer(o.execute).pipe(f.provideMerge(Ce)), d = /* @__PURE__ */ new Date(), p = o.workflow.execute(a).pipe(u.locally(Se, s), u.provide(c.layer), u.provide(l), u.either), m = await u.runPromise(p), h = st(c.readSteps()), g = /* @__PURE__ */ new Date(), _;
 			if (m._tag === "Right") _ = {
 				status: "succeeded",
 				output: m.right,
@@ -678,6 +683,6 @@ var Te = new Set(e), T = 0, E = () => ++T, Ee = (e, t) => {
 		},
 		inspect: async (e) => n.get(e) ?? null
 	};
-}, ct = 1;
+}, lt = 1;
 //#endregion
-export { N as MockClock, F as MockLLM, P as MockWebhooks, ct as TESTING_PRESET_VERSION, qe as TEST_TENANT_ID, Ze as anonymous, Ye as apiKey, n as changeDelete, r as changeInsert, i as changeSoftDelete, a as changeUpdate, Ae as defineFactory, Z as describeIfAvailable, Ke as describeIfReachable, D as fixtureRow, Pe as frozenTime, Y as invoke, X as isTcpReachable, at as makeSubscribeContext, rt as makeTestApp, We as makeTestContext, st as makeWorkflowRunner, Ie as mockStore, E as nextSequence, Le as outboxNudgesOf, W as resetAfterCommit, H as rpcInterceptorFor, G as runAfterCommit, K as runInStoreTransaction, Xe as serviceAccount, U as serviceLayerFor, Qe as system, it as testEventBus, Je as user, Ne as withFrozenTime };
+export { P as MockClock, L as MockLLM, F as MockWebhooks, lt as TESTING_PRESET_VERSION, Ye as TEST_TENANT_ID, $e as anonymous, Ze as apiKey, n as changeDelete, r as changeInsert, i as changeSoftDelete, a as changeUpdate, Ae as defineFactory, Z as describeIfAvailable, Je as describeIfReachable, O as fixtureRow, Pe as frozenTime, qe as invoke, X as isTcpReachable, ot as makeSubscribeContext, at as makeTestApp, Ge as makeTestContext, ct as makeWorkflowRunner, Ie as mockStore, D as nextSequence, Le as outboxNudgesOf, K as resetAfterCommit, W as rpcInterceptorFor, q as runAfterCommit, J as runInStoreTransaction, Qe as serviceAccount, G as serviceLayerFor, et as system, I as testEventBus, Xe as user, Ne as withFrozenTime };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/testing",
-  "version": "0.39.1",
+  "version": "0.40.0",
   "description": "Test utilities for Voltro apps — deterministic clock, subject and row factories, a handler-level invoke and a request-level app harness, queued LLM responses, scoped subject/tenant runners, and a cross-dialect parity harness.",
   "keywords": [
     "voltro",
@@ -43,15 +43,15 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.39.1",
-    "@voltro/env": "0.39.1",
-    "@voltro/logger": "0.39.1",
-    "@voltro/protocol": "0.39.1",
-    "@voltro/runtime": "0.39.1",
-    "@voltro/workflow": "0.39.1"
+    "@voltro/database": "0.40.0",
+    "@voltro/env": "0.40.0",
+    "@voltro/logger": "0.40.0",
+    "@voltro/protocol": "0.40.0",
+    "@voltro/runtime": "0.40.0",
+    "@voltro/workflow": "0.40.0"
   },
   "peerDependencies": {
-    "@voltro/client": "0.39.1",
+    "@voltro/client": "0.40.0",
     "effect": "^3.22.0",
     "react": "^19.0.0",
     "@effect/sql": "^0.52.0"