@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldDefaultBinding.js

@@ -0,0 +1,376 @@
+import { ProtocolError as e } from "./errors.js";
+import { bindWorldTransitionCommandHandlers as t } from "./worldCommands.js";
+import { captureWorldCatalog as n, worldCellAt as r } from "./world.js";
+import { dataStoreWorldCells as i } from "./worldCells.js";
+import { WORLD_ENTITIES_TABLE as a, dataStoreWorldEntities as o } from "./worldEntities.js";
+import { dataStoreWorldCellAllocation as s, nextWorldCellGeneration as c } from "./worldCellAllocation.js";
+import { makeWorldTransitionLeases as l } from "./worldLeases.js";
+import { remoteWorldRoomSteps as u, routedWorldRoomSteps as d } from "./worldRoomSteps.js";
+import { defaultWorldClientAuthority as f } from "./worldTransitionDefaults.js";
+import { defaultWorldComponents as p, defaultWorldGroupService as m, defaultWorldService as h, forwardedWorldTransitionExecutor as g } from "./worldDefaultService.js";
+import { defaultWorldPending as _ } from "./worldDefaultPending.js";
+import { makeWorldClientControl as v } from "./worldClientControl.js";
+import { dataStoreWorldInstanceAllocation as y } from "./worldInstanceAllocation.js";
+import { makeWorldJoin as b } from "./worldJoin.js";
+import { makeDefaultWorldGroups as x } from "./worldDefaultGroups.js";
+import { defaultWorldGroupControl as S } from "./worldDefaultGroupControl.js";
+import { defaultWorldGroupContinuation as C } from "./worldDefaultGroupContinuation.js";
+import { and as w, eq as T } from "@voltro/database";
+import { Subject as E } from "@voltro/protocol";
+import { Effect as D, Schema as O } from "effect";
+// src/worldDefaultBinding.ts
+var k = "rooms-world", A = 16384, j = 1024, M = (t) => new e({ detail: t }), N = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	return (n) => {
+		let r = t.get(n);
+		return r === void 0 && (t.size >= j && t.delete(t.keys().next().value), r = e(n), t.set(n, r)), r;
+	};
+}, P = (e, t, n, r, i = A, s) => o(e, {
+	worlds: t,
+	epochNow: n,
+	maxDataBytes: i,
+	maxJournalBytes: i * 2,
+	maxPrivacyEntities: 256,
+	maxPrivacyJournal: 4096,
+	maxBatchRows: 64,
+	authorize: () => D.void,
+	quiesceSubject: (t) => D.tryPromise({
+		try: () => e.query({
+			table: a,
+			predicate: w(T("tenantId", t.tenantId), T("subjectId", t.subject.id), T("subjectKind", t.subject.kind)),
+			order: [],
+			take: 257,
+			skip: void 0,
+			projection: ["activeTransitionId"]
+		}),
+		catch: () => M("World Subject quiescence is unavailable")
+	}).pipe(D.flatMap((e) => e.some((e) => e.activeTransitionId != null) ? D.fail(M("World Subject still has an active transition")) : D.void)),
+	...r ? { transitions: {
+		maxPrivacyRows: 1024,
+		authorize: () => D.void,
+		...s === void 0 ? {} : { groups: s }
+	} } : {}
+}), F = (e, t, n, r, i = A) => P(e, t, n, r, i), I = (e, t) => {
+	if (!t) throw M("Only a player allocates World Rooms");
+	return O.decodeUnknownSync(E)({
+		type: "user",
+		id: t.id,
+		tenantId: e,
+		...t.kind === "guest" ? { kind: "guest" } : {}
+	});
+}, L = (e) => Object.freeze({
+	roomId: e.roomId,
+	hostId: e.hostId,
+	epoch: e.epoch
+}), R = (e, t, n, r, i) => ({
+	cell: (a, o) => D.suspend(() => {
+		let l = I(t, o), u = n.find((e) => e.name === a.worldId), d = {
+			worldId: a.worldId,
+			zoneId: a.zoneId,
+			at: a.at,
+			layer: a.layer
+		};
+		return u ? D.tryPromise({
+			try: () => c(e, t, u, d),
+			catch: () => M("World Room preparation did not complete")
+		}).pipe(D.flatMap((a) => s(e, {
+			tenantId: t,
+			worlds: n,
+			epochNow: r,
+			authorize: () => D.void,
+			authorizeRecreation: () => D.void,
+			prepare: (e) => i({
+				room: e.roomName,
+				creationKey: e.creationKey,
+				generation: e.generation,
+				hostId: e.existing?.hostId ?? void 0,
+				worldCell: {
+					worldId: e.placement.worldId,
+					zoneId: e.placement.zoneId,
+					at: [e.placement.at[0], e.placement.at[1]],
+					layer: e.placement.layer
+				}
+			}, l).pipe(D.map(L))
+		}).ensure(d, a))).pipe(D.asVoid) : D.fail(M("World Room preparation did not complete"));
+	}),
+	instance: (a, o) => D.suspend(() => {
+		let s = I(t, o);
+		return y(e, {
+			tenantId: t,
+			worlds: n,
+			epochNow: r,
+			maxManagedGroups: 1024,
+			authorize: () => D.void,
+			prepare: (e) => i({
+				room: e.roomName,
+				creationKey: e.creationKey,
+				generation: e.generation,
+				hostId: e.existing?.hostId ?? void 0,
+				worldInstance: {
+					tenantId: e.identity.tenantId,
+					worldId: e.identity.worldId,
+					instance: e.identity.instance,
+					groupId: e.identity.groupId
+				}
+			}, s).pipe(D.map(L))
+		}).ensure(a).pipe(D.asVoid);
+	})
+}), z = Object.freeze({
+	transition: "world.transition",
+	transitionGroup: "world.transitionGroup"
+}), B = (e, r) => {
+	let { store: i, catalog: a, world: o, ownership: s, epochNow: c } = e, d = n(e.worlds), y = e.maxBytes ?? 16384;
+	if (e.authority === "api" && !e.hot) throw M("World authority \"api\" needs the HotStore the Hosts verify leases against");
+	if (r && (!e.transitionsEnabled || !e.clientControls || typeof r.runWithAppServices != "function")) throw M("Default World groups need transition state, player controls and application services");
+	let w = r ? x((e) => P(i, d, c, !0, y, e)) : void 0, T = w?.entities ?? F(i, d, c, e.transitionsEnabled, y), E = !1, O = (e, t, n) => D.gen(function* () {
+		let r = o.bindAdmission;
+		if (!r) return yield* D.fail(M("World group target admission is unavailable"));
+		let i = yield* s(e.target.roomId, e.origin.tenantId).pipe(D.mapError(() => M("World group target admission is unavailable")));
+		return !i?.hostId || i.state !== "live" || i.epoch !== e.target.epoch ? yield* D.fail(M("World group target admission is unavailable")) : yield* r(i.hostId, {
+			roomId: e.target.roomId,
+			sessionId: t,
+			epoch: e.target.epoch
+		}, n).pipe(D.mapError(() => M("World group target admission is unavailable")));
+	}), A = u({
+		world: o,
+		ownership: s
+	}), j = (t) => R(i, t, d, c, (n, r) => {
+		let { hostId: i, ...a } = n;
+		return (i === void 0 ? e.selectHost(n.room, t) : D.succeed(i)).pipe(D.mapError(() => M("No Rooms Host is ready for a new World Room")), D.flatMap((e) => o.prepareRoom(e, a, r).pipe(D.mapError(() => M("World Room preparation did not complete")))));
+	}), L = N((t) => {
+		let n = j(t), u = {
+			store: i,
+			tenantId: t,
+			worlds: d,
+			catalog: a,
+			entities: T,
+			rooms: A,
+			epochNow: c,
+			maxBytes: y,
+			allocation: n,
+			seats: e.signing
+		}, x = p(u, w ? 64 : 1), C = e.authority === "host" ? g({
+			world: o,
+			ownership: s,
+			states: T.transitions
+		}) : w ? m({
+			...u,
+			leases: l(e.hot, {
+				namespace: k,
+				tenantId: t,
+				ttlMs: 3e4
+			})
+		}, w, (e) => e.ready ? O(e, e.ready.sessionId, I(t, e.subject)) : D.fail(M("World group target admission is unavailable"))).executor : h({
+			...u,
+			leases: l(e.hot, {
+				namespace: k,
+				tenantId: t,
+				ttlMs: 3e4
+			})
+		}).executor, E = x.seats, N = w && r ? S({
+			store: i,
+			tenantId: t,
+			groups: w,
+			executor: C,
+			resolve: x.resolve,
+			parties: r.parties,
+			runWithAppServices: r.runWithAppServices,
+			epochNow: c,
+			bindAdmission: O
+		}) : void 0, P = b({
+			tenantId: t,
+			worlds: d,
+			entities: T,
+			reserve: e.reserve,
+			allocateCell: (e, r) => n.cell({
+				tenantId: t,
+				...e
+			}, {
+				id: r.id,
+				kind: r.type === "user" && r.kind === "guest" ? "guest" : "user"
+			}).pipe(D.flatMap(() => H(i, d, c, t, e)))
+		}), F = v({
+			tenantId: t,
+			worlds: d,
+			executor: C,
+			seats: E,
+			join: P,
+			...N === void 0 ? {} : {
+				groupReady: N.ready,
+				groupCancel: { cancel: N.cancel }
+			},
+			...f({
+				store: i,
+				tenantId: t,
+				worlds: d,
+				epochNow: c
+			})
+		}), L = _({
+			store: i,
+			tenantId: t,
+			worlds: d,
+			observe: F.observe.bind(F)
+		});
+		return Object.freeze({
+			service: Object.freeze({
+				...F,
+				pending: L
+			}),
+			executor: C,
+			groupControl: N
+		});
+	}), B = (e) => e.type === "user" ? e.tenantId : null, V = (e, t) => {
+		let n = B(e);
+		if (!n || E) return D.fail(M("World control requires an active signed-in player binding"));
+		let r = t(L(n).service) ?? D.fail(M("World control operation is not installed"));
+		return D.suspend(() => E ? D.fail(M("World control binding is closed")) : r);
+	}, U = Object.freeze({
+		pending: (e, t) => V(t, (n) => n.pending?.(e, t)),
+		join: (e, t) => V(t, (n) => n.join?.(e, t)),
+		reservation: (e, t) => V(t, (n) => n.reservation?.(e, t)),
+		follow: (e, t) => V(t, (n) => n.follow?.(e, t)),
+		prepare: (e, t, n) => V(n, (r) => r.prepare(e, t, n)),
+		observe: (e, t) => V(t, (n) => n.observe(e, t)),
+		commit: (e, t) => V(t, (n) => n.commit(e, t)),
+		cancel: (e, t) => V(t, (n) => n.cancel(e, t))
+	}), W = r ? t(z, {
+		transition: (e, t) => D.suspend(() => E ? D.fail(M("World command binding is closed")) : L(t.tenantId).executor.prepare(e, t).pipe(D.asVoid)),
+		transitionGroup: (e, t) => D.suspend(() => {
+			let n = !E && L(t.tenantId).groupControl;
+			return n ? n.preparation.transitionGroup(e, t) : D.fail(M("World group command binding is unavailable"));
+		})
+	}) : void 0, G = w ? C({
+		store: i,
+		states: T.transitions,
+		epochNow: c,
+		control: (e) => {
+			let t = L(e).groupControl;
+			if (!t) throw M("Default World group continuation is unavailable");
+			return t;
+		}
+	}) : void 0;
+	return Object.freeze({
+		source: Object.freeze({
+			worlds: d,
+			transitionsEnabled: e.transitionsEnabled,
+			onErase: T.onErase.bind(T),
+			onExport: T.onExport.bind(T)
+		}),
+		...e.clientControls ? { clientControl: Object.freeze({
+			worlds: d,
+			service: U
+		}) } : {},
+		...W === void 0 ? {} : { commands: W },
+		...G === void 0 ? {} : { runGroupsDue: () => D.suspend(() => E ? D.fail(M("World group binding is closed")) : G.runDue()) },
+		release: () => (E = !0, Promise.resolve())
+	});
+}, V = (e) => B(e), H = (e, t, n, a, o) => D.suspend(() => {
+	let s = t.find((e) => e.name === o.worldId);
+	return s ? i(e, {
+		worlds: t,
+		epochNow: n,
+		maxListedCells: 1,
+		authorize: () => D.void
+	}).observe({
+		tenantId: a,
+		worldId: s.name,
+		zoneId: o.zoneId,
+		cellId: r(s, {
+			zone: o.zoneId,
+			at: o.at
+		}).id,
+		layer: o.layer
+	}).pipe(D.flatMap((e) => e && e.state === "live" ? D.succeed(e) : D.fail(M("World cell Room is not live")))) : D.fail(M("World is not declared"));
+}), U = (e) => {
+	let { store: t, catalog: r, epochNow: i } = e, o = n(e.worlds), s = e.maxBytes ?? 16384, c = x((e) => P(t, o, i, !0, s, e)), { entities: f } = c, p = N((t) => l(e.hot, {
+		namespace: k,
+		tenantId: t,
+		ttlMs: 3e4
+	})), h = {
+		step: () => D.fail(M("World Room is on another Host and this Host has no peer control")),
+		capture: () => D.fail(M("World Room is on another Host and this Host has no peer control"))
+	}, g = d({
+		local: e.controller,
+		ownership: e.ownership,
+		remote: {
+			step: (t, n) => D.suspend(() => {
+				let r = e.peers();
+				return r ? u({
+					world: r,
+					ownership: e.ownership
+				}).step(t, n) : h.step(t, n);
+			}),
+			capture: (t) => D.suspend(() => {
+				let n = e.peers();
+				return n ? u({
+					world: n,
+					ownership: e.ownership
+				}).capture(t) : h.capture(t);
+			})
+		}
+	}), _ = (n) => R(t, n, o, i, (t, n) => D.gen(function* () {
+		let r = e.controller();
+		if (!r) return yield* D.fail(M("World Host is not started"));
+		if (t.hostId !== void 0 && t.hostId !== r.host.id) return yield* D.fail(M("World Room preparation belongs to another Host"));
+		let i = yield* e.resolveSubject(W(n)).pipe(D.mapError(() => M("World player is not authorized"))), a = yield* D.tryPromise({
+			try: () => r.prepareWorldRoom(t.room, {}, i, t.creationKey, t.worldCell, t.generation, t.worldInstance),
+			catch: () => M("World Room preparation did not complete")
+		});
+		return {
+			roomId: a.id,
+			hostId: a.hostId,
+			epoch: a.epoch
+		};
+	})), v = (t) => D.gen(function* () {
+		let n = e.peers(), r = t.ready;
+		if (!n?.bindAdmission || !r || !t.subject) return yield* D.fail(M("World group admission is unavailable"));
+		let i = yield* e.ownership(t.target.roomId, t.origin.tenantId).pipe(D.mapError(() => M("World group admission is unavailable")));
+		return !i?.hostId || i.state !== "live" || i.epoch !== t.target.epoch || r.roomId !== t.target.roomId || r.epoch !== t.target.epoch ? yield* D.fail(M("World group admission is unavailable")) : yield* n.bindAdmission(i.hostId, {
+			roomId: r.roomId,
+			sessionId: r.sessionId,
+			epoch: r.epoch
+		}, I(t.origin.tenantId, t.subject)).pipe(D.mapError(() => M("World group admission is unavailable")));
+	}), y = N((n) => m({
+		store: t,
+		tenantId: n,
+		worlds: o,
+		catalog: r,
+		entities: f,
+		rooms: g,
+		epochNow: i,
+		maxBytes: s,
+		allocation: _(n),
+		seats: e.signing,
+		leases: p(n)
+	}, c, v).executor), b = Object.freeze({
+		...f,
+		admitActorPlayer: (e) => D.tryPromise({
+			try: () => t.query({
+				table: a,
+				predicate: w(T("tenantId", e.tenantId), T("entityId", e.entityId)),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["entityId"]
+			}),
+			catch: () => M("World player entity is unavailable")
+		}).pipe(D.flatMap((t) => t.length ? f.admitActorPlayer(e) : D.succeed(null)))
+	});
+	return Object.freeze({
+		worldEntities: b,
+		resolveWorldPlayer: (e) => e.subjectId ? D.succeed(e.subjectId) : D.fail(M("World player has no Subject")),
+		worldSteps: Object.freeze({
+			leases: p,
+			executor: y
+		})
+	});
+}, W = (e) => {
+	if (e.type !== "user") throw M("Only a player allocates World Rooms");
+	return {
+		type: "user",
+		id: e.id,
+		tenantId: e.tenantId,
+		...e.kind === "guest" ? { kind: "guest" } : {}
+	};
+};
+export { z as DEFAULT_WORLD_COMMAND_NAMES, A as WORLD_DEFAULT_MAX_BYTES, k as WORLD_LEASE_NAMESPACE, B as buildDefaultApiWorldState, V as defaultApiWorldState, U as defaultHostWorld, F as defaultWorldEntities };

package/dist/worldDefaultGroupAdmission.js

@@ -0,0 +1,81 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureRoomSessionAdmissionEvidence as t } from "./sessionAdmission.js";
+import { Effect as n } from "effect";
+// src/worldDefaultGroupAdmission.ts
+var r = () => new e({ detail: "Current World group target admission is unavailable" }), i = (e, t) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) throw r();
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	if (!n || !("value" in n)) throw r();
+	return n.value;
+}, a = (e) => {
+	if (typeof e != "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(e)) throw r();
+	return e;
+}, o = (e) => {
+	let t = a(i(i(e, "origin"), "tenantId")), n = i(e, "subject"), o = i(e, "target"), s = i(n, "kind"), c = i(o, "epoch");
+	if (s !== "guest" && s !== "user" || typeof c != "number" || !Number.isSafeInteger(c) || c < 0 || c > 2147483647) throw r();
+	return Object.freeze({
+		key: JSON.stringify([t, a(i(e, "id"))]),
+		tenantId: t,
+		subjectId: a(i(n, "id")),
+		subjectKind: s,
+		roomId: a(i(o, "roomId")),
+		epoch: c
+	});
+}, s = (e, t) => e.tenantId === t.tenantId && e.subjectId === t.subjectId && e.roomId === t.roomId && e.epoch === t.epoch, c = (e, t) => Object.keys(e).every((n) => e[n] === t[n]), l = (e) => n.suspend(() => {
+	let i = e();
+	return n.isEffect(i) ? i.pipe(n.map(t)) : n.fail(r());
+}).pipe(n.catchCause(() => n.fail(r()))), u = (e = 1024, a = 8) => {
+	if (![e, a].every((e) => Number.isSafeInteger(e) && e > 0 && e <= 16384)) throw r();
+	let u = /* @__PURE__ */ new Map(), d = 0;
+	return {
+		withScope: (t) => n.acquireUseRelease(n.sync(() => ({
+			active: !0,
+			owned: /* @__PURE__ */ new Set()
+		})), (c) => t({ read: (t, f) => {
+			let p, m;
+			try {
+				p = o(t);
+				let e = i(f, "read");
+				if (typeof e != "function") throw r();
+				m = e.bind(f);
+			} catch {
+				return n.fail(r());
+			}
+			return n.uninterruptibleMask((t) => n.gen(function* () {
+				if (!c.active || d >= e || (u.get(p.key)?.size ?? 0) >= a) return yield* n.fail(r());
+				let i = yield* t(l(m));
+				if (!c.active || !s(p, i) || d >= e || (u.get(p.key)?.size ?? 0) >= a) return yield* n.fail(r());
+				let o = Object.freeze({
+					target: p,
+					evidence: i,
+					read: m
+				}), f = u.get(p.key) ?? /* @__PURE__ */ new Set();
+				return f.add(o), u.set(p.key, f), d += 1, c.owned.add(o), i;
+			}));
+		} }), (e) => n.sync(() => {
+			e.active = !1;
+			for (let t of e.owned) {
+				let e = u.get(t.target.key);
+				e?.delete(t) && --d, e?.size === 0 && u.delete(t.target.key);
+			}
+			e.owned.clear();
+		})),
+		confirm: (e, i) => {
+			let a, d;
+			try {
+				a = o(e), d = t(i);
+			} catch {
+				return n.fail(r());
+			}
+			return n.suspend(() => {
+				if (!s(a, d)) return n.fail(r());
+				let e = [...u.get(a.key) ?? []].filter((e) => e.target.subjectKind === a.subjectKind && c(e.evidence, d)), t = (i) => {
+					let o = e[i];
+					return o ? l(o.read).pipe(n.flatMap((e) => u.get(a.key)?.has(o) && c(e, d) ? n.void : n.fail(r())), n.catchCause(() => t(i + 1))) : n.fail(r());
+				};
+				return t(0);
+			});
+		}
+	};
+};
+export { u as makeWorldGroupAdmissionScopes };

package/dist/worldDefaultGroupAppServices.js

@@ -0,0 +1,30 @@
+import { ProtocolError as e } from "./errors.js";
+import { Effect as t, Result as n } from "effect";
+// src/worldDefaultGroupAppServices.ts
+var r = () => new e({ detail: "World group application services are unavailable" }), i = (e, i) => {
+	let a = Object.getOwnPropertyDescriptor(i, "read");
+	if (typeof e != "function" || !a || !("value" in a) || typeof a.value != "function") throw r();
+	let o = a.value.bind(i);
+	return (i) => t.tryPromise({
+		try: () => e(t.gen(function* () {
+			let e = yield* t.context();
+			return yield* t.result(t.acquireUseRelease(t.sync(() => ({ active: !0 })), (n) => {
+				let a = Object.freeze({ read: (i, a) => {
+					if (!n.active) return t.fail(r());
+					let s;
+					try {
+						s = o(i, a);
+					} catch {
+						return t.fail(r());
+					}
+					return t.suspend(() => n.active && t.isEffect(s) ? s.pipe(t.provideContext(e), t.flatMap((e) => n.active ? t.succeed(e) : t.fail(r()))) : t.fail(r()));
+				} });
+				return t.suspend(() => i(a));
+			}, (e) => t.sync(() => {
+				e.active = !1;
+			})));
+		})),
+		catch: r
+	}).pipe(t.flatMap((e) => n.isSuccess(e) ? t.succeed(e.success) : t.fail(e.failure)));
+};
+export { i as worldGroupAppServices };

package/dist/worldDefaultGroupCompensation.js

@@ -0,0 +1,108 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { captureWorldTransitionGroup as n, worldTransitionGroupFromRecords as r } from "./worldTransitionGroup.js";
+import { assertWorldTransitionExecution as i, worldTransitionExecutionGroup as a } from "./worldTransitionExecutor.js";
+import { Effect as o } from "effect";
+// src/worldDefaultGroupCompensation.ts
+var s = () => new e({ detail: "Complete current World group compensation is unavailable" }), c = (e) => [
+	e.worldId,
+	e.zoneId,
+	e.at[0],
+	e.at[1],
+	e.layer,
+	e.roomId,
+	e.epoch
+], l = (e) => {
+	if (e.phase !== "failed" || !e.subject || !e.group || !e.failure) throw s();
+	return JSON.stringify(t([
+		e.id,
+		e.entityId,
+		e.revision,
+		e.entityRevision,
+		e.requestedRevision,
+		e.origin.tenantId,
+		e.origin.roomId,
+		e.origin.requestId,
+		e.subject.id,
+		e.subject.kind,
+		e.mode,
+		c(e.source),
+		c(e.target),
+		e.group.key,
+		e.group.digest,
+		e.group.ordinal,
+		e.group.boundRevision,
+		e.failure
+	], 16384));
+}, u = (e, t = 64, c = 128) => {
+	if (![t, c].every((e) => Number.isSafeInteger(e) && e > 0 && e <= 1024)) throw s();
+	let u = Object.getOwnPropertyDescriptor(e, "observe");
+	if (!u || !("value" in u) || typeof u.value != "function") throw s();
+	let d = u.value.bind(e), f = /* @__PURE__ */ new Set();
+	return {
+		withScope: (e) => o.acquireUseRelease(o.try({
+			try: () => {
+				if (f.size >= c) throw s();
+				let e = {
+					active: !0,
+					group: null,
+					frames: /* @__PURE__ */ new Map(),
+					completed: /* @__PURE__ */ new Set()
+				};
+				return f.add(e), e;
+			},
+			catch: s
+		}), (n) => e({ rollback: (e) => (c, u) => {
+			let d;
+			try {
+				d = l(c);
+			} catch {
+				return o.fail(s());
+			}
+			return o.gen(function* () {
+				if (!n.active || typeof e != "function") return yield* o.fail(s());
+				let f = yield* a(u, c, "rollback"), p, m;
+				try {
+					if (f.length > t || new Set(f.map((e) => e.id)).size !== f.length || new Set(f.map((e) => e.entityId)).size !== f.length) throw s();
+					let e = r(f);
+					if (!e || (p = JSON.stringify(e), m = new Map(f.map((e) => [e.id, l(e)])), m.get(c.id) !== d || n.group !== null && (n.group !== p || n.frames.size !== m.size || [...m].some(([e, t]) => n.frames.get(e) !== t)))) throw s();
+				} catch {
+					return yield* o.fail(s());
+				}
+				if (!n.active) return yield* o.fail(s());
+				if (n.group === null) {
+					n.group = p;
+					for (let [e, t] of m) n.frames.set(e, t);
+				}
+				let h = e(c, u);
+				if (!o.isEffect(h) || (yield* h, yield* i(u, c, "rollback"), !n.active || l(c) !== d)) return yield* o.fail(s());
+				n.completed.add(c.id);
+			}).pipe(o.catchCause(() => o.fail(s())));
+		} }), (e) => o.sync(() => {
+			e.active = !1, f.delete(e), e.frames.clear(), e.completed.clear();
+		})),
+		confirm: (e) => {
+			let i;
+			try {
+				i = n(e, t);
+			} catch {
+				return o.fail(s());
+			}
+			return o.gen(function* () {
+				let e = [];
+				for (let t of i.members) {
+					let n = yield* d(t.origin);
+					if (!n) return yield* o.fail(s());
+					e.push(n);
+				}
+				if (JSON.stringify(r(e)) !== JSON.stringify(i) || !e[0]?.failure || e.some((t) => t.failure !== e[0].failure)) return yield* o.fail(s());
+				if (e.every((e) => e.phase === "rolledBack")) return;
+				let t = new Map(e.map((e) => [e.id, l(e)]));
+				if (t.size !== e.length) return yield* o.fail(s());
+				let n = JSON.stringify(i);
+				if (![...f].some((e) => e.active && e.group === n && e.frames.size === t.size && e.completed.size === t.size && [...t].every(([t, n]) => e.completed.has(t) && e.frames.get(t) === n))) return yield* o.fail(s());
+			}).pipe(o.catchCause(() => o.fail(s())));
+		}
+	};
+};
+export { u as makeWorldGroupCompensationScopes };

package/dist/worldDefaultGroupContinuation.js

@@ -0,0 +1,95 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { WORLD_TRANSITIONS_TABLE as n } from "./identities.js";
+import { captureWorldGroupCommandReceipt as r, worldGroupCommandKey as i } from "./worldGroupCommand.js";
+import { worldTransitionGroupFromRecords as a } from "./worldTransitionGroup.js";
+import { makeWorldGroupSupervisor as o } from "./worldGroupSupervisor.js";
+import { and as s, eq as c, gt as l, neq as u, or as d } from "@voltro/database";
+import { Effect as f, Result as p } from "effect";
+// src/worldDefaultGroupContinuation.ts
+var m = () => new e({ detail: "Default World group continuation retains incomplete work" }), h = (e) => {
+	let h = null, g = !1;
+	return { runDue: () => f.suspend(() => g ? f.fail(m()) : (g = !0, f.gen(function* () {
+		let g = yield* f.tryPromise({
+			try: () => e.store.query({
+				table: n,
+				predicate: s(u("groupCommandKey", null), c("groupDriveAcknowledgedAt", null), ...h === null ? [] : [d(l("groupCommandKey", h.key), s(c("groupCommandKey", h.key), l("id", h.id)))]),
+				order: [{
+					column: "groupCommandKey",
+					direction: "asc"
+				}, {
+					column: "id",
+					direction: "asc"
+				}],
+				take: 257,
+				skip: void 0,
+				projection: [
+					"id",
+					"tenantId",
+					"groupCommandKey",
+					"groupCommandReceipt"
+				]
+			}),
+			catch: m
+		}), _ = /* @__PURE__ */ new Set(), v = 0, y = 0, b = 0, x = 0, S = 0, C = !0;
+		for (let n of g.slice(0, 256)) {
+			let s = n.id, c = n.groupCommandKey;
+			if (typeof s != "string" || !s.length || s.length > 191 || typeof c != "string" || !c.length || c.length > 64) return yield* f.fail(m());
+			if (_.has(c)) {
+				h = {
+					key: c,
+					id: s
+				}, v++;
+				continue;
+			}
+			if (y >= 32) {
+				C = !1;
+				break;
+			}
+			h = {
+				key: c,
+				id: s
+			}, v++, y++;
+			let l = yield* f.result(f.gen(function* () {
+				let s = r(t(n.groupCommandReceipt, 4096));
+				if (n.tenantId !== s.origin.tenantId || c !== i(s)) return yield* f.fail(m());
+				_.add(c);
+				let l = yield* e.states.observeGroupCommand(s.origin).pipe(f.mapError(m));
+				if (!l || !l.records.length || l.records.length > 64 || !a(l.records) || JSON.stringify(l.command) !== JSON.stringify(s)) return yield* f.fail(m());
+				if (l.records.every((e) => e.groupDriveAcknowledgedAt !== void 0)) return {
+					completed: 0,
+					waiting: 0
+				};
+				if (l.records.some((e) => e.groupDriveAcknowledgedAt !== void 0)) return yield* f.fail(m());
+				let u = e.control(s.origin.tenantId);
+				return yield* o({
+					tenantId: s.origin.tenantId,
+					maxCommands: 1,
+					maxMembers: 64,
+					maxPageBytes: 524288,
+					epochNow: e.epochNow,
+					states: {
+						scanGroupCommands: () => f.succeed({
+							groups: [l],
+							nextCursor: null
+						}),
+						acknowledgeGroupCommand: e.states.acknowledgeGroupCommand.bind(e.states)
+					},
+					preparation: u.preparation,
+					deadline: u.deadline,
+					authorize: () => f.void
+				}).runDue();
+			}).pipe(f.catchCause(() => f.fail(m()))));
+			p.isFailure(l) ? S++ : (b += l.success.completed, x += l.success.waiting);
+		}
+		return C && g.length <= 256 && (h = null), S ? yield* f.fail(m()) : Object.freeze({
+			examined: v,
+			visited: y,
+			completed: b,
+			waiting: x
+		});
+	}).pipe(f.ensuring(f.sync(() => {
+		g = !1;
+	}))))) };
+};
+export { h as defaultWorldGroupContinuation };