@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/controlTransport.js

@@ -0,0 +1,573 @@
+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, SeatExpired as c } from "./errors.js";
+import { createSimulationOptionsCodec as l } from "./simulationOptionsWire.js";
+import { captureRoomSeatAttributes as u } from "./room.js";
+import { geometryPersistenceId as d } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadRequest as f, captureRoomGeometryRollbackRequest as p } from "./geometryAdminData.js";
+import { ReserveRoomInput as m } from "./rpc.js";
+import { canonicalRoomJson as h } from "./checkpointJson.js";
+import { captureRoomSessionAdmissionEvidence as ee } from "./sessionAdmission.js";
+import { RoomCatalog as g } from "./catalog.js";
+import { captureRoomHostWithdrawalInput as _ } from "./ownershipWithdrawal.js";
+import { controllerRoomHostControlService as v } from "./reservePort.js";
+import { RoomControlTargetSchema as te, RoomControlWorldAdmissionSchema as ne, decodeRoomControlReservation as y, decodeRoomControlToken as re, encodeRoomControlReservation as b, encodeRoomControlToken as x, makeRoomControlCarrier as S, roomControlIdentity as C, sameRoomControlIdentity as w, sameRoomControlTarget as ie } from "./controlCarrier.js";
+import { RoomsHostBindFailure as T } from "./hostBinding.js";
+import { controllerRoomHostWithdrawalService as E } from "./withdrawalPort.js";
+import { ROOM_APP_COMMAND_TARGET as D } from "./roomAppCommandControl.js";
+import { controllerWorldRoomSteps as O, hostWorldRoomStepHandler as k } from "./worldRoomSteps.js";
+import { runWorldTransitionForward as A } from "./worldDefaultService.js";
+import { Subject as j } from "@voltro/protocol";
+import { Effect as M, Result as ae, Schema as N } from "effect";
+import { createHash as P, randomUUID as F } from "node:crypto";
+// src/controlTransport.ts
+var I = () => new n({ detail: "Room control outcome is unconfirmed; do not repeat or select another host" }), L = "Room control transport is unavailable", R = () => new n({ detail: L }), z = (e, t) => {
+	if (!Number.isSafeInteger(e) || e < 1 || e > t) throw new n({ detail: "Invalid Room control resource budget" });
+	return e;
+}, B = (l) => l instanceof a ? new a({ roomId: l.roomId }) : l instanceof s ? new s({ roomId: l.roomId }) : l instanceof o ? new o({ roomId: l.roomId }) : l instanceof i ? new i({ roomId: l.roomId }) : l instanceof c ? new c({ sessionId: l.sessionId }) : l instanceof t ? new t({ sessionId: l.sessionId }) : l instanceof e ? new e({
+	budget: "roomHostControl",
+	limit: l.limit
+}) : l instanceof r ? new r({
+	room: l.room,
+	detail: "Room authoring refused control"
+}) : l instanceof n && l.detail === L ? R() : I(), oe = (e) => M.uninterruptible(M.tryPromise({
+	try: e,
+	catch: B
+})), V = (e, t, n) => {
+	try {
+		let r = Object.getOwnPropertyDescriptor(t, "catalog");
+		if (r && (!r.enumerable || !("value" in r)) || !r && "catalog" in t) throw R();
+		let i = r?.value === void 0 ? void 0 : new g(r.value.inventory(), { previousHistory: r.value.history }), a = {
+			...t,
+			...i === void 0 ? {} : { catalog: i },
+			projectControlSecrets: structuredClone(t.projectControlSecrets)
+		};
+		return n(Object.freeze({
+			publish: e.publish.bind(e),
+			subscribe: e.subscribe.bind(e),
+			onTransportEvent: e.onTransportEvent.bind(e),
+			close: e.close
+		}), a);
+	} catch {
+		return M.fail(R());
+	}
+}, H = (e, t, r) => V(e, r, (e, r) => M.uninterruptible(M.gen(function* () {
+	let a = yield* M.context(), o = async (e) => {
+		let t = await M.runPromiseWith(a)(M.result(e));
+		if (ae.isFailure(t)) throw t.failure;
+		return t.success;
+	}, s = yield* M.try({
+		try: () => S(r),
+		catch: () => R()
+	}), c = t.host.membership;
+	if (!c || typeof r.resolveSubject != "function" || typeof r.onUnavailable != "function") return yield* M.fail(R());
+	let u = yield* M.try({
+		try: () => N.decodeUnknownSync(te)({
+			hostId: t.host.id,
+			...c
+		}),
+		catch: () => R()
+	}), d = z(r.maxReceipts ?? 4096, 65536), m = z(r.maxInFlight ?? 128, d), h = r.resolveSubject, g = r.onUnavailable, _ = v(t), ne = t.adopt.bind(t), y = r.worldSteps?.leases, x = y === void 0 ? void 0 : (e, n) => k(t, y(e.tenantId))(e, n), C = r.worldSteps === void 0 ? void 0 : O(t).capture, D = E(t), F = t.reloadGeometry.bind(t), I = t.rollbackGeometry.bind(t), L = t.kickSubject.bind(t), oe = t.closeSessions.bind(t), V = e.publish.bind(e), H = e.subscribe.bind(e), U = e.onTransportEvent.bind(e), W = !1, G = !1, K = null, q = null, J = /* @__PURE__ */ new Set(), Y = /* @__PURE__ */ new Map(), X = () => {
+		W = !0;
+	}, Z = () => {
+		X();
+		try {
+			g();
+		} catch {}
+	}, se = async (e) => {
+		try {
+			let a = e.body;
+			if (a.operation === "adopt") return await ne(a.roomId, a.tenantId, a.priorEpoch), {
+				ok: !0,
+				value: null
+			};
+			if (a.operation === "withdraw") return await o(D.withdraw(u.hostId, a.input)), {
+				ok: !0,
+				value: null
+			};
+			if (a.operation === "kick") return {
+				ok: !0,
+				value: await L(a.roomId, a.tenantId, a.subjectId, a.reason)
+			};
+			if (a.operation === "close") return {
+				ok: !0,
+				value: await oe(a.roomId, a.tenantId, a.reason)
+			};
+			if (a.operation === "worldStep") {
+				if (!x) throw new n({ detail: "This Host runs no World steps" });
+				return await o(x(structuredClone(a.step), structuredClone(a.authority))), {
+					ok: !0,
+					value: null
+				};
+			}
+			if (a.operation === "worldTransition") {
+				let e = r.worldSteps?.executor;
+				if (!e) throw new n({ detail: "This Host runs no World transitions" });
+				let i = structuredClone(a.forward), s = await o(t.directory.observeOwnership(i.origin.roomId, i.origin.tenantId));
+				if (!s || s.hostId !== t.host.id || s.state !== "live") throw new n({ detail: "World source Room belongs to another live Host" });
+				return await o(A(e(i.origin.tenantId), i)), {
+					ok: !0,
+					value: null
+				};
+			}
+			if (a.operation === "appCommand") throw new n({ detail: "Room Hosts run no app commands" });
+			if (a.operation === "worldCapture") {
+				if (!C) throw new n({ detail: "This Host runs no World steps" });
+				let e = await o(C(structuredClone(a.capture)));
+				return {
+					ok: !0,
+					value: { captured: {
+						entity: e.entity,
+						data: e.data
+					} }
+				};
+			}
+			let s = N.decodeUnknownSync(j)(await o(h(structuredClone(a.identity))));
+			if (!w(a.identity, s)) throw new i({ roomId: "" });
+			switch (a.operation) {
+				case "reserve": {
+					let e = a.input;
+					if (e.mode === "joinById") {
+						if (a.lockstepOptionsWire !== void 0) throw new n({ detail: "Seat lookup cannot carry Lockstep creation options" });
+					} else {
+						let r = t.catalog.get(e.room);
+						if (r.mode === "lockstep") {
+							if (!a.lockstepOptionsWire || e.options !== null) throw new n({ detail: "Declared Lockstep control requires its one canonical LSO options blob" });
+							let t = l(r.simulation), i = a.lockstepOptionsWire;
+							if (Buffer.byteLength(i, "base64url") > t.maxBytes) throw new n({ detail: "Lockstep control options exceed actual declared bytes" });
+							let o = Uint8Array.from(Buffer.from(i, "base64url"));
+							if (Buffer.from(o).toString("base64url") !== i) throw new n({ detail: "Lockstep control options are not canonical base64url" });
+							e = {
+								...e,
+								options: t.decode(o)
+							};
+						} else if (a.lockstepOptionsWire !== void 0) throw new n({ detail: "State-sync control cannot carry Lockstep options" });
+					}
+					return {
+						ok: !0,
+						value: b(await o(_.reserve(u.hostId, e, s, a.attributes)))
+					};
+				}
+				case "geometryReload": return await F(a.roomId, f(a.input), s), {
+					ok: !0,
+					value: null
+				};
+				case "geometryRollback": return await I(a.roomId, p(a.input), s), {
+					ok: !0,
+					value: null
+				};
+				case "worldAdmission": {
+					if (!x || s.type !== "user" || !s.tenantId || !s.id) throw R();
+					let { roomId: e, sessionId: n, epoch: r } = a.lookup, i = ee(t.runtime.readSessionAdmission(e, n));
+					if (i.roomId !== e || i.sessionId !== n || i.epoch !== r || i.tenantId !== s.tenantId || i.subjectId !== s.id) throw R();
+					return {
+						ok: !0,
+						value: { admission: i }
+					};
+				}
+				case "worldPrepareRoom": {
+					if (!x) throw new n({ detail: "This Host runs no World steps" });
+					let { room: e, creationKey: r, generation: i, worldCell: o, worldInstance: c } = structuredClone(a.prepare), l = await t.prepareWorldRoom(e, {}, s, r, o, i, c);
+					return {
+						ok: !0,
+						value: { prepared: {
+							roomId: l.id,
+							hostId: l.hostId,
+							epoch: l.epoch
+						} }
+					};
+				}
+				case "matchPrepareRoom": {
+					let { room: e, options: n, requestId: r } = structuredClone(a.prepare), i = await t.prepareMatchRoom(e, n, s, r);
+					return {
+						ok: !0,
+						value: { prepared: {
+							roomId: i.id,
+							hostId: i.hostId,
+							epoch: i.epoch
+						} }
+					};
+				}
+				case "resume": return {
+					ok: !0,
+					value: b(await o(_.resume(u.hostId, a.sessionId, s, a.attributes)))
+				};
+				case "leave": return {
+					ok: !0,
+					value: await o(_.leave(u.hostId, a.sessionId, re(a.token), s))
+				};
+			}
+		} catch (e) {
+			return {
+				ok: !1,
+				error: B(e)
+			};
+		}
+	}, Q = (e) => {
+		let t = Promise.resolve().then(e).catch(Z);
+		J.add(t), t.then(() => {
+			J.delete(t);
+		});
+	}, $ = yield* H(s.requestChannel(u), (e) => {
+		if (W || G) return;
+		let t, n;
+		try {
+			if (t = s.readRequest(e), !ie(t.target, u)) return;
+			n = s.now();
+		} catch {
+			return;
+		}
+		for (let [e, t] of Y) !t.running && t.expiresAt <= n && Y.delete(e);
+		let r = P("sha256").update(e).digest("hex"), i = Y.get(t.requestId);
+		if (i) {
+			if (i.digest !== r || i.running || !i.reply || J.size >= m) return;
+			let e = i.reply;
+			Q(() => o(V(s.replyChannel(t.clientId), e)));
+			return;
+		}
+		if (J.size >= m || Y.size >= d) return;
+		let a = {
+			digest: r,
+			expiresAt: t.expiresAt,
+			reply: null,
+			running: !0
+		};
+		Y.set(t.requestId, a), Q(async () => {
+			try {
+				let e = await se(t);
+				if (s.now() >= t.expiresAt) return;
+				let { purpose: n, body: r, ...i } = t;
+				a.reply = s.signReply({
+					purpose: "voltro.rooms.control.reply.v3",
+					...i,
+					operation: r.operation,
+					result: e
+				}), await o(V(s.replyChannel(t.clientId), a.reply));
+			} finally {
+				a.running = !1;
+			}
+		});
+	}).pipe(M.mapError(() => R()));
+	try {
+		q = U((e) => {
+			e.kind === "disconnected" && Z();
+		});
+	} catch {
+		Z();
+		let e = async () => {
+			await Promise.all([...J]), await o($);
+		};
+		return yield* M.tryPromise({
+			try: e,
+			catch: () => new T(e)
+		}), yield* M.fail(R());
+	}
+	let ce = !1;
+	return Object.freeze({
+		fence: X,
+		close: () => {
+			if (X(), G) return Promise.resolve();
+			if (K) return K;
+			let e = (async () => {
+				await Promise.all([...J]), ce ||= (await o($), !0), q?.(), q = null, Y.clear(), G = !0;
+			})();
+			return K = e, e.then(() => {
+				K = null;
+			}, () => {
+				K = null;
+			}), e;
+		}
+	});
+}))), U = (t, r) => V(t, r, (t, r) => M.uninterruptible(M.gen(function* () {
+	let i = yield* M.context(), a = async (e) => {
+		let t = await M.runPromiseWith(i)(M.result(e));
+		if (ae.isFailure(t)) throw t.failure;
+		return t.success;
+	}, o = yield* M.try({
+		try: () => S(r),
+		catch: () => R()
+	});
+	if (typeof r.resolveTarget != "function") return yield* M.fail(R());
+	let s = r.resolveTarget, c = z(r.maxPending ?? 128, 65536), g = F(), v = t.publish.bind(t), re = t.subscribe.bind(t), b = t.onTransportEvent.bind(t), w = !1, E = !1, O = null, k = null, A = /* @__PURE__ */ new Set(), j = /* @__PURE__ */ new Map(), P = yield* re(o.replyChannel(g), (e) => {
+		let t;
+		try {
+			t = o.readReply(e);
+		} catch {
+			return;
+		}
+		let n = j.get(t.requestId), r = n?.request;
+		n && r && t.clientId === g && t.operation === r.body.operation && ie(t.target, r.target) && t.issuedAt === r.issuedAt && t.expiresAt === r.expiresAt && n.settle({ reply: t });
+	}).pipe(M.mapError(() => R()));
+	try {
+		k = b((e) => {
+			if (e.kind === "disconnected") for (let e of j.values()) e.settle({ error: I() });
+		});
+	} catch {
+		w = !0;
+		let e = () => a(P);
+		return yield* M.tryPromise({
+			try: e,
+			catch: () => new T(e)
+		}), yield* M.fail(R());
+	}
+	let L = !1, V = (t, n, r) => {
+		let i;
+		try {
+			i = JSON.parse(h(n));
+		} catch (e) {
+			return M.fail(B(e));
+		}
+		return oe(() => {
+			if (w || E) throw R();
+			if (A.size >= c) throw new e({
+				budget: "roomControlRequests",
+				limit: c
+			});
+			let n = Promise.resolve().then(async () => {
+				let e = r ?? N.decodeUnknownSync(te)(await a(s(t)));
+				if (e.hostId !== t) throw R();
+				let n = o.now(), c = F(), l = {
+					purpose: "voltro.rooms.control.request.v3",
+					mount: o.mount,
+					requestId: c,
+					clientId: g,
+					target: e,
+					issuedAt: n,
+					expiresAt: n + o.maxRequestMs,
+					body: i
+				}, u = o.signRequest(l), d = () => void 0, f = new Promise((e) => {
+					d = e;
+				});
+				j.set(c, {
+					request: l,
+					settle: d
+				});
+				let p = setTimeout(() => d({ error: I() }), o.maxRequestMs);
+				try {
+					try {
+						await a(v(o.requestChannel(e), u));
+					} catch {
+						d({ error: I() });
+					}
+					let t = await f;
+					if ("error" in t) throw t.error;
+					if (!t.reply.result.ok) throw t.reply.result.error;
+					return t.reply;
+				} finally {
+					clearTimeout(p), j.delete(c);
+				}
+			});
+			return A.add(n), n.then(() => {
+				A.delete(n);
+			}, () => {
+				A.delete(n);
+			}), n;
+		});
+	}, H = (e, t) => {
+		try {
+			return V(e, t());
+		} catch (e) {
+			return M.fail(B(e));
+		}
+	}, U = Object.freeze({
+		reserve: (e, t, n, i) => H(e, () => {
+			let e = N.decodeUnknownSync(m)(structuredClone(t)), a = C(n), o = e.mode === "joinById" ? void 0 : r.catalog?.get(e.room), s = i === void 0 ? {} : { attributes: u(e.mode === "joinById" ? e.roomId : e.room, i) };
+			if (e.mode !== "joinById" && o?.mode === "lockstep") {
+				let t = Buffer.from(l(o.simulation).encode(e.options)).toString("base64url");
+				return {
+					operation: "reserve",
+					identity: a,
+					input: {
+						...e,
+						options: null
+					},
+					lockstepOptionsWire: t,
+					...s
+				};
+			}
+			return {
+				operation: "reserve",
+				input: e,
+				identity: a,
+				...s
+			};
+		}).pipe(M.flatMap((e) => M.try({
+			try: () => {
+				if (!e.result.ok || e.result.value === null || !("token" in e.result.value)) throw I();
+				return y(e.result.value);
+			},
+			catch: B
+		}))),
+		resume: (e, t, n, r) => H(e, () => ({
+			operation: "resume",
+			sessionId: t,
+			identity: C(n),
+			...r === void 0 ? {} : { attributes: u(t, r) }
+		})).pipe(M.flatMap((e) => M.try({
+			try: () => {
+				if (!e.result.ok || e.result.value === null || !("token" in e.result.value)) throw I();
+				return y(e.result.value);
+			},
+			catch: B
+		}))),
+		leave: (e, t, n, r) => H(e, () => ({
+			operation: "leave",
+			sessionId: t,
+			token: x(n),
+			identity: C(r)
+		})).pipe(M.flatMap((e) => e.result.ok && e.result.value !== null && "ok" in e.result.value && e.result.value.ok === !0 ? M.succeed({ ok: !0 }) : M.fail(I())))
+	}), W = Object.freeze({ adopt: (e, t, n, r) => V(e, {
+		operation: "adopt",
+		roomId: t,
+		tenantId: n,
+		priorEpoch: r
+	}).pipe(M.flatMap((e) => e.result.ok && e.result.value === null ? M.void : M.fail(I())), M.mapError(() => I())) }), G = Object.freeze({ withdraw: (e, t) => {
+		try {
+			let n = _(t);
+			return V(e, {
+				operation: "withdraw",
+				input: n
+			}).pipe(M.flatMap((e) => e.result.ok && e.result.value === null ? M.void : M.fail(I())), M.mapError(() => I()));
+		} catch {
+			return M.fail(new n({ detail: "Invalid room ownership withdrawal" }));
+		}
+	} }), K = (e) => e.result.ok && e.result.value === null ? M.void : M.fail(I()), q = Object.freeze({
+		reload: (e, t, n, r) => H(e, () => ({
+			operation: "geometryReload",
+			roomId: d(t),
+			input: f(n),
+			identity: C(r)
+		})).pipe(M.flatMap(K)),
+		rollback: (e, t, n, r) => H(e, () => ({
+			operation: "geometryRollback",
+			roomId: d(t),
+			input: p(n),
+			identity: C(r)
+		})).pipe(M.flatMap(K))
+	}), J = (e) => M.try({
+		try: () => {
+			if (!e.result.ok || e.result.value === null || !("kicked" in e.result.value)) throw I();
+			return { kicked: e.result.value.kicked };
+		},
+		catch: B
+	}), Y = Object.freeze({
+		kick: (e, t) => H(e, () => ({
+			operation: "kick",
+			roomId: t.roomId,
+			tenantId: t.tenantId,
+			subjectId: t.subjectId,
+			reason: t.reason
+		})).pipe(M.flatMap(J)),
+		close: (e, t) => H(e, () => ({
+			operation: "close",
+			roomId: t.roomId,
+			tenantId: t.tenantId,
+			reason: t.reason
+		})).pipe(M.flatMap(J))
+	}), X = Object.freeze({ prepareRoom: (e, t, n) => H(e, () => ({
+		operation: "matchPrepareRoom",
+		prepare: t,
+		identity: C(n)
+	})).pipe(M.flatMap((e) => M.try({
+		try: () => {
+			if (!e.result.ok || e.result.value === null || !("prepared" in e.result.value)) throw I();
+			return e.result.value.prepared;
+		},
+		catch: B
+	}))) }), Z = (e, t, n) => {
+		let r = N.decodeUnknownSync(ne)(JSON.parse(h(t)), { onExcessProperty: "error" }), i = C(n);
+		if (i.type !== "user" || !i.id || !i.tenantId) throw R();
+		return (t) => V(e, {
+			operation: "worldAdmission",
+			identity: i,
+			lookup: r
+		}, t).pipe(M.flatMap((e) => M.try({
+			try: () => {
+				if (!e.result.ok || e.result.value === null || !("admission" in e.result.value)) throw I();
+				let t = ee(e.result.value.admission);
+				if (t.roomId !== r.roomId || t.sessionId !== r.sessionId || t.epoch !== r.epoch || t.subjectId !== i.id || t.tenantId !== i.tenantId) throw I();
+				return {
+					reply: e,
+					evidence: t
+				};
+			},
+			catch: B
+		})));
+	}, se = Object.freeze({
+		admission: (e, t, n) => {
+			try {
+				return Z(e, t, n)().pipe(M.map((e) => e.evidence));
+			} catch (e) {
+				return M.fail(B(e));
+			}
+		},
+		bindAdmission: (e, t, n) => {
+			try {
+				let r = Z(e, t, n);
+				return r().pipe(M.map((e) => {
+					let t = Object.freeze({ ...e.reply.target });
+					return Object.freeze({ read: () => r(t).pipe(M.map((e) => e.evidence)) });
+				}));
+			} catch (e) {
+				return M.fail(B(e));
+			}
+		},
+		prepareRoom: (e, t, n) => H(e, () => ({
+			operation: "worldPrepareRoom",
+			prepare: t,
+			identity: C(n)
+		})).pipe(M.flatMap((e) => M.try({
+			try: () => {
+				if (!e.result.ok || e.result.value === null || !("prepared" in e.result.value)) throw I();
+				return e.result.value.prepared;
+			},
+			catch: B
+		}))),
+		step: (e, t, n) => V(e, {
+			operation: "worldStep",
+			step: t,
+			authority: n
+		}).pipe(M.flatMap(K)),
+		transition: (e, t) => V(e, {
+			operation: "worldTransition",
+			forward: t
+		}).pipe(M.flatMap(K)),
+		capture: (e, t) => V(e, {
+			operation: "worldCapture",
+			capture: t
+		}).pipe(M.flatMap((e) => M.try({
+			try: () => {
+				if (!e.result.ok || e.result.value === null || !("captured" in e.result.value)) throw I();
+				return e.result.value.captured;
+			},
+			catch: B
+		})))
+	}), Q = Object.freeze({ deliver: (e) => V(D, {
+		operation: "appCommand",
+		delivery: e
+	}).pipe(M.flatMap(K)) }), $ = () => {
+		w = !0;
+	};
+	return Object.freeze({
+		control: U,
+		adoption: W,
+		withdrawal: G,
+		geometry: q,
+		kick: Y,
+		world: se,
+		match: X,
+		commands: Q,
+		fence: $,
+		close: () => {
+			if ($(), E) return Promise.resolve();
+			if (O) return O;
+			let e = (async () => {
+				await Promise.allSettled([...A]), L ||= (await a(P), !0), k?.(), k = null, E = !0;
+			})();
+			return O = e, e.then(() => {
+				O = null;
+			}, () => {
+				O = null;
+			}), e;
+		}
+	});
+})));
+export { U as openRoomControlClient, H as openRoomControlServer };

package/dist/developmentBinding.js

@@ -0,0 +1,112 @@
+import { ProtocolError as e } from "./errors.js";
+import { applicationRoomCommands as t } from "./commandDelivery.js";
+import { RoomsHostOwner as n } from "./hostBinding.js";
+import { registryRoomsApiBinder as r } from "./apiRegistryBinding.js";
+import { registryRoomsHostBinder as i } from "./hostRegistryBinding.js";
+import { roomControlSubjectResolver as a, roomSeatSubjectResolver as o } from "./seatSubject.js";
+import { Subject as s } from "@voltro/protocol";
+import { Effect as c, Schema as l } from "effect";
+import { randomBytes as u, randomUUID as d } from "node:crypto";
+// src/developmentBinding.ts
+var f = (t) => t.subjectId === null || t.subjectType !== void 0 && t.subjectType !== "user" ? c.fail(new e({ detail: "Development seats admit signed-in players only" })) : c.try({
+	try: () => l.decodeUnknownSync(s)({
+		type: "user",
+		id: t.subjectId,
+		tenantId: t.tenantId,
+		...t.subjectKind === "guest" ? { kind: "guest" } : {}
+	}),
+	catch: () => new e({ detail: "Development seat Subject is malformed" })
+}), p = (s) => async (c, l) => {
+	let p = process.env.NODE_ENV;
+	if (p !== "development" && p !== "test") throw new e({ detail: "developmentRoomsBinding runs only in development; production uses the registry binders" });
+	let m = l.host?.connectionRegistry, h = l.host?.membership, g = l.host?.runEffect;
+	if (!m || !h?.list || !("receive" in h) || typeof h.receive != "function" || !g || !l.catalog) throw new e({ detail: "Development Rooms need the app registry, membership and catalog" });
+	let _ = () => ({ current: {
+		kid: "dev-" + d().slice(0, 8),
+		secret: u(32).toString("base64url")
+	} }), v = _(), y = _(), b = Object.freeze({
+		instanceId: "rooms-dev-" + d(),
+		startedAt: Date.now()
+	}), x = h.receive.bind(h), S = () => x({
+		...b,
+		meta: { role: "rooms-host" }
+	}), C = s.listenHost ?? "127.0.0.1", w = s.publicAddress ?? "ws://" + (C === "0.0.0.0" ? "localhost" : C) + ":" + s.port + "/_voltro/rooms", T = s.auth === void 0 ? {} : {
+		authority: s.auth,
+		getStore: () => c
+	}, E = a(T), D = s.auth === void 0 ? f : o(T), O = s.world, k = Object.getOwnPropertyDescriptor(O ?? {}, "groups"), A = k !== void 0 && "value" in k && k.value !== void 0, j = r({
+		region: "local",
+		controlConnection: s.connection,
+		projectControlSecrets: v,
+		seatSecrets: y,
+		epochNow: Date.now,
+		observerNow: Date.now,
+		heartbeatEveryMs: 1e3,
+		heartbeatTtlMs: 1e4,
+		graceMs: 5e3,
+		bindPrivacy: s.bindPrivacy,
+		...s.commands === void 0 || !A ? {} : { commands: s.commands },
+		...O === void 0 ? {} : { world: O },
+		...s.admission === void 0 ? {} : { admission: s.admission },
+		...s.seatAttributes === void 0 ? {} : { seatAttributes: s.seatAttributes }
+	});
+	if (A && (l.worldState !== "transitions" || !l.worldClientControls || typeof l.host?.runWithAppServices != "function")) throw new e({ detail: "Default World groups require transition state, player controls and the app-service runner" });
+	let M = new n(l.pluginName, i({
+		topology: "single-node",
+		controlConnection: s.connection,
+		hotConnection: s.connection,
+		projectControlSecrets: v,
+		graceMs: 5e3,
+		acquire: async () => ({
+			store: c,
+			registry: m,
+			runEffect: g,
+			membership: { list: h.list.bind(h) },
+			instance: b,
+			resolveSeatSubject: D,
+			resolveControlSubject: E,
+			...s.commands === void 0 || A ? {} : { application: t(s.commands) },
+			readiness: async () => !0,
+			release: async () => {}
+		}),
+		host: {
+			address: w,
+			region: "local",
+			capacity: s.capacity ?? 32,
+			clock: { now: () => performance.now() },
+			epochNow: Date.now,
+			secrets: y,
+			heartbeatEveryMs: 1e3,
+			heartbeatTtlMs: 1e4,
+			seatTtlMs: 3e4,
+			measuredCpu: () => 0
+		},
+		driver: {
+			cadenceMs: 50,
+			onFailure: () => {}
+		},
+		listener: {
+			host: C,
+			port: s.port
+		}
+	}), { worldState: l.worldState });
+	S();
+	let N = setInterval(S, 1e3);
+	N.unref?.();
+	try {
+		await M.start(process.cwd(), l.catalog, l.worlds, {}, l.pools);
+		let e = await j(c, l);
+		return {
+			...e,
+			release: async () => {
+				try {
+					await e.release();
+				} finally {
+					clearInterval(N), await M.close();
+				}
+			}
+		};
+	} catch (e) {
+		throw clearInterval(N), await M.close().catch(() => void 0), e;
+	}
+};
+export { p as developmentRoomsBinding, f as trustedRoomSeatSubject };