@voltro/runtime 0.85.0 → 0.86.0

package/dist/storeQuery.js

@@ -0,0 +1,204 @@
+import { NO_ROW_FILTER as e } from "./rowFilter.js";
+import { Schema as t } from "effect";
+import { and as n, contains as r, eq as i, getTable as a, gt as o, gte as s, inSet as c, isNull as l, lt as u, lte as d, neq as f, queryFor as p, startsWith as m } from "@voltro/database";
+import { NoRowFound as h, NoRowFound as g } from "@voltro/protocol";
+//#region src/storeQuery.ts
+var _ = (e, t) => t === void 0 ? new h(e) : t(e), v = class extends t.TaggedError()("OptimisticLockError", {
+	table: t.String,
+	expected: t.Number
+}) {
+	get message() {
+		return `optimistic lock failed on '${this.table}': expected version ${this.expected}`;
+	}
+}, y = (e) => typeof e == "object" && !!e && ("and" in e || "or" in e || "not" in e || "op" in e || "subquery" in e), b = (e) => {
+	if (e.length === 1 && y(e[0])) return e[0];
+	if (e.length !== 2 && e.length !== 3 || typeof e[0] != "string") throw TypeError("where(): pass a predicate, (column, value), or (column, operator, value)");
+	let t = e[0];
+	if (e.length === 2) return i(t, e[1]);
+	let n = e[1], a = e[2];
+	switch (n) {
+		case "=": return i(t, a);
+		case "!=":
+		case "<>": return f(t, a);
+		case ">": return o(t, a);
+		case ">=": return s(t, a);
+		case "<": return u(t, a);
+		case "<=": return d(t, a);
+		case "in": return c(t, a);
+		case "contains":
+		case "fts": return r(t, a);
+		case "startsWith": return m(t, a);
+		default: throw TypeError("where(): unsupported comparison operator; use contains or startsWith for text matching");
+	}
+}, x = (e) => {
+	let t = a(e);
+	if (t === void 0) throw Error(`unknown table '${e}' — is it declared with table()?`);
+	return p(t);
+}, S = class t {
+	backend;
+	scope;
+	table;
+	query;
+	skipTenant;
+	skipSoftDelete;
+	constructor(e, t, n, r, i = !1, a = !1) {
+		this.backend = e, this.scope = t, this.table = n, this.query = r, this.skipTenant = i, this.skipSoftDelete = a;
+	}
+	clone(e) {
+		return new t(this.backend, this.scope, this.table, e, this.skipTenant, this.skipSoftDelete);
+	}
+	where(...e) {
+		return this.clone(this.query.where(b(e)));
+	}
+	orderBy(e, t = "asc") {
+		return this.clone(this.query.orderBy(e, t));
+	}
+	limit(e) {
+		return this.clone(this.query.limit(e));
+	}
+	forUpdate() {
+		return this.clone(this.query.forUpdate());
+	}
+	offset(e) {
+		return this.clone(this.query.offset(e));
+	}
+	select(...e) {
+		return this.clone(this.query.select(...e));
+	}
+	using(e) {
+		return this.clone(this.query.using(e));
+	}
+	with(e) {
+		return this.clone(this.query.with(e));
+	}
+	groupBy(e) {
+		return this.clone(this.query.groupBy(e));
+	}
+	matching(e, t) {
+		return this.clone(this.query.matching(e, t));
+	}
+	unscoped() {
+		return new t(this.backend, this.scope, this.table, this.query, !0, this.skipSoftDelete);
+	}
+	withDeleted() {
+		return new t(this.backend, this.scope, this.table, this.query, this.skipTenant, !0);
+	}
+	scopedQuery() {
+		let t = this.query, { subject: n, schemaRegistry: r } = this.scope;
+		!this.skipTenant && r.hasTenant(this.table) && n.tenantId != null && (t = t.where(i("tenantId", n.tenantId))), !this.skipSoftDelete && r.hasSoftDelete(this.table) && (t = t.where(l("deletedAt")));
+		let a = (this.scope.rowFilter ?? e)(this.table);
+		return a !== void 0 && (t = t.where(a)), t;
+	}
+	async all() {
+		return this.backend.query(this.scopedQuery().descriptor);
+	}
+	async maybeOne() {
+		return (await this.backend.query(this.scopedQuery().limit(1).descriptor))[0] ?? null;
+	}
+	first() {
+		return this.maybeOne();
+	}
+	async one(e) {
+		let t = await this.backend.query(this.scopedQuery().limit(2).descriptor), n = t[0];
+		if (n === void 0) throw _({
+			table: this.table,
+			found: 0
+		}, e);
+		if (t.length > 1) throw _({
+			table: this.table,
+			found: t.length
+		}, e);
+		return n;
+	}
+	async count() {
+		let e = (await this.backend.query(this.scopedQuery().count().descriptor))[0]?.count;
+		return typeof e == "number" ? e : Number(e ?? 0);
+	}
+	async exists() {
+		return (await this.backend.query(this.scopedQuery().limit(1).descriptor)).length > 0;
+	}
+	get descriptor() {
+		return this.scopedQuery().descriptor;
+	}
+}, C = class {
+	backend;
+	scope;
+	table;
+	predicate;
+	skipTenant = !1;
+	expectedVersion;
+	constructor(e, t, n) {
+		this.backend = e, this.scope = t, this.table = n;
+	}
+	where(...e) {
+		let t = b(e);
+		return this.predicate = this.predicate ? n(this.predicate, t) : t, this;
+	}
+	unscoped() {
+		return this.skipTenant = !0, this;
+	}
+	expectVersion(e) {
+		return this.expectedVersion = e, this;
+	}
+	scopedWhere() {
+		let e = this.predicate, { subject: t, schemaRegistry: r } = this.scope;
+		if (!this.skipTenant && r.hasTenant(this.table) && t.tenantId != null) {
+			let r = i("tenantId", t.tenantId);
+			e = e ? n(e, r) : r;
+		}
+		if (this.expectedVersion !== void 0) {
+			let t = i("version", this.expectedVersion);
+			e = e ? n(e, t) : t;
+		}
+		if (e === void 0) throw Error(`update('${this.table}') needs a .where(...) clause`);
+		return e;
+	}
+	async set(e) {
+		let t = await this.backend.updateMany(this.table, e, { where: this.scopedWhere() });
+		if (this.expectedVersion !== void 0 && t === 0) throw new v({
+			table: this.table,
+			expected: this.expectedVersion
+		});
+		return t;
+	}
+	async restore() {
+		return this.backend.updateMany(this.table, { deletedAt: null }, { where: this.scopedWhere() });
+	}
+}, w = class {
+	backend;
+	scope;
+	table;
+	predicate;
+	skipTenant = !1;
+	constructor(e, t, n) {
+		this.backend = e, this.scope = t, this.table = n;
+	}
+	where(...e) {
+		let t = b(e);
+		return this.predicate = this.predicate ? n(this.predicate, t) : t, this;
+	}
+	unscoped() {
+		return this.skipTenant = !0, this;
+	}
+	scopedWhere() {
+		let e = this.predicate, { subject: t, schemaRegistry: r } = this.scope;
+		if (!this.skipTenant && r.hasTenant(this.table) && t.tenantId != null) {
+			let r = i("tenantId", t.tenantId);
+			e = e ? n(e, r) : r;
+		}
+		if (e === void 0) throw Error(`delete('${this.table}') needs a .where(...) clause`);
+		return e;
+	}
+	async soft() {
+		return this.backend.updateMany(this.table, { deletedAt: /* @__PURE__ */ new Date() }, { where: this.scopedWhere() });
+	}
+	async hard() {
+		return this.backend.deleteMany(this.table, { where: this.scopedWhere() });
+	}
+}, T = (e, t) => ({
+	select: (n) => new S(e, t, n, x(n)),
+	updateWhere: (n) => new C(e, t, n),
+	deleteWhere: (n) => new w(e, t, n)
+});
+//#endregion
+export { w as DeleteBuilder, g as NoRowFound, v as OptimisticLockError, S as SelectBuilder, C as UpdateBuilder, T as makeFluentStore, _ as missingRowError };

package/dist/storeRead.js

@@ -0,0 +1,10 @@
+//#region src/storeRead.ts
+var e = async (e, t) => {
+	let n = "descriptor" in t ? t.descriptor : t;
+	return (await e.query({
+		...n,
+		take: 1
+	}))[0] ?? null;
+};
+//#endregion
+export { e as readMaybeOne };

package/dist/subscriber.js

@@ -0,0 +1,7 @@
+//#region src/subscriber.ts
+var e = (e) => {
+	if (e.once !== void 0 && e.eachReplica === !0) throw Error("defineSubscriber: choose either `once` or `eachReplica: true`, not both");
+	return e;
+};
+//#endregion
+export { e as defineSubscriber };

package/dist/subscriptionOutbox.js

@@ -0,0 +1,139 @@
+import { createSubscriptionBufferMetric as e, recordCoalesced as t, recordOverrun as n, recordOversized as r, recordStalled as i } from "./subscriptionSocketMetrics.js";
+import { createRowStateByteEstimator as a } from "./rowStateBytes.js";
+import { MutableList as o } from "effect";
+import { createRowPatchApplier as s, diffRows as c, isIdKeyed as l } from "@voltro/protocol";
+import { createLogger as u } from "@voltro/logger";
+//#region src/subscriptionOutbox.ts
+var d = u({ scope: "voltro:subscription" }), f = 1048576, p = 1e4, m = 262144, h = 5e3, g = Symbol.for("@voltro/runtime/reactiveSocketTunables"), _ = (e) => {
+	let t = globalThis;
+	t[g] = e;
+}, v = () => globalThis[g] ?? {
+	maxBufferedBytes: 1048576,
+	overrunAfterMs: 1e4,
+	oversizedEventBytes: 262144,
+	stallWarnAfterMs: 5e3
+}, y = (e) => {
+	try {
+		let t = JSON.stringify(e);
+		return t === void 0 ? 0 : t.length;
+	} catch {
+		return 0;
+	}
+}, b = (i) => {
+	let u = i.now ?? Date.now, f = i.crdt !== void 0 && i.crdt.columns.size > 0 ? i.crdt : void 0, p = f === void 0 ? {} : { mergeCell: f.merge }, m = f === void 0 ? {} : { crdt: {
+		columns: f.columns,
+		incremental: f.incremental
+	} }, h = i.warn ?? ((e, t) => {
+		d.warn(e, t);
+	}), g, _, v, b = 0, x = o.make(), S, C, w = !1, T = !1, E, D = () => E !== void 0, O = a(), k = s(), A = e(i.label), j = () => {
+		g = void 0, k.reset(), O.reset();
+	}, M = (e) => {
+		if (e._tag === "snapshot") O.reset(), k.reset(), v = e.data;
+		else if (e._tag === "delta") {
+			let t = v ?? g;
+			v = t === void 0 ? void 0 : k.apply(t, e.patch, p);
+		}
+	}, N = (e) => (t(i.label, b), e._tag === "delta" && v !== void 0 && g !== void 0 && Array.isArray(g) && Array.isArray(v) && l(g) && l(v) ? {
+		_tag: "delta",
+		revision: e.revision,
+		emittedAt: e.emittedAt,
+		patch: c(g, v, m)
+	} : v === void 0 ? e : e._tag === "snapshot" ? {
+		...e,
+		data: v
+	} : {
+		_tag: "snapshot",
+		revision: e.revision,
+		data: v
+	}), P = (e) => {
+		let t = E;
+		E = void 0, t?.(e);
+	};
+	return {
+		push: (e) => {
+			if (w || T) return;
+			let t = y(e._tag === "snapshot" ? e.data : e._tag === "delta" ? e.patch : void 0);
+			if (t > i.oversizedEventBytes && (r(i.label), h(`subscription '${i.label}': oversized ${e._tag} (${t} bytes > ${i.oversizedEventBytes})`, {
+				label: i.label,
+				tag: e._tag,
+				bytes: t,
+				threshold: i.oversizedEventBytes
+			})), e._tag === "error") {
+				if (D() && _ === void 0 && x.length === 0) {
+					P(e);
+					return;
+				}
+				o.append(x, e);
+				return;
+			}
+			if (D() && _ === void 0) {
+				M(e), g = v ?? g, v = void 0, P(e);
+				return;
+			}
+			_ !== void 0 && (b += 1), M(e), _ = e, S === void 0 && (S = u());
+			let a = O.estimate(v ?? [], y, e._tag === "delta");
+			if (A(a), a > i.maxBufferedBytes) {
+				if (C === void 0 && (C = u()), u() - C >= i.overrunAfterMs) {
+					T = !0, n(i.label);
+					let e = {
+						_tag: "SubscriptionOverrun",
+						message: `subscription '${i.label}' overran its socket buffer: the consumer stayed ${a} bytes behind (max ${i.maxBufferedBytes}) for ${i.overrunAfterMs}ms. Re-subscribe for a fresh snapshot.`,
+						bufferedBytes: a,
+						maxBufferedBytes: i.maxBufferedBytes
+					};
+					_ = void 0, v = void 0, j(), A(0), x = o.make(), o.append(x, {
+						_tag: "error",
+						error: e
+					}), h(`subscription '${i.label}': overrun — closing with SubscriptionOverrun`, {
+						label: i.label,
+						bufferedBytes: a,
+						maxBufferedBytes: i.maxBufferedBytes
+					});
+				}
+			} else C = void 0;
+		},
+		take: () => {
+			if (_ !== void 0) {
+				let e = _, t = b > 0 ? N(e) : e;
+				return _ = void 0, b = 0, S = void 0, C = void 0, A(0), g = v ?? g, v = void 0, w && j(), Promise.resolve(t);
+			}
+			if (x.length !== 0) {
+				let e = o.take(x);
+				return T && x.length === 0 && (w = !0), Promise.resolve(e);
+			}
+			return w || T ? Promise.resolve(null) : new Promise((e) => {
+				E = e;
+			});
+		},
+		overrun: () => T,
+		close: () => {
+			w = !0, A(0), _ === void 0 || b === 0 ? j() : k.reset(), P(null);
+		}
+	};
+}, x = async (e, t, n, r) => {
+	let a = r?.stallWarnAfterMs ?? v().stallWarnAfterMs, o = r?.warn ?? ((e, t) => {
+		d.warn(e, t);
+	});
+	for (;;) {
+		let r = await e.take();
+		if (r === null) {
+			t.end();
+			return;
+		}
+		let s = setTimeout(() => {
+			i(n), o(`subscription '${n}': the transport has not accepted a delivery for ${a}ms — the consumer is not acknowledging chunks. Every effect/rpc Chunk must be answered with { _tag: 'Ack', requestId }; the typed client does this itself, a hand-rolled socket client must. Updates coalesce behind the stall and are delivered once the socket accepts again.`, {
+				label: n,
+				tag: r._tag,
+				stallWarnAfterMs: a
+			});
+		}, a);
+		typeof s == "object" && s && "unref" in s && s.unref();
+		try {
+			await t.single(r);
+		} finally {
+			clearTimeout(s);
+		}
+	}
+};
+//#endregion
+export { f as DEFAULT_SOCKET_MAX_BUFFERED_BYTES, p as DEFAULT_SOCKET_OVERRUN_AFTER_MS, m as DEFAULT_SOCKET_OVERSIZED_EVENT_BYTES, h as DEFAULT_SOCKET_STALL_WARN_AFTER_MS, b as makeSubscriptionOutbox, x as pumpOutbox, v as reactiveSocketTunables, _ as setReactiveSocketTunables };

package/dist/subscriptionRegistry.js

@@ -0,0 +1,82 @@
+import { fingerprintFor as e } from "./fingerprint.js";
+//#region src/subscriptionRegistry.ts
+var t = class {
+	matcher;
+	byFingerprint = /* @__PURE__ */ new Map();
+	byClient = /* @__PURE__ */ new Map();
+	changeListeners = /* @__PURE__ */ new Set();
+	constructor(e) {
+		this.matcher = e;
+	}
+	onChange(e) {
+		return this.changeListeners.add(e), () => {
+			this.changeListeners.delete(e);
+		};
+	}
+	notifyChange() {
+		for (let e of this.changeListeners) try {
+			e();
+		} catch {}
+	}
+	subscribe(t, n, r, i) {
+		let a = e(n, r, i?.name), o = this.byFingerprint.get(a);
+		return o ? (o.subscribers.add(t), this.byClient.set(t, a), this.notifyChange(), {
+			fingerprint: a,
+			deduplicated: !0
+		}) : (this.byFingerprint.set(a, {
+			table: n,
+			predicate: r,
+			subscribers: /* @__PURE__ */ new Set([t]),
+			...i === void 0 ? {} : { usingIndex: i }
+		}), this.byClient.set(t, a), this.matcher.register({
+			id: a,
+			table: n,
+			predicate: r,
+			...i === void 0 ? {} : { usingIndex: i }
+		}), this.notifyChange(), {
+			fingerprint: a,
+			deduplicated: !1
+		});
+	}
+	unsubscribe(e) {
+		let t = this.byClient.get(e);
+		if (!t) return;
+		let n = this.byFingerprint.get(t);
+		n && (n.subscribers.delete(e), this.byClient.delete(e), n.subscribers.size === 0 && (this.matcher.unregister(t, n.table), this.byFingerprint.delete(t)), this.notifyChange());
+	}
+	notify(e) {
+		let t = this.matcher.match(e), n = [];
+		for (let e of t) {
+			let t = this.byFingerprint.get(e.subId);
+			if (t) for (let r of t.subscribers) n.push({
+				subscriberId: r,
+				fingerprint: e.subId,
+				oldMatched: e.oldMatched,
+				newMatched: e.newMatched
+			});
+		}
+		return n;
+	}
+	stats() {
+		let e = 0;
+		for (let t of this.byFingerprint.values()) e += t.subscribers.size;
+		return {
+			fingerprints: this.byFingerprint.size,
+			subscribers: e,
+			dedupRatio: e === 0 ? 1 : this.byFingerprint.size / e
+		};
+	}
+	snapshot() {
+		let e = [];
+		for (let [t, n] of this.byFingerprint) e.push({
+			fingerprint: t,
+			table: n.table,
+			predicate: n.predicate,
+			subscriberCount: n.subscribers.size,
+			...n.usingIndex === void 0 ? {} : { usingIndex: n.usingIndex }
+		});
+		return e;
+	}
+};
+//#endregion
+export { t as SubscriptionRegistry };

package/dist/subscriptionResume.js

@@ -0,0 +1,132 @@
+import { BoundedRing as e } from "@voltro/protocol";
+//#region src/subscriptionResume.ts
+var t = 6e4, n = 256, r = Symbol.for("@voltro/runtime:resume-tunables"), i = (e) => {
+	let t = globalThis;
+	t[r] = e;
+}, a = () => globalThis[r] ?? {
+	windowMs: 6e4,
+	maxDeltas: 256
+}, o = (e) => `${e.label}\u0000${e.inputKey}\u0000${e.subjectId}\u0000${e.tenantId}`, s = (e) => {
+	let t = (e) => {
+		if (Array.isArray(e)) return e.map(t);
+		if (typeof e == "object" && e) {
+			let n = Object.entries(e).sort(([e], [t]) => e.localeCompare(t));
+			for (let e = 0; e < n.length; e++) {
+				let r = n[e];
+				r[1] = t(r[1]);
+			}
+			return Object.fromEntries(n);
+		}
+		return e;
+	};
+	try {
+		return JSON.stringify(t(e)) ?? "undefined";
+	} catch {
+		return "uncanonical";
+	}
+}, c = Symbol.for("@voltro/runtime:resume-rings"), l = () => {
+	let e = globalThis;
+	return e[c] ??= /* @__PURE__ */ new Map();
+}, u = Symbol.for("@voltro/runtime:resume-cleanup"), d = 32, f = (e, t) => {
+	let n = l(), r = globalThis, i = r[u];
+	(i === void 0 || i.rings !== n) && (i = {
+		rings: n,
+		cursor: void 0
+	}, r[u] = i), i.cursor ??= n.entries();
+	for (let r = 0; r < d; r++) {
+		let r = i.cursor.next();
+		if (r.done) {
+			i.cursor = void 0;
+			break;
+		}
+		let [a, o] = r.value;
+		e - o.touchedAt > t && n.delete(a);
+	}
+}, p = (e, t, n) => {
+	let r = l(), i = r.get(e);
+	if (i !== void 0 && t - i.touchedAt > n) r.delete(e);
+	else return i;
+}, m = (e) => Number.isNaN(e) ? Infinity : Math.max(0, Math.floor(e)), h = (t, n) => {
+	if (n === t.capacity) return;
+	let r = Math.max(0, t.deltas.length - n);
+	r > 0 && (t.baseRevision = t.deltas.get(r - 1).revision);
+	let i = new e(n);
+	for (let e = r; e < t.deltas.length; e++) i.push(t.deltas.get(e));
+	t.deltas = i, t.capacity = n;
+}, g = (t, n, r = Date.now(), i = a()) => {
+	f(r, i.windowMs);
+	let s = l(), c = o(t);
+	if (n._tag === "error") {
+		s.delete(c);
+		return;
+	}
+	if (n._tag === "snapshot") {
+		let t = m(i.maxDeltas);
+		s.set(c, {
+			baseRevision: n.revision,
+			headRevision: n.revision,
+			deltas: new e(t),
+			capacity: t,
+			touchedAt: r
+		});
+		return;
+	}
+	let u = p(c, r, i.windowMs);
+	u !== void 0 && (n.revision <= u.headRevision ? s.delete(c) : (h(u, m(i.maxDeltas)), u.capacity === 0 ? u.baseRevision = n.revision : u.deltas.length === u.capacity && (u.baseRevision = u.deltas.get(0).revision), u.deltas.push({
+		revision: n.revision,
+		emittedAt: n.emittedAt,
+		patch: n.patch
+	}), u.headRevision = n.revision, u.touchedAt = r));
+}, _ = (e, t, n = Date.now(), r = a()) => {
+	f(n, r.windowMs);
+	let i = p(o(e), n, r.windowMs);
+	if (i === void 0 || t < i.baseRevision || t > i.headRevision) return { kind: "snapshot" };
+	let s = 0, c = i.deltas.length;
+	for (; s < c;) {
+		let e = s + Math.floor((c - s) / 2);
+		i.deltas.get(e).revision > t ? c = e : s = e + 1;
+	}
+	let l = [];
+	for (let e = s; e < i.deltas.length; e++) l.push(i.deltas.get(e));
+	return {
+		kind: "deltas",
+		deltas: l
+	};
+}, v = () => {
+	l().clear();
+	let e = globalThis;
+	delete e[u];
+}, y = Symbol.for("@voltro/runtime:resume-detached"), b = () => {
+	let e = globalThis;
+	return e[y] ??= /* @__PURE__ */ new Map();
+}, x = (e, t, n = a(), r = Date.now) => {
+	let i = o(e), s = l(), c = b().get(i);
+	c !== void 0 && (clearTimeout(c.timer), c.unsubscribe(), b().delete(i));
+	let u = {
+		sink: t.sink,
+		unsubscribe: t.unsubscribe,
+		dead: !1,
+		timer: setTimeout(() => {
+			b().delete(i), s.delete(i), t.unsubscribe();
+		}, n.windowMs)
+	};
+	typeof u.timer.unref == "function" && u.timer.unref(), t.sink.current = (t) => {
+		g(e, t, r(), n), t._tag === "error" && (u.dead = !0);
+	}, b().set(i, u);
+}, S = (e, t, n = Date.now(), r = a()) => {
+	let i = o(e), s = b().get(i);
+	if (s === void 0) return;
+	clearTimeout(s.timer), b().delete(i);
+	let c = s.dead ? { kind: "snapshot" } : _(e, t, n, r);
+	if (c.kind !== "deltas" || c.deltas.length === 0) l().delete(i), s.unsubscribe();
+	else return {
+		deltas: c.deltas,
+		sink: s.sink,
+		unsubscribe: s.unsubscribe
+	};
+}, C = () => {
+	for (let e of b().values()) clearTimeout(e.timer), e.unsubscribe();
+	b().clear();
+};
+//#endregion
+export { n as DEFAULT_RESUME_MAX_DELTAS, t as DEFAULT_RESUME_WINDOW_MS, S as adoptDetached, _ as answerResume, s as canonicalInputKey, x as detachForResume, g as recordForResume, C as resetDetachedForTest, v as resetResumeRingsForTest, o as resumeKeyOf, a as resumeTunables, i as setResumeTunables };

package/dist/subscriptionSocketMetrics.js

@@ -0,0 +1,65 @@
+//#region src/subscriptionSocketMetrics.ts
+var e = Symbol.for("@voltro/runtime/subscriptionSocketMetrics"), t = () => {
+	let t = globalThis;
+	return t[e] ??= {
+		bufferedBytes: /* @__PURE__ */ new Map(),
+		bufferOwners: /* @__PURE__ */ new WeakMap(),
+		coalescedTotal: /* @__PURE__ */ new Map(),
+		overrunTotal: /* @__PURE__ */ new Map(),
+		oversizedTotal: /* @__PURE__ */ new Map(),
+		stalledTotal: /* @__PURE__ */ new Map()
+	};
+}, n = (e, t, n = 1) => {
+	e.set(t, (e.get(t) ?? 0) + n);
+}, r = (e, n) => {
+	let r = t();
+	n === 0 ? r.bufferedBytes.delete(e) : r.bufferedBytes.set(e, n);
+}, i = (e) => {
+	let n = {};
+	return (r) => {
+		let i = t(), a = i.bufferOwners.get(n) ?? 0;
+		r === 0 ? i.bufferOwners.delete(n) : i.bufferOwners.set(n, r);
+		let o = (i.bufferedBytes.get(e) ?? 0) + r - a;
+		o === 0 ? i.bufferedBytes.delete(e) : i.bufferedBytes.set(e, o);
+	};
+}, a = (e, r) => {
+	n(t().coalescedTotal, e, r);
+}, o = (e) => {
+	n(t().overrunTotal, e);
+}, s = (e) => {
+	n(t().oversizedTotal, e);
+}, c = (e) => {
+	n(t().stalledTotal, e);
+}, l = (e) => {
+	let t = 0, n = {};
+	for (let [r, i] of e) t += i, n[r] = i;
+	return {
+		total: t,
+		byLabel: n
+	};
+}, u = () => {
+	let e = t();
+	return {
+		bufferedBytes: l(e.bufferedBytes),
+		coalescedTotal: l(e.coalescedTotal),
+		overrunTotal: l(e.overrunTotal),
+		oversizedTotal: l(e.oversizedTotal),
+		stalledTotal: l(e.stalledTotal)
+	};
+}, d = () => {
+	let e = t(), n = [], r = (e, t, r, i) => {
+		for (let [a, o] of r) n.push({
+			name: e,
+			type: t,
+			labels: { query: a },
+			value: o,
+			description: i
+		});
+	};
+	return r("voltro_subscription_buffered_bytes", "gauge", e.bufferedBytes, "Estimated pending bytes a blocked subscription consumer is behind (0 rows omitted)."), r("voltro_subscription_coalesced_total", "counter", e.coalescedTotal, "Subscription events collapsed into a newer state while the consumer was blocked."), r("voltro_subscription_overrun_total", "counter", e.overrunTotal, "Subscriptions terminally closed with SubscriptionOverrun (consumer persistently over the buffer threshold)."), r("voltro_subscription_oversized_total", "counter", e.oversizedTotal, "Subscription events exceeding the oversized-event WARN threshold (telemetry, not a cap)."), r("voltro_subscription_stalled_total", "counter", e.stalledTotal, "Subscription deliveries the transport did not accept within reactive.socket.stallWarnAfterMs (the consumer is not acknowledging chunks)."), n;
+}, f = () => {
+	let e = t();
+	e.bufferOwners = /* @__PURE__ */ new WeakMap(), e.bufferedBytes.clear(), e.coalescedTotal.clear(), e.overrunTotal.clear(), e.oversizedTotal.clear(), e.stalledTotal.clear();
+};
+//#endregion
+export { i as createSubscriptionBufferMetric, a as recordCoalesced, o as recordOverrun, s as recordOversized, c as recordStalled, f as resetSubscriptionSocketMetrics, r as setBufferedBytes, d as subscriptionSocketMetricSamples, u as subscriptionSocketMetricsSnapshot };

package/dist/systemSubject.js

@@ -0,0 +1,5 @@
+import { systemSubject as e } from "@voltro/protocol";
+//#region src/systemSubject.ts
+var t = e("system");
+//#endregion
+export { t as SYSTEM_SUBJECT };

package/dist/tenantScope.js

@@ -0,0 +1,23 @@
+import { and as e, eq as t, isNull as n } from "@voltro/database";
+//#region src/tenantScope.ts
+var r = (n, r, i) => {
+	if (n.crossTenant || !r.has(n.table) || i == null) return n;
+	let a = t("tenantId", i);
+	return {
+		...n,
+		predicate: n.predicate ? e(n.predicate, a) : a
+	};
+}, i = (e, t, n) => n === "" && !e.crossTenant && t.has(e.table), a = (e) => e?.type === "user" && e.tenantId === "", o = (t, r) => {
+	if (t.includeDeleted || !r.has(t.table)) return t;
+	let i = n("deletedAt");
+	return {
+		...t,
+		predicate: t.predicate ? e(t.predicate, i) : i
+	};
+}, s = (e) => (t, n) => {
+	e.observe?.beforeScope?.({ ...t }, n);
+	let i = o(r(t, e.tenantScopedTables, n.tenantId), e.softDeleteScopedTables);
+	return e.observe?.afterScope?.({ ...i }), i;
+};
+//#endregion
+export { o as applySoftDeleteScope, r as applyTenantScope, i as isEmptyTenantScopedRead, a as isOrglessUserSubject, s as makeQueryFinalizer };