@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/reservations.js

@@ -0,0 +1,258 @@
+import { ProtocolError as e, RoomForbidden as t, RoomFull as n, RoomGone as r, RoomLocked as i, SeatExpired as a } from "./errors.js";
+import { roomHostTransportEndpoints as o } from "./transportEndpoints.js";
+import { ROOM_HOSTS_TABLE as s, ROOM_SEATS_TABLE as c } from "./identities.js";
+import { captureWorldCatalog as l } from "./world.js";
+import { assertRoomSubjectAdmission as u } from "./subjectAdmission.js";
+import { WorldSourceSeatPending as d } from "./worldSourceSeatPending.js";
+import { resolveRoomSeatTokenStrategies as f, roomSeatTokenDigest as p, signRoomSeatWithStrategies as m } from "./seats.js";
+import { assertHostClientCapacity as h, lockRoomReservationOwners as g } from "./hostClientCapacity.js";
+import { captureRoomReservationBatchOptions as _, makeRoomReservationBatch as v, makeRoomReservationBatchMemberReplay as ee, makeRoomReservationBatchReissue as te, makeRoomReservationBatchRelease as y } from "./reservationBatch.js";
+import { assertWorldInstanceSeatAdmission as b } from "./worldInstanceAdmission.js";
+import { consumeRoomSeatInTransaction as x, dataStoreRoomSeats as S, revalidateRoomSeatInTransaction as C } from "./seatStore.js";
+import { and as w, eq as T, generateId as ne, lte as E, or as D } from "@voltro/database";
+import { Effect as O, Result as k } from "effect";
+import { randomBytes as A } from "node:crypto";
+// src/reservations.ts
+var j = (e) => Object.freeze({
+	tenantId: e.tenantId,
+	subjectId: e.subjectId,
+	...e.subjectType === void 0 ? {} : { subjectType: e.subjectType },
+	...e.subjectKind === void 0 ? {} : { subjectKind: e.subjectKind }
+}), M = async (e, t, n, r = !1) => (await e.query({
+	table: t,
+	predicate: n,
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0,
+	...r ? { lock: "update" } : {}
+}))[0], N = (t) => {
+	if (typeof t != "number" || !Number.isSafeInteger(t) || t < 0) throw new e({ detail: "Invalid durable Rooms counter" });
+	return t;
+}, P = (t) => {
+	let n = t instanceof Date ? t.getTime() : typeof t == "string" ? Date.parse(t) : NaN;
+	if (!Number.isFinite(n)) throw new e({ detail: "Invalid durable Rooms timestamp" });
+	return n;
+}, F = (o) => o instanceof t || o instanceof n || o instanceof r || o instanceof i || o instanceof a || o instanceof e ? o : new e({ detail: "Durable Rooms reservation failed" }), I = (e) => O.tryPromise({
+	try: e,
+	catch: F
+}), L = async (e) => {
+	let t = await O.runPromise(O.result(e));
+	if (k.isFailure(t)) throw t.failure;
+	return t.success;
+}, R = (k, F) => {
+	let R = l(F.worlds ?? []), z = f(F.seatToken), B = _(F.batch), V = _(F.batchRelease), H = _(F.batchReissue), U = F.maxHostCapacity ?? 4096;
+	if (!Number.isSafeInteger(U) || U < 1 || U >= 2 ** 53 - 1) throw new e({ detail: "Invalid host client capacity scan budget" });
+	for (let t of [
+		F.seatTtlMs,
+		F.hostHeartbeatTtlMs,
+		...typeof F.graceMs == "number" ? [F.graceMs] : []
+	]) if (!Number.isFinite(t) || t <= 0) throw new e({ detail: "Rooms reservation durations must be positive" });
+	let W = (t) => {
+		let n = typeof F.graceMs == "number" ? F.graceMs : F.graceMs(t);
+		if (!Number.isFinite(n) || n <= 0) throw new e({ detail: "Room seat grace policy returned an invalid duration" });
+		return n;
+	}, G = () => {
+		let t = F.epochNow();
+		if (!Number.isFinite(t) || t < 0) throw new e({ detail: "Rooms reservation wall clock is invalid" });
+		return t;
+	}, K = (e, t, n = !1) => {
+		if (!e || e.erasure != null || e.snapshotErasure != null || e.state !== "live" && !(n && e.state === "hibernating" && F.ownerHostId !== void 0) || F.ownerHostId !== void 0 && e.hostId !== F.ownerHostId) throw new r({ roomId: t });
+		return e;
+	}, q = async (e, t, n, r = !1) => K((await g(e, [t], n)).get(t), t, r), J = async (e, t, n) => {
+		let r = await g(e, t, n);
+		for (let [e, t] of r) K(t, e);
+		return r;
+	}, Y = async (t, n, i) => {
+		let a = n.hostId;
+		if (typeof a != "string") throw new e({ detail: "Room has no durable host identity" });
+		let c = await M(t, s, T("id", a));
+		if (!c || c.ready !== !0 || c.draining === !0 || i - P(c.lastHeartbeatAt) > F.hostHeartbeatTtlMs) throw new r({ roomId: String(n.id) });
+		return o(c.publicAddress, c.webTransportAddress, c.webTransportCertificateHash);
+	}, X = (e, t, n, r = F.secrets) => Object.freeze({
+		roomId: e.roomId,
+		sessionId: e.sessionId,
+		token: m(e, r, n, z),
+		address: t.ws,
+		endpoints: t,
+		transport: t.wt === void 0 ? Object.freeze(["ws"]) : Object.freeze(["ws", "wt"]),
+		expiresAt: e.expiresAt
+	}), Z = (e, t) => ne({
+		kind: "typeid",
+		prefix: e
+	}, t), Q = async (t, n, i, a) => {
+		let o = N(n.clients), s = N(n.maxClients);
+		if (o + i < 0 || o + i > s) throw new e({ detail: "Room capacity ledger is inconsistent" });
+		if (i > 0) {
+			if (typeof n.hostId != "string") throw new r({ roomId: String(n.id) });
+			await h(t, n.hostId, i, U);
+		}
+		if (await t.updateMany("_voltro_rooms", {
+			clients: o + i,
+			updatedAt: new Date(a)
+		}, { where: w(T("id", String(n.id)), T("tenantId", n.tenantId), T("clients", o), T("epoch", n.epoch)) }) !== 1) throw new e({ detail: "Room capacity transaction lost its ownership" });
+	}, re = {
+		revalidate: (t, n) => I(() => k.transactional(async (r) => {
+			let i = await q(r, t.roomId, t.tenantId);
+			if (N(i.epoch) !== t.epoch) throw new e({ detail: "Room Seat admission epoch changed" });
+			await b(r, i, R, G), await C(r, t, n), await b(r, i, R, G);
+		})).pipe(O.mapError((t) => t instanceof d ? t : new e({ detail: "Room Seat final admission failed" }))),
+		consume: (n, r) => I(() => k.transactional(async (e) => {
+			let t = await q(e, n.roomId, n.tenantId);
+			if (N(t.epoch) !== n.epoch) throw new a({ sessionId: n.sessionId });
+			await b(e, t, R, G);
+			let i = await x(e, n, r, new Date(G()));
+			return await b(e, t, R, G), i;
+		})).pipe(O.mapError((n) => n instanceof a || n instanceof t || n instanceof e ? n : new e({ detail: "Room seat admission failed" }))),
+		disconnect: (t, n, r) => I(() => k.transactional(async (i) => {
+			let a = G(), o = await q(i, t.roomId, t.tenantId);
+			if (o.epoch !== t.epoch) throw new e({ detail: "Room seat disconnect owner was fenced" });
+			await i.updateMany("_voltro_room_seats", {
+				state: n === "reconnecting" ? "grace" : "released",
+				updatedAt: new Date(a),
+				graceUntil: n === "reconnecting" ? new Date(a + W(t.roomId)) : null
+			}, { where: w(T("roomId", t.roomId), T("sessionId", t.sessionId), T("tenantId", t.tenantId), T("subjectId", t.subjectId), T("epoch", t.epoch), T("token", r), T("state", "connected")) }) === 1 && n !== "reconnecting" && await Q(i, o, -1, a);
+		})).pipe(O.mapError((t) => t instanceof e ? t : new e({ detail: "Room seat release failed" })))
+	}, $ = {
+		store: k,
+		budget: B,
+		secrets: structuredClone(F.secrets),
+		seatTtlMs: F.seatTtlMs,
+		now: G,
+		authorize: F.authorize,
+		rooms: J,
+		endpoints: Y,
+		capacity: Q,
+		sign: X,
+		create: (e, t, n, r) => L(S(e, F.epochNow, W(r)).reserve(Z("rseat", c), t, n))
+	}, ie = v($), ae = v($, !1), oe = ee($), se = te({
+		...$,
+		budget: H
+	}), ce = y({
+		store: k,
+		budget: V,
+		now: G,
+		authorize: F.authorize,
+		rooms: async (e, t, n) => {
+			let i = await g(e, t, n);
+			if (F.ownerHostId !== void 0 && [...i.values()].some((e) => e.hostId !== F.ownerHostId)) throw new r({ roomId: "batch" });
+			return i;
+		},
+		capacity: Q
+	});
+	return Object.freeze({
+		admission: re,
+		reserveBatch: ie,
+		replayBatch: ae,
+		replayBatchMember: oe,
+		reissueBatchMember: se,
+		releaseBatch: ce,
+		reserve: (e, t, r = "player", a) => {
+			let o = j(t);
+			return O.gen(function* () {
+				return yield* F.authorize(e, o), yield* I(() => k.transactional(async (t) => {
+					await u(t, o);
+					let s = G(), l = await q(t, e, o.tenantId);
+					if (l.locked !== !1) throw new i({ roomId: e });
+					if (N(l.clients) >= N(l.maxClients)) throw new n({ roomId: e });
+					let d = await Y(t, l, s), f = {
+						roomId: e,
+						...o,
+						role: r,
+						epoch: N(l.epoch),
+						nonce: A(16).toString("base64url"),
+						sessionId: Z("rseat", c),
+						expiresAt: s + F.seatTtlMs,
+						...a === void 0 ? {} : { attributes: a }
+					}, m = X(f, d, s);
+					return await Q(t, l, 1, s), await L(S(t, F.epochNow, W(e)).reserve(Z("rseat", c), f, p(m.token))), m;
+				}));
+			});
+		},
+		resume: (n, r, i) => {
+			let o = j(r);
+			return O.gen(function* () {
+				if (o.subjectId === null) return yield* O.fail(new t({ roomId: "" }));
+				let r = yield* I(() => M(k, c, w(T("sessionId", n), T("tenantId", o.tenantId), T("subjectId", o.subjectId))));
+				if (!r || typeof r.roomId != "string") return yield* O.fail(new a({ sessionId: n }));
+				let s = r.roomId;
+				return yield* F.authorize(s, o), yield* I(() => k.transactional(async (t) => {
+					await u(t, o);
+					let r = G(), l = await q(t, s, o.tenantId), d = await M(t, c, w(T("sessionId", n), T("roomId", s), T("tenantId", o.tenantId), T("subjectId", o.subjectId)), !0), f = d?.state;
+					if (!d || !(f === "grace" && P(d.graceUntil) > r || f === "reserved" && P(d.expiresAt) > r)) throw new a({ sessionId: n });
+					let m = d.role;
+					if (m !== "player" && m !== "spectator") throw new e({ detail: "Invalid durable seat role" });
+					let h = {
+						roomId: s,
+						sessionId: n,
+						...o,
+						role: m,
+						nonce: A(16).toString("base64url"),
+						epoch: N(l.epoch),
+						expiresAt: r + F.seatTtlMs,
+						...i === void 0 ? {} : { attributes: i }
+					}, g = X(h, await Y(t, l, r), r);
+					if (await t.updateMany("_voltro_room_seats", {
+						epoch: h.epoch,
+						nonce: h.nonce,
+						state: "reserved",
+						attributes: i ?? null,
+						token: p(g.token),
+						expiresAt: new Date(h.expiresAt),
+						graceUntil: null,
+						updatedAt: new Date(r),
+						reservationBatchReissueReceipt: d.reservationBatchReceipt == null ? null : {
+							issuedAt: r,
+							signingKid: F.secrets.current.kid
+						}
+					}, { where: w(T("id", d.id), T("tenantId", o.tenantId), T("state", String(f)), T("token", d.token)) }) !== 1) throw new a({ sessionId: n });
+					return g;
+				}));
+			});
+		},
+		release: (t, n, i) => I(async () => {
+			let o = p(n), s = await M(k, c, w(T("sessionId", t), T("tenantId", i.tenantId), T("subjectId", i.subjectId), T("token", o)));
+			if (!s || typeof s.roomId != "string") return null;
+			let l = s.roomId;
+			return k.transactional(async (n) => {
+				let s = G(), u = (await g(n, [l], i.tenantId)).get(l);
+				if (!u || F.ownerHostId !== void 0 && u.hostId !== F.ownerHostId) throw new r({ roomId: l });
+				let d = await M(n, c, w(T("sessionId", t), T("roomId", l), T("tenantId", i.tenantId), T("subjectId", i.subjectId), T("token", o)), !0);
+				if (!d) return null;
+				if (d.state === "released") return l;
+				if (d.state !== "reserved" && d.state !== "grace" && d.state !== "connected") throw new e({ detail: "Room seat has an invalid withdrawal state" });
+				if (d.epoch !== u.epoch) throw new a({ sessionId: t });
+				if (await n.updateMany("_voltro_room_seats", {
+					state: "released",
+					graceUntil: null,
+					updatedAt: new Date(s)
+				}, { where: w(T("id", d.id), T("tenantId", i.tenantId), T("state", d.state), T("token", o)) }) !== 1) throw new e({ detail: "Room seat withdrawal lost its credential ownership" });
+				return await Q(n, u, -1, s), l;
+			});
+		}),
+		sweepExpired: (t, n, r = 256) => I(() => k.transactional(async (i) => {
+			if (!Number.isSafeInteger(r) || r < 1 || r > 4096) throw new e({ detail: "Seat sweep limit is invalid" });
+			let a = G(), o = await q(i, t, n, !0), s = await i.query({
+				table: c,
+				predicate: w(T("roomId", t), T("tenantId", n), D(w(T("state", "reserved"), E("expiresAt", new Date(a))), w(T("state", "grace"), E("graceUntil", new Date(a))))),
+				order: [{
+					column: "expiresAt",
+					direction: "asc"
+				}],
+				take: r,
+				skip: void 0,
+				projection: void 0
+			}), l = 0;
+			for (let t of s) {
+				if (t.epoch !== o.epoch) throw new e({ detail: "Seat expiry owner epoch is inconsistent" });
+				(t.state === "grace" ? P(t.graceUntil) : P(t.expiresAt)) > a || (l += await i.updateMany(c, {
+					state: "released",
+					graceUntil: null,
+					updatedAt: new Date(a)
+				}, { where: w(T("id", t.id), T("tenantId", n), T("epoch", o.epoch), T("state", t.state), T("token", t.token)) }));
+			}
+			return l && await Q(i, o, -l, a), l;
+		}))
+	});
+};
+export { R as dataStoreRoomReservations, j as roomReservationIdentity };

package/dist/reservePort.js

@@ -0,0 +1,68 @@
+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 { Effect as u } from "effect";
+// src/reservePort.ts
+var d = (d) => u.tryPromise({
+	try: d,
+	catch: (u) => u instanceof e || u instanceof t || u instanceof n || u instanceof r || u instanceof i || u instanceof a || u instanceof o || u instanceof s || u instanceof c || u instanceof l ? u : new n({ detail: "Room API operation failed" })
+}), f = (e, t) => {
+	try {
+		let n = e();
+		return d(() => t(n));
+	} catch {
+		return u.fail(new n({ detail: "Invalid Room API request capture" }));
+	}
+}, p = (e) => {
+	let t = e.create.bind(e), n = e.join.bind(e), r = e.reserve.bind(e), a = e.resume.bind(e), o = e.leave.bind(e), s = e.list.bind(e), c = e.prepareMatchRoom?.bind(e);
+	return Object.freeze({
+		reserve: (a, o, s) => f(() => ({
+			input: structuredClone(a),
+			subject: structuredClone(o),
+			attributes: structuredClone(s)
+		}), (a) => {
+			if (a.input.mode !== "joinById" && a.input.pool !== void 0 && a.input.pool !== e.host?.pool) throw new i({ roomId: "host" });
+			switch (a.input.mode) {
+				case "create": return t(a.input.room, a.input.options, a.subject, {}, a.attributes);
+				case "join": return n(a.input.room, a.input.options, a.subject, a.attributes);
+				case "joinById": return r(a.input.roomId, a.subject, a.input.role, a.attributes);
+			}
+		}),
+		resume: (e, t, n) => f(() => ({
+			subject: structuredClone(t),
+			attributes: structuredClone(n)
+		}), (t) => a(e, t.subject, t.attributes)),
+		leave: (e, t, n) => f(() => {
+			if (!(t instanceof Uint8Array) || t.byteLength < 1 || t.byteLength > 8192) throw Error("Invalid withdrawal bytes");
+			return {
+				token: Uint8Array.from(t),
+				subject: structuredClone(n)
+			};
+		}, (t) => o(e, t.token, t.subject)),
+		list: (e, t, n) => f(() => structuredClone(t), async (t) => (await s(e, t, n)).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
+		}))),
+		...c === void 0 ? {} : { prepareMatch: (t, n) => f(() => ({
+			input: structuredClone(t),
+			subject: structuredClone(n)
+		}), async (t) => {
+			if (t.input.pool !== void 0 && t.input.pool !== e.host?.pool) throw new i({ roomId: "host" });
+			let n = await c(t.input.room, t.input.options, t.subject, t.input.requestId);
+			return {
+				roomId: n.id,
+				epoch: n.epoch
+			};
+		}) }
+	});
+}, m = (e) => {
+	let t = p(e), n = (t, n) => u.suspend(() => t === e.host.id ? n : u.fail(new i({ roomId: "host" })));
+	return Object.freeze({
+		reserve: (e, r, i, a) => n(e, t.reserve(r, i, a)),
+		resume: (e, r, i, a) => n(e, t.resume(r, i, a)),
+		leave: (e, r, i, a) => n(e, t.leave(r, i, a))
+	});
+};
+export { m as controllerRoomHostControlService, p as hostRoomReserveService };

package/dist/resolvedOptions.js

@@ -0,0 +1,3 @@
+// src/resolvedOptions.ts
+var e = (e) => Object.fromEntries(Object.entries(e).filter(([, e]) => e !== void 0));
+export { e as definedOnly };