@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldCells.js

@@ -0,0 +1,488 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOMS_TABLE as t } from "./identities.js";
+import { captureWorldCatalog as n, worldCellAt as r } from "./world.js";
+import { lockRoomReservationOwners as i } from "./hostClientCapacity.js";
+import { assertWorldRoomPool as a } from "./worldRoomPool.js";
+import { and as o, eq as s, generateId as c, id as l, integer as u, neq as d, table as f, text as p, timestamp as m } from "@voltro/database";
+import { Effect as h } from "effect";
+// src/worldCells.ts
+var g = "_voltro_world_cells", _ = f(g, {
+	id: l({ prefix: "wcell" }),
+	tenantId: p().maxLength(191),
+	worldId: p().maxLength(120),
+	zoneId: p().maxLength(120),
+	cellId: p().maxLength(191),
+	layer: u(),
+	roomId: p().maxLength(191),
+	hostId: p().maxLength(191).nullable(),
+	epoch: u(),
+	revision: u(),
+	players: u(),
+	state: p().maxLength(16),
+	updatedAt: m()
+}).unique("byWorldCell", [
+	"tenantId",
+	"worldId",
+	"zoneId",
+	"cellId",
+	"layer"
+]).unique("byWorldCellRoom", ["tenantId", "roomId"]).index(["tenantId", "worldId"]).index(["hostId"]);
+function v(t) {
+	throw new e({ detail: t });
+}
+var y = (e, t = 191) => typeof e == "string" && e.length > 0 && e.length <= t && e.trim() === e ? e : v("Invalid World cell identity"), b = (e, t = !1) => typeof e == "number" && Number.isSafeInteger(e) && e >= +!!t ? e : v("Invalid World cell counter"), x = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return Number.isSafeInteger(t) && t >= 0 ? t : v("Invalid World cell timestamp");
+}, S = (e) => {
+	let t = e.state, n = e.hostId, r = b(e.players);
+	return (t !== "creating" && t !== "live" && t !== "hibernated" || t === "hibernated" && (n !== null || r !== 0) || (t === "live" || t === "creating") && n === null || t === "creating" && b(e.epoch, !0) === 1 && r !== 0) && v("Contradictory World cell observation"), Object.freeze({
+		id: y(e.id),
+		tenantId: y(e.tenantId),
+		worldId: y(e.worldId, 120),
+		zoneId: y(e.zoneId, 120),
+		cellId: y(e.cellId),
+		layer: b(e.layer, !0),
+		roomId: y(e.roomId),
+		hostId: n === null ? null : y(n),
+		epoch: b(e.epoch, !0),
+		revision: b(e.revision, !0),
+		players: r,
+		state: t,
+		updatedAt: x(e.updatedAt)
+	});
+}, C = (t) => h.uninterruptible(h.tryPromise({
+	try: t,
+	catch: (t) => t instanceof e ? t : new e({ detail: "World cell SQL operation remains incomplete" })
+})), w = (e, t) => {
+	typeof e == "object" && e && Object.getPrototypeOf(e) === Object.prototype || v("World cell requests require 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 || v("Invalid World cell request field");
+	}
+}, T = (e) => Object.freeze({
+	tenantId: y(e.tenantId),
+	worldId: y(e.worldId, 120)
+}), E = (e) => Object.freeze({
+	...T(e),
+	zoneId: y(e.zoneId, 120),
+	cellId: y(e.cellId),
+	layer: b(e.layer, !0)
+}), D = (e, t) => {
+	(e.tenantId !== t.tenantId || e.worldId !== t.worldId || e.zoneId !== t.zoneId || e.cellId !== t.cellId || e.layer !== t.layer) && v("SQL World cell escaped its exact identity scope");
+}, O = (e) => o(s("tenantId", e.tenantId), s("worldId", e.worldId), s("zoneId", e.zoneId), s("cellId", e.cellId), s("layer", e.layer)), k = (e, t, n = !1) => e.query({
+	table: g,
+	predicate: O(t),
+	order: [{
+		column: "id",
+		direction: "asc"
+	}],
+	take: 2,
+	skip: void 0,
+	projection: void 0,
+	...n ? { lock: "update" } : {}
+}), A = (l, u) => {
+	Array.isArray(u.worlds) && u.worlds.length && typeof u.authorize == "function" && typeof u.epochNow == "function" || v("World cell directory requires actual configuration and authorization");
+	let f = b(u.maxListedCells, !0), p = u.authorize, m = u.epochNow;
+	f === 2 ** 53 - 1 && v("World listing budget leaves no lookahead range");
+	let _ = /* @__PURE__ */ new Map();
+	for (let e of n(u.worlds)) _.set(e.name, e);
+	let x = (e) => _.get(e.worldId) ?? v("Unknown configured World"), A = (t, n, r) => {
+		try {
+			let i = T(n);
+			return x(i), h.suspend(() => {
+				let n = p(t, i);
+				return h.isEffect(n) ? n.pipe(h.flatMap(r)) : h.fail(new e({ detail: "World authorization must return an Effect" }));
+			});
+		} catch {
+			return h.fail(new e({ detail: "World cell scope is invalid" }));
+		}
+	}, j = async (e, n, i, c = !1) => {
+		let l = await e.query({
+			table: t,
+			predicate: o(s("id", n.roomId), s("tenantId", n.tenantId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: [
+				"id",
+				"tenantId",
+				"name",
+				"hostId",
+				"epoch",
+				"clients",
+				"maxClients",
+				"state",
+				"pool"
+			],
+			...i ? { lock: "update" } : {}
+		});
+		l.length !== 1 && v("World cell Room is missing or ambiguous");
+		let u = l[0], d = x(n), f = d.zones.find((e) => e.id === n.zoneId);
+		if (f) {
+			let e = n.cellId.split(":"), t = Number(e[1]), i = Number(e[2]);
+			(e.length !== 3 || e[0] !== f.id || !Number.isSafeInteger(t) || t < 0 || String(t) !== e[1] || !Number.isSafeInteger(i) || i < 0 || String(i) !== e[2]) && v("World cell identity does not describe its configured grid");
+			let a = f.cells?.size ?? Math.max(f.bounds[1][0] - f.bounds[0][0], f.bounds[1][1] - f.bounds[0][1]);
+			r(d, {
+				zone: f.id,
+				at: [f.bounds[0][0] + t * a, f.bounds[0][1] + i * a]
+			}).id !== n.cellId && v("World cell identity escaped its configured grid");
+		}
+		return (!f || u.id !== n.roomId || u.tenantId !== n.tenantId || u.name !== f.room || u.hostId !== n.hostId || b(u.epoch, !0) !== n.epoch || u.state !== n.state && !(c && n.state === "creating" && u.state === "live") || b(u.clients) !== n.players || n.players > b(u.maxClients, !0) || f.layering !== void 0 && b(u.maxClients, !0) !== f.layering.maxPlayers) && v("World cell observation does not match current SQL Room authority"), await a(e, d, u, i), u;
+	}, M = (t) => {
+		let n;
+		try {
+			w(t, [
+				"tenantId",
+				"worldId",
+				"zoneId",
+				"cellId",
+				"layer"
+			]), n = E(t);
+		} catch {
+			return h.fail(new e({ detail: "Invalid World cell lookup" }));
+		}
+		return A("observe", n, () => C(() => l.transactional(async (e) => {
+			let t = await k(e, n);
+			if (!t.length) return null;
+			t.length !== 1 && v("Ambiguous SQL World cell");
+			let r = S(t[0]);
+			return D(r, n), await j(e, r, !1, !0), r;
+		})));
+	}, N = (e) => M(e).pipe(h.map((e) => e?.state === "creating" ? v("Prepared World cells cannot route admissions before actual Room publication") : e)), P = (n, a) => {
+		let u, d;
+		try {
+			w(n, [
+				"tenantId",
+				"worldId",
+				"zoneId",
+				"at",
+				"layer",
+				"roomId",
+				"hostId",
+				"epoch"
+			]);
+			let e = x(T(n)), t = r(e, {
+				zone: y(n.zoneId, 120),
+				at: n.at
+			});
+			u = Object.freeze({
+				...T(n),
+				zoneId: y(n.zoneId, 120),
+				at: Object.freeze([n.at[0], n.at[1]]),
+				layer: b(n.layer, !0),
+				roomId: y(n.roomId),
+				hostId: n.hostId === null ? null : y(n.hostId),
+				epoch: b(n.epoch, !0)
+			}), d = Object.freeze({
+				...T(u),
+				zoneId: u.zoneId,
+				cellId: t.id,
+				layer: u.layer
+			});
+		} catch {
+			return h.fail(new e({ detail: "Invalid World cell publication" }));
+		}
+		return A("publish", u, () => C(() => l.transactional(async (e) => {
+			x(u).hosts !== void 0 && await i(e, [u.roomId], u.tenantId);
+			let n = await e.query({
+				table: t,
+				predicate: o(s("id", u.roomId), s("tenantId", u.tenantId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: [
+					"id",
+					"tenantId",
+					"name",
+					"hostId",
+					"epoch",
+					"clients",
+					"state"
+				],
+				lock: "update"
+			});
+			n.length !== 1 && v("World publication requires one current Room");
+			let r = n[0], l = r.state, f = m();
+			(a ? l !== "creating" : l !== "live" && l !== "hibernated") && v("World cell stage does not match the actual SQL Room lifecycle"), (!Number.isSafeInteger(f) || f < 0 || f > 864e13) && v("Invalid World directory clock");
+			let p = {
+				...d,
+				roomId: u.roomId,
+				hostId: u.hostId,
+				epoch: u.epoch,
+				players: b(r.clients),
+				state: l,
+				revision: 1,
+				id: c({
+					kind: "typeid",
+					prefix: "wcell"
+				}, g),
+				updatedAt: new Date(f)
+			}, h = S(p);
+			await j(e, h, !0);
+			let _ = await k(e, d, !0);
+			if (_.length > 1 && v("Ambiguous SQL World cell"), !_.length) return await e.insert(g, p), h;
+			let y = S(_[0]);
+			return D(y, d), (y.roomId !== u.roomId || y.epoch > u.epoch || y.revision === 2 ** 53 - 1) && v("World cell publication is already owned or exhausted"), !a && y.epoch === h.epoch && y.hostId === h.hostId && y.players === h.players && y.state === h.state ? y : a && y.epoch === u.epoch ? ((y.state !== "creating" || y.hostId !== u.hostId || y.players !== h.players) && v("World preparation cannot regress a published owner in the same epoch"), y) : (await e.updateMany("_voltro_world_cells", {
+				hostId: u.hostId,
+				epoch: u.epoch,
+				players: h.players,
+				state: h.state,
+				revision: y.revision + 1,
+				updatedAt: new Date(f)
+			}, { where: o(O(d), s("id", y.id), s("revision", y.revision)) }) !== 1 && v("World cell publication lost its SQL revision"), Object.freeze({
+				...h,
+				id: y.id,
+				revision: y.revision + 1
+			}));
+		})));
+	}, F = (e) => P(e, !0).pipe(h.map((e) => e.state === "creating" ? e : v("World cell preparation returned an unrelated stage"))), I = (e) => P(e, !1).pipe(h.map((e) => e.state === "creating" ? v("World cell publication returned an uncommitted preparation") : e)), L = (t, n = f) => {
+		let r;
+		try {
+			w(t, ["tenantId", "worldId"]), r = T(t), b(n, !0) > f && v("World cell listing exceeds its budget");
+		} catch {
+			return h.fail(new e({ detail: "Invalid World cell listing" }));
+		}
+		return A("list", r, () => C(() => l.transactional(async (e) => {
+			let t = await e.query({
+				table: g,
+				predicate: o(s("tenantId", r.tenantId), s("worldId", r.worldId), d("state", "creating")),
+				order: [{
+					column: "id",
+					direction: "asc"
+				}],
+				take: n + 1,
+				skip: void 0,
+				projection: void 0
+			});
+			t.length > n && v("World cell listing exceeds its budget");
+			let i = [];
+			for (let n of t) {
+				let t = S(n);
+				t.state === "creating" && v("SQL World routing list included an uncommitted preparation"), (t.tenantId !== r.tenantId || t.worldId !== r.worldId) && v("SQL World listing escaped its exact tenant/world scope"), await j(e, t, !1), i.push(t);
+			}
+			return Object.freeze(i);
+		})));
+	}, R = (n) => {
+		let r;
+		try {
+			w(n, [
+				"tenantId",
+				"worldId",
+				"zoneId",
+				"cellId",
+				"layer",
+				"roomId",
+				"epoch"
+			]), r = Object.freeze({
+				...E(n),
+				roomId: y(n.roomId),
+				epoch: b(n.epoch, !0)
+			});
+		} catch {
+			return h.fail(new e({ detail: "Invalid World routing removal" }));
+		}
+		return A("remove", r, () => C(() => l.transactional(async (e) => {
+			let n = await e.query({
+				table: t,
+				predicate: o(s("id", r.roomId), s("tenantId", r.tenantId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: [
+					"id",
+					"tenantId",
+					"epoch",
+					"clients",
+					"state"
+				],
+				lock: "update"
+			});
+			(n.length !== 1 || n[0].id !== r.roomId || n[0].tenantId !== r.tenantId || n[0].state !== "disposed" && n[0].state !== "faulted" || b(n[0].clients) !== 0 || b(n[0].epoch, !0) < r.epoch) && v("World routing removal requires the exact disposed or faulted empty SQL Room");
+			let i = await k(e, r, !0);
+			if (!i.length) return;
+			i.length !== 1 && v("Ambiguous World routing removal");
+			let a = S(i[0]);
+			D(a, r), (a.roomId !== r.roomId || a.epoch !== r.epoch) && v("World routing removal does not match its recorded Room epoch"), await e.deleteMany("_voltro_world_cells", { where: o(O(r), s("id", a.id), s("revision", a.revision)) }) !== 1 && v("World routing removal lost its SQL revision");
+		})));
+	}, z = (n) => {
+		let i, a;
+		try {
+			w(n, [
+				"tenantId",
+				"worldId",
+				"zoneId",
+				"at",
+				"layer",
+				"roomId",
+				"hostId",
+				"epoch"
+			]);
+			let e = x(T(n)), t = r(e, {
+				zone: y(n.zoneId, 120),
+				at: n.at
+			});
+			n.hostId === null && v("Lifecycle synchronization requires its original Host owner"), i = Object.freeze({
+				...T(n),
+				zoneId: y(n.zoneId, 120),
+				at: Object.freeze([n.at[0], n.at[1]]),
+				layer: b(n.layer, !0),
+				roomId: y(n.roomId),
+				hostId: y(n.hostId),
+				epoch: b(n.epoch, !0)
+			}), a = Object.freeze({
+				...T(i),
+				zoneId: i.zoneId,
+				cellId: t.id,
+				layer: i.layer
+			});
+		} catch {
+			return h.fail(new e({ detail: "Invalid World lifecycle synchronization" }));
+		}
+		return A("publish", i, () => C(async () => {
+			let e = await l.query({
+				table: t,
+				predicate: o(s("id", i.roomId), s("tenantId", i.tenantId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: [
+					"id",
+					"tenantId",
+					"name",
+					"hostId",
+					"epoch",
+					"clients",
+					"state"
+				]
+			});
+			(e.length !== 1 || e[0].id !== i.roomId || e[0].tenantId !== i.tenantId) && v("World lifecycle requires one exact SQL Room");
+			let n = e[0], r = n.state, c = b(n.epoch, !0), u = x(i).zones.find((e) => e.id === i.zoneId);
+			if ((!u || n.name !== u.room || c < i.epoch) && v("World lifecycle escaped its declared Room"), r === "creating" || r === "live") {
+				(n.hostId !== i.hostId || c !== i.epoch) && v("World lifecycle cannot synchronize another Host epoch"), await h.runPromise(r === "creating" ? F(i).pipe(h.as(void 0)) : I(i).pipe(h.as(void 0)));
+				return;
+			}
+			if (r === "hibernating") {
+				(n.hostId !== i.hostId || c !== i.epoch) && v("World hibernation belongs to another Host epoch");
+				return;
+			}
+			(r !== "hibernated" && r !== "disposed" && r !== "faulted" || b(n.clients) !== 0) && v("World lifecycle has no empty terminal SQL boundary");
+			let d = await k(l, a);
+			if (d.length > 1 && v("Ambiguous World lifecycle placement"), !d.length) {
+				r === "hibernated" && v("Hibernation lost its original World placement");
+				return;
+			}
+			let f = S(d[0]);
+			D(f, a), (f.roomId !== i.roomId || f.epoch > c || f.hostId !== null && (f.hostId !== i.hostId || f.epoch !== i.epoch)) && v("World lifecycle cannot retire a successor placement"), r === "hibernated" ? (n.hostId !== null && v("World hibernation has not released its SQL Host"), await h.runPromise(I({
+				...i,
+				hostId: null,
+				epoch: c
+			}).pipe(h.as(void 0)))) : await h.runPromise(R({
+				...a,
+				roomId: i.roomId,
+				epoch: f.epoch
+			}));
+		}));
+	};
+	return Object.freeze({
+		prepare: F,
+		publish: I,
+		observe: N,
+		observeRoom: (t) => {
+			let n;
+			try {
+				w(t, [
+					"tenantId",
+					"worldId",
+					"roomId"
+				]), n = Object.freeze({
+					...T(t),
+					roomId: y(t.roomId)
+				});
+			} catch {
+				return h.fail(new e({ detail: "Invalid World Room observation scope" }));
+			}
+			return A("observe", n, () => C(() => l.transactional(async (e) => {
+				let t = await e.query({
+					table: g,
+					predicate: o(s("tenantId", n.tenantId), s("worldId", n.worldId), s("roomId", n.roomId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0
+				});
+				if (t.length > 1 && v("Ambiguous World Room observation"), !t.length) return null;
+				let r = S(t[0]);
+				if ((r.tenantId !== n.tenantId || r.worldId !== n.worldId || r.roomId !== n.roomId) && v("World Room observation escaped its requested scope"), r.state !== "live") return null;
+				await j(e, r, !1);
+				let i = x(r).zones.find((e) => e.id === r.zoneId), a = r.cellId.split(":"), c = i.cells?.size ?? Math.max(i.bounds[1][0] - i.bounds[0][0], i.bounds[1][1] - i.bounds[0][1]), l = Object.freeze([i.bounds[0][0] + Number(a[1]) * c, i.bounds[0][1] + Number(a[2]) * c]);
+				return Object.freeze({
+					cell: r,
+					at: l
+				});
+			})));
+		},
+		inspect: M,
+		list: L,
+		remove: R,
+		synchronize: z,
+		synchronizeRoom: (t) => {
+			let n;
+			try {
+				w(t, [
+					"tenantId",
+					"roomId",
+					"hostId",
+					"epoch"
+				]), n = Object.freeze({
+					tenantId: y(t.tenantId),
+					roomId: y(t.roomId),
+					hostId: y(t.hostId),
+					epoch: b(t.epoch, !0)
+				});
+			} catch {
+				return h.fail(new e({ detail: "Invalid World Room lifecycle scope" }));
+			}
+			return C(async () => {
+				let e = await l.query({
+					table: g,
+					predicate: o(s("tenantId", n.tenantId), s("roomId", n.roomId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0
+				});
+				if (e.length > 1 && v("Ambiguous recorded World Room placement"), !e.length) return;
+				let t = S(e[0]);
+				(t.tenantId !== n.tenantId || t.roomId !== n.roomId) && v("World Room placement escaped its owner scope");
+				let i = x(t), a = i.zones.find((e) => e.id === t.zoneId), c = t.cellId.split(":");
+				a && c.length === 3 && c[0] === a.id || v("World Room placement has no declared zone");
+				let u = a.cells?.size ?? Math.max(a.bounds[1][0] - a.bounds[0][0], a.bounds[1][1] - a.bounds[0][1]), d = Object.freeze([a.bounds[0][0] + Number(c[1]) * u, a.bounds[0][1] + Number(c[2]) * u]);
+				r(i, {
+					zone: a.id,
+					at: d
+				}).id !== t.cellId && v("World Room placement has no canonical cell"), await h.runPromise(z({
+					...n,
+					worldId: i.name,
+					zoneId: a.id,
+					at: d,
+					layer: t.layer
+				}));
+			});
+		}
+	});
+}, j = (t, n) => {
+	try {
+		return y(t), y(n.requestId), y(n.tenantId), n.kind !== "user" && n.kind !== "guest" && v("Invalid World privacy kind"), h.void;
+	} catch {
+		return h.fail(new e({ detail: "World routing privacy requires a trusted Subject scope" }));
+	}
+}, M = Object.freeze({
+	extendSchema: Object.freeze({ tables: Object.freeze([_]) }),
+	subjectPrivacy: Object.freeze({
+		tables: Object.freeze([g]),
+		kinds: Object.freeze(["user", "guest"])
+	}),
+	onErase: (e, t) => j(e, t),
+	onExport: (e, t) => j(e, t).pipe(h.as(Object.freeze([])))
+});
+export { g as WORLD_CELLS_TABLE, A as dataStoreWorldCells, M as worldCellsContribution, j as worldCellsPrivacyScope, _ as worldCellsTable };

package/dist/worldChange.js

@@ -0,0 +1,31 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+// src/worldChange.ts
+var n = (e) => e.targetData, r = (r, i, a = n) => {
+	let o = () => {
+		throw new e({ detail: "World change policy admission refused" });
+	};
+	r && Object.getPrototypeOf(r) === Object.prototype && Reflect.ownKeys(r).length === 4 && typeof a == "function" || o();
+	for (let e of [
+		"sourceWorldId",
+		"targetWorldId",
+		"sourceData",
+		"targetData"
+	]) {
+		let t = Object.getOwnPropertyDescriptor(r, e);
+		t?.enumerable && "value" in t || o();
+	}
+	[r.sourceWorldId, r.targetWorldId].every((e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,119}$/.test(e)) && r.sourceWorldId !== r.targetWorldId || o();
+	let s = Object.freeze({
+		sourceWorldId: r.sourceWorldId,
+		targetWorldId: r.targetWorldId,
+		sourceData: t(r.sourceData, i),
+		targetData: t(r.targetData, i)
+	});
+	try {
+		return t(a(s), i);
+	} catch {
+		return o();
+	}
+};
+export { n as defaultWorldOnWorldChange, r as resolveWorldOnWorldChange };