@voltro/runtime 0.85.0 → 0.87.0

package/dist/replicaObservations.js

@@ -0,0 +1,121 @@
+import { createLogger as e } from "@voltro/logger";
+import { processIdentity as t } from "@voltro/protocol/identity";
+//#region src/replicaObservations.ts
+var n = e({ scope: "voltro:replica-observations" }), r = "_voltro_replica_observations", i = (e) => e instanceof Date ? e.getTime() : typeof e == "number" ? e : NaN, a = /* @__PURE__ */ new Set(), o = () => {
+	a.clear();
+}, s = async (e, i, o) => {
+	let s = t(), c = {
+		replicaId: s.replicaId,
+		startedAt: new Date(s.startedAt),
+		version: s.version ?? null,
+		kind: i,
+		payload: JSON.stringify(o),
+		reachableAt: s.reachable ? s.reachableAt ?? null : null
+	};
+	try {
+		await e.upsert(r, {
+			...c,
+			writtenAt: /* @__PURE__ */ new Date()
+		}, { conflictColumns: ["replicaId", "kind"] });
+	} catch (e) {
+		let t = {
+			kind: i,
+			error: String(e)
+		};
+		a.has(i) ? n.debug("could not record this replica’s observation", t) : (a.add(i), n.warn("could not record this replica’s observation — fleet views will report this replica as stale for as long as this keeps failing", t));
+	}
+}, c = async (e, t, n = Date.now()) => {
+	try {
+		return (await e.query({
+			table: r,
+			predicate: {
+				column: "kind",
+				op: "eq",
+				value: t
+			},
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: void 0
+		})).map((e) => {
+			let r = i(e.writtenAt);
+			return {
+				replicaId: String(e.replicaId ?? ""),
+				startedAt: i(e.startedAt),
+				version: e.version === null || e.version === void 0 ? void 0 : String(e.version),
+				kind: t,
+				payload: u(e.payload),
+				reachableAt: e.reachableAt === null || e.reachableAt === void 0 ? void 0 : String(e.reachableAt),
+				writtenAt: r,
+				ageMs: Number.isNaN(r) ? NaN : Math.max(0, n - r)
+			};
+		});
+	} catch (e) {
+		throw new l(String(e));
+	}
+}, l = class extends Error {
+	detail;
+	_tag = "ObservationsUnavailable";
+	constructor(e) {
+		super("the replica-observation table could not be read"), this.detail = e;
+	}
+}, u = (e) => {
+	if (typeof e == "string") try {
+		return JSON.parse(e);
+	} catch {
+		return;
+	}
+}, d = async (e, t) => {
+	try {
+		await e.deleteMany(r, { where: {
+			column: "replicaId",
+			op: "eq",
+			value: t
+		} });
+	} catch {}
+}, f = 12e4, p = (e, t, n = f) => {
+	let r = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		if (t.replicaId === "") continue;
+		let e = r.get(t.replicaId);
+		(e === void 0 || t.startedAt > e.startedAt || t.startedAt === e.startedAt && t.writtenAt > e.writtenAt) && r.set(t.replicaId, t);
+	}
+	let i = [...r.values()].filter((e) => e.payload !== void 0).map((e) => ({
+		replicaId: e.replicaId,
+		version: e.version,
+		ageMs: e.ageMs,
+		reachableAt: e.reachableAt,
+		payload: e.payload
+	})).sort((e, t) => e.replicaId.localeCompare(t.replicaId)), a = new Set(t.map((e) => e.instanceId.split("@")[0] ?? e.instanceId)), o = a.size > 0, s = (e) => !a.has(e.replicaId) && Number.isFinite(e.ageMs) && e.ageMs > n, c = o ? [] : i, l = [], u = [], d = /* @__PURE__ */ new Set(), p = {};
+	for (let e of i) {
+		if (o && s(e)) {
+			l.push({
+				replicaId: e.replicaId,
+				ageMs: e.ageMs,
+				version: e.version
+			});
+			continue;
+		}
+		o && c.push(e), d.add(e.replicaId), Number.isFinite(e.ageMs) && e.ageMs > n && u.push({
+			replicaId: e.replicaId,
+			ageMs: e.ageMs
+		});
+		let t = e.version ?? "unknown";
+		p[t] = (p[t] ?? 0) + 1;
+	}
+	let m = [];
+	for (let e of a) d.has(e) || m.push(e);
+	m.sort();
+	let h = Object.keys(p).length > 1 ? p : void 0;
+	return {
+		byReplica: c,
+		missing: m,
+		responded: c.length,
+		expected: Math.max(a.size, c.length),
+		stale: u,
+		departed: l,
+		...h === void 0 ? { versions: void 0 } : { versions: h }
+	};
+};
+//#endregion
+export { f as DEFAULT_STALE_AFTER_MS, l as ObservationsUnavailable, r as REPLICA_OBSERVATIONS_TABLE, d as forgetReplicaObservations, p as mergeFleetObservations, c as readReplicaObservations, o as resetReplicaObservationWarnings, s as writeReplicaObservation };

package/dist/replicaSelection.js

@@ -0,0 +1,32 @@
+//#region src/replicaSelection.ts
+var e = (e = {}) => {
+	let t = e.random ?? Math.random, n = /* @__PURE__ */ new Map(), r = (e) => n.get(e) ?? 0;
+	return {
+		pick(e) {
+			if (e.length === 0) return null;
+			if (e.length === 1) return e[0];
+			let n = Math.floor(t() * e.length), i = Math.floor(t() * e.length);
+			i === n && (i = (i + 1) % e.length);
+			let a = e[n], o = e[i];
+			return r(a) <= r(o) ? a : o;
+		},
+		beforeQuery(e) {
+			n.set(e, r(e) + 1);
+		},
+		afterQuery(e) {
+			let t = r(e) - 1;
+			t <= 0 ? n.delete(e) : n.set(e, t);
+		},
+		loadSnapshot() {
+			let e = Array(n.size), t = 0;
+			return n.forEach((n, r) => {
+				e[t++] = {
+					replica: r,
+					inFlight: n
+				};
+			}), e;
+		}
+	};
+};
+//#endregion
+export { e as powerOfTwoSelector };

package/dist/replicatedDataStore.js

@@ -0,0 +1,257 @@
+import { powerOfTwoSelector as e } from "./replicaSelection.js";
+import { replicaHealth as t } from "./replicaHealth.js";
+import { memoryRywPositionStore as n } from "./rywPositionStore.js";
+import { Effect as r, Fiber as i } from "effect";
+import { createLogger as a } from "@voltro/logger";
+import { AsyncLocalStorage as o } from "node:async_hooks";
+//#region src/replicatedDataStore.ts
+var s = a({ scope: "voltro:replication" }), c = new o(), l = (e, t) => c.run(e, t), u = (e, t) => r.flatMap(r.context(), (n) => r.callback((a) => {
+	let o = l(e, () => r.runForkWith(n)(t));
+	return o.addObserver((e) => {
+		a(e);
+	}), r.asVoid(i.interrupt(o));
+})), d = () => c.getStore(), f = class {
+	integrityQuery;
+	primary;
+	replicas;
+	adapter;
+	policy;
+	rywTtlMs;
+	rywMaxWaitMs;
+	rywStore;
+	selector;
+	health;
+	recordRouting;
+	now;
+	closing;
+	constructor(r) {
+		this.primary = r.primary, r.primary.integrityQuery !== void 0 && (this.integrityQuery = r.primary.integrityQuery.bind(r.primary)), this.replicas = r.replicas, this.adapter = r.replicationAdapter, this.policy = r.rywPolicy ?? "fallback", this.rywTtlMs = r.rywTtlMs ?? 3e4, this.rywMaxWaitMs = r.rywMaxWaitMs ?? 500, this.now = r.now ?? Date.now, this.rywStore = r.rywStore ?? n({ now: this.now }), this.selector = r.replicaSelector ?? e(), this.health = r.replicaHealth ?? t({ now: this.now }), r.recordRouting !== void 0 && (this.recordRouting = r.recordRouting);
+	}
+	async query(e) {
+		let t = c.getStore(), n = t?.subjectKey ?? "anon:bg";
+		if (t?.forcePrimary === !0) return this.emitRouting({
+			target: "primary",
+			replicaIndex: null,
+			policy: this.policy,
+			subjectKey: n,
+			hadRywPosition: !1,
+			waitMs: 0,
+			fallbackReason: "transactional-scope"
+		}), this.primary.query(e);
+		if (this.replicas.length === 0) return this.emitRouting({
+			target: "primary",
+			replicaIndex: null,
+			policy: this.policy,
+			subjectKey: n,
+			hadRywPosition: !1,
+			waitMs: 0,
+			fallbackReason: "no-replicas"
+		}), this.primary.query(e);
+		let r = this.rywStore.get(n), i = r !== void 0;
+		return this.policy === "off" ? this.routeToReplica(e, n, i) : this.policy === "fallback" && i ? (this.emitRouting({
+			target: "primary",
+			replicaIndex: null,
+			policy: this.policy,
+			subjectKey: n,
+			hadRywPosition: !0,
+			waitMs: 0,
+			fallbackReason: "ryw-pinned-to-primary"
+		}), this.primary.query(e)) : this.policy === "wait" && i ? this.routeWaitMode(e, n, r.position) : this.routeToReplica(e, n, i);
+	}
+	async routeToReplica(e, t, n) {
+		let r = this.replicas.filter((e) => this.health.isHealthy(e));
+		if (r.length === 0) return this.emitRouting({
+			target: "primary",
+			replicaIndex: null,
+			policy: this.policy,
+			subjectKey: t,
+			hadRywPosition: n,
+			waitMs: 0,
+			fallbackReason: "no-healthy-replicas"
+		}), this.primary.query(e);
+		let i = this.selector.pick(r);
+		if (i === null) return this.emitRouting({
+			target: "primary",
+			replicaIndex: null,
+			policy: this.policy,
+			subjectKey: t,
+			hadRywPosition: n,
+			waitMs: 0,
+			fallbackReason: "no-healthy-replicas"
+		}), this.primary.query(e);
+		let a = this.replicas.indexOf(i);
+		this.selector.beforeQuery(i);
+		try {
+			let r = await i.query(e);
+			return this.health.reportSuccess(i), this.emitRouting({
+				target: "replica",
+				replicaIndex: a,
+				policy: this.policy,
+				subjectKey: t,
+				hadRywPosition: n,
+				waitMs: 0
+			}), r;
+		} catch (r) {
+			return this.health.reportFailure(i, String(r)), s.warn("replica query failed; falling back to primary", {
+				idx: a,
+				err: r
+			}), this.emitRouting({
+				target: "primary",
+				replicaIndex: a,
+				policy: this.policy,
+				subjectKey: t,
+				hadRywPosition: n,
+				waitMs: 0,
+				fallbackReason: "replica-query-failed"
+			}), this.primary.query(e);
+		} finally {
+			this.selector.afterQuery(i);
+		}
+	}
+	async routeWaitMode(e, t, n) {
+		let r = this.replicas.filter((e) => this.health.isHealthy(e));
+		if (r.length === 0) return this.emitRouting({
+			target: "primary",
+			replicaIndex: null,
+			policy: "wait",
+			subjectKey: t,
+			hadRywPosition: !0,
+			waitMs: 0,
+			fallbackReason: "no-healthy-replicas"
+		}), this.primary.query(e);
+		let i = this.selector.pick(r), a = this.replicas.indexOf(i), o = this.now(), s = o + this.rywMaxWaitMs;
+		for (;;) {
+			let r = await this.adapter.probeReplicaPosition(i);
+			if (this.adapter.compare(n, r) === "caught-up") {
+				let n = this.now() - o;
+				this.selector.beforeQuery(i);
+				try {
+					let r = await i.query(e);
+					return this.health.reportSuccess(i), this.emitRouting({
+						target: "replica",
+						replicaIndex: a,
+						policy: "wait",
+						subjectKey: t,
+						hadRywPosition: !0,
+						waitMs: n
+					}), r;
+				} catch (r) {
+					return this.health.reportFailure(i, String(r)), this.emitRouting({
+						target: "primary",
+						replicaIndex: a,
+						policy: "wait",
+						subjectKey: t,
+						hadRywPosition: !0,
+						waitMs: n,
+						fallbackReason: "replica-query-failed"
+					}), this.primary.query(e);
+				} finally {
+					this.selector.afterQuery(i);
+				}
+			}
+			if (this.now() >= s) {
+				let n = this.now() - o;
+				return this.emitRouting({
+					target: "primary",
+					replicaIndex: a,
+					policy: "wait",
+					subjectKey: t,
+					hadRywPosition: !0,
+					waitMs: n,
+					fallbackReason: "wait-timeout"
+				}), this.primary.query(e);
+			}
+			await p(10);
+		}
+	}
+	async insert(e, t) {
+		let n = await this.primary.insert(e, t);
+		return await this.stampPostWrite(), n;
+	}
+	async insertMany(e, t, n) {
+		let r = await this.primary.insertMany(e, t, n);
+		return await this.stampPostWrite(), r;
+	}
+	async patchJson(e, t, n, r, i) {
+		let a = await this.primary.patchJson(e, t, n, r, i);
+		return await this.stampPostWrite(), a;
+	}
+	async update(e, t, n) {
+		let r = await this.primary.update(e, t, n);
+		return await this.stampPostWrite(), r;
+	}
+	async delete(e, t) {
+		let n = await this.primary.delete(e, t);
+		return await this.stampPostWrite(), n;
+	}
+	async updateMany(e, t, n) {
+		let r = await this.primary.updateMany(e, t, n);
+		return await this.stampPostWrite(), r;
+	}
+	async deleteMany(e, t) {
+		let n = await this.primary.deleteMany(e, t);
+		return await this.stampPostWrite(), n;
+	}
+	async upsert(e, t, n) {
+		let r = await this.primary.upsert(e, t, n);
+		return await this.stampPostWrite(), r;
+	}
+	async insertIgnore(e, t, n) {
+		let r = await this.primary.insertIgnore(e, t, n);
+		return await this.stampPostWrite(), r;
+	}
+	async insertIgnoreWithOutcome(e, t, n) {
+		let r = await this.primary.insertIgnoreWithOutcome(e, t, n);
+		return await this.stampPostWrite(), r;
+	}
+	async transactional(e) {
+		let t = await l({
+			subjectKey: c.getStore()?.subjectKey ?? "anon:bg",
+			forcePrimary: !0
+		}, () => this.primary.transactional(e));
+		return await this.stampPostWrite(), t;
+	}
+	onChange(e) {
+		return this.primary.onChange(e);
+	}
+	injectExternalChange(e) {
+		this.primary.injectExternalChange(e);
+	}
+	get changeScope() {
+		return this.primary.changeScope ?? "local";
+	}
+	close(e) {
+		return this.closing ??= (async () => {
+			let t = [];
+			try {
+				await this.rywStore.close?.();
+			} catch (e) {
+				t.push(e);
+			}
+			for (let n of /* @__PURE__ */ new Set([this.primary, ...this.replicas])) try {
+				await n.close?.(e);
+			} catch (e) {
+				t.push(e);
+			}
+			if (t.length > 0) throw AggregateError(t, "Read replica shutdown failed");
+		})();
+	}
+	async stampPostWrite() {
+		if (this.replicas.length === 0) return;
+		let e = c.getStore()?.subjectKey ?? "anon:bg";
+		try {
+			let t = await this.adapter.capturePrimaryPosition(this.primary);
+			this.rywStore.set(e, {
+				position: t,
+				expiresAt: this.now() + this.rywTtlMs
+			});
+		} catch (e) {
+			s.warn("failed to capture primary position; RYW skipped", { err: e });
+		}
+	}
+	emitRouting(e) {
+		this.recordRouting?.(e);
+	}
+}, p = (e) => new Promise((t) => setTimeout(t, e));
+//#endregion
+export { f as ReplicatedDataStore, d as currentRoutingContext, l as runWithRoutingContext, u as runWithRoutingContextEffect };

package/dist/requestLoader.js

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage as e } from "node:async_hooks";
+//#region src/requestLoader.ts
+var t = new e(), n = (e) => {
+	t.enterWith(e);
+}, r = () => t.getStore(), i = (e, n) => t.run(e, n);
+//#endregion
+export { r as currentRequestLoader, n as enterRequestLoader, i as runWithRequestLoader };

package/dist/resumeCensus.js

@@ -0,0 +1,28 @@
+import { createLogger as e } from "@voltro/logger";
+//#region src/resumeCensus.ts
+var t = Symbol.for("@voltro/runtime/resumeCensus"), n = globalThis, r = n[t] ?? (n[t] = { byLabel: /* @__PURE__ */ new Map() }), i = e({ scope: "voltro:resume" }), a = (e, t) => {
+	let n = e.startsWith("subscription.") ? e.slice(13) : e, a = r.byLabel.get(n) ?? {
+		resumable: 0,
+		excluded: /* @__PURE__ */ new Map(),
+		logged: /* @__PURE__ */ new Set()
+	};
+	t === !0 ? a.resumable += 1 : a.excluded.set(t, (a.excluded.get(t) ?? 0) + 1), r.byLabel.set(n, a);
+	let o = t === !0 ? "resumable" : t;
+	a.logged.has(o) || (a.logged.add(o), i.debug("subscription resume decided", {
+		query: n,
+		resumable: t === !0,
+		...t === !0 ? {} : { reason: t }
+	}));
+}, o = () => {
+	let e = [];
+	for (let [t, n] of r.byLabel) e.push({
+		label: t,
+		resumable: n.resumable,
+		excluded: Object.fromEntries(n.excluded)
+	});
+	return e;
+}, s = () => {
+	r.byLabel.clear();
+};
+//#endregion
+export { a as noteResumeVerdict, s as resetResumeCensus, o as resumeCensus };

package/dist/revalidation.js

@@ -0,0 +1,22 @@
+//#region src/revalidation.ts
+var e = Symbol.for("@voltro/runtime/revalidation:publisher"), t = () => {
+	let t = globalThis;
+	return t[e] ??= { publisher: null };
+}, n = (e) => {
+	t().publisher = e;
+}, r = (e) => {
+	let n = t().publisher;
+	return n === null ? Promise.reject(/* @__PURE__ */ Error("revalidatePath/revalidateTable/revalidateTag: no revalidation publisher is wired in this process. These functions work inside a running Voltro api process (`voltro dev` / `voltro serve`) — the boot path registers the transport. If you see this inside one, the boot wiring is broken; report it.")) : n(e);
+}, i = (e, t = {}) => r({
+	kind: "path",
+	value: e,
+	...t.tenant === void 0 ? {} : { tenant: t.tenant }
+}), a = (e) => r({
+	kind: "table",
+	value: e
+}), o = (e) => r({
+	kind: "tag",
+	value: e
+});
+//#endregion
+export { i as revalidatePath, a as revalidateTable, o as revalidateTag, n as setRevalidationPublisher };

package/dist/rowFilter.js

@@ -0,0 +1,82 @@
+import { restrictingReadsEffect as e } from "./readRecorder.js";
+import { mapSetReadScopes as t } from "./setReadScopes.js";
+import { Effect as n, Schedule as r, Schema as i } from "effect";
+import { and as a } from "@voltro/database";
+import { currentSubjectAuthority as o, isMachineSubject as s } from "@voltro/protocol";
+import { createLogger as c } from "@voltro/logger";
+//#region src/rowFilter.ts
+var l = class extends i.TaggedError()("RowFilterUnavailable", { cause: i.String }) {}, u = class extends i.TaggedError()("RowFilterDeclarationViolated", {
+	table: i.String,
+	declared: i.Array(i.String)
+}) {
+	get message() {
+		return `row filter narrowed '${this.table}', which its declaration does not name (declared: ${this.declared.join(", ") || "none"})`;
+	}
+}, d = r.max([r.exponential("20 millis"), r.recurs(2)]), f = Symbol.for("@voltro/runtime/rowFilter"), p = globalThis, m = p[f] ?? (p[f] = {}), h = (e) => {
+	m.filter = e;
+}, g = () => m.filter, _ = () => m.filter !== void 0, v = () => void 0, y = c({ scope: "voltro:row-filter" }), b = /* @__PURE__ */ new Set(), x = (e, t) => {
+	b.has(e) || (b.add(e), y.info("row filter: RESOLVED on a live read path", {
+		arm: e,
+		...t === void 0 ? {} : { constrains: t },
+		armsSeen: [...b].sort().join(",")
+	}));
+}, S = () => [...b].sort(), C = () => {
+	b.clear();
+}, w = (e, t) => n.tap(T(g(), e, t), () => n.sync(() => {
+	let e = g();
+	e !== void 0 && x("request", e.tables?.length);
+})), T = (t, r, i) => {
+	if (t === void 0 || s(r)) return n.succeed(v);
+	let a = t.retry ?? d, o = e(t.load(r)), c = a === !1 ? o : n.retry(o, a), f = t.tables, p = f === void 0 ? void 0 : new Set(f);
+	return c.pipe(n.map((e) => p === void 0 ? (n) => t.predicate(e, n) : (n) => {
+		let r = t.predicate(e, n);
+		if (r !== void 0 && !p.has(n)) throw new u({
+			table: n,
+			declared: f ?? []
+		});
+		return r;
+	}), n.catch((e) => n.suspend(() => (i?.(e), t.onLoadError === "deny" ? n.succeed(E) : n.fail(new l({ cause: String(e) }))))));
+}, E = () => ({
+	column: "id",
+	op: "isNull"
+}), D = (e) => {
+	let t = g();
+	if (t === void 0) return !1;
+	let n = t.tables;
+	if (n === void 0) return !0;
+	let r = new Set(n);
+	return e.some((e) => r.has(e));
+}, O = (e, t, n) => {
+	let r = e(t);
+	return r === void 0 ? n : n ? a(n, r) : r;
+}, k = (e, n) => {
+	let r = n;
+	if (r.setOp !== void 0) {
+		let i = {
+			...r,
+			table: n.table,
+			predicate: n.predicate,
+			order: r.order ?? [],
+			projection: r.projection,
+			take: r.take,
+			skip: r.skip
+		}, a = t(i, (t) => k(e, t));
+		return {
+			...n,
+			setOp: a.setOp
+		};
+	}
+	let i = O(e, n.table, n.predicate);
+	return i === n.predicate ? n : {
+		...n,
+		predicate: i
+	};
+}, A = (e, t) => {
+	if (g() !== void 0) return async () => {
+		let r = await n.runPromise(n.result(w(o(e), t)));
+		if (r._tag === "Failure") throw r.failure;
+		return r.success;
+	};
+};
+//#endregion
+export { d as DEFAULT_ROW_FILTER_RETRY, v as NO_ROW_FILTER, u as RowFilterDeclarationViolated, l as RowFilterUnavailable, O as applyRowFilter, k as applyRowFilterToDescriptor, g as getRowFilter, A as makeDefaultRefilter, x as noteRowFilterResolved, C as resetRowFilterResolvedArms, w as resolveRowFilterScope, T as resolveRowFilterScopeFor, D as rowFilterMayNarrow, _ as rowFilterRegistered, S as rowFilterResolvedArms, h as setRowFilter };

package/dist/rowStateBytes.js

@@ -0,0 +1,45 @@
+//#region src/rowStateBytes.ts
+var e = (t, n) => {
+	if (typeof t != "object" || !t) return typeof t != "bigint";
+	if (n.has(t)) return !1;
+	let r = Object.getPrototypeOf(t);
+	if (r !== Object.prototype && r !== null && r !== Array.prototype || "toJSON" in t) return !1;
+	n.add(t);
+	try {
+		for (let r of Object.values(Object.getOwnPropertyDescriptors(t))) if (r.enumerable && (!("value" in r) || !e(r.value, n))) return !1;
+		return !0;
+	} finally {
+		n.delete(t);
+	}
+}, t = () => {
+	let t = /* @__PURE__ */ new WeakMap();
+	return {
+		reset: () => {
+			t = /* @__PURE__ */ new WeakMap();
+		},
+		estimate: (n, r, i = !1) => {
+			if (!Array.isArray(n) || Object.getPrototypeOf(n) !== Array.prototype || "toJSON" in n) return r(n);
+			let a = 2 + Math.max(0, n.length - 1);
+			for (let o = 0; o < n.length; o++) {
+				let s = i ? void 0 : Object.getOwnPropertyDescriptor(n, String(o));
+				if (!i && (s === void 0 || !("value" in s))) return r(n);
+				let c = i ? n[o] : s.value;
+				if (typeof c != "object" || !c) return r(n);
+				let l = t.get(c);
+				if (l === void 0) {
+					try {
+						l = e(c, /* @__PURE__ */ new Set()) ? JSON.stringify(c).length : null;
+					} catch {
+						l = null;
+					}
+					t.set(c, l);
+				}
+				if (l === null) return r(n);
+				a += l;
+			}
+			return a;
+		}
+	};
+};
+//#endregion
+export { t as createRowStateByteEstimator };

package/dist/rpcBodyCap.js

@@ -0,0 +1,63 @@
+import { Effect as e, Stream as t } from "effect";
+import { HttpServerError as n, UrlParams as r } from "effect/http";
+//#region src/rpcBodyCap.ts
+var i = (t, n) => e.callback((r) => {
+	let i = [], a = 0, o = !1, s = () => {
+		t.off("data", l), t.off("end", u), t.off("error", d), t.off("aborted", d);
+	}, c = (t) => {
+		o || (o = !0, s(), r(e.succeed(t)));
+	};
+	function l(e) {
+		a += e.length, a > n ? (i.length = 0, c({
+			_tag: "too-large",
+			received: a
+		}), t.resume()) : i.push(e);
+	}
+	function u() {
+		c({
+			_tag: "ok",
+			bytes: i.length === 1 ? i[0] : Buffer.concat(i)
+		});
+	}
+	function d() {
+		c({ _tag: "aborted" });
+	}
+	return t.on("data", l), t.once("end", u), t.once("error", d), t.once("aborted", d), e.sync(() => {
+		o = !0, s();
+	});
+}), a = (i, a) => {
+	let o = Object.create(i), s = Buffer.from(a.buffer, a.byteOffset, a.byteLength).toString("utf8"), c = (e) => new n.HttpServerError({ reason: new n.RequestParseError({
+		request: o,
+		cause: e
+	}) }), l = a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength);
+	return Object.defineProperties(o, {
+		text: {
+			get: () => e.succeed(s),
+			configurable: !0
+		},
+		json: {
+			get: () => e.try({
+				try: () => s === "" ? null : JSON.parse(s),
+				catch: c
+			}),
+			configurable: !0
+		},
+		urlParamsBody: {
+			get: () => e.try({
+				try: () => r.fromInput(new URLSearchParams(s)),
+				catch: c
+			}),
+			configurable: !0
+		},
+		arrayBuffer: {
+			get: () => e.succeed(l),
+			configurable: !0
+		},
+		stream: {
+			get: () => t.succeed(a),
+			configurable: !0
+		}
+	}), o;
+};
+//#endregion
+export { i as readCappedBody, a as withBufferedBody };