@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldDefaultGroupControl.js

@@ -0,0 +1,71 @@
+import { ProtocolError as e } from "./errors.js";
+import { roomReservationBatchSessionId as t } from "./reservationBatch.js";
+import { worldTransitionGroupFromRecords as n } from "./worldTransitionGroup.js";
+import { readWorldTransitionSeatGroup as r, worldTransitionSeatBatch as i } from "./worldTransitionSeatGroup.js";
+import { worldGroupAppServices as a } from "./worldDefaultGroupAppServices.js";
+import { defaultWorldGroupMembers as o } from "./worldDefaultGroupMembers.js";
+import { makeWorldGroupDeadline as s } from "./worldGroupDeadline.js";
+import { makeWorldGroupPreparation as c } from "./worldGroupPreparation.js";
+import { makeWorldGroupReadyControl as l } from "./worldGroupReadyControl.js";
+import { Effect as u } from "effect";
+// src/worldDefaultGroupControl.ts
+var d = () => new e({ detail: "Original World group control is unavailable" }), f = (e, t) => e.tenantId === t.tenantId && e.roomId === t.roomId && e.requestId === t.requestId, p = (e) => {
+	let { tenantId: p, groups: m, executor: h, resolve: g } = e, _ = m.entities.transitions, v = a(e.runWithAppServices, e.parties), y = (e) => c({
+		tenantId: p,
+		maxMembers: 64,
+		maxResolvedMemberBytes: 1048576,
+		states: _,
+		executor: h,
+		resolve: g,
+		authorize: () => u.void,
+		resolveMembers: o({
+			tenantId: p,
+			maxMembers: 64,
+			parties: e,
+			entities: m.entities
+		})
+	}), b = Object.freeze({
+		prepare: (e, t) => v((n) => y(n).prepare(e, t)),
+		transitionGroup: (e, t) => v((n) => y(n).transitionGroup(e, t)),
+		status: (e, t) => v((n) => y(n).status(e, t))
+	}), x = (e) => u.gen(function* () {
+		if (!e.groupCommand || e.origin.tenantId !== p) return yield* u.fail(d());
+		let t = yield* _.observeGroupCommand(e.groupCommand.origin).pipe(u.mapError(d));
+		return !t || t.records.length > 64 || !n(t.records) || JSON.stringify(t.command) !== JSON.stringify(e.groupCommand) || !t.records.some((t) => t.id === e.id && f(t.origin, e.origin)) || t.records.some((t) => !t.subject || t.group?.key !== e.group?.key || t.group?.digest !== e.group?.digest) ? yield* u.fail(d()) : t.records.map((e) => Object.freeze({
+			origin: e.origin,
+			expectedSubject: e.subject
+		}));
+	}), S = Object.freeze({ commit: (n, a) => v(() => m.admissions.withScope((o) => l({
+		tenantId: p,
+		maxMembers: 64,
+		states: _,
+		executor: h,
+		authorize: () => u.void,
+		resolveMembers: (e) => x(e),
+		resolveTargetSession: (n, a) => u.gen(function* () {
+			let s = yield* r(e.store, _.observe.bind(_), n, 64), c = i(s, !0), l = c.seats.findIndex((e) => e.subjectId === n.subject?.id);
+			if (l < 0) return yield* u.fail(d());
+			let f = yield* e.bindAdmission(n, t(c, l), a);
+			return yield* o.read(n, f);
+		})
+	}).commit(n, a))) }), C = (e, t) => v(() => u.gen(function* () {
+		let n = yield* _.observe(e).pipe(u.mapError(d));
+		if (!n || t.type !== "user" || t.tenantId !== p || n.subject?.id !== t.id || n.subject.kind !== (t.kind === "guest" ? "guest" : "user")) return yield* u.fail(d());
+		let r = yield* x(n);
+		return (yield* h.cancelTogether(r, n.failure ?? "clientCancel")).find((t) => t.id === n.id && f(t.origin, e)) ?? (yield* u.fail(d()));
+	})), w = s({
+		tenantId: p,
+		maxMembers: 64,
+		epochNow: e.epochNow,
+		states: _,
+		executor: h,
+		authorize: () => u.void
+	});
+	return Object.freeze({
+		preparation: b,
+		ready: S,
+		cancel: C,
+		deadline: w
+	});
+};
+export { p as defaultWorldGroupControl };

package/dist/worldDefaultGroupMembers.js

@@ -0,0 +1,84 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldGroupCommand as t } from "./worldGroupCommand.js";
+import { Effect as n } from "effect";
+// src/worldDefaultGroupMembers.ts
+var r = () => new e({ detail: "World party membership is unavailable or differs from its current ownership" });
+function i() {
+	throw r();
+}
+var a = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(e) ? e : i(), o = (e, t, n = !0) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype || n && Reflect.ownKeys(e).length !== t.length) return i();
+	let r = {};
+	for (let n of t) {
+		let t = Object.getOwnPropertyDescriptor(e, n);
+		if (!t || !t.enumerable || !("value" in t)) return i();
+		r[n] = t.value;
+	}
+	return r;
+}, s = (e, t) => {
+	let n = e && typeof e == "object" ? Object.getOwnPropertyDescriptor(e, t) : void 0;
+	return !n || !("value" in n) || typeof n.value != "function" ? i() : n.value.bind(e);
+}, c = (e) => n.suspend(() => {
+	let t = e();
+	return n.isEffect(t) ? t : n.fail(r());
+}).pipe(n.catchCause(() => n.fail(r()))), l = (e) => {
+	let l = o(e, [
+		"tenantId",
+		"maxMembers",
+		"parties",
+		"entities"
+	]), u = a(l.tenantId), d = l.maxMembers;
+	(typeof d != "number" || !Number.isSafeInteger(d) || d < 1 || d > 1024) && i();
+	let f = s(l.parties, "read"), p = s(l.entities, "observe");
+	return (e) => {
+		let s, l;
+		try {
+			s = t(e), s.origin.tenantId !== u && i(), l = f(u, s.intent.partyId), n.isEffect(l) || i();
+		} catch {
+			return n.fail(r());
+		}
+		return c(() => l).pipe(n.flatMap((e) => c(() => n.gen(function* () {
+			let t = o(e, [
+				"tenantId",
+				"partyId",
+				"leaderId",
+				"memberIds"
+			]);
+			if (t.tenantId !== u || t.partyId !== s.intent.partyId) return i();
+			let n = a(t.leaderId), r = t.memberIds;
+			if (!Array.isArray(r) || !r.length || r.length > d || Reflect.ownKeys(r).length !== r.length + 1) return i();
+			let l = [], f = /* @__PURE__ */ new Set();
+			for (let e = 0; e < r.length; e++) {
+				let t = Object.getOwnPropertyDescriptor(r, e);
+				if (!t || !t.enumerable || !("value" in t)) return i();
+				let n = a(t.value);
+				if (f.has(n)) return i();
+				f.add(n), l.push(n);
+			}
+			if (!f.has(n)) return i();
+			let m = [];
+			for (let e of l) {
+				let t = o(yield* c(() => p({
+					tenantId: u,
+					entityId: e
+				})), [
+					"tenantId",
+					"entityId",
+					"subject",
+					"roomId"
+				], !1), r = o(t.subject, ["id", "kind"]), l = a(t.roomId);
+				if (t.tenantId !== u || t.entityId !== e || r.id !== e || r.kind !== "user" && r.kind !== "guest" || e === n && l !== s.origin.roomId) return i();
+				m.push(Object.freeze({
+					entityId: e,
+					roomId: l,
+					subject: Object.freeze({
+						id: e,
+						kind: r.kind
+					})
+				}));
+			}
+			return Object.freeze(m);
+		}))));
+	};
+};
+export { l as defaultWorldGroupMembers };

package/dist/worldDefaultGroups.js

@@ -0,0 +1,20 @@
+import { ProtocolError as e } from "./errors.js";
+import { makeWorldGroupAdmissionScopes as t } from "./worldDefaultGroupAdmission.js";
+import { makeWorldGroupCompensationScopes as n } from "./worldDefaultGroupCompensation.js";
+import { Effect as r } from "effect";
+// src/worldDefaultGroups.ts
+var i = (i) => {
+	let a, o = () => new e({ detail: "Default World group state is unavailable" }), s = t(), c = n({ observe: (e) => r.suspend(() => a?.transitions?.observe(e) ?? r.fail(o())) }), l = i({
+		maxRows: 64,
+		readiness: { confirm: s.confirm },
+		authorize: (e, t) => e === "rollback" ? c.confirm(t) : r.void,
+		proceed: { authorize: (e) => e.command.intent.onTimeout === "proceed" ? r.void : r.fail(o()) }
+	});
+	if (!l.transitions) throw o();
+	return a = l, Object.freeze({
+		entities: l,
+		admissions: s,
+		compensation: c
+	});
+};
+export { i as makeDefaultWorldGroups };

package/dist/worldDefaultPending.js

@@ -0,0 +1,78 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldClientPendingInput as t } from "./worldClientPendingInput.js";
+import { WORLD_TRANSITIONS_TABLE as n } from "./identities.js";
+import { worldClientReceipt as r } from "./worldClient.js";
+import { WORLD_ENTITIES_TABLE as i } from "./worldEntities.js";
+import { and as a, eq as o } from "@voltro/database";
+import { Subject as s } from "@voltro/protocol";
+import { Effect as c, Schema as l } from "effect";
+// src/worldDefaultPending.ts
+var u = () => new e({ detail: "Current player World transition is unavailable" }), d = (e) => {
+	let d = new Set(e.worlds.map((e) => e.name)), f = e.observe;
+	return (p, m) => {
+		let h, g;
+		try {
+			h = t(p), g = l.decodeUnknownSync(s)(structuredClone(m)), g.type === "user" && g.scopes && Object.freeze(g.scopes), Object.freeze(g);
+		} catch {
+			return c.fail(u());
+		}
+		if (g.type !== "user" || g.tenantId !== e.tenantId) return c.fail(u());
+		let _ = g.kind === "guest" ? "guest" : "user";
+		return c.tryPromise({
+			try: async () => {
+				let t = await e.store.query({
+					table: i,
+					predicate: a(o("tenantId", e.tenantId), o("entityId", h.entityId), o("subjectId", g.id), o("subjectKind", _)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"entityId",
+						"subjectId",
+						"subjectKind",
+						"worldId",
+						"roomId",
+						"activeTransitionId"
+					]
+				});
+				if (t.length === 0) return null;
+				if (t.length !== 1) throw u();
+				let r = t[0];
+				if (!d.has(String(r.worldId)) || r.roomId !== h.roomId || r.activeTransitionId == null) return null;
+				if (typeof r.activeTransitionId != "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(r.activeTransitionId)) throw u();
+				let s = await e.store.query({
+					table: n,
+					predicate: a(o("tenantId", e.tenantId), o("id", r.activeTransitionId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"id",
+						"entityId",
+						"subjectId",
+						"subjectKind",
+						"sourceRoomId",
+						"sourceWorldId",
+						"phase",
+						"requestId"
+					]
+				});
+				if (s.length !== 1) throw u();
+				let c = s[0];
+				if (c.id !== r.activeTransitionId || c.entityId !== h.entityId || c.subjectId !== g.id || c.subjectKind !== _ || c.sourceRoomId !== h.roomId || c.sourceWorldId !== r.worldId) throw u();
+				if (c.phase !== "switching") return null;
+				if (typeof c.requestId != "string") throw u();
+				return {
+					requestId: c.requestId,
+					transitionId: c.id
+				};
+			},
+			catch: u
+		}).pipe(c.flatMap((e) => e === null ? c.succeed(null) : f(e.requestId, g).pipe(c.map((t) => {
+			let n = r(t);
+			if (n.ticket.requestId !== e.requestId || n.ticket.transitionId !== e.transitionId) throw u();
+			return n.phase === "prepared" ? n : null;
+		}))), c.catchCause(() => c.fail(u())));
+	};
+};
+export { d as defaultWorldPending };

package/dist/worldDefaultService.js

@@ -0,0 +1,244 @@
+import { ProtocolError as e } from "./errors.js";
+import { worldTransitionGroupFromRecords as t } from "./worldTransitionGroup.js";
+import { makeWorldTransitionExecutor as n } from "./worldTransitionExecutor.js";
+import { dataStoreRoomReservations as r } from "./reservations.js";
+import { defaultWorldTransitionPolicies as i } from "./worldTransitionDefaults.js";
+import { worldTransitionPhysicalSteps as a, worldTransitionSeatWithdrawal as o } from "./worldTransitionPhysicalSteps.js";
+import { makeWorldTransitionResolver as s } from "./worldTransitionResolver.js";
+import { dataStoreWorldTransitionSeats as c } from "./worldTransitionSeats.js";
+import { Effect as l } from "effect";
+// src/worldDefaultService.ts
+var u = (t, n = 1) => {
+	let { store: a, tenantId: u, worlds: d, catalog: f, entities: p, rooms: m, epochNow: h, maxBytes: g } = t, _ = p.transitions;
+	if (!_) throw new e({ detail: "Default World transitions need entity transition state" });
+	let v = r(a, {
+		secrets: t.seats.secrets,
+		worlds: d,
+		epochNow: h,
+		seatTtlMs: t.seats.seatTtlMs,
+		graceMs: t.seats.graceMs,
+		hostHeartbeatTtlMs: t.seats.hostHeartbeatTtlMs,
+		authorize: () => l.void,
+		batch: {
+			maxSeats: n,
+			authorize: () => l.void
+		},
+		batchRelease: {
+			maxSeats: n,
+			authorize: () => l.void
+		},
+		...n > 1 ? { batchReissue: {
+			maxSeats: n,
+			authorize: () => l.void
+		} } : {}
+	}), y = c(a, {
+		tenantId: u,
+		epochNow: h,
+		pendingAdmission: !0,
+		...n > 1 ? { maxGroupRows: n } : {},
+		worlds: d,
+		states: _,
+		reservations: v,
+		authorize: () => l.void,
+		withdraw: o(m, g)
+	}), b = s({
+		tenantId: u,
+		worlds: d,
+		entities: p,
+		maxDataBytes: g,
+		placementClass: "default",
+		...i({
+			store: a,
+			tenantId: u,
+			worlds: d,
+			catalog: f,
+			rooms: m,
+			epochNow: h,
+			maxDataBytes: g,
+			maxManagedGroups: t.maxManagedGroups ?? 1024,
+			...t.allocation === void 0 ? {} : { allocation: t.allocation }
+		})
+	});
+	return Object.freeze({
+		seats: y,
+		resolve: b
+	});
+}, d = (e) => {
+	let { tenantId: t, entities: r, leases: i, rooms: o, maxBytes: s } = e, { seats: c, resolve: d } = u(e), f = n({
+		tenantId: t,
+		maxPhaseSteps: 64,
+		states: r.transitions,
+		leases: i,
+		authorize: () => l.void,
+		resolve: d,
+		...a({
+			rooms: o,
+			seats: c,
+			maxBytes: s
+		})
+	});
+	return Object.freeze({
+		executor: f,
+		seats: c
+	});
+}, f = () => new e({ detail: "Forwarded World group requires its complete original durable membership" }), p = (e, t) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) throw f();
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	if (!n || !("value" in n)) throw f();
+	return n.value;
+}, m = (e, t = 191) => {
+	if (typeof e != "string" || e.length > t || !/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e)) throw f();
+	return e;
+}, h = (e) => Object.freeze({
+	tenantId: m(p(e, "tenantId")),
+	roomId: m(p(e, "roomId")),
+	requestId: m(p(e, "requestId"), 384)
+}), g = (e, t) => e.tenantId === t.tenantId && e.roomId === t.roomId && e.requestId === t.requestId, _ = (e) => {
+	if (!Array.isArray(e) || !e.length || e.length > 64 || Reflect.ownKeys(e).length !== e.length + 1) throw f();
+	let t = /* @__PURE__ */ new Set(), n = [];
+	for (let r = 0; r < e.length; r++) {
+		let i = Object.getOwnPropertyDescriptor(e, r);
+		if (!i || !("value" in i)) throw f();
+		let a = h(p(i.value, "origin")), o = p(i.value, "expectedSubject"), s = m(p(o, "id")), c = p(o, "kind");
+		if (c !== "guest" && c !== "user") throw f();
+		let l = JSON.stringify(a);
+		if (t.has(l)) throw f();
+		t.add(l), n.push(Object.freeze({
+			origin: a,
+			expectedSubject: Object.freeze({
+				id: s,
+				kind: c
+			})
+		}));
+	}
+	return Object.freeze(n);
+}, v = (e, n) => l.gen(function* () {
+	let r = [];
+	for (let t of n) {
+		let n = yield* e(t.origin);
+		if (!g(n.origin, t.origin) || !t.expectedSubject || n.subject?.id !== t.expectedSubject.id || n.subject.kind !== t.expectedSubject.kind) throw f();
+		r.push(n);
+	}
+	if (!t(r)) throw f();
+	let i = r[0].groupCommand;
+	if (r.some((e) => JSON.stringify(e.groupCommand) !== JSON.stringify(i))) throw f();
+	return Object.freeze({
+		records: Object.freeze(r),
+		origin: i?.origin ?? r[0].origin
+	});
+}).pipe(l.catchCause(() => l.fail(f()))), y = (e, t, r) => {
+	if (e.entities !== t.entities) throw f();
+	let { tenantId: i, entities: o, leases: s, rooms: c, maxBytes: d } = e, { seats: p, resolve: m } = u(e, 64), h = a({
+		rooms: c,
+		seats: p,
+		maxBytes: d
+	}), g = {
+		tenantId: i,
+		maxPhaseSteps: 64,
+		states: o.transitions,
+		leases: s,
+		authorize: () => l.void,
+		resolve: m,
+		...h,
+		maxTogetherRows: 64,
+		authorizeTogether: (e) => l.try({
+			try: () => {
+				_(e);
+			},
+			catch: f
+		})
+	}, y = n(g), b = Object.freeze({
+		...y,
+		commitTogether: (e) => {
+			let n;
+			try {
+				n = _(e);
+			} catch {
+				return l.fail(f());
+			}
+			return t.admissions.withScope((e) => l.gen(function* () {
+				let t = yield* v(y.status, n);
+				for (let n of t.records) n.phase === "switching" && n.ready && (yield* e.read(n, yield* r(n)));
+				return yield* y.commitTogether(n);
+			}));
+		},
+		cancelTogether: (e, r) => {
+			let i;
+			try {
+				i = _(e);
+			} catch {
+				return l.fail(f());
+			}
+			return t.compensation.withScope((e) => n({
+				...g,
+				rollback: e.rollback(h.rollback)
+			}).cancelTogether(i, r));
+		}
+	});
+	return Object.freeze({
+		executor: b,
+		seats: p,
+		resolve: m
+	});
+}, b = (e, t) => {
+	switch (t.action) {
+		case "prepare": return e.prepare(t.intention, t.origin, t.expectedSubject).pipe(l.asVoid);
+		case "commit": return e.commit(t.origin, t.expectedSubject).pipe(l.asVoid);
+		case "cancel": return e.cancel(t.origin, t.reason, t.expectedSubject).pipe(l.asVoid);
+		default: {
+			let n, r, i;
+			try {
+				if (n = _(t.members), r = h(t.origin), i = t.action === "cancelTogether" ? t.reason : void 0, t.action === "cancelTogether" && (typeof i != "string" || !i.length || i.length > 120)) throw f();
+			} catch {
+				return l.fail(f());
+			}
+			let a = e.status, o = e[t.action];
+			if (typeof a != "function" || typeof o != "function") return l.fail(f());
+			let s = o.bind(e);
+			return v(a.bind(e), n).pipe(l.flatMap((e) => g(r, e.origin) ? s(n, i ?? "").pipe(l.asVoid) : l.fail(f())), l.catchCause(() => l.fail(f())));
+		}
+	}
+}, x = (t) => {
+	let n = (n) => t.states.observe(n).pipe(l.mapError(() => new e({ detail: "World transition is unavailable" })), l.flatMap((t) => t ? l.succeed(t) : l.fail(new e({ detail: "World transition request was not found" })))), r = (n) => t.ownership(n.origin.roomId, n.origin.tenantId).pipe(l.mapError(() => new e({ detail: "World source Room ownership is unavailable" })), l.flatMap((t) => t && t.hostId !== null && t.state === "live" ? l.succeed(t.hostId) : l.fail(new e({ detail: "World source Room has no live Host" }))), l.flatMap((r) => t.world.transition(r, n).pipe(l.mapError((t) => t instanceof e ? t : new e({ detail: "World transition on the source Host did not complete" }))))), i = (e) => r(e).pipe(l.flatMap(() => n(e.origin))), a = (e, t, i) => {
+		let a;
+		try {
+			if (a = _(t), e === "cancelTogether" && (typeof i != "string" || !i.length || i.length > 120)) throw f();
+		} catch {
+			return l.fail(f());
+		}
+		return v(n, a).pipe(l.flatMap((t) => r(e === "cancelTogether" ? {
+			action: e,
+			origin: t.origin,
+			members: a,
+			reason: i
+		} : {
+			action: e,
+			origin: t.origin,
+			members: a
+		})), l.flatMap(() => v(n, a)), l.map((e) => e.records));
+	}, o = (e) => e === void 0 ? {} : { expectedSubject: e };
+	return Object.freeze({
+		prepare: (e, t, n) => i({
+			action: "prepare",
+			origin: t,
+			intention: e,
+			...o(n)
+		}),
+		commit: (e, t) => i({
+			action: "commit",
+			origin: e,
+			...o(t)
+		}),
+		cancel: (e, t, n) => i({
+			action: "cancel",
+			origin: e,
+			reason: t,
+			...o(n)
+		}),
+		prepareTogether: (e) => a("prepareTogether", e),
+		commitTogether: (e) => a("commitTogether", e),
+		cancelTogether: (e, t) => a("cancelTogether", e, t),
+		status: n
+	});
+};
+export { u as defaultWorldComponents, y as defaultWorldGroupService, d as defaultWorldService, x as forwardedWorldTransitionExecutor, b as runWorldTransitionForward };