@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldInstances.js

@@ -0,0 +1,477 @@
+import { WORLD_INSTANCES_TABLE as e, WORLD_INSTANCE_HISTORY_TABLE as t, WORLD_INSTANCE_SCOPES_TABLE as n } from "./worldInstanceState.js";
+import { ProtocolError as r } from "./errors.js";
+import { ROOMS_TABLE as i, ROOM_CREATIONS_TABLE as a } from "./identities.js";
+import { captureWorldCatalog as o } from "./world.js";
+import { lockRoomReservationOwners as s } from "./hostClientCapacity.js";
+import { assertWorldRoomPool as c } from "./worldRoomPool.js";
+import "./worldEntities.js";
+import { and as l, eq as u, generateId as d, neq as f } from "@voltro/database";
+import { Effect as p } from "effect";
+import { createHash as m } from "node:crypto";
+// src/worldInstances.ts
+function h() {
+	throw new r({ detail: "World instance requires exact group and Room authority" });
+}
+var g = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e) ? e : h(), _ = (e, t = 1) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= 2147483647 ? e : h(), v = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return Number.isSafeInteger(t) && t >= 0 ? t : h();
+}, y = (e, t) => {
+	(!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== t.length || t.some((t) => {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		return !n?.enumerable || !("value" in n);
+	})) && h();
+}, b = (e) => m("sha256").update(JSON.stringify([
+	"world-instance-group-v1",
+	g(e.tenantId),
+	g(e.worldId, 120),
+	g(e.instance, 120),
+	g(e.groupId)
+])).digest("hex"), x = (e, t = 1) => m("sha256").update(JSON.stringify(_(t) === 1 ? ["world-instance-room-v1", b(e)] : [
+	"world-instance-room-v1",
+	b(e),
+	t
+])).digest("hex"), S = async (e, t, n) => {
+	if (_(n) < 2) return h();
+	let r = await e.query({
+		table: a,
+		predicate: l(u("tenantId", t.tenantId), u("requestKey", x(t, n - 1))),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: ["roomId"]
+	});
+	return r.length === 1 ? g(r[0].roomId) : h();
+}, C = async (e, t, n, r) => {
+	let a = await e.query({
+		table: i,
+		predicate: l(u("tenantId", t), u("id", n)),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: [
+			"name",
+			"state",
+			"clients"
+		]
+	});
+	if (a.length !== 1 || a[0].name !== r || a[0].state !== "disposed" || a[0].clients !== 0 || (await e.query({
+		table: "_voltro_world_entities",
+		predicate: l(u("tenantId", t), u("roomId", n)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length) return h();
+}, w = async (e, t, n, r) => {
+	let i = t.instances.find((e) => e.id === n.instance);
+	if (t.name !== n.worldId || !i) return h();
+	await e.transactional(async (e) => {
+		let t = await S(e, n, r);
+		await s(e, [t], n.tenantId), await C(e, n.tenantId, t, i.room);
+	});
+}, T = (e) => Object.freeze({
+	tenantId: g(e.tenantId),
+	worldId: g(e.worldId, 120),
+	instance: g(e.instance, 120),
+	groupId: g(e.groupId)
+}), E = (e) => l(u("tenantId", e.tenantId), u("worldId", e.worldId), u("instance", e.instance)), D = (e) => l(E(e), u("groupKey", b(e))), O = (t, n, r = !1) => t.query({
+	table: e,
+	predicate: D(n),
+	order: [],
+	take: 2,
+	skip: void 0,
+	projection: void 0,
+	...r ? { lock: "update" } : {}
+}), k = (e) => p.uninterruptible(p.tryPromise({
+	try: e,
+	catch: (e) => e instanceof r ? e : new r({ detail: "World instance SQL operation remains incomplete" })
+})), A = (m, w) => {
+	y(w, [
+		"worlds",
+		"epochNow",
+		"maxManagedGroups",
+		"authorize"
+	]);
+	let A = o(w.worlds), j = _(w.maxManagedGroups);
+	(j > 65536 || typeof w.epochNow != "function" || typeof w.authorize != "function") && h();
+	let M = w.epochNow.bind(w), N = w.authorize.bind(w), P = () => {
+		let e = M();
+		return Number.isSafeInteger(e) && e >= 0 ? e : h();
+	}, F = (e) => {
+		let t = A.find((t) => t.name === e.worldId), n = t?.instances.find((t) => t.id === e.instance);
+		return !t || !n || n.maxGroups > j || n.ttlMs > 2147483647 ? h() : {
+			world: t,
+			instance: n
+		};
+	}, I = (e, t) => {
+		let n = e.state, r = e.hostId, i = v(e.createdAt), a = v(e.expiresAt), o = v(e.updatedAt);
+		return e.tenantId !== t.tenantId || e.worldId !== t.worldId || e.instance !== t.instance || e.groupKey !== b(t) || ![
+			"creating",
+			"live",
+			"hibernated",
+			"retired"
+		].includes(String(n)) || a <= i || o < i || (n === "creating" || n === "live") && r === null || n === "hibernated" && r !== null || (n === "hibernated" || n === "retired") && e.players !== 0 ? h() : Object.freeze({
+			id: g(e.id),
+			tenantId: t.tenantId,
+			worldId: t.worldId,
+			instance: t.instance,
+			groupKey: b(t),
+			roomId: g(e.roomId),
+			hostId: r === null ? null : g(r),
+			generation: _(e.generation ?? 1),
+			epoch: _(e.epoch),
+			revision: _(e.revision),
+			players: _(e.players, 0),
+			state: n,
+			createdAt: i,
+			expiresAt: a,
+			updatedAt: o,
+			expired: P() >= a
+		});
+	}, L = (e, t, n) => p.suspend(() => {
+		F(t);
+		let i = N(e, t);
+		return p.isEffect(i) ? i.pipe(p.flatMap(n)) : p.fail(new r({ detail: "World instance policy must return an actual Effect" }));
+	}).pipe(p.catchCause(() => p.fail(new r({ detail: "World instance operation remains incomplete" })))), R = async (e, t) => {
+		let { instance: r } = F(t), i = await e.query({
+			table: n,
+			predicate: E(t),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (i.length > 1) return h();
+		if (!i.length) await e.insert(n, {
+			id: d({
+				kind: "typeid",
+				prefix: "wiscope"
+			}, n),
+			tenantId: t.tenantId,
+			worldId: t.worldId,
+			instance: t.instance,
+			maxGroups: r.maxGroups,
+			ttlMs: r.ttlMs
+		});
+		else if (i[0].maxGroups !== r.maxGroups || i[0].ttlMs !== r.ttlMs) return h();
+		return r;
+	}, z = async (e, t, n) => {
+		let { world: r, instance: a } = F(t);
+		n && await s(e, [t.roomId], t.tenantId);
+		let o = await e.query({
+			table: i,
+			predicate: l(u("tenantId", t.tenantId), u("id", t.roomId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			...n ? { lock: "update" } : {}
+		}), d = o[0];
+		return o.length !== 1 || !d || d.id !== t.roomId || d.tenantId !== t.tenantId || d.name !== a.room || d.epoch !== t.epoch || d.hostId !== t.hostId || _(d.clients, 0) > _(d.maxClients) ? h() : (await c(e, r, d, n), d);
+	}, B = (n, i) => {
+		let o;
+		try {
+			y(n, [
+				"tenantId",
+				"worldId",
+				"instance",
+				"groupId",
+				"roomId",
+				"hostId",
+				"epoch",
+				...Object.hasOwn(n, "generation") ? ["generation"] : []
+			]), o = Object.freeze({
+				...T(n),
+				roomId: g(n.roomId),
+				hostId: n.hostId === null ? null : g(n.hostId),
+				epoch: _(n.epoch),
+				...n.generation === void 0 ? {} : { generation: _(n.generation) }
+			});
+		} catch {
+			return p.fail(new r({ detail: "Invalid World instance publication" }));
+		}
+		let c = o.generation ?? 1, v = i && c > 1;
+		return L(v ? "reset" : i ? "prepare" : "publish", o, () => k(() => m.transactional(async (n) => {
+			let r = await R(n, o), p = await O(n, o);
+			if (p.length > 1) return h();
+			let m = v ? await S(n, o, c) : void 0;
+			if (v) {
+				let e = await n.query({
+					table: a,
+					predicate: l(u("tenantId", o.tenantId), u("requestKey", x(o, c))),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: ["roomId"]
+				});
+				if (e.length !== 1 || e[0].roomId !== o.roomId) return h();
+			}
+			await s(n, [
+				o.roomId,
+				...m ? [m] : [],
+				...p[0] ? [g(p[0].roomId)] : []
+			], o.tenantId);
+			let y = await z(n, o, !0), w = y.state, T = await O(n, o, !0), D = P();
+			if ((i ? w !== "creating" : w !== "live" && w !== "hibernated") || T.length > 1 || T.length !== p.length || T[0]?.id !== p[0]?.id) return h();
+			let k = T[0] ? I(T[0], o) : void 0, A = k?.state === "retired";
+			if (m && await C(n, o.tenantId, m, r.room), !k || A) {
+				if (!i || o.epoch !== 1 || y.clients !== 0 || k && (!v || c <= k.generation) || (await n.query({
+					table: "_voltro_world_instances",
+					predicate: l(E(o), f("state", "retired")),
+					order: [],
+					take: r.maxGroups + 1,
+					skip: void 0,
+					projection: ["id"]
+				})).length >= r.maxGroups || !Number.isSafeInteger(D + r.ttlMs) || k && (k.roomId === o.roomId || D < k.updatedAt || (await C(n, o.tenantId, k.roomId, r.room), await n.insert(t, {
+					...T[0],
+					generation: k.generation
+				}), await n.deleteMany("_voltro_world_instances", { where: l(u("id", k.id), u("revision", k.revision), u("state", "retired")) }) !== 1))) return h();
+				let a = {
+					id: d({
+						kind: "typeid",
+						prefix: "winst"
+					}, e),
+					tenantId: o.tenantId,
+					worldId: o.worldId,
+					instance: o.instance,
+					groupKey: b(o),
+					roomId: o.roomId,
+					generation: c,
+					hostId: o.hostId,
+					epoch: o.epoch,
+					revision: 1,
+					players: 0,
+					state: w,
+					createdAt: new Date(D),
+					expiresAt: new Date(D + r.ttlMs),
+					updatedAt: new Date(D)
+				};
+				return await n.insert(e, a), I(a, o);
+			}
+			let j = _(y.clients, 0);
+			if (k.roomId !== o.roomId || k.epoch > o.epoch || o.generation !== void 0 && k.generation !== c || i && k.epoch === o.epoch && k.state !== "creating" || k.revision === 2147483647 || D < k.updatedAt) return h();
+			if (k.hostId === o.hostId && k.epoch === o.epoch && k.state === w && k.players === j) return k;
+			if (k.epoch === o.epoch && k.hostId !== o.hostId && w !== "hibernated") return h();
+			let M = {
+				hostId: o.hostId,
+				epoch: o.epoch,
+				revision: k.revision + 1,
+				players: j,
+				state: w,
+				updatedAt: new Date(D)
+			};
+			return await n.updateMany("_voltro_world_instances", M, { where: l(u("id", k.id), u("revision", k.revision)) }) === 1 ? I({
+				...T[0],
+				...M
+			}, o) : h();
+		})));
+	};
+	return Object.freeze({
+		history: (e, n) => {
+			let i, a;
+			try {
+				y(e, [
+					"tenantId",
+					"worldId",
+					"instance",
+					"groupId"
+				]), i = T(e), a = _(n);
+			} catch {
+				return p.fail(new r({ detail: "Invalid World instance history identity" }));
+			}
+			return L("observe", i, () => k(async () => {
+				let e = await m.query({
+					table: t,
+					predicate: l(D(i), u("generation", a)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0
+				});
+				if (e.length > 1) return h();
+				if (!e.length) return null;
+				let n = I(e[0], i);
+				return n.state !== "retired" || n.generation !== a ? h() : n;
+			}));
+		},
+		inspect: (e) => {
+			let t;
+			try {
+				y(e, [
+					"tenantId",
+					"worldId",
+					"instance",
+					"groupId"
+				]), t = T(e);
+			} catch {
+				return p.fail(new r({ detail: "Invalid World instance inspection" }));
+			}
+			return L("observe", t, () => k(() => m.transactional(async (e) => {
+				let n = await O(e, t);
+				if (n.length > 1) return h();
+				if (!n.length) return null;
+				let r = I(n[0], t), i = await s(e, [r.roomId], t.tenantId), a = await O(e, t, !0);
+				if (a.length !== 1 || a[0].id !== r.id || a[0].revision !== r.revision) return h();
+				let o = I(a[0], t);
+				if (o.state === "retired") return Object.freeze({
+					publication: o,
+					owner: null,
+					synchronized: !1
+				});
+				let l = i.get(r.roomId), { world: u, instance: d } = F(t);
+				if (l.name !== d.room || _(l.epoch) < o.epoch || ![
+					"creating",
+					"live",
+					"hibernated",
+					"orphaned"
+				].includes(String(l.state)) || _(l.clients, 0) > _(l.maxClients)) return h();
+				let f = l.hostId === null ? null : g(l.hostId), p = _(l.epoch), m = l.state;
+				if (m === "hibernated" ? f !== null || l.clients !== 0 : f === null) return h();
+				await c(e, u, l, !0);
+				let v = o.hostId === f && o.epoch === p && o.state === m && o.players === l.clients;
+				return Object.freeze({
+					publication: o,
+					owner: Object.freeze({
+						hostId: f,
+						epoch: p,
+						state: m
+					}),
+					synchronized: v
+				});
+			})));
+		},
+		reset: (e) => {
+			let t = e && Object.getOwnPropertyDescriptor(e, "generation");
+			return !t || !("value" in t) || !Number.isSafeInteger(t.value) || t.value < 2 ? p.fail(new r({ detail: "Explicit instance reset requires a newer bounded generation" })) : B(e, !0);
+		},
+		prepare: (e) => B(e, !0),
+		publish: (e) => B(e, !1),
+		observe: (e) => {
+			let t;
+			try {
+				y(e, [
+					"tenantId",
+					"worldId",
+					"instance",
+					"groupId"
+				]), t = T(e);
+			} catch {
+				return p.fail(new r({ detail: "Invalid World instance observation" }));
+			}
+			return L("observe", t, () => k(() => m.transactional(async (e) => {
+				let n = await O(e, t);
+				if (n.length > 1) return h();
+				if (!n.length) return null;
+				let r = I(n[0], t);
+				if (r.state !== "retired") {
+					let n = await z(e, {
+						...t,
+						roomId: r.roomId,
+						hostId: r.hostId,
+						epoch: r.epoch
+					}, !1);
+					if (n.state !== r.state || n.clients !== r.players) return h();
+				}
+				return r;
+			})));
+		},
+		retire: (e) => {
+			let t;
+			try {
+				y(e, [
+					"tenantId",
+					"worldId",
+					"instance",
+					"groupId"
+				]), t = T(e);
+			} catch {
+				return p.fail(new r({ detail: "Invalid World instance retirement" }));
+			}
+			return L("retire", t, () => k(() => m.transactional(async (e) => {
+				await R(e, t);
+				let n = await O(e, t);
+				if (n.length !== 1) return h();
+				let r = I(n[0], t);
+				if (r.state === "retired") return r;
+				await s(e, [r.roomId], t.tenantId);
+				let a = await e.query({
+					table: i,
+					predicate: l(u("id", r.roomId), u("tenantId", t.tenantId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"id",
+						"tenantId",
+						"state",
+						"clients",
+						"epoch"
+					],
+					lock: "update"
+				});
+				if (a.length !== 1 || a[0].state !== "disposed" || a[0].clients !== 0 || _(a[0].epoch) < r.epoch) return h();
+				let o = await O(e, t, !0);
+				if (o.length !== 1 || o[0].id !== r.id || o[0].revision !== r.revision || (await e.query({
+					table: "_voltro_world_entities",
+					predicate: l(u("tenantId", t.tenantId), u("roomId", r.roomId)),
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: ["id"]
+				})).length) return h();
+				let c = P();
+				if (c < r.updatedAt || r.revision === 2147483647) return h();
+				let d = {
+					state: "retired",
+					players: 0,
+					revision: r.revision + 1,
+					updatedAt: new Date(c)
+				};
+				return await e.updateMany("_voltro_world_instances", d, { where: l(u("id", r.id), u("revision", r.revision)) }) === 1 ? I({
+					...n[0],
+					...d
+				}, t) : h();
+			})));
+		},
+		withAdmission: (e, t) => {
+			let n;
+			try {
+				y(e, [
+					"tenantId",
+					"worldId",
+					"instance",
+					"groupId"
+				]), n = T(e), typeof t != "function" && h();
+			} catch {
+				return p.fail(new r({ detail: "Invalid World instance admission scope" }));
+			}
+			return L("admit", n, () => k(() => m.transactional(async (e) => {
+				let r = await O(e, n);
+				if (r.length !== 1) return h();
+				let i = I(r[0], n);
+				if (i.state !== "live" || i.expired || i.hostId === null) return h();
+				let a = {
+					...n,
+					roomId: i.roomId,
+					hostId: i.hostId,
+					epoch: i.epoch
+				}, o = await z(e, a, !0), s = await O(e, n, !0);
+				if (s.length !== 1 || s[0].id !== i.id || s[0].revision !== i.revision || o.state !== "live" || o.clients !== i.players || P() >= i.expiresAt) return h();
+				let c = t(e, i);
+				if (!(c instanceof Promise)) return h();
+				let d = await c, f = await z(e, a, !0), p = await O(e, n, !0), m = P();
+				if (p.length !== 1 || m >= i.expiresAt || m < i.updatedAt || f.state !== "live") return h();
+				let g = I(p[0], n);
+				if (g.id !== i.id || g.revision !== i.revision || g.updatedAt !== i.updatedAt || g.roomId !== i.roomId || g.hostId !== i.hostId || g.epoch !== i.epoch || g.state !== i.state || g.expiresAt !== i.expiresAt || g.createdAt !== i.createdAt || g.players !== i.players) return h();
+				let v = _(f.clients, 0);
+				return v !== i.players && (i.revision === 2147483647 || await e.updateMany("_voltro_world_instances", {
+					players: v,
+					revision: i.revision + 1,
+					updatedAt: new Date(m)
+				}, { where: l(u("id", i.id), u("revision", i.revision)) }) !== 1) ? h() : d;
+			})));
+		}
+	});
+};
+export { w as assertWorldInstanceRecreation, A as dataStoreWorldInstances, x as worldInstanceCreationKey, b as worldInstanceGroupKey };

package/dist/worldJoin.js

@@ -0,0 +1,55 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldCatalog as t, worldSpawn as n } from "./world.js";
+import { Effect as r } from "effect";
+// src/worldJoin.ts
+var i = (t) => new e({ detail: t }), a = (a) => {
+	let { tenantId: o, entities: s, allocateCell: c, reserve: l } = a, u = t(a.worlds), d = (t, n) => t.pipe(r.mapError((t) => t instanceof e ? t : i(n)));
+	return Object.freeze({ join: (e, t) => r.gen(function* () {
+		if (t.type !== "user" || t.tenantId !== o || !t.id) return yield* r.fail(i("Only a signed-in player joins a World"));
+		let a = u.find((t) => t.name === e);
+		if (!a) return yield* r.fail(i("World is not declared"));
+		let f = t.id, p = t.kind === "guest" ? "guest" : "user", m = yield* d(s.observe({
+			tenantId: o,
+			entityId: f
+		}), "World entity is unavailable");
+		if (m && (m.subject?.id !== t.id || m.subject.kind !== p)) return yield* r.fail(i("World entity belongs to another player"));
+		if (!m) {
+			let e = n(a, {
+				id: t.id,
+				kind: p
+			}), l = yield* c({
+				worldId: a.name,
+				zoneId: e.zone,
+				at: e.at,
+				layer: 1
+			}, t);
+			if (yield* s.create({
+				tenantId: o,
+				entityId: f,
+				subject: {
+					id: t.id,
+					kind: p
+				},
+				kind: "player",
+				data: {},
+				location: {
+					worldId: a.name,
+					zoneId: e.zone,
+					at: e.at,
+					layer: 1,
+					roomId: l.roomId,
+					epoch: l.epoch
+				}
+			}).pipe(r.ignore), m = yield* d(s.observe({
+				tenantId: o,
+				entityId: f
+			}), "World entity is unavailable"), !m || m.subject?.id !== t.id || m.subject.kind !== p) return yield* r.fail(i("World entity could not be created"));
+		}
+		let h = yield* d(l(m.roomId, t), "World Room Seat is unavailable");
+		return Object.freeze({
+			entityId: f,
+			reservation: h
+		});
+	}) });
+};
+export { a as makeWorldJoin };

package/dist/worldLayers.js

@@ -0,0 +1,150 @@
+import { RoomAuthoringError as e } from "./errors.js";
+// src/worldLayers.ts
+function t(t) {
+	throw new e({
+		room: "world",
+		detail: t
+	});
+}
+var n = (e, n = !1) => {
+	(!Number.isSafeInteger(e) || e < +!n) && t("Invalid World layer count");
+}, r = (e, n) => {
+	typeof e == "object" && e && Object.getPrototypeOf(e) === Object.prototype || t("World layers require plain own data");
+	for (let r of Reflect.ownKeys(e)) {
+		let i = Object.getOwnPropertyDescriptor(e, r);
+		typeof r == "string" && n.includes(r) && i?.enumerable && "value" in i || t("Invalid World layer field");
+	}
+}, i = (e) => {
+	r(e, [
+		"policy",
+		"layers",
+		"groupSize",
+		"affinity",
+		"maxLayers"
+	]), r(e.policy, [
+		"maxPlayers",
+		"splitAt",
+		"mergeBelow"
+	]), n(e.policy.maxPlayers), n(e.policy.splitAt), n(e.policy.mergeBelow, !0), n(e.groupSize), n(e.maxLayers), (e.policy.mergeBelow >= e.policy.splitAt || e.policy.splitAt >= e.policy.maxPlayers) && t("Invalid World layering thresholds"), e.affinity !== null && n(e.affinity), (!Array.isArray(e.layers) || e.layers.length > e.maxLayers || Reflect.ownKeys(e.layers).length !== e.layers.length + 1) && t("Invalid World layer inventory");
+	let i = /* @__PURE__ */ new Set(), a = [];
+	for (let o = 0; o < e.layers.length; o++) {
+		let s = Object.getOwnPropertyDescriptor(e.layers, String(o));
+		s?.enumerable && "value" in s || t("World layer inventory must use own entries");
+		let c = s.value;
+		r(c, [
+			"layer",
+			"players",
+			"state"
+		]), n(c.layer), n(c.players, !0), (i.has(c.layer) || ![
+			"live",
+			"hibernated",
+			"splitting",
+			"merging"
+		].includes(c.state) || c.state === "hibernated" && c.players !== 0) && t("Duplicate or contradictory World layer observation"), i.add(c.layer), a.push(Object.freeze({
+			layer: c.layer,
+			players: c.players,
+			state: c.state
+		}));
+	}
+	return Object.freeze({
+		...e,
+		policy: Object.freeze({ ...e.policy }),
+		layers: Object.freeze(a)
+	});
+}, a = (e, t) => (e.state === "live" || e.state === "hibernated") && t.groupSize <= t.policy.maxPlayers - e.players, o = (e) => Object.freeze({
+	kind: "use",
+	layer: e.layer,
+	wake: e.state === "hibernated"
+}), s = (e) => {
+	if (e.layers.some((e) => e.state === "splitting")) return Object.freeze({
+		kind: "blocked",
+		reason: "capacity"
+	});
+	if (e.layers.length >= e.maxLayers) return Object.freeze({
+		kind: "blocked",
+		reason: "layer-budget"
+	});
+	let t = e.layers.reduce((e, t) => Math.max(e, t.layer), 0) + 1;
+	return Object.freeze(Number.isSafeInteger(t) ? {
+		kind: "create",
+		layer: t
+	} : {
+		kind: "blocked",
+		reason: "layer-budget"
+	});
+}, c = (e) => {
+	let t = i(e);
+	if (t.groupSize > t.policy.maxPlayers) return Object.freeze({
+		kind: "blocked",
+		reason: "capacity"
+	});
+	if (t.affinity !== null) {
+		let e = t.layers.find((e) => e.layer === t.affinity);
+		return e && a(e, t) ? o(e) : Object.freeze({
+			kind: "blocked",
+			reason: "affinity-unavailable"
+		});
+	}
+	let n = t.layers.filter((e) => a(e, t)).sort((e, t) => e.players - t.players || e.layer - t.layer)[0];
+	if (n && n.players <= t.policy.splitAt) return o(n);
+	let r = s(t);
+	return r.kind === "blocked" && n ? o(n) : r;
+}, l = (e, n = c) => {
+	let l = i(e);
+	typeof n != "function" && t("World layer policy requires a synchronous strategy");
+	let u;
+	try {
+		u = n(l);
+	} catch {
+		return t("World layer policy failed");
+	}
+	if (r(u, [
+		"kind",
+		"layer",
+		"wake",
+		"reason"
+	]), u.kind === "blocked") return [
+		"affinity-unavailable",
+		"capacity",
+		"layer-budget"
+	].includes(u.reason) && Reflect.ownKeys(u).length === 2 || t("Invalid World layer refusal"), Object.freeze({
+		kind: "blocked",
+		reason: u.reason
+	});
+	if (l.groupSize > l.policy.maxPlayers && t("World layer policy exceeded group capacity"), u.kind === "use") {
+		let e = l.layers.find((e) => e.layer === u.layer);
+		return (Reflect.ownKeys(u).length !== 3 || !e || !a(e, l) || u.wake !== (e.state === "hibernated") || l.affinity !== null && u.layer !== l.affinity) && t("World layer policy selected an ineligible layer"), o(e);
+	}
+	if (u.kind === "create") {
+		let e = s(l);
+		return (Reflect.ownKeys(u).length !== 2 || l.affinity !== null || e.kind !== "create" || e.layer !== u.layer) && t("World layer policy selected an invalid new layer"), e;
+	}
+	return t("Invalid World layer decision");
+}, u = (e) => {
+	r(e, [
+		"policy",
+		"layers",
+		"maxLayers"
+	]);
+	let t = i({
+		...e,
+		affinity: null,
+		groupSize: 1
+	}), n = [...t.layers].sort((e, t) => e.layer - t.layer), a = n.filter((e) => e.state === "live" || e.state === "hibernated"), o = a.find((e) => e.players >= t.policy.mergeBelow) ?? a[0], c = [];
+	for (let e of n) e.state === "merging" && e.players === 0 ? c.push(Object.freeze({
+		kind: "dispose",
+		layer: e.layer
+	})) : e.state === "live" && e.layer !== o?.layer && e.players < t.policy.mergeBelow ? c.push(Object.freeze({
+		kind: "drain",
+		layer: e.layer
+	})) : e.state === "live" && e.players === 0 && c.push(Object.freeze({
+		kind: "hibernate",
+		layer: e.layer
+	}));
+	if (a.length > 0 && a.every((e) => e.players > t.policy.splitAt)) {
+		let e = s(t);
+		e.kind === "create" && c.push(e);
+	}
+	return Object.freeze(c);
+};
+export { c as defaultWorldLayerPolicy, l as resolveWorldLayerPolicy, u as worldLayerMaintenance };