@voltro/testing 0.85.0 → 0.86.0

package/dist/invoke.js

@@ -0,0 +1,44 @@
+import { resetAfterCommit as e, restInvocationOf as t, rpcInterceptorFor as n, runAfterCommit as r, runInStoreTransaction as i, serviceLayerFor as a } from "./testContext.js";
+import { Cause as o, Effect as s, Exit as c, Schema as l } from "effect";
+import { SubjectService as u, checkGuardsEffect as d } from "@voltro/protocol";
+import { makeEffectStoreLayer as f, runProvidedEffect as p, runWithDeadlockRetry as m } from "@voltro/runtime";
+//#region src/invoke.ts
+var h = (e, t) => {
+	let n = a(t);
+	return (n === void 0 ? e : s.provide(e, n)).pipe(s.provide(f(t.store)), s.provideService(u, t.request.subject));
+}, g = async (a, u, f, g) => {
+	let _ = a.input, v = await l.decodeUnknownPromise(_)(f), y = a.kind, b = async (e) => {
+		let t = u(v, e);
+		return s.isEffect(t) ? p(h(t, e)) : t;
+	}, x = async () => {
+		let t = a.guards;
+		if (t !== void 0 && t.length > 0) {
+			let e = await s.runPromise(d(g.request.subject, t, v));
+			if (e !== null) throw e;
+		}
+		if (y !== "mutation") return b(g);
+		let n = await m(async () => i(g, async (t) => (e(g), b(t))), { delay: () => Promise.resolve() });
+		return await r(g), n;
+	}, S = y === "mutation" || y === "query" || y === "action" ? y : void 0, C = S === void 0 ? void 0 : n(g, S);
+	if (C === void 0 || S === void 0) return await x();
+	let w = s.tryPromise({
+		try: () => x(),
+		catch: (e) => e
+	}), T = t(g), E = C(w, {
+		tag: a.name ?? "",
+		kind: S,
+		input: v,
+		subject: g.request.subject,
+		traceId: g.request.traceId,
+		...g.request.spanId === void 0 ? {} : { spanId: g.request.spanId },
+		...T === void 0 ? {} : {
+			surface: "rest",
+			publicApi: T.publicApi
+		},
+		...T?.remoteAddr === void 0 ? {} : { remoteAddr: T.remoteAddr }
+	}), D = await s.runPromiseExit(E);
+	if (c.isSuccess(D)) return D.value;
+	throw o.squash(D.cause);
+};
+//#endregion
+export { g as invoke };

package/dist/mockClock.js

@@ -0,0 +1,78 @@
+import { Effect as e } from "effect";
+//#region src/mockClock.ts
+var t = Symbol.for("voltro/testing/mockClock.installed"), n = () => globalThis, r = (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)
+}), i = (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;
+}, a = class {
+	currentMs;
+	constructor(e = "2026-01-01T00:00:00Z") {
+		this.currentMs = i(e);
+	}
+	now() {
+		return this.currentMs;
+	}
+	date() {
+		return new Date(this.currentMs);
+	}
+	advance(e) {
+		this.currentMs += typeof e == "number" ? e : l(e);
+	}
+	set(e) {
+		this.currentMs = i(e);
+	}
+	get installed() {
+		return n()[t]?.clock === this;
+	}
+	install() {
+		let e = n(), i = e[t];
+		if (i !== void 0) throw Error("mockClock: global time is already faked" + (i.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 a = globalThis.Date;
+		return e[t] = {
+			realDate: a,
+			clock: this
+		}, globalThis.Date = r(a, () => this.currentMs), () => {
+			this.uninstall();
+		};
+	}
+	uninstall() {
+		let e = n(), r = e[t];
+		r !== void 0 && r.clock === this && (globalThis.Date = r.realDate, delete e[t]);
+	}
+}, o = (e) => typeof e == "object" && !!e && typeof e.then == "function", s = (e, t) => {
+	let n = e instanceof a ? e : new a(e);
+	n.install();
+	let r = !1;
+	try {
+		let e = t(n);
+		return o(e) ? (r = !0, e.then((e) => (n.uninstall(), e), (e) => {
+			throw n.uninstall(), e;
+		})) : e;
+	} finally {
+		r || n.uninstall();
+	}
+}, c = (t) => e.acquireRelease(e.sync(() => {
+	let e = t instanceof a ? t : new a(t);
+	return e.install(), e;
+}), (t) => e.sync(() => {
+	t.uninstall();
+})), l = (e) => {
+	let t = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)\s*$/.exec(e);
+	if (!t) throw Error(`mockClock: cannot parse duration '${e}'`);
+	let n = Number(t[1]), r = t[2];
+	switch (r) {
+		case "ms": return n;
+		case "s": return n * 1e3;
+		case "m": return n * 6e4;
+		case "h": return n * 36e5;
+		case "d": return n * 864e5;
+		default: throw Error(`mockClock: unknown unit '${r}'`);
+	}
+};
+//#endregion
+export { a as MockClock, c as frozenTime, s as withFrozenTime };

package/dist/mockLLM.js

@@ -0,0 +1,19 @@
+//#region src/mockLLM.ts
+var e = class {
+	queue;
+	calls = [];
+	constructor(e) {
+		this.queue = [...e];
+	}
+	next(e) {
+		this.calls.push(e);
+		let t = this.queue.shift();
+		if (!t) throw Error("MockLLM: no more responses queued");
+		return t;
+	}
+	remaining() {
+		return this.queue.length;
+	}
+};
+//#endregion
+export { e as MockLLM };

package/dist/mockWebhooks.js

@@ -0,0 +1,26 @@
+//#region src/mockWebhooks.ts
+var e = class {
+	emitted = [];
+	async emit(e, t) {
+		let n = typeof e == "string" ? e : e.name ?? e.id ?? e.event ?? "(unnamed event)";
+		return this.emitted.push({
+			event: n,
+			payload: t,
+			emittedAt: /* @__PURE__ */ new Date()
+		}), { delivered: 0 };
+	}
+	async listTargets(e, t) {
+		return [];
+	}
+	payloadsFor(e) {
+		return this.emitted.filter((t) => t.event === e).map((e) => e.payload);
+	}
+	last(e) {
+		for (let t = this.emitted.length - 1; t >= 0; t--) if (this.emitted[t].event === e) return this.emitted[t];
+	}
+	clear() {
+		this.emitted.length = 0;
+	}
+};
+//#endregion
+export { e as MockWebhooks };

package/dist/platform.js

@@ -10,11 +10,7 @@ var r = (r, i) => {
 			t(Number.isFinite(e.clock.now())).toBe(!0);
 		}), n("storage: the local area is a synchronous store that reads back what it wrote", async () => {
 			let e = await o(), n = e.storage("local");
-			if (n === null) {
-				t(e.storage("session")).toBeNull();
-				return;
-			}
-			n.setItem(a, "v1"), t(n.getItem(a)).toBe("v1"), n.removeItem?.(a);
+			n === null ? t(e.storage("session")).toBeNull() : (n.setItem(a, "v1"), t(n.getItem(a)).toBe("v1"), n.removeItem?.(a));
 		}), n("secureStorage: honours its declared kind", async () => {
 			let e = await o();
 			e.capabilities.secureTokenStorage ? (t(e.secureStorage.kind).not.toBe("none"), await e.secureStorage.set(a, "secret"), t(await e.secureStorage.get(a)).toBe("secret"), await e.secureStorage.delete(a), t(await e.secureStorage.get(a)).toBeNull()) : (t(e.secureStorage.kind).toBe("none"), t(await e.secureStorage.get(a)).toBeNull(), await t(e.secureStorage.set(a, "secret")).rejects.toThrow());

package/dist/reachable.js

@@ -0,0 +1,27 @@
+import e from "node:net";
+import { describe as t } from "vitest";
+//#region src/reachable.ts
+var n = (t) => new Promise((n) => {
+	let r = new e.Socket(), i = (e) => {
+		clearTimeout(a), r.destroy(), n(e);
+	}, a = setTimeout(() => i(!1), t.timeoutMs ?? 750);
+	r.once("connect", () => i(!0)), r.once("error", () => i(!1)), r.connect(t.port, t.host);
+}), r = async (e, n, r, i) => {
+	if (typeof n != "string" || typeof r != "function" || typeof i != "function") throw TypeError(`describeIfAvailable('${e}', ...): expected (label, dependency, probe, suite) — got dependency: ${typeof n}, probe: ${typeof r}, suite: ${typeof i}. Three arguments means the suite body is being used as the probe: it would run at file scope, unconditionally, and the skip would silently do nothing.`);
+	let a = !1;
+	try {
+		a = await r();
+	} catch {
+		a = !1;
+	}
+	t.skipIf(!a)(a ? e : `${e} [SKIPPED: needs ${n}]`, i);
+}, i = async (e, t, i) => {
+	await r(e, `${t.name} at ${t.host}:${t.port}`, () => n(t), i);
+}, a = async (e, t) => {
+	try {
+		let n = await t();
+		n !== void 0 && n !== "" && console.log(`[engine] ${e}: ${n}`);
+	} catch {}
+};
+//#endregion
+export { r as describeIfAvailable, i as describeIfReachable, n as isTcpReachable, a as reportEngineVersion };

package/dist/serviceApiMock.js

@@ -0,0 +1,53 @@
+import { Effect as e, Schema as t } from "effect";
+import { ApiUnavailable as n } from "@voltro/protocol";
+//#region src/serviceApiMock.ts
+var r = (r, i, a = {}) => {
+	let o = a.name ?? "mock", s = [], c = /* @__PURE__ */ new Map(), l = (e, t) => `${e}\u0000${JSON.stringify(t)}`, u = async (e, a, c) => {
+		let l = r[e];
+		if (l === void 0) throw Error(`makeServiceApiMock: '${e}' is not a service procedure of this api`);
+		let u = l.input, d = t.encodeUnknownSync(u)(a), f = t.decodeUnknownSync(u)(d);
+		s.push({
+			tag: e,
+			input: f,
+			idempotencyKey: c?.idempotencyKey
+		});
+		let p = i[e];
+		if (p === void 0) throw new n({
+			api: o,
+			tag: e,
+			reason: "transport",
+			message: "no handler in makeServiceApiMock"
+		});
+		let m = await p(f), h = l.output;
+		return t.decodeUnknownSync(h)(t.encodeUnknownSync(h)(m));
+	}, d = (t) => {
+		let n = t.join("."), r = Object.assign((e, t) => u(n, e, t), {
+			effect: (t, r) => e.tryPromise({
+				try: () => u(n, t, r),
+				catch: (e) => e
+			}),
+			subscribe: (e, t) => {
+				let r = l(n, e), i = c.get(r) ?? /* @__PURE__ */ new Set();
+				return c.set(r, i), i.add(t.onValue), u(n, e).then(t.onValue, (e) => t.onError?.(e)), { unsubscribe: () => {
+					i.delete(t.onValue);
+				} };
+			}
+		});
+		return new Proxy(r, { get: (e, n) => {
+			if (typeof n == "string") {
+				if (n === "effect" || n === "subscribe") return e[n];
+				if (n !== "then") return d([...t, n]);
+			}
+		} });
+	};
+	return {
+		api: new Proxy({}, { get: (e, t) => typeof t == "string" && t !== "then" ? d([t]) : void 0 }),
+		calls: (e) => e === void 0 ? [...s] : s.filter((t) => t.tag === e),
+		emit: (e, n, i) => {
+			let a = r[e], o = a === void 0 ? i : t.decodeUnknownSync(a.output)(t.encodeUnknownSync(a.output)(i));
+			for (let t of c.get(l(e, n)) ?? []) t(o);
+		}
+	};
+};
+//#endregion
+export { r as makeServiceApiMock };

package/dist/subject.js

@@ -0,0 +1,11 @@
+import { anonymousSubject as e, systemSubject as t } from "@voltro/protocol";
+//#region src/subject.ts
+var n = "test-tenant", r = (e, t, n) => ({
+	type: e,
+	id: t,
+	tenantId: n.tenantId ?? "test-tenant",
+	scopes: n.scopes ?? [],
+	...n.metadata === void 0 ? {} : { metadata: n.metadata }
+}), i = (e, t = {}) => r("user", e, t), a = (e, t = {}) => r("apiKey", e, t), o = (e, t = {}) => r("serviceAccount", e, t), s = (t = null) => e(t), c = (e = "job:test", n) => n === void 0 ? t(e) : t(e, n);
+//#endregion
+export { n as TEST_TENANT_ID, s as anonymous, a as apiKey, o as serviceAccount, c as system, i as user };

package/dist/subscribeContext.js

@@ -0,0 +1,16 @@
+import { changeDelete as e, changeInsert as t, changeSoftDelete as n, changeUpdate as r } from "@voltro/database";
+import { createLogger as i } from "@voltro/logger";
+//#region src/subscribeContext.ts
+var a = (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.`);
+	} });
+	return {
+		id: t,
+		log: e.log ?? i({ scope: `subscribe:${t}` }),
+		store: n,
+		...e.publish === void 0 ? {} : { publish: e.publish }
+	};
+};
+//#endregion
+export { e as changeDelete, t as changeInsert, n as changeSoftDelete, r as changeUpdate, a as makeSubscribeContext };

package/dist/testApps.js

@@ -0,0 +1,111 @@
+import { apiBindingTokenEnv as e, apiBindingUrlEnv as t, mintServiceToken as n, serviceCallerTokenEnv as r } from "@voltro/runtime";
+import i from "node:net";
+import { randomBytes as a } from "node:crypto";
+import { spawn as o } from "node:child_process";
+import { createRequire as s } from "node:module";
+import { dirname as c, join as l } from "node:path";
+//#region src/testApps.ts
+var u = () => new Promise((e, t) => {
+	let n = i.createServer();
+	n.once("error", t), n.listen(0, "127.0.0.1", () => {
+		let t = n.address(), r = typeof t == "object" && t ? t.port : 0;
+		n.close(() => e(r));
+	});
+}), d = async (e) => {
+	try {
+		return (await fetch(`http://127.0.0.1:${e}/internal/readiness`)).status === 200;
+	} catch {
+		return !1;
+	}
+}, f = (e) => l(c(s(l(e, "package.json")).resolve("@voltro/cli/package.json")), "bin", "voltro.mjs"), p = 1e4, m = (e) => new Promise((t) => {
+	if (e.exitCode !== null || e.signalCode !== null) return t();
+	let n = setTimeout(() => {
+		e.kill("SIGKILL");
+	}, p);
+	e.once("exit", () => {
+		clearTimeout(n), t();
+	}), e.kill("SIGTERM");
+}), h = async (i) => {
+	let s = Object.keys(i.apps);
+	if (s.length === 0) throw Error("startTestApps: no apps given");
+	let c = i.mode ?? "dev", l = i.bootTimeoutMs ?? 3e5, p = i.cli ?? f(i.apps[s[0]].root), h = /* @__PURE__ */ new Map();
+	for (let e of s) h.set(e, await u());
+	let g = /* @__PURE__ */ new Map(), _ = new Map(s.map((e) => [e, {}]));
+	for (let a of i.edges ?? []) {
+		for (let e of [a.caller, a.callee]) if (!s.includes(e)) throw Error(`startTestApps: edge names '${e}', which is not among the apps (${s.join(", ")})`);
+		let i = n();
+		g.set(`${a.caller}\u0000${a.callee}`, i), Object.assign(_.get(a.caller), {
+			[e(a.binding)]: i,
+			[t(a.binding)]: `ws://127.0.0.1:${h.get(a.callee)}/ws`
+		}), Object.assign(_.get(a.callee), { [r(a.caller)]: i });
+	}
+	let v = [], y = /* @__PURE__ */ new Set(), b = (e) => {
+		if (!v.includes(e)) {
+			if (y.has(e)) throw Error(`startTestApps: the edges form a cycle through '${e}' — no app can boot first`);
+			y.add(e);
+			for (let t of i.edges ?? []) t.caller === e && b(t.callee);
+			y.delete(e), v.push(e);
+		}
+	};
+	for (let e of s) b(e);
+	let x = [], S = /* @__PURE__ */ new Map(), C = async () => {
+		await Promise.all(x.map(m));
+	};
+	for (let e of v) {
+		let t = i.apps[e], n = h.get(e), r = "", s = o(process.execPath, [
+			p,
+			c,
+			...c === "serve" ? ["."] : []
+		], {
+			cwd: t.root,
+			env: {
+				...process.env,
+				...c === "serve" ? { VOLTRO_SESSION_SECRET: a(32).toString("base64url") } : {},
+				...t.env,
+				..._.get(e),
+				PORT: String(n)
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		x.push(s), s.stdout?.on("data", (e) => {
+			r += e.toString();
+		}), s.stderr?.on("data", (e) => {
+			r += e.toString();
+		}), s.on("exit", (e, t) => {
+			r += `\n[exited] code=${String(e)} signal=${String(t)}`;
+		});
+		let u = {
+			name: e,
+			port: n,
+			url: `http://127.0.0.1:${n}`,
+			wsUrl: `ws://127.0.0.1:${n}/ws`,
+			log: () => r,
+			stop: () => m(s)
+		};
+		S.set(e, u);
+		let f = Date.now() + l;
+		for (; !await d(n);) {
+			if (s.exitCode !== null || s.signalCode !== null || Date.now() > f) {
+				await C();
+				let t = s.exitCode !== null || s.signalCode !== null ? "exited before it was ready" : `was not ready within ${l} ms`;
+				throw Error(`startTestApps: '${e}' ${t}\n${u.log().slice(-4e3)}`);
+			}
+			await new Promise((e) => setTimeout(e, 250));
+		}
+	}
+	return {
+		apps: Object.fromEntries(S),
+		token: (e, t) => {
+			let n = g.get(`${e}\u0000${t}`);
+			if (n === void 0) throw Error(`startTestApps: no edge ${e} → ${t}`);
+			return n;
+		},
+		stop: C
+	};
+};
+//#endregion
+export { h as startTestApps };

package/dist/testContext.js

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