@voltro/runtime 0.85.0 → 0.87.0

package/dist/dispatcher.js

@@ -0,0 +1,522 @@
+import { IndexedMatcher as e } from "./matcher.js";
+import { canonicalize as t } from "./fingerprint.js";
+import { SubscriptionRegistry as n } from "./subscriptionRegistry.js";
+import { resolveReactiveConfig as r } from "./reactiveConfig.js";
+import { currentRawReads as i, runWithRawReadScope as a } from "./rawReadScope.js";
+import { crdtIncrementalCell as o } from "./crdtMerge.js";
+import { resolveDependentTables as s } from "./dependencyGraph.js";
+import { isEventRelevant as c, resolveRelevantFields as l } from "./relevantFields.js";
+import { recordSubscriptionActive as u } from "./metrics.js";
+import { buildSubjectKey as d } from "./rywPositionStore.js";
+import { runWithRoutingContext as f } from "./replicatedDataStore.js";
+import { applyRowFilterToDescriptor as p, rowFilterRegistered as m } from "./rowFilter.js";
+import { createDispatchWireStrip as h, stripForbiddenForWire as g } from "./wireColumnStrip.js";
+import { committedChangeBatchOf as _ } from "@voltro/database";
+import { createHash as v, randomUUID as y } from "node:crypto";
+import { diffRows as b, isIdKeyed as x } from "@voltro/protocol";
+import { createLogger as S } from "@voltro/logger";
+//#region src/dispatcher.ts
+var C = /* @__PURE__ */ new Set(), w = S({ scope: "voltro:dispatcher" }), T = (e) => Array.isArray(e) ? e.length : e == null ? 0 : 1, E = (e, n) => ({
+	...e,
+	key: `${e.key}:${v("sha256").update(JSON.stringify(t(n))).digest("base64url")}`
+}), D = (e) => typeof e == "object" && !!e && (e._tag === "ScopeError" || e._tag === "Unauthenticated" || e._tag === "RequestedTenantRefused"), O = 1e3, k = 3e4, A = Object.freeze({
+	_tag: "QueryRecomputeFailed",
+	message: "The live query could not be refreshed. Retrying automatically."
+}), j = class {
+	deps;
+	subscriptionRegistry;
+	matcher;
+	subscriptions = /* @__PURE__ */ new Map();
+	unsubscribeChange;
+	closed = !1;
+	operations = /* @__PURE__ */ new Set();
+	beginOperation() {
+		let e, t = new Promise((t) => {
+			e = t;
+		});
+		return this.operations.add(t), () => {
+			this.operations.delete(t), e();
+		};
+	}
+	interests = /* @__PURE__ */ new Map();
+	dependentByTable = /* @__PURE__ */ new Map();
+	computedSubs = /* @__PURE__ */ new Map();
+	computedByTable = /* @__PURE__ */ new Map();
+	reactive;
+	rawReadWarned = /* @__PURE__ */ new Set();
+	readFences = /* @__PURE__ */ new WeakMap();
+	changeEpoch = 0;
+	committedReads = /* @__PURE__ */ new WeakMap();
+	crdtColumnsFor(e) {
+		return this.deps.crdtColumnsOf?.(e) ?? C;
+	}
+	constructor(t) {
+		this.deps = t, this.matcher = new e(), this.subscriptionRegistry = new n(this.matcher), this.reactive = r(t.reactive);
+	}
+	measureLoop(e) {
+		return this.deps.measureSync ? this.deps.measureSync(e) : e();
+	}
+	retainInterest(e, t) {
+		if (this.closed) throw Error("Dispatcher is closed");
+		this.interests.set(e, t);
+		try {
+			this.unsubscribeChange ??= this.deps.store.onChange((e) => {
+				let t = _(e), n = t === void 0 ? void 0 : this.committedReads.get(t);
+				n === void 0 && (this.changeEpoch++, t !== void 0 && (n = {
+					epoch: this.changeEpoch,
+					reads: /* @__PURE__ */ new Map()
+				}, this.committedReads.set(t, n))), this.closed || this.handleChange(e, !1, n);
+			});
+		} catch (t) {
+			throw this.interests.delete(e), t;
+		}
+	}
+	removeInterest(e) {
+		let t = this.interests.get(e);
+		if (t === void 0) return;
+		this.interests.delete(e);
+		let n = this.computedSubs.get(e);
+		n?.retryTimer !== void 0 && (clearTimeout(n.retryTimer), n.retryTimer = void 0);
+		let r = this.subscriptions.get(e) ?? n;
+		this.subscriptions.delete(e), this.computedSubs.delete(e), r !== void 0 && u(r.label, -1), this.subscriptionRegistry.unsubscribe(e);
+		for (let n of t) for (let t of [this.dependentByTable, this.computedByTable]) {
+			let r = t.get(n);
+			r?.delete(e), r?.size === 0 && t.delete(n);
+		}
+		this.interests.size === 0 && (this.unsubscribeChange?.(), this.unsubscribeChange = void 0);
+	}
+	warnUndeclaredRawReads(e, t) {
+		if (t.length !== 0 && !this.rawReadWarned.has(e)) {
+			this.rawReadWarned.add(e);
+			for (let n of t) w.warn(`${e}: a raw SQL read in this live query declares no dependsOn, so no write can invalidate it — every subscriber keeps its first result until it reconnects. Declare the tables it reads: ctx.store.raw(fragment, { dependsOn: ['orders'] }) — or on the fragment itself. The read: ${n.sql}`, {
+				label: e,
+				sql: n.sql
+			});
+		}
+	}
+	async subscribe(e, t, n, r, a, o, c, h, _ = !1) {
+		let v = `sub_${y()}`, b = a ?? `subscription.${e.table}`, x = s(e);
+		this.retainInterest(v, x);
+		let S = this.beginOperation();
+		try {
+			if (h === void 0 && m()) throw Error(`subscription "${b}" was opened without a row-filter resolver while a row filter is registered — this would read every row the filter exists to hide. Pass the resolver from \`makeDefaultRefilter(subject)\`, or pass one returning \`NO_ROW_FILTER\` to read unfiltered deliberately.`);
+			let a = l(e);
+			e.predicate !== void 0 && this.subscriptionRegistry.subscribe(v, e.table, e.predicate, r);
+			let s = e.predicate !== void 0 && (e.dependentTables?.length ?? 0) === 0 && e.eager === void 0 && e.setOp === void 0 && e.ctes === void 0 && e.alias === void 0 && (e.joins?.length ?? 0) === 0 && x.size === 1 && x.has(e.table);
+			for (let t of x) {
+				if (s && t === e.table) continue;
+				let n = this.dependentByTable.get(t);
+				n === void 0 && (n = /* @__PURE__ */ new Set(), this.dependentByTable.set(t, n)), n.add(v);
+			}
+			let y = Date.now(), S = Array.from(x), C = () => this.removeInterest(v), w, T;
+			try {
+				if (w = h === void 0 ? e : p(await h(), e), this.closed) throw Error("Dispatcher is closed");
+				let t = _ ? await f({
+					subjectKey: d(n.subject.id, n.clientId),
+					forcePrimary: !0
+				}, () => this.deps.store.query(w)) : this.deps.cache !== void 0 && o !== void 0 ? await this.deps.cache.wrap(E(o, w), S, () => f({
+					subjectKey: d(n.subject.id, n.clientId),
+					forcePrimary: !0
+				}, () => this.deps.store.query(w))) : await this.deps.store.query(w);
+				if (this.closed) throw Error("Dispatcher is closed");
+				if (c !== void 0) {
+					let e = await c();
+					if (e) throw e;
+				}
+				if (this.closed) throw Error("Dispatcher is closed");
+				T = g(w.table, t, n.subject);
+			} catch (e) {
+				throw C(), e;
+			}
+			this.warnUndeclaredRawReads(b, i().filter((e) => e.dependsOn.length === 0)), this.subscriptions.set(v, {
+				id: v,
+				descriptor: w,
+				baseDescriptor: e,
+				context: n,
+				emit: t,
+				label: b,
+				dependentTables: x,
+				relevantFields: a,
+				lastDelivered: T,
+				cacheBinding: o,
+				readFromPrimary: _,
+				reauthorize: c,
+				refilter: h,
+				memoKey: void 0
+			}), u(b, 1), t({
+				_tag: "snapshot",
+				revision: 0,
+				data: T
+			});
+			let D = Date.now();
+			return this.deps.recordDelivery?.({
+				traceId: n.traceId,
+				parentSpanId: n.spanId,
+				label: b,
+				kind: "snapshot",
+				startMs: y,
+				endMs: D,
+				durationMs: D - y,
+				rowCount: T.length
+			}), () => this.removeInterest(v);
+		} catch (e) {
+			throw this.removeInterest(v), e;
+		} finally {
+			S();
+		}
+	}
+	revokeSubscription(e, t, n = "guards no longer satisfied") {
+		this.subscriptions.get(e.id) === e && (this.removeInterest(e.id), w.warn(`subscription revoked mid-stream — ${n}`, {
+			id: e.id,
+			label: e.label,
+			traceId: e.context.traceId
+		}), e.emit({
+			_tag: "error",
+			error: t
+		}));
+	}
+	removeComputed(e) {
+		return this.computedSubs.get(e.id) === e && (this.removeInterest(e.id), !0);
+	}
+	revokeComputed(e, t) {
+		this.removeComputed(e) && (w.warn("computed subscription revoked mid-stream — guards no longer satisfied", {
+			id: e.id,
+			label: e.label,
+			traceId: e.context.traceId
+		}), e.emit({
+			_tag: "error",
+			error: t
+		}));
+	}
+	async subscribeComputed(e, t, n, r) {
+		let o = `csub_${y()}`, s = r ?? "subscription.computed", c = i(), l = new Set(e.dependentTables);
+		for (let e of c) for (let t of e.dependsOn) l.add(t);
+		let d = Array.from(l);
+		this.retainInterest(o, l);
+		try {
+			this.warnUndeclaredRawReads(s, c.filter((e) => e.dependsOn.length === 0));
+			let r = {
+				id: o,
+				recompute: () => a(e.recompute),
+				tenantId: e.tenantId,
+				emit: t,
+				context: n,
+				label: s,
+				tables: d,
+				lastJson: M(e.value),
+				revision: 0,
+				failed: !1,
+				retryAttempts: 0,
+				retryTimer: void 0,
+				running: !1,
+				rerunRequested: !1
+			};
+			this.computedSubs.set(o, r), u(r.label, 1);
+			for (let e of d) {
+				let t = this.computedByTable.get(e);
+				t === void 0 && (t = /* @__PURE__ */ new Set(), this.computedByTable.set(e, t)), t.add(o);
+			}
+			let i = Date.now();
+			return t({
+				_tag: "snapshot",
+				revision: 0,
+				data: e.value
+			}), this.deps.recordDelivery?.({
+				traceId: n.traceId,
+				parentSpanId: n.spanId,
+				label: r.label,
+				kind: "snapshot",
+				startMs: i,
+				endMs: Date.now(),
+				durationMs: Date.now() - i,
+				rowCount: T(e.value)
+			}), () => {
+				this.removeComputed(r);
+			};
+		} catch (e) {
+			throw this.removeInterest(o), e;
+		}
+	}
+	async recomputeComputed(e) {
+		if (this.closed || this.computedSubs.get(e.id) !== e) return;
+		if (e.running) {
+			e.rerunRequested = !0;
+			return;
+		}
+		e.retryTimer !== void 0 && clearTimeout(e.retryTimer), e.retryTimer = void 0, e.running = !0;
+		let t = this.beginOperation();
+		try {
+			do {
+				e.rerunRequested = !1;
+				let t = Date.now(), n = await e.recompute();
+				if (this.computedSubs.get(e.id) !== e) return;
+				if (e.rerunRequested) continue;
+				let r = this.measureLoop(() => M(n)), i = e.failed;
+				if (e.failed = !1, e.retryAttempts = 0, r === e.lastJson && !i) return;
+				e.lastJson = r, e.revision += 1;
+				let a = Date.now();
+				this.measureLoop(() => e.emit({
+					_tag: "snapshot",
+					revision: e.revision,
+					data: n
+				})), this.deps.recordDelivery?.({
+					traceId: e.context.traceId,
+					parentSpanId: e.context.spanId,
+					label: e.label,
+					kind: "delta",
+					startMs: t,
+					endMs: a,
+					durationMs: a - t,
+					rowCount: T(n)
+				}), this.deps.recordCost !== void 0 && this.deps.recordCost({
+					tenantId: e.tenantId,
+					subscriptionId: e.id,
+					unit: "recompute",
+					amount: 1,
+					traceId: e.context.traceId
+				});
+			} while (e.rerunRequested);
+		} catch (t) {
+			if (this.computedSubs.get(e.id) !== e) return;
+			if (D(t)) {
+				this.revokeComputed(e, t);
+				return;
+			}
+			e.failed || (e.failed = !0, e.emit({
+				_tag: "error",
+				error: A
+			}), w.warn("computed recompute failed; retrying with last value marked stale", {
+				id: e.id,
+				label: e.label,
+				traceId: e.context.traceId
+			}, t));
+			let n = Math.min(k, O * 2 ** Math.min(e.retryAttempts, 5));
+			if (e.retryAttempts += 1, this.computedSubs.get(e.id) !== e) return;
+			e.retryTimer = setTimeout(() => {
+				e.retryTimer = void 0, this.recomputeComputed(e);
+			}, n), e.retryTimer.unref();
+		} finally {
+			e.running = !1, t();
+		}
+	}
+	subscriptionSnapshot() {
+		return this.subscriptionRegistry.snapshot();
+	}
+	matcherStats() {
+		return this.matcher.stats?.() ?? { perTable: [] };
+	}
+	onSubscriptionsChange(e) {
+		return this.subscriptionRegistry.onChange(e);
+	}
+	close() {
+		this.closed = !0;
+		for (let e of this.interests.keys()) this.removeInterest(e);
+		this.unsubscribeChange?.(), this.unsubscribeChange = void 0;
+	}
+	async closeAndDrain() {
+		try {
+			this.close();
+		} finally {
+			for (; this.operations.size > 0;) await Promise.all(this.operations);
+		}
+	}
+	async refreshAll(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let e of this.subscriptions.values()) t.add(e.descriptor.table);
+		for (let e of this.computedByTable.keys()) t.add(e);
+		if (t.size !== 0) {
+			w.warn("refreshing every live subscription", {
+				reason: e,
+				tables: t.size,
+				subscriptions: this.subscriptions.size
+			});
+			for (let e of t) await this.handleChange({
+				table: e,
+				op: "insert",
+				new: {},
+				old: void 0
+			}, !0);
+		}
+	}
+	async handleChange(e, n = !1, r) {
+		if (this.closed) return;
+		let i = this.beginOperation();
+		try {
+			n && this.changeEpoch++;
+			let i = this.computedByTable.get(e.table);
+			if (i !== void 0 && i.size > 0) for (let e of i) {
+				let t = this.computedSubs.get(e);
+				t !== void 0 && this.recomputeComputed(t);
+			}
+			let a = n || e.oversized === "tombstone" || e.oversized === "unrecovered", s = a ? [] : this.measureLoop(() => this.subscriptionRegistry.notify(e)), l = /* @__PURE__ */ new Set();
+			for (let e of s) l.add(e.subscriberId);
+			if (a) for (let [t, n] of this.subscriptions) n.descriptor.table === e.table && l.add(t);
+			let u = this.dependentByTable.get(e.table);
+			if (u !== void 0) for (let e of u) l.add(e);
+			if (w.trace("handleChange", {
+				table: e.table,
+				op: e.op,
+				matcher: s.length,
+				dependent: u?.size ?? 0,
+				triggered: l.size
+			}), l.size === 0) return;
+			let m = Date.now(), _ = 0, v = /* @__PURE__ */ new Map(), y = l.size > 1 ? h() : void 0, S = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), D = async (i) => {
+				let a = this.subscriptions.get(i);
+				if (!a) {
+					w.trace("missing subscription", { subscriberId: i });
+					return;
+				}
+				if (!n && !c(e, a.relevantFields)) {
+					_++;
+					return;
+				}
+				let s = Date.now();
+				try {
+					if (a.reauthorize !== void 0) {
+						let e = await a.reauthorize();
+						if (this.subscriptions.get(a.id) !== a) return;
+						if (e) {
+							this.revokeSubscription(a, e);
+							return;
+						}
+					}
+					let n, c;
+					if (a.refilter === void 0) n = a.descriptor, a.memoKey ??= JSON.stringify(t(n)), c = a.memoKey;
+					else {
+						let e;
+						try {
+							if (e = await a.refilter(), this.subscriptions.get(a.id) !== a) return;
+						} catch (e) {
+							this.revokeSubscription(a, e, "row filter unavailable");
+							return;
+						}
+						try {
+							n = p(e, a.baseDescriptor);
+						} catch (e) {
+							this.revokeSubscription(a, e, "row filter declaration violated");
+							return;
+						}
+						c = JSON.stringify(t(n));
+					}
+					c = `${a.readFromPrimary ? "primary" : "policy"}:${c}`;
+					let l = r?.epoch === this.changeEpoch ? r.reads : v, u = l.get(c);
+					if (u === void 0) {
+						let e = () => a.readFromPrimary ? f({
+							subjectKey: d(a.context.subject.id, a.context.clientId),
+							forcePrimary: !0
+						}, () => this.deps.store.query(n)) : this.deps.store.query(n), t = this.deps.cache;
+						if (t !== void 0 && a.cacheBinding !== void 0) {
+							let n = t.fence();
+							u = n.then(e, e), this.readFences.set(u, n);
+						} else u = e();
+						l.set(c, u);
+					}
+					let h = await u;
+					if (this.subscriptions.get(a.id) !== a) return;
+					if (a.reauthorize !== void 0) {
+						let e = await a.reauthorize();
+						if (this.subscriptions.get(a.id) !== a) return;
+						if (e) {
+							this.revokeSubscription(a, e);
+							return;
+						}
+					}
+					let _ = this.measureLoop(() => y?.(n.table, h, a.context.subject)), D = _?.rows ?? this.measureLoop(() => g(n.table, h, a.context.subject));
+					_ !== void 0 && (c = JSON.stringify([c, _.visibilityKey]));
+					let O = a.lastDelivered, k = T.get(c);
+					k === void 0 && (k = /* @__PURE__ */ new Map(), T.set(c, k));
+					let A = k.get(O);
+					if (A === void 0 && (A = !this.measureLoop(() => N(D, O)), k.set(O, A)), !A) {
+						w.trace("suppressed no-op delta", {
+							subscriberId: i,
+							table: e.table
+						});
+						return;
+					}
+					a.lastDelivered = D;
+					let j = this.readFences.get(u);
+					if (this.deps.cache !== void 0 && a.cacheBinding !== void 0 && j !== void 0) {
+						let e = this.deps.cache, t = E(a.cacheBinding, n), r = Array.from(a.dependentTables);
+						j.then((n) => {
+							e.put(t, r, h, n);
+						}, () => void 0);
+					}
+					if (x(O) && x(D)) {
+						let e = S.get(c);
+						e === void 0 && (e = /* @__PURE__ */ new Map(), S.set(c, e));
+						let t = e.get(O);
+						if (t === void 0) {
+							let n = this.deps.crdtColumnsOf?.(a.descriptor.table) ?? C;
+							t = this.measureLoop(() => n.size === 0 ? b(O, D) : b(O, D, { crdt: {
+								columns: n,
+								incremental: o
+							} })), e.set(O, t);
+						}
+						let n = t;
+						this.measureLoop(() => a.emit({
+							_tag: "delta",
+							revision: m,
+							emittedAt: m,
+							patch: n
+						}));
+					} else this.measureLoop(() => a.emit({
+						_tag: "snapshot",
+						revision: m,
+						data: D
+					}));
+					let M = Date.now();
+					this.deps.recordDelivery?.({
+						traceId: a.context.traceId,
+						parentSpanId: a.context.spanId,
+						label: a.label,
+						kind: "delta",
+						startMs: s,
+						endMs: M,
+						durationMs: M - s,
+						rowCount: D.length
+					}), this.deps.recordCost !== void 0 && this.deps.recordCost({
+						tenantId: a.context.subject.tenantId,
+						subscriptionId: a.id,
+						unit: "recompute",
+						amount: 1,
+						traceId: a.context.traceId
+					});
+				} catch (t) {
+					w.warn("reactive re-query failed; subscriber left on last snapshot", {
+						subscriberId: i,
+						label: a.label,
+						table: e.table,
+						traceId: a.context.traceId
+					}, t);
+				}
+			}, O = Array.from(l), k = Math.max(1, Math.min(this.reactive.deliveryConcurrency, O.length)), A = 0, j = async () => {
+				for (;;) {
+					let e = A++;
+					if (e >= O.length) return;
+					await D(O[e]);
+				}
+			}, M = (await Promise.allSettled(Array.from({ length: k }, () => j()))).find((e) => e.status === "rejected");
+			if (M?.status === "rejected") throw M.reason;
+			_ > 0 && w.trace("handleChange/prefiltered", {
+				table: e.table,
+				op: e.op,
+				skipped: _
+			});
+		} finally {
+			i();
+		}
+	}
+}, M = (e) => {
+	try {
+		return JSON.stringify(e) ?? "null";
+	} catch {
+		return String(e);
+	}
+}, N = (e, t) => {
+	if (e === t) return !0;
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (JSON.stringify(e[n]) !== JSON.stringify(t[n])) return !1;
+	return !0;
+};
+//#endregion
+export { j as Dispatcher, T as deliveredRowCount, E as snapshotEntryFor };

package/dist/effectStore.js

@@ -0,0 +1,71 @@
+import { Context as e, Effect as t, Exit as n, Layer as r } from "effect";
+import { authoredError as i, describeDriverError as a, wireSafeCause as o } from "@voltro/database";
+import { StoreOperationFailed as s } from "@voltro/protocol";
+import { createLogger as c } from "@voltro/logger";
+//#region src/effectStore.ts
+var l = c({ scope: "store" }), u = class extends e.Service()("@voltro/EffectStore") {}, d = {
+	TenantScopeViolation: !0,
+	TenantRowNotFound: !0,
+	ServerOnlyColumnWrite: !0,
+	StoreOperationFailed: !0,
+	TableValidationFailed: !0,
+	ConstraintViolation: !0
+}, f = (e) => {
+	let t = e?._tag;
+	return typeof t == "string" && Object.hasOwn(d, t);
+}, p = (e, t) => (n) => f(n) ? n : (l.warn("store operation failed", {
+	operation: e,
+	table: t,
+	detail: a(n) ?? String(n)
+}), new s({
+	operation: e,
+	table: t,
+	cause: o(n, e)
+})), m = (e, n, r) => t.tryPromise({
+	try: r,
+	catch: p(e, n)
+}), h = (e) => ("descriptor" in e ? e.descriptor : e).table, g = (e, n) => t.tryPromise({
+	try: n,
+	catch: (t) => t?._tag === "NoRowFound" ? t : p("one", e)(t)
+}), _ = class extends Error {
+	effectCause;
+	constructor(e) {
+		super("Effect program failed inside store transaction"), this.effectCause = e;
+	}
+}, v = (e) => ({
+	query: ((t) => m("query", t.table, () => e.query(t))),
+	insert: (t, n) => m("insert", t, () => e.insert(t, n)),
+	insertMany: (t, n, r) => m("insertMany", t, () => e.insertMany(t, n, r)),
+	patchJson: (t, n, r, i, a) => m("patchJson", t, () => e.patchJson(t, n, r, i, a)),
+	update: (t, n, r) => m("update", t, () => e.update(t, n, r)),
+	updateMany: (t, n, r) => m("updateMany", t, () => e.updateMany(t, n, r)),
+	delete: (t, n) => m("delete", t, () => e.delete(t, n)),
+	deleteMany: (t, n) => m("deleteMany", t, () => e.deleteMany(t, n)),
+	upsert: (t, n, r) => m("upsert", t, () => e.upsert(t, n, r)),
+	upsertWithOutcome: (t, n, r) => m("upsertWithOutcome", t, async () => {
+		if (e.upsertWithOutcome === void 0) throw i("upsertWithOutcome: this store does not implement it — the framework's store wrapper does; a hand-written DataStore must add it");
+		return e.upsertWithOutcome(t, n, r);
+	}),
+	insertIgnore: (t, n, r) => m("insertIgnore", t, () => e.insertIgnore(t, n, r)),
+	insertIgnoreWithOutcome: (t, n, r) => m("insertIgnoreWithOutcome", t, async () => e.insertIgnoreWithOutcome(t, n, r)),
+	one: ((t) => g(h(t), () => e.one(t))),
+	maybeOne: ((t) => m("maybeOne", h(t), () => e.maybeOne(t))),
+	first: ((t) => m("first", h(t), () => e.first(t))),
+	hardDelete: (t, n) => m("hardDelete", t, () => e.hardDelete(t, n)),
+	transactional: (r) => t.flatMap(t.context(), (i) => t.callback((o) => {
+		let s;
+		e.transactional(async (e) => {
+			let a = await t.runPromiseExitWith(i)(r(v(e)));
+			if (n.isFailure(a)) throw s = a.cause, new _(a.cause);
+			return a.value;
+		}).then((e) => o(t.succeed(e)), (e) => {
+			e instanceof _ ? o(t.failCause(e.effectCause)) : s === void 0 ? o(t.fail(p("transactional", "<transaction>")(e))) : (l.warn("transaction rollback failed after the work did", { detail: a(e) ?? String(e) }), o(t.failCause(s)));
+		});
+	}))
+}), y = (e) => r.succeed(u, v(e)), b = (e) => ({
+	conflictColumns: e.conflictColumns,
+	...e.update === void 0 ? {} : { update: e.update },
+	...e.updateValues === void 0 ? {} : { updateValues: e.updateValues }
+}), x = (e, t, n) => e.insert(t.tableName, n), S = (e, t, n, r) => e.insertMany(t.tableName, n, r), C = (e, t, n, r) => e.upsert(t.tableName, n, b(r)), w = (e, t, n, r) => e.upsertWithOutcome(t.tableName, n, b(r)), T = (e, t, n, r) => e.insertIgnoreWithOutcome(t.tableName, n, { conflictColumns: r.conflictColumns });
+//#endregion
+export { u as EffectStore, T as insertIgnoreRowOutcomeEffect, S as insertManyRowsEffect, x as insertRowEffect, y as makeEffectStoreLayer, C as upsertRowEffect, w as upsertRowOutcomeEffect };

package/dist/engineClients.js

@@ -0,0 +1,24 @@
+//#region src/engineClients.ts
+var e = /* @__PURE__ */ new Map(), t = 0, n = (e) => {
+	let t = /^([a-z]{1,16})\/([0-9A-Za-z.+-]{1,100})(?:; surface=([0-9a-f]{64}))?$/.exec(e.trim());
+	return t ? {
+		target: t[1],
+		version: t[2],
+		surface: t[3] ?? null
+	} : null;
+}, r = (r, i) => {
+	let a = r.headers["x-voltro-sdk"];
+	if (typeof a != "string" || e.size >= 1024) return;
+	let o = n(a);
+	if (!o) return;
+	let s = "client-" + String(++t);
+	e.set(s, Object.freeze({
+		id: s,
+		...o,
+		connectedAt: Date.now()
+	})), i.once("close", () => {
+		e.delete(s);
+	});
+}, i = () => [...e.values()];
+//#endregion
+export { i as engineClientsSnapshot, n as parseEngineSdkHeader, r as trackEngineClient };