@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldTransitionExecutor.js

@@ -0,0 +1,518 @@
+import { ProtocolError as e } from "./errors.js";
+import { worldTransitionRequest as t } from "./worldCommands.js";
+import { nextWorldTransitionPhase as n } from "./worldTransitionState.js";
+import { worldTransitionGroupFromRecords as r } from "./worldTransitionGroup.js";
+import { isVerifiedWorldTransitionLease as i, worldTransitionLeaseToken as a } from "./worldLeases.js";
+import { Effect as o, Option as s } from "effect";
+// src/worldTransitionExecutor.ts
+var c = /* @__PURE__ */ new WeakMap(), l = (t, n, r) => o.suspend(() => {
+	let i = t, a = i && typeof i == "object" ? c.get(i) : void 0;
+	return !a?.active || i.tenantId !== n.origin.tenantId || i.entityId !== n.entityId || i.transitionId !== n.id || i.revision !== n.revision || i.operation !== r ? o.fail(new e({ detail: "World actor operation requires its active leased executor callback" })) : a.renew().pipe(o.flatMap(() => a.active ? o.void : o.fail(new e({ detail: "World executor callback authority expired" }))));
+}), u = (t, n, i) => l(t, n, i).pipe(o.flatMap(() => o.suspend(() => {
+	let i = c.get(t), a = i?.members;
+	return !i?.active || !a || !r(a) || !a.some((e) => e.id === n.id && e.revision === n.revision) ? o.fail(new e({ detail: "World operation requires every original group lease" })) : o.succeed(a);
+}))), d = (t, n, r, i, a) => u(t, n, i).pipe(o.flatMap((n) => o.suspend(() => {
+	let s = c.get(t);
+	if (!s?.active || !n.some((e) => e.id === r.id && e.entityId === r.entityId && e.origin.tenantId === r.origin.tenantId && e.revision === r.revision)) return o.fail(new e({ detail: "World group callback cannot acquire another member scope" }));
+	let l = Object.freeze({
+		tenantId: r.origin.tenantId,
+		entityId: r.entityId,
+		transitionId: r.id,
+		revision: r.revision,
+		operation: i
+	}), u = {
+		active: !0,
+		members: n,
+		...s.tokens ? { tokens: s.tokens } : {},
+		renew: () => s.active ? s.renew().pipe(o.flatMap(() => s.active ? o.void : o.fail(new e({ detail: "World parent group callback expired" })))) : o.fail(new e({ detail: "World parent group callback expired" }))
+	};
+	return c.set(l, u), o.suspend(() => {
+		let t = a(l);
+		return o.isEffect(t) ? t : o.fail(new e({ detail: "World member callback requires an Effect" }));
+	}).pipe(o.ensuring(o.sync(() => {
+		u.active = !1, c.delete(l);
+	})));
+}))), f = (e) => {
+	let t = e, n = t && typeof t == "object" ? c.get(t) : void 0;
+	return n?.active ? n.tokens?.get(t.entityId) : void 0;
+}, p = (t) => {
+	let n = t, r = n && typeof n == "object" ? c.get(n) : void 0;
+	if (r?.active && r.members) return r.members.map((t) => {
+		let n = r.tokens?.get(t.entityId);
+		if (n === void 0) throw new e({ detail: "A remote World group step needs every member lease token" });
+		return Object.freeze({
+			record: t,
+			leaseToken: n
+		});
+	});
+}, m = Object.freeze({
+	guard: ["requested"],
+	prepare: ["reserving"],
+	ghost: ["ghosting"],
+	detach: ["detaching"],
+	switchClient: ["switching"],
+	enter: ["switching"],
+	settle: ["committed"],
+	rollback: ["failed"],
+	retire: ["settled", "rolledBack"]
+}), h = [
+	"reserving",
+	"prepared",
+	"ghosting",
+	"persisting",
+	"detaching",
+	"switching"
+], g = (t, n) => o.suspend(() => {
+	let { record: a, operation: s, lease: l, group: u } = t, d = u ?? [{
+		record: a,
+		lease: l
+	}], f = u !== void 0 && (s === "prepare" || s === "ghost" || s === "detach") ? h : m[s];
+	if (!m[s]?.includes(a.phase) || d.some((e) => !i(e.lease) || !f?.includes(e.record.phase)) || !d.some((e) => e.record.id === a.id && e.record.revision === a.revision) || u !== void 0 && !r(u.map((e) => e.record))) return o.fail(new e({ detail: "World step is not current for its transition phase" }));
+	let p = d.map((e) => e.lease.renew.bind(e.lease)), g = () => o.forEach(p, (t) => o.suspend(() => t()).pipe(o.catchCause(() => o.succeed(!1)), o.flatMap((t) => t === !0 ? o.void : o.fail(new e({ detail: "World step lost its transition lease" })))), { discard: !0 }), _ = Object.freeze({
+		tenantId: a.origin.tenantId,
+		entityId: a.entityId,
+		transitionId: a.id,
+		revision: a.revision,
+		operation: s
+	}), v = {
+		active: !0,
+		renew: g,
+		...u ? { members: Object.freeze(u.map((e) => e.record)) } : {}
+	};
+	return c.set(_, v), o.suspend(() => {
+		let t = n(_);
+		return o.isEffect(t) ? t : o.fail(new e({ detail: "World step requires an Effect" }));
+	}).pipe(o.ensuring(o.sync(() => {
+		v.active = !1, c.delete(_);
+	})));
+});
+function _() {
+	throw new e({ detail: "Invalid World transition executor admission" });
+}
+var v = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e) ? e : _(), y = (e, t) => {
+	e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype || _();
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		typeof n == "string" && t.includes(n) && r?.enumerable && "value" in r || _();
+	}
+}, b = (e, t) => {
+	y(e, [
+		"tenantId",
+		"roomId",
+		"requestId"
+	]);
+	let n = Object.freeze({
+		tenantId: v(e.tenantId),
+		roomId: v(e.roomId),
+		requestId: v(e.requestId, 384)
+	});
+	return n.tenantId !== t && _(), n;
+}, x = (e) => {
+	if (e !== void 0) return y(e, ["id", "kind"]), e.kind !== "user" && e.kind !== "guest" && _(), Object.freeze({
+		id: v(e.id),
+		kind: e.kind
+	});
+}, ee = (e) => {
+	let n = t(e), r = (e) => {
+		if (typeof e == "object" && e) {
+			for (let t of Object.values(e)) r(t);
+			Object.freeze(e);
+		}
+	};
+	return r(n), n;
+}, S = (e, t) => {
+	typeof e == "object" && e || _();
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	return n && "value" in n && typeof n.value == "function" || _(), n.value.bind(e);
+}, C = (t) => o.suspend(() => {
+	let n = t();
+	return o.isEffect(n) ? n : o.fail(new e({ detail: "World transition provider requires an Effect" }));
+}).pipe(o.catchCause(() => o.fail(new e({ detail: "World transition execution remains incomplete" })))), w = (t) => {
+	y(t, [
+		"tenantId",
+		"maxPhaseSteps",
+		"states",
+		"leases",
+		"authorize",
+		"resolve",
+		"guard",
+		"prepare",
+		"ghost",
+		"detach",
+		"switchClient",
+		"enter",
+		"settle",
+		"rollback",
+		"retire",
+		"authorizeTogether",
+		"maxTogetherRows"
+	]);
+	let i = v(t.tenantId), l = t.maxPhaseSteps;
+	(!Number.isSafeInteger(l) || l < 1 || l > 1024) && _();
+	let u = Object.getOwnPropertyDescriptor(t.leases, "tenantId");
+	u && "value" in u && u.value === i || _();
+	let d = S(t.states, "begin"), f = S(t.states, "advance"), p = S(t.states, "observe"), m = S(t.leases, "acquire"), h = S(t, "resolve"), g = S(t, "authorize"), w = (e, t) => C(() => g(e, Object.freeze(t))), T = Object.freeze(Object.fromEntries([
+		"guard",
+		"prepare",
+		"ghost",
+		"detach",
+		"switchClient",
+		"enter",
+		"settle",
+		"rollback"
+	].map((e) => [e, S(t, e)]))), E = (e, t, n, r, i, a) => o.suspend(() => {
+		let s = Object.freeze({
+			tenantId: n.origin.tenantId,
+			entityId: n.entityId,
+			transitionId: n.id,
+			revision: n.revision,
+			operation: t
+		}), l = {
+			active: !0,
+			renew: r,
+			...i ? { members: Object.freeze([...i]) } : {},
+			...a ? { tokens: a } : {}
+		};
+		return c.set(s, l), C(() => e(n, s)).pipe(o.ensuring(o.sync(() => {
+			l.active = !1, c.delete(s);
+		})));
+	}), D = (e, t, n, r, i) => E(T[e], e, t, n, r, i), O = (e) => {
+		let t = e.flatMap(([e, t]) => {
+			let n = a(t);
+			return n === void 0 ? [] : [[e, n]];
+		});
+		return t.length ? new Map(t) : void 0;
+	}, k = Object.getOwnPropertyDescriptor(t, "retire") === void 0 ? void 0 : S(t, "retire"), A = (e, t, n) => o.gen(function* () {
+		return e.phase !== "settled" && e.phase !== "rolledBack" && _(), k && (yield* t(), yield* E(k, "retire", e, t, void 0, n), yield* t()), e;
+	}), j = (t) => C(() => t.renew()).pipe(o.flatMap((t) => t === !0 ? o.void : o.fail(new e({ detail: "World transition lost its temporary lease" })))), M = (t, n) => o.uninterruptible(o.gen(function* () {
+		let r = yield* C(() => m(t));
+		if (s.isNone(r)) return yield* o.fail(new e({ detail: "World transition is already in progress" }));
+		let i = r.value;
+		return yield* n(i).pipe(o.ensuring(C(() => i.release()).pipe(o.orDie)));
+	})).pipe(o.catchDefect(() => o.fail(new e({ detail: "World transition execution remains incomplete" })))), N = (t, r, i) => C(() => o.gen(function* () {
+		if (t.group && i !== "switching" && !["committed", "settled"].includes(t.phase)) return yield* o.fail(new e({ detail: "Grouped World transition requires its complete coordinating operation" }));
+		let a = t, s = O([[t.entityId, r]]), c = (e) => j(r).pipe(o.flatMap(() => C(() => f({
+			origin: a.origin,
+			expectedRevision: a.revision,
+			phase: e
+		}))));
+		for (let e = 0; e < l; e++) {
+			if (a.phase === "settled" || a.phase === "rolledBack") return yield* A(a, () => j(r), s);
+			if (i === "switching" && (a.phase === "switching" || a.phase === "committed")) return a;
+			switch (yield* j(r), a.phase) {
+				case "requested":
+					yield* D("guard", a, () => j(r), void 0, s);
+					break;
+				case "reserving":
+					yield* D("prepare", a, () => j(r), void 0, s);
+					break;
+				case "ghosting":
+					yield* D("ghost", a, () => j(r), void 0, s);
+					break;
+				case "detaching":
+					yield* D("detach", a, () => j(r), void 0, s);
+					break;
+				case "switching":
+					yield* D("switchClient", a, () => j(r), void 0, s), yield* j(r), yield* D("enter", a, () => j(r), void 0, s);
+					break;
+				case "committed":
+					yield* D("settle", a, () => j(r), void 0, s);
+					break;
+				case "failed": yield* D("rollback", a, () => j(r), void 0, s);
+			}
+			let e = n(a.mode, a.phase);
+			if (e === null) return a;
+			a = yield* c(e);
+		}
+		return a.phase === "settled" || a.phase === "rolledBack" ? yield* A(a, () => j(r), s) : i === "switching" && (a.phase === "switching" || a.phase === "committed") ? a : yield* o.fail(new e({ detail: "World transition reached its phase-step budget" }));
+	})), P = (t) => C(() => p(t)).pipe(o.flatMap((t) => t === null ? o.fail(new e({ detail: "World transition request was not found" })) : o.succeed(t))), F = (t, n, r, a) => {
+		let s, c, l;
+		try {
+			l = x(a), s = ee(t), c = b(n, i);
+		} catch {
+			return o.fail(new e({ detail: "Invalid World transition command" }));
+		}
+		return w("transition", {
+			origin: c,
+			intent: s
+		}).pipe(o.flatMap(() => M(s.entityId, (e) => o.gen(function* () {
+			let t = yield* C(() => p(c)), n;
+			t === null ? (n = yield* C(() => h(s, c)), y(n, [
+				"tenantId",
+				"entityId",
+				"expectedRevision",
+				"source",
+				"target",
+				"data",
+				"sourceData",
+				"origin",
+				"mode",
+				"intent",
+				"expectedSubject"
+			]), (n.entityId !== s.entityId || n.tenantId !== i) && _(), n = {
+				...n,
+				origin: c,
+				intent: s
+			}) : n = {
+				tenantId: i,
+				entityId: t.entityId,
+				expectedRevision: t.requestedRevision,
+				source: t.source,
+				target: t.target,
+				data: t.data,
+				sourceData: t.sourceData,
+				mode: t.mode,
+				origin: c,
+				intent: s
+			}, l !== void 0 && (n = {
+				...n,
+				expectedSubject: l
+			}), yield* j(e);
+			let a = yield* C(() => d(n));
+			return yield* N(a, e, r);
+		}))));
+	}, I = (e, t) => F(e, t).pipe(o.asVoid), L = (e, t, n) => F(e, t, "switching", n), R = (t) => {
+		let n;
+		try {
+			n = b(t, i);
+		} catch {
+			return o.fail(new e({ detail: "Invalid World transition status scope" }));
+		}
+		return w("status", { origin: n }).pipe(o.flatMap(() => P(n)));
+	}, z = (t) => {
+		let n;
+		try {
+			n = b(t, i);
+		} catch {
+			return o.fail(new e({ detail: "Invalid World transition resume scope" }));
+		}
+		return w("resume", { origin: n }).pipe(o.flatMap(() => P(n)), o.flatMap((e) => M(e.entityId, (t) => P(e.origin).pipe(o.flatMap((e) => N(e, t))))));
+	}, B = (t, n, r) => {
+		let a, s, c;
+		try {
+			c = x(r), a = b(t, i), s = v(n, 120);
+		} catch {
+			return o.fail(new e({ detail: "Invalid World transition cancellation" }));
+		}
+		return w("cancel", {
+			origin: a,
+			reason: s
+		}).pipe(o.flatMap(() => P(a)), o.flatMap((t) => M(t.entityId, (t) => o.gen(function* () {
+			let n = yield* P(a);
+			return n.group ? yield* o.fail(new e({ detail: "Grouped World transition forbids individual cancellation" })) : c && (n.subject?.id !== c.id || n.subject?.kind !== c.kind) ? yield* o.fail(new e({ detail: "World cancellation belongs to another Subject" })) : n.phase === "committed" || n.phase === "settled" ? yield* o.fail(new e({ detail: "Committed World transition cannot roll back" })) : (n.phase !== "failed" && n.phase !== "rolledBack" && (yield* j(t), n = yield* C(() => f({
+				origin: a,
+				expectedRevision: n.revision,
+				phase: "failed",
+				failure: s
+			}))), yield* N(n, t));
+		}))));
+	}, te = (t, n) => {
+		let r, a;
+		try {
+			a = x(n), r = b(t, i);
+		} catch {
+			return o.fail(new e({ detail: "Invalid World client commit scope" }));
+		}
+		return w("resume", { origin: r }).pipe(o.flatMap(() => P(r)), o.flatMap((t) => M(t.entityId, (t) => P(r).pipe(o.flatMap((n) => a && (n.subject?.id !== a.id || n.subject?.kind !== a.kind) ? o.fail(new e({ detail: "World client commit belongs to another Subject" })) : n.phase === "switching" || n.phase === "committed" || n.phase === "settled" ? N(n, t) : o.fail(new e({ detail: "World client commit requires a prepared switching request" })))))));
+	}, V = Object.getOwnPropertyDescriptor(t.states, "commitBatch"), H = Object.getOwnPropertyDescriptor(t.states, "batchCommitRows");
+	(V && (!("value" in V) || typeof V.value != "function") || H && !("value" in H)) && _();
+	let U = H?.value;
+	(V !== void 0 != (H !== void 0) || H && (typeof U != "number" || !Number.isSafeInteger(U) || U < 1 || U >= 2147483647)) && _();
+	let W = V === void 0 ? void 0 : S(t.states, "commitBatch"), G = Object.getOwnPropertyDescriptor(t.states, "advanceGroup");
+	G && (!("value" in G) || typeof G.value != "function") && _();
+	let K = G === void 0 ? void 0 : S(t.states, "advanceGroup"), q = Object.getOwnPropertyDescriptor(t.states, "requiresGroupReadiness"), J = Object.getOwnPropertyDescriptor(t.states, "confirmGroupReady");
+	(q && (!("value" in q) || typeof q.value != "boolean") || J && (!("value" in J) || typeof J.value != "function") || q?.value === !0 && J === void 0) && _();
+	let Y = q?.value === !0, X = J === void 0 ? void 0 : S(t.states, "confirmGroupReady"), Z = t.authorizeTogether === void 0 ? void 0 : S(t, "authorizeTogether"), Q = t.maxTogetherRows;
+	(Z === void 0 != (Q === void 0) || Q !== void 0 && (!W || typeof U != "number" || !Number.isSafeInteger(Q) || Q < 1 || Q > 1024 || Q > U)) && _();
+	let $ = (e) => {
+		(!Z || Q === void 0 || typeof U != "number" || !Array.isArray(e) || Object.getPrototypeOf(e) !== Array.prototype || !e.length || e.length > Q || e.length > U || Reflect.ownKeys(e).length !== e.length + 1) && _();
+		let t = /* @__PURE__ */ new Set(), n = [];
+		for (let r = 0; r < e.length; r++) {
+			let a = Object.getOwnPropertyDescriptor(e, String(r));
+			a?.enumerable && "value" in a || _();
+			let o = a.value;
+			y(o, ["origin", "expectedSubject"]);
+			let s = b(o.origin, i), c = x(o.expectedSubject), l = JSON.stringify(s);
+			t.has(l) && _(), t.add(l), n.push(Object.freeze({
+				origin: s,
+				...c === void 0 ? {} : { expectedSubject: c }
+			}));
+		}
+		return Object.freeze(n);
+	};
+	return Object.freeze({
+		transition: I,
+		prepare: L,
+		prepareTogether: (t) => {
+			let i;
+			try {
+				i = $(t);
+			} catch {
+				return o.fail(new e({ detail: "World group preparation requires bounded complete authority" }));
+			}
+			return C(() => o.uninterruptible(o.gen(function* () {
+				yield* C(() => Z(i));
+				for (let e of i) yield* w("resume", { origin: e.origin });
+				let t = [];
+				for (let e of i) t.push(yield* P(e.origin));
+				let a = r(t);
+				a && new Set(t.map((e) => e.entityId)).size === t.length || _();
+				let s = [...t].sort((e, t) => e.entityId < t.entityId ? -1 : 1), c = (u, d) => u < s.length ? M(s[u].entityId, (e) => c(u + 1, [...d, e])) : C(() => o.gen(function* () {
+					let c = () => o.gen(function* () {
+						for (let e of d) yield* j(e);
+					}), u = O(s.map((e, t) => [e.entityId, d[t]])), p = [];
+					for (let e = 0; e < i.length; e++) {
+						let n = i[e], r = yield* P(n.origin);
+						(r.id !== t[e].id || r.entityId !== t[e].entityId || n.expectedSubject && (r.subject?.id !== n.expectedSubject.id || r.subject?.kind !== n.expectedSubject.kind) || [
+							"failed",
+							"rolledBack",
+							"committed",
+							"settled"
+						].includes(r.phase)) && _(), p.push(r);
+					}
+					JSON.stringify(r(p)) !== JSON.stringify(a) && _();
+					for (let e = 0; e < l; e++) {
+						if (p.every((e) => e.phase === "switching")) return Object.freeze([...p]);
+						for (let e = 0; e < p.length; e++) {
+							let t = p[e];
+							if (t.phase === "switching" || t.phase !== "requested" && p.some((e) => e.phase === "requested")) continue;
+							let i = t.phase === "requested" ? "guard" : t.phase === "reserving" ? "prepare" : t.phase === "ghosting" ? "ghost" : t.phase === "detaching" ? "detach" : void 0;
+							yield* c(), i && (yield* D(i, t, c, p, u)), yield* c();
+							let o = n(t.mode, t.phase);
+							o && o !== "committed" || _();
+							let s = yield* C(() => f({
+								origin: t.origin,
+								expectedRevision: t.revision,
+								phase: o
+							}));
+							(s.id !== t.id || s.entityId !== t.entityId || s.phase !== o || s.revision !== t.revision + 1) && _(), p[e] = s, JSON.stringify(r(p)) !== JSON.stringify(a) && _();
+						}
+					}
+					return p.every((e) => e.phase === "switching") ? Object.freeze([...p]) : yield* o.fail(new e({ detail: "World group preparation reached its phase-step budget" }));
+				}));
+				return yield* c(0, []);
+			})));
+		},
+		commit: te,
+		commitTogether: (t) => {
+			let n;
+			try {
+				W || _(), n = $(t);
+			} catch {
+				return o.fail(new e({ detail: "World common commit requires actual complete batch and group authorization providers" }));
+			}
+			return C(() => o.uninterruptible(o.gen(function* () {
+				yield* C(() => Z(n));
+				for (let e of n) yield* w("resume", { origin: e.origin });
+				let e = [];
+				for (let t of n) e.push(yield* P(t.origin));
+				new Set(e.map((e) => e.entityId)).size !== e.length && _(), r(e);
+				let t = [...e].sort((e, t) => e.entityId < t.entityId ? -1 : 1), i = (a, s) => a < t.length ? M(t[a].entityId, (e) => i(a + 1, [...s, e])) : C(() => o.gen(function* () {
+					let i = () => o.gen(function* () {
+						for (let e of s) yield* j(e);
+					}), a = O(t.map((e, t) => [e.entityId, s[t]])), c = [];
+					for (let t = 0; t < n.length; t++) {
+						let r = n[t], i = yield* P(r.origin);
+						(i.id !== e[t].id || i.entityId !== e[t].entityId || r.expectedSubject && (i.subject?.id !== r.expectedSubject.id || i.subject?.kind !== r.expectedSubject.kind)) && _(), [
+							"switching",
+							"committed",
+							"settled"
+						].includes(i.phase) || _(), c.push(i);
+					}
+					let l = r(c), u = c.every((e) => e.phase === "switching"), d = c.every((e) => e.phase === "committed" || e.phase === "settled");
+					if (!u && !d && _(), u && (l !== void 0 && Y || c.some((e) => e.group?.requiresReadiness || e.ready !== void 0)) && (X || _(), yield* i(), yield* C(() => X(c.map((e) => e.origin)))), u) for (let e of c) yield* i(), yield* D("switchClient", e, i, c, a), yield* i(), yield* D("enter", e, i, c, a);
+					yield* i();
+					let p = yield* C(() => W(c.map((e) => ({
+						origin: e.origin,
+						expectedRevision: e.revision - (e.phase === "settled" ? 2 : +(e.phase === "committed"))
+					}))));
+					p.length !== n.length && _();
+					let m = [];
+					for (let e = 0; e < p.length; e++) {
+						let t = p[e];
+						(t.id !== c[e].id || t.phase !== "committed" && t.phase !== "settled" || t.result === null) && _(), t.phase === "committed" && (yield* i(), yield* D("settle", t, i, void 0, a), yield* i(), t = yield* C(() => f({
+							origin: t.origin,
+							expectedRevision: t.revision,
+							phase: "settled"
+						}))), m.push(t);
+					}
+					for (let e of m) yield* A(e, i, a);
+					return Object.freeze(m);
+				}));
+				return yield* i(0, []);
+			})));
+		},
+		cancelTogether: (t, n) => {
+			let i, a;
+			try {
+				K || _(), i = $(t), a = v(n, 120);
+			} catch {
+				return o.fail(new e({ detail: "World group cancellation requires actual complete source and authority providers" }));
+			}
+			return C(() => o.uninterruptible(o.gen(function* () {
+				yield* C(() => Z(i));
+				for (let e of i) yield* w("cancel", {
+					origin: e.origin,
+					reason: a
+				});
+				let e = [];
+				for (let t of i) e.push(yield* P(t.origin));
+				(r(e) === void 0 || new Set(e.map((e) => e.entityId)).size !== e.length) && _();
+				let t = [...e].sort((e, t) => e.entityId < t.entityId ? -1 : 1), n = (s, c) => s < t.length ? M(t[s].entityId, (e) => n(s + 1, [...c, e])) : C(() => o.gen(function* () {
+					let n = () => o.gen(function* () {
+						for (let e of c) yield* j(e);
+					}), s = O(t.map((e, t) => [e.entityId, c[t]])), l = [];
+					for (let t = 0; t < i.length; t++) {
+						let n = i[t], r = yield* P(n.origin);
+						(r.id !== e[t].id || r.entityId !== e[t].entityId || n.expectedSubject && (r.subject?.id !== n.expectedSubject.id || r.subject?.kind !== n.expectedSubject.kind) || r.phase === "committed" || r.phase === "settled") && _(), l.push(r);
+					}
+					r(l) === void 0 && _();
+					let u = (t) => C(() => o.gen(function* () {
+						let i = l.map((e) => ({
+							origin: e.origin,
+							expectedRevision: e.revision - t
+						})), o = yield* C(() => K({
+							phase: "rolledBack",
+							members: i
+						}));
+						(o.length !== l.length || o.some((e, t) => e.id !== l[t].id || e.entityId !== l[t].entityId || e.phase !== "rolledBack" || e.failure !== a || e.revision !== i[t].expectedRevision + 1) || JSON.stringify(r(o)) !== JSON.stringify(r(e))) && _();
+						for (let e of o) yield* A(e, n, s);
+						return o;
+					}));
+					if (l.every((e) => e.phase === "rolledBack" && e.failure === a)) return yield* n(), yield* u(1);
+					(l.some((e) => e.phase === "rolledBack") || l.some((e) => e.phase === "failed" && e.failure !== a) || l.some((e) => e.phase === "failed") && !l.every((e) => e.phase === "failed")) && _(), l.every((e) => e.phase === "failed") || (yield* n(), l = [...yield* C(() => K({
+						phase: "failed",
+						failure: a,
+						members: l.map((e) => ({
+							origin: e.origin,
+							expectedRevision: e.revision
+						}))
+					}))]), (l.length !== i.length || l.some((t, n) => t.id !== e[n].id || t.phase !== "failed" || t.failure !== a)) && _(), JSON.stringify(r(l)) !== JSON.stringify(r(e)) && _();
+					for (let e of l) yield* n(), yield* D("rollback", e, n, l, s);
+					return yield* n(), yield* u(0);
+				}));
+				return yield* n(0, []);
+			})));
+		},
+		resume: z,
+		cancel: B,
+		status: R
+	});
+}, T = (e, n) => {
+	let r = v(e), i = S(n, "transition");
+	return Object.freeze({
+		run: Object.freeze({ [r]: (e, n) => C(() => i(t(e), n)) }),
+		publish: Object.freeze({})
+	});
+}, E = (t) => (n, r) => o.suspend(() => {
+	if (!n.length || n.some((e) => e.origin.tenantId !== n[0].origin.tenantId)) return o.fail(new e({ detail: "World recovery compensation requires one tenant" }));
+	let i = t(n[0].origin.tenantId, r);
+	if (n[0].group) return i.cancelTogether(n.map((e) => ({
+		origin: e.origin,
+		...e.subject ? { expectedSubject: e.subject } : {}
+	})), "room_owner_recovery").pipe(o.asVoid);
+	if (n.length !== 1) return o.fail(new e({ detail: "Ungrouped World recovery compensation requires one transition" }));
+	let a = n[0];
+	return i.cancel(a.origin, "room_owner_recovery", a.subject ?? void 0).pipe(o.asVoid);
+});
+export { g as admitWorldTransitionStep, l as assertWorldTransitionExecution, w as makeWorldTransitionExecutor, d as withWorldTransitionGroupMember, E as worldRecoveryTransitionCompensation, T as worldSingleTransitionCommandBindings, u as worldTransitionExecutionGroup, p as worldTransitionExecutionGroupTokens, f as worldTransitionExecutionLeaseToken };

package/dist/worldTransitionGroup.js

@@ -0,0 +1,112 @@
+import { ProtocolError as e } from "./errors.js";
+import { createHash as t } from "node:crypto";
+// src/worldTransitionGroup.ts
+function n() {
+	throw new e({ detail: "World transition group receipt or membership is invalid" });
+}
+var r = (e, t) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== t.length) return n();
+	let r = Object.getOwnPropertyDescriptors(e);
+	return t.some((e) => !r[e] || !Object.hasOwn(r[e], "value")) ? n() : Object.fromEntries(t.map((e) => [e, r[e].value]));
+}, i = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e) ? e : n(), a = (e) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 && e < 2147483647 ? e : n(), o = (e) => t("sha256").update(JSON.stringify(e)).digest("hex"), s = (e) => JSON.stringify([
+	e.tenantId,
+	e.roomId,
+	e.requestId
+]), c = (e, t) => {
+	let o = r(e, [
+		"tenantId",
+		"requestId",
+		"members"
+	]), c = i(o.tenantId), l = i(o.requestId, 384), u = o.members;
+	if (!Array.isArray(u) || !Number.isSafeInteger(t) || t < 1 || u.length < 1 || u.length > t || Reflect.ownKeys(u).length !== u.length + 1) return n();
+	let d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), p = [];
+	for (let e = 0; e < u.length; e++) {
+		let t = Object.getOwnPropertyDescriptor(u, e);
+		if (!t || !Object.hasOwn(t, "value")) return n();
+		let o = r(t.value, [
+			"origin",
+			"expectedRevision",
+			"subject"
+		]), l = r(o.origin, [
+			"tenantId",
+			"roomId",
+			"requestId"
+		]), m = Object.freeze({
+			tenantId: i(l.tenantId),
+			roomId: i(l.roomId),
+			requestId: i(l.requestId, 384)
+		}), h = r(o.subject, ["id", "kind"]);
+		if (h.kind !== "guest" && h.kind !== "user") return n();
+		let g = Object.freeze({
+			id: i(h.id),
+			kind: h.kind
+		});
+		if (m.tenantId !== c || d.has(s(m)) || f.has(g.id)) return n();
+		d.add(s(m)), f.add(g.id), p.push(Object.freeze({
+			origin: m,
+			expectedRevision: a(o.expectedRevision),
+			subject: g
+		}));
+	}
+	return p.sort((e, t) => s(e.origin) < s(t.origin) ? -1 : 1), Object.freeze({
+		tenantId: c,
+		requestId: l,
+		members: Object.freeze(p)
+	});
+}, l = (e, t = !1) => {
+	if (typeof t != "boolean") return n();
+	let r = c(e, e.members.length), i = o([
+		"world-transition-group-v1",
+		r.tenantId,
+		r.requestId,
+		r.members.map((e) => e.origin)
+	]);
+	return Object.freeze(r.members.map((e, n) => Object.freeze({
+		requiresReadiness: t,
+		key: i,
+		digest: o(r),
+		requestId: r.requestId,
+		size: r.members.length,
+		ordinal: n,
+		boundRevision: e.expectedRevision
+	})));
+}, u = (e) => {
+	let t = r(e, [
+		"requiresReadiness",
+		"key",
+		"digest",
+		"requestId",
+		"size",
+		"ordinal",
+		"boundRevision"
+	]), o = a(t.size), s = t.ordinal;
+	return typeof t.requiresReadiness != "boolean" || typeof t.key != "string" || !/^[a-f0-9]{64}$/.test(t.key) || typeof t.digest != "string" || !/^[a-f0-9]{64}$/.test(t.digest) || typeof s != "number" || !Number.isSafeInteger(s) || s < 0 || s >= o ? n() : Object.freeze({
+		requiresReadiness: t.requiresReadiness,
+		key: t.key,
+		digest: t.digest,
+		requestId: i(t.requestId, 384),
+		size: o,
+		ordinal: s,
+		boundRevision: a(t.boundRevision)
+	});
+}, d = (e) => {
+	if (!e.length) return n();
+	if (e.every((e) => e.group === void 0)) return;
+	let t = e[0].group;
+	if (!t || t.size !== e.length || e.some((e) => !e.group || e.subject === null)) return n();
+	let r = c({
+		tenantId: e[0].origin.tenantId,
+		requestId: t.requestId,
+		members: e.map((e) => ({
+			origin: e.origin,
+			expectedRevision: e.group.boundRevision,
+			subject: e.subject
+		}))
+	}, e.length), i = l(r, t.requiresReadiness);
+	for (let t of e) {
+		let e = r.members.findIndex((e) => s(e.origin) === s(t.origin)), a = u(t.group), o = i[e];
+		if (!o || t.revision <= a.boundRevision || Object.keys(o).some((e) => a[e] !== o[e])) return n();
+	}
+	return r;
+};
+export { c as captureWorldTransitionGroup, u as captureWorldTransitionGroupReceipt, d as worldTransitionGroupFromRecords, l as worldTransitionGroupReceipts };

package/dist/worldTransitionPhysicalSteps.js

@@ -0,0 +1,39 @@
+import { Effect as e } from "effect";
+// src/worldTransitionPhysicalSteps.ts
+var t = (t) => {
+	let { rooms: n, seats: r, maxBytes: i } = t, a = (e, t, r, a, o) => n.step({
+		tenantId: t.origin.tenantId,
+		roomId: e.roomId,
+		epoch: e.epoch,
+		origin: t.origin,
+		action: r,
+		maxBytes: i,
+		...o === void 0 ? {} : { receipt: o }
+	}, a);
+	return Object.freeze({
+		guard: () => e.void,
+		prepare: (t, n) => a(t.source, t, "snapshot", n).pipe(e.andThen(r.prepare(t.origin, n)), e.andThen(a(t.target, t, "preview", n))),
+		ghost: (e, t) => a(e.target, e, "ghost", t),
+		detach: (e, t) => a(e.source, e, "detach", t),
+		switchClient: (t, n) => t.mode === "seamless" ? a(t.source, t, "detach", n) : e.void,
+		enter: (e, t) => a(e.target, e, "preview", t),
+		settle: (e, t) => a(e.target, e, "commit", t),
+		rollback: (t, n) => r.rollback(t.origin, n).pipe(e.andThen(a(t.source, t, "restore", n))),
+		retire: (t, n) => e.forEach([
+			"enter",
+			"exit",
+			"ghost"
+		], (r) => e.forEach([t.source, t.target], (e) => a(e, t, "retire", n, {
+			requestId: `${t.id}:${r}`,
+			operation: r
+		}), { discard: !0 }), { discard: !0 })
+	});
+}, n = (e, t) => (n, r) => e.step({
+	tenantId: n.origin.tenantId,
+	roomId: n.target.roomId,
+	epoch: n.target.epoch,
+	origin: n.origin,
+	action: "withdraw",
+	maxBytes: t
+}, r);
+export { t as worldTransitionPhysicalSteps, n as worldTransitionSeatWithdrawal };