@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldTransitionResolver.js

@@ -0,0 +1,227 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { resolveWorldOnWorldChange as n } from "./worldChange.js";
+import { resolveWorldTransitionPolicy as r } from "./worldTransitions.js";
+import { worldTransitionRequest as i } from "./worldCommands.js";
+import { captureWorldCatalog as a, worldCellAt as o } from "./world.js";
+import { captureWorldEntityReturnAnchor as s } from "./worldReturnAnchor.js";
+import { Effect as c } from "effect";
+// src/worldTransitionResolver.ts
+function l() {
+	throw new e({ detail: "World transition resolution refused" });
+}
+var u = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e) ? e : l(), d = (e) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 && e <= 2147483647 ? e : l(), f = (e, t) => {
+	e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype && Reflect.ownKeys(e).length === t.length || l();
+	for (let n of t) {
+		let t = Object.getOwnPropertyDescriptor(e, n);
+		t?.enumerable && "value" in t || l();
+	}
+}, p = (e, t) => {
+	let n = e && typeof e == "object" ? Object.getOwnPropertyDescriptor(e, t) : void 0;
+	return n && "value" in n && typeof n.value == "function" || l(), n.value.bind(e);
+}, m = (t) => c.suspend(() => {
+	let n = t();
+	return c.isEffect(n) ? n : c.fail(new e({ detail: "World resolution requires actual Effects" }));
+}).pipe(c.catchCause(() => c.fail(new e({ detail: "World transition resolution remains incomplete" })))), h = (h) => {
+	f(h, [
+		"tenantId",
+		"worlds",
+		"maxDataBytes",
+		"placementClass",
+		"entities",
+		"authorize",
+		"captureCurrent",
+		"resolveDestination",
+		"admit"
+	]);
+	let g = u(h.tenantId), _ = d(h.maxDataBytes), v = u(h.placementClass, 120), y = a(h.worlds);
+	/^[A-Za-z0-9][A-Za-z0-9_-]{0,119}$/.test(v) || l();
+	let b = Object.getOwnPropertyDescriptor(h.entities, "worlds");
+	b && "value" in b || l();
+	let x = a(b.value);
+	(!y.length || x.length !== y.length || x.some((e, t) => e !== y[t])) && l();
+	let S = p(h.entities, "capturePersistence"), C = p(h.entities, "observe"), w = p(h, "authorize"), T = p(h, "captureCurrent"), E = p(h, "resolveDestination"), D = p(h, "admit"), O = (e) => y.find((t) => t.name === e) ?? l(), k = (e) => {
+		f(e, [
+			"worldId",
+			"zoneId",
+			"at",
+			"layer",
+			"roomId",
+			"epoch"
+		]), Array.isArray(e.at) && Object.getPrototypeOf(e.at) === Array.prototype && Reflect.ownKeys(e.at).length === 3 || l();
+		for (let t of ["0", "1"]) {
+			let n = Object.getOwnPropertyDescriptor(e.at, t);
+			n?.enumerable && "value" in n || l();
+		}
+		let t = O(u(e.worldId)), n = u(e.zoneId), r = d(e.layer);
+		t.characters !== "shared" && l();
+		let i = Object.freeze({
+			worldId: t.name,
+			zoneId: n,
+			at: Object.freeze([e.at[0], e.at[1]]),
+			layer: r,
+			roomId: u(e.roomId),
+			epoch: d(e.epoch)
+		});
+		return o(t, {
+			zone: i.zoneId,
+			at: i.at
+		}), !t.zones.find((e) => e.id === n).layering && r !== 1 && l(), i;
+	}, A = (e) => (f(e, ["location", "data"]), Object.freeze({
+		location: k(e.location),
+		data: t(e.data, _)
+	}));
+	return (a, p) => {
+		let h, b;
+		try {
+			h = i(a), f(p, [
+				"tenantId",
+				"roomId",
+				"requestId"
+			]), b = Object.freeze({
+				tenantId: u(p.tenantId),
+				roomId: u(p.roomId),
+				requestId: u(p.requestId, 384)
+			}), (b.tenantId !== g || ![
+				"cell",
+				"zone",
+				"layer",
+				"world",
+				"instance",
+				"return"
+			].includes(h.target.kind) || (h.target.kind === "instance" ? h.options.returnTo !== "here" : h.options.returnTo !== void 0)) && l();
+			let e = (t) => {
+				if (t && typeof t == "object") {
+					for (let n of Object.values(t)) e(n);
+					Object.freeze(t);
+				}
+			};
+			e(h);
+		} catch {
+			return c.fail(new e({ detail: "Invalid World resolution intention or origin" }));
+		}
+		return m(() => c.gen(function* () {
+			yield* m(() => w(h, b));
+			let e = yield* m(() => C({
+				tenantId: g,
+				entityId: h.entityId
+			}));
+			e || l(), f(e, [
+				"tenantId",
+				"entityId",
+				"subject",
+				"kind",
+				"worldId",
+				"zoneId",
+				"cellId",
+				"layer",
+				"roomId",
+				"epoch",
+				"revision",
+				"data",
+				"updatedAt",
+				...Object.hasOwn(e, "returnAnchor") ? ["returnAnchor"] : []
+			]), (e.tenantId !== g || e.entityId !== h.entityId || e.roomId !== b.roomId) && l(), e.subject !== null && f(e.subject, ["id", "kind"]);
+			let i;
+			if (Object.hasOwn(e, "returnAnchor")) {
+				let t = s(e.returnAnchor, y);
+				(t.source.worldId !== e.worldId || t.instanceRoomId !== e.roomId || t.enteredRevision > e.revision || !O(e.worldId).instances.some((e) => e.id === t.instance)) && l(), i = t;
+			}
+			(h.target.kind === "return" ? !i : i !== void 0) && l();
+			let a = Object.freeze({
+				tenantId: g,
+				entityId: h.entityId,
+				...i ? { returnAnchor: i } : {},
+				subject: e.subject === null ? null : Object.freeze({
+					id: u(e.subject.id),
+					kind: e.subject.kind
+				}),
+				kind: u(e.kind, 120),
+				worldId: u(e.worldId, 120),
+				zoneId: u(e.zoneId, 120),
+				cellId: u(e.cellId),
+				layer: d(e.layer),
+				roomId: u(e.roomId),
+				epoch: d(e.epoch),
+				revision: d(e.revision),
+				data: t(e.data, _),
+				updatedAt: e.updatedAt
+			});
+			(!Number.isSafeInteger(a.updatedAt) || a.updatedAt < 0 || a.subject && a.subject.kind !== "user" && a.subject.kind !== "guest") && l();
+			let c = A(yield* m(() => T(a, b))), p = O(c.location.worldId), x = o(p, {
+				zone: c.location.zoneId,
+				at: c.location.at
+			});
+			(a.worldId !== c.location.worldId || a.zoneId !== c.location.zoneId || a.cellId !== x.id || a.layer !== c.location.layer || a.roomId !== c.location.roomId || a.epoch !== c.location.epoch) && l(), S({
+				tenantId: g,
+				entityId: a.entityId,
+				expectedRevision: a.revision,
+				source: c.location,
+				data: c.data
+			});
+			let k = Object.freeze({
+				origin: b,
+				intent: h,
+				entity: a,
+				current: c
+			}), j = A(yield* m(() => E(k))), M = h.target, N = j.location;
+			(N.roomId === c.location.roomId || M.kind !== "world" && N.worldId !== c.location.worldId) && l(), M.kind !== "cell" && M.kind !== "zone" || N.zoneId === M.zone && N.at[0] === M.at[0] && N.at[1] === M.at[1] && N.layer === c.location.layer || l(), M.kind === "layer" && (N.layer !== M.layer || N.zoneId !== c.location.zoneId) && l(), M.kind === "world" && N.worldId !== M.world && l(), M.kind === "instance" && !p.instances.some((e) => e.id === M.instance) && l(), M.kind !== "return" || i && N.worldId === i.source.worldId && N.zoneId === i.source.zoneId && N.layer === i.source.layer && N.at[0] === i.source.at[0] && N.at[1] === i.source.at[1] || l();
+			let P = O(N.worldId), F = r({
+				kind: M.kind,
+				sourceWorld: p,
+				targetWorld: P,
+				source: {
+					world: p.name,
+					pool: p.hosts?.pool ?? v,
+					zone: c.location.zoneId,
+					at: c.location.at,
+					layer: c.location.layer,
+					instance: i?.instance ?? null
+				},
+				target: {
+					world: P.name,
+					pool: P.hosts?.pool ?? v,
+					zone: N.zoneId,
+					at: N.at,
+					layer: N.layer,
+					instance: M.kind === "instance" ? M.instance : null
+				},
+				mode: h.options.mode,
+				crossPool: h.options.crossPool,
+				recovery: !1
+			}, p.strategies.transitionPolicy), I = p === P ? j.data : n({
+				sourceWorldId: p.name,
+				targetWorldId: P.name,
+				sourceData: c.data,
+				targetData: j.data
+			}, _, p.strategies.onWorldChange);
+			S({
+				tenantId: g,
+				entityId: a.entityId,
+				expectedRevision: a.revision,
+				source: N,
+				data: I
+			});
+			let L = Object.freeze({
+				location: N,
+				data: I
+			});
+			yield* m(() => D(k, L, F)), F.mode === "recover" && l();
+			let R = {
+				tenantId: g,
+				entityId: a.entityId,
+				expectedRevision: a.revision,
+				source: c.location,
+				target: N,
+				sourceData: c.data,
+				data: I,
+				mode: F.mode,
+				origin: b,
+				intent: h,
+				...a.subject === null ? {} : { expectedSubject: a.subject }
+			};
+			return Object.freeze(R);
+		}));
+	};
+};
+export { h as makeWorldTransitionResolver };

package/dist/worldTransitionSeatGroup.js

@@ -0,0 +1,63 @@
+import { ProtocolError as e } from "./errors.js";
+import { WORLD_TRANSITIONS_TABLE as t } from "./identities.js";
+import { captureRoomReservationBatch as n } from "./reservationBatch.js";
+import { worldTransitionGroupFromRecords as r } from "./worldTransitionGroup.js";
+import { and as i, eq as a } from "@voltro/database";
+import { Effect as o } from "effect";
+// src/worldTransitionSeatGroup.ts
+function s() {
+	throw new e({ detail: "World Seat group requires complete original membership" });
+}
+var c = (e) => e.group ? `world-group:${e.group.key}` : `world:${e.id}`, l = (e, t) => !e.length || e.length > 1024 || !r(e) && e.length !== 1 ? s() : n({
+	tenantId: e[0].origin.tenantId,
+	requestId: c(e[0]),
+	seats: e.map((e) => e.subject ? {
+		roomId: e.target.roomId,
+		subjectId: e.subject.id,
+		sourceRoomId: e.origin.roomId,
+		...e.subject.kind === "guest" ? { subjectKind: "guest" } : {},
+		...t ? { worldTarget: {
+			transitionId: e.id,
+			sourceRoomId: e.origin.roomId,
+			requestId: e.origin.requestId,
+			entityId: e.entityId
+		} } : {}
+	} : s())
+}, 1024), u = (n, c, l, u) => o.tryPromise({
+	try: async () => {
+		if (!l.group) return Object.freeze([l]);
+		if (!Number.isSafeInteger(u) || u < 1 || u > 1024 || l.group.size > u) return s();
+		let e = await n.query({
+			table: t,
+			predicate: i(a("tenantId", l.origin.tenantId), a("groupKey", l.group.key)),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: u + 1,
+			skip: void 0,
+			projection: [
+				"tenantId",
+				"sourceRoomId",
+				"requestId"
+			]
+		});
+		if (e.length !== l.group.size || e.length > u) return s();
+		let d = [];
+		for (let t of e) {
+			if (t.tenantId !== l.origin.tenantId || typeof t.sourceRoomId != "string" || typeof t.requestId != "string") return s();
+			let e = c({
+				tenantId: l.origin.tenantId,
+				roomId: t.sourceRoomId,
+				requestId: t.requestId
+			});
+			if (!o.isEffect(e)) return s();
+			let n = await o.runPromise(e);
+			if (!n || n.origin.tenantId !== l.origin.tenantId || n.origin.roomId !== t.sourceRoomId || n.origin.requestId !== t.requestId) return s();
+			d.push(n);
+		}
+		return !r(d) || !d.some((e) => e.id === l.id && e.revision === l.revision) ? s() : Object.freeze(d);
+	},
+	catch: () => new e({ detail: "World Seat group observation is incomplete or changed" })
+});
+export { u as readWorldTransitionSeatGroup, l as worldTransitionSeatBatch, c as worldTransitionSeatRequestId };

package/dist/worldTransitionSeats.js

@@ -0,0 +1,259 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { ROOMS_TABLE as n } from "./identities.js";
+import { captureWorldCatalog as r, worldCellAt as i } from "./world.js";
+import { assertWorldRoomPool as a } from "./worldRoomPool.js";
+import { WORLD_CELLS_TABLE as o } from "./worldCells.js";
+import { roomReservationBatchSessionId as s } from "./reservationBatch.js";
+import { readWorldTransitionSeatGroup as c, worldTransitionSeatBatch as l } from "./worldTransitionSeatGroup.js";
+import { dataStoreWorldInstances as u } from "./worldInstances.js";
+import { assertWorldTransitionExecution as d, withWorldTransitionGroupMember as ee, worldTransitionExecutionGroup as f } from "./worldTransitionExecutor.js";
+import { assertWorldInstanceSeatAdmission as p } from "./worldInstanceAdmission.js";
+import { and as m, eq as h } from "@voltro/database";
+import { Subject as g } from "@voltro/protocol";
+import { Effect as _, Schema as v } from "effect";
+// src/worldTransitionSeats.ts
+function y() {
+	throw new e({ detail: "World target Seat authority is incomplete or changed" });
+}
+var b = (e, t) => {
+	let n = e && typeof e == "object" ? Object.getOwnPropertyDescriptor(e, t) : void 0;
+	return !n || !("value" in n) || typeof n.value != "function" ? y() : n.value.bind(e);
+}, x = (t) => _.suspend(() => {
+	let n = t();
+	return _.isEffect(n) ? n : _.fail(new e({ detail: "World target Seat operation requires an Effect" }));
+}).pipe(_.catchCause(() => _.fail(new e({ detail: "World target Seat operation remains incomplete" })))), S = (S, C) => {
+	for (let e of [
+		"tenantId",
+		"worlds",
+		"states",
+		"reservations",
+		"authorize"
+	]) {
+		let t = Object.getOwnPropertyDescriptor(C, e);
+		t && "value" in t || y();
+	}
+	let w = Object.getOwnPropertyDescriptor(C, "pendingAdmission");
+	(w && (!("value" in w) || w.value !== !0) || !w && "pendingAdmission" in C) && y();
+	let T = Object.getOwnPropertyDescriptor(C, "maxGroupRows");
+	(T && (!("value" in T) || !Number.isSafeInteger(T.value) || T.value < 1 || T.value > 1024) || !T && "maxGroupRows" in C) && y();
+	let E = T?.value, D = w?.value === !0, O = C.tenantId, k = r(C.worlds);
+	(typeof O != "string" || !O || O.length > 191 || !k.length) && y();
+	let A = Object.getOwnPropertyDescriptor(C, "epochNow");
+	(A && (!("value" in A) || typeof A.value != "function") || !A && ("epochNow" in C || k.some((e) => e.instances.length > 0))) && y();
+	let j = A ? b(C, "epochNow") : void 0, M = b(C.states, "observe"), N = Object.getOwnPropertyDescriptor(C.states, "withActorFollower");
+	(N && (!("value" in N) || typeof N.value != "function") || !N && "withActorFollower" in C.states) && y();
+	let P = N ? b(C.states, "withActorFollower") : void 0, F = Object.getOwnPropertyDescriptor(C.reservations, "reissueBatchMember");
+	(F && (!("value" in F) || typeof F.value != "function") || !F && "reissueBatchMember" in C.reservations) && y();
+	let I = F ? b(C.reservations, "reissueBatchMember") : void 0, L = b(C.reservations, "reserveBatch"), R = b(C.reservations, "replayBatch"), z = Object.getOwnPropertyDescriptor(C.reservations, "replayBatchMember");
+	(z && (!("value" in z) || typeof z.value != "function") || !z && "replayBatchMember" in C.reservations) && y();
+	let B = z ? b(C.reservations, "replayBatchMember") : void 0, V = b(C.reservations, "releaseBatch"), H = Object.getOwnPropertyDescriptor(C, "withdraw");
+	(H && (!("value" in H) || typeof H.value != "function") || !H && "withdraw" in C) && y();
+	let U = H ? b(C, "withdraw") : void 0, W = b(C, "authorize"), G = (e) => x(() => M(e)).pipe(_.map((t) => !t || t.group && E === void 0 || t.origin.tenantId !== O || e.tenantId !== O || t.origin.roomId !== e.roomId || t.origin.requestId !== e.requestId ? y() : t)), K = (e) => c(S, M, e, E ?? 1), q = (e, t, n) => _.gen(function* () {
+		yield* d(t, e, n);
+		let r = yield* K(e);
+		if (e.group) {
+			let i = yield* f(t, e, n);
+			if (i.length !== r.length || r.some((e) => !i.some((t) => t.id === e.id && t.entityId === e.entityId && t.revision === e.revision && t.phase === e.phase))) return y();
+		}
+		return r;
+	}), J = (e, t, n) => e.requestId !== l(t, D).requestId || e.seats.length !== t.length || t.some((t) => e.seats.filter((e) => e.subjectId === t.subject?.id && e.roomId === t.target.roomId).length !== 1) ? y() : e.seats.find((e) => e.subjectId === n.subject?.id && e.roomId === n.target.roomId) ?? y(), Y = (e, t) => {
+		if (e.intent.target.kind === "instance") return j ? {
+			identity: {
+				tenantId: O,
+				worldId: e.target.worldId,
+				instance: e.intent.target.instance,
+				groupId: e.intent.target.group
+			},
+			source: u(S, {
+				worlds: k,
+				epochNow: j,
+				maxManagedGroups: 65536,
+				authorize: () => x(() => W(t, e))
+			})
+		} : y();
+	}, X = async (e, t) => {
+		if (t.intent.target.kind !== "instance") return;
+		if (!j) return y();
+		let r = await e.query({
+			table: n,
+			predicate: m(h("id", t.target.roomId), h("tenantId", O)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r.length !== 1) return y();
+		await p(e, r[0], k, j);
+	}, Z = (t, r = "prepare") => _.tryPromise({
+		try: async () => {
+			let e = k.find((e) => e.name === t.target.worldId);
+			if (!e) return y();
+			let s = i(e, {
+				zone: t.target.zoneId,
+				at: t.target.at
+			}).id, c = await S.query({
+				table: n,
+				predicate: m(h("id", t.target.roomId), h("tenantId", O)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0
+			}), l = c[0];
+			if (c.length !== 1 || l.epoch !== t.target.epoch || l.state !== "live" || l.erasure != null || l.snapshotErasure != null) return y();
+			await a(S, e, l);
+			let u = Y(t, r);
+			if (u) {
+				let e = await _.runPromise(u.source.observe(u.identity));
+				return !e || e.state !== "live" || e.expired || e.roomId !== t.target.roomId || e.epoch !== t.target.epoch || e.hostId !== l.hostId ? y() : void 0;
+			}
+			let d = await S.query({
+				table: o,
+				predicate: m(h("tenantId", O), h("worldId", e.name), h("zoneId", t.target.zoneId), h("cellId", s), h("layer", t.target.layer)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0
+			});
+			if (d.length !== 1 || d[0].roomId !== t.target.roomId || d[0].epoch !== t.target.epoch || d[0].hostId !== l.hostId || d[0].state !== "live") return y();
+		},
+		catch: () => new e({ detail: "World target Seat lost its actual placement" })
+	}), Q = (e) => G(e.origin).pipe(_.map((t) => {
+		(t.id !== e.id || t.revision !== e.revision || t.phase !== e.phase) && y();
+	})), $ = (n, r) => {
+		try {
+			let e = t(n, 4096);
+			return x(() => r(e));
+		} catch {
+			return _.fail(new e({ detail: "Invalid World target Seat origin" }));
+		}
+	};
+	return Object.freeze({
+		follow: (t, r) => {
+			let i;
+			try {
+				i = v.decodeUnknownSync(g)(structuredClone(r)), "scopes" in i && i.scopes && Object.freeze(i.scopes), Object.freeze(i);
+			} catch {
+				return _.fail(new e({ detail: "World follow requires an authenticated Subject" }));
+			}
+			return $(t, (t) => _.gen(function* () {
+				if (!D || !P || !I || i.type !== "user" || i.tenantId !== O) return y();
+				let r = yield* G(t), a = i.kind === "guest" ? "guest" : "user";
+				if (r.phase !== "settled" || !r.groupProceed || !r.groupCommand || r.subject?.id !== i.id || r.subject.kind !== a) return y();
+				yield* x(() => W("follow", r, i));
+				let o = yield* K(r), c = l(o, !0), u = yield* _.tryPromise({
+					try: async () => {
+						let e = await S.query({
+							table: n,
+							predicate: m(h("id", r.target.roomId), h("tenantId", O)),
+							order: [],
+							take: 2,
+							skip: void 0,
+							projection: ["hostId", "epoch"]
+						}), t = e[0];
+						return e.length !== 1 || typeof t.hostId != "string" || typeof t.epoch != "number" || !Number.isSafeInteger(t.epoch) || t.epoch < r.target.epoch ? y() : {
+							hostId: t.hostId,
+							epoch: t.epoch
+						};
+					},
+					catch: () => new e({ detail: "World follower current owner is unavailable" })
+				});
+				yield* Z({
+					...r,
+					target: {
+						...r.target,
+						epoch: u.epoch
+					}
+				}, "follow");
+				let d = yield* x(() => I(c, i.id, (e) => x(() => P({
+					origin: r.origin,
+					roomId: r.target.roomId,
+					hostId: u.hostId,
+					epoch: u.epoch,
+					subjectId: i.id,
+					subjectKind: a
+				}, async (t, n) => {
+					if (n.id !== r.id || n.revision !== r.revision || n.entityId !== r.entityId) return y();
+					await X(t, n);
+					let i = await e(t);
+					return await X(t, n), i;
+				}))));
+				return d.roomId !== r.target.roomId || d.sessionId !== s(c, c.seats.findIndex((e) => e.subjectId === i.id)) ? y() : (yield* Q(r), d);
+			}));
+		},
+		prepare: (e, t) => $(e, (e) => _.gen(function* () {
+			let n = yield* G(e);
+			if (n.phase !== "reserving") return y();
+			let r = yield* q(n, t, "prepare");
+			for (let e of r) {
+				if ([
+					"requested",
+					"failed",
+					"rolledBack",
+					"committed",
+					"settled"
+				].includes(e.phase)) return y();
+				yield* x(() => W("prepare", e)), e.subject && (yield* Z(e));
+			}
+			if (!n.subject) return null;
+			let i = Y(n, "prepare");
+			if (i && r.some((e) => e.intent.target.kind !== "instance" || e.intent.target.instance !== i.identity.instance || e.intent.target.group !== i.identity.groupId || e.target.worldId !== i.identity.worldId || e.target.roomId !== n.target.roomId || e.target.epoch !== n.target.epoch)) return y();
+			let a = yield* x(() => L(l(r, D), i ? (e) => i.source.withAdmission(i.identity, async (t, r) => r.roomId !== n.target.roomId || r.epoch !== n.target.epoch ? y() : e(t)) : void 0));
+			for (let e of r) yield* Q(e), yield* Z(e);
+			return yield* q(n, t, "prepare"), J(a, r, n);
+		})),
+		reservation: (t, n) => {
+			let r;
+			try {
+				r = v.decodeUnknownSync(g)(structuredClone(n)), "scopes" in r && r.scopes && Object.freeze(r.scopes), Object.freeze(r);
+			} catch {
+				return _.fail(new e({ detail: "World target reservation requires an authenticated Subject" }));
+			}
+			return $(t, (e) => _.gen(function* () {
+				let t = yield* G(e);
+				if (r.type !== "user" || r.tenantId !== O || t.subject?.id !== r.id || t.subject.kind !== (r.kind === "guest" ? "guest" : "user") || [
+					"requested",
+					"reserving",
+					"failed",
+					"rolledBack"
+				].includes(t.phase)) return y();
+				let n = yield* K(t);
+				for (let e of n) {
+					if ([
+						"requested",
+						"reserving",
+						"failed",
+						"rolledBack"
+					].includes(e.phase)) return y();
+					yield* Z(e, "reservation");
+				}
+				yield* x(() => W("reservation", t, r));
+				let i = l(n, D);
+				if (t.group) {
+					if (!B) return y();
+					let e = yield* x(() => B(i, r.id));
+					for (let e of n) yield* Q(e), yield* Z(e, "reservation");
+					return e.roomId !== t.target.roomId || e.sessionId !== s(i, i.seats.findIndex((e) => e.subjectId === r.id)) ? y() : e;
+				}
+				let a = yield* x(() => R(i));
+				for (let e of n) yield* Q(e), yield* Z(e, "reservation");
+				return J(a, n, t);
+			}));
+		},
+		rollback: (e, t) => $(e, (e) => _.gen(function* () {
+			let n = yield* G(e);
+			if (n.phase !== "failed") return y();
+			let r = yield* q(n, t, "rollback");
+			for (let e of r) {
+				if (e.phase !== "failed") return y();
+				yield* x(() => W("rollback", e));
+			}
+			if (U) for (let e of r) n.group ? yield* ee(t, n, e, "rollback", (t) => x(() => U(e, t))) : yield* x(() => U(e, t)), yield* Q(e), yield* q(n, t, "rollback");
+			if (!n.subject) return null;
+			let i = yield* x(() => V(l(r, D)));
+			for (let e of r) yield* Q(e);
+			return yield* q(n, t, "rollback"), i;
+		}))
+	});
+};
+export { S as dataStoreWorldTransitionSeats };

package/dist/worldTransitionState.js

@@ -0,0 +1,94 @@
+import { worldTransitionPhases as e } from "./worldCommands.js";
+import { WORLD_TRANSITIONS_TABLE as t } from "./identities.js";
+import { id as n, integer as r, json as i, table as a, text as o, timestamp as s } from "@voltro/database";
+// src/worldTransitionState.ts
+var c = a(t, {
+	id: n({ prefix: "wtran" }),
+	tenantId: o().maxLength(191),
+	entityId: o().maxLength(191),
+	subjectId: o().maxLength(191).nullable(),
+	subjectKind: o().maxLength(8).nullable(),
+	sourceRoomId: o().maxLength(191),
+	sourceWorldId: o().maxLength(120),
+	targetWorldId: o().maxLength(120),
+	requestId: o().maxLength(384),
+	requestKey: o().maxLength(64),
+	requestDigest: o().maxLength(64),
+	groupKey: o().maxLength(64).nullable(),
+	groupReceipt: i().nullable(),
+	groupCommandKey: o().maxLength(64).nullable(),
+	groupCommandReceipt: i().nullable(),
+	groupProceedReceipt: i().nullable(),
+	groupDriveAcknowledgedAt: s().nullable(),
+	readySession: i().nullable(),
+	readyAt: s().nullable(),
+	actorSnapshot: i().nullable(),
+	actorSnapshotRevision: r().nullable(),
+	actorFinalSnapshot: i().nullable(),
+	actorDepartureRevision: r().nullable(),
+	mode: o().maxLength(8),
+	phase: o().maxLength(16),
+	revision: r(),
+	requestedRevision: r(),
+	entityRevision: r(),
+	intent: i(),
+	source: i(),
+	target: i(),
+	sourceData: i(),
+	data: i(),
+	result: i().nullable(),
+	failure: o().maxLength(120).nullable(),
+	createdAt: s(),
+	updatedAt: s(),
+	committedAt: s().nullable()
+}).unique("byWorldTransitionRequest", ["requestKey"]).index([
+	"tenantId",
+	"entityId",
+	"createdAt"
+]).index([
+	"tenantId",
+	"subjectId",
+	"subjectKind"
+]).index([
+	"tenantId",
+	"sourceWorldId",
+	"id"
+]).index([
+	"tenantId",
+	"targetWorldId",
+	"id"
+]).index("_voltro_world_transitions_source_idx", [
+	"tenantId",
+	"sourceRoomId",
+	"sourceWorldId",
+	"phase",
+	"id"
+]).index(["tenantId", "groupKey"]).index(["tenantId", "groupCommandKey"]).index("_voltro_world_transitions_group_drive_idx", [
+	"tenantId",
+	"groupDriveAcknowledgedAt",
+	"groupCommandKey"
+]).index("_voltro_world_transitions_pending_groups_idx", [
+	"groupDriveAcknowledgedAt",
+	"groupCommandKey",
+	"id"
+]), l = (e, t) => {
+	switch (t) {
+		case "requested": return "reserving";
+		case "reserving": return "prepared";
+		case "prepared": return e === "seamless" ? "ghosting" : "persisting";
+		case "ghosting": return "switching";
+		case "persisting": return "detaching";
+		case "detaching": return "switching";
+		case "switching": return "committed";
+		case "committed": return "settled";
+		case "failed": return "rolledBack";
+		case "settled":
+		case "rolledBack": return null;
+	}
+}, u = (e, t, n) => l(e, t) === n || n === "failed" && ![
+	"committed",
+	"settled",
+	"failed",
+	"rolledBack"
+].includes(t);
+export { t as WORLD_TRANSITIONS_TABLE, u as canAdvanceWorldTransition, l as nextWorldTransitionPhase, e as worldTransitionPhases, c as worldTransitionsTable };