@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/checkpointStore.js

@@ -0,0 +1,386 @@
+import { ProtocolError as e, RoomHibernatePending as t } from "./errors.js";
+import { captureRoomListing as n } from "./room.js";
+import { ROOMS_TABLE as r, ROOM_CHECKPOINTS_TABLE as i, ROOM_COMMANDS_TABLE as a, ROOM_SEATS_TABLE as o } from "./identities.js";
+import { canonicalRoomJson as s } from "./checkpointJson.js";
+import { RoomCheckpointPort as c } from "./ports.js";
+import { worldTargetSeatBindingFromReceipt as l } from "./worldSeatBinding.js";
+import { captureRoomInputReceipts as u, captureRoomSeatInputReceipt as d } from "./inputReceipts.js";
+import { captureRoomSnapshotBlobReference as f } from "./snapshotBlob.js";
+import { captureRoomSnapshotBlobs as p, captureRoomSnapshotEffectRunner as m } from "./snapshotBlobIndex.js";
+import { retireRoomSnapshotSegments as h } from "./snapshotSegmentBlobs.js";
+import { appendRoomSnapshotRetiredClaims as g, cleanupRoomCheckpointBlobs as _, planRoomSnapshotBlobJournal as v } from "./snapshotBlobCleanup.js";
+import { appendRoomSnapshotUploadIntent as y, cleanupRoomSnapshotUploads as b, finishRoomSnapshotUploadIntent as x, recordRoomSnapshotUploadReference as S } from "./snapshotUploads.js";
+import { captureWorldActorReceipts as C } from "./worldActorReceipts.js";
+import { decodeDurableRoomCommand as w } from "./commandRecord.js";
+import { loadRoomSnapshotPayload as T, prepareRoomSnapshotPayload as E, writeRoomSnapshotPayload as D } from "./snapshotChain.js";
+import { and as O, eq as k, generateId as A, or as j } from "@voltro/database";
+import { Effect as M, Layer as N } from "effect";
+import { createHash as P } from "node:crypto";
+//#region src/checkpointStore.ts
+function F(t) {
+	throw new e({ detail: t });
+}
+var I = (t) => M.flatMap(M.context(), (n) => M.tryPromise({
+	try: () => t(m(n)),
+	catch: (t) => t instanceof e ? t : new e({ detail: "Durable Room checkpoint operation failed" })
+})), L = (n) => M.flatMap(M.context(), (r) => M.uninterruptible(M.tryPromise({
+	try: () => n(m(r)),
+	catch: (n) => n instanceof e || n instanceof t ? n : new e({ detail: "Durable Room checkpoint operation failed" })
+}))), R = async (e, t, n) => (await e.query({
+	table: t,
+	predicate: n,
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0,
+	lock: "update"
+}))[0], z = (e, t) => {
+	let n = P("sha256").update(e);
+	return t && n.update(t), n.digest("hex");
+}, B = (e, t, r, i) => {
+	let a = e.checkpoint, o = e.bytes;
+	(!a || typeof a != "object" || Array.isArray(a) || !(o instanceof Uint8Array)) && F("Malformed durable Room checkpoint");
+	let c = s(a);
+	(Buffer.byteLength(c) + o.byteLength > i || e.digest !== z(c, o)) && F("Durable Room checkpoint integrity or byte budget failed");
+	let l = JSON.parse(c);
+	if ((l.roomId !== t || l.tenantId !== r || ![l.epoch, l.revision].every((e) => Number.isSafeInteger(e) && e > 0) || ![l.tick, l.commandCursor].every((e) => Number.isSafeInteger(e) && e >= 0) || l.requestId !== `${t}:${l.epoch}:checkpoint:${l.revision}` || !Number.isSafeInteger(l.schemaHash) || l.schemaHash < 0 || l.schemaHash > 4294967295 || ![
+		"live",
+		"faulted",
+		"disposed",
+		"hibernating",
+		"hibernated"
+	].includes(l.disposition) || !Array.isArray(l.schedules) || !Array.isArray(l.commands)) && F("Invalid durable Room checkpoint identity"), l.publication !== void 0 && (l.publication !== "held" || l.disposition !== "live") && F("Invalid held checkpoint publication"), l.worldRecoveryEpoch !== void 0 && (l.publication !== "held" || !Number.isSafeInteger(l.worldRecoveryEpoch) || l.worldRecoveryEpoch < 1 || l.worldRecoveryEpoch > l.epoch) && F("Invalid held World recovery epoch"), u(l.inputReceipts), l.listing !== void 0) {
+		let e;
+		try {
+			e = n(t, l.listing);
+		} catch {
+			F("Invalid durable Room listing");
+		}
+		s(e) !== s(l.listing) && F("Invalid durable Room listing");
+	}
+	l.worldReceipts !== void 0 && C(l.worldReceipts), l.snapshot !== void 0 && (!l.snapshot || typeof l.snapshot != "object" || Array.isArray(l.snapshot) || Object.keys(l.snapshot).some((e) => ![
+		"mode",
+		"fullEvery",
+		"keepFulls",
+		"store",
+		"maxInlineBytes"
+	].includes(e)) || !["full", "delta"].includes(l.snapshot.mode) || !Number.isSafeInteger(l.snapshot.fullEvery) || l.snapshot.fullEvery < 1 || l.snapshot.fullEvery > 128 || !Number.isSafeInteger(l.snapshot.keepFulls) || l.snapshot.keepFulls < 1 || l.snapshot.keepFulls > 16 || l.snapshot.store !== "auto" || !Number.isSafeInteger(l.snapshot.maxInlineBytes) || l.snapshot.maxInlineBytes < 1 || l.snapshot.maxInlineBytes > 67108864) && F("Invalid durable Room snapshot encoding policy");
+	let d = /* @__PURE__ */ new Set();
+	for (let e of l.schedules) (!e || typeof e.label != "string" || !e.label.trim() || d.has(e.label) || !Number.isFinite(e.remainingMs) || e.remainingMs < 0 || e.intervalMs !== null && (!Number.isFinite(e.intervalMs) || e.intervalMs <= 0)) && F("Invalid durable Room checkpoint schedule"), d.add(e.label);
+	return {
+		...l,
+		bytes: Uint8Array.from(o)
+	};
+}, V = async (e, t, n, r, i, a, o, s = M.runPromise) => {
+	let c = await T(e, t, n, r, i, a, o, s);
+	return B({
+		...t,
+		bytes: c
+	}, n, r, i);
+}, H = async (t, n, r, a, o, c, l) => {
+	if (!c) return;
+	let u = /* @__PURE__ */ new Map(), d = (e, t) => s([e, t]), f = (await t.query({
+		table: i,
+		predicate: O(k("roomId", n), k("tenantId", r)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	return f && (f.blob != null || f.storage != null) && await V(t, f, n, r, a, o, {
+		...c,
+		read: (e, t) => M.tap(c.read(e, t), (n) => M.sync(() => {
+			u.set(d(e, t), Uint8Array.from(n));
+		}))
+	}, l), Object.freeze({
+		...c,
+		read: (t, n) => {
+			let r = u.get(d(t, n));
+			return r ? M.succeed(Uint8Array.from(r)) : M.fail(new e({ detail: "Snapshot blob changed after its pre-transaction read" }));
+		}
+	});
+}, U = (e, n) => {
+	let c = n.maxCheckpointBytes ?? 1048576, u = n.maxCommands ?? 1024, m = n.maxPendingCommands ?? 4096, C = n.snapshotCodec, T = p(n.snapshotBlobs), N = n.maxInlineBytes ?? Math.min(65536, c);
+	(!n.hostId.trim() || ![
+		c,
+		u,
+		m
+	].every((e) => Number.isSafeInteger(e) && e > 0) || u > m || !Number.isSafeInteger(N) || N < 1 || N > c) && F("Invalid checkpoint store options");
+	let P = () => {
+		let e = n.epochNow();
+		return !Number.isFinite(e) || e < 0 || e > 864e13 ? F("Invalid checkpoint wall clock") : new Date(e);
+	}, U = (e, t) => O(k("roomId", e), k("tenantId", t)), W = (e, t) => A({
+		kind: "typeid",
+		prefix: e
+	}, t), G = async (e, t, a, o, s, l = !1) => {
+		let u = await R(e, r, O(k("id", t), k("tenantId", a)));
+		if (!u) return !1;
+		if ((u.snapshotErasure != null || u.erasure != null) && F("Room snapshot privacy withdrawal was fenced"), u.state === "hibernated" && u.hostId === null) {
+			let r = await R(e, i, U(t, a));
+			(!r || r.ownerHostId !== n.hostId) && F("Hibernated Room receipt owner was fenced");
+			let l = await V(e, r, t, a, c, C, o, s);
+			return (l.disposition !== "hibernated" || l.epoch !== u.epoch) && F("Hibernated Room command receipt was fenced"), !1;
+		}
+		if ((u.hostId !== n.hostId || ![
+			"live",
+			"creating",
+			"faulted",
+			"disposed",
+			"hibernating"
+		].includes(String(u.state))) && F("Room command owner was fenced"), u.state === "creating") return l && Number(u.epoch) > 1;
+		if (u.state === "disposed" || u.state === "faulted") {
+			let n = await R(e, i, U(t, a));
+			if (!n && u.lockstepJournal != null) return !0;
+			(!n || (await V(e, n, t, a, c, C, o, s)).epoch !== u.epoch) && F("Terminal Room command owner was fenced");
+		}
+		return !0;
+	};
+	return Object.freeze({
+		commit: (p) => L(async (w) => {
+			(!p.roomId.trim() || !p.tenantId.trim() || ![p.epoch, p.revision].every((e) => Number.isSafeInteger(e) && e > 0) || ![p.tick, p.commandCursor].every((e) => Number.isSafeInteger(e) && e >= 0) || ![
+				"live",
+				"faulted",
+				"disposed",
+				"hibernating",
+				"hibernated"
+			].includes(p.disposition) || p.requestId !== `${p.roomId}:${p.epoch}:checkpoint:${p.revision}` || !(p.bytes instanceof Uint8Array) || p.bytes.byteLength > c || !Number.isSafeInteger(p.schemaHash) || p.schemaHash < 0 || p.schemaHash > 4294967295 || !Array.isArray(p.schedules) || !Array.isArray(p.inputReceipts) || !Array.isArray(p.commands) || p.commands.length > u) && F("Malformed checkpoint identity or budget");
+			let { bytes: A, ...M } = p, I = s(M), L = Uint8Array.from(A);
+			Buffer.byteLength(I) + L.byteLength > c && F("Checkpoint byte budget exceeded");
+			let G = JSON.parse(I), K = z(I, L);
+			B({
+				checkpoint: G,
+				bytes: L,
+				digest: K
+			}, G.roomId, G.tenantId, c), T && await w(b(e, T, G.roomId, G.tenantId, c)), T && await w(_(e, T, G.roomId, G.tenantId, {
+				maxBytes: c,
+				limit: 256
+			}));
+			let q = await H(e, G.roomId, G.tenantId, c, C, T, w), J = Math.min(N, G.snapshot?.maxInlineBytes ?? N);
+			G.snapshot?.mode === "full" && L.byteLength > J && !T && F("Full snapshot exceeds inline placement and needs its actual blob port");
+			let Y = null, X, Z, Q;
+			if (T && (G.snapshot?.mode === "delta" || G.snapshot?.mode === "full" && L.byteLength > J)) {
+				let t = await e.transactional(async (e) => {
+					let t = await R(e, r, O(k("id", G.roomId), k("tenantId", G.tenantId))), a = await R(e, i, U(G.roomId, G.tenantId));
+					if (G.publication === "held" && t?.state !== "creating" && F("Held checkpoint requires an unpublished owner"), (t?.snapshotErasure != null || t?.erasure != null) && F("Checkpoint snapshot privacy withdrawal was fenced"), a && a.checkpoint?.requestId === G.requestId) return a.digest !== K && F("Checkpoint requestId was reused with different data"), (!t || t.epoch !== G.epoch || t.hostId !== n.hostId && (t.state !== "hibernated" || t.hostId !== null || a.ownerHostId !== n.hostId)) && F("Checkpoint blob owner was fenced"), {
+						committed: !0,
+						plan: void 0,
+						intent: void 0
+					};
+					(!t || t.hostId !== n.hostId || t.epoch !== G.epoch || ![
+						"live",
+						"creating",
+						"hibernating"
+					].includes(String(t.state)) || G.revision !== (a?.checkpoint?.revision ?? 0) + 1) && F("Checkpoint blob admission was fenced");
+					let o = G.snapshot?.mode === "delta" && a ? await V(e, a, G.roomId, G.tenantId, c, C, q, w) : void 0, s = G.snapshot?.mode === "delta" ? await E(e, {
+						...G,
+						bytes: L
+					}, a, o, C) : void 0, l = s?.payload ?? L, u = l.byteLength > J ? {
+						roomId: G.roomId,
+						tenantId: G.tenantId,
+						hostId: n.hostId,
+						epoch: G.epoch,
+						revision: G.revision,
+						requestId: G.requestId,
+						fingerprint: K,
+						claimId: s ? `${G.requestId}:segment` : G.requestId,
+						size: l.byteLength,
+						checksum: z("", l),
+						reference: null
+					} : void 0;
+					return u && await y(e, t, u, c), {
+						committed: !1,
+						plan: s,
+						intent: u
+					};
+				});
+				Z = t.plan, Q = t.intent;
+				let a = Z?.payload ?? L;
+				if (!t.committed && a.byteLength > J) {
+					let t = {
+						roomId: G.roomId,
+						tenantId: G.tenantId,
+						epoch: G.epoch,
+						revision: G.revision
+					}, n = f(await w(T.write({
+						...t,
+						claimId: Z ? `${G.requestId}:segment` : G.requestId,
+						bytes: Uint8Array.from(a)
+					})), t, c);
+					(n.size !== a.byteLength || n.checksum !== z("", a)) && F("Uploaded snapshot does not match its retained checkpoint"), Q || F("Snapshot upload has no durable SQL intent"), await S(e, Q, n, c), Z ? X = n : Y = n;
+				}
+			}
+			await e.transactional(async (e) => {
+				let u = await R(e, r, O(k("id", G.roomId), k("tenantId", G.tenantId)));
+				(!u || u.epoch !== G.epoch || u.snapshotErasure != null || u.erasure != null) && F("Checkpoint owner was fenced");
+				let f = await R(e, i, U(G.roomId, G.tenantId)), p = f ? await V(e, f, G.roomId, G.tenantId, c, C, q, w) : void 0;
+				if (u.state === "hibernated") {
+					(u.hostId !== null || f?.ownerHostId !== n.hostId || p?.disposition !== "hibernated" || G.disposition !== "hibernated" || p.requestId !== G.requestId || f.digest !== K) && F("Hibernated checkpoint receipt was fenced");
+					return;
+				}
+				if ((u.hostId !== n.hostId || ![
+					"live",
+					"creating",
+					"faulted",
+					"disposed",
+					"hibernating"
+				].includes(String(u.state))) && F("Checkpoint owner was fenced"), G.publication === "held" && u.state !== "creating" && F("Held checkpoint requires an unpublished owner"), p?.requestId === G.requestId) {
+					f?.digest !== K && F("Checkpoint requestId was reused with different data");
+					return;
+				}
+				G.disposition === "hibernated" ? (u.state !== "hibernating" || p?.disposition !== "hibernating" || p.epoch !== G.epoch || G.commands.length !== 0 || G.tick !== p.tick || G.commandCursor !== p.commandCursor || G.schemaHash !== p.schemaHash || s(G.schedules) !== s(p.schedules) || s(G.inputReceipts) !== s(p.inputReceipts) || !Buffer.from(L).equals(Buffer.from(p.bytes))) && F("Hibernate requires the unchanged staged durable snapshot") : u.state !== "live" && u.state !== "creating" && F("Room is no longer live"), (G.revision !== (p?.revision ?? 0) + 1 || G.epoch < (p?.epoch ?? 0) || G.commandCursor < (p?.commandCursor ?? 0)) && F("Checkpoint revision or cursor regressed");
+				let _ = v(f, {
+					...G,
+					bytes: L
+				}, Y, c);
+				!T && (_.blobHistory.length || _.retiredBlobs.length) && F("Snapshot claim history needs its actual blob port");
+				let y = await e.query({
+					table: a,
+					predicate: O(U(G.roomId, G.tenantId), k("acknowledged", !1)),
+					order: [],
+					take: m + 1,
+					skip: void 0,
+					projection: ["id"]
+				});
+				if (y.length + G.commands.length > m && F("Pending Room app commands exceed their durable budget"), G.disposition === "hibernated") {
+					let n = await e.query({
+						table: o,
+						predicate: O(U(G.roomId, G.tenantId), j(k("state", "reserved"), k("state", "connected"), k("state", "grace"))),
+						order: [],
+						take: 1,
+						skip: void 0,
+						projection: ["id"]
+					});
+					if (y.length !== 0 || n.length !== 0 || u.clients !== 0) throw new t({ roomId: G.roomId });
+				}
+				let b = /* @__PURE__ */ new Set();
+				for (let t of G.commands) {
+					let n = `${G.roomId}:${G.epoch}:`, r = Number(t.requestId.slice(n.length));
+					(!t.requestId.startsWith(n) || !Number.isSafeInteger(r) || r < 1 || r > G.commandCursor || p?.epoch === G.epoch && r <= p.commandCursor || b.has(t.requestId) || !["run", "publish"].includes(t.kind) || !t.name.trim() || t.kind === "publish" && !t.key?.trim()) && F("Malformed or replayed checkpoint command"), b.add(t.requestId);
+					let i = z(s(t));
+					await e.insert(a, {
+						id: W("rcmd", a),
+						roomId: G.roomId,
+						tenantId: G.tenantId,
+						requestId: t.requestId,
+						command: t,
+						digest: i,
+						epoch: G.epoch,
+						sequence: r,
+						acknowledged: !1,
+						createdAt: P()
+					});
+				}
+				for (let t of G.inputReceipts) {
+					let n = O(U(G.roomId, G.tenantId), k("sessionId", t.sessionId), k("subjectId", t.subjectId), k("epoch", G.epoch)), r = await R(e, o, n);
+					if (!r) continue;
+					let i = d(r.inputReceipt);
+					t.discardedThrough !== void 0 && !l(r.reservationBatchReceipt) && F("Discarded input checkpoint requires a World target Seat"), i && (i.checkpointEpoch > G.epoch || i.lastAppliedSeq > t.lastAppliedSeq || (i.discardedThrough ?? -1) > (t.discardedThrough ?? -1)) && F("Checkpoint input receipt regressed"), await e.updateMany(o, { inputReceipt: {
+						lastAppliedSeq: t.lastAppliedSeq,
+						...t.discardedThrough === void 0 ? {} : { discardedThrough: t.discardedThrough },
+						checkpointEpoch: G.epoch,
+						checkpointRevision: G.revision,
+						checkpointTick: G.tick
+					} }, { where: O(n, k("id", r.id)) });
+				}
+				let S = Y ? {
+					bytes: /* @__PURE__ */ new Uint8Array(),
+					storage: null,
+					retiredBlobs: await h(e, G.roomId, G.tenantId, c)
+				} : await D(e, {
+					...G,
+					bytes: L
+				}, f, p, C, P(), J, Z, X, c), E = g(_, {
+					...G,
+					bytes: L
+				}, Y, S.retiredBlobs, c), A = {
+					checkpoint: G,
+					bytes: S.bytes,
+					storage: S.storage,
+					blob: Y,
+					...E,
+					digest: K,
+					ownerHostId: n.hostId,
+					updatedAt: P()
+				};
+				if (f ? await e.updateMany(i, A, { where: O(U(G.roomId, G.tenantId), k("id", f.id)) }) : await e.insert(i, {
+					id: W("rcheck", i),
+					roomId: G.roomId,
+					tenantId: G.tenantId,
+					...A
+				}), await x(e, G.roomId, G.tenantId, G.requestId, K, c), G.publication !== "held" && (G.disposition !== "live" || u.state === "creating")) {
+					let t = G.disposition === "faulted" || G.disposition === "disposed";
+					t && await e.updateMany(o, {
+						state: "released",
+						graceUntil: null,
+						updatedAt: P()
+					}, { where: O(U(G.roomId, G.tenantId), k("epoch", G.epoch)) }), await e.updateMany(r, {
+						state: G.disposition,
+						updatedAt: P(),
+						...t ? { clients: 0 } : {},
+						...G.disposition === "hibernated" ? { hostId: null } : {}
+					}, { where: O(k("id", G.roomId), k("tenantId", G.tenantId), k("epoch", G.epoch), k("hostId", n.hostId)) });
+				}
+				let M = G.listing;
+				M !== void 0 && G.publication !== "held" && G.disposition === "live" && await e.updateMany(r, {
+					...M.metadata === void 0 ? {} : { metadata: M.metadata },
+					...M.private === void 0 ? {} : { private: M.private },
+					...M.locked === void 0 ? {} : { locked: M.locked },
+					updatedAt: P()
+				}, { where: O(k("id", G.roomId), k("tenantId", G.tenantId), k("epoch", G.epoch), k("hostId", n.hostId), k("state", "live")) });
+			}), T && await w(_(e, T, G.roomId, G.tenantId, {
+				maxBytes: c,
+				limit: 256
+			}));
+		}),
+		load: (t, n) => M.uninterruptible(I(async (a) => {
+			let o = await H(e, t, n, c, C, T, a);
+			return e.transactional(async (e) => {
+				await R(e, r, O(k("id", t), k("tenantId", n)));
+				let s = await R(e, i, U(t, n));
+				return s ? V(e, s, t, n, c, C, o, a) : null;
+			});
+		})),
+		pending: (t, n, r) => I(async (i) => {
+			let o = await H(e, t, n, c, C, T, i);
+			return e.transactional(async (e) => ((!Number.isSafeInteger(r) || r < 1 || r > u) && F("Invalid pending command limit"), await G(e, t, n, o, i, !0) ? (await e.query({
+				table: a,
+				predicate: O(U(t, n), k("acknowledged", !1)),
+				order: [{
+					column: "epoch",
+					direction: "asc"
+				}, {
+					column: "sequence",
+					direction: "asc"
+				}],
+				take: r,
+				skip: void 0,
+				projection: [
+					"roomId",
+					"tenantId",
+					"command",
+					"digest",
+					"requestId",
+					"epoch",
+					"sequence"
+				]
+			})).map((e) => w(e, t, n, c)) : []));
+		}),
+		acknowledge: (t, n, r) => I(async (i) => {
+			let o = await H(e, t, n, c, C, T, i);
+			return e.transactional(async (e) => {
+				await G(e, t, n, o, i) && await e.updateMany(a, { acknowledged: !0 }, { where: O(U(t, n), k("requestId", r)) });
+			});
+		}),
+		park: (t, n, r) => I(async (i) => {
+			let o = await H(e, t, n, c, C, T, i);
+			return e.transactional(async (e) => {
+				await G(e, t, n, o, i) && await e.updateMany(a, {
+					acknowledged: !0,
+					failedAt: P()
+				}, { where: O(U(t, n), k("requestId", r), k("acknowledged", !1)) });
+			});
+		})
+	});
+}, W = (e, t) => N.succeed(c, U(e, t));
+//#endregion
+export { s as canonicalRoomJson, U as dataStoreRoomCheckpoints, B as decodeDurableRoomCheckpoint, V as loadDurableRoomCheckpoint, H as prefetchRoomCheckpointBlobs, W as roomCheckpointLayer };

package/dist/client.js

@@ -0,0 +1,56 @@
+import { RoomConnection as e } from "./connection.js";
+import { roomTransportConnector as t } from "./transportConnector.js";
+import { roomRpcReservations as n, worldRpcJoin as r } from "./rpcClient.js";
+//#region src/client.ts
+var i = (n, r, i) => {
+	let a = i.clock ?? { now: () => performance.now() };
+	return new e(n, a, r, t({
+		clock: a,
+		socket: i.socket,
+		webTransport: i.webTransport,
+		preference: i.transportPreference
+	}), i);
+}, a = async (e, t, n, r) => {
+	let a = i(e, t, r);
+	try {
+		return await a.start(n), a;
+	} catch (e) {
+		try {
+			await a.leave();
+		} catch (t) {
+			throw AggregateError([e, t], "Room entry and withdrawal failed");
+		}
+		throw e;
+	}
+}, o = (e, t, r, i) => a(t, n(e), r, i), s = (e, t, n, r) => o(e, t, {
+	mode: "join",
+	...n
+}, r), c = (e, t, n, r) => o(e, t, {
+	mode: "create",
+	...n
+}, r), l = (e, t, n, r) => o(e, t, {
+	mode: "joinById",
+	...n
+}, r), u = (e, t, r, i) => {
+	let o = n(e);
+	return a(t, {
+		reserve: (e, t) => o.resume(e.sessionId, t),
+		resume: o.resume,
+		...o.release ? { release: o.release } : {}
+	}, { sessionId: r.sessionId }, i);
+}, d = async (e, t, i, o) => {
+	let s = n(e), c = r(e), l;
+	return {
+		connection: await a(t, {
+			reserve: async (e, t) => {
+				let n = await c(e.world, t);
+				return l = n.entityId, n.reservation;
+			},
+			resume: s.resume,
+			...s.release ? { release: s.release } : {}
+		}, { world: i.world }, o),
+		entityId: l
+	};
+};
+//#endregion
+export { c as createRoom, i as createRoomClient, l as joinById, s as joinRoom, u as joinSeat, d as joinWorld };

package/dist/clockSync.js

@@ -0,0 +1,51 @@
+import { ProtocolError as e } from "./errors.js";
+//#region src/clockSync.ts
+var t = (e) => {
+	if (e.length === 0) return 0;
+	let t = [...e].sort((e, t) => e - t), n = Math.floor(t.length / 2);
+	return t.length % 2 == 0 ? ((t[n - 1] ?? 0) + (t[n] ?? 0)) / 2 : t[n] ?? 0;
+}, n = class {
+	clock;
+	samples = [];
+	lastServerNow = -Infinity;
+	provisionalOffset = null;
+	constructor(e) {
+		this.clock = e;
+	}
+	anchor(t, n = this.clock.now()) {
+		if (![t, n].every((e) => Number.isFinite(e) && e >= 0)) throw new e({ detail: "Invalid monotonic clock anchor" });
+		this.provisionalOffset = t - n;
+	}
+	reset() {
+		this.samples.length = 0, this.provisionalOffset = null, this.lastServerNow = -Infinity;
+	}
+	pong(t, n, r = this.clock.now()) {
+		if (![
+			t,
+			n,
+			r
+		].every((e) => Number.isFinite(e) && e >= 0) || r < t) throw new e({ detail: "Invalid monotonic ping/pong timestamps" });
+		let i = r - t, a = n - (t + r) / 2;
+		this.samples.length === 8 && this.samples.shift(), this.samples.push({
+			rttMs: i,
+			offsetMs: a
+		});
+	}
+	stats() {
+		return this.samples.length === 0 ? {
+			rttMs: null,
+			offsetMs: null
+		} : {
+			rttMs: t(this.samples.map((e) => e.rttMs)),
+			offsetMs: t(this.samples.map((e) => e.offsetMs))
+		};
+	}
+	serverNow() {
+		let t = this.clock.now();
+		if (!Number.isFinite(t) || t < 0) throw new e({ detail: "The local monotonic clock is invalid" });
+		let n = this.stats().offsetMs ?? this.provisionalOffset;
+		return n === null ? null : (this.lastServerNow = Math.max(this.lastServerNow, t + n), this.lastServerNow);
+	}
+};
+//#endregion
+export { n as RoomClockSync };

package/dist/collision.js

@@ -0,0 +1,156 @@
+import { BudgetExceeded as e, RoomAuthoringError as t } from "./errors.js";
+import { spatialGrid as n } from "./spatial.js";
+//#region src/collision.ts
+function r(e) {
+	throw new t({
+		room: "collision",
+		detail: e
+	});
+}
+var i = (e) => Number.isFinite(e) ? e : r("Collision geometry must be finite"), a = (e) => i(e) > 0 ? e : r("Collision extents must be positive"), o = (e) => {
+	if (e.kind === "circle") {
+		let t = a(e.radius);
+		return {
+			x: t,
+			y: t,
+			radius: t
+		};
+	}
+	e.kind !== "aabb" && r("Unknown collision body");
+	let t = a(e.halfWidth), n = a(e.halfHeight);
+	return {
+		x: t,
+		y: n,
+		radius: a(Math.hypot(t, n))
+	};
+}, s = (e) => {
+	i(e.x), i(e.y);
+}, c = (e) => {
+	let t = n(e), i = a(e.maxObstacleRadius);
+	return (!Number.isSafeInteger(e.maxIterations) || e.maxIterations < 1 || e.maxIterations > 256) && r("Collision iterations must have a positive bounded budget"), Object.freeze({
+		maxObstacleRadius: i,
+		maxIterations: e.maxIterations,
+		set: (e, n) => {
+			s(n.position), o(n.body).radius > i && r("Obstacle exceeds its declared broadphase bound"), t.set(e, n.position, n);
+		},
+		delete: (e) => t.delete(e),
+		get: (e) => t.get(e),
+		nearby: (e, n) => t.nearby(e, n)
+	});
+}, l = (t) => {
+	let n = a(t.tileSize), o = n / 2;
+	(!Number.isSafeInteger(t.width) || t.width < 1 || !Number.isSafeInteger(t.height) || t.height < 1 || !Number.isSafeInteger(t.maxTiles) || t.maxTiles < 1 || t.maxTiles > 16384) && r("Tile dimensions and budget must be positive bounded integers");
+	let l = t.width * t.height;
+	if (!Number.isSafeInteger(l) || l > t.maxTiles) throw new e({
+		budget: "collisionTiles",
+		limit: t.maxTiles
+	});
+	(!Array.isArray(t.solid) || t.solid.length !== l) && r("Tile occupancy must be a complete dense row-major array"), s(t.origin);
+	let u = t.origin.x, d = t.origin.y, f = t.width;
+	i(u + t.width * n), i(d + t.height * n);
+	let p = [];
+	for (let e = 0; e < l; e++) (!Object.hasOwn(t.solid, e) || typeof t.solid[e] != "boolean") && r("Tile occupancy must contain only explicit booleans"), t.solid[e] && p.push({
+		id: `tile:${e % f}:${Math.floor(e / f)}`,
+		entity: {
+			position: {
+				x: i(u + (e % f + .5) * n),
+				y: i(d + (Math.floor(e / f) + .5) * n)
+			},
+			body: {
+				kind: "aabb",
+				halfWidth: o,
+				halfHeight: o
+			},
+			solid: !0
+		}
+	});
+	let m = c({
+		cell: t.cell,
+		maxEntities: t.maxEntities,
+		maxQueryCells: t.maxQueryCells,
+		maxObstacleRadius: t.maxObstacleRadius,
+		maxIterations: t.maxIterations
+	});
+	if (p.length > t.maxEntities) throw new e({
+		budget: "spatialEntities",
+		limit: t.maxEntities
+	});
+	for (let e of p) m.set(e.id, e.entity);
+	let h = (e) => {
+		e.startsWith("tile:") && r("Static tile identities are reserved");
+	};
+	return Object.freeze({
+		maxObstacleRadius: m.maxObstacleRadius,
+		maxIterations: m.maxIterations,
+		set: (e, t) => {
+			h(e), m.set(e, t);
+		},
+		delete: (e) => (h(e), m.delete(e)),
+		get: m.get,
+		nearby: m.nearby
+	});
+}, u = (e, t, n, r) => {
+	let i = e.x - t.x, a = e.y - t.y, o = n - Math.abs(i), s = r - Math.abs(a);
+	return o <= 0 || s <= 0 ? null : o <= s ? {
+		x: i <= 0 ? -o : o,
+		y: 0
+	} : {
+		x: 0,
+		y: a <= 0 ? -s : s
+	};
+}, d = (e, t, n, r, a) => {
+	let o = e.x - n.x, s = e.y - n.y, c = Math.max(-r, Math.min(r, o)), l = Math.max(-a, Math.min(a, s)), d = o - c, f = s - l, p = i(Math.hypot(d, f));
+	return p >= t ? null : p > 0 ? {
+		x: d * (t - p) / p,
+		y: f * (t - p) / p
+	} : u(e, n, r + t, a + t);
+}, f = (e, t, n) => {
+	let r = o(t), a = o(n.body);
+	if (t.kind === "aabb" && n.body.kind === "aabb") return u(e, n.position, r.x + a.x, r.y + a.y);
+	if (t.kind === "circle" && n.body.kind === "aabb") return d(e, r.radius, n.position, a.x, a.y);
+	if (t.kind === "aabb" && n.body.kind === "circle") {
+		let t = d(n.position, a.radius, e, r.x, r.y);
+		return t ? {
+			x: -t.x,
+			y: -t.y
+		} : null;
+	}
+	let s = e.x - n.position.x, c = e.y - n.position.y, l = i(Math.hypot(s, c)), f = r.radius + a.radius - l;
+	return f <= 0 ? null : l === 0 ? {
+		x: -f,
+		y: 0
+	} : {
+		x: s * f / l,
+		y: c * f / l
+	};
+}, p = (t, n, c, l) => {
+	s(t), i(t.rot), i(t.vx ?? 0), i(t.vy ?? 0);
+	let u = o(n), d = a(c.maxObstacleRadius);
+	(!Number.isSafeInteger(c.maxIterations) || c.maxIterations < 1 || c.maxIterations > 256) && r("Collision iterations must have a positive bounded budget");
+	let p = { ...t }, m = /* @__PURE__ */ new Set(), h = 0;
+	for (; h < c.maxIterations; h++) {
+		let e = !1, t = [...c.nearby(p, i(u.radius + d))].sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id));
+		for (let a of t) {
+			if (a.id === l || !a.value.solid) continue;
+			s(a.value.position), o(a.value.body).radius > d && r("Obstacle exceeds its declared broadphase bound");
+			let t = f(p, n, a.value);
+			t && (p.x = i(p.x + t.x), p.y = i(p.y + t.y), t.x !== 0 && (p.vx = 0), t.y !== 0 && (p.vy = 0), m.add(a.id), e = !0);
+		}
+		if (!e) return {
+			transform: p,
+			collided: [...m].sort(),
+			iterations: h + 1
+		};
+	}
+	for (let t of c.nearby(p, i(u.radius + d))) if (t.id !== l && t.value.solid && f(p, n, t.value)) throw new e({
+		budget: "collisionIterations",
+		limit: c.maxIterations
+	});
+	return {
+		transform: p,
+		collided: [...m].sort(),
+		iterations: h
+	};
+};
+//#endregion
+export { p as collide, c as collisionWorld, l as tileCollisionWorld2D };