@voltro/testing 0.86.0 → 0.88.0

package/dist/mockClock.js

@@ -1,5 +1,5 @@
 import { Effect as e } from "effect";
-//#region src/mockClock.ts
+// 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(),
@@ -74,5 +74,4 @@ var t = Symbol.for("voltro/testing/mockClock.installed"), n = () => globalThis,
 		default: throw Error(`mockClock: unknown unit '${r}'`);
 	}
 };
-//#endregion
 export { a as MockClock, c as frozenTime, s as withFrozenTime };

package/dist/mockLLM.js

@@ -1,4 +1,4 @@
-//#region src/mockLLM.ts
+// src/mockLLM.ts
 var e = class {
 	queue;
 	calls = [];
@@ -15,5 +15,4 @@ var e = class {
 		return this.queue.length;
 	}
 };
-//#endregion
 export { e as MockLLM };

package/dist/mockWebhooks.js

@@ -1,4 +1,4 @@
-//#region src/mockWebhooks.ts
+// src/mockWebhooks.ts
 var e = class {
 	emitted = [];
 	async emit(e, t) {
@@ -22,5 +22,4 @@ var e = class {
 		this.emitted.length = 0;
 	}
 };
-//#endregion
 export { e as MockWebhooks };

package/dist/platform.js

@@ -1,5 +1,5 @@
 import { describe as e, expect as t, it as n } from "vitest";
-//#region src/platformConformance.ts
+// src/platformConformance.ts
 var r = (r, i) => {
 	let a = i.scratchKey ?? "voltro:conformance", o = async () => i.adapter();
 	e(`platform adapter conformance — ${r}`, () => {
@@ -38,5 +38,4 @@ var r = (r, i) => {
 		});
 	});
 };
-//#endregion
 export { r as platformAdapterConformance };

package/dist/reachable.js

@@ -1,6 +1,6 @@
 import e from "node:net";
 import { describe as t } from "vitest";
-//#region src/reachable.ts
+// src/reachable.ts
 var n = (t) => new Promise((n) => {
 	let r = new e.Socket(), i = (e) => {
 		clearTimeout(a), r.destroy(), n(e);
@@ -23,5 +23,4 @@ var n = (t) => new Promise((n) => {
 		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

@@ -1,6 +1,6 @@
 import { Effect as e, Schema as t } from "effect";
 import { ApiUnavailable as n } from "@voltro/protocol";
-//#region src/serviceApiMock.ts
+// 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];
@@ -49,5 +49,4 @@ var r = (r, i, a = {}) => {
 		}
 	};
 };
-//#endregion
 export { r as makeServiceApiMock };

package/dist/subject.js

@@ -1,5 +1,5 @@
 import { anonymousSubject as e, systemSubject as t } from "@voltro/protocol";
-//#region src/subject.ts
+// src/subject.ts
 var n = "test-tenant", r = (e, t, n) => ({
 	type: e,
 	id: t,
@@ -7,5 +7,4 @@ var n = "test-tenant", r = (e, t, n) => ({
 	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

@@ -1,6 +1,6 @@
 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
+// 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.`);
@@ -12,5 +12,4 @@ var a = (e = {}) => {
 		...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/system.d.ts

@@ -0,0 +1,99 @@
+import { AnyEventDescriptor } from '@voltro/protocol';
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { PluginInspectRequest } from '@voltro/protocol';
+import { PluginInspectResponse } from '@voltro/protocol';
+import { PluginPrivacyRequest } from '@voltro/protocol';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { VoltroPlugin } from '@voltro/protocol';
+
+/**
+ * Register the system contract against real exports and descriptor surfaces.
+ * Refuses incomplete inventories before registering any tests. This suite does
+ * not establish SQL parity, ordinary boot, four dashboard layers or capacity.
+ */
+export declare const systemContractConformance: (plugin: VoltroPlugin, options: SystemContractConformanceOptions) => void;
+
+export declare interface SystemContractConformanceOptions {
+    readonly manifest: SystemContractManifest;
+    /** Actual module namespace imports, never copies of the system exports. */
+    readonly strategies: Readonly<Record<string, unknown>>;
+    readonly ports: Readonly<Record<string, unknown>>;
+    readonly testing: Readonly<Record<string, unknown>>;
+    /** Actual descriptors used by discovery/codegen. Hidden events are not inferred. */
+    readonly eventCatalog: ReadonlyArray<AnyEventDescriptor>;
+    readonly eventFixtures: Readonly<Record<string, SystemEventFixture>>;
+    readonly stages: Readonly<Record<'take' | 'configure' | 'hook' | 'override' | 'extendOrReplace', SystemContractProbe>>;
+    readonly privacy: Readonly<Record<string, (kind: PluginPrivacyTarget['kind']) => Effect.Effect<SystemPrivacyFixture, unknown>>>;
+    /** Exactly one case per contributed endpoint, keyed as "GET path". */
+    readonly inspect: Readonly<Record<string, SystemInspectFixture>>;
+}
+
+/** Export this inventory beside the system's public strategies and ports. */
+export declare interface SystemContractManifest {
+    readonly slots: Readonly<Record<string, {
+        readonly defaultExport: string;
+        readonly fixtureExport: string;
+    }>>;
+    readonly ports: Readonly<Record<string, {
+        readonly tagExport: string;
+        readonly fakeLayerExport: string;
+        readonly fixtureExport: string;
+    }>>;
+    readonly events: ReadonlyArray<string>;
+}
+
+/** A measured observation. Use inputs that distinguish defaults from overrides. */
+export declare interface SystemContractProbe {
+    readonly run: () => Effect.Effect<unknown, unknown>;
+    readonly expected: unknown;
+}
+
+export declare interface SystemEventFixture {
+    readonly descriptor: AnyEventDescriptor;
+    readonly key: unknown;
+    readonly payload: unknown;
+}
+
+export declare interface SystemInspectFixture {
+    readonly request: PluginInspectRequest;
+    readonly expected: PluginInspectResponse;
+}
+
+export declare interface SystemPortFixture {
+    readonly kind: 'port';
+    readonly tag: unknown;
+    readonly fakeLayer: unknown;
+    readonly probe: SystemContractProbe;
+}
+
+/** Preserve concrete Tag/Layer types; the suite owns scope acquisition and cleanup. */
+export declare const systemPortFixture: <Identifier, Service>(options: {
+    readonly tag: Context.Service<Identifier, Service>;
+    readonly fakeLayer: Layer.Layer<Identifier>;
+    readonly read: Effect.Effect<unknown, unknown, Identifier>;
+    readonly expected: unknown;
+}) => SystemPortFixture;
+
+/** A fresh, seeded fixture; read() must include peer/tenant rows that must survive. */
+export declare interface SystemPrivacyFixture {
+    /** Explicitly reviewed tenant-wide table without subject facts; erase retains every row. */
+    readonly subjectData?: 'none';
+    readonly request: PluginPrivacyRequest;
+    readonly read: () => Effect.Effect<ReadonlyArray<unknown>, unknown>;
+    readonly before: ReadonlyArray<unknown>;
+    readonly after: ReadonlyArray<unknown>;
+    readonly exported: unknown;
+    readonly close: Effect.Effect<void>;
+}
+
+/** A ./testing export that exercises the imported default and configured override. */
+export declare interface SystemSlotFixture {
+    readonly kind: 'slot';
+    readonly defaultImplementation: unknown;
+    readonly defaultProbe: SystemContractProbe;
+    readonly overrideProbe: SystemContractProbe;
+}
+
+export { }

package/dist/system.js

@@ -0,0 +1,93 @@
+import { testEventBus as e } from "./testEventBus.js";
+import { Context as t, Effect as n, Layer as r } from "effect";
+import { createPluginPrivacyRegistry as i } from "@voltro/protocol";
+import { describe as a, expect as o, it as s } from "vitest";
+// src/systemContractConformance.ts
+var c = (e) => ({
+	kind: "port",
+	tag: e.tag,
+	fakeLayer: e.fakeLayer,
+	probe: {
+		run: () => n.scoped(e.read.pipe(n.provide(e.fakeLayer))),
+		expected: e.expected
+	}
+}), l = (e, t) => {
+	if (e.some((e) => !e.trim()) || new Set(e).size !== e.length) throw Error(`Invalid system ${t} inventory`);
+}, u = (e, t, n) => {
+	if (l(e, n), l(t, n), JSON.stringify([...e].sort()) !== JSON.stringify([...t].sort())) throw Error(`Incomplete system ${n} fixtures`);
+}, d = (e) => typeof e == "object" && !!e, f = (e) => d(e) && typeof e.run == "function" && e.expected !== void 0, p = (e) => d(e) && e.kind === "slot" && typeof e.defaultImplementation == "function" && f(e.defaultProbe) && f(e.overrideProbe), m = (e) => d(e) && e.kind === "port" && t.isKey(e.tag) && r.isLayer(e.fakeLayer) && f(e.probe), h = (e, t) => `${e} ${t.replace(/^\//, "")}`, g = (t, r) => {
+	let { manifest: c } = r, g = t.services !== void 0 || (t.routes?.length ?? 0) > 0 || (t.extendSchema?.tables?.length ?? 0) > 0 || (t.inspectEndpoints?.length ?? 0) > 0 || t.onActivate !== void 0 || t.interceptMutation !== void 0;
+	if (!t.name.trim() || !g || Object.keys(c.slots).length === 0) throw Error("System conformance requires an implemented system with strategy slots");
+	let _ = (t.extendSchema?.tables ?? []).map((e) => {
+		if (!d(e) || typeof e.tableName != "string") throw Error("System conformance requires named table descriptors");
+		return e.tableName;
+	});
+	u(Object.keys(r.stages), [
+		"take",
+		"configure",
+		"hook",
+		"override",
+		"extendOrReplace"
+	], "stages");
+	for (let e of Object.values(r.stages)) if (!f(e)) throw Error("System stages require measured probes");
+	u(Object.keys(r.privacy), _, "privacy"), u(r.eventCatalog.map((e) => e.name), c.events, "events"), u(Object.keys(r.eventFixtures), c.events, "events");
+	let v = t.inspectEndpoints ?? [];
+	u(Object.keys(r.inspect), v.map((e) => h(e.method, e.path)), "inspect");
+	let y = Object.entries(c.slots).map(([e, t]) => {
+		l([e], "slots");
+		let n = r.strategies[t.defaultExport], i = r.testing[t.fixtureExport];
+		if (typeof n != "function" || !p(i) || i.defaultImplementation !== n) throw Error(`System slot requires its actual default export and fixture: ${e}`);
+		return {
+			name: e,
+			fixture: i
+		};
+	}), b = Object.entries(c.ports).map(([e, t]) => {
+		l([e], "ports");
+		let n = r.testing[t.fixtureExport];
+		if (!m(n) || n.tag !== r.ports[t.tagExport] || n.fakeLayer !== r.testing[t.fakeLayerExport]) throw Error(`System port requires its actual Tag, fake Layer and fixture: ${e}`);
+		return {
+			name: e,
+			fixture: n
+		};
+	});
+	for (let e of r.eventCatalog) if (e.kind !== "event" || r.eventFixtures[e.name]?.descriptor !== e) throw Error(`System event requires its actual catalog descriptor: ${e.name}`);
+	for (let e of v) {
+		let t = r.inspect[h(e.method, e.path)];
+		if (t.request.method !== e.method || t.expected.kind !== "json" || (t.expected.status ?? 200) !== 200 || t.expected.data === void 0) throw Error("System inspect fixture must observe successful JSON");
+	}
+	let x = i([t]);
+	if (_.length > 0 && (!t.subjectPrivacy || x.coverage("user").missing.length > 0 || x.coverage("guest").missing.length > 0 || !t.subjectPrivacy.kinds.includes("user") || !t.subjectPrivacy.kinds.includes("guest"))) throw Error("System tables require user and guest erase/export coverage");
+	let S = async (e) => {
+		o(await n.runPromise(n.suspend(e.run))).toEqual(e.expected);
+	};
+	a(`system contract — ${t.name}`, () => {
+		for (let [e, t] of Object.entries(r.stages)) s(`stage ${e}`, () => S(t));
+		for (let { name: e, fixture: t } of y) s(`slot ${e}: exported default and configured override`, async () => {
+			o(t.overrideProbe.expected).not.toEqual(t.defaultProbe.expected), await S(t.defaultProbe), await S(t.overrideProbe);
+		});
+		for (let { name: e, fixture: t } of b) s(`port ${e}: scoped fake Layer`, () => S(t.probe));
+		for (let t of r.eventCatalog) s(`event ${t.name}: real validation and delivery`, async () => {
+			let n = r.eventFixtures[t.name], i = e(), a = i.subscribe(t, n.key);
+			try {
+				await i.publish(t, n.key, n.payload), o(a.received).toEqual([n.payload]), o(a.missedCount).toBe(0);
+			} finally {
+				a.stop(), i.reset();
+			}
+		});
+		for (let e of _) for (let i of ["user", "guest"]) s(`table ${e}: ${i} export, erase, peers and idempotent retry`, () => n.runPromise(n.acquireUseRelease(r.privacy[e](i), (e) => n.gen(function* () {
+			o(e.request.target.kind).toBe(i), o(e.before.length).toBeGreaterThan(0), e.subjectData === "none" ? o(e.before).toEqual(e.after) : o(e.before).not.toEqual(e.after), o(yield* e.read()).toEqual(e.before);
+			let n = yield* x.exportSubject(e.request);
+			o(n.plugins).toEqual([{
+				name: t.name,
+				data: e.exported
+			}]);
+			let r = yield* x.eraseSubject(e.request);
+			o(r.completed).toEqual([t.name]), o(yield* e.read()).toEqual(e.after), yield* x.eraseSubject(e.request), o(yield* e.read()).toEqual(e.after);
+		}), (e) => e.close)));
+		for (let e of v) s(`inspect ${h(e.method, e.path)}: actual handler`, async () => {
+			let t = r.inspect[h(e.method, e.path)];
+			o(await n.runPromise(n.suspend(() => e.handler(t.request)))).toEqual(t.expected);
+		});
+	});
+};
+export { g as systemContractConformance, c as systemPortFixture };

package/dist/testApps.js

@@ -4,7 +4,7 @@ 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
+// src/testApps.ts
 var u = () => new Promise((e, t) => {
 	let n = i.createServer();
 	n.once("error", t), n.listen(0, "127.0.0.1", () => {
@@ -107,5 +107,4 @@ var u = () => new Promise((e, t) => {
 		stop: C
 	};
 };
-//#endregion
 export { h as startTestApps };

package/dist/testContext.js

@@ -1,48 +1,50 @@
 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);
+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";
+// 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);
-}, 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, {
+}, 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 }
 	});
-}, 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 = [];
+}, 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 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);
+	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);
-}, K = async (e) => {
-	let t = F.get(e);
+}, 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();
-}, q = (e) => I.get(e) ?? [], J = async (e, t) => {
-	let n = M.get(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);
-}, Y = (e) => {
+}, 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;
@@ -81,7 +83,7 @@ var A = (e) => e, j = "00000000000000000000000000000000", M = /* @__PURE__ */ ne
 			return i(e, o, n.ttlMs, n.tags), o;
 		}
 	};
-}, X = (e) => {
+}, 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;
@@ -109,140 +111,158 @@ var A = (e) => e, j = "00000000000000000000000000000000", M = /* @__PURE__ */ ne
 			t.clear();
 		}
 	};
-}, Z = async (e, t) => {
-	let n = _();
-	D(e);
+}, de = async (e, t) => {
+	let n = b();
+	M(e);
 	try {
 		return await t();
 	} finally {
-		n === void 0 ? h() : D(n);
+		n === void 0 ? v() : M(n);
 	}
-}, Q = /* @__PURE__ */ new Set(), ne = (e) => {
+}, Q = /* @__PURE__ */ new Set(), fe = (e) => {
 	Q.has(e) || (Q.add(e), console.warn(e));
-}, re = (e, t, n) => {
-	let r = ie, i;
+}, pe = (e, t, n) => {
+	let r = me, 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) => {
+		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;
 	};
-}, ie = Symbol("unresolved"), $ = (e, t) => new Proxy(e, { get: (e, n) => {
-	if (n === "query") return async (n) => e.query(m(await t(), n));
+}, 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;
-} }), ae = (s = {}) => {
-	if (k({
+} }), he = (u = {}) => {
+	if (re({
 		...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);
+		...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 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
+	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: _
 	};
-	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 = {
+	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: j,
-			...t === void 0 ? {} : { connection: t }
-		}, o = r?.queued ?? [], c = r?.nudges ?? [], l = ee({
-			bus: E.bus,
+			traceId: F,
+			...n === void 0 ? {} : { connection: n }
+		}, s = i?.queued ?? [], c = i?.nudges ?? [], l = ne({
+			bus: H.bus,
 			tenantId: e.tenantId ?? null,
-			...n === h ? {} : { deferToCommit: (e) => {
-				o.push(async () => {
+			...r === v ? {} : { deferToCommit: (e) => {
+				s.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, {
+		}), 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: []
-					}, i), o = await r(a);
-					return s = a, o;
+					}, a), o = await t(i);
+					return s = i, o;
 				});
-				return s !== void 0 && (await K(s), c.push(...q(s))), l;
+				return s !== void 0 && (await Y(s), c.push(...X(s))), l;
 			},
-			clock: _,
-			webhooks: w,
+			clock: b,
+			webhooks: R,
 			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);
+			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: p,
-			access: v(e),
-			cache: P,
-			kv: R,
-			store: O($(n, x), {
+			validation: g,
+			access: S(e),
+			cache: G,
+			kv: K,
+			store: N(D($(r, f)), {
 				subject: e,
-				schemaRegistry: m,
-				rowFilter: f
+				schemaRegistry: _,
+				rowFilter: h
 			}),
-			storeForTenant: (t) => O($(n, x), {
-				subject: u(e, t),
-				schemaRegistry: m,
-				rowFilter: f
+			storeForTenant: (t) => N($(r, f), {
+				subject: p(e, t),
+				schemaRegistry: _,
+				rowFilter: h
 			}),
-			outbox: S({
-				store: n,
+			outbox: w({
+				store: r,
 				subject: e,
-				traceId: j,
+				traceId: F,
 				nudge: () => {
-					c.push(j);
+					c.push(F);
 				},
 				afterCommit: (e) => {
-					o.push(e);
+					s.push(e);
 				}
 			}),
 			load: d.load,
 			loadMany: d.loadMany,
-			withSubject: (e, r) => Promise.resolve(r(z(e, t, n, {
-				queued: o,
+			withSubject: (e, t) => Promise.resolve(t(q(e, n, r, {
+				queued: s,
 				nudges: c
 			}))),
-			withTenant: (r, i) => Promise.resolve(i(z({
+			withTenant: (t, i) => Promise.resolve(i(q({
 				...e,
-				tenantId: r
-			}, t, n, {
-				queued: o,
+				tenantId: t
+			}, n, r, {
+				queued: s,
 				nudges: c
 			}))),
-			asSubject: (e) => z(e, t, n, {
-				queued: o,
+			asSubject: (e) => q(e, n, r, {
+				queued: s,
 				nudges: c
 			}),
-			asTenant: (r) => z({
+			asTenant: (t) => q({
 				...e,
-				tenantId: r
-			}, t, n, {
-				queued: o,
+				tenantId: t
+			}, n, r, {
+				queued: s,
 				nudges: c
 			})
 		};
-		return F.set(C, o), N.set(C, (t) => z(e, t, n, {
-			queued: o,
+		return z.set(m, s), L.set(m, (t) => q(e, t, r, {
+			queued: s,
 			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,
+		})), 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
-		})))), C;
+		})))), t(m, v), m;
 	};
-	return z(s.subject ?? c(null), s.connection);
+	return q(u.subject ?? d(null), u.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 };
+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 };