@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryHostDirectory.js

@@ -0,0 +1,206 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceId as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadPort as a } from "./geometryReloadPorts.js";
+import { captureRoomGeometryRollbackPort as o } from "./geometryRollbackPorts.js";
+import { captureWorldCatalog as s, worldCellAt as c, worldCellById as l } from "./world.js";
+import { GeometryPersistencePort as u } from "./geometryPersistencePorts.js";
+import { WORLD_CELLS_TABLE as d, dataStoreWorldCells as f } from "./worldCells.js";
+import { captureRoomGeometryOwnerScope as p, makeRoomGeometryResource as m } from "./geometryHost.js";
+import { loadPreparedWorldCellGeometry as h } from "./geometryCellLoader.js";
+import { and as g, eq as _ } from "@voltro/database";
+import { Effect as v } from "effect";
+// src/geometryHostDirectory.ts
+var y = () => new t({ detail: "Actual SQL Host geometry placement could not be admitted" }), b = (e, t, n) => v.suspend(() => {
+	let r = t ? e.find((e) => e.name === t.worldId) : void 0;
+	if (!t || !r) return v.fail(y());
+	let i;
+	try {
+		i = l(r, t.zoneId, t.cellId);
+	} catch {
+		return v.fail(y());
+	}
+	return v.succeed(Object.freeze({
+		worldId: r.name,
+		zoneId: t.zoneId,
+		at: i.bounds[0],
+		layer: t.layer,
+		layerSetId: n.layerSetId,
+		version: n.version,
+		...n.load === void 0 ? {} : { load: n.load }
+	}));
+}), x = (l, b) => {
+	let x = n(b, [
+		"worlds",
+		"epochNow",
+		"maxListedCells",
+		"authorize",
+		"persistence",
+		"select",
+		"mutations",
+		"streams",
+		"maxSubjectFences",
+		"reload",
+		"rollback"
+	], [
+		"worlds",
+		"epochNow",
+		"maxListedCells",
+		"authorize",
+		"persistence",
+		"select"
+	]), S = s(x.worlds), C = Object.hasOwn(x, "maxSubjectFences") ? i(x.maxSubjectFences, 1, 65536) : 4096, w = Object.hasOwn(x, "rollback") ? o(x.rollback) : void 0, T = Object.hasOwn(x, "reload") ? a(x.reload) : void 0;
+	if (!S.length || typeof x.epochNow != "function" || typeof x.authorize != "function" || typeof x.select != "function" || Object.hasOwn(x, "mutations") && typeof x.mutations != "function" || Object.hasOwn(x, "streams") && typeof x.streams != "function") throw y();
+	let E = x.authorize.bind(b), D = x.select.bind(b), O = n(x.persistence, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]);
+	if (Object.values(O).some((e) => typeof e != "function")) throw y();
+	let k = Object.freeze({
+		publish: O.publish.bind(x.persistence),
+		observe: O.observe.bind(x.persistence),
+		commit: O.commit.bind(x.persistence),
+		exportSubject: O.exportSubject.bind(x.persistence),
+		eraseSubject: O.eraseSubject.bind(x.persistence)
+	}), A = f(l, {
+		worlds: S,
+		epochNow: x.epochNow.bind(b),
+		maxListedCells: i(x.maxListedCells, 1),
+		authorize: E
+	});
+	return Object.freeze({
+		worlds: S,
+		prepare: (a) => v.uninterruptible(v.tryPromise({
+			try: async () => {
+				let e = p(a), t = await l.query({
+					table: d,
+					predicate: g(_("tenantId", e.tenantId), _("roomId", e.roomId)),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"tenantId",
+						"worldId",
+						"zoneId",
+						"cellId",
+						"layer",
+						"roomId"
+					]
+				});
+				if (t.length > 1) throw y();
+				let o = null;
+				if (t.length) {
+					let n = t[0];
+					if (n.tenantId !== e.tenantId || n.roomId !== e.roomId) throw y();
+					o = Object.freeze({
+						tenantId: e.tenantId,
+						worldId: r(n.worldId),
+						zoneId: r(n.zoneId),
+						cellId: r(n.cellId),
+						layer: i(n.layer, 1)
+					});
+				}
+				let s = D(e, o);
+				if (!v.isEffect(s)) throw y();
+				let f = n(await v.runPromise(s), [
+					"worldId",
+					"zoneId",
+					"at",
+					"layer",
+					"layerSetId",
+					"version",
+					"load"
+				], [
+					"worldId",
+					"zoneId",
+					"at",
+					"layer",
+					"layerSetId",
+					"version"
+				]), w = S.find((e) => e.name === r(f.worldId)), T = r(f.zoneId), O = i(f.layer, 1);
+				if (!w?.geometry || !w.zones.some((t) => t.id === T && t.room === e.name)) throw y();
+				let j = c(w, {
+					zone: T,
+					at: f.at
+				}), M = Object.freeze({
+					zone: T,
+					at: j.bounds[0]
+				}), N = Object.freeze({
+					tenantId: e.tenantId,
+					worldId: w.name,
+					kind: w.geometry.kind,
+					layerSetId: r(f.layerSetId),
+					version: r(f.version)
+				}), P = Object.freeze({
+					tenantId: e.tenantId,
+					worldId: w.name,
+					zoneId: T,
+					at: M.at,
+					layer: O,
+					roomId: e.roomId,
+					hostId: e.hostId,
+					epoch: e.epoch
+				});
+				if (o && (o.worldId !== w.name || o.zoneId !== T || o.cellId !== j.id || o.layer !== O)) throw y();
+				let F = E("publish", {
+					tenantId: e.tenantId,
+					worldId: w.name
+				});
+				if (!v.isEffect(F)) throw y();
+				await v.runPromise(F);
+				let I = Object.hasOwn(f, "load") ? f.load : {}, L = h(w, N, M, I), R = await v.runPromise(L.pipe(v.provideService(u, k)));
+				return await v.runPromise(A.prepare(P)), m(w, e, R.inventory, async () => void 0, { synchronize: () => v.runPromise(A.synchronize(P)) }, Object.hasOwn(x, "mutations") ? x.mutations.bind(b) : void 0, Object.hasOwn(x, "streams") ? x.streams.bind(b) : void 0, C);
+			},
+			catch: (n) => n instanceof e || n instanceof t ? n : y()
+		})),
+		cleanupCreation: (n) => {
+			let a;
+			try {
+				a = p(n);
+			} catch {
+				return v.fail(y());
+			}
+			return S.some((e) => e.geometry && e.zones.some((e) => e.room === a.name)) ? v.uninterruptible(v.tryPromise({
+				try: async () => {
+					let e = await l.query({
+						table: d,
+						predicate: g(_("tenantId", a.tenantId), _("roomId", a.roomId)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: [
+							"tenantId",
+							"worldId",
+							"zoneId",
+							"cellId",
+							"layer",
+							"roomId",
+							"hostId",
+							"epoch"
+						]
+					});
+					if (e.length > 1) throw y();
+					if (!e.length) return;
+					let t = e[0], n = S.find((e) => e.name === t.worldId);
+					if (t.tenantId !== a.tenantId || t.roomId !== a.roomId || t.hostId !== a.hostId || t.epoch !== a.epoch || !n?.geometry || !n.zones.some((e) => e.id === t.zoneId && e.room === a.name)) throw y();
+					await v.runPromise(A.remove({
+						tenantId: a.tenantId,
+						worldId: n.name,
+						zoneId: r(t.zoneId),
+						cellId: r(t.cellId),
+						layer: i(t.layer, 1),
+						roomId: a.roomId,
+						epoch: a.epoch
+					}));
+				},
+				catch: (n) => n instanceof e || n instanceof t ? n : y()
+			})) : v.void;
+		},
+		...T ? { reload: T } : {},
+		...w ? { rollback: w } : {}
+	});
+};
+export { x as dataStoreRoomHostGeometry, b as recordedGeometryPlacement };

package/dist/geometryHostMutations.js

@@ -0,0 +1,136 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { geometryPersistenceId as n } from "./geometryPersistenceData.js";
+import { captureGeometryEditStrategies as r } from "./geometryEdits.js";
+import { captureGeometryActorFrame as i } from "./geometryActorInventory.js";
+import { captureRoomAdmittedSessionReader as a } from "./serverSession.js";
+import { captureRoomGeometryResourceState as o, roomGeometryEditorPoint as s } from "./geometryHost.js";
+import { makeGeometryCommitCoordinator as c } from "./geometryCommitCoordinator.js";
+import { makeGeometryPlayerEditOwner as l } from "./geometryPlayerEditOwner.js";
+import { makeGeometryReliablePublication as u } from "./geometryReliablePublication.js";
+import { makeGeometryEditIngress as d } from "./geometryEditIngress.js";
+import { Effect as f } from "effect";
+// src/geometryHostMutations.ts
+var p = (p, m, h) => {
+	let g = o(p), _ = i(g.inventory), v = t(h, [
+		"persistence",
+		"leases",
+		"now",
+		"resolveSubject",
+		"authorizeIntent",
+		"authorizeRecipient",
+		"channel",
+		"coordinator",
+		"edits",
+		"ingress",
+		"publication"
+	], [
+		"persistence",
+		"leases",
+		"now",
+		"resolveSubject",
+		"authorizeIntent",
+		"authorizeRecipient"
+	]);
+	if (!g.world.geometry?.dynamic.enabled || typeof m != "function" || [
+		"now",
+		"resolveSubject",
+		"authorizeIntent",
+		"authorizeRecipient"
+	].some((e) => typeof v[e] != "function")) throw new e({ detail: "Host geometry mutations require actual dynamic World, native Sessions and complete current server policies" });
+	let y = Object.freeze({
+		roomId: g.scope.roomId,
+		hostId: g.scope.hostId,
+		epoch: g.scope.epoch
+	}), b = (e, n) => Object.hasOwn(v, e) ? t(v[e], n, []) : {}, x = b("coordinator", [
+		"maxPending",
+		"maxPatchBytes",
+		"maxPendingBytes",
+		"maxSubjectFences"
+	]), S = b("edits", [
+		"strategies",
+		"maxPending",
+		"maxPendingPatchBytes",
+		"maxOpsPerPump",
+		"maxSubjectWindows",
+		"maxSubjectFences",
+		"localWindowMs",
+		"localOpsPerWindow",
+		"localCooldownMs"
+	]), C = Object.hasOwn(S, "strategies") ? t(S.strategies, ["opValidator", "applyOp"], []) : {}, w = r({
+		opValidator: g.world.geometry.strategies.opValidator,
+		applyOp: g.world.geometry.strategies.applyOp,
+		...C
+	}), T = b("ingress", [
+		"maxPending",
+		"maxPerPump",
+		"maxSubjectFences"
+	]), E = b("publication", [
+		"channel",
+		"maxRecipients",
+		"maxPatchBytes",
+		"maxFragmentDeliveries"
+	]), D = Object.hasOwn(v, "channel") ? n(v.channel, 96) : "geometryEdit", O = Object.hasOwn(E, "channel") ? n(E.channel, 96) : "geometry";
+	if (D === O || !/^[A-Za-z][A-Za-z0-9._-]*$/.test(D) || !/^[A-Za-z][A-Za-z0-9._-]*$/.test(O)) throw new e({ detail: "Geometry intention and publication need distinct actual channels" });
+	let k = v.authorizeIntent.bind(h), A = (e) => {
+		let t = s(p, e), n = t ? Math.round(t[0] * 65536) : NaN, r = t ? Math.round(t[1] * 65536) : NaN;
+		return Number.isSafeInteger(n) && Number.isSafeInteger(r) ? Object.freeze({ position: Object.freeze({
+			xRaw: n,
+			yRaw: r,
+			zRaw: 0
+		}) }) : null;
+	}, j = c(v.persistence, v.leases, {
+		...x,
+		tenantId: g.scope.tenantId
+	}), M = u({
+		...E,
+		scope: _.scope,
+		owner: y,
+		currentSessions: () => m().filter((e) => a(e).identity() !== null),
+		authorizeRecipient: v.authorizeRecipient.bind(h)
+	}), N = l(g.inventory, j, {
+		...S,
+		strategies: w,
+		tenantId: g.scope.tenantId,
+		now: v.now.bind(h),
+		authorizeIntent: (e) => k(Object.freeze({
+			...e,
+			editor: A(e.subject.id)
+		})),
+		publishCommitted: M
+	}), P = d(N, {
+		...T,
+		scope: _.scope,
+		owner: y,
+		resolveSubject: v.resolveSubject.bind(h)
+	}), F = !1;
+	return Object.freeze({
+		channel: D,
+		publicationChannel: O,
+		stage: (t, n) => {
+			if (F || !m().includes(t)) throw new e({ detail: "Geometry intent did not originate from its actual owned Host Session" });
+			P.stage(t, n);
+		},
+		discardUnsubmitted: async (t) => {
+			if (F) throw new e({ detail: "Closed Host geometry mutations cannot discard local intents" });
+			return f.runPromise(P.discardUnsubmitted(t));
+		},
+		withdrawSubject: async (e) => {
+			F || await f.runPromise(P.withdrawSubject(e));
+		},
+		eraseSubject: async (t) => {
+			if (F) throw new e({ detail: "Closed Host geometry mutations cannot attest Subject content erasure" });
+			await f.runPromise(P.eraseSubject(t));
+		},
+		fence: () => {
+			P.fence();
+		},
+		pump: async () => {
+			!F && !P.observation().closed && await f.runPromise(P.pump());
+		},
+		close: async () => {
+			F ||= (await f.runPromise(P.close()), await f.runPromise(N.close()), await f.runPromise(j.close()), !0);
+		}
+	});
+};
+export { p as makeRoomGeometryMutations };

package/dist/geometryHostStreams.js

@@ -0,0 +1,123 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryDense as r, captureGeometryPrivacyTarget as i, captureGeometrySubject as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryActorFrame as c } from "./geometryActorInventory.js";
+import { captureRoomAdmittedSessionReader as l } from "./serverSession.js";
+import { captureRoomGeometryResourceState as u } from "./geometryHost.js";
+import { makeRoomGeometrySnapshotServer as d } from "./geometrySnapshotServer.js";
+import { makeGeometryManifestPublication as f } from "./geometryManifestPublication.js";
+import { Effect as p, Result as m } from "effect";
+// src/geometryHostStreams.ts
+var h = (h, g, _) => {
+	let v = u(h), y = c(v.inventory).scope, b = n(_, [
+		"source",
+		"authorizeRecipient",
+		"authorizeChunk",
+		"resolveSubject",
+		"channel",
+		"maxRecipients",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxFragmentDeliveries",
+		"maxSubjectFences",
+		"recovery"
+	], [
+		"source",
+		"authorizeRecipient",
+		"authorizeChunk",
+		"resolveSubject"
+	]), x = Object.hasOwn(b, "channel") ? o(b.channel, 96) : "geometryManifest", S = Object.hasOwn(b, "maxSubjectFences") ? s(b.maxSubjectFences, 1, 65536) : 4096, C = b.resolveSubject, w = /* @__PURE__ */ new Set();
+	if (typeof C != "function" || typeof g != "function") throw new t({ detail: "Actual Host geometry stream needs native roster and current Subject lookup" });
+	let T = [], E = /* @__PURE__ */ new Map(), D = !1, O = !1, k = null, A = 0, j = null, M = null, N = /* @__PURE__ */ new Set(), P = Object.fromEntries(Object.entries(b).filter(([e]) => e !== "resolveSubject" && e !== "maxSubjectFences" && e !== "recovery")), F = f({
+		...P,
+		scope: y,
+		owner: {
+			roomId: v.scope.roomId,
+			hostId: v.scope.hostId,
+			epoch: v.scope.epoch
+		},
+		currentSessions: () => D || O ? [] : T.filter((e) => {
+			let t = E.get(e);
+			return t !== void 0 && !w.has(L(t));
+		})
+	}), I = () => {
+		A = s(A + 1);
+	}, L = (e) => JSON.stringify([e.id, e.kind]), R = Object.hasOwn(b, "recovery") ? d(v, g, b.recovery) : void 0;
+	return Object.freeze({
+		channel: x,
+		invalidate: I,
+		...R ? { recovery: R } : {},
+		withdrawSubject: async (n) => {
+			let r = i(n);
+			if (r.tenantId !== v.scope.tenantId || O) throw new t({ detail: "Geometry stream withdrawal requires its actual Room tenant" });
+			let a = L(r.subject);
+			if (!w.has(a) && w.size >= S) throw new e({
+				budget: "geometryStreamSubjectFences",
+				limit: S
+			});
+			w.add(a), I();
+			let o = R?.withdrawSubject(r), s = j;
+			if ((await Promise.allSettled([...o ? [o] : [], ...s ? [s.catch(() => void 0)] : []])).some((e) => e.status === "rejected")) throw new t({ detail: "Geometry stream/read withdrawal remains incomplete" });
+		},
+		fence: () => {
+			D = !0, R?.fence();
+		},
+		pump: async () => {
+			if (D || O) return;
+			if (j) throw new t({ detail: "Host geometry manifest pump is already active" });
+			let e = Promise.resolve().then(async () => {
+				let e = r(g(), 65536, (e) => e).map((e) => ({
+					session: e,
+					identity: l(e).identity()
+				})).filter((e) => e.identity !== null), n = v.inventory.observation().generation, i = A, o = JSON.stringify([
+					n,
+					i,
+					e.map((e) => e.identity).sort((e, t) => e.sessionId.localeCompare(t.sessionId))
+				]);
+				if (k === o) {
+					await R?.pump();
+					return;
+				}
+				let s = [], c = !1;
+				for (let n of e) {
+					let e = n.identity, r = Object.freeze({
+						tenantId: e.tenantId,
+						roomId: e.roomId,
+						sessionId: e.sessionId,
+						subjectId: e.subjectId,
+						epoch: e.epoch
+					}), i = C.call(_, r);
+					if (!p.isEffect(i)) throw new t({ detail: "Geometry stream Subject lookup needs its actual Effect" });
+					let o = await p.runPromise(p.result(i));
+					if (m.isFailure(o) || JSON.stringify(l(n.session).identity()) !== JSON.stringify(e)) {
+						c = !0;
+						continue;
+					}
+					let u = a(o.success);
+					if (u.id !== e.subjectId) throw new t({ detail: "Geometry stream Subject changed actual native admission" });
+					w.has(L(u)) || (s.push(n.session), E.set(n.session, u));
+				}
+				let u = JSON.stringify([n, i]);
+				M !== u && (M = u, N.clear());
+				let d = s.filter((e) => !N.has(JSON.stringify(l(e).identity())));
+				if (d.length) {
+					T = d, await p.runPromise(F());
+					for (let e of d) N.add(JSON.stringify(l(e).identity()));
+				}
+				c || (k = o), await R?.pump();
+			});
+			j = e;
+			try {
+				await e;
+			} finally {
+				j = null, T = [], E.clear();
+			}
+		},
+		close: async () => {
+			D = !0, R?.fence();
+			let e = j;
+			e && await e.catch(() => void 0), await R?.close(), O = !0, T = [], E.clear(), k = null, w.clear(), N.clear(), M = null;
+		}
+	});
+};
+export { h as makeRoomGeometryStreams };

package/dist/geometryHttpBody.js

@@ -0,0 +1,75 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceInteger as r } from "./geometryPersistenceData.js";
+// src/geometryHttpBody.ts
+var i = () => new t({ detail: "Authorized native geometry HTTP download remains unavailable" }), a = async (t, a, o, s, c, l, u = {}) => {
+	let d = n(u, ["contentType", "credentials"], []), f = d.contentType ?? "application/octet-stream", p = d.credentials ?? "include";
+	if (typeof f != "string" || ![
+		"include",
+		"omit",
+		"same-origin"
+	].includes(p)) throw i();
+	let m, h, g = !1, _ = 0, v, y = !1, b, x = [], S = () => h ? (v ||= Promise.resolve().then(() => h.cancel()).then(() => void 0, () => {
+		y = !0;
+	}), v) : Promise.resolve();
+	try {
+		if (!(o instanceof AbortSignal) || o.aborted) throw i();
+		let n = t();
+		if (typeof n != "string" || n.length > 16384) throw i();
+		let u = new URL(n);
+		if (!["http:", "https:"].includes(u.protocol) || u.username || u.password || u.hash || (m = await a(u.href, {
+			method: "GET",
+			credentials: p,
+			redirect: "error",
+			signal: o
+		}), !(m instanceof Response) || m.status !== 200 || m.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== f || !m.body)) throw i();
+		let d = m.headers.get("content-length"), v = m.headers.get("content-encoding");
+		if (d !== null && !/^[1-9][0-9]{0,15}$/.test(d)) throw i();
+		let y = d === null ? void 0 : r(Number(d), 1, s), C = l(m);
+		h = m.body.getReader();
+		let w = () => {
+			S();
+		};
+		if (o.addEventListener("abort", w, { once: !0 }), b = () => o.removeEventListener("abort", w), o.aborted) throw await S(), i();
+		for (;;) {
+			let t = await h.read();
+			if (t.done) {
+				g = !0;
+				break;
+			}
+			if (o.aborted || !(t.value instanceof Uint8Array) || !t.value.length) throw i();
+			if (_ += t.value.length, _ > s) throw new e({
+				budget: "geometryHttpResponseBytes",
+				limit: s
+			});
+			if (x.length >= c) throw new e({
+				budget: "geometryHttpReadChunks",
+				limit: c
+			});
+			x.push(new Uint8Array(t.value));
+		}
+		if (o.aborted || _ === 0 || (v === null || v === "identity") && y !== void 0 && _ !== y) throw i();
+		let T = new Uint8Array(_), E = 0;
+		for (let e of x) T.set(e, E), E += e.length;
+		return {
+			metadata: C,
+			bytes: T
+		};
+	} catch (t) {
+		throw t instanceof e ? t : i();
+	} finally {
+		try {
+			if (h) try {
+				if ((!g || v) && await S(), y) throw i();
+			} finally {
+				h.releaseLock();
+			}
+			else m?.body && !m.body.locked && await m.body.cancel();
+		} catch {
+			throw i();
+		} finally {
+			b?.(), x.length = 0;
+		}
+	}
+};
+export { a as readGeometryHttp };

package/dist/geometryHttpRoutes.js

@@ -0,0 +1,111 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryPersistenceScope as n, geometryPersistenceInteger as r } from "./geometryPersistenceData.js";
+import { geometryChunkHttpResponse as i } from "./geometryChunkHttp.js";
+import { captureWorldCatalog as a } from "./world.js";
+import { assertRoomSubjectAdmission as o } from "./subjectAdmission.js";
+import { Subject as s } from "@voltro/protocol";
+import { Effect as c, Schema as l } from "effect";
+// src/geometryHttpRoutes.ts
+var u = () => new e({ detail: "Geometry snapshot HTTP request is not authorized or available" }), d = (e) => ({
+	status: e,
+	body: "Geometry snapshot unavailable",
+	contentType: "text/plain",
+	headers: { "cache-control": "private, no-store, no-transform" }
+}), f = (e) => {
+	if (e === null || !/^(0|-?[1-9][0-9]{0,9})$/.test(e)) throw u();
+	return r(Number(e), -2147483648, 2147483647);
+}, p = (e, p, m) => {
+	let h = a(e), g = t(m, [
+		"path",
+		"resolveSubject",
+		"authorizeRead",
+		"maxResponseBytes"
+	], [
+		"path",
+		"resolveSubject",
+		"authorizeRead"
+	]), _ = g.path, v = Object.hasOwn(g, "maxResponseBytes") ? r(g.maxResponseBytes, 512, 16777216) : 16777216;
+	if (typeof _ != "string" || _.length > 512 || !/^\/(?:[a-zA-Z0-9_-]+\/)*[a-zA-Z0-9_-]+$/.test(_) || typeof g.resolveSubject != "function" || typeof g.authorizeRead != "function" || !h.some((e) => e.geometry)) throw u();
+	let y = g.resolveSubject.bind(m), b = g.authorizeRead.bind(m), x = t(p, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]);
+	if (Object.values(x).some((e) => typeof e != "function")) throw u();
+	let S = x.observe.bind(p);
+	return Object.freeze({
+		method: "GET",
+		path: _,
+		match: "exact",
+		answersOtherMethods: !0,
+		maxBodyBytes: 0,
+		handle: async (e) => {
+			if (e.path !== _) return d(404);
+			if (e.method !== "GET") return {
+				...d(405),
+				headers: {
+					...d(405).headers,
+					allow: "GET"
+				}
+			};
+			let r, a;
+			try {
+				if (typeof e.query != "string" || e.query.length > 4096 || e.rawBody.length !== 0) return d(400);
+				let t = new URLSearchParams(e.query), i = [
+					"worldId",
+					"layerSetId",
+					"version",
+					"cx",
+					"cy",
+					"cz"
+				];
+				for (let [e] of t) if (!i.includes(e) || t.getAll(e).length !== 1) return d(400);
+				let o = h.find((e) => e.name === t.get("worldId"));
+				if (!o?.geometry) return d(400);
+				if (a = l.decodeUnknownSync(s)(structuredClone(await y(e))), a.type !== "user" || !a.id.trim() || !a.tenantId.trim()) return d(403);
+				if (a.scopes && Object.freeze(a.scopes), Object.freeze(a), r = n({
+					tenantId: a.tenantId,
+					kind: o.geometry.kind,
+					worldId: o.name,
+					layerSetId: t.get("layerSetId"),
+					version: t.get("version"),
+					cx: f(t.get("cx")),
+					cy: f(t.get("cy")),
+					...t.has("cz") ? { cz: f(t.get("cz")) } : {}
+				}), r.kind.startsWith("3d-") !== (r.cz !== void 0)) return d(400);
+			} catch {
+				return d(403);
+			}
+			try {
+				if (!e.store) return d(503);
+				if (await o(e.store, {
+					tenantId: r.tenantId,
+					subjectId: a.id
+				}), await c.runPromise(b(r, a)) !== void 0) return d(403);
+			} catch {
+				return d(403);
+			}
+			try {
+				let e = await c.runPromise(S(r)), a = t(e, [
+					"scope",
+					"revision",
+					"artifact"
+				]);
+				if (JSON.stringify(n(a.scope)) !== JSON.stringify(r)) return d(503);
+				let o = i(e, { maxBytes: v });
+				return {
+					status: o.status,
+					headers: { ...o.headers },
+					body: o.body,
+					contentType: "application/octet-stream"
+				};
+			} catch {
+				return d(503);
+			}
+		}
+	});
+};
+export { p as roomsGeometryHttpRoute };