@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/room.js

@@ -0,0 +1,284 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { captureRoomWorldHooks as t } from "./worldRoomHooks.js";
+import { retainRoomPolicyOrigin as n } from "./roomPoolRuntimeDefaults.js";
+import { roomAuthoringStrategy as r } from "./roomAuthoringStrategy.js";
+import { captureLockstepRoomDefinition as i } from "./lockstepDefinition.js";
+import { defaultRoomSpectatorPolicy as a } from "./spectatorPolicy.js";
+//#region src/room.ts
+var o = Symbol.for("@voltro/rooms/fieldId"), s = Symbol.for("@voltro/rooms/quantization"), c = Symbol.for("@voltro/rooms/interpolation"), l = Symbol.for("@voltro/rooms/transform"), u = Symbol.for("@voltro/rooms/nonAuthoritative"), d = Symbol.for("@voltro/rooms/precision");
+function f(t) {
+	throw new e({
+		room: "transform",
+		detail: t
+	});
+}
+var p = (e, t) => Number.isFinite(e) ? e : f(`${t} must be finite`), m = (e, t) => p(e, t) > 0 ? e : f(`${t} must be positive`), h = (e) => (t) => ((!Number.isSafeInteger(e) || e < 1 || e > 2147483647) && f("fieldId must be an integer between 1 and 2147483647"), t.annotate({ [o]: e })), g = () => (e) => e.annotate({ [u]: !0 }), _ = (e) => {
+	if (p(e.min, "min"), p(e.max, "max"), e.max <= e.min && f("max must exceed min"), e.bits !== void 0 && e.step !== void 0 && f("Choose bits or step, not both"), e.bits !== void 0) return (!Number.isSafeInteger(e.bits) || e.bits < 1 || e.bits > 32) && f("bits must be between 1 and 32"), m((e.max - e.min) / (2 ** e.bits - 1), "quantization step");
+	let t = m(e.step ?? 1, "step");
+	return (e.max - e.min) / t > 2 ** 53 - 1 && f("Quantized range exceeds safe integer precision"), t;
+}, v = (e) => (t) => (_(e), t.annotate({ [s]: Object.freeze({ ...e }) })), y = (e = "linear") => (t) => t.annotate({ [c]: e }), b = (e) => (t) => t.annotate({ [d]: e }), x = (e, t) => {
+	let n = _(t);
+	return Math.max(0, Math.min(Math.round((t.max - t.min) / n), Math.round((p(e, "value") - t.min) / n)));
+}, S = (e, t) => {
+	let n = _(t), r = Math.round((t.max - t.min) / n);
+	return (!Number.isSafeInteger(e) || e < 0 || e > r) && f("Quantized integer is outside its declared range"), Math.min(t.max, t.min + e * n);
+}, C = 16, w = 2048, T = (t, n, r) => {
+	let i = (n) => {
+		throw new e({
+			room: t,
+			detail: n
+		});
+	};
+	if (!n || typeof n != "object" || Array.isArray(n) || Object.getPrototypeOf(n) !== Object.prototype) return i(`${r} must be a plain object`);
+	let a = Object.entries(n).sort(([e], [t]) => e < t ? -1 : +(e > t));
+	a.length > C && i(`${r} has too many keys`);
+	for (let [e, t] of a) (!e || e.length > 64) && i(`${r} keys are 1 to 64 characters`), t === null || typeof t == "boolean" || typeof t == "string" && t.length <= 256 || typeof t == "number" && Number.isFinite(t) || i(`${r} values are short strings, finite numbers, booleans or null`);
+	let o = Object.fromEntries(a);
+	return new TextEncoder().encode(JSON.stringify(o)).byteLength > w && i(`${r} exceed 2 KiB`), o;
+}, E = (e, t) => Object.freeze(T(e, t, "Seat attributes")), D = (t, n) => {
+	let r = (n) => {
+		throw new e({
+			room: t,
+			detail: n
+		});
+	};
+	if (!n || typeof n != "object" || Array.isArray(n) || Object.getPrototypeOf(n) !== Object.prototype) return r("A Room listing must be a plain object");
+	let i = n;
+	if (Object.keys(i).some((e) => ![
+		"metadata",
+		"private",
+		"locked"
+	].includes(e))) return r("A Room listing has only metadata, private and locked");
+	for (let e of ["private", "locked"]) i[e] !== void 0 && typeof i[e] != "boolean" && r(`Room listing ${e} must be a boolean`);
+	let a = i.metadata === void 0 ? void 0 : T(t, i.metadata, "Room listing metadata"), o = Object.freeze({
+		...a === void 0 ? {} : { metadata: Object.freeze(a) },
+		...i.private === void 0 ? {} : { private: i.private },
+		...i.locked === void 0 ? {} : { locked: i.locked }
+	});
+	return new TextEncoder().encode(JSON.stringify(o)).byteLength > w && r("A Room listing exceeds 2 KiB"), o;
+}, O = (t = {}) => {
+	if (!t || typeof t != "object" || Array.isArray(t) || Object.keys(t).some((e) => ![
+		"everyMs",
+		"onlyIfChanged",
+		"pick",
+		"mode",
+		"fullEvery",
+		"keepFulls",
+		"store",
+		"maxInlineBytes"
+	].includes(e)) || t.everyMs !== void 0 && (!Number.isSafeInteger(t.everyMs) || t.everyMs <= 0 || t.everyMs > 2147483647) || t.onlyIfChanged !== void 0 && typeof t.onlyIfChanged != "boolean" || t.mode !== void 0 && !["full", "delta"].includes(t.mode) || t.fullEvery !== void 0 && (!Number.isSafeInteger(t.fullEvery) || t.fullEvery < 1 || t.fullEvery > 128) || t.keepFulls !== void 0 && (!Number.isSafeInteger(t.keepFulls) || t.keepFulls < 1 || t.keepFulls > 16) || t.store !== void 0 && t.store !== "auto" || t.maxInlineBytes !== void 0 && (!Number.isSafeInteger(t.maxInlineBytes) || t.maxInlineBytes < 1 || t.maxInlineBytes > 67108864) || t.pick !== void 0 && typeof t.pick != "function") throw new e({
+		room: "",
+		detail: "Invalid implemented Room snapshot policy"
+	});
+	return Object.freeze({
+		everyMs: t.everyMs ?? 15e3,
+		onlyIfChanged: t.onlyIfChanged ?? !0,
+		mode: t.mode ?? "full",
+		fullEvery: t.fullEvery ?? 10,
+		keepFulls: t.keepFulls ?? 3,
+		store: t.store ?? "auto",
+		maxInlineBytes: t.maxInlineBytes ?? 65536,
+		pick: t.pick ?? ((e) => e)
+	});
+}, k = (t, n, r, i = !1) => {
+	if (!Number.isFinite(n) || n <= 0 || i && !Number.isSafeInteger(n)) throw new e({
+		room: t,
+		detail: `${r} must be a finite positive ${i ? "integer" : "number"}`
+	});
+	return n;
+}, A = (t = {}) => {
+	let n = {
+		inputsPerSecond: 60,
+		bytesPerSecond: 16384,
+		burst: 30,
+		maxQueuedInputs: 1024,
+		maxOutboxCommands: 1024,
+		maxScheduledHooks: 1024,
+		maxQueuedLifecycleHooks: 128,
+		maxNpcs: 64,
+		inputLatencyBudgetMs: 250
+	};
+	if (!t || typeof t != "object" || Array.isArray(t) || Object.keys(t).some((e) => !Object.hasOwn(n, e))) throw new e({
+		room: "budgets",
+		detail: "Unknown or malformed Room budget option"
+	});
+	let r = Object.freeze({
+		...n,
+		...t
+	});
+	for (let [e, t] of Object.entries(r)) k("budgets", t, e, !0);
+	return r;
+}, j = (t = {}) => {
+	if (!t || typeof t != "object" || Array.isArray(t) || Object.keys(t).some((e) => e !== "graceMs")) throw new e({
+		room: "reconnect",
+		detail: "Unknown or malformed Room reconnect option"
+	});
+	return Object.freeze({ graceMs: k("reconnect", t.graceMs ?? 2e4, "reconnect.graceMs") });
+}, M = (e) => structuredClone(e.state), N = (t) => {
+	if (!t.name.trim() || !t.channel.trim() || new Set(t.fields).size !== t.fields.length) throw new e({
+		room: t.name,
+		detail: "An extension requires a name, channel and unique owned fields"
+	});
+	return k(t.name, t.tickBudgetMs, "tickBudgetMs"), Object.freeze({
+		...t,
+		fields: Object.freeze([...t.fields])
+	});
+}, P = (i) => {
+	let o = i.name, s = Object.getOwnPropertyDescriptor(i, "world");
+	if (s && (!s.enumerable || !("value" in s)) || !s && "world" in i) throw new e({
+		room: o,
+		detail: "Room World hooks require an own data field"
+	});
+	let c = s?.value === void 0 ? void 0 : t(o, s.value);
+	if (!o.trim()) throw new e({
+		room: o,
+		detail: "A room requires a name"
+	});
+	if (typeof i.onTick != "function") throw new e({
+		room: o,
+		detail: "A room requires a synchronous onTick hook"
+	});
+	if (i.initialState !== void 0 && typeof i.initialState != "function") throw new e({
+		room: o,
+		detail: "Initial state must be an author-owned function"
+	});
+	if (i.view !== void 0 && typeof i.view != "function") throw new e({
+		room: o,
+		detail: "A room view must be a synchronous function"
+	});
+	if (i.listing !== void 0 && typeof i.listing != "function") throw new e({
+		room: o,
+		detail: "A room listing must be a synchronous function"
+	});
+	if (i.auth !== void 0 && i.auth !== "subject" && i.auth !== "public") throw new e({
+		room: o,
+		detail: "Room auth must be subject or explicitly public"
+	});
+	if (i.openAccess !== void 0 && (!i.openAccess.trim() || (i.guards?.length ?? 0) > 0)) throw new e({
+		room: o,
+		detail: "Room openAccess requires a reason and cannot be combined with guards"
+	});
+	if (i.guards !== void 0 && i.guards.length === 0) throw new e({
+		room: o,
+		detail: "Empty room guards are not an access decision"
+	});
+	let l = Object.freeze(i.guards ? [...i.guards] : i.openAccess === void 0 ? i.auth === "public" ? [{ open: "This Room explicitly declares public admission" }] : [{ authenticated: !0 }] : [{ open: i.openAccess }]), u = k(o, i.tickRate ?? 30, "tickRate"), d = k(o, i.sendRate ?? Math.min(20, u), "sendRate");
+	if (u < 1 || u > 128 || d > u) throw new e({
+		room: o,
+		detail: "tickRate must be between 1 and 128 and sendRate cannot exceed tickRate"
+	});
+	if (i.strategies !== void 0 && (!i.strategies || typeof i.strategies != "object" || Array.isArray(i.strategies) || Object.keys(i.strategies).some((e) => ![
+		"budgets",
+		"reconnectPolicy",
+		"snapshotPolicy",
+		"spectatorPolicy"
+	].includes(e)))) throw new e({
+		room: o,
+		detail: "Unknown Room authoring strategy slot"
+	});
+	let f = r(o, "budgets", i.strategies?.budgets ?? A, i.budgets === void 0 ? {} : i.budgets);
+	if (i.strategies?.budgets && Object.keys(A()).some((e) => !Object.hasOwn(f, e))) throw new e({
+		room: o,
+		detail: "Custom Room budget strategy must return every declared budget"
+	});
+	let p = A(f), m = r(o, "reconnectPolicy", i.strategies?.reconnectPolicy ?? j, i.reconnect === void 0 ? {} : i.reconnect);
+	if (!Object.hasOwn(m, "graceMs")) throw new e({
+		room: o,
+		detail: "Room reconnect strategy must return its grace duration"
+	});
+	let h = j(m), g = i.snapshot === void 0 ? {} : i.snapshot;
+	O(g);
+	let _ = r(o, "snapshotPolicy", i.strategies?.snapshotPolicy ?? O, g, (e) => Object.freeze({ ...e }));
+	if (![
+		"everyMs",
+		"onlyIfChanged",
+		"pick",
+		"mode",
+		"fullEvery",
+		"keepFulls",
+		"store",
+		"maxInlineBytes"
+	].every((e) => Object.hasOwn(_, e))) throw new e({
+		room: o,
+		detail: "Room snapshot strategy must return the full implemented policy"
+	});
+	let v = O(_), y = i.spectator === void 0 ? void 0 : a(i.spectator), b = y === void 0 ? void 0 : r(o, "spectatorPolicy", i.strategies?.spectatorPolicy ?? a, y);
+	if (b && Object.keys(y ?? {}).some((e) => !Object.hasOwn(b, e))) throw new e({
+		room: o,
+		detail: "Room spectator strategy must return the full policy"
+	});
+	let x = b === void 0 ? void 0 : a(b), S = k(o, i.lifecycleTimeoutMs ?? 5e3, "lifecycleTimeoutMs", !0);
+	if (S > 2147483647) throw new e({
+		room: o,
+		detail: "Lifecycle timeout exceeds the timer range"
+	});
+	let C = Object.freeze(Object.fromEntries(Object.entries(i.messages ?? {}).map(([e, t]) => [e, Object.freeze({ ...t })]))), w = Object.freeze((i.extensions ?? []).map((e) => N(e))), T = /* @__PURE__ */ new Set(), E = /* @__PURE__ */ new Set(), D = /* @__PURE__ */ new Set();
+	for (let t of w) {
+		if (T.has(t.name) || E.has(t.channel) || !C[t.channel]) throw new e({
+			room: o,
+			detail: "Extension names and channels must be unique and their channel declared"
+		});
+		T.add(t.name), E.add(t.channel);
+		for (let n of t.fields) {
+			if (D.has(n)) throw new e({
+				room: o,
+				detail: `Extension field ${n} has multiple owners`
+			});
+			D.add(n);
+		}
+	}
+	if (i.autoDispose?.hibernate !== void 0 && typeof i.autoDispose.hibernate != "boolean") throw new e({
+		room: o,
+		detail: "autoDispose.hibernate must be a boolean"
+	});
+	return n(i, Object.freeze({
+		...i,
+		...c ? { world: c } : {},
+		openAccess: void 0,
+		guards: l,
+		_tag: "RoomDescriptor",
+		auth: i.auth ?? "subject",
+		tickRate: u,
+		sendRate: d,
+		viewBudgetMs: k(o, i.viewBudgetMs ?? 2, "viewBudgetMs"),
+		maxClients: k(o, i.maxClients ?? 64, "maxClients", !0),
+		maxCatchUpTicks: k(o, i.maxCatchUpTicks ?? 5, "maxCatchUpTicks", !0),
+		lifecycleTimeoutMs: S,
+		budgets: p,
+		messages: C,
+		extensions: w,
+		view: i.view ?? M,
+		strategies: Object.freeze({
+			budgets: i.strategies?.budgets ?? A,
+			reconnectPolicy: i.strategies?.reconnectPolicy ?? j,
+			snapshotPolicy: i.strategies?.snapshotPolicy ?? O,
+			spectatorPolicy: i.strategies?.spectatorPolicy ?? a
+		}),
+		reconnect: h,
+		snapshot: v,
+		spectator: x,
+		autoDispose: Object.freeze({
+			afterEmptyMs: k(o, i.autoDispose?.afterEmptyMs ?? 3e4, "autoDispose.afterEmptyMs"),
+			hibernate: i.autoDispose?.hibernate ?? !1
+		})
+	}));
+};
+function F(t) {
+	let n = Object.getOwnPropertyDescriptor(t, "mode");
+	if (n && (!n.enumerable || !("value" in n)) || !n && "mode" in t) throw new e({
+		room: "declaration",
+		detail: "Room mode requires own plain data"
+	});
+	if (n?.value === "lockstep") return i(t);
+	if (n?.value !== void 0 && n.value !== "state-sync") throw new e({
+		room: "declaration",
+		detail: "Unknown Room mode"
+	});
+	if (Object.hasOwn(t, "simulation") || Object.hasOwn(t, "lockstep")) throw new e({
+		room: "declaration",
+		detail: "Lockstep simulation requires its explicit Room mode"
+	});
+	return P(t);
+}
+//#endregion
+export { o as RoomFieldId, c as RoomInterpolation, u as RoomNonAuthoritative, d as RoomPrecision, s as RoomQuantization, l as RoomTransform, D as captureRoomListing, E as captureRoomSeatAttributes, A as defaultRoomBudgets, j as defaultRoomReconnectPolicy, O as defaultRoomSnapshotPolicy, a as defaultRoomSpectatorPolicy, M as defaultRoomView, F as defineRoom, N as defineRoomExtension, S as dequantize, h as fieldId, y as interpolate, g as nonAuthoritative, b as precision, _ as quantizationStep, x as quantize, v as quantized };

package/dist/roomAccessSweep.js

@@ -0,0 +1,95 @@
+import { RoomsClosed as e } from "./errors.js";
+import { ROOMS_TABLE as t, ROOM_SEATS_TABLE as n } from "./identities.js";
+import { roomAccessDeadline as r } from "./apiReservations.js";
+import { and as i, eq as a, isNotNull as o, lte as s } from "@voltro/database";
+import { Effect as c, Result as l } from "effect";
+//#region src/roomAccessSweep.ts
+var u = (u, d) => {
+	let f = d.limit ?? 100;
+	if (!Number.isSafeInteger(f) || f < 1 || f > 1e3) throw Error("Room access sweep limit must be 1..1000");
+	let { admission: p, kick: m, now: h } = d, g = [
+		"sessionId",
+		"roomId",
+		"tenantId",
+		"subjectId"
+	], _ = async (o, s) => {
+		let d = 0, f = 0;
+		for (let h of o) {
+			let o = String(h.sessionId), g = String(h.roomId), _ = String(h.tenantId), v = h.subjectId, y = i(a("sessionId", o), a("tenantId", _)), b = (await u.query({
+				table: t,
+				predicate: i(a("id", g), a("tenantId", _)),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["name"]
+			}))[0];
+			if (typeof v != "string" || !b) {
+				await u.updateMany(n, { accessUntil: null }, { where: y });
+				continue;
+			}
+			let x = {
+				type: "user",
+				id: v,
+				tenantId: _
+			}, S = await c.runPromise(c.result(c.suspend(() => p(Object.freeze({
+				subject: x,
+				room: String(b.name),
+				mode: "continue"
+			}))))).catch(() => null);
+			if (S === null) continue;
+			let C = l.isFailure(S) && S.failure instanceof e ? S.failure : null;
+			if (l.isSuccess(S)) try {
+				let e = r(S.success, s);
+				await u.updateMany(n, { accessUntil: e === null ? null : new Date(e) }, { where: y }), d++;
+				continue;
+			} catch (t) {
+				C = t instanceof e ? t : null;
+			}
+			else if (C === null) continue;
+			let w = await c.runPromise(c.result(m({
+				tenantId: _,
+				roomId: g,
+				subjectId: v,
+				reason: C?.messageKey ?? "rooms.accessEnded"
+			})));
+			l.isSuccess(w) && (f += w.success.kicked);
+		}
+		return {
+			visited: o.length,
+			renewed: d,
+			kicked: f
+		};
+	};
+	return Object.freeze({
+		run: () => c.tryPromise(async () => {
+			let e = h();
+			return _(await u.query({
+				table: n,
+				predicate: i(a("state", "connected"), o("accessUntil"), s("accessUntil", new Date(e))),
+				order: [{
+					column: "accessUntil",
+					direction: "asc"
+				}],
+				take: f,
+				skip: void 0,
+				projection: g
+			}), e);
+		}),
+		recheck: (e) => c.tryPromise(async () => {
+			let t = h();
+			return _(await u.query({
+				table: n,
+				predicate: i(a("tenantId", e.tenantId), a("subjectId", e.subjectId), a("state", "connected"), o("accessUntil")),
+				order: [{
+					column: "sessionId",
+					direction: "asc"
+				}],
+				take: f,
+				skip: void 0,
+				projection: g
+			}), t);
+		})
+	});
+};
+//#endregion
+export { u as dataStoreRoomAccessSweep };

package/dist/roomAppCommandControl.js

@@ -0,0 +1,59 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOM_COMMAND_FAILED as t, applicationRoomCommands as n, roomCommandDeferred as r } from "./commandDelivery.js";
+import { RoomControlTargetSchema as i, makeRoomControlCarrier as a, sameRoomControlTarget as o } from "./controlCarrier.js";
+import { Effect as s, Option as c, Result as l, Schema as u } from "effect";
+import "node:crypto";
+//#region src/roomAppCommandControl.ts
+var d = "app-commands", f = () => new e({ detail: t }), p = (t, r) => s.gen(function* () {
+	let c = yield* s.context(), p = (e) => s.runPromiseWith(c)(e), m = yield* s.try({
+		try: () => a(r),
+		catch: () => new e({ detail: "Room app command carrier is unavailable" })
+	}), h = yield* s.try({
+		try: () => u.decodeUnknownSync(i)({
+			hostId: d,
+			...r.instance
+		}),
+		catch: () => new e({ detail: "Room app command server needs this instance identity" })
+	}), g = n(r.bindings), _ = /* @__PURE__ */ new Set(), v = !1, y = yield* t.subscribe(m.requestChannel(h), (e) => {
+		if (v) return;
+		let n;
+		try {
+			n = m.readRequest(e);
+		} catch {
+			return;
+		}
+		if (!o(n.target, h) || n.body.operation !== "appCommand") return;
+		let r = n.body, i = (async () => {
+			let e = await p(s.result(g.deliver(structuredClone(r.delivery))));
+			if (m.now() >= n.expiresAt) return;
+			let { purpose: i, body: a, ...o } = n, c = l.isSuccess(e) ? {
+				ok: !0,
+				value: null
+			} : {
+				ok: !1,
+				error: f()
+			};
+			await p(t.publish(m.replyChannel(n.clientId), m.signReply({
+				purpose: "voltro.rooms.control.reply.v3",
+				...o,
+				operation: "appCommand",
+				result: c
+			})));
+		})().catch(() => void 0);
+		_.add(i), i.then(() => {
+			_.delete(i);
+		});
+	}).pipe(s.mapError(() => new e({ detail: "Room app command channel is unavailable" })));
+	return Object.freeze({ close: async () => {
+		v || (v = !0, await Promise.all([..._]), await p(y));
+	} });
+}), m = (t) => Object.freeze({ deliver: (n) => t.deliver(n).pipe(s.mapError((t) => t instanceof e && t.detail === "Room application command failed" ? t : r())) }), h = (e) => {
+	let t = e.filter((e) => e.meta?.role !== "rooms-host").sort((e, t) => e.startedAt - t.startedAt || (e.instanceId < t.instanceId ? -1 : 1))[0];
+	return t === void 0 ? c.none() : c.some({
+		hostId: d,
+		instanceId: t.instanceId,
+		startedAt: t.startedAt
+	});
+};
+//#endregion
+export { d as ROOM_APP_COMMAND_TARGET, m as forwardedRoomAppCommands, p as openRoomAppCommandServer, h as roomAppCommandTarget };

package/dist/roomAuthoringStrategy.js

@@ -0,0 +1,17 @@
+import { RoomAuthoringError as e } from "./errors.js";
+//#region src/roomAuthoringStrategy.ts
+var t = (t, n, r, i, a = (e) => structuredClone(e)) => {
+	try {
+		if (typeof r != "function") throw Error("Missing strategy");
+		let e = r(a(i));
+		if (!e || typeof e != "object" || Array.isArray(e) || Object.getPrototypeOf(e) !== Object.prototype && Object.getPrototypeOf(e) !== null) throw Error("Strategy must return plain options");
+		return e;
+	} catch {
+		throw new e({
+			room: t,
+			detail: `Room strategy ${n} failed or returned invalid synchronous options`
+		});
+	}
+};
+//#endregion
+export { t as roomAuthoringStrategy };

package/dist/roomErasure.js

@@ -0,0 +1,198 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOMS_TABLE as t, ROOM_COMMANDS_TABLE as n, ROOM_SEATS_TABLE as r } from "./identities.js";
+import { RoomErasurePort as i } from "./ports.js";
+import { deleteLockstepJournalTicks as a, hasLockstepJournalTicks as o } from "./lockstepJournalRows.js";
+import { captureRoomSnapshotBlobs as s, captureRoomSnapshotEffectRunner as c } from "./snapshotBlobIndex.js";
+import { eraseRoomSnapshots as l, readRoomSnapshotErasureJournal as u } from "./snapshotErasure.js";
+import { and as d, eq as f } from "@voltro/database";
+import { Effect as p, Layer as m } from "effect";
+//#region src/roomErasure.ts
+var h = [
+	"fenced",
+	"owner-withdrawn",
+	"external-withdrawn",
+	"snapshots-erased",
+	"data-erased",
+	"complete"
+];
+function g(t) {
+	throw new e({ detail: t });
+}
+var _ = (e) => typeof e == "string" && e.trim() && e.length <= 191 ? e : g("Invalid room erasure identity"), v = (e) => d(f("id", e.roomId), f("tenantId", e.tenantId)), y = (e) => d(f("roomId", e.roomId), f("tenantId", e.tenantId)), b = (e) => !e || typeof e != "object" || Array.isArray(e) || Object.keys(e).some((e) => ![
+	"roomId",
+	"tenantId",
+	"requestId"
+].includes(e)) ? g("Invalid room erasure request") : Object.freeze({
+	roomId: _(e.roomId),
+	tenantId: _(e.tenantId),
+	requestId: _(e.requestId)
+}), x = (e, t, n) => {
+	if (e.id !== t || e.tenantId !== n) return g("Room erasure SQL scope changed");
+	let r = e.erasure;
+	if (r == null) return null;
+	if (!r || typeof r != "object" || Array.isArray(r)) return g("Malformed room erasure journal");
+	let i = r;
+	return Object.keys(i).some((e) => ![
+		"version",
+		"requestId",
+		"hostId",
+		"priorEpoch",
+		"withdrawnEpoch",
+		"phase"
+	].includes(e)) || i.version !== 1 || !h.includes(i.phase) || !Number.isSafeInteger(i.priorEpoch) || i.priorEpoch < 1 || !Number.isSafeInteger(i.withdrawnEpoch) || i.withdrawnEpoch !== i.priorEpoch + 1 || e.epoch !== i.withdrawnEpoch || e.hostId !== i.hostId || e.state !== "disposed" || e.clients !== 0 || e.locked !== !0 || e.private !== !0 ? g("Invalid room erasure authority or phase") : Object.freeze({
+		version: 1,
+		requestId: _(i.requestId),
+		hostId: _(i.hostId),
+		priorEpoch: i.priorEpoch,
+		withdrawnEpoch: i.withdrawnEpoch,
+		phase: i.phase
+	});
+}, S = (i, d) => {
+	if (!d || typeof d != "object" || Array.isArray(d) || typeof d.epochNow != "function" || typeof d.owner?.withdraw != "function" || typeof d.external?.withdraw != "function" || typeof d.invalidateDirectory != "function") return g("Room erasure requires actual owner, external work and directory bindings");
+	let f = d.epochNow.bind(d), m = d.owner.withdraw.bind(d.owner), S = d.external.withdraw.bind(d.external), C = d.invalidateDirectory.bind(d), w = d.maxSeats ?? 4096, T = d.maxCommands ?? 4096, E = d.maxSnapshotBytes ?? 1048576, D = s(d.snapshotBlobs);
+	if (![w, T].every((e) => Number.isSafeInteger(e) && e >= 1 && e <= 65536) || !Number.isSafeInteger(E) || E < 1 || E > 67108864) return g("Invalid room erasure budgets");
+	let O = () => {
+		let e = f();
+		return !Number.isFinite(e) || e < 0 || e > 864e13 ? g("Invalid room erasure wall clock") : new Date(e);
+	}, k = async (e, n) => {
+		let r = await e.query({
+			table: t,
+			predicate: v(n),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		return r.length !== 1 || r[0].id !== n.roomId || r[0].tenantId !== n.tenantId ? g("Room erasure requires one exact SQL room") : r[0];
+	}, A = (e, t) => {
+		let n = x(e, t.roomId, t.tenantId);
+		return !n || n.requestId !== t.requestId ? g("Room erasure request identity changed") : n;
+	}, j = async (e, t, n, r = {}) => {
+		if (await e.updateMany("_voltro_rooms", {
+			...r,
+			erasure: n,
+			updatedAt: O()
+		}, { where: v(t) }) !== 1) return g("Room erasure lost its SQL receipt");
+	}, M = (e, t) => {
+		let n = u(e, t.roomId, t.tenantId, E);
+		if (!n || n.requestId !== t.requestId || n.state !== "complete") return g("Room erasure snapshots are not confirmed complete");
+	}, N = async (e, t, n, r) => {
+		let i = await e.query({
+			table: n,
+			predicate: y(t),
+			order: [],
+			take: r + 1,
+			skip: void 0,
+			projection: [
+				"id",
+				"roomId",
+				"tenantId",
+				"epoch"
+			],
+			lock: "update"
+		});
+		return i.length > r || new Set(i.map((e) => e.id)).size !== i.length || i.some((e) => e.roomId !== t.roomId || e.tenantId !== t.tenantId || typeof e.id != "string" || !e.id.trim() || e.id.length > 191 || !Number.isSafeInteger(e.epoch) || Number(e.epoch) < 1) ? g("Invalid or oversized room erasure data inventory") : i;
+	};
+	return Object.freeze({ erase: (t) => {
+		let s;
+		try {
+			s = b(t);
+		} catch {
+			return p.fail(new e({ detail: "Room erasure request admission failed" }));
+		}
+		return p.flatMap(p.context(), (t) => p.uninterruptible(p.tryPromise({
+			try: async () => {
+				let e = c(t);
+				await i.transactional(async (e) => {
+					let t = await k(e, s);
+					if (x(t, s.roomId, s.tenantId)) {
+						A(t, s);
+						return;
+					}
+					let n = t.epoch;
+					if (!Number.isSafeInteger(n) || Number(n) < 1 || Number(n) >= 2 ** 53 - 1 || ![
+						"live",
+						"orphaned",
+						"faulted",
+						"hibernating",
+						"creating",
+						"disposed"
+					].includes(String(t.state)) || !Number.isSafeInteger(t.clients) || Number(t.clients) < 0 || !Number.isSafeInteger(t.maxClients) || Number(t.maxClients) < 1 || Number(t.clients) > Number(t.maxClients) || t.snapshotErasure != null) return g("Room cannot acquire a new erasure fence");
+					let r = {
+						version: 1,
+						requestId: s.requestId,
+						hostId: _(t.hostId),
+						priorEpoch: Number(n),
+						withdrawnEpoch: Number(n) + 1,
+						phase: "fenced"
+					};
+					await j(e, s, r, {
+						epoch: r.withdrawnEpoch,
+						state: "disposed",
+						clients: 0,
+						locked: !0,
+						private: !0
+					});
+				});
+				for (let t of h) {
+					let c = await i.transactional(async (e) => {
+						let n = await k(e, s), r = A(n, s);
+						return h.indexOf(r.phase) < h.indexOf(t) ? g("Room erasure phase order changed") : {
+							saved: r,
+							name: _(n.name)
+						};
+					});
+					if (c.saved.phase !== t) continue;
+					if (t === "complete") {
+						await e(l(i, D, {
+							...s,
+							epoch: c.saved.withdrawnEpoch
+						}, { maxBytes: E })), await i.transactional(async (e) => {
+							let t = await k(e, s);
+							if (A(t, s), M(t, s), (await N(e, s, "_voltro_room_seats", w)).length || (await N(e, s, "_voltro_room_outbox", T)).length || await o(e, s) || t.options != null || t.lockstepJournal != null || t.lockstepAdmission != null || t.lockstepCreatorSubjectId != null || !t.metadata || typeof t.metadata != "object" || Array.isArray(t.metadata) || Object.keys(t.metadata).length) return g("Completed room erasure has reintroduced private data");
+						});
+						return;
+					}
+					let u = c.saved, d = Object.freeze({
+						roomId: s.roomId,
+						tenantId: s.tenantId,
+						priorEpoch: u.priorEpoch,
+						withdrawnEpoch: u.withdrawnEpoch
+					});
+					t === "fenced" && await e(m(u.hostId, d)), t === "owner-withdrawn" && await e(S(Object.freeze({
+						...d,
+						requestId: s.requestId
+					}))), t === "external-withdrawn" && await e(l(i, D, {
+						...s,
+						epoch: u.withdrawnEpoch
+					}, { maxBytes: E })), t === "data-erased" && await e(C(s.tenantId, c.name)), await i.transactional(async (e) => {
+						let i = await k(e, s), o = A(i, s);
+						if (h.indexOf(o.phase) > h.indexOf(t)) return;
+						if (o.phase !== t) return g("Room erasure phase regressed");
+						if ((t === "external-withdrawn" || t === "snapshots-erased" || t === "data-erased") && M(i, s), t === "snapshots-erased") {
+							let t = await N(e, s, r, w), i = await N(e, s, n, T);
+							if ([...t, ...i].some((e) => Number(e.epoch) >= o.withdrawnEpoch)) return g("Room erasure found an unfenced data writer");
+							for (let [a, o] of [[r, t], [n, i]]) if (await e.deleteMany(a, { where: y(s) }) !== o.length) return g("Room erasure data removal did not match its inventory");
+							await a(e, s);
+						}
+						let c = h[h.indexOf(t) + 1];
+						await j(e, s, {
+							...o,
+							phase: c
+						}, t === "snapshots-erased" ? {
+							metadata: {},
+							options: null,
+							lockstepJournal: null,
+							lockstepAdmission: null,
+							lockstepCreatorSubjectId: null
+						} : {});
+					});
+				}
+			},
+			catch: () => new e({ detail: "Coordinated room erasure remains unconfirmed" })
+		})));
+	} });
+}, C = (e, t) => m.succeed(i, S(e, t));
+//#endregion
+export { S as dataStoreRoomErasure, x as readRoomErasureJournal, C as roomErasureLayer };

package/dist/roomPoolRuntimeDefaults.js

@@ -0,0 +1,24 @@
+//#region src/roomPoolRuntimeDefaults.ts
+var e = /* @__PURE__ */ new WeakMap(), t = (t, n) => (e.set(n, e.get(t) ?? Object.freeze({
+	catchUp: t.maxCatchUpTicks !== void 0,
+	snapshot: t.snapshot?.everyMs !== void 0 || t.strategies?.snapshotPolicy !== void 0,
+	hibernate: t.autoDispose?.hibernate !== void 0
+})), n), n = (t, n) => {
+	let r = e.get(t);
+	return !n || !r ? t : Object.freeze({
+		...t,
+		maxCatchUpTicks: r.catchUp ? t.maxCatchUpTicks : n.maxCatchUpTicks,
+		snapshot: r.snapshot ? t.snapshot : Object.freeze({
+			...t.snapshot,
+			everyMs: n.snapshotEveryMs
+		}),
+		autoDispose: r.hibernate ? t.autoDispose : Object.freeze({
+			...t.autoDispose,
+			hibernate: n.hibernate
+		})
+	});
+}, r = /* @__PURE__ */ new WeakMap(), i = (e, t) => {
+	r.set(t, r.get(e) ?? e.maxCatchUpTicks !== void 0);
+}, a = (e, t) => t && r.get(e) === !1 ? t.maxCatchUpTicks : e.maxCatchUpTicks;
+//#endregion
+export { n as applyRoomPoolRuntimeDefaults, i as retainLockstepPoolOrigin, t as retainRoomPolicyOrigin, a as roomPoolLockstepCatchUp };