@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/strategyFixtures.js

@@ -0,0 +1,181 @@
+import { defaultRoomSpectatorPolicy as e } from "./spectatorPolicy.js";
+import { defaultRoomBudgets as t, defaultRoomReconnectPolicy as n, defaultRoomSnapshotPolicy as r, defaultRoomView as i, defineRoom as a } from "./room.js";
+import { captureRoomSnapshotBudget as o, defaultRoomSnapshotBudget as s } from "./snapshotBudget.js";
+import { leastLoadedRoomHostInRegion as c, resolveRoomHostSelection as l } from "./hostSelection.js";
+import { Effect as u, Schema as d } from "effect";
+// src/strategyFixtures.ts
+var f = {
+	name: "strategy-fixture",
+	state: d.Struct({ n: d.Int }),
+	input: d.Struct({}),
+	options: d.Struct({}),
+	onTick: () => void 0
+}, p = { burst: 31 }, m = { graceMs: 1234 }, h = {
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			budgets: p
+		}).budgets.burst),
+		expected: 31
+	},
+	overrideProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			budgets: p,
+			strategies: { budgets: (e) => ({
+				...t(e),
+				burst: 7
+			}) }
+		}).budgets.burst),
+		expected: 7
+	}
+}, g = {
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			reconnect: m
+		}).reconnect.graceMs),
+		expected: 1234
+	},
+	overrideProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			reconnect: m,
+			strategies: { reconnectPolicy: (e) => ({ graceMs: n(e).graceMs * 2 }) }
+		}).reconnect.graceMs),
+		expected: 2468
+	}
+}, _ = {
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			snapshot: {
+				everyMs: 1234,
+				maxInlineBytes: 8192
+			}
+		}).snapshot.maxInlineBytes),
+		expected: 8192
+	},
+	overrideProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			snapshot: {
+				everyMs: 1234,
+				maxInlineBytes: 8192
+			},
+			strategies: { snapshotPolicy: (e) => ({
+				...r(e),
+				maxInlineBytes: 4096
+			}) }
+		}).snapshot.maxInlineBytes),
+		expected: 4096
+	}
+}, v = {
+	kind: "slot",
+	defaultImplementation: s,
+	defaultProbe: {
+		run: () => u.sync(() => {
+			let e = o(s, {
+				budgetBytesPerSec: 10,
+				burstBytes: 10
+			});
+			return e.forced(20, 0), e.metrics().debtBytes;
+		}),
+		expected: 10
+	},
+	overrideProbe: {
+		run: () => u.sync(() => {
+			let e = o((e) => s({
+				...e,
+				burstBytes: 20
+			}), {
+				budgetBytesPerSec: 10,
+				burstBytes: 10
+			});
+			return e.forced(20, 0), e.metrics().debtBytes;
+		}),
+		expected: 0
+	}
+}, y = () => ({
+	state: { n: 7 },
+	tick: 1,
+	role: "player",
+	client: {
+		sessionId: "fixture-session",
+		subjectId: "fixture-subject",
+		tenantId: "fixture-tenant"
+	}
+}), b = {
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => u.sync(() => a(f).view(y()).n),
+		expected: 7
+	},
+	overrideProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			view: () => ({ n: 0 })
+		}).view(y()).n),
+		expected: 0
+	}
+}, x = () => [{
+	id: "first",
+	address: "wss://first.invalid/rooms",
+	region: "fixture-region",
+	capacity: 2,
+	rooms: 1,
+	clients: 1,
+	cpu: .25,
+	lastHeartbeatAt: 1,
+	ready: !0
+}, {
+	id: "second",
+	address: "wss://second.invalid/rooms",
+	region: "fixture-region",
+	capacity: 2,
+	rooms: 0,
+	clients: 0,
+	cpu: .5,
+	lastHeartbeatAt: 1,
+	ready: !0
+}], S = {
+	kind: "slot",
+	defaultImplementation: c,
+	defaultProbe: {
+		run: () => u.sync(() => l(x(), "fixture-region")?.id),
+		expected: "second"
+	},
+	overrideProbe: {
+		run: () => u.sync(() => l(x(), "fixture-region", (e) => e[0] ?? null)?.id),
+		expected: "first"
+	}
+}, C = {
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			spectator: { delayMs: 100 }
+		}).spectator?.delayMs),
+		expected: 100
+	},
+	overrideProbe: {
+		run: () => u.sync(() => a({
+			...f,
+			spectator: { delayMs: 100 },
+			strategies: { spectatorPolicy: (t) => ({
+				...e(t),
+				delayMs: 200
+			}) }
+		}).spectator?.delayMs),
+		expected: 200
+	}
+};
+export { h as roomBudgetsSlotFixture, g as roomReconnectSlotFixture, S as roomSelectHostSlotFixture, v as roomSnapshotBudgetSlotFixture, _ as roomSnapshotSlotFixture, C as roomSpectatorSlotFixture, b as roomViewSlotFixture };

package/dist/streamFraming.js

@@ -0,0 +1,121 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+// src/streamFraming.ts
+var r = (e, t) => {
+	if (typeof e != "number" || !Number.isSafeInteger(e) || e < 1 || e > t) throw new n({
+		room: "stream-framing",
+		detail: "Stream framing requires explicit positive bounded budgets"
+	});
+	return e;
+}, i = (e) => {
+	if (!(e instanceof Uint8Array)) throw new t({ detail: "Room stream chunks must contain binary bytes" });
+	return e;
+}, a = (n, a) => {
+	let o = i(n), s = r(a, 16777216);
+	if (!o.byteLength) throw new t({ detail: "Room stream cannot encode an empty frame" });
+	if (o.byteLength > s) throw new e({
+		budget: "roomStreamFrameBytes",
+		limit: s
+	});
+	let c = new Uint8Array(o.byteLength + 4);
+	return new DataView(c.buffer).setUint32(0, o.byteLength, !1), c.set(o, 4), c;
+}, o = class {
+	options;
+	header = /* @__PURE__ */ new Uint8Array(4);
+	headerBytes = 0;
+	payload = null;
+	payloadBytes = 0;
+	ended = !1;
+	constructor(e) {
+		if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== 3 || [
+			"maxFrameBytes",
+			"maxChunkBytes",
+			"maxFramesPerChunk"
+		].some((t) => {
+			let n = Object.getOwnPropertyDescriptor(e, t);
+			return !n?.enumerable || !("value" in n);
+		})) throw new n({
+			room: "stream-framing",
+			detail: "Stream framing configuration requires own bounded data"
+		});
+		this.options = Object.freeze({
+			maxFrameBytes: r(e.maxFrameBytes, 16777216),
+			maxChunkBytes: r(e.maxChunkBytes, 33554432),
+			maxFramesPerChunk: r(e.maxFramesPerChunk, 65536)
+		});
+	}
+	get bufferedBytes() {
+		return this.headerBytes + this.payloadBytes;
+	}
+	push(n) {
+		if (this.ended) throw new t({ detail: "Room stream framing is closed or failed" });
+		try {
+			let r = i(n);
+			if (r.byteLength > this.options.maxChunkBytes) throw new e({
+				budget: "roomStreamChunkBytes",
+				limit: this.options.maxChunkBytes
+			});
+			let a = [], o = 0;
+			for (; o < r.byteLength;) {
+				if (this.payload === null) {
+					let n = Math.min(4 - this.headerBytes, r.byteLength - o);
+					if (this.header.set(r.subarray(o, o + n), this.headerBytes), this.headerBytes += n, o += n, this.headerBytes < 4) break;
+					let i = new DataView(this.header.buffer).getUint32(0, !1);
+					if (!i) throw new t({ detail: "Room stream declared an empty frame" });
+					if (i > this.options.maxFrameBytes) throw new e({
+						budget: "roomStreamFrameBytes",
+						limit: this.options.maxFrameBytes
+					});
+					if (a.length >= this.options.maxFramesPerChunk) throw new e({
+						budget: "roomStreamFramesPerChunk",
+						limit: this.options.maxFramesPerChunk
+					});
+					this.payload = new Uint8Array(i), this.payloadBytes = 0;
+				}
+				let n = Math.min(this.payload.byteLength - this.payloadBytes, r.byteLength - o);
+				this.payload.set(r.subarray(o, o + n), this.payloadBytes), this.payloadBytes += n, o += n, this.payloadBytes === this.payload.byteLength && (a.push(this.payload), this.payload = null, this.payloadBytes = 0, this.headerBytes = 0);
+			}
+			return Object.freeze(a);
+		} catch (e) {
+			throw this.ended = !0, this.payload = null, this.payloadBytes = 0, this.headerBytes = 0, e;
+		}
+	}
+	finish() {
+		if (this.ended) throw new t({ detail: "Room stream framing is already closed or failed" });
+		this.ended = !0;
+		let e = this.headerBytes !== 0 || this.payload !== null;
+		if (this.payload = null, this.headerBytes = 0, this.payloadBytes = 0, e) throw new t({ detail: "Room stream ended inside a frame" });
+	}
+}, s = class {
+	maxDatagramBytes;
+	pending = null;
+	dropped = 0;
+	ended = !1;
+	constructor(e) {
+		this.maxDatagramBytes = r(e, 65535);
+	}
+	get droppedDatagrams() {
+		return this.dropped;
+	}
+	get bufferedBytes() {
+		return this.pending?.byteLength ?? 0;
+	}
+	offer(n) {
+		if (this.ended) throw new t({ detail: "Room datagram mailbox is closed" });
+		let r = i(n);
+		if (!r.byteLength) throw new t({ detail: "Room datagram cannot contain an empty frame" });
+		if (r.byteLength > this.maxDatagramBytes) throw new e({
+			budget: "maxDatagramBytes",
+			limit: this.maxDatagramBytes
+		});
+		this.pending && this.dropped++, this.pending = r.slice();
+	}
+	take() {
+		if (this.ended) throw new t({ detail: "Room datagram mailbox is closed" });
+		let e = this.pending;
+		return this.pending = null, e;
+	}
+	close() {
+		this.pending && this.dropped++, this.pending = null, this.ended = !0;
+	}
+};
+export { s as RoomLatestDatagram, o as RoomStreamFrameDecoder, a as encodeRoomStreamFrame };

package/dist/streamTransport.js

@@ -0,0 +1,265 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { captureRoomTransportClock as r } from "./transportAuthoring.js";
+import { RoomTransportCleanupFailure as i } from "./transportCleanup.js";
+import { RoomLatestDatagram as a, RoomStreamFrameDecoder as o, encodeRoomStreamFrame as s } from "./streamFraming.js";
+// src/streamTransport.ts
+var c = (e) => new t({ detail: e }), l = async (t) => {
+	let l = [
+		"reliable",
+		"datagrams",
+		"maxFrameBytes",
+		"maxChunkBytes",
+		"maxFramesPerChunk",
+		"maxQueuedBytes",
+		"maxListeners",
+		"clock",
+		"signal",
+		"release"
+	];
+	if (!t || Object.getPrototypeOf(t) !== Object.prototype || Reflect.ownKeys(t).some((e) => {
+		let n = Object.getOwnPropertyDescriptor(t, e);
+		return typeof e != "string" || !l.includes(e) || !n?.enumerable || !("value" in n);
+	}) || !Number.isSafeInteger(t.maxQueuedBytes) || t.maxQueuedBytes < 1 || t.maxQueuedBytes > 33554432 || !Number.isSafeInteger(t.maxListeners) || t.maxListeners < 1 || t.maxListeners > 1024 || typeof t.release != "function" || !(t.signal instanceof AbortSignal)) throw new n({
+		room: "stream-transport",
+		detail: "Stream transport requires complete actual providers and bounded budgets"
+	});
+	let u = (e) => {
+		if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).some((t) => {
+			let n = Object.getOwnPropertyDescriptor(e, t);
+			return typeof t != "string" || ![
+				"readable",
+				"writable",
+				"maxDatagramBytes"
+			].includes(t) || !n?.enumerable || !("value" in n);
+		}) || !(e.readable instanceof ReadableStream) || !(e.writable instanceof WritableStream)) throw new n({
+			room: "stream-transport",
+			detail: "Room duplex requires actual transferred readable and writable streams"
+		});
+		return Object.freeze({
+			readable: e.readable,
+			writable: e.writable
+		});
+	}, d = r(t.clock);
+	if (t.signal.aborted) throw c("Room stream admission was cancelled before resource transfer");
+	let f = u(t.reliable), p = t.datagrams === void 0 ? void 0 : u(t.datagrams), m = new o({
+		maxFrameBytes: t.maxFrameBytes,
+		maxChunkBytes: t.maxChunkBytes,
+		maxFramesPerChunk: t.maxFramesPerChunk
+	}), h = t.maxFrameBytes, g = t.maxQueuedBytes, _ = t.maxListeners, v = d.now, y = t.release.bind(t), b = t.signal, x = t.datagrams === void 0 ? void 0 : new a(t.datagrams.maxDatagramBytes), S = [], C, w, T, E;
+	try {
+		C = f.readable.getReader(), S.push(C), w = f.writable.getWriter(), S.push(w), p && (T = p.readable.getReader(), S.push(T), E = p.writable.getWriter(), S.push(E));
+	} catch {
+		let e = /* @__PURE__ */ new Set(), t = !1, n = new i(async () => {
+			let n = !1;
+			for (let t of S) if (!e.has(t)) try {
+				t.releaseLock(), e.add(t);
+			} catch {
+				n = !0;
+			}
+			if (!t) try {
+				await y(1011, "Room stream acquisition failed"), t = !0;
+			} catch {
+				n = !0;
+			}
+			if (n) throw c("Room stream acquisition cleanup remains incomplete");
+		});
+		try {
+			await n.cleanupAsync();
+		} catch {
+			throw n;
+		}
+		throw c("Room stream acquisition failed");
+	}
+	let D = new AbortController(), O = /* @__PURE__ */ new Set(), k = /* @__PURE__ */ new Set(), A = [], j = 0, M, N, P, F, I = !1, L, R = !1, z = -1, B = /* @__PURE__ */ new Set(), V = /* @__PURE__ */ new Set(), H, U = async (e, t) => {
+		let n = [], r = async (e, t) => {
+			if (!B.has(e)) try {
+				await t(), B.add(e);
+			} catch (e) {
+				n.push(e);
+			}
+		};
+		await Promise.all([
+			r(C, () => C.cancel()),
+			r(w, () => w.abort()),
+			...T ? [r(T, () => T.cancel())] : [],
+			...E ? [r(E, () => E.abort())] : [],
+			(async () => {
+				if (!R) try {
+					await y(e, t), R = !0;
+				} catch (e) {
+					n.push(e);
+				}
+			})()
+		]);
+		let i = await Promise.allSettled([
+			M,
+			N,
+			P,
+			F
+		].filter((e) => e !== void 0));
+		for (let e of i) e.status === "rejected" && n.push(e.reason);
+		for (let e of S) if (B.has(e) && !V.has(e)) try {
+			e.releaseLock(), V.add(e);
+		} catch (e) {
+			n.push(e);
+		}
+		if (n.length) throw c("Room stream transport cleanup remains incomplete");
+	}, W = (e, t) => {
+		if (!Number.isSafeInteger(e) || e < 0 || e > 4294967295 || typeof t != "string" || !t.isWellFormed() || new TextEncoder().encode(t).byteLength > 1024) return Promise.reject(c("Invalid Room stream close information"));
+		if (L) return L;
+		if (!I) {
+			H = Object.freeze({
+				code: e,
+				reason: t
+			}), I = !0, b.removeEventListener("abort", K), D.abort(c("Room stream transport closed")), O.clear(), k.clear(), x?.close();
+			for (let e of A.splice(0)) j -= e.bytes.byteLength, e.reject(c("Room stream write was withdrawn before submission"));
+		}
+		let n = U(H.code, H.reason);
+		return L = n, n.catch(() => {
+			L === n && (L = void 0);
+		}), n;
+	}, G = (e, t) => {
+		W(e, t).catch(() => {});
+	}, K = () => {
+		G(1e3, "Room stream parent admission was cancelled");
+	}, q = () => {
+		G(1002, "Room stream operation failed");
+	}, J = (e, t) => {
+		let n = v();
+		if (!Number.isFinite(n) || n < 0 || n < z) throw c("Room stream requires a monotonic observation clock");
+		z = n;
+		for (let r of e) {
+			if (I) return;
+			r(t.slice(), n);
+		}
+	}, Y = async () => {
+		try {
+			for (; !I;) {
+				let e = await C.read();
+				if (I) return;
+				if (e.done) {
+					m.finish(), G(1e3, "Room reliable stream ended");
+					return;
+				}
+				for (let t of m.push(e.value)) J(O, t);
+			}
+		} catch {
+			I || q();
+		}
+	}, X = async () => {
+		try {
+			for (; !I;) {
+				let e = await T.read();
+				if (I) return;
+				if (e.done) {
+					G(1e3, "Room datagram stream ended");
+					return;
+				}
+				if (!(e.value instanceof Uint8Array) || !e.value.byteLength || e.value.byteLength > x.maxDatagramBytes) throw c("Room datagram exceeded its admitted binary budget");
+				J(k, e.value);
+			}
+		} catch {
+			I || q();
+		}
+	}, Z = () => {
+		if (P || I) return;
+		let e = (async () => {
+			for (; !I && A.length;) {
+				let e = A.shift();
+				try {
+					await w.write(e.bytes), I ? e.reject(c("Room native stream write outcome was withdrawn")) : e.resolve();
+				} catch {
+					e.reject(c("Room native stream write remains incomplete")), I || q();
+				} finally {
+					j -= e.bytes.byteLength;
+				}
+			}
+		})();
+		P = e;
+		let t = () => {
+			P === e && (P = void 0), !I && A.length && Z();
+		};
+		e.then(t, () => {
+			q(), t();
+		});
+	}, Q = () => {
+		if (F || I) return;
+		let e = (async () => {
+			try {
+				for (; !I && x.bufferedBytes;) {
+					if (await E.ready, I) return;
+					let e = x.take();
+					e && await E.write(e);
+				}
+			} catch {
+				I || q();
+			}
+		})();
+		F = e;
+		let t = () => {
+			F === e && (F = void 0), !I && x.bufferedBytes && Q();
+		};
+		e.then(t, () => {
+			q(), t();
+		});
+	}, $ = (t, n, r) => {
+		if (typeof n != "function" || I) throw c("Room stream cannot attach a listener after close");
+		if (!t.has(n) && t.size >= _) throw new e({
+			budget: "roomTransportListeners",
+			limit: _
+		});
+		return t.add(n), r ? N ??= X() : M ??= Y(), () => {
+			t.delete(n);
+		};
+	};
+	if (b.addEventListener("abort", K, { once: !0 }), b.aborted) {
+		let e = new i(() => W(1e3, "Room stream parent admission was cancelled"));
+		try {
+			await e.cleanupAsync();
+		} catch {
+			throw e;
+		}
+		throw c("Room stream admission was cancelled");
+	}
+	return Object.freeze({
+		name: "wt",
+		signal: D.signal,
+		reliable: Object.freeze({
+			send: (t) => {
+				if (I) return Promise.reject(c("Room stream transport is closed"));
+				let n;
+				try {
+					n = s(t, h);
+				} catch (e) {
+					return Promise.reject(e);
+				}
+				return j + n.byteLength > g ? (G(1009, "Room stream output exceeded its budget"), Promise.reject(new e({
+					budget: "maxQueuedBytes",
+					limit: g
+				}))) : new Promise((e, t) => {
+					j += n.byteLength, A.push({
+						bytes: n,
+						resolve: e,
+						reject: t
+					}), Z();
+				});
+			},
+			onFrame: (e) => $(O, e, !1)
+		}),
+		...x === void 0 ? {} : { unreliable: Object.freeze({
+			maxDatagramBytes: x.maxDatagramBytes,
+			send: (e) => {
+				x.offer(e), Q();
+			},
+			onFrame: (e) => $(k, e, !0)
+		}) },
+		stats: () => ({
+			rttMs: null,
+			queuedBytes: j,
+			droppedDatagrams: x?.droppedDatagrams ?? 0
+		}),
+		close: G,
+		closeAsync: W
+	});
+};
+export { l as makeRoomStreamTransport };

package/dist/subjectAdmission.js

@@ -0,0 +1,49 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOM_SUBJECT_PRIVACY_TABLE as t } from "./identities.js";
+import { canonicalRoomJson as n } from "./checkpointJson.js";
+import { and as r, eq as i, inSet as a } from "@voltro/database";
+import { createHash as o } from "node:crypto";
+// src/subjectAdmission.ts
+var s = (t, r) => {
+	if (![t, r].every((e) => typeof e == "string" && e.trim().length > 0 && e.length <= 191)) throw new e({ detail: "Rooms Subject admission requires an explicit tenant and identity" });
+	return o("sha256").update(n([t, r])).digest("hex");
+}, c = async (n, a) => {
+	let o = a.tenantId, c = a.subjectId;
+	if (typeof o != "string" || !o.trim() || o.length > 191) throw new e({ detail: "Rooms Subject admission requires an explicit tenant" });
+	if (c === null) return;
+	let l = s(o, c), u;
+	try {
+		u = await n.query({
+			table: t,
+			predicate: r(i("tenantId", o), i("subjectKey", l)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: ["tenantId", "subjectKey"]
+		});
+	} catch {
+		throw new e({ detail: "Rooms Subject admission could not be verified" });
+	}
+	if (!Array.isArray(u) || u.length > 1 || u.some((e) => typeof e != "object" || !e || e.tenantId !== o || e.subjectKey !== l)) throw new e({ detail: "Rooms Subject admission observation changed scope" });
+	if (u.length !== 0) throw new e({ detail: "Rooms Subject admission is fenced" });
+}, l = async (n, o, c) => {
+	if (typeof o != "string" || !o.trim() || o.length > 191) throw new e({ detail: "Rooms Subject admission requires an explicit tenant" });
+	let l = [...new Set(c.map((e) => s(o, e)))];
+	if (l.length === 0) return;
+	let u;
+	try {
+		u = await n.query({
+			table: t,
+			predicate: r(i("tenantId", o), a("subjectKey", l)),
+			order: [],
+			take: l.length + 1,
+			skip: void 0,
+			projection: ["tenantId", "subjectKey"]
+		});
+	} catch {
+		throw new e({ detail: "Rooms Subject admission could not be verified" });
+	}
+	if (!Array.isArray(u) || u.some((e) => typeof e != "object" || !e || e.tenantId !== o || !l.includes(e.subjectKey))) throw new e({ detail: "Rooms Subject admission observation changed scope" });
+	if (u.length !== 0) throw new e({ detail: "Rooms Subject admission is fenced" });
+};
+export { c as assertRoomSubjectAdmission, l as assertRoomSubjectsAdmission, s as roomSubjectPrivacyKey };