@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/apiReservations.js

@@ -0,0 +1,432 @@
+import { BudgetExceeded as e, NotRoomMember as t, ProtocolError as n, RoomAuthoringError as r, RoomForbidden as i, RoomFull as a, RoomGone as o, RoomLocked as s, RoomsClosed as c, SeatExpired as l } from "./errors.js";
+import { simulationOwnData as u } from "./simulationAuthoring.js";
+import { createSimulationOptionsCodec as d } from "./simulationOptionsWire.js";
+import { captureRoomSeatAttributes as f } from "./room.js";
+import { RoomStateCodec as p } from "./stateCodec.js";
+import { captureRoomTransportEndpoints as m, roomHostTransportEndpoints as h } from "./transportEndpoints.js";
+import { RoomReservationSchema as ee } from "./reservationSchemas.js";
+import { ROOMS_TABLE as g, ROOM_CHECKPOINTS_TABLE as _, ROOM_CREATIONS_TABLE as v, ROOM_SEATS_TABLE as y } from "./identities.js";
+import { ReserveRoomInput as b } from "./rpc.js";
+import { canonicalRoomJson as x } from "./checkpointJson.js";
+import { assertRoomSubjectAdmission as S } from "./subjectAdmission.js";
+import { RoomReservePort as C } from "./ports.js";
+import { captureRoomSnapshotBlobs as te, captureRoomSnapshotEffectRunner as ne } from "./snapshotBlobIndex.js";
+import { createRoomLockstepAdmissionCodec as re } from "./lockstepAdmissionCodec.js";
+import { assertRoomSeatSecrets as ie, resolveRoomSeatTokenStrategies as ae, roomSeatTokenDigest as w, verifyRoomSeatWithStrategy as oe } from "./seats.js";
+import { assertRoomPoolRecoveryTarget as se, captureAdmittedRoomPoolTopology as ce, resolveRoomPool as le } from "./roomPoolTopology.js";
+import { loadDurableRoomCheckpoint as ue, prefetchRoomCheckpointBlobs as de } from "./checkpointStore.js";
+import { captureRoomLockstepRecoveryOptions as fe, readRoomLockstepRecoveryTruth as pe } from "./lockstepRecoveryTruth.js";
+import { matchRoomCreationKey as me } from "./matchRooms.js";
+import { resolveRoomHostSelection as he } from "./hostSelection.js";
+import { resolveRoomPoolHostSelection as ge } from "./roomPoolSelection.js";
+import { decodeRoomDirectoryListing as _e } from "./directory.js";
+import { and as T, eq as E, or as ve } from "@voltro/database";
+import { checkGuardsEffect as ye } from "@voltro/protocol";
+import { Effect as D, Layer as O, Result as k, Schema as A } from "effect";
+// src/apiReservations.ts
+var be = (e, t) => {
+	if (e === void 0) return null;
+	let r = typeof e == "object" && e && "until" in e ? e.until : void 0;
+	if (typeof r != "number" || !Number.isSafeInteger(r)) throw new n({ detail: "Room access grant needs an epoch-ms deadline" });
+	if (r <= t) throw new c({
+		until: null,
+		messageKey: "rooms.accessEnded"
+	});
+	return r;
+}, j = (e) => (t) => t.subject.type === "user" ? D.suspend(() => e.until(t.subject)).pipe(D.orDie, D.flatMap((t) => t === null ? D.fail(new c({
+	until: null,
+	messageKey: e.messageKey
+})) : D.succeed({ until: t }))) : D.void, xe = (e) => {
+	let t = e.accessUntil;
+	if (t == null) return null;
+	let r = t instanceof Date ? t.getTime() : typeof t == "string" ? Date.parse(t) : typeof t == "number" ? t : NaN;
+	if (!Number.isFinite(r)) throw new n({ detail: "Room seat access deadline is unreadable" });
+	return r;
+};
+function M(e) {
+	throw new n({ detail: e });
+}
+var N = (e) => typeof e == "string" && e.trim() && e.length <= 191 ? e : M("Invalid Room routing identity"), P = (e) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 ? e : M("Invalid Room routing epoch"), F = async (e) => {
+	let t = await D.runPromise(D.result(e));
+	if (k.isFailure(t)) throw t.failure;
+	return t.success;
+}, I = (u) => D.flatMap(D.context(), (d) => D.uninterruptible(D.tryPromise({
+	try: () => u(ne(d)),
+	catch: (u) => u instanceof n || u instanceof e || u instanceof i || u instanceof a || u instanceof o || u instanceof s || u instanceof c || u instanceof l || u instanceof r || u instanceof t ? u : new n({ detail: "Room API routing could not be completed" })
+}))), L = (e, t) => {
+	try {
+		let n = e();
+		return I((e) => t(n, e));
+	} catch (e) {
+		return I(async () => {
+			throw e;
+		});
+	}
+}, R = (e, t, n, r = 1, i = !1) => e.query({
+	table: t,
+	predicate: n,
+	order: [{
+		column: "id",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0,
+	...i ? { lock: "update" } : {}
+}), z = (t, n) => {
+	let r = n.pools === void 0 ? void 0 : ce(n.pools), C = Object.getOwnPropertyDescriptor(n, "lockstepRecovery");
+	if (C && (!C.enumerable || !("value" in C)) || !C && "lockstepRecovery" in n) return M("API Lockstep recovery budgets require own data");
+	let ne = C?.value === void 0 ? {} : u(C.value, [
+		"maxTicks",
+		"maxJournalBytes",
+		"maxPlayers"
+	], []), O = Object.freeze({ ...n }), j = O.maxListedRooms ?? 256, I = O.maxHostAttempts ?? 32, z = O.maxCheckpointBytes ?? 1048576, Se = ae(O.strategies?.seatToken), B = O.strategies?.selectHost;
+	(![
+		j,
+		I,
+		z
+	].every((e) => Number.isSafeInteger(e) && e > 0) || j > 256 || I > 256 || typeof O.region != "function" || typeof O.membership?.list != "function") && M("Invalid Room API routing budgets or topology"), ie(O.secrets), O.admission !== void 0 && typeof O.admission != "function" && M("Room reservation admission must be a function");
+	let Ce = O.admission;
+	O.seatAttributes !== void 0 && typeof O.seatAttributes != "function" && M("Room seat attributes must be resolved by a function");
+	let we = O.seatAttributes, V = async (e, t, n, r) => {
+		if (!we) return;
+		let i = await D.runPromise(D.result(D.suspend(() => we(Object.freeze({
+			subject: structuredClone(e),
+			room: t,
+			roomId: n,
+			role: r
+		}))))).catch(() => null);
+		if (i === null || k.isFailure(i)) return M("Room seat attributes are unavailable");
+		try {
+			return f(t, i.success);
+		} catch {
+			return M("Room seat attributes are invalid");
+		}
+	}, H = async (e, t, n) => {
+		if (!Ce) return null;
+		let r = await D.runPromise(D.result(D.suspend(() => Ce(Object.freeze({
+			subject: structuredClone(e),
+			room: t,
+			mode: n
+		}))))).catch(() => null);
+		if (r === null && M("Room reservation admission is unavailable"), k.isFailure(r)) {
+			let e = r.failure;
+			if (e instanceof c) throw new c({
+				until: e.until,
+				messageKey: e.messageKey
+			});
+			M("Room reservation admission is unavailable");
+		}
+		return be(r.success, K());
+	}, U = async (e, n, r) => (r !== null && await t.updateMany(y, { accessUntil: new Date(r) }, { where: T(E("sessionId", e.sessionId), E("tenantId", n)) }), e), Te = structuredClone(O.secrets), Ee = te(O.snapshotBlobs), De = O.match === void 0 ? void 0 : Object.freeze({ prepareRoom: O.match.prepareRoom.bind(O.match) }), W = Object.freeze({
+		reserve: O.control.reserve.bind(O.control),
+		resume: O.control.resume.bind(O.control),
+		leave: O.control.leave.bind(O.control)
+	}), Oe = O.adoption.adopt.bind(O.adoption), ke = O.recovery.claim.bind(O.recovery), Ae = O.directory.hosts.bind(O.directory), je = O.membership.list.bind(O.membership), G = O.region, Me = O.epochNow, K = () => {
+		let e = Me();
+		return Number.isSafeInteger(e) && e >= 0 && e <= 864e13 ? e : M("Invalid Room API routing wall clock");
+	}, q = (e) => {
+		if (e.type === "system" || e.type === "service") throw new i({ roomId: "" });
+		return {
+			tenantId: N(e.tenantId),
+			subjectId: e.id === null ? null : N(e.id)
+		};
+	}, J = async (e, t, n, r = "") => {
+		let a = q(t);
+		if (a.subjectId === null && e.auth !== "public" || await F(ye(t, e.guards, n, {
+			defaultDeny: !0,
+			procedure: `rooms.${e.name}`
+		}))) throw new i({ roomId: r });
+		return a;
+	}, Y = async (e, n) => {
+		let r = (await R(t, g, T(E("id", N(e)), E("tenantId", n))))[0];
+		if (!r) throw new o({ roomId: e });
+		return P(r.epoch), N(r.name), r;
+	}, X = (e, t, n, i, a) => {
+		if (!r) return a !== void 0 || i?.pool != null ? M("Pooled Room routing requires its admitted topology") : void 0;
+		let o = i === void 0 ? a : N(i.pool);
+		return i !== void 0 && a !== void 0 && o !== a ? M("Requested Room pool does not match durable ownership") : le(r, t, q(e).tenantId, n, o).name;
+	}, Z = async (e, t, n, r) => {
+		let i = N(G(structuredClone(e), t)), a = je(), o = X(e, t, i, n, r);
+		return (await F(Ae(i, o))).filter((e) => e.ready && e.region === i && (o === void 0 ? e.pool === void 0 : e.pool === o) && e.membership && a.some((t) => t.instanceId === e.membership.instanceId && t.startedAt === e.membership.startedAt));
+	}, Ne = (e, t, n, i, a) => {
+		let o = N(G(structuredClone(t), n)), s = X(t, n, o, i, a);
+		if (!r) return he(e, o, B);
+		let c = e.map((e) => e.pool === void 0 || e.clientCapacity === void 0 ? M("API candidate lacks pool registration metadata") : e);
+		return ge(r, c, n, q(t).tenantId, o, s, O.poolSelectHost ?? (B === void 0 ? void 0 : (e, t) => {
+			let n = B(e, t);
+			return n === null ? null : n;
+		}));
+	}, Q = async (e, t) => {
+		let n = (await Z(t, N(e.name), e)).find((t) => t.id === e.hostId);
+		if (!n) throw new o({ roomId: N(e.id) });
+		return se(r, N(e.name), q(t).tenantId, e.pool, n.pool, n.region), n;
+	}, Pe = fe({
+		descriptor: (e) => {
+			let t = O.catalog.get(e);
+			return t.mode === "lockstep" ? t : void 0;
+		},
+		maxJournalBytes: z,
+		...ne
+	}), Fe = (e, t) => pe(e, t, Pe), Ie = async (e, t, n, r) => {
+		let i = N(t.id), a = N(t.tenantId), s = (await R(e, _, T(E("roomId", i), E("tenantId", a))))[0];
+		if (!s) throw new o({ roomId: i });
+		return ue(e, s, i, a, z, (e) => new p(O.catalog.get(e).state), n, r);
+	}, Le = async (e, n, r, i, a) => {
+		let s = await de(t, e, n, z, (e) => new p(O.catalog.get(e).state), Ee, a);
+		return t.transactional(async (t) => {
+			let c = (await R(t, g, T(E("id", e), E("tenantId", n)), 1, !0))[0];
+			if (!c || c.state !== "live" || c.hostId !== r || c.epoch !== i) throw new o({ roomId: e });
+			if (O.catalog.get(N(c.name)).mode === "lockstep") {
+				let e = await Fe(t, c);
+				e && e.admission.adoption?.priorEpoch === i - 1 || M("Lockstep publication needs its actual retained adoption");
+			} else {
+				let e = await Ie(t, c, s, a);
+				(e.disposition !== "live" || e.epoch !== i) && M("Room wake has no matching published SQL checkpoint");
+			}
+			return c;
+		});
+	}, Re = async (e, n, r) => {
+		let s = N(e.id), c = N(e.tenantId), l = P(e.epoch), u, d;
+		if (e.state === "creating") {
+			if (O.catalog.get(N(e.name)).mode === "lockstep") {
+				let r = await t.transactional(async (t) => {
+					let n = (await R(t, g, T(E("id", s), E("tenantId", c)), 1, !0))[0];
+					if (!n || n.state !== "creating" || n.epoch !== l || n.hostId !== e.hostId) throw new o({ roomId: s });
+					return Fe(t, n);
+				});
+				if (!r || r.admission.adoption?.priorEpoch !== l - 1) throw new o({ roomId: s });
+				u = await Q(e, n), d = r.admission.adoption.priorEpoch;
+			} else {
+				let i = await Ie(t, e, Ee, r);
+				if (i.disposition !== "hibernated" || i.epoch + 1 !== l) throw new o({ roomId: s });
+				u = await Q(e, n), d = i.epoch;
+			}
+		} else {
+			let t = e.state === "orphaned" && O.catalog.get(N(e.name)).mode === "lockstep";
+			if (!t && (e.state !== "hibernated" || e.hostId !== null || e.clients !== 0)) throw new o({ roomId: s });
+			let f = await Z(n, N(e.name), e), p = null;
+			for (let o = 0; o < I && f.length; o++) {
+				let o = Ne(f, n, N(e.name), e);
+				if (!o) break;
+				try {
+					let e = await F(ke(o.id, s, c, l));
+					(e.listing.id !== s || e.listing.tenantId !== c || e.listing.hostId !== o.id || e.listing.epoch !== l + 1) && M("Room wake port returned an unrelated claim"), t && (e.mode !== "lockstep" || e.checkpoint !== null) && M("Lockstep orphan claim cannot supply a state checkpoint"), p = o;
+					break;
+				} catch (e) {
+					if (e instanceof a) {
+						f.splice(f.findIndex((e) => e.id === o.id), 1);
+						continue;
+					}
+					e instanceof i || M("Room wake claim outcome is unconfirmed; retry the same room");
+					let t = await Y(s, c);
+					if (t.epoch !== l + 1 || !["creating", "live"].includes(String(t.state))) throw e;
+					if (t.state === "live") try {
+						return await Le(s, c, N(t.hostId), l + 1, r);
+					} catch {
+						return M("Competing Room wake publication is unconfirmed");
+					}
+					return Re(t, n, r);
+				}
+			}
+			if (!p) throw new a({ roomId: "host" });
+			u = p, d = l;
+		}
+		try {
+			return await F(Oe(u.id, s, c, d)), await Le(s, c, u.id, d + 1, r);
+		} catch {
+			return M("Room wake dispatch or publication is unconfirmed; retry the same room");
+		}
+	}, ze = (e, t) => {
+		if (t.mode !== "lockstep") return x(e.options);
+		if (e.options !== null || e.name !== t.name) return M("Lockstep creation cannot use state-sync option truth");
+		let n = re(t.simulation, z).captureStored(e.lockstepAdmission, {
+			roomId: N(e.id),
+			tenantId: N(e.tenantId),
+			epoch: P(e.epoch)
+		}, N(e.hostId));
+		return n.initial.name !== t.name || n.initial.creatorSubjectId !== e.lockstepCreatorSubjectId ? M("Lockstep creation metadata changed its indexed creator") : n.initial.options;
+	}, $ = async (e, n, i, a, s = "player", c) => {
+		let l = A.decodeUnknownSync(A.toType(ee))(structuredClone(e)), u = q(i), d = K(), f = h(n.address, n.webTransportAddress, n.webTransportCertificateHash), p = l.endpoints === void 0 ? h(l.address, void 0) : m(l.endpoints), g = oe(l.token, Te, d, Se.verify);
+		(a !== void 0 && l.roomId !== a || g.roomId !== l.roomId || g.sessionId !== l.sessionId || g.tenantId !== u.tenantId || g.subjectId !== u.subjectId || g.role !== s || g.expiresAt !== l.expiresAt || l.address !== n.address || p.ws !== f.ws || p.wt !== f.wt || p.wtCertificateHash !== f.wtCertificateHash || p.wt === void 0 != (l.transport.length === 1)) && M("Room host returned an unrelated reservation receipt");
+		let _ = await Y(l.roomId, u.tenantId);
+		if (c && (_.name !== c.name || ze(_, O.catalog.get(c.name)) !== c.encodedOptions) && M("Room creation changed the authorized descriptor or options"), c && O.catalog.get(c.name).mode === "lockstep" && _.lockstepCreatorSubjectId !== u.subjectId && M("Lockstep creation changed its actual requesting creator"), se(r, N(_.name), q(i).tenantId, _.pool, n.pool, n.region), _.state !== "live" || _.hostId !== n.id || _.epoch !== g.epoch) throw new o({ roomId: l.roomId });
+		let v = (await R(t, y, T(E("roomId", g.roomId), E("tenantId", u.tenantId), E("sessionId", g.sessionId), E("subjectId", u.subjectId), E("epoch", g.epoch), E("token", w(l.token)), E("state", "reserved"))))[0], b = v?.expiresAt, x = b instanceof Date ? b.getTime() : typeof b == "string" ? Date.parse(b) : NaN;
+		return v && v.nonce === g.nonce && v.role === g.role && x === g.expiresAt || M("Room reservation has no matching SQL seat receipt"), {
+			...l,
+			endpoints: p,
+			token: Uint8Array.from(l.token)
+		};
+	}, Be = async (e, n, r, i) => {
+		let c = N(e.id), l = O.catalog.get(N(e.name)), u = await J(l, n, {
+			roomId: c,
+			role: r
+		}, c);
+		await S(t, u);
+		let d = e.state === "hibernated" || e.state === "creating" || e.state === "orphaned" && l.mode === "lockstep", f = d ? await Re(e, n, i) : e;
+		if (f.state !== "live") throw new o({ roomId: c });
+		let p;
+		try {
+			p = await Q(f, n);
+		} catch (e) {
+			if (d) return M("Claimed Room wake target is unavailable; retry the same room");
+			throw e;
+		}
+		let m = await V(n, l.name, c, r), h;
+		try {
+			h = await F(W.reserve(p.id, {
+				mode: "joinById",
+				roomId: c,
+				role: r
+			}, n, m));
+		} catch (e) {
+			if (e instanceof a || e instanceof s) throw e;
+			return M("Room reservation dispatch is unconfirmed; no other owner was attempted");
+		}
+		try {
+			return await $(h, p, n, c, r);
+		} catch {
+			return M("Room reservation receipt is unconfirmed; no other owner was attempted");
+		}
+	}, Ve = async (n, r, i, c) => {
+		let l = O.catalog.get(n.room);
+		await J(l, r, {
+			name: n.room,
+			options: n.options
+		}), await S(t, i);
+		let u = l.mode === "lockstep" ? Buffer.from(d(l.simulation).encode(n.options)).toString("base64url") : x(A.encodeSync(l.options)(A.decodeUnknownSync(l.options)(n.options))), f = X(r, n.room, N(G(structuredClone(r), n.room)), void 0, n.pool);
+		if (n.mode === "join") {
+			let d = await R(t, g, T(E("tenantId", i.tenantId), E("name", n.room), E("pool", f ?? null), E("private", !1), ve(E("state", "live"), E("state", "hibernated"), E("state", "creating"))), j + 1);
+			if (d.length > j) throw new e({
+				budget: "apiListedRooms",
+				limit: j
+			});
+			for (let e of d) if (e.locked === !1 && ze(e, l) === u) try {
+				return await Be(e, r, "player", c);
+			} catch (e) {
+				if (!(e instanceof a || e instanceof s || e instanceof o)) throw e;
+			}
+		}
+		let p = await Z(r, n.room, void 0, n.pool), m = await V(r, n.room, null, "player");
+		for (let e = 0; e < I && p.length; e++) {
+			let e = Ne(p, r, n.room, void 0, n.pool);
+			if (!e) break;
+			try {
+				return await $(await F(W.reserve(e.id, {
+					...n,
+					mode: "create"
+				}, r, m)), e, r, void 0, "player", {
+					name: n.room,
+					encodedOptions: u
+				});
+			} catch (t) {
+				if (!(t instanceof a)) throw t;
+				p.splice(p.findIndex((t) => t.id === e.id), 1);
+			}
+		}
+		throw new a({ roomId: "host" });
+	};
+	return Object.freeze({
+		reserve: (e, t) => L(() => ({
+			request: structuredClone(e),
+			authority: structuredClone(t)
+		}), async ({ request: e, authority: t }, n) => {
+			K();
+			let r = A.decodeUnknownSync(b)(e), i = q(t);
+			if (r.mode === "joinById") {
+				let e = await Y(r.roomId, i.tenantId), a = await H(t, N(e.name), "joinById");
+				return U(await Be(e, t, r.role ?? "player", n), i.tenantId, a);
+			}
+			let a = await H(t, r.room, r.mode);
+			return U(await Ve(r, t, i, n), i.tenantId, a);
+		}),
+		resume: (e, n) => L(() => structuredClone(n), async (n, r) => {
+			K();
+			let i = q(n);
+			if (i.subjectId === null) throw new l({ sessionId: e });
+			let a = (await R(t, y, T(E("sessionId", N(e)), E("tenantId", i.tenantId), E("subjectId", i.subjectId))))[0];
+			if (!a || a.state !== "grace" && a.state !== "reserved") throw new l({ sessionId: e });
+			let s = a.state === "grace" ? a.graceUntil : a.expiresAt, c = s instanceof Date ? s.getTime() : typeof s == "string" ? Date.parse(s) : NaN;
+			if (!Number.isFinite(c) || c <= K()) throw new l({ sessionId: e });
+			let u = await Y(N(a.roomId), i.tenantId), d = N(u.id), f = O.catalog.get(N(u.name)), p = xe(a);
+			if (p !== null && p <= K()) {
+				let r = await H(n, f.name, "continue");
+				r === null ? await t.updateMany(y, { accessUntil: null }, { where: T(E("sessionId", N(e)), E("tenantId", i.tenantId)) }) : await U({ sessionId: e }, i.tenantId, r);
+			}
+			await J(f, n, {
+				roomId: d,
+				sessionId: e
+			}, d), await S(t, i);
+			let m = ["creating", "orphaned"].includes(String(u.state)) && f.mode === "lockstep" ? await Re(u, n, r) : u;
+			if (m.state !== "live") throw new o({ roomId: d });
+			let h = a.role === "spectator" ? "spectator" : "player", ee = await V(n, f.name, d, h), g = await Q(m, n), _ = await F(W.resume(g.id, e, n, ee));
+			return _.sessionId !== e && M("Room resume changed the durable seat identity"), $(_, g, n, d, a.role === "spectator" ? "spectator" : "player");
+		}),
+		leave: (e, n, r) => L(() => !(n instanceof Uint8Array) || n.byteLength < 1 || n.byteLength > 8192 ? M("Invalid Room withdrawal credential bytes") : {
+			authority: structuredClone(r),
+			token: Uint8Array.from(n)
+		}, async ({ authority: n, token: r }) => {
+			K();
+			let i = q(n);
+			(!(r instanceof Uint8Array) || r.byteLength < 1 || r.byteLength > 8192) && M("Invalid Room withdrawal credential bytes");
+			let a = Uint8Array.from(r), o = (await R(t, y, T(E("sessionId", N(e)), E("tenantId", i.tenantId), E("subjectId", i.subjectId), E("token", w(a)))))[0];
+			if (!o || o.state === "released") return { ok: !0 };
+			let s = await Y(N(o.roomId), i.tenantId);
+			(await F(W.leave(N(s.hostId), e, a, n)))?.ok !== !0 && M("Room withdrawal response is unconfirmed");
+			let c = (await R(t, y, T(E("sessionId", e), E("tenantId", i.tenantId), E("subjectId", i.subjectId), E("token", w(a)))))[0];
+			return c && c.state !== "released" && M("Room withdrawal has no matching SQL release observation"), { ok: !0 };
+		}),
+		...De === void 0 ? {} : { prepareMatch: (e, n) => L(() => ({
+			request: structuredClone(e),
+			authority: structuredClone(n)
+		}), async ({ request: e, authority: n }) => {
+			K();
+			let r = N(e.room), i = O.catalog.get(r), o = N(e.requestId);
+			await H(n, r, "create");
+			let s = await J(i, n, {
+				name: r,
+				options: e.options
+			});
+			await S(t, s);
+			let c = {
+				room: r,
+				options: e.options,
+				requestId: o
+			}, l = await R(t, v, T(E("tenantId", s.tenantId), E("requestKey", me(s.tenantId, r, o))), 2);
+			if (l.length > 1 && M("Ambiguous match Room receipt"), l[0]) {
+				let t = await Y(N(l[0].roomId), s.tenantId);
+				if ((i.mode === "lockstep" || t.name !== r || ze(t, i) !== x(A.encodeSync(i.options)(A.decodeUnknownSync(i.options)(e.options)))) && M("Match Room retry changed its Room or options"), t.state !== "creating") return {
+					roomId: N(t.id),
+					epoch: P(t.epoch)
+				};
+				let a = await F(De.prepareRoom(N(t.hostId), c, n));
+				return {
+					roomId: a.roomId,
+					epoch: a.epoch
+				};
+			}
+			let u = await Z(n, r, void 0, e.pool), d = Ne(u, n, r, void 0, e.pool);
+			if (!d) throw new a({ roomId: "host" });
+			let f = await F(De.prepareRoom(d.id, c, n));
+			return {
+				roomId: f.roomId,
+				epoch: f.epoch
+			};
+		}) },
+		list: (e, n, r = 64) => L(() => structuredClone(n), async (n) => {
+			K();
+			let i = O.catalog.get(N(e)), a = await J(i, n, { name: e });
+			(!Number.isSafeInteger(r) || r < 1 || r > j) && M("Invalid Room API listing budget");
+			let o = X(n, e, N(G(structuredClone(n), e))), s = await R(t, g, T(E("tenantId", a.tenantId), E("name", e), E("pool", o ?? null), E("private", !1), E("state", "live")), r), c = new Set((await Z(n, e)).map((e) => e.id));
+			return s.map(_e).filter((e) => c.has(e.hostId)).map(({ id: e, name: t, metadata: n, clients: r, maxClients: i, locked: a }) => ({
+				id: e,
+				name: t,
+				metadata: n,
+				clients: r,
+				maxClients: i,
+				locked: a
+			}));
+		})
+	});
+}, Se = (e, t) => O.succeed(C, z(e, t));
+export { z as dataStoreRoomApiReservations, be as roomAccessDeadline, Se as roomApiReservationLayer, xe as seatAccessUntil, j as timedRoomAdmission };

package/dist/baselines.js

@@ -0,0 +1,72 @@
+import { RoomAuthoringError as e } from "./errors.js";
+// src/baselines.ts
+var t = class {
+	capacity;
+	maxBaselineAgeMs;
+	sent = /* @__PURE__ */ new Map();
+	epoch = null;
+	newestTick = -1;
+	ackTick = null;
+	lastAckAt = -1;
+	lastNow = -1;
+	constructor(t, n) {
+		if (this.capacity = t, this.maxBaselineAgeMs = n, !Number.isSafeInteger(t) || t < 1 || !Number.isFinite(n) || n <= 0) throw new e({
+			room: "baseline",
+			detail: "Baseline capacity and age must be positive"
+		});
+	}
+	record(t) {
+		if (![t.tick, t.epoch].every((e) => Number.isSafeInteger(e) && e >= 0)) throw new e({
+			room: "baseline",
+			detail: "Baseline tick and epoch must be nonnegative safe integers"
+		});
+		if (this.epoch !== null && t.epoch < this.epoch) throw new e({
+			room: "baseline",
+			detail: "An old epoch cannot replace the current baseline history"
+		});
+		if (t.epoch !== this.epoch && (this.sent.clear(), this.ackTick = null, this.lastAckAt = -1, this.newestTick = -1, this.epoch = t.epoch), t.tick <= this.newestTick) throw new e({
+			room: "baseline",
+			detail: "Sent baseline ticks must increase within an epoch"
+		});
+		let n = {
+			...t,
+			state: structuredClone(t.state)
+		};
+		for (this.sent.set(t.tick, n), this.newestTick = t.tick; this.sent.size > this.capacity;) {
+			let e = this.sent.keys().next();
+			if (e.done) break;
+			this.sent.delete(e.value);
+		}
+	}
+	acknowledge(e, t) {
+		if (this.time(t), !Number.isSafeInteger(e) || e < 0 || !this.sent.has(e) || this.ackTick !== null && e < this.ackTick) return !1;
+		this.ackTick = e, this.lastAckAt = t;
+		for (let t of this.sent.keys()) t < e && this.sent.delete(t);
+		return !0;
+	}
+	current(e) {
+		if (this.time(e), this.ackTick === null || e - this.lastAckAt > this.maxBaselineAgeMs) return null;
+		let t = this.sent.get(this.ackTick);
+		return t ? {
+			...t,
+			state: structuredClone(t.state)
+		} : null;
+	}
+	time(t) {
+		if (!Number.isFinite(t) || t < 0 || t < this.lastNow) throw new e({
+			room: "baseline",
+			detail: "Baseline time must be monotonic, finite and nonnegative"
+		});
+		this.lastNow = t;
+	}
+	retained() {
+		return this.sent.size;
+	}
+	acknowledgedTick() {
+		return this.ackTick;
+	}
+	release() {
+		this.sent.clear(), this.ackTick = null, this.lastAckAt = -1;
+	}
+};
+export { t as RoomBaselineRing };