@voltro/testing 0.85.0 → 0.87.0

package/dist/testContext.js

@@ -0,0 +1,269 @@
+import { MockClock as e } from "./mockClock.js";
+import { recordTestRawStore as t, registerTestFieldKeys as n } from "./fieldKeys.js";
+import { MockWebhooks as r } from "./mockWebhooks.js";
+import { testEventBus as i } from "./testEventBus.js";
+import { MockLLM as a } from "./mockLLM.js";
+import { allRegisteredTables as o, clearRelationsRegistry as s, registerRelations as c } from "@voltro/database";
+import { Effect as l, Layer as u } from "effect";
+import { anonymousSubject as d, composeRpcInterceptors as f, tenantScopedSubject as p } from "@voltro/protocol";
+import { InMemoryDataStore as m, NO_ROW_FILTER as h, appValidation as g, applyRowFilterToDescriptor as _, clearSystemStoreHandle as v, getRowFilter as y, getSystemStoreHandle as b, installComputedQueryCacheCapture as x, makeAppAccess as S, makeConnectionState as ee, makeDataLoader as te, makeEventPublisher as ne, makeFieldCipher as C, makeOutboxFacade as w, makeSchemaRegistry as T, queryCachePolicy as E, recordingStore as D, resolveRowFilterScopeFor as O, resolveTransactionSubject as k, runProvidedEffect as A, setFieldCipher as j, setSystemStoreHandle as M, wrapStoreWithMixinBehaviour as N } from "@voltro/runtime";
+import { installEnvSnapshot as re } from "@voltro/env";
+import { Cache as ie, layerMemory as ae } from "@voltro/cache";
+//#region src/testContext.ts
+var P = (e) => e, F = "00000000000000000000000000000000", I = /* @__PURE__ */ new WeakMap(), L = /* @__PURE__ */ new WeakMap(), R = (e, t) => {
+	let n = L.get(e);
+	if (n === void 0) throw Error("withRpcConnection requires a context created by makeTestContext");
+	return n(t);
+}, z = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), H = (e) => V.get(e) ?? [], U = /* @__PURE__ */ new WeakMap(), W = /* @__PURE__ */ new WeakMap(), G = (e) => W.get(e), K = (e, t, n) => {
+	U.set(e, {
+		publicApi: t,
+		...n === void 0 ? {} : { remoteAddr: n }
+	});
+}, q = (e) => U.get(e), J = /* @__PURE__ */ new WeakMap(), oe = (e, t) => {
+	let n = V.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 f(i);
+}, se = (e) => {
+	let t = (V.get(e) ?? []).map((e) => e.services).filter((e) => e !== void 0), n = J.get(e) ?? [], r = [...t, ...n];
+	if (r.length !== 0) return u.mergeAll(...r);
+}, ce = (e) => {
+	let t = z.get(e);
+	t !== void 0 && (t.length = 0);
+}, Y = async (e) => {
+	let t = z.get(e);
+	if (t === void 0 || t.length === 0) return;
+	let n = [...t];
+	t.length = 0;
+	for (let e of n) await e();
+}, X = (e) => B.get(e) ?? [], Z = async (e, t) => {
+	let n = I.get(e);
+	return n === void 0 ? e.store.transactional(async (n) => t({
+		...e,
+		store: n
+	})) : n(t);
+}, le = (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;
+	}, i = (r, i, a, o) => {
+		if (t.set(r, {
+			value: i,
+			expiresAt: a === void 0 ? null : e() + a
+		}), o) for (let e of o) {
+			let t = n.get(e) ?? /* @__PURE__ */ new Set();
+			t.add(r), n.set(e, t);
+		}
+	};
+	return {
+		get: async (e) => r(e) ? t.get(e).value : void 0,
+		set: async (e, t, n) => {
+			i(e, t, n?.ttlMs);
+		},
+		setWithTags: async (e, t, n) => {
+			i(e, t, n.ttlMs, n.tags);
+		},
+		remove: async (e) => t.delete(e),
+		has: async (e) => r(e),
+		clear: async () => {
+			t.clear(), n.clear();
+		},
+		invalidateTag: async (e) => {
+			let r = n.get(e);
+			if (r === void 0) return 0;
+			let i = 0;
+			for (let e of r) t.delete(e) && i++;
+			return n.delete(e), i;
+		},
+		wrap: async (e, n, a) => {
+			if (r(e)) return t.get(e).value;
+			let o = await a();
+			return i(e, o, n.ttlMs, n.tags), o;
+		}
+	};
+}, ue = (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;
+	};
+	return {
+		get: async (e) => n(e) ? t.get(e).value : void 0,
+		getOrElse: async (e, r) => n(e) ? t.get(e).value : r(),
+		set: async (n, r, i) => {
+			t.set(n, {
+				value: r,
+				expiresAt: i?.ttlMs === void 0 ? null : e() + i.ttlMs
+			});
+		},
+		delete: async (e) => {
+			let r = n(e);
+			return t.delete(e), r;
+		},
+		has: async (e) => n(e),
+		list: async (e) => {
+			let r = [];
+			for (let i of t.keys()) n(i) && (e === "" || i.startsWith(e)) && r.push(i);
+			return r;
+		},
+		clear: async () => {
+			t.clear();
+		}
+	};
+}, de = async (e, t) => {
+	let n = b();
+	M(e);
+	try {
+		return await t();
+	} finally {
+		n === void 0 ? v() : M(n);
+	}
+}, Q = /* @__PURE__ */ new Set(), fe = (e) => {
+	Q.has(e) || (Q.add(e), console.warn(e));
+}, pe = (e, t, n) => {
+	let r = me, i;
+	return () => {
+		let a = t ?? y();
+		return t !== void 0 && y() !== void 0 && t !== y() && fe("[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 = de(n, () => A(O(a, e, (e) => {
+			console.error("[voltro:testing] row filter failed to load — reads refused for this subject", e);
+		})))), i;
+	};
+}, me = Symbol("unresolved"), $ = (e, t) => new Proxy(e, { get: (e, n) => {
+	if (n === "query") return async (n) => e.query(_(await t(), n));
+	let r = Reflect.get(e, n, e);
+	return typeof r == "function" ? r.bind(e) : r;
+} }), he = (u = {}) => {
+	if (re({
+		...process.env,
+		...u.env ?? {}
+	}), u.fieldEncryptionKey !== void 0 && u.fieldKeys !== void 0) throw Error("makeTestContext: pass `fieldEncryptionKey` or `fieldKeys`, not both — one is a keyring of one key");
+	if (u.fieldEncryptionKey !== void 0 && j(C(u.fieldEncryptionKey)), u.fieldKeys !== void 0 && n(u.fieldKeys), u.relations !== void 0) {
+		s();
+		for (let e of u.relations) c(e);
+	}
+	let f = u.tables ?? o(), _ = T(f), v = new m(u.store ?? {});
+	for (let e of u.plugins ?? []) e.bindDataStore?.(v);
+	let y = {
+		dataStore: v,
+		schemaRegistry: _
+	};
+	M(y);
+	let b = new e(u.clockStart);
+	x();
+	let O = l.runSync(ie.make.pipe(l.provide(ae({ now: () => b.now() }))));
+	v.onChange((e) => {
+		l.runSync(O.invalidateTag(e.table).pipe(l.ignore));
+	});
+	let A = [], P = {
+		wrapDynamic: (e, t, n, r) => O.wrapDynamic(e, t, n, r),
+		policyFor: E,
+		codeIdentity: "test",
+		maxEntryBytes: 1048576,
+		notice: (e, t, n) => {
+			A.push(n);
+		}
+	}, R = new r(), H = i(), U = new a(u.llmResponses ?? []), G = le(() => b.now()), K = ue(() => b.now()), q = (e, n, r = v, i, a = !1) => {
+		let o = {
+			subject: e,
+			traceId: F,
+			...n === void 0 ? {} : { connection: n }
+		}, s = i?.queued ?? [], c = i?.nudges ?? [], l = ne({
+			bus: H.bus,
+			tenantId: e.tenantId ?? null,
+			...r === v ? {} : { deferToCommit: (e) => {
+				s.push(async () => {
+					e();
+				});
+			} }
+		}), d = te({ store: r }), f = a ? async () => h : pe(e, u.rowFilter, y), m = {
+			apis: u.apis ?? Object.freeze({}),
+			transaction: async (t, i) => {
+				let o = k(e, i?.tenantId, r !== v);
+				if (o !== e) return q(o, n, v, void 0, !0).transaction(t);
+				if (r !== v) return t(m);
+				let s, l = await r.transactional(async (r) => {
+					let i = q(e, n, r, {
+						queued: [],
+						nudges: []
+					}, a), o = await t(i);
+					return s = i, o;
+				});
+				return s !== void 0 && (await Y(s), c.push(...X(s))), l;
+			},
+			clock: b,
+			webhooks: R,
+			events: l,
+			eventBus: H,
+			llm: U,
+			...u.ai === void 0 ? {} : { ai: u.ai },
+			request: o,
+			...n === void 0 ? {} : { connectionState: ee(n, r === v ? void 0 : (e) => {
+				s.push(e);
+			}) },
+			validation: g,
+			access: S(e),
+			cache: G,
+			kv: K,
+			store: N(D($(r, f)), {
+				subject: e,
+				schemaRegistry: _,
+				rowFilter: h
+			}),
+			storeForTenant: (t) => N($(r, f), {
+				subject: p(e, t),
+				schemaRegistry: _,
+				rowFilter: h
+			}),
+			outbox: w({
+				store: r,
+				subject: e,
+				traceId: F,
+				nudge: () => {
+					c.push(F);
+				},
+				afterCommit: (e) => {
+					s.push(e);
+				}
+			}),
+			load: d.load,
+			loadMany: d.loadMany,
+			withSubject: (e, t) => Promise.resolve(t(q(e, n, r, {
+				queued: s,
+				nudges: c
+			}))),
+			withTenant: (t, i) => Promise.resolve(i(q({
+				...e,
+				tenantId: t
+			}, n, r, {
+				queued: s,
+				nudges: c
+			}))),
+			asSubject: (e) => q(e, n, r, {
+				queued: s,
+				nudges: c
+			}),
+			asTenant: (t) => q({
+				...e,
+				tenantId: t
+			}, n, r, {
+				queued: s,
+				nudges: c
+			})
+		};
+		return z.set(m, s), L.set(m, (t) => q(e, t, r, {
+			queued: s,
+			nudges: c
+		})), B.set(m, c), V.set(m, u.plugins ?? []), J.set(m, u.layers ?? []), W.set(m, {
+			deps: P,
+			rowFilter: async () => u.rowFilter === void 0 ? void 0 : f(),
+			notices: A
+		}), I.set(m, (t) => r.transactional((r) => t(q(e, n, r, {
+			queued: s,
+			nudges: c
+		})))), t(m, v), m;
+	};
+	return q(u.subject ?? d(null), u.connection);
+};
+//#endregion
+export { he as makeTestContext, K as markRestInvocation, P as mockStore, X as outboxNudgesOf, H as pluginsOf, G as queryCacheOf, ce as resetAfterCommit, q as restInvocationOf, oe as rpcInterceptorFor, Y as runAfterCommit, Z as runInStoreTransaction, se as serviceLayerFor, R as withRpcConnection };

package/dist/testEventBus.js

@@ -0,0 +1,73 @@
+import { Effect as e, Result as t } from "effect";
+import { eventRoute as n } from "@voltro/protocol";
+import { EventBus as r, publishEvent as i } from "@voltro/runtime";
+//#region src/testEventBus.ts
+var a = (a = {}) => {
+	let o = a.tenantId ?? null, s = new r({
+		origin: a.origin ?? "test",
+		...a.ringSize === void 0 ? {} : { ringSize: a.ringSize }
+	});
+	return {
+		publish: async (n, r, a) => {
+			let c = await e.runPromise(e.result(i({
+				bus: s,
+				tenantId: o
+			}, n, r, a)));
+			if (t.isFailure(c)) {
+				let e = c.failure;
+				throw Error(`testEventBus.publish(${n.name}) was rejected: ${e._tag}`, { cause: e });
+			}
+			return { n: c.success.n };
+		},
+		subscribe: (e, t, n) => {
+			let r = [], i = [];
+			return {
+				get received() {
+					return r.map((e) => e.payload);
+				},
+				get deliveries() {
+					return r;
+				},
+				get missed() {
+					return i;
+				},
+				get missedCount() {
+					return i.reduce((e, t) => e + t.count, 0);
+				},
+				stop: s.subscribe({
+					tenantId: n?.tenantId ?? o,
+					event: e.name,
+					key: t,
+					listener: (e) => {
+						e.kind === "gap" ? i.push({
+							count: e.missed,
+							reason: e.reason
+						}) : r.push({
+							payload: e.envelope.payload,
+							origin: e.envelope.origin,
+							n: e.envelope.n
+						});
+					},
+					...n?.resume === void 0 ? {} : { options: { resume: n.resume } }
+				})
+			};
+		},
+		skipSerials: (e, t, r, i) => {
+			let a = i?.tenantId ?? o, c = {
+				route: n(a, e.name, t),
+				event: e.name,
+				origin: "test-gap",
+				n: r + 1,
+				emittedAt: Date.now(),
+				payload: void 0
+			};
+			s.injectRemote(c);
+		},
+		bus: s,
+		reset: () => {
+			s.clear();
+		}
+	};
+};
+//#endregion
+export { a as testEventBus };

package/dist/testRequest.js

@@ -0,0 +1,121 @@
+import { markRestInvocation as e, pluginsOf as t } from "./testContext.js";
+import { invoke as n } from "./invoke.js";
+import { Effect as r } from "effect";
+import { composeAuthStrategies as i, composeReplayAuthorityBindings as a } from "@voltro/protocol";
+import { resolveRequestClientAddress as o, resolveTrustedProxies as s } from "@voltro/runtime";
+import { collectPublicApiRoutes as c, dispatchSharedPath as l, restRoutesToHttpRoutes as u } from "@voltro/protocol/rest";
+//#region src/testRequest.ts
+var d = "127.0.0.1", f = (e) => {
+	let t = e.indexOf("?");
+	return t === -1 ? {
+		path: e,
+		query: ""
+	} : {
+		path: e.slice(0, t),
+		query: e.slice(t + 1)
+	};
+}, p = (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]);
+}, m = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e)) t[n.toLowerCase()] = r;
+	return t;
+}, h = (e) => e === void 0 ? /* @__PURE__ */ new Uint8Array() : new TextEncoder().encode(JSON.stringify(e)), g = (e) => e === void 0 ? "" : typeof e == "string" ? e : new TextDecoder().decode(e), _ = (_) => {
+	let v = s(_.security?.trustedProxies, process.env, _.security?.clientAddressHeader), { ctx: y } = _, b = c((_.publicApi ?? []).map((t) => ({
+		descriptor: t.descriptor,
+		invoke: (r, i) => y.withSubject(i.subject, (a) => (t.descriptor.publicApi !== void 0 && e(a, t.descriptor.publicApi, i.remoteAddr), n(t.descriptor, t.handler, r, a)))
+	})), {
+		pluginErrors: t(y).flatMap((e) => e.errorSchemas ?? []),
+		..._.publicApiProfile === void 0 ? {} : { profile: _.publicApiProfile }
+	}), x = [..._.restRoutes ?? [], ...b], S = i(_.strategies ?? [], {
+		anonymous: _.anonymous ?? { headerOrTenant: "acme" },
+		getStore: () => y.store
+	}), C = (e, n) => {
+		let i = a(t(y)), s = {
+			store: y.store,
+			traceId: () => y.request.traceId,
+			...i === void 0 ? {} : { bindReplayAuthority: i },
+			...t(y).some((e) => e.restRateLimit !== void 0) ? { rateLimit: (e, n, i) => r.forEach(t(y), (t) => t.restRateLimit?.(e, n, i) ?? r.void, { discard: !0 }) } : {},
+			buildContext: (e) => y.asSubject(e),
+			resolveSubject: e === void 0 ? async (e) => (await S({
+				headers: e,
+				clientId: -1
+			})).subject : () => e,
+			..._.idempotency === void 0 ? {} : { idempotency: _.idempotency }
+		}, c = u(x, s).map((e, t) => ({
+			pattern: x[t].path,
+			route: e
+		})), b = async (e, t, r = {}) => {
+			let { path: i, query: a } = f(t), s = c.filter((e) => p(e.pattern, i)).map((e) => e.route);
+			if (s.length === 0) return {
+				status: 404,
+				headers: {},
+				text: "",
+				body: {
+					error: "No route mounted for this path",
+					mounted: x.map((e) => e.path)
+				},
+				stream: !1
+			};
+			let u = {
+				...m(n),
+				...m(r.headers ?? {})
+			}, _ = o({
+				socketAddress: r.remoteAddr ?? d,
+				headers: u,
+				config: v
+			}), b = {
+				method: e.toUpperCase(),
+				path: i,
+				query: a,
+				headers: u,
+				rawBody: h(r.body),
+				store: y.store,
+				..._ === void 0 ? {} : { remoteAddr: _ }
+			}, S = await l(s, b), C = {};
+			for (let [e, t] of Object.entries(S.headers ?? {})) C[e.toLowerCase()] = t;
+			S.contentType !== void 0 && (C["content-type"] = S.contentType);
+			let w = typeof S.body == "string" ? new TextEncoder().encode(S.body) : S.body ?? /* @__PURE__ */ new Uint8Array();
+			if (S.byteStream !== void 0) {
+				let e = S.byteStream.stream, t = typeof e == "function" ? e() : e;
+				w = new Uint8Array(await new Response(t).arrayBuffer());
+			}
+			let T = g(w), E = (S.contentType ?? "").includes("json");
+			return {
+				status: S.status,
+				headers: C,
+				text: T,
+				body: E && T !== "" ? JSON.parse(T) : void 0,
+				bytes: w,
+				stream: S.stream !== void 0 || S.byteStream !== void 0
+			};
+		};
+		return {
+			actingAs: (e) => C(e, n),
+			withHeaders: (t) => C(e, {
+				...n,
+				...t
+			}),
+			get: (e, t) => b("GET", e, t ?? {}),
+			delete: (e, t) => b("DELETE", e, t ?? {}),
+			post: (e, t, n) => b("POST", e, {
+				...n ?? {},
+				body: t
+			}),
+			put: (e, t, n) => b("PUT", e, {
+				...n ?? {},
+				body: t
+			}),
+			patch: (e, t, n) => b("PATCH", e, {
+				...n ?? {},
+				body: t
+			}),
+			request: (e, t, n) => b(e, t, n ?? {}),
+			paths: x.map((e) => e.path)
+		};
+	};
+	return C(void 0, {});
+};
+//#endregion
+export { _ as makeTestApp };

package/dist/withConnections.js

@@ -0,0 +1,26 @@
+import { Layer as e } from "effect";
+import { layerConfiguredConnections as t } from "@voltro/kv/connection";
+//#region src/withConnections.ts
+var n = (n, r = {}) => {
+	let i = r.connections ?? {}, a = { ...i.redis };
+	for (let [e, t] of Object.entries(n)) {
+		if (!/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(e)) throw Error("Connection test overrides require redis:name references");
+		let n = e.slice(6);
+		if (i.redis !== void 0 && !Object.hasOwn(i.redis, n)) throw Error("Connection test override must name a declared app entry");
+		if (t._tag !== "MemoryRedisConnection") throw Error("Connection test overrides require memory() entries");
+		a[n] = t;
+	}
+	let o = {
+		...i,
+		redis: a,
+		...i.nats === void 0 ? {} : { nats: { ...i.nats } },
+		...i.defaults === void 0 ? {} : { defaults: { ...i.defaults } },
+		...i.bindings === void 0 ? {} : { bindings: Object.fromEntries(Object.entries(i.bindings).map(([e, t]) => [e, { ...t }])) }
+	};
+	return t({
+		connections: o,
+		...r.connectAnalytics === void 0 ? {} : { connectAnalytics: r.connectAnalytics }
+	}).pipe(e.orDie);
+};
+//#endregion
+export { n as withConnections };

package/dist/workflowRunner.js

@@ -0,0 +1,85 @@
+import { Effect as e, Layer as t, Result as n } from "effect";
+import { getFieldCipher as r, makeEffectStoreLayer as i, makeFieldCipher as a } from "@voltro/runtime";
+import { randomBytes as o } from "node:crypto";
+import { CurrentWorkflowRunId as s, failureMessage as c, getWorkflowJournalCipher as l, inMemoryWorkflowEngineLayer as u, makeInMemoryRecorder as d, setWorkflowJournalCipher as f } from "@voltro/workflow";
+//#region src/workflowRunner.ts
+var p = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = t.get(n.stepName);
+		e === void 0 ? t.set(n.stepName, [n]) : e.push(n);
+	}
+	let n = [];
+	for (let [e, r] of t) {
+		r.sort((e, t) => e.attempt - t.attempt);
+		let t = r[r.length - 1], i = t.errorTag !== null || t.errorMessage !== null ? {
+			tag: t.errorTag,
+			message: t.errorMessage ?? ""
+		} : null;
+		n.push({
+			name: e,
+			attempt: t.attempt,
+			attempts: r.length,
+			status: t.status,
+			input: t.input,
+			output: t.output,
+			error: i,
+			durationMs: t.durationMs,
+			_startedAt: r[0].startedAt.getTime()
+		});
+	}
+	return n.sort((e, t) => e._startedAt - t._startedAt), n.map(({ _startedAt: e, ...t }) => t);
+}, m = () => {
+	if (l() !== void 0) return;
+	let e = a(o(32).toString("hex"));
+	f(() => r() ?? e);
+}, h = (r) => {
+	m();
+	let a = r.workflows ?? [], o = /* @__PURE__ */ new Map(), l = 0;
+	return {
+		start: async (f, m) => {
+			let h = a.find((e) => e.workflow.name === f);
+			if (h === void 0) throw Error(`makeWorkflowRunner: no workflow named '${f}' — pass it in makeWorkflowRunner({ ctx, workflows: [{ workflow, execute }] }).`);
+			let g = `wfrun_test_${++l}`, _ = d(), v = h.workflow.toLayer(h.execute).pipe(t.provideMerge(u)), y = /* @__PURE__ */ new Date(), b = h.workflow.execute(m).pipe(e.provideService(s, g), e.provide(_.layer), e.provide(v)), x = (r.ctx.store === void 0 ? b : e.provide(b, i(r.ctx.store))).pipe(e.result), S = await e.runPromise(x), C = p(_.readSteps()), w = /* @__PURE__ */ new Date(), T;
+			if (n.isSuccess(S)) T = {
+				status: "succeeded",
+				output: S.success,
+				error: null,
+				steps: C,
+				runId: g
+			};
+			else {
+				let e = S.failure;
+				T = {
+					status: "failed",
+					output: null,
+					error: {
+						tag: e && typeof e == "object" && "_tag" in e ? String(e._tag) : null,
+						message: c(S.failure)
+					},
+					steps: C,
+					runId: g
+				};
+			}
+			return o.set(g, {
+				id: g,
+				executionId: g,
+				name: f,
+				status: T.status,
+				input: m,
+				output: T.output,
+				subject: r.ctx.request.subject,
+				source: "test-runner",
+				steps: C,
+				startedAt: y,
+				finishedAt: w,
+				traceId: null,
+				parentExecutionId: null,
+				parentClosePolicy: null
+			}), T;
+		},
+		inspect: async (e) => o.get(e) ?? null
+	};
+};
+//#endregion
+export { h as makeWorkflowRunner };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/testing",
-  "version": "0.85.0",
+  "version": "0.87.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,6 +43,11 @@
       "import": "./dist/crdt.js",
       "default": "./dist/crdt.js"
     },
+    "./system": {
+      "types": "./dist/system.d.ts",
+      "import": "./dist/system.js",
+      "default": "./dist/system.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
@@ -53,16 +58,18 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.85.0",
-    "@voltro/env": "0.85.0",
-    "@voltro/local-first": "0.85.0",
-    "@voltro/logger": "0.85.0",
-    "@voltro/protocol": "0.85.0",
-    "@voltro/runtime": "0.85.0",
-    "@voltro/workflow": "0.85.0"
+    "@voltro/cache": "0.87.0",
+    "@voltro/database": "0.87.0",
+    "@voltro/env": "0.87.0",
+    "@voltro/kv": "0.87.0",
+    "@voltro/local-first": "0.87.0",
+    "@voltro/logger": "0.87.0",
+    "@voltro/protocol": "0.87.0",
+    "@voltro/runtime": "0.87.0",
+    "@voltro/workflow": "0.87.0"
   },
   "peerDependencies": {
-    "@voltro/client": "0.85.0",
+    "@voltro/client": "0.87.0",
     "effect": "4.0.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",