@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/world.js

@@ -0,0 +1,333 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { captureWorldGeometry as t, cmsGeometry as n, importedGeometry as r, procedural as i } from "./worldGeometry.js";
+import { defaultWorldLayerPolicy as a, resolveWorldLayerPolicy as o, worldLayerMaintenance as s } from "./worldLayers.js";
+import { defaultWorldOnWorldChange as c, resolveWorldOnWorldChange as l } from "./worldChange.js";
+import { defaultWorldTransitionPolicy as u, resolveWorldTransitionPolicy as d } from "./worldTransitions.js";
+import { worldSystemContractManifest as f } from "./worldManifest.js";
+import { WorldGroupTransitionRequestSchema as p, WorldTransitionPhaseSchema as m, WorldTransitionPort as h, WorldTransitionRequestSchema as g, WorldTransitionTargetSchema as _, stageWorldGroupTransition as v, stageWorldTransition as y, worldGroupTransitionRequest as b, worldTransitionCommandBindings as x, worldTransitionPhases as S, worldTransitionRequest as C } from "./worldCommands.js";
+import { WorldInspectionSchema as w, decodeWorldInspection as T } from "./worldInspection.js";
+import { WorldClientReceiptSchema as E, WorldClientRequestIdSchema as D, WorldClientTicketSchema as O } from "./worldClientSchemas.js";
+import { makeWorldHandoffView as k } from "./worldHandoffView.js";
+import { worldRpcControls as A, worldRpcPending as ee } from "./rpcClient.js";
+import { makeWorldEntityHandoffView as j } from "./worldEntityHandoffView.js";
+import { WorldClient as M, worldClientReceipt as N, worldClientTicket as P } from "./worldClient.js";
+import { makeWorldGhostNeighborhood as F } from "./worldGhostNeighborhood.js";
+import { makeWorldCellMovement as I } from "./worldMovement.js";
+import { Duration as L } from "effect";
+//#region src/world.ts
+function R(t) {
+	throw new e({
+		room: "world",
+		detail: t
+	});
+}
+var z = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,119}$/.test(e) ? e : R("World names must be nonempty bounded identifiers"), B = (e) => Number.isFinite(e) ? e : R("World coordinates must be finite"), V = (e) => Number.isFinite(e) && e > 0 ? e : R("World dimensions must be positive and finite"), H = (e, t = !1) => Number.isSafeInteger(e) && e >= +!t ? e : R("World counts and durations must be safe whole numbers"), U = (e, t) => {
+	(typeof e != "object" || !e || Object.getPrototypeOf(e) !== Object.prototype) && R("World configuration must use 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)) && R("Unknown or accessor World configuration field");
+	}
+}, W = (e, t) => {
+	(!Array.isArray(e) || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) && R("Invalid or over-budget World list");
+	for (let t = 0; t < e.length; t++) {
+		let n = Object.getOwnPropertyDescriptor(e, String(t));
+		(!n?.enumerable || !("value" in n)) && R("World lists must contain own data entries");
+	}
+}, G = (e) => (W(e, 2), e.length !== 2 && R("World points require two coordinates"), Object.freeze([B(e[0]), B(e[1])])), K = (e, t, n, r) => (B(e), B(t), B(n), B(r), V(n - e), V(r - t), Object.freeze([Object.freeze([e, t]), Object.freeze([n, r])])), q = (e) => {
+	W(e, 2), e.length !== 2 && R("World bounds require minimum and maximum");
+	let t = G(e[0]), n = G(e[1]);
+	return K(t[0], t[1], n[0], n[1]);
+}, J = (e, t) => t[0] >= e[0][0] && t[0] < e[1][0] && t[1] >= e[0][1] && t[1] < e[1][1], Y = (e) => {
+	let t = e.cells?.size;
+	return t === void 0 ? {
+		columns: 1,
+		rows: 1,
+		size: Math.max(e.bounds[1][0] - e.bounds[0][0], e.bounds[1][1] - e.bounds[0][1])
+	} : {
+		columns: Math.ceil((e.bounds[1][0] - e.bounds[0][0]) / t),
+		rows: Math.ceil((e.bounds[1][1] - e.bounds[0][1]) / t),
+		size: t
+	};
+}, X = (e) => {
+	U(e, [
+		"name",
+		"map",
+		"zones",
+		"instances",
+		"persistence",
+		"handoff",
+		"spawn",
+		"hosts",
+		"characters",
+		"transitionCooldownMs",
+		"budgets",
+		"strategies",
+		"geometry"
+	]);
+	let n = z(e.name), r = Object.hasOwn(e, "geometry") ? t(e.geometry, n) : void 0;
+	U(e.map, ["bounds"]);
+	let i = Object.freeze({ bounds: q(e.map.bounds) });
+	e.budgets !== void 0 && U(e.budgets, [
+		"maxZones",
+		"maxCells",
+		"maxInstances"
+	]);
+	let o = Object.freeze({
+		maxZones: H(e.budgets?.maxZones ?? 256),
+		maxCells: H(e.budgets?.maxCells ?? 65536),
+		maxInstances: H(e.budgets?.maxInstances ?? 256)
+	});
+	W(e.zones, o.maxZones), e.zones.length || R("A World requires at least one Zone");
+	let s = /* @__PURE__ */ new Set(), l = 0, d = e.zones.map((e) => {
+		U(e, [
+			"id",
+			"bounds",
+			"room",
+			"neighbors",
+			"cells",
+			"layering"
+		]);
+		let t = z(e.id), n = z(e.room), r = q(e.bounds);
+		s.has(t) && R("Duplicate World Zone"), s.add(t), (r[0][0] < i.bounds[0][0] || r[0][1] < i.bounds[0][1] || r[1][0] > i.bounds[1][0] || r[1][1] > i.bounds[1][1]) && R("Zone bounds must stay inside the World map"), W(e.neighbors, o.maxZones);
+		let a = Object.freeze(e.neighbors.map(z));
+		(new Set(a).size !== a.length || a.includes(t)) && R("Zone neighbors must be unique and exclude itself"), e.cells !== void 0 && U(e.cells, ["size"]);
+		let c = e.cells === void 0 ? void 0 : Object.freeze({ size: V(e.cells.size) });
+		e.layering !== void 0 && U(e.layering, [
+			"maxPlayers",
+			"splitAt",
+			"mergeBelow"
+		]);
+		let u = e.layering === void 0 ? void 0 : Object.freeze({
+			maxPlayers: H(e.layering.maxPlayers),
+			splitAt: H(e.layering.splitAt),
+			mergeBelow: H(e.layering.mergeBelow, !0)
+		});
+		u !== void 0 && (u.mergeBelow >= u.splitAt || u.splitAt >= u.maxPlayers) && R("Layering requires mergeBelow < splitAt < maxPlayers");
+		let d = Object.freeze({
+			id: t,
+			room: n,
+			bounds: r,
+			neighbors: a,
+			...c === void 0 ? {} : { cells: c },
+			...u === void 0 ? {} : { layering: u }
+		}), f = Y(d), p = f.columns * f.rows;
+		return (!Number.isSafeInteger(p) || p < 1 || p > o.maxCells - l) && R("World cell inventory exceeds its authoring budget"), l += p, d;
+	});
+	for (let e of d) for (let t of e.neighbors) {
+		let n = d.find((e) => e.id === t);
+		(!n || !n.neighbors.includes(e.id)) && R("World neighbors must exist and be reciprocal");
+	}
+	for (let e = 0; e < d.length; e++) for (let t = e + 1; t < d.length; t++) {
+		let n = d[e].bounds, r = d[t].bounds;
+		Math.max(n[0][0], r[0][0]) < Math.min(n[1][0], r[1][0]) && Math.max(n[0][1], r[0][1]) < Math.min(n[1][1], r[1][1]) && R("World Zone interiors must not overlap");
+	}
+	W(e.instances ?? [], o.maxInstances);
+	let f = /* @__PURE__ */ new Set(), p = (e.instances ?? []).map((e) => {
+		U(e, [
+			"id",
+			"room",
+			"maxGroups",
+			"ttl"
+		]);
+		let t = z(e.id), n = z(e.room);
+		(f.has(t) || s.has(t)) && R("World Instance identifiers must be unique"), f.add(t);
+		let r;
+		try {
+			r = L.toMillis(e.ttl);
+		} catch {
+			return R("Invalid World Instance duration");
+		}
+		return Object.freeze({
+			id: t,
+			room: n,
+			maxGroups: H(e.maxGroups),
+			ttlMs: H(r)
+		});
+	});
+	U(e.persistence, [
+		"entities",
+		"snapshotEveryMs",
+		"journal"
+	]), (e.persistence.entities !== "world" || typeof e.persistence.journal != "boolean") && R("Invalid World persistence policy");
+	let m = Object.freeze({
+		entities: "world",
+		snapshotEveryMs: H(e.persistence.snapshotEveryMs),
+		journal: e.persistence.journal
+	});
+	U(e.handoff, ["marginUnits", "ghostUnits"]);
+	let h = Object.freeze({
+		marginUnits: V(e.handoff.marginUnits),
+		ghostUnits: V(e.handoff.ghostUnits)
+	});
+	h.marginUnits > h.ghostUnits && R("Handoff margin cannot exceed the ghost range"), typeof e.spawn != "function" && R("World spawn requires an author-owned function"), e.hosts !== void 0 && U(e.hosts, ["pool"]);
+	let g = e.hosts === void 0 ? void 0 : Object.freeze({ pool: z(e.hosts.pool) }), _ = e.characters ?? "shared";
+	_ !== "shared" && _ !== "per-world" && R("Invalid World character policy"), e.strategies !== void 0 && U(e.strategies, [
+		"layerPolicy",
+		"transitionPolicy",
+		"onWorldChange"
+	]);
+	let v = e.strategies?.layerPolicy ?? a, y = e.strategies?.transitionPolicy ?? u, b = e.strategies?.onWorldChange ?? c;
+	return typeof b != "function" && R("World change requires a synchronous strategy"), (typeof v != "function" || typeof y != "function") && R("World policies require synchronous strategies"), Object.freeze({
+		_tag: "WorldDescriptor",
+		name: n,
+		map: i,
+		zones: Object.freeze(d),
+		instances: Object.freeze(p),
+		persistence: m,
+		handoff: h,
+		spawn: e.spawn,
+		...r === void 0 ? {} : { geometry: r },
+		...g === void 0 ? {} : { hosts: g },
+		characters: _,
+		transitionCooldownMs: H(e.transitionCooldownMs ?? 2e3, !0),
+		budgets: o,
+		cellCount: l,
+		strategies: Object.freeze({
+			layerPolicy: v,
+			transitionPolicy: y,
+			onWorldChange: b
+		})
+	});
+}, Z = /* @__PURE__ */ new WeakSet(), Q = (e) => {
+	if (Z.has(e)) return;
+	let n = [e], r = /* @__PURE__ */ new Set();
+	for (; n.length > 0;) {
+		let e = n.pop();
+		if (typeof e != "object" || !e || r.has(e)) continue;
+		r.add(e), Object.isFrozen(e) || R("World catalogue definitions must be deeply immutable");
+		let t = Reflect.ownKeys(e);
+		Array.isArray(e) ? W(e, e.length) : U(e, t.filter((e) => typeof e == "string"));
+		for (let r of t) {
+			if (Array.isArray(e) && r === "length") continue;
+			let t = Object.getOwnPropertyDescriptor(e, r);
+			(!t?.enumerable || !("value" in t)) && R("World catalogue definitions require own data"), n.push(t.value);
+		}
+	}
+	try {
+		for (let t of [
+			"name",
+			"map",
+			"zones",
+			"instances",
+			"persistence",
+			"handoff",
+			"spawn",
+			"characters",
+			"transitionCooldownMs",
+			"budgets",
+			"cellCount",
+			"strategies"
+		]) Object.hasOwn(e, t) || R("Incomplete immutable World descriptor");
+		U(e.strategies, [
+			"layerPolicy",
+			"transitionPolicy",
+			"onWorldChange"
+		]);
+		for (let t of [
+			"layerPolicy",
+			"transitionPolicy",
+			"onWorldChange"
+		]) {
+			let n = Object.getOwnPropertyDescriptor(e.strategies, t);
+			(!n || !("value" in n) || typeof n.value != "function") && R("World descriptor requires complete policy slots");
+		}
+		U(e.budgets, [
+			"maxZones",
+			"maxCells",
+			"maxInstances"
+		]), H(e.budgets.maxZones), H(e.budgets.maxCells), H(e.budgets.maxInstances), W(e.instances, e.budgets.maxInstances);
+		let n = e.instances.map((e) => (U(e, [
+			"id",
+			"room",
+			"maxGroups",
+			"ttlMs"
+		]), {
+			id: e.id,
+			room: e.room,
+			maxGroups: e.maxGroups,
+			ttl: H(e.ttlMs)
+		})), r = X({
+			name: e.name,
+			map: e.map,
+			zones: e.zones,
+			instances: n,
+			persistence: e.persistence,
+			handoff: e.handoff,
+			spawn: e.spawn,
+			...e.hosts === void 0 ? {} : { hosts: e.hosts },
+			characters: e.characters,
+			transitionCooldownMs: e.transitionCooldownMs,
+			budgets: e.budgets,
+			strategies: e.strategies,
+			...Object.hasOwn(e, "geometry") ? { geometry: t(e.geometry, e.name) } : {}
+		});
+		(r.cellCount !== H(e.cellCount) || r.characters !== e.characters || r.transitionCooldownMs !== H(e.transitionCooldownMs, !0)) && R("World descriptor contradicts its captured topology");
+	} catch {
+		R("World catalogue descriptor failed topology admission");
+	}
+	Z.add(e);
+}, te = (e, t = 256) => {
+	H(t), W(e, t);
+	let n = /* @__PURE__ */ new Set(), r = e.map((e) => {
+		U(e, [
+			"_tag",
+			"name",
+			"map",
+			"zones",
+			"instances",
+			"persistence",
+			"handoff",
+			"spawn",
+			"hosts",
+			"characters",
+			"transitionCooldownMs",
+			"budgets",
+			"cellCount",
+			"strategies",
+			"geometry"
+		]), (e._tag !== "WorldDescriptor" || !Object.isFrozen(e)) && R("World catalogue requires immutable definitions"), Q(e);
+		let t = z(e.name);
+		return n.has(t) && R("Duplicate configured World"), n.add(t), e;
+	});
+	return Object.freeze(r);
+}, ne = (e, t) => {
+	let n = G(t);
+	return e.zones.find((e) => J(e.bounds, n)) ?? R("Position has no World Zone");
+}, $ = (e, t) => {
+	U(t, ["zone", "at"]);
+	let n = G(t.at), r = e.zones.find((e) => e.id === t.zone);
+	if (!r || !J(r.bounds, n)) return R("Position is outside its declared World Zone");
+	let i = Y(r), a = (e, t, n) => {
+		let r = 0, a = n;
+		for (; r + 1 < a;) {
+			let n = r + Math.floor((a - r) / 2);
+			e < t + n * i.size ? a = n : r = n;
+		}
+		return r;
+	}, o = a(n[0], r.bounds[0][0], i.columns), s = a(n[1], r.bounds[0][1], i.rows), c = r.bounds[0][0] + o * i.size, l = r.bounds[0][1] + s * i.size;
+	return Object.freeze({
+		id: `${r.id}:${o}:${s}`,
+		zone: r.id,
+		column: o,
+		row: s,
+		bounds: K(c, l, Math.min(r.bounds[0][0] + (o + 1) * i.size, r.bounds[1][0]), Math.min(r.bounds[0][1] + (s + 1) * i.size, r.bounds[1][1]))
+	});
+}, re = (e, t, n) => {
+	let r = e.zones.find((e) => e.id === t), i = typeof n == "string" ? n.split(":") : [];
+	if (!r || i.length < 3 || i.slice(0, -2).join(":") !== r.id) return R("Cell is not in its declared World Zone");
+	let a = Y(r), o = Number(i[i.length - 2]), s = Number(i[i.length - 1]);
+	if (!/^(0|[1-9][0-9]*)$/.test(i[i.length - 2]) || !/^(0|[1-9][0-9]*)$/.test(i[i.length - 1]) || o >= a.columns || s >= a.rows) return R("Cell is not in its declared World Zone");
+	let c = $(e, {
+		zone: r.id,
+		at: [r.bounds[0][0] + o * a.size, r.bounds[0][1] + s * a.size]
+	});
+	return c.id === n ? c : R("Cell is not in its declared World Zone");
+}, ie = (e, t) => {
+	let n = e.spawn({ player: t });
+	return U(n, ["zone", "at"]), $(e, n), Object.freeze({
+		zone: n.zone,
+		at: G(n.at)
+	});
+};
+//#endregion
+export { M as WorldClient, E as WorldClientReceiptSchema, D as WorldClientRequestIdSchema, O as WorldClientTicketSchema, p as WorldGroupTransitionRequestSchema, w as WorldInspectionSchema, m as WorldTransitionPhaseSchema, h as WorldTransitionPort, g as WorldTransitionRequestSchema, _ as WorldTransitionTargetSchema, te as captureWorldCatalog, n as cmsGeometry, T as decodeWorldInspection, a as defaultWorldLayerPolicy, c as defaultWorldOnWorldChange, u as defaultWorldTransitionPolicy, X as defineWorld, r as importedGeometry, I as makeWorldCellMovement, j as makeWorldEntityHandoffView, F as makeWorldGhostNeighborhood, k as makeWorldHandoffView, i as procedural, K as rect, o as resolveWorldLayerPolicy, l as resolveWorldOnWorldChange, d as resolveWorldTransitionPolicy, v as stageWorldGroupTransition, y as stageWorldTransition, $ as worldCellAt, re as worldCellById, N as worldClientReceipt, P as worldClientTicket, b as worldGroupTransitionRequest, s as worldLayerMaintenance, A as worldRpcControls, ee as worldRpcPending, ie as worldSpawn, f as worldSystemContractManifest, x as worldTransitionCommandBindings, S as worldTransitionPhases, C as worldTransitionRequest, ne as worldZoneAt };

package/dist/worldActorReceipts.js

@@ -0,0 +1,48 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { captureWorldData as n } from "./worldData.js";
+//#region src/worldActorReceipts.ts
+var r = (r, i = 4096) => {
+	if (!Number.isSafeInteger(i) || i < 1 || i > 4096 || !Array.isArray(r)) throw new t({ detail: "Invalid World actor receipt budget or inventory" });
+	if (r.length > i) throw new e({
+		budget: "worldActorReceipts",
+		limit: i
+	});
+	let a = n(r, 1048576), o = /* @__PURE__ */ new Set();
+	for (let e of a) {
+		if (!e || Object.keys(e).some((e) => ![
+			"requestId",
+			"operation",
+			"fingerprint",
+			"projection"
+		].includes(e)) || typeof e.requestId != "string" || !e.requestId || e.requestId.length > 191 || o.has(e.requestId) || ![
+			"enter",
+			"exit",
+			"ghost"
+		].includes(e.operation) || typeof e.fingerprint != "string" || !/^[0-9a-f]{64}$/.test(e.fingerprint)) throw new t({ detail: "Invalid World actor receipt" });
+		if (e.projection !== void 0) {
+			let n = e.projection;
+			if (!n || typeof n != "object" || Array.isArray(n)) throw new t({ detail: "Invalid retained World ghost projection" });
+			let r = n.location, i = n.entity;
+			if (e.operation !== "ghost" || !/^wghost-[0-9a-f]{64}:ghost$/.test(e.requestId) || Object.keys(n).some((e) => ![
+				"entity",
+				"location",
+				"expiresAt"
+			].includes(e)) || n.expiresAt !== void 0 && (!Number.isSafeInteger(n.expiresAt) || n.expiresAt < 0) || !i || typeof i != "object" || Array.isArray(i) || typeof i.id != "string" || !i.id || i.id.length > 191 || !r || Object.keys(r).length !== 6 || ![
+				r.worldId,
+				r.zoneId,
+				r.roomId
+			].every((e) => typeof e == "string" && e.length > 0 && e.length <= 191) || ![r.epoch, r.layer].every((e) => Number.isSafeInteger(e) && e > 0) || !Array.isArray(r.at) || r.at.length !== 2 || !r.at.every((e) => typeof e == "number" && Number.isFinite(e))) throw new t({ detail: "Invalid retained World ghost projection" });
+		}
+		o.add(e.requestId);
+	}
+	return a;
+}, i = (e) => {
+	let n = (e) => Array.isArray(e) ? e.map(n) : e && typeof e == "object" ? Object.fromEntries(Object.keys(e).sort().map((t) => [t, n(e[t])])) : e, r = JSON.stringify(n(e));
+	if (typeof r != "string") throw new t({ detail: "World actor identity requires captured JSON data" });
+	return r;
+}, a = async (e) => {
+	let t = new TextEncoder().encode(i(e)), n = await globalThis.crypto.subtle.digest("SHA-256", t);
+	return Array.from(new Uint8Array(n), (e) => e.toString(16).padStart(2, "0")).join("");
+};
+//#endregion
+export { r as captureWorldActorReceipts, i as worldActorCanonicalJson, a as worldActorFingerprint };

package/dist/worldActorTransferSnapshot.js

@@ -0,0 +1,14 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { worldActorCanonicalJson as n } from "./worldActorReceipts.js";
+//#region src/worldActorTransferSnapshot.ts
+var r = (n, r) => {
+	let i = t(n, r);
+	if (!i || typeof i != "object" || Object.keys(i).length !== 3 || !Number.isSafeInteger(i.schemaHash) || i.schemaHash < 0 || i.schemaHash > 4294967295 || !Array.isArray(i.bytes) || !i.bytes.length || !i.bytes.every((e) => Number.isInteger(e) && e >= 0 && e <= 255) || !i.entity || typeof i.entity != "object" || Array.isArray(i.entity) || typeof i.entity.id != "string" || !i.entity.id || i.entity.id.length > 191) throw new e({ detail: "World actor transfer requires bounded actual codec bytes and source entity" });
+	return i;
+}, i = (i, a, o) => {
+	let s = t(i, o), c = r(a, o);
+	if (n(s) !== n(c.entity)) throw new e({ detail: "World source requires final snapshot reconciliation before rollback" });
+};
+//#endregion
+export { i as assertWorldActorSnapshotSource, r as captureWorldActorTransferSnapshot };

package/dist/worldAdmissionPending.js

@@ -0,0 +1,8 @@
+//#region src/worldAdmissionPending.ts
+var e = class extends Error {
+	constructor() {
+		super("World reconnect discard must be checkpointed before admission"), this.name = "WorldAdmissionPending";
+	}
+};
+//#endregion
+export { e as WorldAdmissionPending };

package/dist/worldBoundaryCoordinator.js

@@ -0,0 +1,148 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { simulationOwnData as n } from "./simulationAuthoring.js";
+import { captureWorldData as r } from "./worldData.js";
+import { captureWorldCatalog as i, worldCellAt as a } from "./world.js";
+import { Effect as o } from "effect";
+import { randomUUID as s } from "node:crypto";
+//#region src/worldBoundaryCoordinator.ts
+var c = () => new t({ detail: "World boundary coordination requires its bounded actual source and exact durable requests" }), l = (t, l, u) => {
+	let d = [
+		"tenantId",
+		"roomId",
+		"epoch",
+		"world",
+		"maxPending",
+		"maxEntriesPerTurn",
+		"maxBytes",
+		"prepareTtlMs",
+		"epochNow"
+	];
+	n(u, d, d);
+	let { tenantId: f, roomId: p, epoch: m, maxPending: h, maxEntriesPerTurn: g, maxBytes: _, prepareTtlMs: v } = u, y = i([u.world])[0], b = u.epochNow.bind(u);
+	if (![f, p].every((e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(e)) || !Number.isSafeInteger(m) || m < 1 || !Number.isSafeInteger(h) || h < 1 || h > 4095 || !Number.isSafeInteger(g) || g < 1 || g > h || !Number.isSafeInteger(_) || _ < 1 || _ > 16777216 || !Number.isSafeInteger(v) || v < 1 || v > 3e5) throw c();
+	let x = t.scanWorldSourceTransitions.bind(t), S = t.captureWorldBoundaryIntents.bind(t), C = l.prepare.bind(l), w = l.commit.bind(l), T = l.cancel.bind(l), E = l.resume.bind(l), D = l.status.bind(l), O = /* @__PURE__ */ new Map(), k = `boundary-${s()}`, A = 0, j = -1, M = 0, N = !1, P, F = () => {
+		let e = b();
+		if (!Number.isSafeInteger(e) || e < 0 || e < j || e > 2 ** 53 - 1 - v) throw c();
+		return j = e, e;
+	}, I = (e, t) => JSON.stringify(e) === JSON.stringify(t), L = (e, t) => {
+		let n = r(e, _);
+		if (n.origin.tenantId !== f || n.origin.roomId !== p || n.source.epoch !== m || n.source.worldId !== y.name || n.source.roomId !== p || n.mode !== "seamless" || n.group || n.intent.entityId !== n.entityId || n.intent.options.reason !== "boundary" || n.intent.target.kind !== "cell" || t && (!I(n.origin, t.origin) || !I(n.intent, t.intent))) throw c();
+		return n;
+	}, R = (t, n) => {
+		if (!O.has(t) && O.size >= h) throw new e({
+			budget: "worldBoundaryPending",
+			limit: h
+		});
+		r([...O.entries()].filter(([e]) => e !== t).map(([, e]) => e).concat(n), _), O.set(t, n);
+	}, z = (e, t, n) => {
+		let r = L(n, t);
+		return R(e, {
+			...t,
+			record: r,
+			commitStarted: t.commitStarted || r.actorFinalSnapshot !== void 0 || ["committed", "settled"].includes(r.phase)
+		}), O.get(e);
+	}, B = (e) => o.isEffect(e) ? o.runPromise(e) : Promise.reject(c()), V = (e, t) => e.entityId !== t.entityId || e.target.kind !== "cell" || t.intent.target.kind !== "cell" || e.target.zone !== t.target.zoneId || t.target.worldId !== y.name ? !1 : a(y, {
+		zone: e.target.zone,
+		at: e.target.at
+	}).id === a(y, {
+		zone: t.target.zoneId,
+		at: t.target.at
+	}).id, H = async () => {
+		let e = [], t = /* @__PURE__ */ new Set(), n = await x(p, f, m, y.name, h, _);
+		if (N) return;
+		for (let e of n) {
+			if (t.add(e.entityId), e.mode !== "seamless" || e.group || e.intent.options.reason !== "boundary") continue;
+			let n = L(e), r = O.get(n.entityId);
+			if (r && !I(r.origin, n.origin)) throw c();
+			let i = r ?? {
+				origin: n.origin,
+				intent: n.intent,
+				createdAt: n.createdAt,
+				commitStarted: !1
+			};
+			z(n.entityId, i, n);
+		}
+		let i;
+		try {
+			if ([...O.values()].some((e) => e.commitStarted || e.record?.phase === "failed") || (i = await S(p, f, m, y.name)), i) {
+				if (i.epoch !== m || i.intents.length > h) throw c();
+				r(i, _);
+			}
+		} catch (t) {
+			e.push(t);
+		}
+		if (N) return;
+		if (i) for (let e of i.intents) {
+			if (O.has(e.intention.entityId) || t.has(e.intention.entityId)) continue;
+			if (O.size >= h) break;
+			if (A >= 2 ** 53 - 1) throw c();
+			let n = r(e.intention, _);
+			R(n.entityId, {
+				origin: Object.freeze({
+					tenantId: f,
+					roomId: p,
+					requestId: `${k}-${++A}`
+				}),
+				intent: n,
+				createdAt: F(),
+				commitStarted: !1
+			});
+		}
+		let a = [...O.keys()], o = a.slice(M % Math.max(1, a.length)).concat(a.slice(0, M % Math.max(1, a.length))).slice(0, g);
+		M = a.length ? (M + o.length) % a.length : 0;
+		for (let t of o) {
+			if (N) break;
+			let n = O.get(t);
+			try {
+				n = n.record ? z(t, n, await B(D(n.origin))) : z(t, n, await B(C(n.intent, n.origin)));
+				let e = n.record;
+				if (N) break;
+				if (["settled", "rolledBack"].includes(e.phase)) {
+					await B(E(n.origin)), O.delete(t);
+					continue;
+				}
+				if (e.phase === "failed") n = z(t, n, await B(T(n.origin, e.failure ?? "boundary_expired")));
+				else if (n.commitStarted || e.phase === "committed") n = z(t, n, await B(w(n.origin)));
+				else if (F() - n.createdAt >= v) n = z(t, n, await B(T(n.origin, "boundary_expired")));
+				else {
+					e.phase !== "switching" && (n = z(t, n, await B(C(n.intent, n.origin)))), e = n.record;
+					let i = await S(p, f, m, y.name);
+					if (i.epoch !== m || i.intents.length > h) throw c();
+					r(i, _);
+					let a = i.intents.find((e) => e.intention.entityId === t);
+					if (N) break;
+					!a || a.revision !== e.entityRevision || !V(a.intention, e) ? n = z(t, n, await B(T(n.origin, "boundary_withdrawn"))) : a.crossing && (n = {
+						...n,
+						commitStarted: !0
+					}, R(t, n), n = z(t, n, await B(w(n.origin))));
+				}
+				["settled", "rolledBack"].includes(n.record.phase) && O.delete(t);
+			} catch (t) {
+				e.push(t);
+			}
+		}
+		if (e.length) throw AggregateError(e, "World boundary operations remain retained");
+	};
+	return Object.freeze({
+		runDue: () => {
+			if (N) return Promise.resolve();
+			if (P) return P;
+			let e = Promise.resolve().then(H);
+			return P = e, e.then(() => {
+				P === e && (P = void 0);
+			}, () => {
+				P === e && (P = void 0);
+			}), e;
+		},
+		observation: () => Object.freeze({
+			closed: N,
+			busy: P !== void 0,
+			pending: O.size
+		}),
+		close: async () => {
+			N = !0, P && await P.catch(() => void 0);
+		}
+	});
+};
+//#endregion
+export { l as makeWorldBoundaryCoordinator };

package/dist/worldCatalog.js

@@ -0,0 +1,81 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { captureWorldCatalog as t } from "./world.js";
+//#region src/worldCatalog.ts
+function n(t) {
+	throw new e({
+		room: "world-catalog",
+		detail: t
+	});
+}
+var r = (e, r, i = 256) => {
+	let a = [];
+	for (let o of t(e, i)) {
+		for (let e of o.zones) {
+			let t = r.get(e.room);
+			e.layering !== void 0 && e.layering.maxPlayers !== t.maxClients && n("World layering capacity differs from its admitted Room"), a.push(Object.freeze({
+				worldId: o.name,
+				areaId: e.id,
+				kind: "zone",
+				room: t.name,
+				maxClients: t.maxClients
+			}));
+		}
+		for (let e of o.instances) {
+			let t = r.get(e.room);
+			a.push(Object.freeze({
+				worldId: o.name,
+				areaId: e.id,
+				kind: "instance",
+				room: t.name,
+				maxClients: t.maxClients
+			}));
+		}
+	}
+	return Object.freeze(a);
+}, i = async (e, r, i, o = {}) => {
+	let s = o.maxWorlds ?? 256;
+	(!Number.isSafeInteger(s) || s < 1 || !Array.isArray(e) || e.length > s || Reflect.ownKeys(e).length !== e.length + 1) && n("Invalid or over-budget World source inventory");
+	let c = [];
+	for (let t = 0; t < e.length; t++) {
+		let r = Object.getOwnPropertyDescriptor(e, String(t));
+		(!r?.enumerable || !("value" in r) || typeof r.value != "string" || r.value.length === 0 || r.value.length > 4096) && n("World source inventory requires bounded own data"), c.push(r.value);
+	}
+	let l = [];
+	for (let e of [...new Set(c)].sort()) {
+		let i = await r(e), a = Object.getOwnPropertyDescriptor(i, "default");
+		(!a || !("value" in a)) && n("World modules must default-export their immutable definition as data");
+		let o = t([a.value], s)[0];
+		l.push(Object.freeze({
+			source: e,
+			descriptor: o
+		}));
+	}
+	return new a(l, i, o);
+}, a = class {
+	entries;
+	roomReferences;
+	constructor(e, i, a = {}) {
+		let o = a.maxWorlds ?? 256;
+		(!Number.isSafeInteger(o) || o < 1 || !Array.isArray(e) || e.length > o || Reflect.ownKeys(e).length !== e.length + 1) && n("Invalid or over-budget World catalogue");
+		let s = [];
+		for (let t = 0; t < e.length; t++) {
+			let r = Object.getOwnPropertyDescriptor(e, String(t));
+			(!r || !("value" in r)) && n("World catalogue requires own entries");
+			let i = Object.getOwnPropertyDescriptor(r.value, "source"), a = Object.getOwnPropertyDescriptor(r.value, "descriptor");
+			(!i || !("value" in i) || typeof i.value != "string" || i.value.length === 0 || i.value.length > 4096 || !a || !("value" in a)) && n("Invalid World catalogue source"), s.push(Object.freeze({
+				source: i.value,
+				descriptor: a.value
+			}));
+		}
+		let c = t(s.map((e) => e.descriptor), o);
+		new Set(s.map((e) => e.source)).size !== s.length && n("Duplicate World source identity"), this.roomReferences = r(c, i, o), this.entries = Object.freeze(s.sort((e, t) => e.descriptor.name < t.descriptor.name ? -1 : +(e.descriptor.name > t.descriptor.name)));
+	}
+	get(e) {
+		return this.entries.find((t) => t.descriptor.name === e)?.descriptor ?? n("Unknown admitted World");
+	}
+	inventory() {
+		return this.entries;
+	}
+};
+//#endregion
+export { a as WorldCatalog, i as loadWorldCatalog, r as validateWorldRooms };