@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/reservationBatch.js

@@ -0,0 +1,422 @@
+import { ProtocolError as e, RoomForbidden as t, RoomFull as n, RoomGone as r, RoomLocked as i, SeatExpired as a } from "./errors.js";
+import { captureRoomSeatAttributes as o } from "./room.js";
+import { ROOM_SEATS_TABLE as s } from "./identities.js";
+import { assertRoomSubjectAdmission as c } from "./subjectAdmission.js";
+import { captureWorldTargetSeatBinding as l } from "./worldSeatBinding.js";
+import { roomSeatTokenDigest as u } from "./seats.js";
+import { and as d, eq as f } from "@voltro/database";
+import { Effect as p } from "effect";
+import { createHash as m, randomBytes as h } from "node:crypto";
+//#region src/reservationBatch.ts
+var g = (t) => new e({ detail: t }), _ = (e) => m("sha256").update(JSON.stringify(e)).digest("hex"), v = (e, t) => {
+	if (!e || typeof e != "object" || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e))) throw g("Room reservation batch must be plain own data");
+	let n = Object.getOwnPropertyDescriptors(e);
+	if (Reflect.ownKeys(e).length !== t.length || t.some((e) => !n[e] || !Object.hasOwn(n[e], "value"))) throw g("Room reservation batch fields must be exact own values");
+	return Object.fromEntries(t.map((e) => [e, n[e].value]));
+}, y = (e) => {
+	if (typeof e != "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:/-]{0,190}$/.test(e)) throw g("Invalid Room reservation batch identity");
+	return e;
+}, b = (e) => {
+	if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0 || e > 2147483647) throw g("Invalid Room reservation batch counter");
+	return e;
+}, x = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(t) || t < 0) throw g("Invalid Room reservation batch timestamp");
+	return t;
+}, S = (e) => {
+	if (e === void 0) return;
+	let t = v(e, ["maxSeats", "authorize"]), n = b(t.maxSeats);
+	if (n < 1 || n > 1024 || typeof t.authorize != "function") throw g("Room reservation batch requires its budget and authority");
+	return Object.freeze({
+		maxSeats: n,
+		authorize: t.authorize
+	});
+}, C = (e, t) => {
+	if (b(t) < 1 || t > 1024) throw g("Room reservation batch requires a valid seat budget");
+	let n = v(e, [
+		"requestId",
+		"tenantId",
+		"seats"
+	]), r = n.seats;
+	if (!Array.isArray(r) || r.length < 1 || r.length > t || Reflect.ownKeys(r).length !== r.length + 1) throw g("Room reservation batch exceeds its own bounded seat list");
+	let i = [], a = /* @__PURE__ */ new Set();
+	for (let e = 0; e < r.length; e++) {
+		let t = Object.getOwnPropertyDescriptor(r, e);
+		if (!t || !Object.hasOwn(t, "value")) throw g("Room reservation batch list must contain own values");
+		let n = !!t.value && typeof t.value == "object" && "worldTarget" in t.value, o = !!t.value && typeof t.value == "object" && "subjectKind" in t.value, s = !!t.value && typeof t.value == "object" && "sourceRoomId" in t.value, c = v(t.value, [
+			"roomId",
+			"subjectId",
+			...o ? ["subjectKind"] : [],
+			...n ? ["worldTarget"] : [],
+			...s ? ["sourceRoomId"] : []
+		]), u = y(c.subjectId);
+		if (o && c.subjectKind !== "guest") throw g("Room reservation batch Subject kind is guest or absent");
+		let d = n ? l(c.worldTarget) : void 0;
+		if (a.has(u)) throw g("Room reservation batch Subjects must be distinct");
+		a.add(u), i.push(Object.freeze({
+			roomId: y(c.roomId),
+			subjectId: u,
+			...o ? { subjectKind: "guest" } : {},
+			...d ? { worldTarget: d } : {},
+			...s ? { sourceRoomId: y(c.sourceRoomId) } : {}
+		}));
+	}
+	return i.sort((e, t) => e.subjectId < t.subjectId ? -1 : +(e.subjectId > t.subjectId)), Object.freeze({
+		requestId: y(n.requestId),
+		tenantId: y(n.tenantId),
+		seats: Object.freeze(i)
+	});
+}, w = (e, t, n) => {
+	if (!Number.isSafeInteger(n) || n < 0 || n >= 1024) throw g("Invalid Room batch ordinal");
+	return "rgseat_" + _([_([
+		"voltro.rooms.reservation-batch.v1",
+		y(e),
+		y(t)
+	]), n]);
+}, T = (e) => ({
+	key: _([
+		"voltro.rooms.reservation-batch.v1",
+		e.tenantId,
+		e.requestId
+	]),
+	digest: _({
+		...e,
+		seats: e.seats.map(({ sourceRoomId: e, ...t }) => t)
+	}),
+	session: (t) => w(e.tenantId, e.requestId, t)
+}), E = (e, t) => {
+	let n = C(e, 1024);
+	if (!Number.isSafeInteger(t) || t < 0 || t >= n.seats.length) throw g("Invalid Room batch ordinal");
+	return T(n).session(t);
+}, D = (e, t, n, r) => {
+	let { key: i, digest: a, session: o } = r, s = t.seats[n], c = v(e.reservationBatchReceipt, [
+		"version",
+		"key",
+		"digest",
+		"size",
+		"ordinal",
+		"issuedAt",
+		"signingKid",
+		...s.worldTarget ? ["worldTarget"] : []
+	]);
+	if (s.worldTarget && JSON.stringify(l(c.worldTarget)) !== JSON.stringify(s.worldTarget)) throw g("Room reservation batch World target binding changed");
+	if (c.version !== 1 || c.key !== i || c.digest !== a || c.size !== t.seats.length || c.ordinal !== n || e.reservationBatchKey !== i || e.tenantId !== t.tenantId || e.roomId !== s.roomId || e.subjectId !== s.subjectId || e.role !== "player" || e.sessionId !== o(n)) throw g("Room reservation batch receipt does not match its original request");
+	return c;
+}, O = (e) => e.attributes == null ? {} : { attributes: o(String(e.roomId), e.attributes) }, k = async (e, t, n) => {
+	let r = n.sourceRoomId ?? n.worldTarget?.sourceRoomId;
+	if (r === void 0) return {};
+	let i = await e.query({
+		table: s,
+		predicate: d(f("tenantId", t), f("roomId", r), f("subjectId", n.subjectId)),
+		order: [{
+			column: "updatedAt",
+			direction: "desc"
+		}],
+		take: 16,
+		skip: void 0,
+		projection: [
+			"roomId",
+			"attributes",
+			"state"
+		]
+	}), a = i.find((e) => e.state !== "released") ?? i[0];
+	return a ? O(a) : {};
+}, A = (e, t, n, r, i, a, o, s) => {
+	let c = t.seats[n], l = T(t).session(n), d = x(e.expiresAt), f = r.issuedAt;
+	if (typeof f != "number" || !Number.isSafeInteger(f) || f < 0 || f > s || f !== x(e.createdAt) || typeof e.nonce != "string" || e.state !== "reserved" || d <= s) throw g("Room reservation batch issuance receipt is invalid");
+	let p = e.reservationBatchReissueReceipt == null ? r : v(e.reservationBatchReissueReceipt, ["issuedAt", "signingKid"]), m = p.issuedAt;
+	if (typeof m != "number" || !Number.isSafeInteger(m) || m < f || m > s || m >= d) throw g("Room reservation batch reissue time is invalid");
+	let h = [a.current, a.previous].find((e) => e && e.kid === p.signingKid);
+	if (!h) throw g("Room reservation batch signing key is unavailable");
+	let _ = o({
+		roomId: c.roomId,
+		subjectId: c.subjectId,
+		...c.subjectKind ? { subjectKind: c.subjectKind } : {},
+		tenantId: t.tenantId,
+		sessionId: l,
+		role: "player",
+		epoch: b(e.epoch),
+		nonce: e.nonce,
+		expiresAt: d,
+		...O(e)
+	}, i, m, { current: h });
+	if (u(_.token) !== e.token) throw g("Room reservation batch signer cannot reproduce its current credential");
+	return _;
+}, j = (e, t, n) => {
+	let r = C(t, 1024);
+	if (!Number.isSafeInteger(n) || n < 0 || n >= r.seats.length) throw g("Invalid Room batch ordinal");
+	D(e, r, n, T(r));
+}, M = (n) => {
+	let { store: i, budget: a, now: o, authorize: c, rooms: l, capacity: u } = n;
+	return (n) => {
+		if (!a) return p.fail(g("Room reservation batch release is not configured"));
+		let m;
+		try {
+			m = C(n, a.maxSeats);
+		} catch (t) {
+			return p.fail(t instanceof e ? t : g("Invalid Room batch release"));
+		}
+		let h = T(m), { key: _, session: v } = h;
+		return p.gen(function* () {
+			yield* a.authorize(m);
+			for (let e of m.seats) yield* c(e.roomId, {
+				tenantId: m.tenantId,
+				subjectId: e.subjectId
+			});
+			return yield* p.uninterruptible(p.tryPromise({
+				try: () => i.transactional(async (e) => {
+					let t = o();
+					if (!Number.isSafeInteger(t) || t < 0) throw g("Invalid Room batch release clock");
+					let n = [...new Set(m.seats.map((e) => e.roomId))].sort(), r = await l(e, n, m.tenantId), i = await e.query({
+						table: s,
+						predicate: d(f("tenantId", m.tenantId), f("reservationBatchKey", _)),
+						order: [],
+						take: a.maxSeats + 1,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					});
+					if (!i.length) return Object.freeze({
+						requestId: m.requestId,
+						state: "absent",
+						sessionIds: Object.freeze([])
+					});
+					if (i.length !== m.seats.length) throw g("Room batch release receipt is incomplete");
+					let c = /* @__PURE__ */ new Map();
+					for (let n = 0; n < m.seats.length; n++) {
+						let a = i.find((e) => e.sessionId === v(n)), o = m.seats[n], s = r.get(o.roomId);
+						if (!a || !s || s.tenantId !== m.tenantId) throw g("Room batch release lost its owner or receipt");
+						if (D(a, m, n, h), a.state !== "released") {
+							if (!["reserved", "grace"].includes(String(a.state)) || a.epoch !== s.epoch) throw g("Room batch release requires disconnected current-epoch seats");
+							if (await e.updateMany("_voltro_room_seats", {
+								state: "released",
+								graceUntil: null,
+								updatedAt: new Date(t)
+							}, { where: d(f("id", a.id), f("tenantId", m.tenantId), f("state", a.state), f("epoch", a.epoch), f("reservationBatchKey", _)) }) !== 1) throw g("Room batch release lost its SQL seat CAS");
+							c.set(o.roomId, (c.get(o.roomId) ?? 0) + 1);
+						}
+					}
+					for (let i of n) c.has(i) && await u(e, r.get(i), -c.get(i), t);
+					return Object.freeze({
+						requestId: m.requestId,
+						state: "released",
+						sessionIds: Object.freeze(m.seats.map((e, t) => v(t)))
+					});
+				}),
+				catch: (n) => n instanceof e || n instanceof t || n instanceof r ? n : g("Room reservation batch release transaction failed")
+			}));
+		});
+	};
+}, N = (o, l = !0, m) => {
+	let { store: _, budget: v, secrets: y, seatTtlMs: S, now: w, authorize: E, rooms: O, endpoints: j, capacity: M, sign: N, create: P } = o;
+	return (o, F) => {
+		if (!v) return p.fail(g("Room reservation batches are not configured"));
+		let I;
+		try {
+			if (F !== void 0 && typeof F != "function") throw g("Room batch scope must be an actual acquired operation");
+			if (I = C(o, v.maxSeats), m !== void 0 && (l || typeof m != "string" || !I.seats.some((e) => e.subjectId === m))) throw g("Room batch replay requires its original selected Subject");
+		} catch (t) {
+			return p.fail(t instanceof e ? t : g("Invalid Room reservation batch"));
+		}
+		let L = T(I), { key: R, digest: z, session: B } = L;
+		return p.gen(function* () {
+			yield* v.authorize(I);
+			for (let e of I.seats) yield* E(e.roomId, Object.freeze({
+				tenantId: I.tenantId,
+				subjectId: e.subjectId
+			}));
+			let o = async (e) => {
+				let t = w();
+				if (!Number.isSafeInteger(t) || t < 0 || !Number.isSafeInteger(t + S)) throw g("Invalid Room reservation batch clock");
+				let r = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), _ = [...new Set(I.seats.map((e) => e.roomId))].sort(), C = await O(e, _, I.tenantId);
+				for (let e of _) {
+					let t = C.get(e);
+					if (!t) throw g("Room reservation batch SQL owner disappeared");
+					if (t.id !== e || t.tenantId !== I.tenantId) throw g("Room reservation batch SQL owner scope changed");
+					r.set(e, t);
+				}
+				for (let t of I.seats) await c(e, {
+					tenantId: I.tenantId,
+					subjectId: t.subjectId
+				});
+				let T = await e.query({
+					table: s,
+					predicate: d(f("tenantId", I.tenantId), f("reservationBatchKey", R)),
+					order: [],
+					take: v.maxSeats + 1,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				for (let [n, i] of r) o.set(n, await j(e, i, t));
+				if (T.length > 0) {
+					if (T.length !== I.seats.length) throw g("Room reservation batch receipt is incomplete");
+					let e = [];
+					for (let n = 0; n < I.seats.length; n++) {
+						let i = I.seats[n], s = r.get(i.roomId), c = T.find((e) => e.sessionId === B(n));
+						if (!c) throw g("Room reservation batch receipt is incomplete");
+						let l = D(c, I, n, L), u = x(c.expiresAt);
+						if (c.epoch !== s.epoch) throw new a({ sessionId: B(n) });
+						if (m !== void 0 && i.subjectId !== m) {
+							if (c.state === "reserved" ? u <= t : c.state === "grace" ? x(c.graceUntil) <= t : c.state !== "connected") throw new a({ sessionId: B(n) });
+							continue;
+						}
+						if (c.state !== "reserved" || u <= t) throw new a({ sessionId: B(n) });
+						let d = A(c, I, n, l, o.get(i.roomId), y, N, t);
+						e.push(Object.freeze({
+							...d,
+							subjectId: i.subjectId
+						}));
+					}
+					return Object.freeze({
+						requestId: I.requestId,
+						seats: Object.freeze(e)
+					});
+				}
+				if (!l) throw g("Room reservation batch replay requires an existing complete receipt");
+				for (let e of I.seats) p.set(e.roomId, (p.get(e.roomId) ?? 0) + 1);
+				for (let [e, t] of r) {
+					if (t.locked !== !1) throw new i({ roomId: e });
+					if (b(t.clients) + p.get(e) > b(t.maxClients)) throw new n({ roomId: e });
+				}
+				let E = [];
+				for (let t of I.seats) E.push(await k(e, I.tenantId, t));
+				let F = I.seats.map((e, n) => {
+					let i = {
+						roomId: e.roomId,
+						subjectId: e.subjectId,
+						...e.subjectKind ? { subjectKind: e.subjectKind } : {},
+						tenantId: I.tenantId,
+						role: "player",
+						sessionId: B(n),
+						epoch: b(r.get(e.roomId).epoch),
+						nonce: h(16).toString("base64url"),
+						expiresAt: t + S,
+						...E[n]
+					};
+					return {
+						claims: i,
+						result: N(i, o.get(e.roomId), t, y),
+						receipt: {
+							version: 1,
+							key: R,
+							digest: z,
+							size: I.seats.length,
+							ordinal: n,
+							issuedAt: t,
+							signingKid: y.current.kid,
+							...e.worldTarget ? { worldTarget: e.worldTarget } : {}
+						}
+					};
+				});
+				for (let [n, i] of r) await M(e, i, p.get(n), t);
+				for (let n of F) if (await P(e, n.claims, u(n.result.token), n.claims.roomId), await e.updateMany("_voltro_room_seats", {
+					reservationBatchKey: R,
+					reservationBatchReceipt: n.receipt,
+					createdAt: new Date(t)
+				}, { where: d(f("sessionId", n.claims.sessionId), f("roomId", n.claims.roomId), f("tenantId", I.tenantId), f("subjectId", n.claims.subjectId), f("token", u(n.result.token)), f("state", "reserved")) }) !== 1) throw g("Room reservation batch lost its inserted seat");
+				return Object.freeze({
+					requestId: I.requestId,
+					seats: Object.freeze(F.map((e) => Object.freeze({
+						...e.result,
+						subjectId: e.claims.subjectId
+					})))
+				});
+			}, C = F === void 0 ? p.uninterruptible(p.tryPromise({
+				try: () => _.transactional(o),
+				catch: (e) => e
+			})) : F(o);
+			return p.isEffect(C) ? yield* C.pipe(p.mapError((o) => o instanceof e || o instanceof t || o instanceof n || o instanceof r || o instanceof i || o instanceof a ? o : g("Room reservation batch transaction failed"))) : yield* p.fail(g("Room batch scope must return an actual Effect"));
+		});
+	};
+}, P = (e) => (t, n) => typeof n != "string" || !n ? p.fail(g("Room batch member replay requires its Subject")) : N(e, !1, n)(t).pipe(p.flatMap((e) => e.seats.length === 1 && e.seats[0].subjectId === n ? p.succeed(e.seats[0]) : p.fail(g("Room batch member replay did not select exactly one credential")))), F = (o) => {
+	let { budget: l, secrets: m, seatTtlMs: _, now: v, authorize: S, rooms: w, endpoints: E, capacity: k, sign: j } = o;
+	return (o, M, N) => {
+		let P, F, I;
+		try {
+			if (!l || typeof N != "function") throw g("Room batch reissue requires explicit budget/policy and actual transaction scope");
+			if (P = C(o, l.maxSeats), F = y(M), I = P.seats.findIndex((e) => e.subjectId === F), I < 0) throw g("Room batch reissue requires an original member");
+		} catch {
+			return p.fail(g("Invalid or unconfigured Room batch reissue"));
+		}
+		let L = T(P), R = P.seats[I];
+		return p.gen(function* () {
+			yield* l.authorize(P), yield* S(R.roomId, {
+				tenantId: P.tenantId,
+				subjectId: F
+			});
+			let o = N(async (e) => {
+				let t = v();
+				if (!Number.isSafeInteger(t) || t < 0 || !Number.isSafeInteger(t + _)) throw g("Invalid Room batch reissue clock");
+				let r = (await w(e, [R.roomId], P.tenantId)).get(R.roomId);
+				if (!r || r.id !== R.roomId || r.tenantId !== P.tenantId) throw g("Room batch reissue lost its target owner");
+				await c(e, {
+					tenantId: P.tenantId,
+					subjectId: F
+				});
+				let a = await e.query({
+					table: s,
+					predicate: d(f("tenantId", P.tenantId), f("reservationBatchKey", L.key)),
+					order: [],
+					take: l.maxSeats + 1,
+					skip: void 0,
+					projection: void 0
+				});
+				if (a.length !== P.seats.length) throw g("Room batch reissue lost complete original membership");
+				for (let e = 0; e < P.seats.length; e++) {
+					let t = a.find((t) => t.sessionId === L.session(e));
+					if (!t) throw g("Room batch reissue lost an original peer receipt");
+					D(t, P, e, L);
+				}
+				let o = await e.query({
+					table: s,
+					predicate: d(f("tenantId", P.tenantId), f("sessionId", L.session(I))),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				if (o.length !== 1) throw g("Room batch reissue lost its selected Seat");
+				let p = o[0], y = D(p, P, I, L), S = await E(e, r, t);
+				if (![
+					"reserved",
+					"grace",
+					"released"
+				].includes(String(p.state)) || p.worldSourceTransitionId != null || b(p.epoch) > b(r.epoch)) throw g("Room batch reissue refuses connected, fenced or newer Seats");
+				if (p.state === "reserved" && p.epoch === r.epoch && x(p.expiresAt) > t) return A(p, P, I, y, S, m, j, t);
+				if (r.locked !== !1) throw new i({ roomId: R.roomId });
+				let C = +(p.state === "released");
+				if (b(r.clients) + C > b(r.maxClients)) throw new n({ roomId: R.roomId });
+				let T = {
+					roomId: R.roomId,
+					tenantId: P.tenantId,
+					subjectId: F,
+					role: "player",
+					sessionId: L.session(I),
+					epoch: b(r.epoch),
+					nonce: h(16).toString("base64url"),
+					expiresAt: t + _,
+					...O(p)
+				}, M = j(T, S, t, m);
+				if (C && await k(e, r, C, t), await e.updateMany("_voltro_room_seats", {
+					epoch: T.epoch,
+					nonce: T.nonce,
+					state: "reserved",
+					token: u(M.token),
+					expiresAt: new Date(T.expiresAt),
+					graceUntil: null,
+					updatedAt: new Date(t),
+					reservationBatchReissueReceipt: {
+						issuedAt: t,
+						signingKid: m.current.kid
+					}
+				}, { where: d(f("id", p.id), f("tenantId", P.tenantId), f("state", p.state), f("epoch", p.epoch), f("token", p.token)) }) !== 1) throw g("Room batch reissue lost its credential CAS");
+				return M;
+			});
+			return p.isEffect(o) ? yield* o.pipe(p.mapError((o) => o instanceof e || o instanceof t || o instanceof n || o instanceof r || o instanceof i || o instanceof a ? o : g("Room batch reissue transaction failed"))) : yield* p.fail(g("Room batch reissue requires an actual scoped Effect"));
+		});
+	};
+};
+//#endregion
+export { j as assertRoomReservationBatchSeatReceipt, C as captureRoomReservationBatch, S as captureRoomReservationBatchOptions, N as makeRoomReservationBatch, P as makeRoomReservationBatchMemberReplay, F as makeRoomReservationBatchReissue, M as makeRoomReservationBatchRelease, E as roomReservationBatchSessionId, w as roomReservationBatchSessionIdentity };

package/dist/reservationSchemas.js

@@ -0,0 +1,17 @@
+import { Schema as e } from "effect";
+//#region src/reservationSchemas.ts
+var t = e.Struct({
+	ws: e.NonEmptyString,
+	wt: e.optional(e.NonEmptyString),
+	wtCertificateHash: e.optional(e.NonEmptyString)
+}), n = e.Struct({
+	roomId: e.NonEmptyString,
+	sessionId: e.NonEmptyString,
+	token: e.Uint8Array,
+	address: e.NonEmptyString,
+	endpoints: e.optional(t),
+	transport: e.Union([e.Tuple([e.Literal("ws")]), e.Tuple([e.Literal("ws"), e.Literal("wt")])]),
+	expiresAt: e.Number.pipe(e.check(e.isFinite()), e.check(e.isGreaterThan(0)))
+});
+//#endregion
+export { n as RoomReservationSchema, t as RoomTransportEndpointsSchema };