@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/worldInspection.js

@@ -0,0 +1,109 @@
+import { WorldTransitionPhaseSchema as e } from "./worldCommands.js";
+import { Schema as t } from "effect";
+//#region src/worldInspection.ts
+var n = t.String.pipe(t.check(t.isMinLength(1)), t.check(t.isMaxLength(191)), t.check(t.makeFilter((e) => e.trim() === e))), r = t.Number.pipe(t.check(t.isInt()), t.check(t.isGreaterThanOrEqualTo(0)), t.check(t.makeFilter(Number.isSafeInteger))), i = r.pipe(t.check(t.isGreaterThan(0))), a = t.Number.pipe(t.check(t.isFinite())), o = t.Tuple([a, a]), s = t.Tuple([o, o]).pipe(t.check(t.makeFilter((e) => e[1][0] > e[0][0] && e[1][1] > e[0][1] && Number.isFinite(e[1][0] - e[0][0]) && Number.isFinite(e[1][1] - e[0][1])))), c = t.String.pipe(t.check(t.makeFilter((e) => Number.isFinite(Date.parse(e))))), l = t.Struct({
+	id: n,
+	bounds: s,
+	cellSize: t.NullOr(a.pipe(t.check(t.isGreaterThan(0)))),
+	maxPlayers: t.NullOr(i)
+}), u = t.Struct({
+	id: n,
+	bounds: s,
+	zones: t.Array(l).pipe(t.check(t.isMinLength(1)), t.check(t.isMaxLength(256))),
+	layerPolicy: t.Literals(["default", "custom"]),
+	transitionPolicy: t.Literals(["default", "custom"]),
+	worldChangePolicy: t.Literals(["default", "custom"])
+}), d = t.Struct({
+	id: n,
+	zoneId: n,
+	cellId: n,
+	layer: i,
+	bounds: s,
+	players: r,
+	epoch: i,
+	revision: i,
+	state: t.Literals([
+		"creating",
+		"live",
+		"hibernated"
+	]),
+	roomObservation: t.Literals([
+		"matching",
+		"stale",
+		"missing"
+	]),
+	updatedAt: c
+}), f = t.Struct({
+	worldId: n,
+	zoneId: n,
+	cellId: n,
+	layer: i
+}), p = t.Struct({
+	id: n,
+	mode: t.Literals(["seamless", "portal"]),
+	phase: e,
+	revision: i,
+	entityRevision: i,
+	source: f,
+	target: f,
+	createdAt: c,
+	updatedAt: c,
+	committedAt: t.NullOr(c)
+}), m = t.Struct({
+	worldState: t.Literals([
+		"none",
+		"entities",
+		"transitions"
+	]),
+	worldClientControls: t.Boolean,
+	catalog: t.Array(n).pipe(t.check(t.isMaxLength(256))),
+	page: t.Struct({
+		tenantId: n,
+		worldId: t.NullOr(n),
+		after: t.NullOr(n),
+		nextAfter: t.NullOr(n)
+	}),
+	world: t.NullOr(u),
+	cells: t.Array(d).pipe(t.check(t.isMaxLength(50))),
+	transitions: t.NullOr(t.Struct({
+		after: t.NullOr(n),
+		nextAfter: t.NullOr(n),
+		entries: t.Array(p).pipe(t.check(t.isMaxLength(50)))
+	}))
+}).pipe(t.check(t.makeFilter((e) => {
+	if (e.worldClientControls && e.worldState !== "transitions" || new Set(e.catalog).size !== e.catalog.length || new Set(e.cells.map((e) => e.id)).size !== e.cells.length || new Set(e.cells.map((e) => JSON.stringify([
+		e.zoneId,
+		e.cellId,
+		e.layer
+	]))).size !== e.cells.length) return !1;
+	if (e.world === null) return e.page.worldId === null && e.page.after === null && e.page.nextAfter === null && e.cells.length === 0 && e.transitions === null;
+	if (e.world.id !== e.page.worldId || !e.catalog.includes(e.world.id) || new Set(e.world.zones.map((e) => e.id)).size !== e.world.zones.length) return !1;
+	let t = e.world.bounds;
+	for (let n of e.world.zones) if (n.bounds[0][0] < t[0][0] || n.bounds[0][1] < t[0][1] || n.bounds[1][0] > t[1][0] || n.bounds[1][1] > t[1][1]) return !1;
+	for (let t = 0; t < e.cells.length; t++) {
+		let n = e.cells[t], r = e.world.zones.find((e) => e.id === n.zoneId);
+		if (!r || (n.state === "hibernated" || n.state === "creating" && n.epoch === 1) && n.players !== 0 || r.maxPlayers !== null && n.players > r.maxPlayers || e.page.after !== null && n.id <= e.page.after || t > 0 && e.cells[t - 1].id >= n.id) return !1;
+		let i = n.cellId.split(":"), a = Number(i[1]), o = Number(i[2]);
+		if (i.length !== 3 || i[0] !== r.id || !Number.isSafeInteger(a) || a < 0 || String(a) !== i[1] || !Number.isSafeInteger(o) || o < 0 || String(o) !== i[2]) return !1;
+		let s = r.cellSize ?? Math.max(r.bounds[1][0] - r.bounds[0][0], r.bounds[1][1] - r.bounds[0][1]), c = r.bounds[0][0] + a * s, l = r.bounds[0][1] + o * s;
+		if (!Number.isFinite(c) || !Number.isFinite(l) || c >= r.bounds[1][0] || l >= r.bounds[1][1] || n.bounds[0][0] !== c || n.bounds[0][1] !== l || n.bounds[1][0] !== Math.min(c + s, r.bounds[1][0]) || n.bounds[1][1] !== Math.min(l + s, r.bounds[1][1])) return !1;
+	}
+	if (e.page.nextAfter !== null && (e.cells.length !== 50 || e.page.nextAfter !== e.cells.at(-1)?.id)) return !1;
+	if (e.worldState !== "transitions") return e.transitions === null;
+	if (e.transitions === null) return !1;
+	let n = e.transitions;
+	if (new Set(n.entries.map((e) => e.id)).size !== n.entries.length) return !1;
+	for (let t = 0; t < n.entries.length; t++) {
+		let r = n.entries[t], i = r.phase === "committed" || r.phase === "settled";
+		if (!e.catalog.includes(r.source.worldId) || !e.catalog.includes(r.target.worldId) || r.source.worldId !== e.world.id && r.target.worldId !== e.world.id || n.after !== null && r.id <= n.after || t > 0 && n.entries[t - 1].id >= r.id || i !== (r.committedAt !== null) || Date.parse(r.updatedAt) < Date.parse(r.createdAt) || r.committedAt !== null && (Date.parse(r.committedAt) < Date.parse(r.createdAt) || Date.parse(r.committedAt) > Date.parse(r.updatedAt))) return !1;
+		for (let t of [r.source, r.target]) if (t.worldId === e.world.id) {
+			let n = e.world.zones.find((e) => e.id === t.zoneId), r = t.cellId.split(":"), i = Number(r[1]), a = Number(r[2]);
+			if (!n || r.length !== 3 || r[0] !== n.id || !Number.isSafeInteger(i) || i < 0 || String(i) !== r[1] || !Number.isSafeInteger(a) || a < 0 || String(a) !== r[2]) return !1;
+			let o = n.cellSize ?? Math.max(n.bounds[1][0] - n.bounds[0][0], n.bounds[1][1] - n.bounds[0][1]);
+			if (n.bounds[0][0] + i * o >= n.bounds[1][0] || n.bounds[0][1] + a * o >= n.bounds[1][1]) return !1;
+		}
+	}
+	return n.nextAfter === null || n.entries.length === 50 && n.nextAfter === n.entries.at(-1)?.id;
+}))), h = (e) => t.decodeUnknownSync(m)(e);
+//#endregion
+export { m as WorldInspectionSchema, h as decodeWorldInspection };

package/dist/worldInstanceAdmission.js

@@ -0,0 +1,31 @@
+import { WORLD_INSTANCES_TABLE as e } from "./worldInstanceState.js";
+import { ProtocolError as t } from "./errors.js";
+import { assertWorldRoomPool as n } from "./worldRoomPool.js";
+import { and as r, eq as i } from "@voltro/database";
+//#region src/worldInstanceAdmission.ts
+var a = async (a, o, s, c) => {
+	let l = s.flatMap((e) => e.instances.filter((e) => e.room === o.name).map((t) => ({
+		world: e,
+		instance: t
+	})));
+	if (!l.length) return;
+	let u = () => {
+		throw new t({ detail: "World instance Session requires a live unexpired owner" });
+	}, d = await a.query({
+		table: e,
+		predicate: r(i("tenantId", o.tenantId), i("roomId", o.id)),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0,
+		lock: "update"
+	}), f = d[0];
+	if (d.length !== 1 || !f || f.state !== "live" || o.state !== "live" || f.hostId !== o.hostId || f.epoch !== o.epoch) return u();
+	let p = l.find(({ world: e, instance: t }) => e.name === f.worldId && t.id === f.instance);
+	if (!p) return u();
+	await n(a, p.world, o, !1);
+	let m = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, h = m(f.createdAt), g = m(f.expiresAt), _ = c();
+	if (!Number.isSafeInteger(h) || h < 0 || !Number.isSafeInteger(g) || g - h !== p.instance.ttlMs || !Number.isSafeInteger(_) || _ < h || _ >= g) return u();
+};
+//#endregion
+export { a as assertWorldInstanceSeatAdmission };

package/dist/worldInstanceAllocation.js

@@ -0,0 +1,116 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { ROOM_CREATIONS_TABLE as n } from "./identities.js";
+import { captureWorldCatalog as r } from "./world.js";
+import { assertWorldInstanceRecreation as i, dataStoreWorldInstances as a, worldInstanceCreationKey as o } from "./worldInstances.js";
+import { and as s, eq as c } from "@voltro/database";
+import { Effect as l } from "effect";
+//#region src/worldInstanceAllocation.ts
+function u() {
+	throw new e({ detail: "Instance allocation requires exact live Host publication" });
+}
+var d = (t) => l.suspend(() => {
+	let e = t();
+	return l.isEffect(e) ? e : u();
+}).pipe(l.catchCause(() => l.fail(new e({ detail: "Instance allocation remains incomplete" })))), f = (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);
+	})) && u();
+}, p = (p, m) => {
+	f(m, [
+		"tenantId",
+		"worlds",
+		"epochNow",
+		"maxManagedGroups",
+		"authorize",
+		"prepare",
+		...Object.hasOwn(m, "wake") ? ["wake"] : []
+	]);
+	let h = r(m.worlds), g = m.tenantId;
+	(typeof g != "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(g) || typeof m.epochNow != "function" || typeof m.authorize != "function" || typeof m.prepare != "function" || m.wake !== void 0 && typeof m.wake != "function") && u();
+	let _ = m.epochNow.bind(m), v = m.authorize.bind(m), y = m.prepare.bind(m), b = m.wake?.bind(m), x = m.maxManagedGroups;
+	return a(p, {
+		worlds: h,
+		epochNow: _,
+		maxManagedGroups: x,
+		authorize: () => l.void
+	}), Object.freeze({ ensure: (r, m = 1) => {
+		let S;
+		try {
+			f(r, [
+				"tenantId",
+				"worldId",
+				"instance",
+				"groupId"
+			]), S = t(r, 4096), S.tenantId !== g && u(), o(S, m);
+		} catch {
+			return l.fail(new e({ detail: "Invalid instance allocation identity" }));
+		}
+		let C = Object.freeze({
+			identity: S,
+			generation: m
+		});
+		return d(() => l.gen(function* () {
+			let r = h.find((e) => e.name === S.worldId), w = r?.instances.find((e) => e.id === S.instance);
+			if (!r || !w) return u();
+			yield* d(() => v("allocate", C));
+			let T = a(p, {
+				worlds: h,
+				epochNow: _,
+				maxManagedGroups: x,
+				authorize: () => d(() => v("observe", C))
+			}), E = yield* T.inspect(S), D = E?.publication ?? null;
+			if (D && D.state !== "retired" && (D.generation !== m || D.expired)) return u();
+			if (D?.state === "live" && E?.synchronized) return D;
+			let O, k = E?.owner;
+			if (D && k && (k.state === "hibernated" || k.state === "orphaned" || k.epoch > 1)) {
+				if (!b) return u();
+				yield* d(() => v("wake", C));
+				let e = k.state === "hibernated" || k.state === "orphaned" ? k.epoch : k.epoch - 1;
+				if (O = t(yield* d(() => b(Object.freeze({
+					...C,
+					existing: D,
+					priorEpoch: e
+				}))), 4096), f(O, [
+					"roomId",
+					"hostId",
+					"epoch"
+				]), O.roomId !== D.roomId || O.epoch !== e + 1) return u();
+			} else {
+				if (D && (D.state !== "retired" && D.state !== "creating" || D.state === "retired" && m <= D.generation)) return u();
+				m > 1 && (yield* d(() => v("reset", C)), yield* l.tryPromise({
+					try: () => i(p, r, S, m),
+					catch: () => new e({ detail: "Instance reset predecessor is not disposed and empty" })
+				}));
+				let a = o(S, m);
+				if (O = t(yield* d(() => y(Object.freeze({
+					...C,
+					roomName: w.room,
+					creationKey: a,
+					existing: D
+				}))), 4096), f(O, [
+					"roomId",
+					"hostId",
+					"epoch"
+				]), O.epoch !== 1 || D?.state === "creating" && (O.roomId !== D.roomId || O.hostId !== D.hostId)) return u();
+				let h = yield* l.tryPromise({
+					try: () => p.query({
+						table: n,
+						predicate: s(c("tenantId", g), c("requestKey", a)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: ["roomId"]
+					}),
+					catch: () => new e({ detail: "Instance creation receipt remains unavailable" })
+				});
+				if (h.length !== 1 || h[0].roomId !== O.roomId) return u();
+			}
+			let A = yield* T.observe(S);
+			return !A || A.state !== "live" || A.expired || A.generation !== m || A.roomId !== O.roomId || A.hostId !== O.hostId || A.epoch !== O.epoch || typeof O.hostId != "string" || !O.hostId || D && D.state !== "retired" && (A.id !== D.id || A.createdAt !== D.createdAt || A.expiresAt !== D.expiresAt) ? u() : A;
+		}));
+	} });
+};
+//#endregion
+export { p as dataStoreWorldInstanceAllocation };

package/dist/worldInstanceDestination.js

@@ -0,0 +1,64 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldData as t } from "./worldData.js";
+import { worldTransitionRequest as n } from "./worldCommands.js";
+import { captureWorldCatalog as r, worldCellAt as i } from "./world.js";
+import { dataStoreWorldInstances as a } from "./worldInstances.js";
+import { Effect as o } from "effect";
+//#region src/worldInstanceDestination.ts
+var s = (s, c) => {
+	let l = [
+		"tenantId",
+		"worlds",
+		"maxDataBytes",
+		"maxManagedGroups",
+		"epochNow",
+		"authorize",
+		...Object.hasOwn(c, "prepare") ? ["prepare"] : []
+	], u = () => {
+		throw new e({ detail: "Instance destination requires an actual live group Room" });
+	};
+	(!c || Object.getPrototypeOf(c) !== Object.prototype || Reflect.ownKeys(c).length !== l.length || l.some((e) => {
+		let t = Object.getOwnPropertyDescriptor(c, e);
+		return !t?.enumerable || !("value" in t);
+	})) && u();
+	let d = r(c.worlds), f = c.tenantId, p = c.maxDataBytes;
+	(typeof f != "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(f) || !Number.isSafeInteger(p) || p < 1 || typeof c.epochNow != "function" || typeof c.authorize != "function") && u(), c.prepare !== void 0 && typeof c.prepare != "function" && u();
+	let m = c.prepare?.bind(c), h = a(s, {
+		worlds: d,
+		epochNow: c.epochNow.bind(c),
+		maxManagedGroups: c.maxManagedGroups,
+		authorize: c.authorize.bind(c)
+	});
+	return (r) => o.suspend(() => {
+		let e = n(r.intent), a = t(r.current.location, 4096), s = t(r.current.data, p), c = d.find((e) => e.name === a.worldId);
+		if (e.target.kind !== "instance" || e.options.returnTo !== "here" || !c || r.entity.returnAnchor || r.origin.tenantId !== f || r.entity.tenantId !== f || r.entity.entityId !== e.entityId || r.origin.roomId !== a.roomId || r.entity.roomId !== a.roomId || r.entity.epoch !== a.epoch || r.entity.worldId !== a.worldId || r.entity.zoneId !== a.zoneId || r.entity.layer !== a.layer || i(c, {
+			zone: a.zoneId,
+			at: a.at
+		}).id !== r.entity.cellId) return u();
+		let l = Object.freeze({
+			tenantId: f,
+			worldId: c.name,
+			instance: e.target.instance,
+			groupId: e.target.group
+		});
+		return o.gen(function* () {
+			let e = yield* h.inspect(l), t = e?.publication ?? null;
+			if (t?.expired || t?.state === "retired") return u();
+			if (!t || t.state !== "live" || !e?.synchronized) {
+				if (!m) return u();
+				let e = t, n = m(l);
+				if (!o.isEffect(n) || (yield* n) !== void 0 || (t = yield* h.observe(l), e && (!t || t.id !== e.id || t.generation !== e.generation || t.roomId !== e.roomId || t.createdAt !== e.createdAt || t.expiresAt !== e.expiresAt))) return u();
+			}
+			return !t || t.state !== "live" || t.expired || !t.hostId || t.roomId === a.roomId ? u() : Object.freeze({
+				location: Object.freeze({
+					...a,
+					roomId: t.roomId,
+					epoch: t.epoch
+				}),
+				data: s
+			});
+		});
+	}).pipe(o.catchCause(() => o.fail(new e({ detail: "SQL instance destination remains unavailable" }))));
+};
+//#endregion
+export { s as dataStoreWorldInstanceDestination };

package/dist/worldInstanceExpiry.js

@@ -0,0 +1,282 @@
+import { WORLD_INSTANCES_TABLE as e } from "./worldInstanceState.js";
+import { ProtocolError as t } from "./errors.js";
+import { captureWorldData as n } from "./worldData.js";
+import { worldTransitionRequest as r } from "./worldCommands.js";
+import { WORLD_TRANSITIONS_TABLE as i } from "./identities.js";
+import { captureWorldCatalog as a } from "./world.js";
+import { lockRoomReservationOwners as o } from "./hostClientCapacity.js";
+import { assertWorldRoomPool as s } from "./worldRoomPool.js";
+import { captureWorldEntityReturnAnchor as c } from "./worldReturnAnchor.js";
+import { WORLD_ENTITIES_TABLE as l } from "./worldEntities.js";
+import { worldInstanceGroupKey as u } from "./worldInstances.js";
+import { and as d, eq as f, gt as p, lte as m, neq as h } from "@voltro/database";
+import { Effect as g } from "effect";
+//#region src/worldInstanceExpiry.ts
+function _() {
+	throw new t({ detail: "Instance expiry inventory requires current bounded SQL authority" });
+}
+var v = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(e) ? e : _(), y = (e, t = 0) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= 2147483647 ? e : _(), b = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return Number.isSafeInteger(t) && t >= 0 ? t : _();
+}, x = (x, S) => {
+	let C = [
+		"tenantId",
+		"worlds",
+		"epochNow",
+		"maxPageRows",
+		"maxEntityRows",
+		"maxInventoryBytes",
+		"authorize"
+	];
+	(!S || Object.getPrototypeOf(S) !== Object.prototype || Reflect.ownKeys(S).length !== C.length || C.some((e) => {
+		let t = Object.getOwnPropertyDescriptor(S, e);
+		return !t?.enumerable || !("value" in t);
+	})) && _();
+	let w = v(S.tenantId), T = a(S.worlds), E = y(S.maxPageRows, 1);
+	(E > 1024 || !T.some((e) => e.instances.length) || typeof S.epochNow != "function" || typeof S.authorize != "function") && _();
+	let D = y(S.maxEntityRows, 1), O = y(S.maxInventoryBytes, 1);
+	(D > 1024 || O > 16777216) && _();
+	let k = S.epochNow.bind(S), A = S.authorize.bind(S), j = () => {
+		let e = k();
+		return Number.isSafeInteger(e) && e >= 0 ? e : _();
+	}, M = async (e, t) => {
+		let n = A(e, Object.freeze({
+			tenantId: w,
+			...t ? { instanceId: t } : {}
+		}));
+		if (!g.isEffect(n)) return _();
+		await g.runPromise(n);
+	};
+	return Object.freeze({
+		scan: (n) => {
+			let r, i;
+			try {
+				if (!n || Object.getPrototypeOf(n) !== Object.prototype || Reflect.ownKeys(n).length !== 2 || ["afterId", "limit"].some((e) => {
+					let t = Object.getOwnPropertyDescriptor(n, e);
+					return !t?.enumerable || !("value" in t);
+				}) || (r = n.afterId === null ? null : v(n.afterId), i = y(n.limit, 1), i > E)) return _();
+			} catch {
+				return g.fail(new t({ detail: "Invalid bounded instance expiry cursor" }));
+			}
+			return g.tryPromise({
+				try: async () => {
+					await M("scan");
+					let t = j(), n = await x.query({
+						table: e,
+						predicate: d(f("tenantId", w), h("state", "retired"), m("expiresAt", new Date(t)), ...r ? [p("id", r)] : []),
+						order: [{
+							column: "id",
+							direction: "asc"
+						}],
+						take: i + 1,
+						skip: void 0,
+						projection: ["id", "roomId"]
+					}), a = n.slice(0, i), c = [], l = [];
+					for (let t of a) {
+						let n = v(t.id), r = v(t.roomId);
+						try {
+							await M("inspect", n);
+							let t = await x.transactional(async (t) => {
+								let i = (await o(t, [r], w)).get(r), a = await t.query({
+									table: e,
+									predicate: d(f("tenantId", w), f("id", n)),
+									order: [],
+									take: 2,
+									skip: void 0,
+									projection: void 0,
+									lock: "update"
+								}), c = a[0];
+								if (a.length !== 1 || !c || !i || c.roomId !== r) return _();
+								if (c.state === "retired" || b(c.expiresAt) > j()) return null;
+								let l = T.find((e) => e.name === c.worldId), u = l?.instances.find((e) => e.id === c.instance), p = c.state, m = y(c.epoch, 1), h = c.hostId === null ? null : v(c.hostId);
+								return !l || !u || u.room !== i.name || i.epoch !== m || ![
+									"creating",
+									"live",
+									"hibernated"
+								].includes(String(p)) || i.hostId !== h || ![
+									"creating",
+									"live",
+									"hibernating",
+									"hibernated",
+									"disposed",
+									"faulted"
+								].includes(String(i.state)) || b(c.expiresAt) - b(c.createdAt) !== u.ttlMs || typeof c.groupKey != "string" || !/^[a-f0-9]{64}$/.test(c.groupKey) ? _() : (await s(t, l, i, !1), Object.freeze({
+									id: n,
+									tenantId: w,
+									worldId: l.name,
+									instance: u.id,
+									groupKey: c.groupKey,
+									roomId: r,
+									epoch: m,
+									hostId: h,
+									revision: y(c.revision, 1),
+									expiresAt: b(c.expiresAt),
+									players: y(i.clients),
+									state: p,
+									roomState: String(i.state)
+								}));
+							});
+							t && c.push(t);
+						} catch {
+							l.push(n);
+						}
+					}
+					return Object.freeze({
+						entries: Object.freeze(c),
+						deferred: Object.freeze(l),
+						nextCursor: n.length > i ? v(a[a.length - 1].id) : null
+					});
+				},
+				catch: () => new t({ detail: "Instance expiry SQL inventory remains unavailable" })
+			});
+		},
+		inventory: (a) => {
+			let p;
+			try {
+				if (p = n(a, 4096), p.tenantId !== w || Object.keys(p).sort().join(",") !== "epoch,expiresAt,groupKey,hostId,id,instance,players,revision,roomId,roomState,state,tenantId,worldId") return _();
+				v(p.id), v(p.roomId);
+			} catch {
+				return g.fail(new t({ detail: "Invalid instance expiry inventory identity" }));
+			}
+			return g.tryPromise({
+				try: async () => (await M("inventory", p.id), x.transactional(async (t) => {
+					let a = (await o(t, [p.roomId], w)).get(p.roomId), m = await t.query({
+						table: e,
+						predicate: d(f("tenantId", w), f("id", p.id)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					}), h = m[0], g = T.find((e) => e.name === p.worldId), x = g?.instances.find((e) => e.id === p.instance);
+					if (m.length !== 1 || !h || !a || !g || !x || x.room !== a.name || h.roomId !== p.roomId || h.worldId !== g.name || h.instance !== x.id || h.groupKey !== p.groupKey || h.revision !== p.revision || h.epoch !== p.epoch || h.state !== p.state || h.hostId !== p.hostId || h.state === "retired" || a.epoch !== p.epoch || a.hostId !== p.hostId || a.state !== p.roomState || a.clients !== p.players || b(h.expiresAt) !== p.expiresAt || b(h.expiresAt) - b(h.createdAt) !== x.ttlMs || j() < p.expiresAt) return _();
+					await s(t, g, a, !1);
+					let S = await t.query({
+						table: l,
+						predicate: d(f("tenantId", w), f("roomId", p.roomId)),
+						order: [{
+							column: "entityId",
+							direction: "asc"
+						}],
+						take: D + 1,
+						skip: void 0,
+						projection: [
+							"tenantId",
+							"entityId",
+							"subjectId",
+							"subjectKind",
+							"worldId",
+							"roomId",
+							"epoch",
+							"revision",
+							"activeTransitionId",
+							"returnAnchor"
+						],
+						lock: "update"
+					});
+					if (S.length > D) return _();
+					let C = [], E = [];
+					for (let e of S) {
+						let t = v(e.entityId), n = y(e.revision, 1);
+						if (e.tenantId !== w || e.worldId !== g.name || e.roomId !== p.roomId || e.epoch !== p.epoch) return _();
+						if (e.activeTransitionId != null) {
+							C.push({
+								entityId: t,
+								reason: "openTransition"
+							});
+							continue;
+						}
+						if (e.returnAnchor == null) {
+							C.push({
+								entityId: t,
+								reason: "missingAnchor"
+							});
+							continue;
+						}
+						if (e.subjectId === null || !["user", "guest"].includes(String(e.subjectKind))) {
+							C.push({
+								entityId: t,
+								reason: "missingSubject"
+							});
+							continue;
+						}
+						let r = c(e.returnAnchor, T);
+						if (r.instanceId !== p.id || r.instance !== p.instance || r.instanceRoomId !== p.roomId || r.groupKey !== p.groupKey || r.enteredRevision > n || r.source.worldId !== g.name) return _();
+						E.push({
+							entityId: t,
+							revision: n,
+							anchor: r,
+							subject: Object.freeze({
+								id: v(e.subjectId),
+								kind: e.subjectKind
+							})
+						});
+					}
+					let k = null, A = [];
+					for (let e of E.sort((e, t) => e.anchor.entryTransitionId < t.anchor.entryTransitionId ? -1 : +(e.anchor.entryTransitionId > t.anchor.entryTransitionId))) {
+						let a = await t.query({
+							table: i,
+							predicate: d(f("tenantId", w), f("id", e.anchor.entryTransitionId)),
+							order: [],
+							take: 2,
+							skip: void 0,
+							projection: [
+								"id",
+								"tenantId",
+								"entityId",
+								"subjectId",
+								"subjectKind",
+								"sourceRoomId",
+								"requestId",
+								"phase",
+								"mode",
+								"source",
+								"target",
+								"intent",
+								"result",
+								"entityRevision"
+							],
+							lock: "update"
+						}), o = a[0];
+						if (a.length !== 1 || !o || o.entityId !== e.entityId || o.subjectId !== e.subject.id || o.subjectKind !== e.subject.kind || o.mode !== "portal" || !["committed", "settled"].includes(String(o.phase)) || o.entityRevision !== e.anchor.enteredRevision || o.sourceRoomId !== e.anchor.source.roomId) return _();
+						let s = r(o.intent);
+						if (s.entityId !== e.entityId || s.target.kind !== "instance" || s.options.returnTo !== "here" || s.target.instance !== x.id || u({
+							tenantId: w,
+							worldId: g.name,
+							instance: x.id,
+							groupId: s.target.group
+						}) !== p.groupKey || k !== null && k !== s.target.group) return _();
+						k = s.target.group;
+						let l = n(o.result, O), m = n(o.target, 4096);
+						if (m.worldId !== g.name || m.roomId !== p.roomId || y(m.epoch, 1) > p.epoch || l.epoch !== m.epoch || l.revision !== e.anchor.enteredRevision) return _();
+						let h = c(l.returnAnchor, T), v = c({
+							...h,
+							source: o.source
+						}, T).source;
+						if (l.tenantId !== w || l.entityId !== e.entityId || l.roomId !== p.roomId || l.subject?.id !== e.subject.id || l.subject?.kind !== e.subject.kind || JSON.stringify(h) !== JSON.stringify(e.anchor) || JSON.stringify(v) !== JSON.stringify(h.source)) return _();
+						let b = o.requestId;
+						if (typeof b != "string" || b.length > 384 || !/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(b)) return _();
+						A.push(Object.freeze({
+							...e,
+							entryOrigin: Object.freeze({
+								tenantId: w,
+								roomId: h.source.roomId,
+								requestId: b
+							})
+						}));
+					}
+					let M = Object.freeze({
+						instance: Object.freeze(p),
+						groupId: k,
+						members: Object.freeze(A.sort((e, t) => e.entityId < t.entityId ? -1 : +(e.entityId > t.entityId))),
+						blocked: Object.freeze(C.map((e) => Object.freeze(e)))
+					});
+					return n(M, O), M;
+				})),
+				catch: () => new t({ detail: "Instance expiry entity inventory remains incomplete" })
+			});
+		}
+	});
+};
+//#endregion
+export { x as dataStoreWorldInstanceExpiry };