@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryImportTiles.js

@@ -0,0 +1,136 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { createGeometryTileCodec as n, geometryOwnData as r, geometryTileRefusal as i } from "./geometryTileCodec.js";
+//#region src/geometryImportTiles.ts
+var a = (e, t = -2147483648, n = 2147483647) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : i(), o = (e) => !e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype ? i() : e, s = (e, t) => {
+	if (!Array.isArray(e) || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return i();
+	for (let t = 0; t < e.length; t++) {
+		let n = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!n?.enumerable || !("value" in n)) return i();
+	}
+	return e;
+}, c = (e) => typeof e == "string" && e.length > 0 && e.length <= 256 ? e : i(), l = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : i(), u = (e) => {
+	let t = r(e, ["key", "solid"]);
+	return typeof t.key != "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(t.key) || typeof t.solid != "boolean" ? i() : Object.freeze({
+		key: t.key,
+		solid: t.solid
+	});
+}, d = [
+	"worldId",
+	"layerSetId",
+	"version",
+	"origin",
+	"chunkSide",
+	"tileSizeRaw",
+	"materials",
+	"maxInputBytes",
+	"maxCells",
+	"maxRegions",
+	"maxChunks",
+	"codecLimits"
+], f = (e, c, f) => {
+	let p = r(e, [...d, ...c], [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"materials",
+		...f
+	]), m = (e, t, n) => a(Object.hasOwn(p, e) ? p[e] : t, 1, n), h = m("maxInputBytes", 16777216, 67108864), g = m("maxCells", 1048576, 4194304), _ = m("maxRegions", 4096, 16384), v = m("maxChunks", 256, 4096), y = m("chunkSide", 64, 1024), b = m("tileSizeRaw", 65536, 2147483647), x = r(p.origin, ["x", "y"]), S = a(x.x), C = a(x.y), w = l(p.worldId), T = l(p.layerSetId), E = l(p.version), D = [
+		"maxSide",
+		"maxCells",
+		"maxPalette",
+		"maxRuns",
+		"maxBytes"
+	], O = Object.hasOwn(p, "codecLimits") ? r(p.codecLimits, D, []) : {}, k = Object.fromEntries(D.filter((e) => Object.hasOwn(O, e)).map((e) => [e, a(O[e], 1, 16777216)])), A = n(k), j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map();
+	if (y > A.limits.maxSide || y * y > A.limits.maxCells || y * b > 2147483647) return i();
+	for (let e of s(p.materials, 4096)) {
+		let t = r(e, [
+			"sourceId",
+			"flip",
+			"material"
+		], ["sourceId", "material"]), n = a(t.sourceId, 0, 4294967295), o = a(Object.hasOwn(t, "flip") ? t.flip : 0, 0, 3), s = u(t.material), c = `${n}:${o}`;
+		if (j.has(c) || M.has(s.key) && M.get(s.key) !== s.solid) return i();
+		M.set(s.key, s.solid), j.set(c, s);
+	}
+	if (!j.size) return i();
+	if (Object.hasOwn(p, "emptyMaterial")) {
+		let e = u(p.emptyMaterial);
+		if (M.has(e.key) && M.get(e.key) !== e.solid) return i();
+	}
+	return {
+		data: p,
+		maxCells: g,
+		maxRegions: _,
+		maxChunks: v,
+		side: y,
+		tileSizeRaw: b,
+		x: S,
+		y: C,
+		worldId: w,
+		layerSetId: T,
+		version: E,
+		codec: A,
+		selectMaterial: (e, t = 0) => j.get(`${a(e, 0, 4294967295)}:${a(t, 0, 3)}`) ?? i(),
+		parse: (e) => {
+			let n = t(e, h, "geometryImportBytes");
+			try {
+				return o(JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(n)));
+			} catch {
+				return i();
+			}
+		}
+	};
+}, p = (t, n) => {
+	if (!n.length || n.length > t.maxRegions) return i();
+	let { side: r } = t, o = /* @__PURE__ */ new Map(), s = 0;
+	for (let c of n) {
+		if (s += c.width * c.height, s > t.maxCells) throw new e({
+			budget: "geometryImportCells",
+			limit: t.maxCells
+		});
+		if (c.cells.length !== c.width * c.height) return i();
+		a(c.x), a(c.y), a(c.x + c.width - 1), a(c.y + c.height - 1);
+		let n = Math.floor(c.x / r), l = Math.floor((c.x + c.width - 1) / r), u = Math.floor(c.y / r), d = Math.floor((c.y + c.height - 1) / r);
+		if ((l - n + 1) * (d - u + 1) > t.maxChunks) throw new e({
+			budget: "geometryImportChunks",
+			limit: t.maxChunks
+		});
+		for (let i = u; i <= d; i++) for (let a = n; a <= l; a++) {
+			let n = `${a}:${i}`;
+			if (!o.has(n)) {
+				if (o.size >= t.maxChunks || (o.size + 1) * r * r > t.maxCells) throw new e({
+					budget: "geometryImportChunks",
+					limit: t.maxChunks
+				});
+				o.set(n, {
+					cx: a,
+					cy: i,
+					seen: new Uint8Array(r * r),
+					cells: Array(r * r),
+					count: 0
+				});
+			}
+		}
+	}
+	for (let e of n) for (let t = 0; t < e.height; t++) for (let n = 0; n < e.width; n++) {
+		let a = e.x + n, s = e.y + t, c = Math.floor(a / r), l = Math.floor(s / r), u = o.get(`${c}:${l}`), d = (s - l * r) * r + (a - c * r);
+		if (u.seen[d]) return i();
+		u.seen[d] = 1, u.cells[d] = e.cells[t * e.width + n], u.count++;
+	}
+	return [...o.values()].some((e) => e.count !== r * r) ? i() : Object.freeze([...o.values()].sort((e, t) => e.cy - t.cy || e.cx - t.cx).map((e) => t.codec.create({
+		address: {
+			worldId: t.worldId,
+			layerSetId: t.layerSetId,
+			cx: e.cx,
+			cy: e.cy
+		},
+		version: t.version,
+		width: r,
+		height: r,
+		tileSizeRaw: t.tileSizeRaw,
+		cells: e.cells
+	})));
+};
+//#endregion
+export { f as admitTileImport, p as collectImportedTiles, s as importArray, a as importInteger, u as importMaterial, c as importName, o as importRecord };

package/dist/geometryImportVox.js

@@ -0,0 +1,130 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { geometryOwnData as n, geometryTileRefusal as r } from "./geometryTileCodec.js";
+import { createGeometryVoxelCodec as i } from "./geometryVoxel.js";
+import { importArray as a, importInteger as o, importMaterial as s } from "./geometryImportTiles.js";
+//#region src/geometryImportVox.ts
+var c = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : r(), l = (l, u) => {
+	let d = n(u, [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"axes",
+		"chunkSide",
+		"voxelSizeRaw",
+		"modelIndex",
+		"emptyMaterial",
+		"materials",
+		"maxInputBytes",
+		"maxVoxels",
+		"maxChunks",
+		"maxFileChunks",
+		"codecLimits"
+	], [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"axes",
+		"emptyMaterial",
+		"materials"
+	]), f = (e, t, n) => o(Object.hasOwn(d, e) ? d[e] : t, 1, n), p = f("maxInputBytes", 16777216, 67108864), m = f("maxVoxels", 1048576, 16777216), h = f("maxChunks", 256, 4096), g = f("maxFileChunks", 4096, 16384), _ = f("chunkSide", 64, 128), v = f("voxelSizeRaw", 65536, 2147483647), y = n(d.origin, [
+		"cx",
+		"cy",
+		"cz"
+	]), b = o(y.cx), x = o(y.cy), S = o(y.cz), C = c(d.worldId), w = c(d.layerSetId), T = c(d.version), E = s(d.emptyMaterial), D = [
+		"maxSide",
+		"maxVoxels",
+		"maxPalette",
+		"maxSections",
+		"maxRunsPerSection",
+		"maxBytes"
+	], O = Object.hasOwn(d, "codecLimits") ? n(d.codecLimits, D, []) : {}, k = Object.fromEntries(D.filter((e) => Object.hasOwn(O, e)).map((e) => [e, o(O[e], 1, 16777216)])), A = i(k), j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map([[E.key, E.solid]]);
+	if (d.axes !== "xyz" && d.axes !== "xzy" || _ % 16 || _ > A.limits.maxSide || _ ** 3 > A.limits.maxVoxels || (_ / 16) ** 3 > A.limits.maxSections || _ * v > 2147483647) return r();
+	for (let e of a(d.materials, 255)) {
+		let t = n(e, ["colorIndex", "material"]), i = o(t.colorIndex, 1, 255), a = s(t.material);
+		if (j.has(i) || M.has(a.key) && M.get(a.key) !== a.solid) return r();
+		j.set(i, a), M.set(a.key, a.solid);
+	}
+	let N = t(l, p, "geometryImportBytes"), P = new DataView(N.buffer), F = (e) => String.fromCharCode(...N.subarray(e, e + 4));
+	if (N.length < 20 || F(0) !== "VOX " || P.getInt32(4, !0) !== 150 || F(8) !== "MAIN" || P.getInt32(12, !0) !== 0 || P.getInt32(16, !0) !== N.length - 20) return r();
+	let I = [], L = 20, R = 0, z, B, V = !1;
+	for (; L < N.length;) {
+		if (++R > g) throw new e({
+			budget: "geometryVoxFileChunks",
+			limit: g
+		});
+		if (N.length - L < 12) return r();
+		let t = F(L), n = P.getInt32(L + 4, !0), i = P.getInt32(L + 8, !0), a = L + 12, s = a + n;
+		if (n < 0 || i !== 0 || s > N.length) return r();
+		if (t === "PACK") {
+			if (R !== 1 || n !== 4 || z !== void 0) return r();
+			z = o(P.getInt32(a, !0), 1, Math.floor(g / 2));
+		} else if (t === "SIZE") {
+			if (B || V || n !== 12) return r();
+			B = {
+				x: o(P.getInt32(a, !0), 1, 256),
+				y: o(P.getInt32(a + 4, !0), 1, 256),
+				z: o(P.getInt32(a + 8, !0), 1, 256)
+			};
+		} else if (t === "XYZI") {
+			if (!B || n < 4 || V) return r();
+			let e = o(P.getInt32(a, !0), 0, m);
+			if (n !== 4 + e * 4) return r();
+			I.push({
+				...B,
+				voxels: N.subarray(a + 4, s),
+				count: e
+			}), B = void 0;
+		} else if (t === "RGBA") {
+			if (B || V || !I.length || n !== 1024) return r();
+			V = !0;
+		} else return r();
+		L = s;
+	}
+	if (B || !I.length || (z === void 0 ? I.length !== 1 : z !== I.length) || I.length > 1 && !Object.hasOwn(d, "modelIndex")) return r();
+	let H = I[o(Object.hasOwn(d, "modelIndex") ? d.modelIndex : 0, 0, I.length - 1)], U = H.x, W = d.axes === "xyz" ? H.y : H.z, G = d.axes === "xyz" ? H.z : H.y, K = U * W * G, q = U / _, J = W / _, Y = G / _;
+	if (U % _ || W % _ || G % _) return r();
+	if (K > m) throw new e({
+		budget: "geometryImportVoxels",
+		limit: m
+	});
+	if (q * J * Y > h) throw new e({
+		budget: "geometryImportChunks",
+		limit: h
+	});
+	o(b + q - 1), o(x + J - 1), o(S + Y - 1);
+	let X = new Uint8Array(K), Z = new Uint8Array(K);
+	for (let e = 0; e < H.count; e++) {
+		let t = H.voxels[e * 4], n = H.voxels[e * 4 + 1], i = H.voxels[e * 4 + 2], a = H.voxels[e * 4 + 3], o = d.axes === "xyz" ? n : i, s = d.axes === "xyz" ? i : n;
+		if (t >= U || o >= W || s >= G || !a || !j.has(a)) return r();
+		let c = (s * W + o) * U + t;
+		if (Z[c]) return r();
+		Z[c] = 1, X[c] = a;
+	}
+	let Q = [];
+	for (let e = 0; e < Y; e++) for (let t = 0; t < J; t++) for (let n = 0; n < q; n++) {
+		let r = [];
+		for (let i = 0; i < _; i++) for (let a = 0; a < _; a++) for (let o = 0; o < _; o++) {
+			let s = X[((e * _ + i) * W + t * _ + a) * U + n * _ + o];
+			r.push(s ? j.get(s) : E);
+		}
+		Q.push(A.create({
+			address: {
+				worldId: C,
+				layerSetId: w,
+				cx: b + n,
+				cy: x + t,
+				cz: S + e
+			},
+			version: T,
+			side: _,
+			voxelSizeRaw: v,
+			voxels: r
+		}));
+	}
+	return Object.freeze(Q);
+};
+//#endregion
+export { l as importVoxGeometry };

package/dist/geometryImportedSource.js

@@ -0,0 +1,101 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { verifyGeometryArtifact as r } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as i, captureGeometryCodecProfiles as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { geometryChunkHasWorldExtent as c } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as l } from "./world.js";
+import { captureGeometryVersion as u } from "./geometryPersistenceCapture.js";
+import { Effect as d } from "effect";
+import { isAbsolute as f, join as p, relative as m, resolve as h, sep as g } from "node:path";
+import { constants as _, promises as v } from "node:fs";
+//#region src/geometryImportedSource.ts
+var y = () => new t({ detail: "Imported geometry package identity, native bytes or exact declared scope remains unconfirmed" }), b = (e, t) => {
+	let n = m(e, t);
+	return !!n && !f(n) && n !== ".." && !n.startsWith(".." + g);
+}, x = (t, m, g = {}) => {
+	try {
+		let x = l([t])[0], S = x.geometry, C = n(m, [
+			"tenantId",
+			"version",
+			"appRoot"
+		]), w = o(C.tenantId), T = o(C.version, 96), E = C.appRoot, D = n(g, [
+			"maxChunks",
+			"maxArtifactBytes",
+			"maxManifestBytes",
+			"codecLimits"
+		], []), O = (e, t, n, r) => s(Object.hasOwn(D, e) ? D[e] : t, n, r), k = O("maxChunks", 256, 1, 4096), A = O("maxArtifactBytes", 52428800, 64, 268435456), j = O("maxManifestBytes", 262144, 256, 16777216), M = a(Object.hasOwn(D, "codecLimits") ? D.codecLimits : {});
+		if (!S || S.static.kind !== "imported" || typeof E != "string" || !f(E) || h(E) !== E || /[\u0000-\u001f\u007f]/.test(E)) return d.fail(y());
+		let N = h(E, S.static.directory);
+		return b(E, N) ? d.uninterruptible(d.tryPromise({
+			try: async () => {
+				if (await v.realpath(E) !== E || await v.realpath(N) !== N) throw y();
+				let t = await v.open(N, _.O_RDONLY | _.O_DIRECTORY | _.O_NOFOLLOW);
+				try {
+					let a = await t.stat();
+					if (!a.isDirectory()) throw y();
+					let o = async () => {
+						let e = await v.lstat(N);
+						if (!e.isDirectory() || e.dev !== a.dev || e.ino !== a.ino || await v.realpath(N) !== N) throw y();
+					}, s = async (t, n) => {
+						await o();
+						let r = p(N, t), i = await v.open(r, _.O_RDONLY | _.O_NOFOLLOW);
+						try {
+							let t = await i.stat(), a = await v.lstat(r);
+							if (!t.isFile() || !a.isFile() || a.dev !== t.dev || a.ino !== t.ino) throw y();
+							if (t.size > n) throw new e({
+								budget: "geometryImportedSourceBytes",
+								limit: n
+							});
+							let s = new Uint8Array(t.size + 1), c = 0;
+							for (; c < s.length;) {
+								let e = await i.read(s, c, s.length - c, null);
+								if (!e.bytesRead) break;
+								c += e.bytesRead;
+							}
+							let l = await i.stat(), u = await v.lstat(r);
+							if (c !== t.size || l.size !== t.size || l.mtimeMs !== t.mtimeMs || l.ctimeMs !== t.ctimeMs || u.dev !== t.dev || u.ino !== t.ino) throw y();
+							return await o(), s.subarray(0, c);
+						} finally {
+							await i.close();
+						}
+					}, l = await s("manifest.json", j), d = n(JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(l)), [
+						"tenantId",
+						"kind",
+						"worldId",
+						"version",
+						"chunks",
+						"manifestSha256"
+					]), f = u({
+						tenantId: d.tenantId,
+						kind: d.kind,
+						worldId: d.worldId,
+						version: d.version,
+						chunks: d.chunks
+					}, k, j);
+					if (f.tenantId !== w || f.kind !== S.kind || f.worldId !== x.name || f.version !== T || d.manifestSha256 !== f.manifestSha256) throw y();
+					let m = [], h = 0;
+					for (let e of f.chunks) {
+						let t = await s(e.blobSha256 + ".bin", Math.min(16777216, A - h));
+						h += t.length;
+						let n = await r(e.kind, t, e.blobSha256, M.get(e.kind) ?? {});
+						if (i(n, e), n.contentSha256 !== e.contentSha256 || !c(n, S.chunkSizeRaw)) throw y();
+						m.push(n);
+					}
+					let g = await s("manifest.json", j);
+					if (g.length !== l.length || g.some((e, t) => e !== l[t])) throw y();
+					return await o(), Object.freeze({
+						manifest: f,
+						artifacts: Object.freeze(m)
+					});
+				} finally {
+					await t.close();
+				}
+			},
+			catch: (t) => t instanceof e ? t : y()
+		})) : d.fail(y());
+	} catch (t) {
+		return d.fail(t instanceof e ? t : y());
+	}
+};
+//#endregion
+export { x as loadImportedGeometryPublication };

package/dist/geometryInspectEndpoint.js

@@ -0,0 +1,248 @@
+import { captureGeometryKind as e, captureGeometryPersistenceScope as t, captureGeometryReceipt as n, geometryPersistenceId as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { defaultGeometryApplyOp as a, defaultGeometryOpValidator as o } from "./geometryEdits.js";
+import { defaultGeometryCollisionDerive as s, defaultGeometryNavDerive as c } from "./geometryDerivationStrategies.js";
+import { GEO_JOURNAL_ARCHIVES_TABLE as l } from "./geometryJournalArchiveTable.js";
+import { defaultGeometryMigrateDelta as u } from "./geometryMigrationStrategies.js";
+import { defaultGeometryCompaction as d } from "./geometryCompactionStrategies.js";
+import { captureWorldCatalog as f } from "./world.js";
+import { GEO_MIGRATIONS_TABLE as p } from "./geometryMigrationJournal.js";
+import { captureGeometryJournalArchiveReference as m } from "./geometryJournalArchiveData.js";
+import { geometryPersistenceDigest as h, geometryPersistenceScopeKey as g, geometryPersistenceVersionKey as _ } from "./geometryPersistenceCapture.js";
+import { GEO_CHUNK_DELTAS_TABLE as v, GEO_JOURNAL_TABLE as y, GEO_VERSIONS_TABLE as b } from "./geometryPersistence.js";
+import { captureGeometryMigrationReceipt as x } from "./geometryMigrations.js";
+import { decodeGeometryInspection as S } from "./geometryInspection.js";
+import { and as C, eq as w, gt as T } from "@voltro/database";
+import { Effect as E, Result as D } from "effect";
+import { parseReplicaSelection as O } from "@voltro/protocol/inspect";
+//#region src/geometryInspectEndpoint.ts
+var k = (e) => {
+	let t = e instanceof Date ? e : typeof e == "string" ? new Date(e) : null;
+	if (!t || !Number.isFinite(t.getTime())) throw Error("Invalid recorded geometry timestamp");
+	return t.toISOString();
+}, A = (A, j) => {
+	let M = f(j);
+	if (M.length !== A.worlds.length || M.some((e, t) => e !== A.worlds[t])) throw Error("Geometry inspection catalog differs from the actual API owner");
+	let N = M.filter((e) => e.geometry !== void 0), P = N.map((e) => {
+		let t = e.geometry;
+		return {
+			worldId: e.name,
+			kind: t.kind,
+			staticSource: t.static.kind,
+			chunkSizeRaw: t.chunkSizeRaw,
+			dynamicEnabled: t.dynamic.enabled,
+			migrationStrategy: t.strategies.migrateDelta === u ? "default" : "custom",
+			compactionStrategy: t.strategies.compaction === d ? "default" : "custom",
+			collisionDeriveStrategy: t.strategies.collisionDerive === s ? "default" : "custom",
+			navDeriveStrategy: t.strategies.navDerive === c ? "default" : "custom",
+			opValidatorStrategy: t.strategies.opValidator === o ? "default" : "custom",
+			applyOpStrategy: t.strategies.applyOp === a ? "default" : "custom",
+			overlapTestBudget: t.budgets.maxOverlapTests,
+			rayCellBudget: t.budgets.maxRayCells,
+			deltaByteBudget: t.dynamic.maxDeltaBytesPerChunk,
+			preparedChunkBudget: t.budgets.maxPreparedChunks,
+			preparedByteBudget: t.budgets.maxPreparedBytes,
+			marginChunks: t.streaming.cell.marginChunks
+		};
+	});
+	return {
+		method: "GET",
+		path: "/geometry",
+		scope: "shared-store",
+		description: "Declared geometry budgets and paged redacted durable metadata",
+		handler: (a) => E.gen(function* () {
+			let o = yield* E.result(E.try({
+				try: () => {
+					let e = new URL(a.url, "http://inspect.local").searchParams;
+					O(e), e.delete("replica"), e.delete("replicas");
+					for (let t of e.keys()) if (![
+						"tenantId",
+						"table",
+						"after"
+					].includes(t) || e.getAll(t).length !== 1) throw Error("Invalid geometry query");
+					let t = r(e.get("tenantId")), n = e.get("table") ?? "deltas", i = e.has("after") ? r(e.get("after")) : null;
+					if (![
+						"versions",
+						"deltas",
+						"journal",
+						"migrations",
+						"archives"
+					].includes(n) || (!N.length || n === "migrations" && !A.geometryMigrationsEnabled || n === "archives" && !A.geometryJournalArchives) && i !== null) throw Error("Invalid geometry selection");
+					return {
+						tenantId: t,
+						table: n,
+						after: i
+					};
+				},
+				catch: () => "Invalid geometry query"
+			}));
+			if (D.isFailure(o)) return {
+				kind: "json",
+				status: 400,
+				data: { error: "Geometry inspection requires one tenant and a valid recorded-data page" }
+			};
+			let s = o.success, c = N.length > 0, u = c && A.geometryMigrationsEnabled, d = c && A.geometryAssetUrls, f = c && A.geometryJournalArchives, j = f && A.geometryJournalRetention, M = c && A.geometryAdminControls;
+			if (!c || s.table === "migrations" && !u || s.table === "archives" && !f) return {
+				kind: "json",
+				data: S({
+					installed: c,
+					migrationsInstalled: u,
+					assetUrlsInstalled: d,
+					archivesInstalled: f,
+					retentionInstalled: j,
+					adminControlsInstalled: M,
+					sourceBound: c && A.status().phase === "ready",
+					page: {
+						...s,
+						nextAfter: null
+					},
+					configuration: P,
+					rows: []
+				})
+			};
+			let F = yield* E.result(A.inspect(async (a) => {
+				let o = A.status().phase, E = s.table === "versions" ? b : s.table === "deltas" ? v : s.table === "migrations" ? p : s.table === "archives" ? l : y, D = s.table === "archives" ? [
+					"id",
+					"tenantId",
+					"scopeKey",
+					"requestKey",
+					"archive",
+					"createdAt"
+				] : s.table === "migrations" ? [
+					"id",
+					"tenantId",
+					"requestKey",
+					"inputSha256",
+					"fromScopeKey",
+					"toScopeKey",
+					"receipt",
+					"createdAt"
+				] : s.table === "versions" ? [
+					"id",
+					"tenantId",
+					"versionKey",
+					"worldId",
+					"kind",
+					"version",
+					"manifestChunks",
+					"createdAt"
+				] : s.table === "deltas" ? [
+					"id",
+					"tenantId",
+					"scopeKey",
+					"scope",
+					"revision",
+					"updatedAt"
+				] : [
+					"id",
+					"tenantId",
+					"scopeKey",
+					"requestKey",
+					"receipt",
+					"createdAt"
+				], O = await a.query({
+					table: E,
+					predicate: C(w("tenantId", s.tenantId), ...s.table === "archives" ? [w("releasedAt", null)] : [], ...s.after === null ? [] : [T("id", s.after)]),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: 51,
+					skip: void 0,
+					projection: D
+				});
+				if (O.length > 51 || new Set(O.map((e) => e.id)).size !== O.length || O.some((e, t) => e.tenantId !== s.tenantId || s.after !== null && r(e.id) <= s.after || t > 0 && r(O[t - 1].id) >= r(e.id))) throw Error("Geometry metadata escaped its page scope");
+				let N = O.slice(0, 50).map((a) => {
+					if (s.table === "migrations") {
+						let e = x(a.receipt), t = e.to;
+						if (t.tenantId !== s.tenantId || a.requestKey !== e.requestKey || a.inputSha256 !== e.inputSha256 || a.fromScopeKey !== g(e.from) || a.toScopeKey !== g(t)) throw Error("Geometry migration metadata changed scope");
+						return {
+							id: r(a.id),
+							worldId: t.worldId,
+							kind: t.kind,
+							version: t.version,
+							coordinates: {
+								cx: t.cx,
+								cy: t.cy,
+								...t.cz === void 0 ? {} : { cz: t.cz }
+							},
+							revision: e.revision,
+							changed: null,
+							manifestChunks: null,
+							migration: {
+								fromVersion: e.from.version,
+								fromRevision: e.fromRevision,
+								decision: e.decision,
+								staticChanged: e.staticChanged
+							},
+							observedAt: k(a.createdAt)
+						};
+					}
+					if (s.table === "versions") {
+						let t = {
+							tenantId: s.tenantId,
+							kind: e(a.kind),
+							worldId: r(a.worldId, 96),
+							version: r(a.version, 96)
+						};
+						if (a.versionKey !== _(t)) throw Error("Geometry version metadata could not be admitted");
+						return {
+							id: r(a.id),
+							worldId: t.worldId,
+							kind: t.kind,
+							version: t.version,
+							coordinates: null,
+							revision: null,
+							changed: null,
+							manifestChunks: i(a.manifestChunks, 1, 4096),
+							migration: null,
+							observedAt: k(a.createdAt)
+						};
+					}
+					let o = s.table === "archives" ? m(a.archive).receipt : s.table === "journal" ? n(a.receipt) : null, c = o?.scope ?? t(a.scope);
+					if (c.tenantId !== s.tenantId || a.scopeKey !== g(c) || o && a.requestKey !== h(JSON.stringify([s.tenantId, o.requestId]))) throw Error("Geometry scope metadata could not be admitted");
+					return {
+						id: r(a.id),
+						worldId: c.worldId,
+						kind: c.kind,
+						version: c.version,
+						coordinates: {
+							cx: c.cx,
+							cy: c.cy,
+							...c.cz === void 0 ? {} : { cz: c.cz }
+						},
+						revision: o?.revision ?? i(a.revision, 1),
+						changed: o?.changed ?? null,
+						manifestChunks: null,
+						migration: null,
+						observedAt: k(s.table === "journal" || s.table === "archives" ? a.createdAt : a.updatedAt)
+					};
+				});
+				return S({
+					installed: c,
+					migrationsInstalled: u,
+					assetUrlsInstalled: d,
+					archivesInstalled: f,
+					retentionInstalled: j,
+					adminControlsInstalled: M,
+					sourceBound: o === "ready",
+					configuration: P,
+					page: {
+						...s,
+						nextAfter: O.length > 50 ? N.at(-1).id : null
+					},
+					rows: N
+				});
+			}));
+			return D.isFailure(F) ? {
+				kind: "json",
+				status: 503,
+				data: { error: "Recorded geometry metadata is unavailable" }
+			} : {
+				kind: "json",
+				data: F.success
+			};
+		})
+	};
+};
+//#endregion
+export { A as roomsGeometryInspectEndpoint };