@voltro/testing 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -39,6 +39,26 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.7.0] — 2026-07-20
+
+### ⚠ BREAKING
+
+- **@voltro/runtime** — Row-level security: a `load` failure is now retried, and then surfaces as an **error** instead of an empty result. `setRowFilter({ load, predicate })` resolves `load` once per request; previously ANY failure was answered with a predicate matching zero rows. A downstream app reported the consequence correctly — for shared/team visibility `load` must read the store, so one transient DB blip denied every constrained table for that request and the whole UI rendered empty. Two distinct defects, fixed separately, because conflating them was the original mistake. **A transient failure should never reach the decision:** `load` had no retry at all, so a reaped connection was answered as if it were an authorization fact. It now runs under a bounded `retry` schedule — `DEFAULT_ROW_FILTER_RETRY`, three attempts backing off exponentially from 20ms, so ~60ms worst case — configurable per filter with your own `Schedule`, or `retry: false` for one attempt. **And refusal was expressed as an empty result, which is a lie:** "we could not determine your visibility" and "you may see nothing" are different facts, and only one of them is a fact. An empty list is byte-identical to legitimate emptiness, so the user reads "you have no tickets", the operator reads a healthy 200, and the outage is invisible to both — the most misleading outcome available. The module header used to defend this ("an empty result rather than a 500 on every page"); every constrained page IS broken, and saying so is the correct behavior. `onLoadError` now defaults to `'fail'`, raising the exported typed `RowFilterUnavailable`; `onLoadError: 'deny'` keeps the old degradation for apps that have looked at the screen and genuinely prefer an empty list to an error state, with the `onError` reporter still firing so the choice is not silent. The app asked for `onLoadError: 'fallthrough'` — fail OPEN to the handler's own check. Deliberately not implemented, and not planned. Serving unfiltered rows when the authorization filter is unavailable leaks data precisely when the system is under stress and nobody is reading dashboards, and it is only safe if every handler still carries the check that row filters exist to replace. Fail-closed is retained under both policies; a test asserts neither branch can ever yield an unfiltered read. **Migration.** `resolveRowFilterScope` gains an error channel — `Effect<RowFilterScope, RowFilterUnavailable>` instead of an infallible Effect — so direct callers (a custom entrypoint, a test harness) must handle it; TypeScript points at each one. Apps that want the previous behavior add `onLoadError: 'deny'`, but should decide that rather than default into it. Tests asserting "a broken load yields an empty result" now fail with `RowFilterUnavailable`, which is the fix working. Subscriptions changed shape too: a re-resolve that fails mid-delivery now REVOKES the subscription and emits a typed error frame — following the existing withdrawn-guard precedent — because an empty snapshot on a live subscription reads to a client as "every row you could see was just deleted". The same failure at subscribe time aborts the subscribe instead of opening a stream on a fabricated snapshot, and unwinds the matcher + dependent-table registration it had already made (previously leaked on any subscribe-time throw).
+- **@voltro/testing, @voltro/runtime** — `@voltro/testing` now mirrors the runtime store's POLICY path, not only its DATA path. An adopting app found three places where the harness diverged, each of which made a class of rule untestable in-repo while leaving the suite green. **`invoke` runs Effect-mode handlers.** The framework's contract is "async OR Effect, your choice per handler", and every production runner honours it (`Effect.isEffect(result) ? … : …`). `invoke` only awaited the executor's return value, so an Effect-mode handler handed back its own un-run `EffectPrimitive`: nothing executed, nothing was written, and a test asserting on the "result" asserted on a description of work. The Effect now runs through `runProvidedEffect` — the same function the serve entrypoints use — so a handler failing with a typed error REJECTS WITH THAT ERROR rather than an opaque FiberFailure, and `EffectStore` + `SubjectService` are provided over the context the handler is actually given. Guards, the input decode, the transactional wrap, the deadlock replay, `afterCommit` and the plugin interceptor chain apply identically to both modes. **`makeTestContext({ relations: [spec] })`** registers `relations()` specs. `relations()` is pure — it returns a spec, it does not register one — and production registration is a boot step (`voltro dev` → `registerDiscoveredRelations`), so under the harness an eager load failed with "no relations registered" no matter what the test imported. The option REPLACES the process-global registry with exactly the specs given (the registry is a `Symbol.for` global; additive registration would throw `duplicate relation` on the second `makeTestContext` in a file and leak the first test's relations into the second). Omitting it touches the registry not at all. **The harness store applies row-level security.** After `setRowFilter(...)` a `makeTestContext` read of a constrained table returned the unfiltered set, so "user A cannot see user B's row" could not be asserted at all. `ctx.store` now resolves the filter for its subject and AND-merges it into every read — fluent builders and descriptor reads alike, not bypassed by `.unscoped()`, bypassed for a `system` subject. A new `rowFilter:` option passes a filter directly for tests that would rather not write to a process global. Resolution goes through the runtime's new `resolveRowFilterScopeFor` (`resolveRowFilterScope` is now that function applied to the registered filter), so the retry schedule, the system bypass and the `onLoadError` policy are the runtime's single definition rather than a second copy in the harness. **Breaking, and how to migrate** (`voltro update` prints this): delete any `Effect.isEffect(out) ? await Effect.runPromise(out) : out` shim around an `invoke` call — it is dead code that also destroyed your typed errors. `ProcedureExecutor<Input, Output>` gained an `Effect<Output, E>` arm and an optional third parameter `E` (default `never`); `invoke` now infers from the executor's whole return type instead of taking `Output` as its second type parameter, so an explicit `invoke<typeof d, Note>(…)` type-argument list must be dropped in favour of inference. Handlers themselves keep compiling — what changes is the type of a CALL.
+
+### Added
+
+- **@voltro/plugin-auth** — `subjectFromUser(user, { metadata })` now carries arbitrary app metadata onto the Subject. Previously the helper set the metadata slot ONLY when `memberships` were supplied, so an app whose Subject must carry a provider credential — an Atlassian PAT captured at login and read back as `subject.metadata.jiraToken` by `@voltro/plugin-atlassian`'s `credentialsResolver`, say — could not adopt the helper at all: calling it silently dropped the credential, and building the Subject by hand was the only way to keep it. The framework shipped both halves of that gap itself. `metadata` MERGES with the memberships projection rather than replacing it. **Precedence when a `memberships` key appears in both:** the dedicated `memberships` option wins — it is the specific, typed input, and it is the one projected into the `{ tenantId, role }` shape `subjectMemberships()` and the switch-tenant menu read, so letting a free-form bag shadow it would break tenant switching in a way nothing type-checks. Without the option, a `memberships` key inside `metadata` passes through unchanged. A Subject built with neither option still has NO `metadata` key (not an empty object). The later stamps compose unchanged: the sign-in / sign-up / magic-link / passkey handlers spread the existing slot before adding `sessionId`, and the password strategy does the same for `provider`, so keys set through this option survive every login path — unless a caller names a key `sessionId` or `provider`, which those merges overwrite by design. **`handleSwitchTenant` now carries that metadata across a switch**, via a new optional `metadata` on `SwitchTenantInput` (the built-in `/switch-tenant` route passes the caller's `subject.metadata` for you). Without this the option above would have been a trap rather than a feature: a switch rebuilds the Subject from the user record, so an app parking a provider credential in the slot would lose it the first time a user changed tenant — staying authenticated while every call to the provider began failing, with no signal at the point that caused it. `memberships` is deliberately NOT carried: it is re-derived for the target tenant, and a carried copy would report a role the user does not hold there. Covered by a test that fails on the exact assertion when the carry is removed. `SwitchTenantInput` is now exported too — every sibling handler input (`SignInInput`, `MfaVerifyInput`, …) already was, and this one had simply been forgotten, so an app calling `handleSwitchTenant` directly could not name its argument type. Additive: the option is optional and callers that pass neither get byte-identical Subjects. `packages/plugin-auth/etc/plugin-auth.api.md` gains one line and changes none.
+- **@voltro/database** — `timestampMs` and `timestampMsOrNull` — the timestamp wire mapping as STANDALONE field schemas, for hand-written `Schema.Struct` outputs. `Date` in the handler, epoch-ms `number` on the wire; `timestampMsOrNull` is the `.nullable()` column's variant, so a "never archived" row stays `null` instead of becoming `new Date(null)` (1970-01-01, which renders as a plausible date rather than as nothing). ```ts output: Schema.Struct({   id: Schema.String,   addedAt: timestampMs,          // Date in the handler, epoch ms on the wire   archivedAt: timestampMsOrNull,   seenAt: Schema.optional(timestampMs), }) ``` This closes the half of the problem `rowSchema(table)` left open. `rowSchema` only helps a handler returning a RAW FULL TABLE ROW, and real handlers overwhelmingly return a COMPUTED struct assembled across several tables — `{ id, name, slug, addedAt, jiraProjectKey }` — where there is no single table to derive from. That is exactly where the hand-written `Date → epoch` converters accumulate: the app that reported the original gap has ~228 of them, all in shaped outputs, and found zero clean applications for whole-row `rowSchema`. Single-sourced, not a parallel declaration: `columnSchema` now READS `timestampMs` for `timestamp()` / `date()` columns, so the derived-row and hand-written-struct paths are the same schema by identity and cannot drift into different wire representations. `rowSchema.test.ts` asserts that identity rather than asserting both merely produce a number. There is deliberately no `timestampMsOptional` — an absent field is `Schema.optional(timestampMs)`, which composes without a third export. Both exports live in the browser-safe `@voltro/database` main entry (pure `effect/Schema`, no driver, no `node:*`), which is what a descriptor's `output` needs. Additive: two new exports, no existing declaration changed. `packages/database/etc/database.api.md` gains two entries and changes none.
+
+### Fixed
+
+- **@voltro/sql-turso** — Turso (local Rust engine): pooled connections now WAIT for a held lock instead of failing instantly with `database is locked`. The engine keeps SQLite's default of `PRAGMA busy_timeout = 0`, so any statement that met a lock held by another connection failed on the spot — and with the default pool of 4 connections on one file, two concurrent writers are enough to reach it. `makeConnection` now issues `busy_timeout` for every pooled connection, beside the mandatory MVCC and foreign-key pragmas. MVCC did not cover this and was the reason it was missed: `journal_mode=experimental_mvcc` resolves write-write conflicts BETWEEN transactions, while DDL and the schema lock stay exclusive, so the failure lands on statements the concurrency design appears to have handled. It also only reproduces under CPU contention — green on an idle machine, sporadic under load — which is the worst shape for a defect to have. It surfaced as a flaky `CREATE TABLE` in the MVCC keystone test during a full local gate run, where 78 packages build in parallel; a user would see it as an intermittent `database is locked` under production traffic with no obvious trigger. The default is 5000ms, matching better-sqlite3's own default — which is why the sibling `@voltro/sql-sqlite` never needed this: that driver sets the timeout for us, and the turso NAPI driver does not. Tunable via `busyTimeoutMs` on `makeTursoSqlLayer` / `TursoClientConfig`, beside `maxConnections`; `busyTimeoutMs: 0` explicitly restores the fail-immediately behavior (asserted by a test, so the default can never be implemented as a floor that silently ignores 0). It is deliberately NOT on the cross-dialect `ConnectionConfig` — that shape stays free of engine-specific knobs, the same reason the Turso auth token is env-sourced rather than threaded through it.
+- **@voltro/cli** — `voltro update` now honors the project's actual package manager instead of defaulting to npm. It resolves the manager by walking from the app directory **up to the repo root**, preferring the corepack `packageManager` field over a lockfile (`pnpm-lock.yaml` / `yarn.lock` / `bun.lock` / `bun.lockb` / `package-lock.json`), and only falls back to npm when nothing declares one. Walking up fixes the workspace case: a scaffolded project keeps its lockfile at the monorepo root, so running `voltro update` from `apps/api` previously found no lockfile and ran `npm install` against a pnpm/yarn workspace — writing a stray lockfile and a nested `node_modules`. The resolved manager is also used for the latest-version registry lookup (`pnpm view` / `yarn` / `bun pm view`, with `npm view` as a last-resort fallback), so a private or scoped registry configured in `.npmrc` / `.yarnrc.yml` is honored. The yarn query dispatches on the installed yarn MAJOR version rather than probing berry syntax first: on yarn classic, `yarn npm info …` parses as `yarn run npm` and **executes a `npm` script from the project's package.json** if one exists — verified against yarn 1.22.22. Resolving a version number must never run user code, so classic gets `yarn info … --silent` and only berry (>=2) gets `yarn npm info`. All three managers are verified against real binaries in throwaway Docker containers — yarn classic 1.22.22, yarn berry 4.6.0, bun 1.3.14 — each asserting both that the query resolves a version and that it does not execute a same-named script. Re-run with `node scripts/smoke-package-managers.mjs`.
+- **@voltro/cli** — Three fixes to `voltro update`, all reported by an app upgrading a pnpm workspace. **The bump is now LOCKSTEP across the whole workspace.** `voltro update` in `apps/api` bumped only that `package.json`, leaving the sibling web app and shared `packages/*` on the previous version — an api on 0.6.0 and a web client on 0.5.0 disagree about the generated rpcGroup types and the session cookie shape, and that disagreement surfaces as a runtime decode error, not a build error. When the app sits inside a workspace (`pnpm-workspace.yaml`, or a `workspaces` field in an ancestor `package.json`, found by the same bounded upward walk that resolves the package manager and stops at the first `.git`), every member `package.json` that declares `@voltro/*` is bumped to the target together, and the install runs **once at the workspace root** — running it inside `apps/api` corrupts a pnpm/yarn workspace's layout. Each file that will be bumped is listed in the plan output and in `--dry-run`. A standalone (non-workspace) project is unchanged: its own `package.json`, its own install, in place. The codemod re-exec now also looks for the installed `voltro` bin at the workspace root, since npm and yarn hoist it there. **A failed install now says that the codemods were skipped.** It previously printed only "install failed — package.json was bumped; fix the install and re-run", never mentioning codemods, so a user could boot on target-version code with source shaped for the old one and no signal as to why. The codemods for a jump ship *inside* the target version, which a failed install did not put on disk, so running them is impossible rather than merely undesirable — the fix is the message. It now states plainly that no codemods were applied, why, and prints the exact copy-pasteable recovery command with the concrete versions: `voltro update --codemods-only --from <from> --to <to>`. **`--help` / `-h` is answered before every guard.** `voltro update --help` on a dirty tree printed "working tree is not clean" — at precisely the moment the user was trying to discover `--dry-run` and `--codemods-only`. Help is documentation, not an operation, so it is now handled first, ahead of the `package.json` check, the `@voltro/*`-deps check and the clean-tree guard, and lists every flag (`--to`, `--from`, `--root`, `--dry-run`, `--force`, `--exact`, `--codemods-only`). `voltro doctor --help` had the same shape — it fell through to the preflight and reported on the tree instead — and gets the same treatment. `voltro help`'s `update` line now names `--from` and `--codemods-only` too.
+
+---
+
 ## [0.6.0] — 2026-07-19
 
 ### ⚠ BREAKING

package/dist/index.d.ts

@@ -5,7 +5,9 @@ import { InspectedWorkflow } from '@voltro/workflow';
 import { Layer } from 'effect';
 import { ParseResult } from 'effect';
 import { ProcedureDescriptor } from '@voltro/protocol';
+import { RelationsSpec } from '@voltro/database';
 import { Row } from '@voltro/database';
+import { RowFilter } from '@voltro/runtime';
 import { RpcInterceptor } from '@voltro/protocol';
 import { RpcKind } from '@voltro/protocol';
 import { Schema } from 'effect';
@@ -21,6 +23,19 @@ import { VoltroPlugin } from '@voltro/protocol';
  *  ergonomic without an `any` in the public type. */
 declare type ErasedWorkflowEffect = Effect.Effect<unknown, unknown, never>;
 
+/**
+ * What `invoke` resolves to for a handler returning `Result`: an `Effect`'s
+ * SUCCESS value, an awaited `Promise`, or the value itself.
+ *
+ * Inferring from the executor's whole return type — rather than making `Output`
+ * a naked type parameter that also appears inside `Effect<Output, E>` — is what
+ * keeps `invoke(d, () => Effect.succeed('x'), …)` resolving to `string` instead
+ * of to `Effect<string>`: with two inference sites for one parameter TypeScript
+ * would pick the bare candidate and hand the caller back the un-run Effect in
+ * the TYPE as well as at runtime.
+ */
+export declare type HandlerOutput<Result> = Result extends Effect.Effect<infer A, infer _E, infer _R> ? A : Awaited<Result>;
+
 /**
  * Run `executor` as the dispatcher would: enforce the descriptor's `guards:`
  * against `ctx.request.subject`, decode `rawInput` through the descriptor's
@@ -54,17 +69,48 @@ declare type ErasedWorkflowEffect = Effect.Effect<unknown, unknown, never>;
  * expect(await ctx.store.select('notes').all()).toHaveLength(0)
  * ```
  */
-export declare const invoke: <D extends Pick<ProcedureDescriptor, "input">, Output>(descriptor: D, executor: ProcedureExecutor<Schema.Schema.Type<D["input"]>, Output>, rawInput: unknown, ctx: TestContext) => Promise<Output>;
+export declare const invoke: <D extends Pick<ProcedureDescriptor, "input">, Result>(descriptor: D, executor: (input: Schema.Schema.Type<D["input"]>, ctx: TestContext) => Result, rawInput: unknown, ctx: TestContext) => Promise<HandlerOutput<Result>>;
 
-export declare const makeTestContext: (options?: MakeTestContextOptions) => TestContext;
+export declare const makeTestContext: <RowFilterCtx = unknown>(options?: MakeTestContextOptions<RowFilterCtx>) => TestContext;
 
-export declare interface MakeTestContextOptions {
+export declare interface MakeTestContextOptions<RowFilterCtx = unknown> {
     /** The acting subject. Default: anonymous, no tenant. Read it back at
      *  `ctx.request.subject` (the same place a live handler reads it). */
     readonly subject?: Subject;
     /** Tables to wire into the store's schema. Default: all globally
      *  registered tables (whatever the test imported). */
     readonly tables?: ReadonlyArray<TableLike>;
+    /**
+     * `relations(...)` specs to register for this context — the harness's stand-in
+     * for the boot sweep, so `.with({ ... })` eager loads resolve under test.
+     *
+     * Needed because `relations()` is PURE: it RETURNS a spec, it does not
+     * register one. In production `voltro dev` discovers `*.relations.ts` and
+     * feeds each export to `registerDiscoveredRelations`; a unit test runs no
+     * boot, so importing the module registers nothing and the first eager load
+     * fails with "no relations registered". Hand the specs over instead:
+     *
+     * ```ts
+     * import { teamRelations } from '../db/teams.relations'
+     * const ctx = makeTestContext({ relations: [teamRelations] })
+     * ```
+     *
+     * SEMANTICS, because the registry is process-global (a `Symbol.for` map shared
+     * by every copy of `@voltro/database`) and that global is a leak waiting to
+     * happen: passing `relations` REPLACES the registry with exactly these specs
+     * (`clearRelationsRegistry()` then `registerRelations` each). It is a
+     * declaration of what this context's relations ARE, not an addition to
+     * whatever a previous test left behind. That is what makes two
+     * `makeTestContext({ relations: [...] })` calls in one file independent —
+     * additive registration would make the second call throw
+     * `duplicate relation '…'` on a re-registered spec and would silently carry
+     * the first test's relations into the second's store.
+     *
+     * Omitting the option touches the registry NOT AT ALL, so a suite that calls
+     * `registerRelations` itself (or one whose app registers at import time) keeps
+     * working unchanged.
+     */
+    readonly relations?: ReadonlyArray<RelationsSpec>;
     /** Seed rows keyed by table name (use `mockStore({...})`). */
     readonly store?: Record<string, ReadonlyArray<Row>>;
     /** Frozen clock start. Default 2026-01-01T00:00:00Z. */
@@ -97,6 +143,24 @@ export declare interface MakeTestContextOptions {
      * for a single handler call, and are ignored.
      */
     readonly plugins?: ReadonlyArray<VoltroPlugin>;
+    /**
+     * Row-level security for this context, WITHOUT touching the process global.
+     *
+     * `ctx.store` applies the app's row filter either way: with this option
+     * omitted the harness resolves whatever `setRowFilter(...)` registered, so a
+     * test that boots its app's real filter needs no option at all. Passing one
+     * here overrides the global FOR THIS CONTEXT — which is what a test usually
+     * wants, because `setRowFilter` is process-global: registered in one test it
+     * silently constrains every later test in the same worker, and forgetting the
+     * `afterEach` that clears it produces a failure in an unrelated file.
+     *
+     * Resolution goes through `resolveRowFilterScopeFor` — the same function
+     * `resolveRowFilterScope` (and therefore the serve pipeline) is built on — so
+     * the system-subject bypass, the `retry` schedule, and the `onLoadError`
+     * decision are inherited rather than re-implemented. A filter whose `load`
+     * fails refuses here exactly as it refuses in production.
+     */
+    readonly rowFilter?: RowFilter<RowFilterCtx>;
 }
 
 export declare const makeWorkflowRunner: (opts: MakeWorkflowRunnerOptions) => WorkflowRunner;
@@ -171,9 +235,13 @@ export declare const outboxNudgesOf: (ctx: TestContext) => ReadonlyArray<string>
 export { ParseResult }
 
 /** Any procedure executor: takes the DECODED input + a context, returns a
- *  result (sync or async). Mirrors the `(input, ctx) => …` shape a real
- *  query / mutation / action handler has. */
-export declare type ProcedureExecutor<Input, Output> = (input: Input, ctx: TestContext) => Output | Promise<Output>;
+ *  result — sync, `Promise`, or `Effect`. Mirrors the `(input, ctx) => …` shape
+ *  a real query / mutation / action handler has, INCLUDING the Effect form: the
+ *  framework's contract is "async or Effect, your choice per handler", and the
+ *  dispatcher runs both (`Effect.isEffect(result) ? … : …` in `servePipeline`).
+ *  `E` is the handler's typed error channel; it defaults to `never` for the
+ *  common `Effect.gen` that only succeeds. */
+export declare type ProcedureExecutor<Input, Output, E = never> = (input: Input, ctx: TestContext) => Output | Promise<Output> | Effect.Effect<Output, E>;
 
 /**
  * Drop queued post-commit work WITHOUT running it.

package/dist/index.js

@@ -1,11 +1,11 @@
 import { Cause as e, Effect as t, Exit as n, Layer as r, Schema as i } from "effect";
-import { anonymousSubject as a, checkGuardsEffect as o, composeRpcInterceptors as s } from "@voltro/protocol";
-import { InMemoryDataStore as c, makeAppAccess as l, makeDataLoader as u, makeOutboxFacade as d, makeSchemaRegistry as f, runWithDeadlockRetry as p, wrapStoreWithMixinBehaviour as m } from "@voltro/runtime";
-import { allRegisteredTables as h } from "@voltro/database";
-import { installEnvSnapshot as g } from "@voltro/env";
-import { CurrentWorkflowRunId as _, inMemoryWorkflowEngineLayer as v, makeInMemoryRecorder as y } from "@voltro/workflow";
+import { SubjectService as a, anonymousSubject as o, checkGuardsEffect as s, composeRpcInterceptors as c } from "@voltro/protocol";
+import { InMemoryDataStore as l, applyRowFilterToDescriptor as u, getRowFilter as d, makeAppAccess as f, makeDataLoader as p, makeEffectStoreLayer as m, makeOutboxFacade as h, makeSchemaRegistry as g, resolveRowFilterScopeFor as _, runProvidedEffect as v, runWithDeadlockRetry as y, wrapStoreWithMixinBehaviour as b } from "@voltro/runtime";
+import { allRegisteredTables as x, clearRelationsRegistry as S, registerRelations as C } from "@voltro/database";
+import { installEnvSnapshot as w } from "@voltro/env";
+import { CurrentWorkflowRunId as T, inMemoryWorkflowEngineLayer as E, makeInMemoryRecorder as D } from "@voltro/workflow";
 //#region src/mockClock.ts
-var b = class {
+var O = class {
 	currentMs;
 	constructor(e = /* @__PURE__ */ new Date("2026-01-01T00:00:00Z")) {
 		this.currentMs = typeof e == "number" ? e : e.getTime();
@@ -17,9 +17,9 @@ var b = class {
 		return new Date(this.currentMs);
 	}
 	advance(e) {
-		this.currentMs += typeof e == "number" ? e : x(e);
+		this.currentMs += typeof e == "number" ? e : k(e);
 	}
-}, x = (e) => {
+}, k = (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 +31,7 @@ var b = class {
 		case "d": return n * 864e5;
 		default: throw Error(`mockClock: unknown unit '${r}'`);
 	}
-}, S = class {
+}, A = class {
 	sent = [];
 	send(e) {
 		this.sent.push({
@@ -45,7 +45,7 @@ var b = class {
 	clear() {
 		this.sent.length = 0;
 	}
-}, C = class {
+}, j = class {
 	queue;
 	calls = [];
 	constructor(e) {
@@ -60,29 +60,29 @@ var b = class {
 	remaining() {
 		return this.queue.length;
 	}
-}, w = (e) => e, T = "00000000000000000000000000000000", E = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap(), O = /* @__PURE__ */ new WeakMap(), k = /* @__PURE__ */ new WeakMap(), A = (e, t) => {
-	let n = k.get(e) ?? [], r = t === "mutation" ? "interceptMutation" : t === "query" ? "interceptQuery" : "interceptAction", i = [];
+}, M = (e) => e, N = "00000000000000000000000000000000", P = /* @__PURE__ */ new WeakMap(), F = /* @__PURE__ */ new WeakMap(), I = /* @__PURE__ */ new WeakMap(), L = /* @__PURE__ */ new WeakMap(), R = (e, t) => {
+	let n = L.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 s(i);
-}, j = (e) => {
-	let t = D.get(e);
+	return c(i);
+}, z = (e) => {
+	let t = F.get(e);
 	t !== void 0 && (t.length = 0);
-}, M = async (e) => {
-	let t = D.get(e);
+}, B = async (e) => {
+	let t = F.get(e);
 	if (t === void 0 || t.length === 0) return;
 	let n = [...t];
 	t.length = 0;
 	for (let e of n) await e();
-}, N = (e) => O.get(e) ?? [], P = async (e, t) => {
-	let n = E.get(e);
+}, V = (e) => I.get(e) ?? [], H = async (e, t) => {
+	let n = P.get(e);
 	return n === void 0 ? e.store.transactional(async (n) => t({
 		...e,
 		store: n
 	})) : n(t);
-}, F = (e) => {
+}, U = (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 +121,7 @@ var b = class {
 			return i(e, o, n.ttlMs, n.tags), o;
 		}
 	};
-}, I = (e) => {
+}, W = (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,73 +149,91 @@ var b = class {
 			t.clear();
 		}
 	};
-}, L = (e = {}) => {
-	g({
+}, G = (e, t) => {
+	let n = K, r;
+	return () => {
+		let i = t ?? d();
+		return (r === void 0 || i !== n) && (n = i, r = v(_(i, e, (e) => {
+			console.error("[voltro:testing] row filter failed to load — reads refused for this subject", e);
+		}))), r;
+	};
+}, K = Symbol("unresolved"), q = (e, t) => new Proxy(e, { get: (e, n) => {
+	if (n === "query") return async (n) => e.query(u(await t(), n));
+	let r = Reflect.get(e, n, e);
+	return typeof r == "function" ? r.bind(e) : r;
+} }), J = (e = {}) => {
+	if (w({
 		...process.env,
 		...e.env ?? {}
-	});
-	let t = f(e.tables ?? h()), n = new c(e.store ?? {}), r = new b(e.clockStart), i = new S(), o = new C(e.llmResponses ?? []), s = F(() => r.now()), p = I(() => r.now()), _ = (a, c = n, f) => {
-		let h = {
-			subject: a,
-			traceId: T
-		}, g = f?.queued ?? [], v = f?.nudges ?? [], y = u({ store: c }), b = {
+	}), e.relations !== void 0) {
+		S();
+		for (let t of e.relations) C(t);
+	}
+	let t = g(e.tables ?? x()), n = new l(e.store ?? {}), r = new O(e.clockStart), i = new A(), a = new j(e.llmResponses ?? []), s = U(() => r.now()), c = W(() => r.now()), u = (o, l = n, d) => {
+		let m = {
+			subject: o,
+			traceId: N
+		}, g = d?.queued ?? [], _ = d?.nudges ?? [], v = p({ store: l }), y = G(o, e.rowFilter), x = {
 			clock: r,
 			email: i,
-			llm: o,
+			llm: a,
 			...e.ai === void 0 ? {} : { ai: e.ai },
-			request: h,
-			access: l(a),
+			request: m,
+			access: f(o),
 			cache: s,
-			kv: p,
-			store: m(c, {
-				subject: a,
+			kv: c,
+			store: b(q(l, y), {
+				subject: o,
 				schemaRegistry: t
 			}),
-			outbox: d({
-				store: c,
-				subject: a,
-				traceId: T,
+			outbox: h({
+				store: l,
+				subject: o,
+				traceId: N,
 				nudge: () => {
-					v.push(T);
+					_.push(N);
 				},
 				afterCommit: (e) => {
 					g.push(e);
 				}
 			}),
-			load: y.load,
-			loadMany: y.loadMany,
-			withSubject: (e, t) => Promise.resolve(t(_(e, c, {
+			load: v.load,
+			loadMany: v.loadMany,
+			withSubject: (e, t) => Promise.resolve(t(u(e, l, {
 				queued: g,
-				nudges: v
+				nudges: _
 			}))),
-			withTenant: (e, t) => Promise.resolve(t(_({
-				...a,
+			withTenant: (e, t) => Promise.resolve(t(u({
+				...o,
 				tenantId: e
-			}, c, {
+			}, l, {
 				queued: g,
-				nudges: v
+				nudges: _
 			})))
 		};
-		return D.set(b, g), O.set(b, v), k.set(b, e.plugins ?? []), E.set(b, (e) => c.transactional((t) => e(_(a, t, {
+		return F.set(x, g), I.set(x, _), L.set(x, e.plugins ?? []), P.set(x, (e) => l.transactional((t) => e(u(o, t, {
 			queued: g,
-			nudges: v
-		})))), b;
+			nudges: _
+		})))), x;
 	};
-	return _(e.subject ?? a(null));
-}, R = async (r, a, s, c) => {
-	let l = r.input, u = await i.decodeUnknownPromise(l)(s), d = r.kind, f = async () => {
+	return u(e.subject ?? o(null));
+}, Y = (e, n) => e.pipe(t.provide(m(n.store)), t.provideService(a, n.request.subject)), X = 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) ? v(Y(n, e)) : n;
+	}, p = async () => {
 		let e = r.guards;
 		if (e !== void 0 && e.length > 0) {
-			let n = await t.runPromise(o(c.request.subject, e, u));
+			let n = await t.runPromise(s(c.request.subject, e, u));
 			if (n !== null) throw n;
 		}
-		if (d !== "mutation") return a(u, c);
-		let n = await p(async () => (j(c), P(c, async (e) => a(u, e))), { delay: () => Promise.resolve() });
-		return await M(c), n;
-	}, m = d === "mutation" || d === "query" || d === "action" ? d : void 0, h = m === void 0 ? void 0 : A(c, m);
-	if (h === void 0 || m === void 0) return f();
+		if (d !== "mutation") return f(c);
+		let n = await y(async () => (z(c), H(c, async (e) => f(e))), { delay: () => Promise.resolve() });
+		return await B(c), n;
+	}, m = d === "mutation" || d === "query" || d === "action" ? d : void 0, h = m === void 0 ? void 0 : R(c, m);
+	if (h === void 0 || m === void 0) return await p();
 	let g = h(t.tryPromise({
-		try: () => f(),
+		try: () => p(),
 		catch: (e) => e
 	}), {
 		tag: r.name ?? "",
@@ -227,7 +245,7 @@ var b = class {
 	}), _ = await t.runPromiseExit(g);
 	if (n.isSuccess(_)) return _.value;
 	throw e.squash(_.cause);
-}, z = (e) => {
+}, Z = (e) => {
 	let t = /* @__PURE__ */ new Map();
 	for (let n of e) {
 		let e = t.get(n.stepName);
@@ -253,14 +271,14 @@ var b = class {
 		});
 	}
 	return n.sort((e, t) => e._startedAt - t._startedAt), n.map(({ _startedAt: e, ...t }) => t);
-}, B = (e) => {
+}, Q = (e) => {
 	let n = e.workflows ?? [], i = /* @__PURE__ */ new Map(), a = 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 = y(), d = c.workflow.toLayer(c.execute).pipe(r.provideMerge(v)), f = /* @__PURE__ */ new Date(), p = c.workflow.execute(s).pipe(t.locally(_, l), t.provide(u.layer), t.provide(d), t.either), m = await t.runPromise(p), h = z(u.readSteps()), g = /* @__PURE__ */ new Date(), b;
-			if (m._tag === "Right") b = {
+			let l = `wfrun_test_${++a}`, u = D(), d = c.workflow.toLayer(c.execute).pipe(r.provideMerge(E)), f = /* @__PURE__ */ new Date(), p = c.workflow.execute(s).pipe(t.locally(T, l), t.provide(u.layer), t.provide(d), t.either), m = await t.runPromise(p), h = Z(u.readSteps()), g = /* @__PURE__ */ new Date(), _;
+			if (m._tag === "Right") _ = {
 				status: "succeeded",
 				output: m.right,
 				error: null,
@@ -269,7 +287,7 @@ var b = class {
 			};
 			else {
 				let e = m.left;
-				b = {
+				_ = {
 					status: "failed",
 					output: null,
 					error: {
@@ -284,9 +302,9 @@ var b = class {
 				id: l,
 				executionId: l,
 				name: o,
-				status: b.status,
+				status: _.status,
 				input: s,
-				output: b.output,
+				output: _.output,
 				subject: e.ctx.request.subject,
 				source: "test-runner",
 				steps: h,
@@ -295,10 +313,10 @@ var b = class {
 				traceId: null,
 				parentExecutionId: null,
 				parentClosePolicy: null
-			}), b;
+			}), _;
 		},
 		inspect: async (e) => i.get(e) ?? null
 	};
-}, V = 1;
+}, $ = 1;
 //#endregion
-export { b as MockClock, S as MockEmail, C as MockLLM, V as TESTING_PRESET_VERSION, R as invoke, L as makeTestContext, B as makeWorkflowRunner, w as mockStore, N as outboxNudgesOf, j as resetAfterCommit, A as rpcInterceptorFor, M as runAfterCommit, P as runInStoreTransaction };
+export { O as MockClock, A as MockEmail, j as MockLLM, $ as TESTING_PRESET_VERSION, X as invoke, J as makeTestContext, Q as makeWorkflowRunner, M as mockStore, V as outboxNudgesOf, z as resetAfterCommit, R as rpcInterceptorFor, B as runAfterCommit, H as runInStoreTransaction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/testing",
-  "version": "0.6.0",
+  "version": "0.7.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",
@@ -42,16 +42,16 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.6.0",
-    "@voltro/env": "0.6.0",
-    "@voltro/protocol": "0.6.0",
-    "@voltro/runtime": "0.6.0",
-    "@voltro/workflow": "0.6.0"
+    "@voltro/database": "0.7.0",
+    "@voltro/env": "0.7.0",
+    "@voltro/protocol": "0.7.0",
+    "@voltro/runtime": "0.7.0",
+    "@voltro/workflow": "0.7.0"
   },
   "peerDependencies": {
     "effect": "^3.21.4",
     "react": "^19.0.0",
-    "@voltro/client": "0.6.0"
+    "@voltro/client": "0.7.0"
   },
   "peerDependenciesMeta": {
     "react": {