@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryProceduralWorker.js

@@ -0,0 +1,163 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { verifyGeometryArtifact as n } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as r, captureGeometryCodecProfiles as i, captureGeometryPersistenceScope as a, geometryPersistenceInteger as o } from "./geometryPersistenceData.js";
+import { geometryChunkHasWorldExtent as s } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as c } from "./world.js";
+import { Effect as l } from "effect";
+import { fileURLToPath as u, pathToFileURL as d } from "node:url";
+import { promises as f } from "node:fs";
+import { Worker as p } from "node:worker_threads";
+import { createRequire as m } from "node:module";
+// src/geometryProceduralWorker.ts
+var h = () => new e({ detail: "Procedural geometry worker startup, generation or native lifetime remains unconfirmed" }), g = (e, g) => {
+	try {
+		let _ = c([e])[0], v = _.geometry, y = t(g, [
+			"worldModuleUrl",
+			"moduleLoaderUrl",
+			"exportName",
+			"timeoutMs",
+			"maxArtifactBytes",
+			"maxOldGenerationMb",
+			"codecLimits"
+		], ["worldModuleUrl"]), b = Object.hasOwn(y, "timeoutMs") ? o(y.timeoutMs, 1, 3e5) : 3e4, x = Object.hasOwn(y, "maxArtifactBytes") ? o(y.maxArtifactBytes, 64, 16777216) : 16777216, S = Object.hasOwn(y, "maxOldGenerationMb") ? o(y.maxOldGenerationMb, 16, 1024) : 128, C = i(Object.hasOwn(y, "codecLimits") ? y.codecLimits : {}), w = y.worldModuleUrl, T = Object.hasOwn(y, "exportName") ? y.exportName : "default";
+		if (!v || v.static.kind !== "procedural" || typeof w != "string" || typeof T != "string" || !/^[A-Za-z_$][A-Za-z0-9_$]{0,95}$/.test(T)) return l.fail(h());
+		let E = new URL(w), D = C.get(v.kind) ?? {};
+		if (E.protocol !== "file:" || E.search || E.hash || !/\.m?js$/.test(E.pathname) && !(Object.hasOwn(y, "moduleLoaderUrl") && /\.m?ts$/.test(E.pathname))) return l.fail(h());
+		let O = v.static;
+		return l.uninterruptible(l.tryPromise({
+			try: async () => {
+				let e = u(E);
+				if (await f.realpath(e) !== e || !(await f.lstat(e)).isFile()) throw h();
+				let i = [];
+				if (Object.hasOwn(y, "moduleLoaderUrl")) {
+					if (typeof y.moduleLoaderUrl != "string") throw h();
+					let e = new URL(y.moduleLoaderUrl), t = u(e);
+					if (e.protocol !== "file:" || e.search || e.hash || await f.realpath(t) !== t || !(await f.lstat(t)).isFile()) throw h();
+					i.push("--import", e.href);
+				}
+				let o = m(E), c = d(o.resolve("@voltro/plugin-rooms/geometry/worker")), g = new p(c, {
+					env: {},
+					execArgv: i,
+					stdout: !0,
+					stderr: !0,
+					resourceLimits: { maxOldGenerationSizeMb: S },
+					workerData: {
+						moduleUrl: E.href,
+						exportName: T,
+						worldId: _.name,
+						kind: v.kind,
+						seed: O.seed,
+						chunkSizeRaw: v.chunkSizeRaw,
+						codecLimits: D,
+						maxBytes: x
+					}
+				});
+				g.stdout.resume(), g.stderr.resume();
+				let C = "busy", w = 0, k = null, A = 0, j, M, N, P, F, I = Promise.withResolvers(), L = () => {
+					P !== void 0 && clearTimeout(P), P = void 0, M = void 0, N = void 0;
+				}, R = async () => {
+					k === null && await g.terminate(), await I.promise;
+				};
+				g.on("exit", (e) => {
+					k = e, C !== "closing" && C !== "closed" && (C = "failed"), N?.(), I.resolve();
+				}), g.on("error", () => {
+					C = "failed", N?.();
+				}), g.on("messageerror", () => {
+					C = "failed", N?.();
+				}), g.on("message", (e) => {
+					M?.(e);
+				});
+				let z = (e) => new Promise((t, n) => {
+					M = (e) => {
+						L(), t(e);
+					}, N = () => {
+						L(), n(h());
+					}, P = setTimeout(() => {
+						C = "failed", N?.();
+					}, b);
+					try {
+						e?.();
+					} catch {
+						C = "failed", N?.();
+					}
+				});
+				try {
+					if (t(await z(), ["type"]).type !== "ready" || k !== null) throw h();
+					C = "ready";
+				} catch {
+					throw await R(), L(), h();
+				}
+				return Object.freeze({
+					generate: (e) => {
+						let i;
+						try {
+							if (i = a(e), i.kind !== v.kind || i.worldId !== _.name) return l.fail(h());
+						} catch {
+							return l.fail(h());
+						}
+						return l.uninterruptible(l.tryPromise({
+							try: async () => {
+								if (C !== "ready" || j || k !== null || A === 2 ** 53 - 1) throw h();
+								C = "busy";
+								let e = ++A, a = {
+									worldId: i.worldId,
+									layerSetId: i.layerSetId,
+									cx: i.cx,
+									cy: i.cy,
+									..."cz" in i ? { cz: i.cz } : {}
+								}, o = (async () => {
+									try {
+										let o = t(await z(() => g.postMessage({
+											type: "generate",
+											seq: e,
+											context: {
+												seed: O.seed,
+												kind: v.kind,
+												address: a,
+												version: i.version
+											}
+										})), [
+											"type",
+											"seq",
+											"blobSha256",
+											"contentSha256",
+											"bytes"
+										]);
+										if (o.type !== "generated" || o.seq !== e || !(o.bytes instanceof ArrayBuffer) || o.bytes.byteLength > x || typeof o.blobSha256 != "string") throw h();
+										let c = await n(v.kind, new Uint8Array(o.bytes), o.blobSha256, D);
+										if (r(c, i), c.contentSha256 !== o.contentSha256 || !s(c, v.chunkSizeRaw) || k !== null || C === "failed") throw h();
+										return w++, c;
+									} catch {
+										throw C = "failed", await R(), h();
+									} finally {
+										L(), j = void 0, C === "busy" && (C = "ready");
+									}
+								})();
+								return j = o, await o;
+							},
+							catch: () => h()
+						}));
+					},
+					close: () => l.uninterruptible(l.tryPromise({
+						try: async () => {
+							C !== "closed" && (F ||= (async () => {
+								C = "closing", j && await j.catch(() => void 0), await R(), L(), C = "closed";
+							})(), await F);
+						},
+						catch: () => h()
+					})),
+					observe: () => Object.freeze({
+						phase: C,
+						completedJobs: w,
+						exitCode: k
+					})
+				});
+			},
+			catch: () => h()
+		}));
+	} catch {
+		return l.fail(h());
+	}
+};
+export { g as openGeometryProceduralWorker };

package/dist/geometryPublication.js

@@ -0,0 +1,109 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { admitGeometryChunkForKind as r, captureGeometryArtifact as i } from "./geometryArtifacts.js";
+import { captureGeometryCodecProfiles as a, captureGeometryDense as o, captureGeometryStaticReference as s, geometryPersistenceId as c, geometryPersistenceInteger as l } from "./geometryPersistenceData.js";
+import { geometryChunkHasWorldExtent as u } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as d } from "./world.js";
+import { captureRoomSnapshotEffectRunner as f } from "./snapshotBlobIndex.js";
+import { captureGeometryVersion as p } from "./geometryPersistenceCapture.js";
+import { Effect as m } from "effect";
+// src/geometryPublication.ts
+var h = (h, g, _, v, y = {}) => {
+	try {
+		let b = d([h])[0], x = b.geometry, S = n(y, [
+			"maxChunks",
+			"maxArtifactBytes",
+			"maxManifestBytes",
+			"maxConcurrent",
+			"codecLimits"
+		], []), C = (e, t, n, r) => Object.hasOwn(S, e) ? l(S[e], n, r) : t, w = C("maxChunks", 256, 1, 4096), T = C("maxArtifactBytes", 52428800, 512, 268435456), E = C("maxManifestBytes", 262144, 1024, 16777216), D = C("maxConcurrent", Math.min(4, w), 1, Math.min(64, w)), O = a(Object.hasOwn(S, "codecLimits") ? S.codecLimits : {}), k = n(v, [
+			"tenantId",
+			"version",
+			"artifacts"
+		]), A = c(k.tenantId), j = c(k.version, 96), M = o(k.artifacts, w, i), N = n(g, [
+			"source",
+			"store",
+			"release",
+			"readGrants"
+		], ["store"]), P = n(_, [
+			"publish",
+			"observe",
+			"commit",
+			"exportSubject",
+			"eraseSubject"
+		], ["publish"]);
+		if (!x || !M.length || typeof N.store != "function" || typeof P.publish != "function") throw new t({ detail: "Geometry author publication needs declared kind and actual Storage/SQL capabilities" });
+		let F = 0, I = M.map((n) => {
+			let i = n.chunk;
+			if (i.kind !== x.kind || i.address.worldId !== b.name || i.version !== j || !u(n, x.chunkSizeRaw)) throw new t({ detail: "Geometry author artifact escaped its World/version/kind extent" });
+			if (r(i.kind, i, O.get(i.kind) ?? {}), F += n.bytes().length, F > T) throw new e({
+				budget: "geometryPublicationArtifactBytes",
+				limit: T
+			});
+			return s({
+				tenantId: A,
+				kind: i.kind,
+				worldId: i.address.worldId,
+				layerSetId: i.address.layerSetId,
+				version: j,
+				cx: i.address.cx,
+				cy: i.address.cy,
+				..."cz" in i.address ? { cz: i.address.cz } : {},
+				blobSha256: n.blobSha256,
+				contentSha256: n.contentSha256
+			});
+		}), L = p({
+			tenantId: A,
+			kind: x.kind,
+			worldId: b.name,
+			version: j,
+			chunks: I
+		}, w, E), R = N.store, z = P.publish;
+		return m.flatMap(m.context(), (r) => m.uninterruptible(m.tryPromise({
+			try: async () => {
+				let e = f(r), i = 0, a = !1, o, c = async () => {
+					for (; !a && i < M.length;) {
+						let n = i++;
+						try {
+							let r = R(A, M[n]);
+							if (!m.isEffect(r)) throw new t({ detail: "Geometry artifact storage must return an actual Effect" });
+							let i = s(await e(r));
+							if (JSON.stringify(i) !== JSON.stringify(I[n])) throw new t({ detail: "Geometry publication did not confirm its exact immutable object" });
+						} catch (e) {
+							a || (a = !0, o = e);
+						}
+					}
+				};
+				if (await Promise.all(Array.from({ length: Math.min(D, M.length) }, () => c())), a) throw o;
+				let l = z({
+					tenantId: A,
+					kind: L.kind,
+					worldId: L.worldId,
+					version: j,
+					chunks: L.chunks
+				});
+				if (!m.isEffect(l)) throw new t({ detail: "Geometry manifest publication must return an actual SQL Effect" });
+				let u = await e(l), d = n(u, [
+					"tenantId",
+					"kind",
+					"worldId",
+					"version",
+					"chunks",
+					"manifestSha256"
+				]), h = p({
+					tenantId: d.tenantId,
+					kind: d.kind,
+					worldId: d.worldId,
+					version: d.version,
+					chunks: d.chunks
+				}, w, E);
+				if (h.manifestSha256 !== L.manifestSha256 || d.manifestSha256 !== h.manifestSha256) throw new t({ detail: "Geometry SQL manifest publication did not confirm its exact complete content" });
+				return h;
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "Whole geometry author publication remains unconfirmed; retain exact artifacts" })
+		})));
+	} catch (n) {
+		return m.fail(n instanceof e ? n : new t({ detail: "Complete geometry author artifact inventory could not be captured" }));
+	}
+};
+export { h as publishGeometryArtifacts };

package/dist/geometryRayAlgebra.js

@@ -0,0 +1,115 @@
+import { addWide as e, compareWide as t, multiplyWide as n, subtractWide as r } from "./fixedWide.js";
+// src/geometryRayAlgebra.ts
+var i = [0], a = (e) => t(e, i), o = (e) => n(e, e), s = (e) => {
+	let t = [];
+	do
+		t.push(e % 65536), e = Math.floor(e / 65536);
+	while (e);
+	return t;
+}, c = (e) => ({
+	negative: e < 0,
+	value: s(Math.abs(e))
+}), l = (e) => ({
+	negative: !e.negative,
+	value: e.value
+}), u = (n, i) => n.negative === i.negative ? {
+	negative: n.negative,
+	value: e(n.value, i.value)
+} : t(n.value, i.value) >= 0 ? {
+	negative: n.negative,
+	value: r(n.value, i.value)
+} : {
+	negative: i.negative,
+	value: r(i.value, n.value)
+}, d = (e, t) => ({
+	negative: e.negative,
+	value: n(e.value, t)
+}), f = (e) => a(e.value) * (e.negative ? -1 : 1), p = (e, t) => e.reduce((e, r, i) => {
+	let a = t[i];
+	return u(e, {
+		negative: r < 0 != a < 0,
+		value: n(s(Math.abs(r)), s(Math.abs(a)))
+	});
+}, c(0)), m = (i, a, s) => {
+	let c = o(s), l = e(i, a);
+	if (t(c, l) < 0) return 1;
+	let u = r(c, l);
+	return t(n([4], n(i, a)), o(u));
+}, h = (i, a, s) => {
+	let c = e(o(i), a);
+	if (t(c, s) > 0) return 1;
+	let l = r(s, c);
+	return t(n([4], n(o(i), a)), o(l));
+}, g = (e, t) => {
+	let r = u(d(e.p, t.denominator), l(d(t.p, e.denominator))), i = n(e.q, o(t.denominator)), s = n(t.q, o(e.denominator)), c = e.radicalSign, p = -t.radicalSign, g = f(r);
+	if (c === p) return c > 0 ? g >= 0 ? g || a(i) || a(s) : m(i, s, r.value) : g <= 0 ? g || -a(i) || -a(s) : -m(i, s, r.value);
+	let _ = c > 0 ? i : s, v = c > 0 ? s : i;
+	return g >= 0 ? h(r.value, _, v) : -h(r.value, v, _);
+}, _ = (e, t) => {
+	let n = g(e, t);
+	return n === 0 ? 0 : n;
+}, v = (e, t = 1) => ({
+	p: c(e),
+	q: i,
+	radicalSign: 1,
+	denominator: s(t)
+}), y = (e, t, n, r) => {
+	let i = t.map((t, n) => t - e[n]), c = e.map((e, t) => e - n[t]), m = p(i, i).value, h = p(c, i), g = u(p(c, c), l({
+		negative: !1,
+		value: o(s(r))
+	}));
+	if (!a(m)) return f(g) <= 0 ? {
+		entry: v(0),
+		exit: v(1)
+	} : null;
+	let _ = u({
+		negative: !1,
+		value: o(h.value)
+	}, l(d(g, m)));
+	if (f(_) < 0) return null;
+	let y = l(h);
+	return {
+		entry: {
+			p: y,
+			q: _.value,
+			radicalSign: -1,
+			denominator: m
+		},
+		exit: {
+			p: y,
+			q: _.value,
+			radicalSign: 1,
+			denominator: m
+		}
+	};
+}, b = (e) => {
+	if (!e) return null;
+	let t = v(0), n = v(1), r = _(e.entry, t) < 0 ? t : e.entry, i = _(e.exit, n) > 0 ? n : e.exit;
+	return _(r, i) <= 0 ? {
+		entry: r,
+		exit: i
+	} : null;
+}, x = (e) => {
+	if (_(e, v(0)) === 0) return Object.freeze({
+		lower: 0,
+		upper: 0
+	});
+	if (_(e, v(1)) === 0) return Object.freeze({
+		lower: 1,
+		upper: 1
+	});
+	let t = 0, n = 1;
+	for (let r = 1; r <= 52; r++) {
+		let i = 2 ** r, a = (t + n) * i / 2, o = _(e, v(a, i)), s = a / i;
+		if (!o) return Object.freeze({
+			lower: s,
+			upper: s
+		});
+		o < 0 ? n = s : t = s;
+	}
+	return Object.freeze({
+		lower: t,
+		upper: n
+	});
+};
+export { b as clipGeometryRayInterval, _ as compareGeometryRayTime, v as geometryRayRational, y as geometryRaySphereInterval, x as geometryRayTimeBounds };

package/dist/geometryReadClient.js

@@ -0,0 +1,156 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryCodecProfiles as r, captureGeometryStaticReference as i, geometryPersistenceInteger as a } from "./geometryPersistenceData.js";
+import { BASE_NAME as o } from "./rpc.js";
+import { makeGeometryHttpStaticSource as s, reuseGeometryStaticArtifact as c } from "./geometryClientStatic.js";
+import { pluginTag as l } from "@voltro/protocol";
+// src/geometryReadClient.ts
+var u = (e) => {
+	if (typeof e != "string" || e.length > 16384) throw new t({ detail: "Actual geometry read URL response is unavailable" });
+	try {
+		let t = new URL(e);
+		if (!["http:", "https:"].includes(t.protocol) || t.username || t.password || t.hash) throw Error("Forbidden locator");
+		return t.href;
+	} catch {
+		throw new t({ detail: "Actual geometry read URL has forbidden locator authority" });
+	}
+}, d = (e) => {
+	let r = n(e, ["call", "subscribe"], ["call"]);
+	if (typeof r.call != "function") throw new t({ detail: "Geometry read grants require actual own RPC caller" });
+	let a = r.call.bind(e);
+	return Object.freeze({ grant: async (e, r) => {
+		let s = i(e);
+		if (!(r instanceof AbortSignal) || r.aborted) throw new t({ detail: "Geometry read URL request was closed" });
+		let c = n(await a(l(o, "geometry.staticUrl"), {
+			worldId: s.worldId,
+			layerSetId: s.layerSetId,
+			version: s.version,
+			cx: s.cx,
+			cy: s.cy,
+			...s.cz === void 0 ? {} : { cz: s.cz }
+		}, { signal: r }), ["url"]);
+		if (r.aborted) throw new t({ detail: "Actual geometry read URL response is unavailable" });
+		return u(c.url);
+	} });
+}, f = (e) => {
+	let t = n(e, [
+		"grants",
+		"fetch",
+		"maxResponseBytes",
+		"maxReadChunks",
+		"codecLimits"
+	], ["grants"]);
+	return p({
+		grants: t.grants,
+		...t,
+		maxCachedArtifacts: 0
+	}).source;
+}, p = (o) => {
+	let l = n(o, [
+		"grants",
+		"fetch",
+		"maxResponseBytes",
+		"maxReadChunks",
+		"codecLimits",
+		"maxCachedArtifacts",
+		"maxCachedBytes",
+		"maxInFlight"
+	], ["grants"]), d = n(l.grants, ["grant"]);
+	if (typeof d.grant != "function") throw new t({ detail: "Actual static HTTP grant source required" });
+	let f = d.grant.bind(l.grants), p = Object.hasOwn(l, "maxCachedArtifacts") ? a(l.maxCachedArtifacts, 0, 4096) : 32, m = Object.hasOwn(l, "maxCachedBytes") ? a(l.maxCachedBytes, 512, 67108864) : 16777216, h = Object.hasOwn(l, "maxInFlight") ? a(l.maxInFlight, 1, 64) : 4, g = Object.hasOwn(l, "codecLimits") ? r(l.codecLimits) : null, _ = Object.fromEntries(Object.entries(l).filter(([e]) => [
+		"fetch",
+		"maxResponseBytes",
+		"maxReadChunks",
+		"codecLimits"
+	].includes(e))), v = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), b = () => [...v.values()].reduce((e, t) => e + t.bytes, 0), x = Object.freeze({
+		..._,
+		...g ? { codecLimits: Object.freeze(Object.fromEntries(g)) } : {}
+	});
+	s({
+		...x,
+		urlFor: () => {
+			throw new t({ detail: "Actual per-call geometry read URL required" });
+		}
+	});
+	let S = !1, C = null, w = Object.freeze({ load: (n, r) => {
+		try {
+			let a = i(n);
+			if (S || !(r instanceof AbortSignal) || r.aborted) throw new t({ detail: "Static read grant source was closed" });
+			if (y.size >= h) throw new e({
+				budget: "geometryStaticReadJobs",
+				limit: h
+			});
+			let o = new AbortController(), l = () => o.abort(), d = JSON.stringify([
+				a.tenantId,
+				a.kind,
+				a.worldId,
+				a.layerSetId,
+				a.cx,
+				a.cy,
+				a.cz ?? null,
+				a.contentSha256
+			]), _ = () => {
+				if (S || o.signal.aborted) throw new t({ detail: "Static read grant source was closed" });
+			};
+			r.addEventListener("abort", l, { once: !0 });
+			let C = Promise.resolve().then(async () => {
+				_();
+				let n = f(a, o.signal);
+				if (!(n instanceof Promise)) throw new t({ detail: "Actual static read grant Promise required" });
+				let r = u(await n);
+				_();
+				let i = v.get(d), l = i ? await c(i.artifact, a, g?.get(a.kind) ?? {}) : null;
+				_();
+				let h = l ?? await s({
+					...x,
+					urlFor: () => r
+				}).load(a, o.signal);
+				if (_(), p > 0) {
+					let t = h.bytes().length;
+					if (t > m) throw new e({
+						budget: "geometryStaticCachedBytes",
+						limit: m
+					});
+					for (v.delete(d); v.size >= p || b() + t > m;) {
+						let t = v.keys().next().value;
+						if (t === void 0) throw new e({
+							budget: "geometryStaticCachedBytes",
+							limit: m
+						});
+						v.delete(t);
+					}
+					v.set(d, {
+						artifact: h,
+						bytes: t
+					});
+				}
+				return h;
+			}).catch((n) => {
+				throw n instanceof e ? n : new t({ detail: "Actual granted static geometry read remains unavailable" });
+			});
+			return y.set(C, o), C.then(() => {
+				r.removeEventListener("abort", l), y.delete(C);
+			}, () => {
+				r.removeEventListener("abort", l), y.delete(C);
+			}), C;
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	} });
+	return Object.freeze({
+		source: w,
+		observation: () => Object.freeze({
+			cached: v.size,
+			accountedBytes: b(),
+			active: y.size,
+			closed: S
+		}),
+		close: () => {
+			if (C) return C;
+			S = !0, v.clear();
+			for (let e of y.values()) e.abort();
+			return C = Promise.allSettled([...y.keys()]).then(() => void 0), C;
+		}
+	});
+};
+export { d as geometryRpcReadGrants, p as makeGrantedGeometryHttpStaticCache, f as makeGrantedGeometryHttpStaticSource };

package/dist/geometryReadPorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/geometryReadPorts.ts
+var t = class extends e.Service()("@voltro/GeometryStaticReadGrantPort") {};
+export { t as GeometryStaticReadGrantPort };

package/dist/geometryReadRpc.js

@@ -0,0 +1,26 @@
+import { ProtocolError as e } from "./errors.js";
+import { defineAction as t } from "@voltro/protocol";
+import { Schema as n } from "effect";
+// src/geometryReadRpc.ts
+var r = t({
+	name: "rooms.geometry.staticUrl",
+	input: n.Struct({
+		worldId: n.String,
+		layerSetId: n.String,
+		version: n.String,
+		cx: n.Int,
+		cy: n.Int,
+		cz: n.optional(n.Int)
+	}),
+	output: n.Struct({ url: n.String }),
+	error: e,
+	openAccess: "Geometry URL minting requires the current authenticated tenant player, permanent Subject admission, actual immutable SQL manifest and current World/Storage read policies; payloads contain requested scope only"
+}), i = Object.freeze([{
+	tag: "rooms.geometry.staticUrl",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-rooms/rpc",
+		name: "geometryStaticUrlDescriptor"
+	}
+}]);
+export { i as geometryReadRpcImports, r as geometryStaticUrlDescriptor };

package/dist/geometryReadRpcRoutes.js

@@ -0,0 +1,46 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryPersistenceScope as n } from "./geometryPersistenceData.js";
+import { geometryStaticUrlDescriptor as r } from "./geometryReadRpc.js";
+import { captureWorldCatalog as i } from "./world.js";
+import { Effect as a } from "effect";
+// src/geometryReadRpcRoutes.ts
+var o = (o, s) => {
+	let c = i(o);
+	return [{
+		...r,
+		execute: (r, i) => {
+			try {
+				let o = t(r, [
+					"worldId",
+					"layerSetId",
+					"version",
+					"cx",
+					"cy",
+					"cz"
+				], [
+					"worldId",
+					"layerSetId",
+					"version",
+					"cx",
+					"cy"
+				]), l = c.find((e) => e.name === o.worldId), u = i.request.subject;
+				if (!l?.geometry || u.type !== "user" || !u.tenantId.trim()) throw new e({ detail: "Static geometry grant requires actual installed World and authenticated tenant player" });
+				let d = n({
+					tenantId: u.tenantId,
+					kind: l.geometry.kind,
+					worldId: l.name,
+					layerSetId: o.layerSetId,
+					version: o.version,
+					cx: o.cx,
+					cy: o.cy,
+					...Object.hasOwn(o, "cz") ? { cz: o.cz } : {}
+				});
+				return s.grant(d, u).pipe(a.map((e) => ({ url: e })), a.mapError(() => new e({ detail: "Actual geometry read URL remains unavailable" })));
+			} catch {
+				return a.fail(new e({ detail: "Static geometry grant intention could not be captured" }));
+			}
+		}
+	}];
+};
+export { o as geometryReadRpcRoutes };