@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldEntities.js

@@ -0,0 +1,2979 @@
+import { WORLD_INSTANCES_TABLE as e } from "./worldInstanceState.js";
+import { BudgetExceeded as t, ProtocolError as n } from "./errors.js";
+import { captureWorldData as r } from "./worldData.js";
+import { worldBoundsShareEdge as i } from "./worldTransitions.js";
+import { worldTransitionPhases as a, worldTransitionRequest as o } from "./worldCommands.js";
+import { ROOMS_TABLE as s, ROOM_SEATS_TABLE as c, WORLD_TRANSITIONS_TABLE as l } from "./identities.js";
+import { captureWorldCatalog as u, worldCellAt as d } from "./world.js";
+import { captureWorldTargetSeatBinding as f, worldTargetSeatBindingFromReceipt as p } from "./worldSeatBinding.js";
+import { captureRoomSessionAdmissionEvidence as m } from "./sessionAdmission.js";
+import { lockRoomReservationOwners as h } from "./hostClientCapacity.js";
+import { assertWorldRoomPool as g } from "./worldRoomPool.js";
+import { WORLD_CELLS_TABLE as _ } from "./worldCells.js";
+import { canAdvanceWorldTransition as ee, worldTransitionsTable as v } from "./worldTransitionState.js";
+import { makeWorldHandoffMetrics as y } from "./worldHandoffMetrics.js";
+import { captureWorldEntityReturnAnchor as b } from "./worldReturnAnchor.js";
+import { captureWorldGroupCommand as te, captureWorldGroupCommandReceipt as ne, worldGroupCommandKey as re, worldGroupCommandRequestId as ie } from "./worldGroupCommand.js";
+import { assertRoomReservationBatchSeatReceipt as x, roomReservationBatchSessionIdentity as ae } from "./reservationBatch.js";
+import { captureWorldTransitionGroup as oe, captureWorldTransitionGroupReceipt as se, worldTransitionGroupFromRecords as S, worldTransitionGroupReceipts as ce } from "./worldTransitionGroup.js";
+import { worldTransitionSeatBatch as le, worldTransitionSeatRequestId as ue } from "./worldTransitionSeatGroup.js";
+import { captureWorldRecoveryActor as de } from "./worldRecoveryActor.js";
+import { captureWorldActorTransferSnapshot as fe } from "./worldActorTransferSnapshot.js";
+import { and as C, eq as w, generateId as pe, gt as me, id as T, inSet as he, integer as ge, json as _e, lt as ve, neq as ye, table as be, text as E, timestamp as xe } from "@voltro/database";
+import { Effect as D, Result as Se } from "effect";
+import { createHash as Ce } from "node:crypto";
+// src/worldEntities.ts
+var O = "_voltro_world_entities", k = "_voltro_world_journal", we = be(O, {
+	id: T({ prefix: "went" }),
+	tenantId: E().maxLength(191),
+	entityId: E().maxLength(191),
+	subjectId: E().maxLength(191).nullable(),
+	subjectKind: E().maxLength(8).nullable(),
+	kind: E().maxLength(120),
+	worldId: E().maxLength(120),
+	zoneId: E().maxLength(120),
+	cellId: E().maxLength(191),
+	layer: ge(),
+	roomId: E().maxLength(191),
+	epoch: ge(),
+	revision: ge(),
+	data: _e(),
+	updatedAt: xe(),
+	returnAnchor: _e().nullable(),
+	activeTransitionId: E().maxLength(191).nullable(),
+	transitionedAt: xe().nullable(),
+	transitionRecordedAt: xe().nullable()
+}).unique("byWorldEntity", ["tenantId", "entityId"]).index([
+	"tenantId",
+	"subjectId",
+	"subjectKind"
+]).index([
+	"tenantId",
+	"worldId",
+	"zoneId",
+	"cellId",
+	"layer"
+]).index(["tenantId", "roomId"]), Te = be(k, {
+	id: T({ prefix: "wjour" }),
+	tenantId: E().maxLength(191),
+	entityId: E().maxLength(191),
+	revision: ge(),
+	subjectId: E().maxLength(191).nullable(),
+	subjectKind: E().maxLength(8).nullable(),
+	operation: E().maxLength(16),
+	snapshot: _e(),
+	createdAt: xe(),
+	requestKey: E().maxLength(64).nullable(),
+	requestDigest: E().maxLength(64).nullable()
+}).unique("byWorldEntityRevision", [
+	"tenantId",
+	"entityId",
+	"revision"
+]).index([
+	"tenantId",
+	"subjectId",
+	"subjectKind"
+]).index([
+	"tenantId",
+	"entityId",
+	"createdAt"
+]).index(["requestKey"]), A = Object.freeze([we, Te]), Ee = Object.freeze([...A, v]);
+function j(e) {
+	throw new n({ detail: e });
+}
+var M = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e) ? e : j("Invalid World entity identity"), N = (e, t = 1) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= 2147483647 ? e : j("Invalid World entity integer"), P = (e, t) => {
+	e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype || j("World entity input requires plain own data");
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		typeof n == "string" && t.includes(n) && r?.enumerable && "value" in r || j("Invalid World entity field");
+	}
+}, De = (e) => Object.freeze({
+	tenantId: M(e.tenantId),
+	entityId: M(e.entityId)
+}), Oe = (e) => e === null ? null : (P(e, ["id", "kind"]), e.kind !== "user" && e.kind !== "guest" && j("Invalid World entity Subject kind"), Object.freeze({
+	id: M(e.id),
+	kind: e.kind
+})), ke = (e) => C(w("tenantId", e.tenantId), w("entityId", e.entityId)), Ae = (e) => Array.isArray(e) ? e.map(Ae) : typeof e == "object" && e ? Object.fromEntries(Object.entries(e).sort(([e], [t]) => e < t ? -1 : +(e > t)).map(([e, t]) => [e, Ae(t)])) : e, F = (e, t, n = !1) => e.query({
+	table: O,
+	predicate: ke(t),
+	order: [],
+	take: 2,
+	skip: void 0,
+	projection: void 0,
+	...n ? { lock: "update" } : {}
+}), I = (e) => D.uninterruptible(D.tryPromise({
+	try: e,
+	catch: (e) => e instanceof n || e instanceof t ? e : new n({ detail: "World entity SQL operation remains incomplete" })
+})), je = (v, T) => {
+	P(T, [
+		"worlds",
+		"epochNow",
+		"maxDataBytes",
+		"maxJournalBytes",
+		"maxPrivacyEntities",
+		"maxPrivacyJournal",
+		"maxBatchRows",
+		"authorize",
+		"quiesceSubject",
+		"transitions",
+		"reconcileRecovery"
+	]);
+	let ge = y(), _e = u(T.worlds), be = new Map(_e.map((e) => [e.name, e])), E = N(T.maxDataBytes), xe = N(T.maxJournalBytes), we = N(T.maxPrivacyEntities), Te = N(T.maxPrivacyJournal), A = N(T.maxBatchRows), Ee = T.epochNow, je = T.authorize, Me = T.quiesceSubject, Ne = T.reconcileRecovery;
+	Ne !== void 0 && typeof Ne != "function" && j("World recovery requires an actual compensation function");
+	let L = T.transitions;
+	L !== void 0 && (P(L, [
+		"maxPrivacyRows",
+		"authorize",
+		"groups"
+	]), (N(L.maxPrivacyRows) === 2147483647 || typeof L.authorize != "function") && j("World transition state requires bounded privacy and actual authorization"));
+	let Pe = L?.maxPrivacyRows, Fe = L?.authorize, R;
+	if (L?.groups !== void 0) {
+		P(L.groups, [
+			"maxRows",
+			"authorize",
+			"readiness",
+			"proceed"
+		]);
+		let e = N(L.groups.maxRows);
+		(e > A || typeof L.groups.authorize != "function") && j("World transition groups require actual bounded authority");
+		let t;
+		L.groups.readiness !== void 0 && (P(L.groups.readiness, ["confirm"]), typeof L.groups.readiness.confirm != "function" && j("World group readiness requires actual session confirmation"), t = Object.freeze({ confirm: L.groups.readiness.confirm }));
+		let n;
+		L.groups.proceed !== void 0 && (P(L.groups.proceed, ["authorize"]), typeof L.groups.proceed.authorize != "function" && j("World proceed requires explicit group authority"), n = Object.freeze({ authorize: L.groups.proceed.authorize })), R = Object.freeze({
+			maxRows: e,
+			authorize: L.groups.authorize,
+			...t === void 0 ? {} : { readiness: t },
+			...n === void 0 ? {} : { proceed: n }
+		});
+	}
+	be.size && typeof Ee == "function" && typeof je == "function" && typeof Me == "function" && we !== 2147483647 && Te !== 2147483647 && A !== 2147483647 || j("World entity store requires complete configuration and privacy coordination");
+	let z = (e) => be.get(e) ?? j("Unconfigured World entity World"), B = () => {
+		let e = Ee();
+		return (!Number.isSafeInteger(e) || e < 0 || e > 864e13) && j("Invalid World entity clock"), e;
+	}, V = (e) => {
+		P(e, [
+			"worldId",
+			"zoneId",
+			"at",
+			"layer",
+			"roomId",
+			"epoch"
+		]);
+		let t = M(e.worldId, 120), n = M(e.zoneId, 120), r = d(z(t), {
+			zone: n,
+			at: e.at
+		});
+		return Object.freeze({
+			worldId: t,
+			zoneId: n,
+			at: Object.freeze([e.at[0], e.at[1]]),
+			cellId: r.id,
+			layer: N(e.layer),
+			roomId: M(e.roomId),
+			epoch: N(e.epoch)
+		});
+	}, Ie = (e) => b(e, _e), H = (e) => {
+		let t = e.returnAnchor == null ? void 0 : Ie(e.returnAnchor);
+		t && (t.instanceRoomId !== e.roomId || t.enteredRevision > Number(e.revision) || t.source.worldId !== e.worldId) && j("World return anchor escaped its instance entity");
+		let n = e.subjectId, i = e.subjectKind, a = M(e.worldId, 120), o = z(a), s = M(e.zoneId, 120), c = M(e.cellId), l = o.zones.find((e) => e.id === s);
+		l || j("Unconfigured persisted World entity zone");
+		let u = c.split(":"), f = Number(u[1]), p = Number(u[2]);
+		(u.length !== 3 || u[0] !== s || !Number.isSafeInteger(f) || f < 0 || String(f) !== u[1] || !Number.isSafeInteger(p) || p < 0 || String(p) !== u[2]) && j("Invalid persisted World entity cell");
+		let m = l.cells?.size ?? Math.max(l.bounds[1][0] - l.bounds[0][0], l.bounds[1][1] - l.bounds[0][1]);
+		d(o, {
+			zone: s,
+			at: [l.bounds[0][0] + f * m, l.bounds[0][1] + p * m]
+		}).id !== c && j("Persisted World entity cell escaped configured geometry"), n === null != (i === null) && j("Contradictory World entity Subject");
+		let h = e.updatedAt instanceof Date ? e.updatedAt.getTime() : typeof e.updatedAt == "string" ? Date.parse(e.updatedAt) : NaN;
+		return (!Number.isSafeInteger(h) || h < 0) && j("Invalid persisted World entity time"), Object.freeze({
+			...t ? { returnAnchor: t } : {},
+			tenantId: M(e.tenantId),
+			entityId: M(e.entityId),
+			subject: n === null ? null : Oe({
+				id: M(n),
+				kind: i
+			}),
+			kind: M(e.kind, 120),
+			worldId: a,
+			zoneId: s,
+			cellId: c,
+			layer: N(e.layer),
+			roomId: M(e.roomId),
+			epoch: N(e.epoch),
+			revision: N(e.revision),
+			data: r(e.data, E),
+			updatedAt: h
+		});
+	}, Le = async (t, n, r, i = !1) => {
+		let a = z(r.worldId), o = a.zones.find((e) => e.id === r.zoneId);
+		o || j("World entity location requires a configured Room");
+		let c = await t.query({
+			table: s,
+			predicate: C(w("id", r.roomId), w("tenantId", n)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: [
+				"id",
+				"tenantId",
+				"name",
+				"hostId",
+				"epoch",
+				"state",
+				"maxClients",
+				"pool"
+			],
+			lock: "update"
+		}), l = c[0];
+		c.length === 1 && l && l.epoch === r.epoch && l.state === "live" && typeof l.hostId == "string" || j("World entity location lost current SQL Room authority"), await g(t, a, l, !0);
+		let u = a.instances.filter((e) => e.room === l.name);
+		if (u.length) {
+			a.zones.some((e) => e.room === l.name) && j("World entity Room cannot ambiguously name a zone and an instance");
+			let o = await t.query({
+				table: e,
+				predicate: C(w("tenantId", n), w("worldId", r.worldId), w("roomId", r.roomId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			}), s = o[0];
+			if (o.length === 1 && s && u.some((e) => e.id === s.instance) && s.state === "live" && s.epoch === r.epoch && s.hostId === l.hostId || j("World entity location lost current SQL instance authority"), i) {
+				let e = s.expiresAt instanceof Date ? s.expiresAt.getTime() : typeof s.expiresAt == "string" ? Date.parse(s.expiresAt) : NaN;
+				(!Number.isSafeInteger(e) || B() >= e) && j("Expired World instances refuse new entity ownership");
+			}
+			return;
+		}
+		(l.name !== o.room || o.layering && l.maxClients !== o.layering.maxPlayers) && j("World entity location differs from its configured zone Room");
+		let d = await t.query({
+			table: _,
+			predicate: C(w("tenantId", n), w("worldId", r.worldId), w("zoneId", r.zoneId), w("cellId", r.cellId), w("layer", r.layer)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: [
+				"roomId",
+				"hostId",
+				"epoch",
+				"state"
+			],
+			lock: "update"
+		}), f = d[0];
+		(d.length !== 1 || f?.roomId !== r.roomId || f.hostId !== l.hostId || f.epoch !== r.epoch || f.state !== "live") && j("World entity location lost current SQL cell authority");
+	}, U = async (e, t, n) => {
+		await h(e, n.map((e) => e.roomId), t);
+		for (let r of [...n].sort(Ve)) await Le(e, t, r);
+	}, W = (e, t) => e.worldId === t.worldId && e.zoneId === t.zoneId && e.cellId === t.cellId && e.layer === t.layer && e.roomId === t.roomId && e.epoch === t.epoch, G = (e, t, r) => D.suspend(() => {
+		let i;
+		try {
+			i = je(e, t);
+		} catch {
+			return D.fail(new n({ detail: "World entity authorization refused admission" }));
+		}
+		return D.isEffect(i) ? i.pipe(D.flatMap(r)) : D.fail(new n({ detail: "World entity authorization must return an Effect" }));
+	}), Re = async (e, t, n, i = t.worldId, a) => {
+		if (a === void 0 && !z(t.worldId).persistence.journal && !z(i).persistence.journal) return;
+		let o = r(t, xe);
+		await e.insert(k, {
+			id: pe({
+				kind: "typeid",
+				prefix: "wjour"
+			}, k),
+			tenantId: t.tenantId,
+			entityId: t.entityId,
+			revision: t.revision,
+			subjectId: t.subject?.id ?? null,
+			subjectKind: t.subject?.kind ?? null,
+			operation: n,
+			snapshot: o,
+			createdAt: new Date(t.updatedAt),
+			requestKey: a?.requestKey ?? null,
+			requestDigest: a?.requestDigest ?? null
+		});
+	}, ze = (e) => {
+		let i, a;
+		try {
+			P(e, [
+				"tenantId",
+				"entityId",
+				"subject",
+				"kind",
+				"location",
+				"data"
+			]), a = V(e.location), i = Object.freeze({
+				...De(e),
+				subject: Oe(e.subject),
+				kind: M(e.kind, 120),
+				location: a,
+				data: r(e.data, E)
+			});
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World entity creation" }));
+		}
+		return G("create", i, () => I(() => v.transactional(async (e) => {
+			await U(e, i.tenantId, [a]), await Le(e, i.tenantId, a, !0), (await F(e, i, !0)).length && j("World entity identity already exists");
+			let t = B(), n = {
+				id: pe({
+					kind: "typeid",
+					prefix: "went"
+				}, O),
+				...De(i),
+				subjectId: i.subject?.id ?? null,
+				subjectKind: i.subject?.kind ?? null,
+				kind: i.kind,
+				worldId: a.worldId,
+				zoneId: a.zoneId,
+				cellId: a.cellId,
+				layer: a.layer,
+				roomId: a.roomId,
+				epoch: a.epoch,
+				revision: 1,
+				data: i.data,
+				updatedAt: new Date(t),
+				returnAnchor: null,
+				activeTransitionId: null,
+				transitionedAt: null,
+				transitionRecordedAt: null
+			}, r = H(n);
+			return await e.insert(O, n), await Re(e, r, "create"), await Le(e, i.tenantId, a, !0), r;
+		})));
+	}, Be = (e) => {
+		let t;
+		try {
+			P(e, ["tenantId", "entityId"]), t = De(e);
+		} catch {
+			return D.fail(new n({ detail: "Invalid World entity lookup" }));
+		}
+		return G("observe", t, () => I(async () => {
+			let e = await F(v, t);
+			if (e.length > 1 && j("Ambiguous SQL World entity"), !e.length) return null;
+			let n = H(e[0]);
+			return (n.tenantId !== t.tenantId || n.entityId !== t.entityId) && j("World entity escaped its exact scope"), n;
+		}));
+	}, Ve = (e, t) => e.roomId < t.roomId ? -1 : e.roomId > t.roomId ? 1 : e.cellId < t.cellId ? -1 : +(e.cellId > t.cellId), K = (e, t) => {
+		P(t, e === "transfer" ? [
+			"tenantId",
+			"entityId",
+			"expectedRevision",
+			"source",
+			"target",
+			"data"
+		] : [
+			"tenantId",
+			"entityId",
+			"expectedRevision",
+			"source",
+			"data"
+		]);
+		let n = V(t.source), i = e === "transfer" ? V(t.target) : n, a = Object.freeze({
+			...De(t),
+			expectedRevision: N(t.expectedRevision),
+			source: n,
+			data: r(t.data, E),
+			...e === "transfer" ? { target: i } : {}
+		});
+		return Object.freeze({
+			captured: a,
+			source: n,
+			target: i
+		});
+	}, He = async (t, n, r, i, a) => {
+		let { captured: o, source: s, target: c } = r;
+		n === "transfer" && await Le(t, o.tenantId, c, !0);
+		let u = await F(t, o, !0);
+		u.length !== 1 && j("World entity write requires one durable entity");
+		let d = H(u[0]);
+		u[0].activeTransitionId !== null && u[0].activeTransitionId !== a && j("World entity is fenced by an active SQL transition"), d.tenantId === o.tenantId && d.entityId === o.entityId && d.revision === o.expectedRevision && W(d, s) && d.revision !== 2147483647 || j("World entity write lost its SQL owner or revision");
+		let f = d.returnAnchor ?? null;
+		if (n === "transfer") {
+			let n = z(c.worldId).instances.length ? await t.query({
+				table: e,
+				predicate: C(w("tenantId", o.tenantId), w("roomId", c.roomId), w("worldId", c.worldId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0
+			}) : [];
+			n.length > 1 && j("Ambiguous instance transfer owner");
+			let r = n[0];
+			if (!r && !f && a) {
+				let e = await t.query({
+					table: l,
+					predicate: C(w("tenantId", o.tenantId), w("id", a)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0
+				});
+				e.length !== 1 && j("World transfer lost its transition receipt");
+				let n = Z(e[0]).intent.target;
+				(n.kind === "return" || n.kind === "instance") && j("Instance intention lacks its actual instance or return anchor");
+			}
+			if (r || f) {
+				a && L || j("Instance entry/return requires an actual fenced transition");
+				let e = await t.query({
+					table: l,
+					predicate: C(w("tenantId", o.tenantId), w("id", a)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0
+				});
+				e.length !== 1 && j("Instance transition receipt is missing");
+				let n = Z(e[0]);
+				if ((n.mode !== "portal" || n.phase !== "switching" || n.entityId !== o.entityId || n.entityRevision !== d.revision || J(n.source) !== J(X(s)) || J(n.target) !== J(X(c))) && j("Instance anchor escaped its actual transfer"), r) {
+					let e = n.intent.target;
+					(f || e.kind !== "instance" || n.intent.options.returnTo !== "here" || r.instance !== e.instance || r.groupKey !== J([
+						"world-instance-group-v1",
+						o.tenantId,
+						c.worldId,
+						e.instance,
+						e.group
+					])) && j("Instance entry requires its original group and return intention"), f = Ie({
+						instanceId: M(r.id),
+						instance: e.instance,
+						instanceRoomId: c.roomId,
+						groupKey: r.groupKey,
+						entryTransitionId: n.id,
+						enteredRevision: d.revision + 1,
+						source: X(s)
+					});
+				} else {
+					let e = f;
+					(n.intent.target.kind !== "return" || c.worldId !== e.source.worldId || c.zoneId !== e.source.zoneId || c.layer !== e.source.layer || c.at[0] !== e.source.at[0] || c.at[1] !== e.source.at[1]) && j("World return must resolve the immutable per-entity anchor"), f = null;
+				}
+			}
+		}
+		let p = B(), m = {
+			worldId: c.worldId,
+			zoneId: c.zoneId,
+			cellId: c.cellId,
+			layer: c.layer,
+			roomId: c.roomId,
+			epoch: c.epoch,
+			revision: d.revision + 1,
+			data: o.data,
+			returnAnchor: f,
+			updatedAt: new Date(p)
+		}, h = H({
+			...u[0],
+			...m
+		});
+		return await t.updateMany("_voltro_world_entities", m, { where: C(ke(o), w("revision", d.revision), w("roomId", d.roomId), w("epoch", d.epoch)) }) !== 1 && j("World entity commit lost its SQL revision"), await Re(t, h, n, d.worldId, i), n === "transfer" && await Le(t, o.tenantId, c, !0), h;
+	}, Ue = (e, r) => {
+		let i;
+		try {
+			i = K(e, r);
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World entity write" }));
+		}
+		return G(e, i.captured, () => I(() => v.transactional(async (t) => (await U(t, i.captured.tenantId, [i.source, i.target]), He(t, e, i)))));
+	}, We = (e) => {
+		if (Array.isArray(e) && Object.getPrototypeOf(e) === Array.prototype && Reflect.ownKeys(e).length === e.length + 1 || j("World entity batch requires own entries"), e.length > A) throw new t({
+			budget: "worldEntityBatchRows",
+			limit: A
+		});
+		let n = [], r = /* @__PURE__ */ new Set();
+		for (let t = 0; t < e.length; t++) {
+			let i = Object.getOwnPropertyDescriptor(e, String(t));
+			i?.enumerable && "value" in i || j("World entity batch requires own entries");
+			let a = K("persist", i.value), o = JSON.stringify([a.captured.tenantId, a.captured.entityId]);
+			(r.has(o) || n.length && n[0].captured.tenantId !== a.captured.tenantId) && j("World entity batch requires unique entities in one tenant"), r.add(o), n.push(a);
+		}
+		return n;
+	}, Ge = (e) => {
+		let r;
+		try {
+			r = We(e);
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World entity batch" }));
+		}
+		return r.length ? D.gen(function* () {
+			for (let e of r) yield* G("persist", e.captured, () => D.void);
+			return yield* I(() => v.transactional(async (e) => {
+				await U(e, r[0].captured.tenantId, r.map((e) => e.source));
+				let t = /* @__PURE__ */ new Map();
+				for (let n of [...r].sort((e, t) => e.captured.entityId < t.captured.entityId ? -1 : +(e.captured.entityId > t.captured.entityId))) t.set(n.captured.entityId, await He(e, "persist", n));
+				return Object.freeze(r.map((e) => t.get(e.captured.entityId)));
+			}));
+		}) : D.succeed(Object.freeze([]));
+	}, Ke = (e, r, i) => {
+		let a, o;
+		try {
+			P(i, [
+				"roomId",
+				"tenantId",
+				"requestId"
+			]), a = Object.freeze({
+				roomId: M(i.roomId),
+				tenantId: M(i.tenantId),
+				requestId: M(i.requestId, 384)
+			}), r.length || j("World entity command requires a nonempty batch"), r.some((e) => e.captured.tenantId !== a.tenantId || e.source.roomId !== a.roomId) && j("World entity command escaped its actual outbox origin");
+			let t = (e) => Ce("sha256").update(JSON.stringify(Ae(e)), "utf8").digest("hex");
+			o = Object.freeze({
+				requestKey: t([
+					"world-entity-command",
+					a.tenantId,
+					a.roomId,
+					a.requestId
+				]),
+				requestDigest: t([e, r.map((e) => e.captured)])
+			});
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World entity command" }));
+		}
+		let s = async (t, n) => {
+			let i = await t.query({
+				table: k,
+				predicate: w("requestKey", o.requestKey),
+				order: [{
+					column: "entityId",
+					direction: "asc"
+				}],
+				take: A + 1,
+				skip: void 0,
+				projection: void 0,
+				...n ? { lock: "update" } : {}
+			});
+			if (!i.length) return !1;
+			i.length !== r.length && j("World entity command has incomplete protected receipts");
+			let s = new Map(r.map((e) => [e.captured.entityId, e]));
+			for (let t of i) {
+				let n = M(t.entityId), r = s.get(n);
+				r && t.tenantId === a.tenantId && t.requestDigest === o.requestDigest && t.operation === e && t.revision === r.captured.expectedRevision + 1 || j("World entity command identity or payload conflicts with its receipt"), s.delete(n);
+			}
+			return s.size && j("World entity command receipts omit accepted entities"), !0;
+		};
+		return D.gen(function* () {
+			for (let t of r) yield* G(e, t.captured, () => D.void);
+			(yield* I(() => s(v, !1))) || (yield* I(() => v.transactional(async (t) => {
+				let n = r.flatMap((e) => [e.source, e.target]).sort(Ve);
+				if (await U(t, a.tenantId, n), !await s(t, !0)) for (let n of [...r].sort((e, t) => e.captured.entityId < t.captured.entityId ? -1 : +(e.captured.entityId > t.captured.entityId))) await He(t, e, n, o);
+			})));
+		});
+	}, qe = (e, r) => {
+		try {
+			return Ke("persist", We(e), r);
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World entity persistence command" }));
+		}
+	}, Je = (e, r) => {
+		try {
+			return Ke("transfer", [K("transfer", e)], r);
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World entity transfer command" }));
+		}
+	}, q = (e) => (P(e, [
+		"tenantId",
+		"roomId",
+		"requestId"
+	]), Object.freeze({
+		tenantId: M(e.tenantId),
+		roomId: M(e.roomId),
+		requestId: M(e.requestId, 384)
+	})), J = (e) => Ce("sha256").update(JSON.stringify(Ae(e)), "utf8").digest("hex"), Y = (e) => J([
+		"world-transition",
+		e.tenantId,
+		e.roomId,
+		e.requestId
+	]), X = (e) => Object.freeze({
+		worldId: e.worldId,
+		zoneId: e.zoneId,
+		at: e.at,
+		layer: e.layer,
+		roomId: e.roomId,
+		epoch: e.epoch
+	}), Ye = (e) => {
+		let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+		return (!Number.isSafeInteger(t) || t < 0 || t > 864e13) && j("Invalid World transition SQL time"), t;
+	}, Z = (e) => {
+		let t = q({
+			tenantId: e.tenantId,
+			roomId: e.sourceRoomId,
+			requestId: e.requestId
+		}), n = V(e.source), i = V(e.target), s = e.mode, c = e.phase;
+		(s !== "portal" && s !== "seamless" || typeof c != "string" || !a.includes(c) || e.requestKey !== Y(t) || typeof e.requestDigest != "string" || !/^[a-f0-9]{64}$/.test(e.requestDigest) || n.roomId !== t.roomId || e.sourceWorldId !== n.worldId || e.targetWorldId !== i.worldId) && j("Contradictory World transition identity or phase");
+		let l = M(e.entityId), u = N(e.revision), d = N(e.entityRevision), f = N(e.requestedRevision), p = r(o(e.intent), 4096);
+		(p.entityId !== l || f > d || p.options.mode === "portal" && s !== "portal") && j("World transition intention contradicts its durable entity");
+		let h = e.subjectId === null && e.subjectKind === null ? null : Oe({
+			id: e.subjectId,
+			kind: e.subjectKind
+		}), g = Ye(e.createdAt), _ = Ye(e.updatedAt), ee = e.committedAt === null ? null : Ye(e.committedAt), v = e.failure === null ? null : M(e.failure, 120), y = e.groupReceipt == null ? void 0 : se(e.groupReceipt);
+		(e.groupKey == null != (y === void 0) || y && (e.groupKey !== y.key || u <= y.boundRevision)) && j("World transition group fence is contradictory");
+		let b = e.groupCommandReceipt == null ? void 0 : ne(e.groupCommandReceipt);
+		(e.groupCommandKey == null != (b === void 0) || b && (!y || e.groupCommandKey !== re(b) || y.requestId !== ie(b) || b.origin.tenantId !== t.tenantId || b.startedAt < g || b.startedAt > _ || J({
+			target: p.target,
+			options: p.options
+		}) !== J({
+			target: b.intent.target,
+			options: b.intent.options
+		}))) && j("World group command differs from its immutable member intention");
+		let te;
+		if (e.groupProceedReceipt != null) {
+			let t = e.groupProceedReceipt;
+			P(t, [
+				"at",
+				"revision",
+				"returnAnchor"
+			]);
+			let r = t.at, i = N(t.revision), a = X(V(t.returnAnchor));
+			(!b || b.intent.onTimeout !== "proceed" || !y?.requiresReadiness || typeof r != "number" || !Number.isSafeInteger(r) || r < b.waitUntil || r > _ || i <= y.boundRevision || i > u || J(a) !== J(X(n)) || ![
+				"switching",
+				"committed",
+				"settled",
+				"failed",
+				"rolledBack"
+			].includes(c)) && j("World proceed decision escaped its original command/member anchor"), te = Object.freeze({
+				at: r,
+				revision: i,
+				returnAnchor: a
+			});
+		}
+		let x = e.readySession == null ? void 0 : m(e.readySession), ae = e.readyAt == null ? void 0 : Ye(e.readyAt);
+		(x === void 0 != (ae === void 0) || x && (!y || x.tenantId !== t.tenantId || x.subjectId !== h?.id || x.roomId !== i.roomId || x.epoch !== i.epoch || ![
+			"switching",
+			"committed",
+			"settled",
+			"failed",
+			"rolledBack"
+		].includes(c) || ae < g || ae > _)) && j("World transition ready observation escaped its original target");
+		let oe = x === void 0 ? void 0 : Object.freeze({
+			sessionId: x.sessionId,
+			roomId: x.roomId,
+			epoch: x.epoch,
+			readyAt: ae
+		}), S = null;
+		if (e.result !== null) {
+			let n = r(e.result, xe);
+			P(n, [
+				"tenantId",
+				"entityId",
+				"subject",
+				"kind",
+				"worldId",
+				"zoneId",
+				"cellId",
+				"layer",
+				"roomId",
+				"epoch",
+				"revision",
+				"data",
+				"updatedAt",
+				"returnAnchor"
+			]);
+			let a = Oe(n.subject);
+			S = H({
+				...n,
+				subjectId: a?.id ?? null,
+				subjectKind: a?.kind ?? null,
+				updatedAt: new Date(n.updatedAt)
+			}), S.tenantId === t.tenantId && S.entityId === l && S.revision === d && W(S, i) && S.subject?.id === h?.id && S.subject?.kind === h?.kind || j("World transition commit receipt escaped its entity");
+		}
+		let ce = c === "committed" || c === "settled";
+		(_ < g || ce !== (ee !== null) || ce !== (S !== null) || (c === "failed" || c === "rolledBack") != (v !== null) || ee !== null && (ee < g || ee > _)) && j("Contradictory World transition commit boundary");
+		let le = e.actorSnapshot == null ? void 0 : fe(e.actorSnapshot, E), ue = e.actorSnapshotRevision == null ? void 0 : N(e.actorSnapshotRevision);
+		(le === void 0 != (ue === void 0) || ue !== void 0 && (ue > u || ue < 2 || c === "requested")) && j("World actor snapshot phase receipt is contradictory"), le && le.entity.id !== l && j("World actor snapshot escaped its entity");
+		let de = e.groupDriveAcknowledgedAt == null ? void 0 : Ye(e.groupDriveAcknowledgedAt);
+		de !== void 0 && (!b || !["settled", "rolledBack"].includes(c) || de < _) && j("World group driving acknowledgment contradicts its terminal command");
+		let C = e.actorDepartureRevision == null ? void 0 : N(e.actorDepartureRevision);
+		C !== void 0 && (s !== "portal" || !le || C <= ue || C > u || ![
+			"detaching",
+			"switching",
+			"committed",
+			"settled",
+			"failed",
+			"rolledBack"
+		].includes(c)) && j("World portal departure contradicts its captured source");
+		let w;
+		if (e.actorFinalSnapshot != null) {
+			let t = e.actorFinalSnapshot;
+			P(t, [
+				"snapshot",
+				"data",
+				"revision"
+			]), w = Object.freeze({
+				snapshot: fe(t.snapshot, E),
+				data: r(t.data, E),
+				revision: N(t.revision)
+			}), (!le || s !== "seamless" || n.worldId !== i.worldId || w.snapshot.entity.id !== l || w.snapshot.schemaHash !== le.schemaHash || w.revision <= ue || w.revision > u || ![
+				"switching",
+				"committed",
+				"settled",
+				"failed",
+				"rolledBack"
+			].includes(c)) && j("World final actor snapshot contradicts its handoff");
+		}
+		return Object.freeze({
+			...de === void 0 ? {} : { groupDriveAcknowledgedAt: de },
+			...C === void 0 ? {} : { actorDepartureRevision: C },
+			...te === void 0 ? {} : { groupProceed: te },
+			...b === void 0 ? {} : { groupCommand: b },
+			...w === void 0 ? {} : { actorFinalSnapshot: w },
+			...le === void 0 ? {} : {
+				actorSnapshot: le,
+				actorSnapshotRevision: ue
+			},
+			...y === void 0 ? {} : { group: y },
+			...oe === void 0 ? {} : { ready: oe },
+			id: M(e.id),
+			origin: t,
+			entityId: l,
+			subject: h,
+			mode: s,
+			phase: c,
+			revision: u,
+			entityRevision: d,
+			requestedRevision: f,
+			intent: p,
+			source: X(n),
+			target: X(i),
+			sourceData: r(e.sourceData, E),
+			data: r(e.data, E),
+			result: S,
+			failure: v,
+			createdAt: g,
+			updatedAt: _,
+			committedAt: ee
+		});
+	}, Q = (e, t, n = !1) => e.query({
+		table: l,
+		predicate: w("requestKey", Y(t)),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0,
+		...n ? { lock: "update" } : {}
+	}), Xe = async (e, n, r) => {
+		if (!n.subject || !r && !n.actorFinalSnapshot && n.actorDepartureRevision === void 0) return;
+		let i = C(w("tenantId", n.origin.tenantId), w("roomId", n.source.roomId), w("subjectId", n.subject.id), w("role", "player")), a = r ? C(i, w("epoch", n.source.epoch), he("state", [
+			"reserved",
+			"connected",
+			"grace"
+		])) : C(i, w("worldSourceTransitionId", n.id)), o = await e.query({
+			table: c,
+			predicate: a,
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: A + 1,
+			skip: void 0,
+			projection: ["id", "worldSourceTransitionId"],
+			lock: "update"
+		});
+		if (o.length > A) throw new t({
+			budget: "worldSourceSeats",
+			limit: A
+		});
+		for (let t of o) r && t.worldSourceTransitionId != null && t.worldSourceTransitionId !== n.id && j("World source Seat belongs to another departure"), await e.updateMany("_voltro_room_seats", { worldSourceTransitionId: r ? n.id : null }, { where: C(a, w("id", t.id)) }) !== 1 && j("World source Seat restriction lost its original row");
+	}, $ = (e, t, r) => D.suspend(() => {
+		if (Fe === void 0) return D.fail(new n({ detail: "World transition state is not configured" }));
+		let i;
+		try {
+			i = Fe(e, t);
+		} catch {
+			return D.fail(new n({ detail: "World transition authorization refused admission" }));
+		}
+		return D.isEffect(i) ? i.pipe(D.flatMap(r)) : D.fail(new n({ detail: "World transition authorization requires an Effect" }));
+	}), Ze = (e) => {
+		let t;
+		try {
+			t = q(e);
+		} catch {
+			return D.fail(new n({ detail: "Invalid World transition lookup" }));
+		}
+		return $("observe", t, () => I(async () => {
+			let e = await Q(v, t);
+			return e.length > 1 && j("Ambiguous SQL World transition"), e.length ? Z(e[0]) : null;
+		}));
+	}, Qe = (e, t) => D.suspend(() => {
+		if (!R || t.members.length > R.maxRows) return D.fail(new n({ detail: "World group authority is not configured for this complete set" }));
+		try {
+			let r = R.authorize(e, t);
+			return D.isEffect(r) ? r : D.fail(new n({ detail: "World group authority requires an Effect" }));
+		} catch {
+			return D.fail(new n({ detail: "World group authority refused admission" }));
+		}
+	}), $e = (e, t) => D.suspend(() => {
+		if (!R?.readiness) return D.fail(new n({ detail: "Actual World group session readiness is not configured" }));
+		try {
+			let r = R.readiness.confirm(e, t);
+			return D.isEffect(r) ? r : D.fail(new n({ detail: "World target readiness requires an actual Effect" }));
+		} catch {
+			return D.fail(new n({ detail: "Actual World target session readiness remains incomplete" }));
+		}
+	}), et = async (e, t) => {
+		let n = await D.runPromise(D.result($e(e, t)));
+		if (Se.isFailure(n)) throw n.failure;
+	}, tt = async (e, t, n, r = !1) => {
+		t.group && t.subject !== null && n.tenantId === t.origin.tenantId && n.subjectId === t.subject.id && n.roomId === t.target.roomId && n.epoch === t.target.epoch || j("World target session evidence escaped its group Subject/target");
+		let i = await e.query({
+			table: s,
+			predicate: C(w("id", n.roomId), w("tenantId", n.tenantId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: [
+				"id",
+				"tenantId",
+				"epoch",
+				"state",
+				"erasure",
+				"snapshotErasure"
+			],
+			...r ? { lock: "update" } : {}
+		});
+		(i.length !== 1 || i[0].id !== n.roomId || i[0].tenantId !== n.tenantId || i[0].epoch !== n.epoch || i[0].state !== "live" || i[0].erasure != null || i[0].snapshotErasure != null) && j("World ready target Room is no longer current");
+		let a = await e.query({
+			table: c,
+			predicate: C(w("sessionId", n.sessionId), w("tenantId", n.tenantId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: [
+				"sessionId",
+				"tenantId",
+				"subjectId",
+				"roomId",
+				"epoch",
+				"role",
+				"state",
+				"nonce",
+				"token"
+			],
+			...r ? { lock: "update" } : {}
+		}), o = a[0];
+		(a.length !== 1 || o.sessionId !== n.sessionId || o.tenantId !== n.tenantId || o.subjectId !== n.subjectId || o.roomId !== n.roomId || o.epoch !== n.epoch || o.role !== "player" || o.state !== "connected" || o.nonce !== n.nonce || o.token !== n.credentialDigest) && j("World target Seat is not the actual connected credential"), await et(t, n);
+	}, nt = async (e, t) => {
+		R && t.group || j("World ready member requires a durable complete group");
+		let n = await e.query({
+			table: l,
+			predicate: C(w("tenantId", t.origin.tenantId), w("groupKey", t.group.key)),
+			order: [],
+			take: R.maxRows + 1,
+			skip: void 0,
+			projection: [
+				"tenantId",
+				"sourceRoomId",
+				"requestId",
+				"subjectId",
+				"subjectKind",
+				"revision",
+				"groupKey",
+				"groupReceipt"
+			]
+		});
+		n.length > R.maxRows && j("World group readiness exceeds its complete set budget");
+		let r = n.map((e) => {
+			let n = se(e.groupReceipt);
+			return (e.tenantId !== t.origin.tenantId || e.groupKey !== t.group.key || n.key !== t.group.key) && j("World ready group inventory escaped its tenant/key"), {
+				origin: q({
+					tenantId: e.tenantId,
+					roomId: e.sourceRoomId,
+					requestId: e.requestId
+				}),
+				subject: Oe({
+					id: e.subjectId,
+					kind: e.subjectKind
+				}),
+				revision: N(e.revision),
+				group: n
+			};
+		});
+		return S(r) ?? j("World ready group has no complete receipt");
+	}, rt = (e) => {
+		let t;
+		try {
+			R?.readiness || j("Actual World group readiness is not configured"), P(e, [
+				"origin",
+				"expectedRevision",
+				"subject",
+				"evidence"
+			]);
+			let n = Oe(e.subject) ?? j("World ready player requires trusted Subject identity");
+			t = Object.freeze({
+				origin: q(e.origin),
+				expectedRevision: N(e.expectedRevision),
+				subject: n,
+				evidence: m(e.evidence)
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid or unconfigured World group ready intention" }));
+		}
+		return $("observe", t.origin, () => I(async () => {
+			let e = await Q(v, t.origin);
+			e.length !== 1 && j("World ready player requires one original transition");
+			let n = Z(e[0]);
+			n.group && n.subject?.id === t.subject.id && n.subject.kind === t.subject.kind && n.phase === "switching" || j("World ready intention belongs to no matching switching player");
+			let r = await nt(v, n), i = await D.runPromise(D.result(Qe("ready", r)));
+			if (Se.isFailure(i)) throw i.failure;
+			return v.transactional(async (e) => {
+				await U(e, t.origin.tenantId, [V(n.source), V(n.target)]);
+				let r = await F(e, {
+					tenantId: t.origin.tenantId,
+					entityId: n.entityId
+				}, !0), i = await Q(e, t.origin, !0);
+				(r.length !== 1 || i.length !== 1) && j("World ready intention lost its locked source");
+				let a = Z(i[0]), o = H(r[0]);
+				a.id === n.id && a.phase === "switching" && a.subject?.id === t.subject.id && a.subject.kind === t.subject.kind && a.group?.key === n.group.key && a.group?.digest === n.group.digest && r[0].activeTransitionId === a.id && o.revision === a.entityRevision && W(o, V(a.source)) || j("World ready intention lost its current source/group fence"), await tt(e, a, t.evidence, !0);
+				let s = i[0].readySession == null ? void 0 : m(i[0].readySession);
+				if (s && J(s) === J(t.evidence) && a.revision === t.expectedRevision + 1) return a;
+				(a.revision !== t.expectedRevision || a.revision >= 2147483645) && j("World ready intention lost its phase revision");
+				let c = B();
+				c < a.updatedAt && j("World ready intention clock moved backwards");
+				let l = {
+					readySession: t.evidence,
+					readyAt: new Date(c),
+					revision: a.revision + 1,
+					updatedAt: new Date(c)
+				};
+				return await e.updateMany("_voltro_world_transitions", l, { where: C(w("id", a.id), w("tenantId", t.origin.tenantId), w("phase", "switching"), w("revision", a.revision), w("groupKey", a.group.key)) }) !== 1 && j("World ready intention lost its phase CAS"), Z({
+					...i[0],
+					...l
+				});
+			});
+		}));
+	}, it = (e) => {
+		let t;
+		try {
+			(!R?.readiness || !Array.isArray(e) || !e.length || e.length > R.maxRows || Reflect.ownKeys(e).length !== e.length + 1) && j("World group readiness requires its configured complete origin list");
+			let n = [];
+			for (let t = 0; t < e.length; t++) {
+				let r = Object.getOwnPropertyDescriptor(e, t);
+				r && "value" in r || j("World group readiness requires own origins"), n.push(q(r.value));
+			}
+			new Set(n.map(Y)).size !== n.length && j("World ready group origins must be unique"), t = Object.freeze(n);
+		} catch {
+			return D.fail(new n({ detail: "Invalid or unconfigured complete World group readiness" }));
+		}
+		return D.gen(function* () {
+			for (let e of t) yield* $("observe", e, () => D.void);
+			return yield* I(async () => {
+				let e = [];
+				for (let n of t) {
+					let t = await Q(v, n);
+					t.length !== 1 && j("World readiness requires every original transition");
+					let r = Z(t[0]);
+					(r.phase !== "switching" || t[0].readySession == null && !r.groupProceed) && j("World group has not received every ready intention or deferred decision"), e.push({
+						record: r,
+						evidence: t[0].readySession == null ? void 0 : m(t[0].readySession)
+					});
+				}
+				let n = S(e.map((e) => e.record)) ?? j("World readiness requires a complete durable group"), r = await D.runPromise(D.result(Qe("commit", n)));
+				if (Se.isFailure(r)) throw r.failure;
+				let i = mt(e.map((e) => e.record));
+				if (i) {
+					let e = await D.runPromise(D.result(ht(i)));
+					if (Se.isFailure(e)) throw e.failure;
+					await gt(v, i.records, B(), !1);
+				} else for (let t of e) t.evidence || j("World group member lacks actual readiness evidence"), await tt(v, t.record, t.evidence);
+			});
+		});
+	}, at = (e) => {
+		let t;
+		try {
+			R || j("World transition groups are not configured"), t = oe(e, R.maxRows);
+		} catch {
+			return D.fail(new n({ detail: "Invalid or unconfigured World transition group" }));
+		}
+		let r = ce(t, R?.readiness !== void 0);
+		return D.gen(function* () {
+			yield* Qe("bind", t);
+			for (let e of t.members) yield* $("observe", e.origin, () => D.void);
+			return yield* I(async () => {
+				let e = async (e, n = !1) => {
+					let r = [];
+					for (let i = 0; i < t.members.length; i++) {
+						let a = t.members[i], o = await Q(e, a.origin, n);
+						o.length !== 1 && j("World group requires every original durable request");
+						let s = Z(o[0]);
+						(s.subject?.id !== a.subject.id || s.subject.kind !== a.subject.kind) && j("World group request belongs to another Subject"), r.push({
+							member: a,
+							ordinal: i,
+							row: o[0],
+							record: s
+						});
+					}
+					return new Set(r.map((e) => e.record.entityId)).size !== r.length && j("World group entities must be distinct"), r;
+				}, n = (e) => {
+					let n = S(e.map((e) => e.record));
+					return n !== void 0 && (J(n) !== J(t) && j("World group differs from its original membership receipt"), !0);
+				}, i = await e(v);
+				if (n(i)) return Object.freeze(i.map((e) => e.record));
+				let a = i[0].record.target;
+				return i.some((e) => e.record.phase !== "requested" || e.record.revision !== e.member.expectedRevision || e.record.target.worldId !== a.worldId || e.record.target.layer !== a.layer) && j("World group must bind original requested records in one target World/layer"), v.transactional(async (e) => {
+					await U(e, t.tenantId, i.flatMap((e) => [V(e.record.source), V(e.record.target)]));
+					let o = [...i].sort((e, t) => e.record.entityId < t.record.entityId ? -1 : 1), s = /* @__PURE__ */ new Map();
+					for (let n of o) {
+						let r = await F(e, {
+							tenantId: t.tenantId,
+							entityId: n.record.entityId
+						}, !0);
+						r.length !== 1 && j("World group lost its current entity"), s.set(n.record.entityId, r[0]);
+					}
+					let c = [];
+					for (let t of o) {
+						let n = await Q(e, t.member.origin, !0);
+						n.length !== 1 && j("World group lost its requested transition");
+						let r = Z(n[0]);
+						r.id !== t.record.id && j("World group transition identity changed under locks"), c.push({
+							...t,
+							row: n[0],
+							record: r
+						});
+					}
+					if (n(c)) {
+						let e = new Map(c.map((e) => [Y(e.member.origin), e.record]));
+						return Object.freeze(t.members.map((t) => e.get(Y(t.origin))));
+					}
+					let l = B();
+					for (let e of c) {
+						let n = s.get(e.record.entityId), r = H(n);
+						(e.record.phase !== "requested" || e.record.revision !== e.member.expectedRevision || e.record.revision >= 2147483640 || e.record.subject?.id !== e.member.subject.id || e.record.subject.kind !== e.member.subject.kind || r.subject?.id !== e.member.subject.id || r.subject.kind !== e.member.subject.kind || r.tenantId !== t.tenantId || n.activeTransitionId !== e.record.id || r.revision !== e.record.entityRevision || !W(r, V(e.record.source)) || e.record.target.worldId !== a.worldId || e.record.target.layer !== a.layer || l < e.record.updatedAt) && j("World group lost an original owner/Subject/phase fence");
+					}
+					let u = /* @__PURE__ */ new Map();
+					for (let n of c) {
+						let i = r[n.ordinal], a = {
+							groupKey: i.key,
+							groupReceipt: i,
+							revision: n.record.revision + 1,
+							updatedAt: new Date(l)
+						};
+						await e.updateMany("_voltro_world_transitions", a, { where: C(w("id", n.record.id), w("tenantId", t.tenantId), w("revision", n.record.revision), w("phase", "requested"), w("groupKey", null)) }) !== 1 && j("World group binding lost its phase CAS"), u.set(Y(n.member.origin), Z({
+							...n.row,
+							...a
+						}));
+					}
+					return Object.freeze(t.members.map((e) => u.get(Y(e.origin))));
+				});
+			});
+		});
+	}, ot = (e) => {
+		let t;
+		try {
+			R || j("World transition groups are not configured"), P(e, [
+				"members",
+				"phase",
+				"failure"
+			]), (!["failed", "rolledBack"].includes(e.phase) || e.phase === "failed" != (e.failure !== void 0) || !Array.isArray(e.members) || e.members.length < 1 || e.members.length > R.maxRows || Reflect.ownKeys(e.members).length !== e.members.length + 1) && j("Invalid World group cancellation");
+			let n = /* @__PURE__ */ new Set(), r = [];
+			for (let t = 0; t < e.members.length; t++) {
+				let i = Object.getOwnPropertyDescriptor(e.members, t);
+				i && "value" in i || j("World group cancellation requires own member values");
+				let a = i.value;
+				P(a, ["origin", "expectedRevision"]);
+				let o = q(a.origin), s = Y(o);
+				(n.has(s) || r.length && o.tenantId !== r[0].origin.tenantId) && j("World group cancellation requires unique one-tenant members"), n.add(s), r.push(Object.freeze({
+					origin: o,
+					expectedRevision: N(a.expectedRevision)
+				}));
+			}
+			t = Object.freeze({
+				phase: e.phase,
+				members: Object.freeze(r),
+				...e.failure === void 0 ? {} : { failure: M(e.failure, 120) }
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid or unconfigured World group cancellation" }));
+		}
+		return D.gen(function* () {
+			for (let e of t.members) yield* $("advance", {
+				...e,
+				phase: t.phase,
+				...t.failure === void 0 ? {} : { failure: t.failure }
+			}, () => D.void);
+			return yield* I(async () => {
+				let e = async (e, n = !1) => {
+					let r = [];
+					for (let i of t.members) {
+						let t = await Q(e, i.origin, n);
+						t.length !== 1 && j("World group cancellation requires every durable member"), r.push({
+							member: i,
+							row: t[0],
+							record: Z(t[0])
+						});
+					}
+					return new Set(r.map((e) => e.record.entityId)).size !== r.length && j("World group cancellation entities must be distinct"), r;
+				}, n = (e) => e.every(({ member: e, record: n }) => n.phase === t.phase && n.revision === e.expectedRevision + 1 && (t.phase !== "failed" || n.failure === t.failure) || t.phase === "failed" && n.phase === "rolledBack" && n.revision === e.expectedRevision + 2 && n.failure === t.failure), r = await e(v), i = S(r.map((e) => e.record));
+				i === void 0 && j("World cancellation requires a durable complete group fence");
+				let a = await D.runPromise(D.result(Qe(t.phase === "failed" ? "fail" : "rollback", i)));
+				if (Se.isFailure(a)) throw a.failure;
+				if (n(r)) return Object.freeze(r.map((e) => e.record));
+				let o = [], s = await v.transactional(async (e) => {
+					o = [];
+					let a = [...r].sort((e, t) => e.record.entityId < t.record.entityId ? -1 : 1), s = /* @__PURE__ */ new Map();
+					for (let t of a) {
+						let n = await F(e, {
+							tenantId: t.record.origin.tenantId,
+							entityId: t.record.entityId
+						}, !0);
+						n.length !== 1 && j("World group cancellation lost an entity"), s.set(t.record.entityId, n[0]);
+					}
+					let c = [];
+					for (let t of a) {
+						let n = await Q(e, t.member.origin, !0);
+						n.length !== 1 && j("World group cancellation lost a transition");
+						let r = Z(n[0]);
+						r.id !== t.record.id && j("World group cancellation identity changed"), c.push({
+							member: t.member,
+							row: n[0],
+							record: r
+						});
+					}
+					let l = S(c.map((e) => e.record));
+					if (J(l ?? null) !== J(i) && j("World group cancellation fence changed under locks"), n(c)) {
+						let e = new Map(c.map((e) => [Y(e.member.origin), e.record]));
+						return Object.freeze(t.members.map((t) => e.get(Y(t.origin))));
+					}
+					let u = B();
+					for (let { member: e, record: n } of c) {
+						let r = s.get(n.entityId), i = H(r);
+						(n.revision !== e.expectedRevision || n.revision > 2147483647 - (t.phase === "failed" ? 2 : 1) || t.phase === "failed" && [
+							"committed",
+							"settled",
+							"failed",
+							"rolledBack"
+						].includes(n.phase) || t.phase === "rolledBack" && n.phase !== "failed" || u < n.updatedAt || r.activeTransitionId !== n.id || i.revision !== n.entityRevision || !W(i, V(n.source)) || i.subject?.id !== n.subject?.id || i.subject?.kind !== n.subject?.kind) && j("World group cancellation lost its original source/phase fence");
+					}
+					let d = /* @__PURE__ */ new Map();
+					for (let { record: n, row: r } of c) {
+						let i = n.entityRevision, a = u;
+						if (t.phase === "rolledBack" && n.actorFinalSnapshot) {
+							let t = await He(e, "persist", K("persist", {
+								tenantId: n.origin.tenantId,
+								entityId: n.entityId,
+								expectedRevision: i,
+								source: n.source,
+								data: n.actorFinalSnapshot.data
+							}), void 0, n.id);
+							i = t.revision, a = t.updatedAt, a < u && j("World group rollback clock moved backwards");
+						}
+						t.phase === "rolledBack" && await e.updateMany("_voltro_world_entities", { activeTransitionId: null }, { where: C(ke({
+							tenantId: n.origin.tenantId,
+							entityId: n.entityId
+						}), w("activeTransitionId", n.id), w("revision", i)) }) !== 1 && j("World group rollback lost its active entity fence"), t.phase === "rolledBack" && await Xe(e, n, !1);
+						let o = {
+							phase: t.phase,
+							revision: n.revision + 1,
+							entityRevision: i,
+							failure: t.phase === "failed" ? t.failure : n.failure,
+							updatedAt: new Date(a)
+						};
+						await e.updateMany("_voltro_world_transitions", o, { where: C(w("id", n.id), w("tenantId", n.origin.tenantId), w("phase", n.phase), w("revision", n.revision)) }) !== 1 && j("World group cancellation lost its phase CAS"), d.set(Y(n.origin), Z({
+							...r,
+							...o
+						}));
+					}
+					return o = Object.freeze(t.members.map((e) => d.get(Y(e.origin)))), o;
+				});
+				for (let e of o) ge.observe(e);
+				return s;
+			});
+		});
+	}, st = (e) => {
+		let i, a, s, c;
+		try {
+			P(e, [
+				"tenantId",
+				"entityId",
+				"expectedRevision",
+				"source",
+				"target",
+				"data",
+				"sourceData",
+				"origin",
+				"mode",
+				"intent",
+				"expectedSubject"
+			]), e.mode !== "portal" && e.mode !== "seamless" && j("Invalid World transition mode"), a = K("transfer", {
+				tenantId: e.tenantId,
+				entityId: e.entityId,
+				expectedRevision: e.expectedRevision,
+				source: e.source,
+				target: e.target,
+				data: e.data
+			});
+			let t = q(e.origin);
+			(t.tenantId !== a.captured.tenantId || t.roomId !== a.source.roomId) && j("World transition escaped actual source origin"), i = Object.freeze({
+				...a.captured,
+				target: X(a.target),
+				source: X(a.source),
+				sourceData: r(e.sourceData, E),
+				origin: t,
+				mode: e.mode,
+				intent: r(o(e.intent), 4096)
+			}), (i.intent.entityId !== i.entityId || i.intent.options.mode === "portal" && i.mode !== "portal") && j("World transition intention contradicts resolved work"), s = J(i), e.expectedSubject !== void 0 && (c = Oe(e.expectedSubject) ?? j("World ownership precondition requires an actual Subject"), i = Object.freeze({
+				...i,
+				expectedSubject: c
+			}));
+		} catch (e) {
+			throw e instanceof t ? e : new n({ detail: "Invalid World transition creation" });
+		}
+		let u = async (e, t) => {
+			let n = await Q(e, i.origin, t);
+			if (!n.length) return null;
+			(n.length !== 1 || n[0].requestDigest !== s) && j("World transition request conflicts with its retained receipt");
+			let r = Z(n[0]);
+			return c && (r.subject?.id !== c.id || r.subject?.kind !== c.kind) && j("World transition receipt belongs to another Subject"), r;
+		};
+		return Object.freeze({
+			captured: i,
+			work: a,
+			replay: u,
+			insert: async (e, t) => {
+				let n = await u(e, !0);
+				if (n !== null) return n;
+				t.length !== 1 && j("World transition requires one durable source entity");
+				let r = H(t[0]), o = B();
+				c && (r.subject?.id !== c.id || r.subject?.kind !== c.kind) && j("World transition source belongs to another Subject"), (r.revision !== i.expectedRevision || !W(r, a.source) || t[0].activeTransitionId !== null || r.revision > 2147483647 - (i.mode === "portal" ? 2 : 1) || o < r.updatedAt) && j("World transition lost its source, revision budget or is already active");
+				let d = t[0].transitionedAt === null ? null : Ye(t[0].transitionedAt);
+				d !== null && (d > o || o - d < z(a.source.worldId).transitionCooldownMs) && j("World transition cooldown refused admission");
+				let f = pe({
+					kind: "typeid",
+					prefix: "wtran"
+				}, l), p = {
+					id: f,
+					tenantId: i.tenantId,
+					entityId: i.entityId,
+					subjectId: r.subject?.id ?? null,
+					subjectKind: r.subject?.kind ?? null,
+					sourceRoomId: i.origin.roomId,
+					sourceWorldId: i.source.worldId,
+					targetWorldId: i.target.worldId,
+					requestId: i.origin.requestId,
+					requestKey: Y(i.origin),
+					requestDigest: s,
+					groupKey: null,
+					groupReceipt: null,
+					groupCommandKey: null,
+					groupCommandReceipt: null,
+					groupProceedReceipt: null,
+					readySession: null,
+					readyAt: null,
+					actorSnapshot: null,
+					actorSnapshotRevision: null,
+					actorFinalSnapshot: null,
+					actorDepartureRevision: null,
+					groupDriveAcknowledgedAt: null,
+					mode: i.mode,
+					phase: "requested",
+					revision: 1,
+					requestedRevision: r.revision,
+					entityRevision: r.revision,
+					intent: i.intent,
+					source: i.source,
+					target: i.target,
+					sourceData: i.sourceData,
+					data: i.data,
+					result: null,
+					failure: null,
+					createdAt: new Date(o),
+					updatedAt: new Date(o),
+					committedAt: null
+				}, m = Z(p);
+				return await e.updateMany("_voltro_world_entities", {
+					activeTransitionId: f,
+					transitionRecordedAt: new Date(o)
+				}, { where: C(ke(i), w("revision", r.revision), w("activeTransitionId", null)) }) !== 1 && j("World transition lost its active entity fence"), await e.insert(l, p), m;
+			}
+		});
+	}, ct = (e) => {
+		let r;
+		try {
+			r = st(e);
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World transition creation" }));
+		}
+		return $("begin", r.captured, () => D.gen(function* () {
+			let e = yield* I(() => r.replay(v, !1));
+			return e === null ? yield* I(() => v.transactional(async (e) => (await U(e, r.captured.tenantId, [r.work.source]), r.insert(e, await F(e, r.captured, !0))))) : e;
+		}));
+	}, lt = async (e, t, n = !1) => {
+		R || j("World group command observation requires a group budget");
+		let r = re({ origin: t }), i = await e.query({
+			table: l,
+			predicate: C(w("tenantId", t.tenantId), w("groupCommandKey", r)),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: R.maxRows + 1,
+			skip: void 0,
+			projection: void 0,
+			...n ? { lock: "update" } : {}
+		});
+		if (!i.length) return null;
+		i.length > R.maxRows && j("World group command exceeds its complete inventory budget");
+		let a = i.map(Z), o = S(a), s = a[0].groupCommand;
+		return o && s && J(s.origin) === J(t) && !a.some((e) => !e.groupCommand || J(e.groupCommand) !== J(s)) || j("World group command receipt or membership is incomplete"), Object.freeze({
+			command: s,
+			records: Object.freeze([...a].sort((e, t) => e.group.ordinal - t.group.ordinal))
+		});
+	}, ut = (e) => {
+		let t;
+		try {
+			t = q(e);
+		} catch {
+			return D.fail(new n({ detail: "Invalid World group command origin" }));
+		}
+		return $("observe", t, () => D.gen(function* () {
+			let e = yield* I(() => lt(v, t));
+			if (e) for (let t of e.records) yield* $("observe", t.origin, () => D.void);
+			return e;
+		}));
+	}, dt = (e) => {
+		let i;
+		try {
+			P(e, [
+				"tenantId",
+				"roomId",
+				"hostId",
+				"epoch",
+				"worldId",
+				"maxRows",
+				"maxBytes"
+			]), (!Number.isSafeInteger(e.maxRows) || e.maxRows < 1 || e.maxRows > 4095 || !Number.isSafeInteger(e.maxBytes) || e.maxBytes < 1 || e.maxBytes > 16777216) && j("World source inventory requires explicit row/byte bounds"), i = Object.freeze({
+				tenantId: M(e.tenantId),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch),
+				worldId: M(e.worldId),
+				maxRows: e.maxRows,
+				maxBytes: e.maxBytes
+			}), z(i.worldId);
+		} catch {
+			return D.fail(new n({ detail: "Invalid World source transition inventory" }));
+		}
+		return $("scanSourceTransitions", i, () => D.gen(function* () {
+			let e = yield* I(() => v.transactional(async (e) => {
+				let n = await e.query({
+					table: s,
+					predicate: C(w("id", i.roomId), w("tenantId", i.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"hostId",
+						"epoch",
+						"state",
+						"erasure",
+						"snapshotErasure"
+					],
+					lock: "update"
+				});
+				(n.length !== 1 || n[0].hostId !== i.hostId || n[0].epoch !== i.epoch || n[0].state !== "live" || n[0].erasure != null || n[0].snapshotErasure != null) && j("World source inventory lost its live Room owner");
+				let a = await e.query({
+					table: l,
+					predicate: C(w("tenantId", i.tenantId), w("sourceRoomId", i.roomId), w("sourceWorldId", i.worldId), ye("phase", "settled"), ye("phase", "rolledBack")),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: i.maxRows + 1,
+					skip: void 0,
+					projection: void 0
+				});
+				if (a.length > i.maxRows) throw new t({
+					budget: "worldSourceTransitions",
+					limit: i.maxRows
+				});
+				let o = a.map((e) => Z(e));
+				return o.some((e) => e.source.epoch !== i.epoch || e.source.roomId !== i.roomId || e.source.worldId !== i.worldId) && j("World source inventory requires completed prior-epoch recovery"), r(o, i.maxBytes);
+			}));
+			for (let t of e) yield* $("observe", t.origin, () => D.void);
+			return e;
+		}));
+	}, ft = (e) => {
+		let t;
+		try {
+			P(e, [
+				"tenantId",
+				"after",
+				"limit"
+			]), (!R || !Number.isSafeInteger(e.limit) || e.limit < 1 || e.limit > A || e.after !== void 0 && !/^[a-f0-9]{64}$/.test(e.after)) && j("World command scan requires bounded tenant cursor"), t = Object.freeze({
+				tenantId: M(e.tenantId),
+				limit: e.limit,
+				...e.after === void 0 ? {} : { after: e.after }
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World group command scan" }));
+		}
+		return $("scanGroupCommands", t, () => D.gen(function* () {
+			let e = yield* I(async () => {
+				let e = await v.query({
+					table: l,
+					predicate: C(w("tenantId", t.tenantId), ye("groupCommandKey", null), w("groupDriveAcknowledgedAt", null), ...t.after === void 0 ? [] : [me("groupCommandKey", t.after)]),
+					order: [{
+						column: "groupCommandKey",
+						direction: "asc"
+					}, {
+						column: "id",
+						direction: "asc"
+					}],
+					take: t.limit + 1,
+					skip: void 0,
+					projection: void 0
+				}), n = e.slice(0, t.limit), r = [], i = /* @__PURE__ */ new Set();
+				for (let e of n) {
+					let t = Z(e).groupCommand;
+					t || j("World command scan found incomplete original metadata");
+					let n = re(t);
+					if (e.groupCommandKey !== n && j("World command scan lost its immutable key"), i.has(n)) continue;
+					i.add(n);
+					let a = await lt(v, t.origin);
+					a || j("World command scan lost complete original membership"), !a.records.every((e) => e.groupDriveAcknowledgedAt !== void 0) && (a.records.some((e) => e.groupDriveAcknowledgedAt !== void 0) && j("World group completion receipt is partial"), r.push(a));
+				}
+				let a = n.at(-1);
+				return Object.freeze({
+					groups: Object.freeze(r),
+					nextCursor: e.length > t.limit && a ? String(a.groupCommandKey) : null
+				});
+			});
+			for (let t of e.groups) for (let e of t.records) yield* $("observe", e.origin, () => D.void);
+			return e;
+		}));
+	}, pt = (e) => {
+		let t;
+		try {
+			P(e, ["origin", "members"]), (!R || !Array.isArray(e.members) || !e.members.length || e.members.length > R.maxRows) && j("World group driving acknowledgment requires complete bounded membership"), t = Object.freeze({
+				origin: q(e.origin),
+				members: Object.freeze(e.members.map((e) => (P(e, ["origin", "expectedRevision"]), Object.freeze({
+					origin: q(e.origin),
+					expectedRevision: N(e.expectedRevision)
+				}))))
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World group driving acknowledgment" }));
+		}
+		return $("acknowledgeGroupCommand", t, () => D.gen(function* () {
+			let e = yield* I(() => lt(v, t.origin));
+			if (!e) return j("World group driving acknowledgment lost its original command");
+			let n = yield* I(() => nt(v, e.records[0]));
+			return yield* Qe("completeCommand", n), yield* I(() => v.transactional(async (e) => {
+				let n = await lt(e, t.origin, !0);
+				n && n.records.length === t.members.length && new Set(t.members.map((e) => Y(e.origin))).size === t.members.length && n.records.every((e) => t.members.some((t) => Y(t.origin) === Y(e.origin) && t.expectedRevision === e.revision)) && (n.records.every((e) => e.phase === "settled") || n.records.every((e) => e.phase === "rolledBack")) || j("World group driving acknowledgment requires the exact complete terminal group");
+				let r = n.records[0].groupDriveAcknowledgedAt;
+				if (r !== void 0) return n.records.every((e) => e.groupDriveAcknowledgedAt === r) || j("World group driving acknowledgment is partial"), n;
+				n.records.some((e) => e.groupDriveAcknowledgedAt !== void 0) && j("World group driving acknowledgment is partial");
+				let i = B();
+				for (let r of n.records) i < r.updatedAt && j("World group driving acknowledgment clock regressed"), await e.updateMany("_voltro_world_transitions", { groupDriveAcknowledgedAt: new Date(i) }, { where: C(w("id", r.id), w("tenantId", t.origin.tenantId), w("revision", r.revision), w("phase", r.phase), w("groupDriveAcknowledgedAt", null)) }) !== 1 && j("World group driving acknowledgment lost its terminal CAS");
+				return await lt(e, t.origin) ?? j("World group driving acknowledgment lost its command");
+			}));
+		}));
+	}, mt = (e) => {
+		if (!e.some((e) => e.groupProceed)) return;
+		let t = S(e), n = e[0]?.groupCommand, r = e[0]?.groupProceed?.at;
+		return t && n && r !== void 0 && !e.some((e) => e.groupProceed?.at !== r || !e.groupCommand || J(e.groupCommand) !== J(n)) || j("World deferred readiness requires the complete original decision"), Object.freeze({
+			command: n,
+			records: Object.freeze([...e])
+		});
+	}, ht = (e) => D.suspend(() => {
+		if (!R?.proceed) return D.fail(new n({ detail: "World proceed policy is not explicitly configured" }));
+		try {
+			let t = R.proceed.authorize(e);
+			return D.isEffect(t) ? t : D.fail(new n({ detail: "World proceed policy requires an Effect" }));
+		} catch {
+			return D.fail(new n({ detail: "World proceed policy refused admission" }));
+		}
+	}), gt = async (e, t, n, r) => {
+		let i = le(t, !0);
+		for (let r of t) {
+			r.groupProceed && n < r.groupProceed.at && j("World proceed clock moved behind its durable decision");
+			let t = await e.query({
+				table: s,
+				predicate: C(w("tenantId", i.tenantId), w("id", r.target.roomId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: [
+					"epoch",
+					"state",
+					"erasure",
+					"snapshotErasure"
+				]
+			});
+			(t.length !== 1 || t[0].epoch !== r.target.epoch || t[0].state !== "live" || t[0].erasure != null || t[0].snapshotErasure != null) && j("World proceed target Room is no longer current");
+		}
+		for (let a = 0; a < i.seats.length; a++) {
+			let o = i.seats[a], s = t.find((e) => e.subject?.id === o.subjectId), l = ae(i.tenantId, i.requestId, a), u = await e.query({
+				table: c,
+				predicate: C(w("tenantId", i.tenantId), w("sessionId", l)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0,
+				...r ? { lock: "update" } : {}
+			});
+			u.length !== 1 && j("World proceed requires every actual capacity Seat");
+			let d = u[0];
+			x(d, i, a), (d.epoch !== s.target.epoch || d.worldSourceTransitionId != null || (d.state === "reserved" ? Ye(d.expiresAt) <= n : d.state === "grace" ? d.graceUntil == null || Ye(d.graceUntil) <= n : d.state !== "connected")) && j("World proceed lost actual current target capacity");
+		}
+	}, _t = (e) => {
+		let t;
+		try {
+			t = q(e);
+		} catch {
+			return D.fail(new n({ detail: "Invalid World proceed command origin" }));
+		}
+		let r = (e) => {
+			if (!e.records.some((e) => e.groupProceed)) return !1;
+			let t = e.records[0].groupProceed?.at;
+			return (t === void 0 || e.records.some((e) => e.groupProceed?.at !== t)) && j("World proceed decision is incomplete"), !0;
+		};
+		return $("observe", t, () => D.gen(function* () {
+			let e = yield* I(() => lt(v, t));
+			if (!e || e.command.intent.onTimeout !== "proceed" || e.records.some((e) => !e.group?.requiresReadiness)) return yield* D.fail(new n({ detail: "World command does not permit deferred group readiness" }));
+			yield* ht(e);
+			for (let t of e.records) yield* $("observe", t.origin, () => D.void);
+			return r(e) ? e : yield* I(() => v.transactional(async (n) => {
+				await U(n, t.tenantId, e.records.flatMap((e) => [V(e.source), V(e.target)]));
+				let i = [...e.records].sort((e, t) => e.entityId < t.entityId ? -1 : 1), a = /* @__PURE__ */ new Map();
+				for (let e of i) {
+					let r = await F(n, {
+						tenantId: t.tenantId,
+						entityId: e.entityId
+					}, !0);
+					r.length !== 1 && j("World proceed lost a durable source entity"), a.set(e.entityId, r[0]);
+				}
+				let o = [];
+				for (let e of i) {
+					let t = await Q(n, e.origin, !0);
+					t.length !== 1 && j("World proceed lost an original transition");
+					let r = Z(t[0]);
+					(r.id !== e.id || r.entityId !== e.entityId) && j("World proceed member identity changed"), o.push({
+						row: t[0],
+						record: r
+					});
+				}
+				let s = await lt(n, t);
+				if (s && J(s.command) === J(e.command) && J(S(s.records)) === J(S(e.records)) || j("World proceed command/group changed under locks"), r(s)) return s;
+				let c = B();
+				c < s.command.waitUntil && j("World proceed cannot waive readiness before its original deadline");
+				for (let { record: e } of o) {
+					let t = a.get(e.entityId), n = H(t);
+					(e.phase !== "switching" || e.revision >= 2147483645 || !e.actorSnapshot || c < e.updatedAt || t.activeTransitionId !== e.id || n.revision !== e.entityRevision || !W(n, V(e.source)) || n.subject?.id !== e.subject?.id || n.subject?.kind !== e.subject?.kind) && j("World proceed lost prepared source ownership");
+				}
+				await gt(n, o.map((e) => e.record), c, !0);
+				for (let { record: e } of o) {
+					let r = Object.freeze({
+						at: c,
+						revision: e.revision + 1,
+						returnAnchor: e.source
+					});
+					await n.updateMany("_voltro_world_transitions", {
+						groupProceedReceipt: r,
+						revision: e.revision + 1,
+						updatedAt: new Date(c)
+					}, { where: C(w("id", e.id), w("tenantId", t.tenantId), w("phase", "switching"), w("revision", e.revision)) }) !== 1 && j("World proceed lost its decision CAS");
+				}
+				return await lt(n, t) ?? j("World proceed lost its complete durable decision");
+			}));
+		}));
+	}, vt = (e) => {
+		let r, i, a;
+		try {
+			P(e, [
+				"tenantId",
+				"requestId",
+				"members",
+				"command"
+			]), a = e.command === void 0 ? void 0 : te(e.command), (!R || !Array.isArray(e.members) || !e.members.length || e.members.length > R.maxRows || Reflect.ownKeys(e.members).length !== e.members.length + 1) && j("World group begin requires bounded complete membership");
+			let t = [];
+			for (let n = 0; n < e.members.length; n++) {
+				let r = Object.getOwnPropertyDescriptor(e.members, n);
+				r && "value" in r || j("World group begin requires own member data");
+				let i = st(r.value);
+				i.captured.expectedSubject && i.captured.tenantId === e.tenantId || j("World group begin requires every expected Subject"), t.push(i);
+			}
+			new Set(t.map((e) => e.captured.entityId)).size !== t.length && j("World group begin entities must be distinct");
+			let n = t[0].captured.target;
+			t.some((e) => e.captured.target.worldId !== n.worldId || e.captured.target.layer !== n.layer) && j("World group begin requires one target World and layer"), i = oe({
+				tenantId: e.tenantId,
+				requestId: e.requestId,
+				members: t.map((e) => ({
+					origin: e.captured.origin,
+					expectedRevision: 1,
+					subject: e.captured.expectedSubject
+				}))
+			}, R.maxRows), a && (a.origin.tenantId !== i.tenantId || i.requestId !== ie(a) || !t.some((e) => e.captured.origin.roomId === a.origin.roomId) || t.some((e) => J({
+				target: e.captured.intent.target,
+				options: e.captured.intent.options
+			}) !== J({
+				target: a.intent.target,
+				options: a.intent.options
+			}))) && j("World group command escaped its original Room or member intentions"), r = Object.freeze(t.sort((e, t) => e.captured.entityId < t.captured.entityId ? -1 : 1));
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World group creation" }));
+		}
+		let o = (e) => {
+			let t = S(e);
+			if (t) return (J(t) !== J(i) || a && e.some((t) => J(t.groupCommand ?? null) !== J(e[0].groupCommand ?? null)) || e.some((e) => a ? !e.groupCommand || J(te({
+				origin: e.groupCommand.origin,
+				intent: e.groupCommand.intent
+			})) !== J(a) : e.groupCommand !== void 0)) && j("World group begin conflicts with its original binding/command"), Object.freeze(i.members.map((t) => e.find((e) => Y(e.origin) === Y(t.origin))));
+		};
+		return D.gen(function* () {
+			yield* Qe("bind", i);
+			for (let e of r) yield* $("begin", e.captured, () => D.void);
+			return yield* I(async () => {
+				let e = [];
+				for (let t of r) {
+					let n = await t.replay(v, !1);
+					n && e.push(n);
+				}
+				if (e.length) {
+					e.length !== r.length && j("World group begin cannot adopt a partial preexisting request set");
+					let t = o(e);
+					if (t) return t;
+					j("World group begin cannot adopt preexisting unbound requests");
+				}
+				return v.transactional(async (e) => {
+					await U(e, i.tenantId, r.flatMap((e) => [e.work.source, e.work.target]));
+					let t = /* @__PURE__ */ new Map();
+					for (let n of r) t.set(n.captured.entityId, await F(e, n.captured, !0));
+					if (a) {
+						let t = await lt(e, a.origin);
+						if (t) {
+							let n = o(t.records);
+							n || j("World group command has no complete retained binding");
+							for (let t of r) await t.replay(e, !1) || j("World group command member receipt changed");
+							return n;
+						}
+					}
+					let n = [];
+					for (let i of r) n.push(await i.insert(e, t.get(i.captured.entityId)));
+					let s = o(n);
+					if (s) return s;
+					let c = ce(i, R.readiness !== void 0), l = B(), u = a ? ne({
+						...a,
+						startedAt: l,
+						waitUntil: l + a.intent.waitForAllMs
+					}) : void 0, d = [];
+					for (let t = 0; t < i.members.length; t++) {
+						let r = i.members[t], a = n.find((e) => Y(e.origin) === Y(r.origin));
+						(a.phase !== "requested" || a.revision !== 1 || a.subject?.id !== r.subject.id || a.subject.kind !== r.subject.kind || l < a.updatedAt) && j("World group begin lost its requested member fence");
+						let o = c[t], s = {
+							groupKey: o.key,
+							groupReceipt: o,
+							revision: 2,
+							updatedAt: new Date(l),
+							groupCommandKey: u ? re(u) : null,
+							groupCommandReceipt: u ?? null
+						};
+						await e.updateMany("_voltro_world_transitions", s, { where: C(w("id", a.id), w("tenantId", i.tenantId), w("revision", 1), w("phase", "requested"), w("groupKey", null)) }) !== 1 && j("World group begin lost its binding CAS");
+						let f = await Q(e, r.origin, !0);
+						f.length !== 1 && j("World group begin lost its bound member"), d.push(Z(f[0]));
+					}
+					return Object.freeze(d);
+				});
+			});
+		});
+	}, yt = (t, r, i = !1, a) => {
+		let o, c, l;
+		try {
+			P(t, i ? [
+				"origin",
+				"roomId",
+				"hostId",
+				"epoch",
+				"priorEpoch",
+				"worldRecoveryEpoch"
+			] : r === "source" ? [
+				"origin",
+				"roomId",
+				"hostId",
+				"epoch",
+				"operation"
+			] : [
+				"origin",
+				"roomId",
+				"hostId",
+				"epoch"
+			]);
+			let e = i ? "rollback" : r === "source" ? t.operation : void 0;
+			r === "source" && e !== "detach" && e !== "rollback" && j("Invalid World source actor operation"), i && (c = N(t.priorEpoch), (r !== "source" || t.epoch !== c + 1) && j("World source recovery requires the next claimed epoch"), l = N(t.worldRecoveryEpoch ?? c), l > c && j("World recovery baseline exceeds its prior owner")), o = Object.freeze({
+				origin: q(t.origin),
+				roomId: M(t.roomId),
+				hostId: M(t.hostId),
+				epoch: N(t.epoch),
+				...e === void 0 ? {} : { operation: e }
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World actor owner admission" }));
+		}
+		return $(i ? "actorSourceRecovery" : r === "source" ? "actorSource" : "actorTarget", i ? Object.freeze({
+			origin: o.origin,
+			roomId: o.roomId,
+			hostId: o.hostId,
+			epoch: o.epoch,
+			priorEpoch: c,
+			worldRecoveryEpoch: l
+		}) : o, () => I(async () => {
+			i && l < c && (a || j("Older World source epochs require active checkpoint adoption authority"), de(a, {
+				tenantId: o.origin.tenantId,
+				roomId: o.roomId,
+				hostId: o.hostId,
+				epoch: o.epoch,
+				priorEpoch: c,
+				worldRecoveryEpoch: l
+			}));
+			let t = await Q(v, o.origin);
+			t.length !== 1 && j("World actor operation requires an actual transition");
+			let n = Z(t[0]), u = n[r];
+			return (u.roomId !== o.roomId || (i ? u.epoch < l || u.epoch > c : u.epoch !== o.epoch)) && j("World actor operation differs from its original owner epoch"), v.transactional(async (t) => {
+				i ? await h(t, [o.roomId], o.origin.tenantId) : await U(t, o.origin.tenantId, [V(u)]);
+				let a = await t.query({
+					table: s,
+					predicate: C(w("id", o.roomId), w("tenantId", o.origin.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				if ((a.length !== 1 || a[0].hostId !== o.hostId || a[0].epoch !== o.epoch || a[0].state !== (i ? "creating" : "live") || a[0].erasure != null || a[0].snapshotErasure != null) && j("World actor operation lost its actual admitted Host"), i) {
+					let n = z(u.worldId), r = n.instances.some((e) => e.room === a[0].name);
+					(r ? n.zones.some((e) => e.room === a[0].name) : n.zones.find((e) => e.id === u.zoneId)?.room !== a[0].name) && j("World source recovery Room differs from its declared placement"), (await t.query({
+						table: "_voltro_room_hosts",
+						predicate: w("id", o.hostId),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: ["id"]
+					})).length !== 1 && j("World source recovery requires its retained Host"), await g(t, n, a[0], !0);
+					let i = await t.query({
+						table: r ? e : _,
+						predicate: C(w("tenantId", o.origin.tenantId), w("roomId", o.roomId)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					}), s = i[0];
+					(i.length !== 1 || s.epoch !== u.epoch || s.worldId !== u.worldId || (r ? !n.instances.some((e) => e.id === s.instance && e.room === a[0].name) : s.zoneId !== u.zoneId || s.layer !== u.layer || s.cellId !== d(n, {
+						zone: u.zoneId,
+						at: u.at
+					}).id)) && j("World source recovery differs from its durable cell epoch");
+				}
+				let c = await F(t, {
+					tenantId: o.origin.tenantId,
+					entityId: n.entityId
+				}, !0), l = await Q(t, o.origin, !0);
+				l.length !== 1 && j("World actor operation lost its transition");
+				let f = Z(l[0]), p = r === "target" ? "committed" : o.operation === "rollback" ? "failed" : f.mode === "portal" ? "detaching" : "switching";
+				(f.id !== n.id || f.phase !== p || !f.actorSnapshot && (r !== "source" || o.operation !== "rollback") || r === "target" && !f.result || c.length !== 1 || c[0].activeTransitionId !== (r === "source" ? f.id : null)) && j("World actor operation lost its phase, snapshot or active entity fence");
+				let m = H(c[0]);
+				return m.revision === f.entityRevision && W(m, V(f[r])) && m.subject?.id === f.subject?.id && m.subject?.kind === f.subject?.kind || j("World actor entity advanced beyond its transition receipt"), f;
+			});
+		}));
+	}, bt = (e) => {
+		let t;
+		try {
+			P(e, [
+				"tenantId",
+				"roomId",
+				"transitionId"
+			]), t = Object.freeze({
+				tenantId: M(e.tenantId),
+				roomId: M(e.roomId),
+				transitionId: M(e.transitionId)
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World actor receipt scope" }));
+		}
+		return $("actorReceipt", t, () => I(async () => {
+			let e = await v.query({
+				table: l,
+				predicate: C(w("tenantId", t.tenantId), w("id", t.transitionId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0
+			});
+			if (!e.length) return null;
+			e.length !== 1 && j("World actor receipt identity is ambiguous");
+			let n = Z(e[0]);
+			return n.source.roomId !== t.roomId && n.target.roomId !== t.roomId && j("World actor receipt Room is not a participant"), n;
+		}));
+	}, xt = (e) => {
+		let t;
+		try {
+			P(e, [
+				"origin",
+				"roomId",
+				"hostId",
+				"epoch",
+				"binding",
+				"sessionId",
+				"subjectId",
+				"subjectKind",
+				"credentialDigest"
+			]), e.subjectKind !== void 0 && e.subjectKind !== "user" && e.subjectKind !== "guest" && j("World Seat requires an authenticated Subject kind"), t = Object.freeze({
+				origin: q(e.origin),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch),
+				binding: f(e.binding),
+				sessionId: M(e.sessionId),
+				subjectId: M(e.subjectId),
+				subjectKind: e.subjectKind ?? "user",
+				credentialDigest: e.credentialDigest
+			}), typeof t.credentialDigest == "string" && /^[a-f0-9]{64}$/.test(t.credentialDigest) && t.binding.sourceRoomId === t.origin.roomId && t.binding.requestId === t.origin.requestId || j("World Seat admission scope differs from its durable origin");
+		} catch {
+			return D.fail(new n({ detail: "Invalid World target Seat admission" }));
+		}
+		return $("actorSeat", t, () => I(async () => {
+			let e = await Q(v, t.origin);
+			e.length !== 1 && j("World Seat admission requires its actual transition");
+			let n = Z(e[0]);
+			return (n.id !== t.binding.transitionId || n.entityId !== t.binding.entityId || n.subject?.kind !== t.subjectKind || n.subject.id !== t.subjectId || n.target.roomId !== t.roomId || (n.phase === "settled" ? t.epoch < n.target.epoch : n.target.epoch !== t.epoch)) && j("World Seat admission differs from its player target"), v.transactional(async (e) => {
+				await U(e, t.origin.tenantId, [V(n.phase === "settled" ? {
+					...n.target,
+					epoch: t.epoch
+				} : n.target)]);
+				let r = await e.query({
+					table: s,
+					predicate: C(w("id", t.roomId), w("tenantId", t.origin.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				(r.length !== 1 || r[0].hostId !== t.hostId || r[0].epoch !== t.epoch || r[0].state !== "live" || r[0].erasure != null || r[0].snapshotErasure != null) && j("World Seat admission lost its actual target Host");
+				let i = await F(e, {
+					tenantId: t.origin.tenantId,
+					entityId: n.entityId
+				}, !0), a = await Q(e, t.origin, !0);
+				(a.length !== 1 || i.length !== 1) && j("World Seat admission lost its transition/entity");
+				let o = Z(a[0]);
+				(o.id !== n.id || o.entityId !== n.entityId || J(o.group ?? null) !== J(n.group ?? null) || !o.actorSnapshot || J(o.target) !== J(n.target) || J(o.source) !== J(n.source) || o.subject?.kind !== t.subjectKind || o.subject.id !== t.subjectId || [
+					"requested",
+					"reserving",
+					"failed",
+					"rolledBack"
+				].includes(o.phase)) && j("World Seat admission has no prepared transition");
+				let l = o.group ? await nt(e, o) : void 0, u = (l ? l.members.map((e) => e.subject.id).sort() : [t.subjectId]).indexOf(t.subjectId);
+				(u < 0 || ae(t.origin.tenantId, ue(o), u) !== t.sessionId) && j("World Seat admission differs from its canonical batch Session");
+				let d = o.phase === "committed" || o.phase === "settled", f = H(i[0]), m = o.phase === "settled" ? {
+					...o.target,
+					epoch: t.epoch
+				} : o.target;
+				((o.phase === "settled" ? f.revision < o.entityRevision : f.revision !== o.entityRevision) || !W(f, V(d ? m : o.source)) || f.subject?.kind !== t.subjectKind || f.subject.id !== t.subjectId || i[0].activeTransitionId !== (d ? null : o.id) || d && !o.result) && j("World Seat admission lost its authoritative entity fence");
+				let h = await e.query({
+					table: c,
+					predicate: C(w("tenantId", t.origin.tenantId), w("roomId", t.roomId), w("sessionId", t.sessionId), w("subjectId", t.subjectId), w("epoch", t.epoch), w("role", "player"), w("state", "connected"), w("token", t.credentialDigest)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: ["reservationBatchReceipt"],
+					lock: "update"
+				});
+				return (h.length !== 1 || JSON.stringify(p(h[0].reservationBatchReceipt)) !== JSON.stringify(t.binding)) && j("World Seat admission lacks its actual consumed credential and private binding"), o;
+			});
+		}));
+	}, St = async (e, t, n) => {
+		if (n.activeTransitionId == null) return;
+		let r = await e.query({
+			table: l,
+			predicate: C(w("id", n.activeTransitionId), w("tenantId", t.tenantId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		r.length !== 1 && j("World projection transition fence has no receipt");
+		let i = Z(r[0]);
+		(i.entityId !== t.entityId || i.entityRevision !== t.revision || i.subject?.id !== t.subject?.id || i.subject?.kind !== t.subject?.kind || i.source.roomId !== t.roomId || i.source.epoch !== t.epoch || i.actorFinalSnapshot || i.actorDepartureRevision !== void 0 || ![
+			"requested",
+			"reserving",
+			"prepared",
+			"ghosting",
+			"switching"
+		].includes(i.phase) || i.mode === "portal" && i.phase === "switching") && j("World projection source departed or is compensating");
+	}, Ct = (e) => {
+		let t;
+		try {
+			P(e, [
+				"tenantId",
+				"entityId",
+				"roomId",
+				"hostId",
+				"epoch"
+			]), t = Object.freeze({
+				tenantId: M(e.tenantId),
+				entityId: M(e.entityId),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch)
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World actor projection admission" }));
+		}
+		return G("actorProjection", t, () => I(async () => {
+			let e = await F(v, t);
+			e.length !== 1 && j("World projection requires its actual persisted entity");
+			let n = H(e[0]);
+			return (n.roomId !== t.roomId || n.epoch !== t.epoch || n.returnAnchor) && j("World neighbor projection requires its actual non-instance source"), v.transactional(async (e) => {
+				await U(e, t.tenantId, [n]);
+				let r = await e.query({
+					table: s,
+					predicate: C(w("id", t.roomId), w("tenantId", t.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"hostId",
+						"state",
+						"name",
+						"epoch",
+						"erasure",
+						"snapshotErasure"
+					],
+					lock: "update"
+				});
+				(r.length !== 1 || r[0].hostId !== t.hostId || r[0].state !== "live" || r[0].epoch !== t.epoch || r[0].erasure != null || r[0].snapshotErasure != null || z(n.worldId).instances.some((e) => e.room === r[0].name)) && j("World projection lost its live non-instance Host");
+				let i = await F(e, t, !0);
+				i.length !== 1 && j("World projection lost its persisted entity");
+				let a = H(i[0]);
+				return a.revision === n.revision && W(a, n) || j("World projection changed ownership"), await St(e, a, i[0]), a;
+			});
+		}));
+	}, wt = (e) => {
+		let t, r, a;
+		try {
+			P(e, [
+				"tenantId",
+				"entityId",
+				"roomId",
+				"hostId",
+				"epoch",
+				"expectedRevision",
+				"source",
+				"target",
+				"targetHostId"
+			]), r = V(e.source), a = V(e.target), t = Object.freeze({
+				tenantId: M(e.tenantId),
+				entityId: M(e.entityId),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch),
+				expectedRevision: N(e.expectedRevision),
+				source: Object.freeze({
+					worldId: r.worldId,
+					zoneId: r.zoneId,
+					at: r.at,
+					layer: r.layer,
+					roomId: r.roomId,
+					epoch: r.epoch
+				}),
+				target: Object.freeze({
+					worldId: a.worldId,
+					zoneId: a.zoneId,
+					at: a.at,
+					layer: a.layer,
+					roomId: a.roomId,
+					epoch: a.epoch
+				}),
+				targetHostId: M(e.targetHostId)
+			}), (r.roomId !== t.roomId || r.epoch !== t.epoch || r.roomId === a.roomId || r.worldId !== a.worldId || r.layer !== a.layer) && j("Ghost neighbor crosses its source World or layer");
+			let n = z(r.worldId), o = n.zones.find((e) => e.id === r.zoneId), s = d(n, {
+				zone: r.zoneId,
+				at: r.at
+			}), c = d(n, {
+				zone: a.zoneId,
+				at: a.at
+			});
+			(r.zoneId !== a.zoneId && !o.neighbors.includes(a.zoneId) || !i(s.bounds, c.bounds)) && j("Ghost target is not an edge-adjacent declared neighbor");
+			let l = Math.max(c.bounds[0][0] - r.at[0], 0, r.at[0] - c.bounds[1][0]), u = Math.max(c.bounds[0][1] - r.at[1], 0, r.at[1] - c.bounds[1][1]);
+			Math.hypot(l, u) > n.handoff.ghostUnits && j("Ghost source lies outside its neighbor distance");
+		} catch {
+			return D.fail(new n({ detail: "Invalid World neighbor projection admission" }));
+		}
+		return G("actorNeighbor", t, () => I(() => v.transactional(async (e) => {
+			await U(e, t.tenantId, [r, a]);
+			let n = [];
+			for (let i of [r, a]) {
+				let r = await e.query({
+					table: s,
+					predicate: C(w("id", i.roomId), w("tenantId", t.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				(r.length !== 1 || r[0].state !== "live" || r[0].epoch !== i.epoch || r[0].erasure != null || r[0].snapshotErasure != null || z(i.worldId).instances.some((e) => e.room === r[0].name)) && j("Ghost neighbor lost a live non-instance owner"), n.push(r[0]);
+			}
+			(n[0].hostId !== t.hostId || n[1].hostId !== t.targetHostId || (n[0].pool ?? null) !== (n[1].pool ?? null)) && j("Ghost neighbor changed Host or pool");
+			let i = await F(e, t, !0);
+			i.length !== 1 && j("Ghost neighbor lost its actual source entity");
+			let o = H(i[0]);
+			return (o.revision !== t.expectedRevision || !W(o, r) || o.returnAnchor) && j("Ghost neighbor source revision or ownership changed"), await St(e, o, i[0]), o;
+		})));
+	}, Tt = (e) => {
+		let t;
+		try {
+			P(e, [
+				"tenantId",
+				"entityId",
+				"roomId",
+				"hostId",
+				"epoch",
+				"subject"
+			]), P(e.subject, ["id", "kind"]), ["user", "guest"].includes(e.subject.kind) || j("World player requires an authenticated Subject kind"), t = Object.freeze({
+				tenantId: M(e.tenantId),
+				entityId: M(e.entityId),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch),
+				subject: Object.freeze({
+					id: M(e.subject.id),
+					kind: e.subject.kind
+				})
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid ordinary World player admission" }));
+		}
+		return G("actorPlayer", t, () => I(async () => {
+			let e = await F(v, t);
+			e.length !== 1 && j("World player requires its actual persisted entity");
+			let n = H(e[0]);
+			return (n.roomId !== t.roomId || n.epoch !== t.epoch) && j("World player entity belongs to another Room"), await v.transactional(async (e) => {
+				await U(e, t.tenantId, [n]);
+				let r = await e.query({
+					table: s,
+					predicate: C(w("id", t.roomId), w("tenantId", t.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"hostId",
+						"erasure",
+						"snapshotErasure"
+					],
+					lock: "update"
+				});
+				(r.length !== 1 || r[0].hostId !== t.hostId || r[0].erasure != null || r[0].snapshotErasure != null) && j("World player lost its current published Host");
+				let i = await F(e, t, !0);
+				i.length !== 1 && j("World player lost its persisted entity");
+				let a = H(i[0]);
+				if (a.revision === n.revision && W(a, n) && a.subject?.id === t.subject.id && a.subject.kind === t.subject.kind || j("World player changed identity or ownership"), i[0].activeTransitionId != null) {
+					let n = await e.query({
+						table: l,
+						predicate: C(w("id", i[0].activeTransitionId), w("tenantId", t.tenantId)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					});
+					n.length !== 1 && j("World player transition fence has no complete receipt");
+					let r = Z(n[0]);
+					(r.entityId !== t.entityId || r.subject?.id !== t.subject.id || r.subject.kind !== t.subject.kind || r.source.roomId !== t.roomId || r.source.epoch !== t.epoch || r.actorFinalSnapshot || r.actorDepartureRevision !== void 0 || ![
+						"requested",
+						"reserving",
+						"prepared",
+						"ghosting",
+						"switching"
+					].includes(r.phase) || r.mode === "portal" && r.phase === "switching") && j("World player source has departed or is compensating");
+				}
+				return Object.freeze({
+					entityId: a.entityId,
+					worldId: a.worldId,
+					zoneId: a.zoneId,
+					cellId: a.cellId,
+					layer: a.layer,
+					revision: a.revision,
+					data: a.data
+				});
+			});
+		}));
+	}, Et = (e, t) => {
+		let r;
+		try {
+			P(e, [
+				"origin",
+				"roomId",
+				"hostId",
+				"epoch",
+				"subjectId",
+				"subjectKind"
+			]), (typeof t != "function" || e.subjectKind !== "user" && e.subjectKind !== "guest") && j("World follower requires actual Subject/capacity scope"), r = Object.freeze({
+				origin: q(e.origin),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch),
+				subjectId: M(e.subjectId),
+				subjectKind: e.subjectKind
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World follower admission" }));
+		}
+		return $("actorFollower", r, () => I(async () => {
+			let e = await Q(v, r.origin);
+			e.length !== 1 && j("World follower requires its original transition");
+			let n = Z(e[0]);
+			return (n.phase !== "settled" || !n.groupProceed || !n.groupCommand || !n.result || n.subject?.id !== r.subjectId || n.subject.kind !== r.subjectKind || n.target.roomId !== r.roomId || r.epoch < n.target.epoch) && j("World follower has no settled deferred target"), v.transactional(async (e) => {
+				let i = V({
+					...n.target,
+					epoch: r.epoch
+				});
+				await U(e, r.origin.tenantId, [i]);
+				let a = await e.query({
+					table: s,
+					predicate: C(w("id", r.roomId), w("tenantId", r.origin.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"hostId",
+						"epoch",
+						"state",
+						"erasure",
+						"snapshotErasure"
+					],
+					lock: "update"
+				});
+				(a.length !== 1 || a[0].hostId !== r.hostId || a[0].epoch !== r.epoch || a[0].state !== "live" || a[0].erasure != null || a[0].snapshotErasure != null) && j("World follower lost its actual published target Host");
+				let o = await F(e, {
+					tenantId: r.origin.tenantId,
+					entityId: n.entityId
+				}, !0), c = await Q(e, r.origin, !0);
+				(o.length !== 1 || c.length !== 1) && j("World follower lost original entity/transition");
+				let l = Z(c[0]), u = H(o[0]);
+				(l.id !== n.id || l.entityId !== n.entityId || l.phase !== "settled" || !l.groupProceed || !l.groupCommand || J(l.groupProceed) !== J(n.groupProceed) || J(l.groupCommand) !== J(n.groupCommand) || J(l.target) !== J(n.target) || l.subject?.id !== r.subjectId || l.subject.kind !== r.subjectKind || u.subject?.id !== r.subjectId || u.subject.kind !== r.subjectKind || u.revision < l.entityRevision || !W(u, i) || o[0].activeTransitionId != null) && j("World follower lost current settled entity ownership");
+				let d = await lt(e, l.groupCommand.origin);
+				d && mt(d.records) && d.records.some((e) => e.id === l.id) || j("World follower lost its complete original group decision");
+				let f = await t(e, l), p = await F(e, {
+					tenantId: r.origin.tenantId,
+					entityId: l.entityId
+				}, !0), m = await Q(e, r.origin, !0);
+				return (p.length !== 1 || p[0].activeTransitionId != null || J(H(p[0])) !== J(u) || m.length !== 1 || J(Z(m[0])) !== J(l)) && j("World follower capacity work changed authoritative entity/transition data"), f;
+			});
+		}));
+	}, Dt = (e) => {
+		let t;
+		try {
+			P(e, [
+				"origin",
+				"roomId",
+				"hostId",
+				"epoch"
+			]), t = Object.freeze({
+				origin: q(e.origin),
+				roomId: M(e.roomId),
+				hostId: M(e.hostId),
+				epoch: N(e.epoch)
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World ghost admission" }));
+		}
+		return $("actorGhost", t, () => I(async () => {
+			let e = await Q(v, t.origin);
+			e.length !== 1 && j("World ghost requires an actual transition");
+			let n = Z(e[0]);
+			return n.mode === "seamless" && n.phase === "ghosting" && n.actorSnapshot && n.target.roomId === t.roomId && n.target.epoch === t.epoch || j("World ghost differs from its prepared seamless target"), v.transactional(async (e) => {
+				await U(e, t.origin.tenantId, [V(n.source), V(n.target)]);
+				let r = await e.query({
+					table: s,
+					predicate: C(w("id", t.roomId), w("tenantId", t.origin.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				(r.length !== 1 || r[0].hostId !== t.hostId || r[0].epoch !== t.epoch || r[0].state !== "live" || r[0].erasure != null || r[0].snapshotErasure != null) && j("World ghost lost its actual target owner");
+				let i = await F(e, {
+					tenantId: t.origin.tenantId,
+					entityId: n.entityId
+				}, !0), a = await Q(e, t.origin, !0);
+				(a.length !== 1 || i.length !== 1) && j("World ghost lost its fenced source entity");
+				let o = Z(a[0]), c = H(i[0]);
+				return o.id === n.id && o.revision === n.revision && o.phase === "ghosting" && o.mode === "seamless" && o.actorSnapshot && !o.actorFinalSnapshot && i[0].activeTransitionId === o.id && c.revision === o.entityRevision && W(c, V(o.source)) && c.subject?.id === o.subject?.id && c.subject?.kind === o.subject?.kind || j("World ghost no longer belongs to its current source transition"), o;
+			});
+		}));
+	}, Ot = (e) => yt(e, "target"), kt = (e, t) => yt(e, "source", !0, t), At = (e) => yt(e, "source"), jt = (e) => {
+		let r;
+		try {
+			P(e, [
+				"origin",
+				"expectedRevision",
+				"snapshot"
+			]), r = Object.freeze({
+				origin: q(e.origin),
+				expectedRevision: N(e.expectedRevision),
+				snapshot: fe(e.snapshot, E)
+			});
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World actor transfer snapshot" }));
+		}
+		return $("snapshot", r, () => I(async () => {
+			let e = await Q(v, r.origin);
+			e.length !== 1 && j("World actor snapshot requires an existing transition");
+			let t = Z(e[0]), n = (e) => e.actorSnapshot ? ((e.actorSnapshotRevision !== r.expectedRevision || J(e.actorSnapshot) !== J(r.snapshot)) && j("World actor snapshot conflicts with retained transfer bytes"), !0) : !1;
+			return n(t) ? t : v.transactional(async (e) => {
+				await U(e, r.origin.tenantId, [V(t.source)]);
+				let i = await F(e, {
+					tenantId: r.origin.tenantId,
+					entityId: t.entityId
+				}, !0), a = await Q(e, r.origin, !0);
+				a.length !== 1 && j("World actor snapshot lost its transition");
+				let o = Z(a[0]);
+				return o.id !== t.id && j("World actor snapshot transition identity changed"), n(o) ? o : (o.phase === "reserving" && o.revision === r.expectedRevision && o.entityId === r.snapshot.entity.id && i.length === 1 && i[0].activeTransitionId === o.id && H(i[0]).revision === o.entityRevision && W(H(i[0]), V(o.source)) || j("World actor snapshot lost its reserving phase, source owner or entity fence"), await e.updateMany("_voltro_world_transitions", {
+					actorSnapshot: r.snapshot,
+					actorSnapshotRevision: r.expectedRevision
+				}, { where: C(w("id", o.id), w("tenantId", r.origin.tenantId), w("revision", o.revision), w("phase", "reserving")) }) !== 1 && j("World actor snapshot CAS lost its transition"), Z({
+					...a[0],
+					actorSnapshot: r.snapshot,
+					actorSnapshotRevision: r.expectedRevision
+				}));
+			});
+		}));
+	}, Mt = (e) => {
+		let t;
+		try {
+			P(e, ["origin", "expectedRevision"]), t = Object.freeze({
+				origin: q(e.origin),
+				expectedRevision: N(e.expectedRevision)
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World portal departure" }));
+		}
+		return $("departure", t, () => I(async () => {
+			let e = await Q(v, t.origin);
+			e.length !== 1 && j("World portal departure requires its actual transition");
+			let n = Z(e[0]), r = (e) => e.actorDepartureRevision !== void 0 && (e.actorDepartureRevision !== t.expectedRevision && j("World portal departure conflicts with its retained phase"), !0);
+			return r(n) ? n : v.transactional(async (e) => {
+				await U(e, t.origin.tenantId, [V(n.source)]);
+				let i = await F(e, {
+					tenantId: t.origin.tenantId,
+					entityId: n.entityId
+				}, !0), a = await Q(e, t.origin, !0);
+				a.length !== 1 && j("World portal departure lost its transition");
+				let o = Z(a[0]);
+				if (o.id !== n.id && j("World portal departure changed identity"), r(o)) return o;
+				o.mode === "portal" && o.phase === "detaching" && o.revision === t.expectedRevision && o.actorSnapshot && i.length === 1 && i[0].activeTransitionId === o.id && H(i[0]).revision === o.entityRevision && W(H(i[0]), V(o.source)) || j("World portal departure lost its source owner, snapshot or entity fence"), await Xe(e, o, !0);
+				let s = { actorDepartureRevision: t.expectedRevision };
+				return await e.updateMany("_voltro_world_transitions", s, { where: C(w("id", o.id), w("tenantId", t.origin.tenantId), w("revision", o.revision), w("phase", "detaching")) }) !== 1 && j("World portal departure lost its phase CAS"), Z({
+					...a[0],
+					...s
+				});
+			});
+		}));
+	}, Nt = (e) => {
+		let i;
+		try {
+			P(e, [
+				"origin",
+				"expectedRevision",
+				"snapshot",
+				"data"
+			]), i = Object.freeze({
+				origin: q(e.origin),
+				expectedRevision: N(e.expectedRevision),
+				snapshot: fe(e.snapshot, E),
+				data: r(e.data, E)
+			});
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World final actor snapshot" }));
+		}
+		return $("finalSnapshot", i, () => I(async () => {
+			let e = await Q(v, i.origin);
+			e.length !== 1 && j("World final snapshot requires an existing transition");
+			let t = Z(e[0]), n = Object.freeze({
+				snapshot: i.snapshot,
+				data: i.data,
+				revision: i.expectedRevision
+			}), r = (e) => e.actorFinalSnapshot ? (J(e.actorFinalSnapshot) !== J(n) && j("World final snapshot conflicts with immutable handoff state"), !0) : !1;
+			return r(t) ? t : v.transactional(async (e) => {
+				await U(e, i.origin.tenantId, [V(t.source)]);
+				let a = await F(e, {
+					tenantId: i.origin.tenantId,
+					entityId: t.entityId
+				}, !0), o = await Q(e, i.origin, !0);
+				o.length !== 1 && j("World final snapshot lost its transition");
+				let s = Z(o[0]);
+				return s.id !== t.id && j("World final snapshot transition identity changed"), r(s) ? s : (s.mode === "seamless" && s.phase === "switching" && s.revision === i.expectedRevision && s.actorSnapshot && s.source.worldId === s.target.worldId && s.actorSnapshot.schemaHash === i.snapshot.schemaHash && s.entityId === i.snapshot.entity.id && a.length === 1 && a[0].activeTransitionId === s.id && H(a[0]).revision === s.entityRevision && W(H(a[0]), V(s.source)) || j("World final snapshot lost its switching phase, schema, source owner or entity fence"), await Xe(e, s, !0), await e.updateMany("_voltro_world_transitions", { actorFinalSnapshot: n }, { where: C(w("id", s.id), w("tenantId", i.origin.tenantId), w("revision", s.revision), w("phase", "switching")) }) !== 1 && j("World final snapshot CAS lost its transition"), Z({
+					...o[0],
+					actorFinalSnapshot: n
+				}));
+			});
+		}));
+	}, Pt = (e) => (e.mode === "portal" && e.actorSnapshot && e.actorDepartureRevision === void 0 && j("World portal actor commit requires its durable source departure"), e.mode === "seamless" && e.actorSnapshot && !e.actorFinalSnapshot && j("World seamless actor commit requires a finalized handoff snapshot"), e.actorFinalSnapshot ? e.actorFinalSnapshot.data : e.data), Ft = (e) => {
+		let t;
+		try {
+			P(e, [
+				"origin",
+				"expectedRevision",
+				"phase",
+				"failure"
+			]), a.includes(e.phase) && e.phase === "failed" == (e.failure !== void 0) || j("Invalid World transition phase or failure reason"), t = Object.freeze({
+				origin: q(e.origin),
+				expectedRevision: N(e.expectedRevision),
+				phase: e.phase,
+				...e.failure === void 0 ? {} : { failure: M(e.failure, 120) }
+			});
+		} catch {
+			return D.fail(new n({ detail: "Invalid World transition phase request" }));
+		}
+		return $("advance", t, () => I(async () => {
+			let e = await Q(v, t.origin);
+			e.length !== 1 && j("World transition phase requires one durable request");
+			let n = Z(e[0]), r = V(n.source), i = V(n.target);
+			if (n.group && [
+				"committed",
+				"failed",
+				"rolledBack"
+			].includes(t.phase) && j("Grouped World transition requires its complete coordinating operation"), n.revision === t.expectedRevision + 1 && n.phase === t.phase && (t.phase !== "failed" || n.failure === t.failure)) return n;
+			let a, o = await v.transactional(async (e) => {
+				a = void 0, (t.phase === "committed" || t.phase === "detaching") && await U(e, t.origin.tenantId, t.phase === "committed" ? [r, i] : [r]);
+				let o = {
+					tenantId: n.origin.tenantId,
+					entityId: n.entityId
+				}, s = await F(e, o, !0), c = await Q(e, t.origin, !0);
+				c.length !== 1 && j("World transition disappeared during phase admission");
+				let l = Z(c[0]);
+				if (l.group && [
+					"committed",
+					"failed",
+					"rolledBack"
+				].includes(t.phase) && j("Grouped World transition forbids individual commit or cancellation"), l.id !== n.id && j("World transition identity changed during phase admission"), l.revision === t.expectedRevision + 1 && l.phase === t.phase && (t.phase !== "failed" || l.failure === t.failure)) return l;
+				l.revision === t.expectedRevision && l.revision !== 2147483647 && ee(l.mode, l.phase, t.phase) || j("World transition lost its phase revision or legal edge");
+				let u = B();
+				u < l.updatedAt && j("World transition clock moved backwards"), l.phase === "committed" || s.length === 1 && s[0].activeTransitionId === l.id && H(s[0]).revision === l.entityRevision && W(H(s[0]), r) || j("World transition lost its durable source fence");
+				let d = l.entityRevision, f = l.result, p = l.committedAt;
+				if (t.phase === "detaching") {
+					let t = await He(e, "persist", K("persist", {
+						...o,
+						expectedRevision: d,
+						source: l.source,
+						data: l.sourceData
+					}), void 0, l.id);
+					d = t.revision, u = t.updatedAt;
+				}
+				if (t.phase === "committed" && (f = await He(e, "transfer", K("transfer", {
+					...o,
+					expectedRevision: d,
+					source: l.source,
+					target: l.target,
+					data: Pt(l)
+				}), {
+					requestKey: Y(l.origin),
+					requestDigest: c[0].requestDigest
+				}, l.id), d = f.revision, u = f.updatedAt, p = u, await e.updateMany("_voltro_world_entities", {
+					activeTransitionId: null,
+					transitionedAt: new Date(u)
+				}, { where: C(ke(o), w("activeTransitionId", l.id), w("revision", d)) }) !== 1 && j("World transition commit lost its entity fence")), t.phase === "rolledBack" && l.actorFinalSnapshot) {
+					let t = await He(e, "persist", K("persist", {
+						...o,
+						expectedRevision: d,
+						source: l.source,
+						data: l.actorFinalSnapshot.data
+					}), void 0, l.id);
+					d = t.revision, u = t.updatedAt;
+				}
+				t.phase === "rolledBack" && await e.updateMany("_voltro_world_entities", { activeTransitionId: null }, { where: C(ke(o), w("activeTransitionId", l.id), w("revision", d)) }) !== 1 && j("World transition rollback lost its source fence"), t.phase === "rolledBack" && await Xe(e, l, !1);
+				let m = {
+					phase: t.phase,
+					revision: l.revision + 1,
+					entityRevision: d,
+					result: f,
+					failure: t.phase === "failed" ? t.failure : l.failure,
+					committedAt: p === null ? null : new Date(p),
+					updatedAt: new Date(u)
+				}, h = Z({
+					...c[0],
+					...m
+				});
+				return u < l.updatedAt && j("World transition clock moved backwards during commit"), await e.updateMany("_voltro_world_transitions", m, { where: C(w("id", l.id), w("tenantId", l.origin.tenantId), w("revision", l.revision), w("phase", l.phase)) }) !== 1 && j("World transition phase CAS lost its revision"), a = h, h;
+			});
+			return a && ge.observe(a), o;
+		}));
+	}, It = (e) => {
+		let i, a, o;
+		try {
+			if (Array.isArray(e) && Object.getPrototypeOf(e) === Array.prototype && Reflect.ownKeys(e).length === e.length + 1 && e.length || j("World commit batch requires bounded own entries"), e.length > A) throw new t({
+				budget: "worldTransitionBatchRows",
+				limit: A
+			});
+			let n = [], r = /* @__PURE__ */ new Set();
+			for (let t = 0; t < e.length; t++) {
+				let i = Object.getOwnPropertyDescriptor(e, String(t));
+				i?.enumerable && "value" in i || j("World commit batch refuses accessor entries");
+				let a = i.value;
+				P(a, ["origin", "expectedRevision"]);
+				let o = q(a.origin), s = N(a.expectedRevision), c = Y(o);
+				(r.has(c) || n.length && n[0].origin.tenantId !== o.tenantId) && j("World commit batch requires unique requests in one tenant"), r.add(c), n.push(Object.freeze({
+					origin: o,
+					expectedRevision: s
+				}));
+			}
+			i = Object.freeze(n);
+			let s = [...n].sort((e, t) => Y(e.origin) < Y(t.origin) ? -1 : 1);
+			a = J(["world-transition-commit-batch", s.map((e) => e.origin)]), o = J(s);
+		} catch (e) {
+			return D.fail(e instanceof t ? e : new n({ detail: "Invalid World commit batch" }));
+		}
+		return D.gen(function* () {
+			for (let e of i) yield* $("advance", {
+				...e,
+				phase: "committed"
+			}, () => D.void);
+			return yield* I(async () => {
+				let e = async (e, t) => {
+					let n = [];
+					for (let r of i) {
+						let i = await Q(e, r.origin, t);
+						i.length !== 1 && j("World commit batch requires every durable request"), n.push({
+							input: r,
+							row: i[0],
+							record: Z(i[0])
+						});
+					}
+					return new Set(n.map((e) => e.record.entityId)).size !== n.length && j("World commit batch requires distinct entities"), n;
+				}, t = async (e, t, n) => {
+					let s = await e.query({
+						table: k,
+						predicate: C(w("tenantId", i[0].origin.tenantId), w("requestKey", a)),
+						order: [],
+						take: i.length + 1,
+						skip: void 0,
+						projection: void 0,
+						...n ? { lock: "update" } : {}
+					});
+					if (!s.length) return !1;
+					(s.length !== t.length || new Set(s.map((e) => e.entityId)).size !== t.length) && j("World batch receipt is incomplete or duplicated");
+					for (let { record: e, input: n } of t) {
+						let t = s.find((t) => t.entityId === e.entityId);
+						(!t || t.tenantId !== n.origin.tenantId || t.requestKey !== a || t.requestDigest !== o || t.operation !== "transfer" || e.phase !== "committed" && e.phase !== "settled" || e.revision !== n.expectedRevision + (e.phase === "settled" ? 2 : 1) || e.result === null || t.revision !== e.entityRevision || t.subjectId !== (e.subject?.id ?? null) || t.subjectKind !== (e.subject?.kind ?? null) || Ye(t.createdAt) !== e.result.updatedAt || J(r(t.snapshot, xe)) !== J(e.result)) && j("World batch receipt conflicts with its original commit");
+					}
+					return !0;
+				}, n = await e(v, !1), s = S(n.map((e) => e.record));
+				if (s !== void 0) {
+					let e = await D.runPromise(D.result(Qe("commit", s)));
+					if (Se.isFailure(e)) throw e.failure;
+				}
+				if (await t(v, n, !1)) return Object.freeze(n.map((e) => e.record));
+				n.some((e) => e.record.phase !== "switching" || e.record.revision !== e.input.expectedRevision) && j("World batch is not wholly ready for its original commit");
+				let c = s !== void 0 && R?.readiness !== void 0 || n.some((e) => e.record.group?.requiresReadiness || e.record.ready !== void 0), l = mt(n.map((e) => e.record));
+				if (c) {
+					if (s && R?.readiness || j("World group readiness provider cannot be withdrawn before commit"), l) {
+						let e = await D.runPromise(D.result(ht(l)));
+						if (Se.isFailure(e)) throw e.failure;
+						await gt(v, l.records, B(), !1);
+					} else for (let e of n) e.row.readySession ?? j("World group has not received every target ready intention"), await tt(v, e.record, m(e.row.readySession));
+				}
+				return v.transactional(async (e) => {
+					let r = n.flatMap((e) => [V(e.record.source), V(e.record.target)]).sort(Ve);
+					await U(e, i[0].origin.tenantId, r);
+					let u = [...n].sort((e, t) => e.record.entityId < t.record.entityId ? -1 : 1), d = /* @__PURE__ */ new Map();
+					for (let t of u) {
+						let n = await F(e, {
+							tenantId: t.input.origin.tenantId,
+							entityId: t.record.entityId
+						}, !0);
+						n.length !== 1 && j("World batch lost a durable entity"), d.set(t.record.entityId, n[0]);
+					}
+					let f = [];
+					for (let t of u) {
+						let n = await Q(e, t.input.origin, !0);
+						n.length !== 1 && j("World batch lost a durable transition");
+						let r = Z(n[0]);
+						(r.id !== t.record.id || r.entityId !== t.record.entityId) && j("World batch identity changed under locks"), f.push({
+							input: t.input,
+							row: n[0],
+							record: r
+						});
+					}
+					let p = S(f.map((e) => e.record));
+					if (J(p ?? null) !== J(s ?? null) && j("World commit group fence changed under locks"), await t(e, f, !0)) {
+						let e = new Map(f.map((e) => [Y(e.input.origin), e.record]));
+						return Object.freeze(i.map((t) => e.get(Y(t.origin))));
+					}
+					for (let e of f) {
+						let t = d.get(e.record.entityId), n = H(t);
+						e.record.phase === "switching" && e.record.revision === e.input.expectedRevision && e.record.revision !== 2147483647 && n.tenantId === e.input.origin.tenantId && n.entityId === e.record.entityId && t.activeTransitionId === e.record.id && n.revision === e.record.entityRevision && W(n, V(e.record.source)) || j("World batch lost an original source/phase fence");
+					}
+					if (c) {
+						let t = mt(f.map((e) => e.record));
+						if (J(t?.records.map((e) => e.groupProceed) ?? null) !== J(l ? [...l.records].sort((e, t) => e.entityId < t.entityId ? -1 : 1).map((e) => e.groupProceed) : null) && j("World deferred readiness decision changed under commit locks"), t) await gt(e, t.records, B(), !0);
+						else for (let t of f) t.row.readySession ?? j("World group lost an original ready observation under locks"), await tt(e, t.record, m(t.row.readySession), !0);
+					}
+					let h = /* @__PURE__ */ new Map();
+					for (let { input: t, row: n, record: r } of f) {
+						let i = {
+							tenantId: t.origin.tenantId,
+							entityId: r.entityId
+						}, s = await He(e, "transfer", K("transfer", {
+							...i,
+							expectedRevision: r.entityRevision,
+							source: r.source,
+							target: r.target,
+							data: Pt(r)
+						}), {
+							requestKey: a,
+							requestDigest: o
+						}, r.id);
+						s.updatedAt < r.updatedAt && j("World batch commit clock moved backwards"), await e.updateMany("_voltro_world_entities", {
+							activeTransitionId: null,
+							transitionedAt: new Date(s.updatedAt)
+						}, { where: C(ke(i), w("activeTransitionId", r.id), w("revision", s.revision)) }) !== 1 && j("World batch lost its entity commit fence");
+						let c = {
+							phase: "committed",
+							revision: r.revision + 1,
+							entityRevision: s.revision,
+							result: s,
+							committedAt: new Date(s.updatedAt),
+							updatedAt: new Date(s.updatedAt)
+						}, l = Z({
+							...n,
+							...c
+						});
+						await e.updateMany("_voltro_world_transitions", c, { where: C(w("id", r.id), w("tenantId", t.origin.tenantId), w("revision", r.revision), w("phase", "switching")) }) !== 1 && j("World batch phase CAS lost its original revision"), h.set(Y(t.origin), l);
+					}
+					return Object.freeze(i.map((e) => h.get(Y(e.origin))));
+				});
+			});
+		});
+	}, Lt = (e, t) => (P(t, [
+		"tenantId",
+		"requestId",
+		"kind",
+		"completed"
+	]), Object.freeze({
+		tenantId: M(t.tenantId),
+		subject: Oe({
+			id: e,
+			kind: t.kind
+		}),
+		requestId: M(t.requestId)
+	})), Rt = (e) => C(w("tenantId", e.tenantId), w("subjectId", e.subject.id), w("subjectKind", e.subject.kind));
+	return Object.freeze({
+		handoffMetrics: () => L === void 0 ? void 0 : ge.snapshot(),
+		worlds: _e,
+		recoverRoom: (r, i) => {
+			let a;
+			try {
+				P(r, [
+					"tenantId",
+					"roomId",
+					"hostId",
+					"priorEpoch",
+					"epoch",
+					"worldRecoveryEpoch"
+				]), a = Object.freeze({
+					tenantId: M(r.tenantId),
+					roomId: M(r.roomId),
+					hostId: M(r.hostId),
+					priorEpoch: N(r.priorEpoch),
+					epoch: N(r.epoch),
+					...r.worldRecoveryEpoch === void 0 ? {} : { worldRecoveryEpoch: N(r.worldRecoveryEpoch) }
+				}), a.epoch !== a.priorEpoch + 1 && j("World recovery requires the next claimed Room epoch");
+				let e = a.worldRecoveryEpoch ?? a.priorEpoch;
+				(e > a.priorEpoch || e < a.priorEpoch && !i) && j("Older World recovery requires active checkpoint adoption authority"), i && de(i, a);
+			} catch {
+				return D.fail(new n({ detail: "Invalid World Room recovery scope" }));
+			}
+			let o = C(w("id", a.roomId), w("tenantId", a.tenantId)), c = C(w("roomId", a.roomId), w("tenantId", a.tenantId)), u = async (e) => {
+				await h(e, [a.roomId], a.tenantId);
+				let t = await e.query({
+					table: s,
+					predicate: o,
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				}), n = t[0];
+				return t.length === 1 && n.hostId === a.hostId && n.epoch === a.epoch && ["creating", "live"].includes(String(n.state)) && n.erasure == null && n.snapshotErasure == null || j("World recovery lost its claimed Room owner"), n;
+			}, d = async (t, n) => {
+				if ([...be.values()].filter((e) => e.instances.some((e) => e.room === n.name)).length) {
+					[...be.values()].some((e) => e.zones.some((e) => e.room === n.name)) && j("World recovery Room has ambiguous zone and instance declarations");
+					let r = await t.query({
+						table: e,
+						predicate: c,
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					}), i = r[0];
+					r.length === 1 && i || j("World recovery requires one durable instance placement");
+					let o = z(M(i.worldId, 120)), s = N(i.epoch);
+					return (!o.instances.some((e) => e.id === i.instance && e.room === n.name) || ![
+						"creating",
+						"live",
+						"hibernated"
+					].includes(String(i.state)) || (s === a.epoch ? i.hostId !== a.hostId : s < (a.worldRecoveryEpoch ?? a.priorEpoch) || s > a.priorEpoch || n.state !== "creating")) && j("World recovery instance escaped its checkpoint baseline and claimed Room"), await g(t, o, n, !0), {
+						cell: i,
+						epoch: s,
+						instance: !0,
+						table: e
+					};
+				}
+				let r = await t.query({
+					table: _,
+					predicate: c,
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				r.length !== 1 && j("World recovery requires one durable cell placement");
+				let i = r[0], o = z(M(i.worldId, 120)), s = N(i.epoch);
+				return (o.zones.find((e) => e.id === i.zoneId)?.room !== n.name || ![
+					"creating",
+					"live",
+					"hibernated"
+				].includes(String(i.state)) || (s === a.epoch ? i.hostId !== a.hostId : s < (a.worldRecoveryEpoch ?? a.priorEpoch) || s > a.priorEpoch || n.state !== "creating")) && j("World recovery cell escaped its checkpoint baseline and claimed Room"), await g(t, o, n, !0), {
+					cell: i,
+					epoch: s,
+					instance: !1,
+					table: _
+				};
+			}, f = async (e, n, r = !1) => {
+				let i = await e.query({
+					table: O,
+					predicate: c,
+					order: [{
+						column: "entityId",
+						direction: "asc"
+					}],
+					take: A + 1,
+					skip: void 0,
+					projection: void 0,
+					...r ? { lock: "update" } : {}
+				});
+				if (i.length > A) throw new t({
+					budget: "worldRecoveryRows",
+					limit: A
+				});
+				for (let e of i) {
+					let t = H(e);
+					t.tenantId === a.tenantId && t.roomId === a.roomId && [n, a.epoch].includes(t.epoch) || j("World recovery entity escaped its claimed scope");
+				}
+				return i;
+			};
+			return G("recover", a, () => I(async () => {
+				i && de(i, a);
+				let e = await v.transactional(async (e) => {
+					let t = await u(e), { epoch: n } = await d(e, t), r = await f(e, n);
+					for (let n of new Set(r.map((e) => M(e.worldId, 120)))) await g(e, z(n), t, !0);
+					return {
+						rows: r,
+						epoch: n
+					};
+				}), t = /* @__PURE__ */ new Set();
+				for (let n of e.rows) {
+					if (n.epoch === a.epoch || n.activeTransitionId === null) continue;
+					L || j("World recovery needs configured transition authority");
+					let r = await v.query({
+						table: l,
+						predicate: C(w("tenantId", a.tenantId), w("id", M(n.activeTransitionId))),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0
+					});
+					r.length !== 1 && j("World recovery transition receipt is missing");
+					let o = Z(r[0]);
+					if ((o.entityId !== n.entityId || o.source.roomId !== a.roomId || o.source.epoch !== e.epoch) && j("World recovery transition escaped its prior owner"), o.group) {
+						if (t.has(o.group.key)) continue;
+						R || j("World recovery requires complete group cancellation authority"), t.add(o.group.key);
+						let e = await v.query({
+							table: l,
+							predicate: C(w("tenantId", a.tenantId), w("groupKey", o.group.key)),
+							order: [{
+								column: "id",
+								direction: "asc"
+							}],
+							take: R.maxRows + 1,
+							skip: void 0,
+							projection: void 0
+						});
+						(e.length !== o.group.size || e.length > R.maxRows) && j("World recovery group membership is incomplete");
+						let n = e.map(Z);
+						Ne || j("World recovery requires actual group compensation");
+						let r = Ne(Object.freeze(n), i);
+						D.isEffect(r) || j("World recovery compensation must return an Effect"), await D.runPromise(r);
+					} else {
+						Ne || j("World recovery requires actual transition compensation");
+						let e = Ne(Object.freeze([o]), i);
+						D.isEffect(e) || j("World recovery compensation must return an Effect"), await D.runPromise(e);
+					}
+				}
+				await v.transactional(async (e) => {
+					let t = await u(e), { cell: n, epoch: r, instance: i, table: o } = await d(e, t), s = await f(e, r, !0), c = B();
+					for (let o of s) {
+						let s = H(o);
+						if (s.worldId === n.worldId && (i || s.zoneId === n.zoneId && s.cellId === n.cellId && s.layer === n.layer) || j("World recovery requires matching cells and reconciled transitions"), s.epoch === a.epoch) continue;
+						(o.activeTransitionId !== null || s.epoch !== r || s.revision === 2147483647 || c < s.updatedAt || t.state !== "creating") && j("World entity recovery lost its prior revision or unpublished owner");
+						let l = Object.freeze({
+							...s,
+							epoch: a.epoch,
+							revision: s.revision + 1,
+							updatedAt: c
+						});
+						await e.updateMany("_voltro_world_entities", {
+							epoch: l.epoch,
+							revision: l.revision,
+							updatedAt: new Date(c)
+						}, { where: C(ke(s), w("epoch", s.epoch), w("revision", s.revision), w("activeTransitionId", null)) }) !== 1 && j("World entity recovery lost its SQL CAS"), await Re(e, l, "recover");
+					}
+					let l = N(t.clients, 0);
+					if (n.epoch !== a.epoch || n.state !== t.state || n.players !== l) {
+						let r = N(n.revision);
+						(r === 2147483647 || n.epoch !== a.epoch && t.state !== "creating") && j("World cell recovery cannot replace a published owner"), await e.updateMany(o, {
+							hostId: a.hostId,
+							epoch: a.epoch,
+							revision: r + 1,
+							players: l,
+							state: t.state,
+							updatedAt: new Date(c)
+						}, { where: C(w("id", n.id), w("tenantId", a.tenantId), w("revision", r), w("epoch", n.epoch)) }) !== 1 && j("World cell recovery lost its SQL CAS");
+					}
+				});
+			}));
+		},
+		admitActorNeighbor: wt,
+		admitActorProjection: Ct,
+		admitActorPlayer: Tt,
+		create: ze,
+		observe: Be,
+		persist: (e) => Ue("persist", e),
+		persistBatch: Ge,
+		persistBatchFromCommand: qe,
+		capturePersistence: (e) => {
+			let t = K("persist", e);
+			return Object.freeze({
+				input: Object.freeze({
+					...t.captured,
+					source: X(t.source)
+				}),
+				cellId: t.source.cellId
+			});
+		},
+		persistenceBatchRows: A,
+		transfer: (e) => Ue("transfer", e),
+		transferFromCommand: Je,
+		onErase: (e, t) => {
+			let r;
+			try {
+				r = Lt(e, t);
+			} catch {
+				return D.fail(new n({ detail: "Invalid World entity erasure scope" }));
+			}
+			return G("erase", r, () => D.suspend(() => {
+				let e;
+				try {
+					e = Me(r);
+				} catch {
+					return D.fail(new n({ detail: "World entity quiescence refused admission" }));
+				}
+				return D.isEffect(e) ? e.pipe(D.flatMap(() => I(() => v.transactional(async (e) => {
+					if (Pe === void 0) {
+						let t = await e.query({
+							table: O,
+							predicate: Rt(r),
+							order: [],
+							take: we + 1,
+							skip: void 0,
+							projection: ["transitionRecordedAt"],
+							lock: "update"
+						});
+						(t.length > we || t.some((e) => e.transitionRecordedAt !== null)) && j("World entity erasure requires its configured transition privacy source");
+					}
+					Pe !== void 0 && await e.deleteMany(l, { where: Rt(r) }), await e.deleteMany(k, { where: Rt(r) }), await e.deleteMany(O, { where: Rt(r) });
+				})))) : D.fail(new n({ detail: "World entity erasure requires actual quiescence" }));
+			}));
+		},
+		onExport: (e, i) => {
+			let a;
+			try {
+				a = Lt(e, i);
+			} catch {
+				return D.fail(new n({ detail: "Invalid World entity export scope" }));
+			}
+			return G("export", a, () => I(() => v.transactional(async (e) => {
+				let n = await e.query({
+					table: O,
+					predicate: Rt(a),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: we + 1,
+					skip: void 0,
+					projection: void 0
+				}), i = await e.query({
+					table: k,
+					predicate: Rt(a),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: Te + 1,
+					skip: void 0,
+					projection: void 0
+				}), o = Pe === void 0 ? [] : await e.query({
+					table: l,
+					predicate: Rt(a),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: Pe + 1,
+					skip: void 0,
+					projection: void 0
+				});
+				if (n.length > we || i.length > Te) throw new t({
+					budget: "worldEntityPrivacyRows",
+					limit: n.length > we ? we : Te
+				});
+				if (Pe === void 0 && n.some((e) => e.transitionRecordedAt !== null) && j("World entity export requires its configured transition privacy source"), Pe !== void 0 && o.length > Pe) throw new t({
+					budget: "worldTransitionPrivacyRows",
+					limit: Pe
+				});
+				let s = (e) => ((e.tenantId !== a.tenantId || e.subject?.id !== a.subject.id || e.subject.kind !== a.subject.kind) && j("World entity export escaped its Subject scope"), e);
+				return Object.freeze([
+					...n.map((e) => s(H(e))),
+					...i.map((e) => {
+						let t = r(e.snapshot, xe);
+						P(t, [
+							"tenantId",
+							"entityId",
+							"subject",
+							"kind",
+							"worldId",
+							"zoneId",
+							"cellId",
+							"layer",
+							"roomId",
+							"epoch",
+							"revision",
+							"data",
+							"updatedAt",
+							"returnAnchor"
+						]);
+						let n = Oe(t.subject);
+						(!Number.isSafeInteger(t.updatedAt) || t.updatedAt < 0 || t.updatedAt > 864e13) && j("Invalid World journal time");
+						let i = s(H({
+							...t,
+							subjectId: n?.id ?? null,
+							subjectKind: n?.kind ?? null,
+							updatedAt: new Date(t.updatedAt)
+						}));
+						return e.tenantId === i.tenantId && e.entityId === i.entityId && e.revision === i.revision && e.subjectId === n?.id && e.subjectKind === n?.kind && [
+							"create",
+							"persist",
+							"transfer",
+							"recover"
+						].includes(String(e.operation)) || j("Contradictory World journal scope"), Object.freeze({
+							operation: e.operation,
+							snapshot: i
+						});
+					}),
+					...o.map((e) => {
+						let t = Z(e);
+						return (t.origin.tenantId !== a.tenantId || t.subject?.id !== a.subject.id || t.subject.kind !== a.subject.kind) && j("World transition export escaped its Subject scope"), Object.freeze({
+							operation: "transition",
+							transition: t
+						});
+					})
+				]);
+			})));
+		},
+		pruneJournal: (e, t) => {
+			let r;
+			try {
+				P(e, ["tenantId", "entityId"]), r = De(e), (!Number.isSafeInteger(t) || t < 0 || t > B()) && j("Invalid World journal retention cutoff");
+			} catch {
+				return D.fail(new n({ detail: "Invalid World journal retention scope" }));
+			}
+			return G("pruneJournal", r, () => I(() => v.transactional(async (e) => {
+				let n = C(ke(r), ve("createdAt", new Date(t)), w("requestKey", null)), i = await e.query({
+					table: k,
+					predicate: n,
+					order: [{
+						column: "revision",
+						direction: "asc"
+					}, {
+						column: "id",
+						direction: "asc"
+					}],
+					take: Te,
+					skip: void 0,
+					projection: [
+						"id",
+						"tenantId",
+						"entityId"
+					],
+					lock: "update"
+				});
+				if (!i.length) return 0;
+				let a = i.map((e) => ((e.tenantId !== r.tenantId || e.entityId !== r.entityId) && j("World journal retention escaped its entity scope"), M(e.id))), o = await e.deleteMany(k, { where: C(n, he("id", a)) });
+				return o !== i.length && j("World journal retention lost its selected rows"), o;
+			})));
+		},
+		transitionsEnabled: L !== void 0,
+		transitions: L === void 0 ? void 0 : Object.freeze({
+			begin: ct,
+			advance: Ft,
+			observe: Ze,
+			scanSourceTransitions: dt,
+			retainActorSnapshot: jt,
+			retainActorDeparture: Mt,
+			finalizeActorSnapshot: Nt,
+			admitActorSeat: xt,
+			withActorFollower: Et,
+			admitActorGhost: Dt,
+			admitActorTarget: Ot,
+			admitActorSource: At,
+			admitActorSourceRecovery: kt,
+			observeActorReceipt: bt,
+			batchCommitRows: A,
+			beginGroup: vt,
+			observeGroupCommand: ut,
+			scanGroupCommands: ft,
+			acknowledgeGroupCommand: pt,
+			proceedGroup: _t,
+			commitBatch: It,
+			bindGroup: at,
+			advanceGroup: ot,
+			requiresGroupReadiness: R?.readiness !== void 0,
+			readyMember: rt,
+			confirmGroupReady: it
+		})
+	});
+}, Me = (e) => Object.freeze({
+	extendSchema: Object.freeze({ tables: e.transitionsEnabled ? Ee : A }),
+	subjectPrivacy: Object.freeze({
+		tables: Object.freeze(e.transitionsEnabled ? [
+			O,
+			k,
+			l
+		] : [O, k]),
+		kinds: Object.freeze(["user", "guest"])
+	}),
+	onErase: e.onErase.bind(e),
+	onExport: e.onExport.bind(e)
+}), Ne = (e, t) => {
+	t && typeof t.persistBatchFromCommand == "function" || j("World entity persistence command requires an actual source");
+	let n = M(e), r = t.persistBatchFromCommand.bind(t);
+	return Object.freeze({
+		run: Object.freeze({ [n]: (e, t) => r(e, t) }),
+		publish: Object.freeze({})
+	});
+}, L = (e, t) => {
+	t && typeof t.transferFromCommand == "function" || j("World entity transfer command requires an actual source");
+	let n = M(e), r = t.transferFromCommand.bind(t);
+	return Object.freeze({
+		run: Object.freeze({ [n]: (e, t) => r(e, t) }),
+		publish: Object.freeze({})
+	});
+};
+export { O as WORLD_ENTITIES_TABLE, k as WORLD_JOURNAL_TABLE, je as dataStoreWorldEntities, Me as worldEntitiesContribution, we as worldEntitiesTable, Ne as worldEntityPersistenceCommandBindings, A as worldEntityTables, L as worldEntityTransferCommandBindings, Te as worldJournalTable, Ee as worldTransitionTables };