@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryAssetBundle.js

@@ -0,0 +1,117 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometrySha256 as r } from "./geometryDigest.js";
+import { geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureGeometryAssetManifest as a, captureGeometryAssetRoot as o } from "./geometryAssetData.js";
+//#region src/geometryAssetBundle.ts
+var s = /* @__PURE__ */ new WeakMap(), c = () => new t({ detail: "Geometry asset bundle requires its exact canonical catalogue and complete authorized verified loads" }), l = (t, l) => {
+	let u = n(l, [
+		"source",
+		"maxAssets",
+		"maxManifestBytes",
+		"maxBytes",
+		"maxConcurrent"
+	], ["source"]), d = Object.hasOwn(u, "maxAssets") ? i(u.maxAssets, 1, 4096) : 1024, f = Object.hasOwn(u, "maxManifestBytes") ? i(u.maxManifestBytes, 512, 16777216) : 524288, p = Object.hasOwn(u, "maxBytes") ? i(u.maxBytes, 1, 268435456) : 52428800, m = Object.hasOwn(u, "maxConcurrent") ? i(u.maxConcurrent, 1, 64) : 4, h = a(t, d, f), g = o({
+		tenantId: h.tenantId,
+		worldId: h.worldId,
+		layerSetId: h.layerSetId,
+		version: h.version
+	}), _ = u.source && typeof u.source == "object" ? Object.getOwnPropertyDescriptor(u.source, "load") : void 0, v = { load: _?.enumerable && "value" in _ ? _.value : void 0 };
+	if (typeof v.load != "function") throw c();
+	let y = u.source, b = v.load.bind(y), x = h.assets.reduce((e, t) => e + t.size, 0);
+	if (x > p) throw new e({
+		budget: "geometryAssetBundleBytes",
+		limit: p
+	});
+	let S = /* @__PURE__ */ new Map(), C = new AbortController(), w = null, T = !1, E = !1, D = () => [...S.values()].reduce((e, t) => e + t.size, 0), O = (e) => {
+		if (T || C.signal.aborted || e.aborted) throw c();
+	}, k = Object.freeze({
+		root: g,
+		at: (e) => {
+			if (T || !E) throw c();
+			let t = S.get(e);
+			if (!t) throw c();
+			return t;
+		},
+		observation: () => Object.freeze({
+			totalAssets: h.assets.length,
+			totalBytes: x,
+			loadedAssets: S.size,
+			loadedBytes: D(),
+			active: w !== null,
+			ready: E && !T,
+			closed: T
+		}),
+		preload: (t) => {
+			try {
+				if (!(t instanceof AbortSignal) || w) throw c();
+				O(t);
+				let i = new AbortController(), a = () => i.abort();
+				t.addEventListener("abort", a, { once: !0 }), C.signal.addEventListener("abort", a, { once: !0 }), E = !1;
+				let s = Promise.resolve().then(async () => {
+					let e = 0, a = !1, s = await Promise.allSettled(Array.from({ length: Math.min(m, h.assets.length) }, async () => {
+						try {
+							for (; e < h.assets.length && !a;) {
+								if (O(t), i.signal.aborted) throw c();
+								let a = h.assets[e++], s = Object.freeze({
+									...g,
+									key: a.key
+								}), l = b(s, i.signal);
+								if (!(l instanceof Promise)) throw c();
+								let u = await l, d = n(u, [
+									"root",
+									"key",
+									"checksum",
+									"size",
+									"contentType",
+									"bytes"
+								]), f = o(d.root);
+								if (typeof d.bytes != "function" || JSON.stringify(f) !== JSON.stringify(g) || d.key !== a.key || d.checksum !== a.checksum || d.size !== a.size || d.contentType !== a.contentType) throw c();
+								let m = d.bytes.call(u);
+								if (!(m instanceof Uint8Array) || m.length !== a.size || m.length > p) throw c();
+								let _ = new Uint8Array(m);
+								if (await r(_) !== a.checksum || (O(t), i.signal.aborted)) throw c();
+								S.set(a.key, Object.freeze({
+									root: g,
+									key: a.key,
+									checksum: a.checksum,
+									size: a.size,
+									contentType: a.contentType,
+									bytes: () => new Uint8Array(_)
+								}));
+							}
+						} catch (e) {
+							throw a = !0, i.abort(), e;
+						}
+					}));
+					if (O(t), s.some((e) => e.status === "rejected") || S.size !== h.assets.length) throw c();
+					E = !0;
+				}).catch((t) => {
+					throw t instanceof e ? t : c();
+				}).finally(() => {
+					t.removeEventListener("abort", a), C.signal.removeEventListener("abort", a);
+				});
+				return w = s, s.then(() => {
+					w = null;
+				}, () => {
+					w = null;
+				}), s;
+			} catch (t) {
+				return Promise.reject(t instanceof e ? t : c());
+			}
+		},
+		close: async () => {
+			T = !0, E = !1, C.abort(), S.clear(), w && await w.then(() => void 0, () => void 0);
+		}
+	});
+	return s.set(k, { root: g }), k;
+}, u = (e, t) => {
+	if (!e || typeof e != "object") throw c();
+	let n = s.get(e);
+	if (!n || t !== void 0 && n.root.worldId !== t) throw c();
+	let r = e;
+	if (r.observation().closed) throw c();
+	return r;
+};
+//#endregion
+export { u as captureGeometryAssetBundle, l as makeGeometryAssetBundle };

package/dist/geometryAssetClient.js

@@ -0,0 +1,25 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryAssetReadGrant as n, captureGeometryAssetReadRequest as r } from "./geometryAssetData.js";
+import { BASE_NAME as i } from "./rpc.js";
+import { pluginTag as a } from "@voltro/protocol";
+//#region src/geometryAssetClient.ts
+var o = (o) => {
+	let s = t(o, ["call", "subscribe"], ["call"]);
+	if (typeof s.call != "function") throw new e({ detail: "Geometry asset grants require actual own RPC caller" });
+	let c = s.call.bind(o);
+	return Object.freeze({ grant: async (t, o) => {
+		let s = r(t);
+		if (!(o instanceof AbortSignal) || o.aborted) throw new e({ detail: "Geometry asset read was closed" });
+		let l = await c(a(i, "geometry.assetUrl"), {
+			worldId: s.worldId,
+			layerSetId: s.layerSetId,
+			version: s.version,
+			key: s.key
+		}, { signal: o });
+		if (o.aborted) throw new e({ detail: "Geometry asset read was closed" });
+		return n(l);
+	} });
+};
+//#endregion
+export { o as geometryRpcAssetGrants };

package/dist/geometryAssetData.js

@@ -0,0 +1,106 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryDense as r, geometryPersistenceId as i, geometryPersistenceInteger as a } from "./geometryPersistenceData.js";
+import { geometryCatalogueDigest as o } from "./geometryCatalogueDigest.js";
+//#region src/geometryAssetData.ts
+var s = () => new t({ detail: "Geometry assets require a canonical exact World/version catalogue and real immutable Storage references" }), c = (e) => {
+	let t = n(e, [
+		"tenantId",
+		"worldId",
+		"layerSetId",
+		"version"
+	]);
+	return Object.freeze({
+		tenantId: i(t.tenantId),
+		worldId: i(t.worldId, 96),
+		layerSetId: i(t.layerSetId, 96),
+		version: i(t.version, 96)
+	});
+}, l = (e) => {
+	let t = n(e, [
+		"tenantId",
+		"worldId",
+		"layerSetId",
+		"version",
+		"key"
+	]), r = c({
+		tenantId: t.tenantId,
+		worldId: t.worldId,
+		layerSetId: t.layerSetId,
+		version: t.version
+	});
+	return Object.freeze({
+		...r,
+		key: i(t.key, 96)
+	});
+}, u = (e) => {
+	let t = n(e, [
+		"key",
+		"fileId",
+		"bucket",
+		"checksum",
+		"size",
+		"contentType"
+	]);
+	if (typeof t.checksum != "string" || !/^[a-f0-9]{64}$/.test(t.checksum) || typeof t.contentType != "string" || t.contentType.length > 128 || !/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/.test(t.contentType)) throw s();
+	return Object.freeze({
+		key: i(t.key, 96),
+		fileId: i(t.fileId),
+		bucket: i(t.bucket),
+		checksum: t.checksum,
+		size: a(t.size, 1, 268435456),
+		contentType: t.contentType
+	});
+}, d = (t, n, i = 1024, l = 524288) => {
+	let d = c(t), f = a(i, 1, 4096), p = a(l, 512, 16777216), m = r(n, f, u), h = /* @__PURE__ */ new Set();
+	for (let e of m) {
+		if (h.has(e.key)) throw s();
+		h.add(e.key);
+	}
+	let g = Object.freeze([...m].sort((e, t) => e.key < t.key ? -1 : +(e.key > t.key))), _ = {
+		...d,
+		assets: g
+	}, v = JSON.stringify(_);
+	if (new TextEncoder().encode(v).length > p) throw new e({
+		budget: "geometryAssetManifestBytes",
+		limit: p
+	});
+	return Object.freeze({
+		..._,
+		manifestSha256: o(v)
+	});
+}, f = (e, t = 1024, r = 524288) => {
+	let i = n(e, [
+		"tenantId",
+		"worldId",
+		"layerSetId",
+		"version",
+		"assets",
+		"manifestSha256"
+	]), a = d(c({
+		tenantId: i.tenantId,
+		worldId: i.worldId,
+		layerSetId: i.layerSetId,
+		version: i.version
+	}), i.assets, t, r);
+	if (a.manifestSha256 !== i.manifestSha256 || JSON.stringify(a.assets) !== JSON.stringify(i.assets)) throw s();
+	return a;
+}, p = (e) => {
+	let t = n(e, [
+		"url",
+		"checksum",
+		"size",
+		"contentType"
+	]);
+	if (typeof t.url != "string" || t.url.length > 16384 || typeof t.checksum != "string" || !/^[a-f0-9]{64}$/.test(t.checksum) || typeof t.contentType != "string" || t.contentType.length > 128 || !/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/.test(t.contentType)) throw s();
+	let r = new URL(t.url);
+	if (!["http:", "https:"].includes(r.protocol) || r.username || r.password || r.hash) throw s();
+	return Object.freeze({
+		url: r.href,
+		checksum: t.checksum,
+		size: a(t.size, 1, 268435456),
+		contentType: t.contentType
+	});
+};
+//#endregion
+export { f as captureGeometryAssetManifest, p as captureGeometryAssetReadGrant, l as captureGeometryAssetReadRequest, u as captureGeometryAssetReference, c as captureGeometryAssetRoot, d as geometryAssetManifest };

package/dist/geometryAssetHttp.js

@@ -0,0 +1,123 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometrySha256 as r } from "./geometryDigest.js";
+import { geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureGeometryAssetReadGrant as a, captureGeometryAssetReadRequest as o } from "./geometryAssetData.js";
+import { readGeometryHttp as s } from "./geometryHttpBody.js";
+//#region src/geometryAssetHttp.ts
+var c = () => new t({ detail: "Actual authorized immutable asset download or owned cleanup remains unavailable" }), l = (t) => {
+	let l = n(t, [
+		"grants",
+		"fetch",
+		"maxCachedAssets",
+		"maxCachedBytes",
+		"maxInFlight",
+		"maxResponseBytes",
+		"maxReadChunks"
+	], ["grants"]), u = n(l.grants, ["grant"]);
+	if (typeof u.grant != "function" || Object.hasOwn(l, "fetch") && typeof l.fetch != "function" || !Object.hasOwn(l, "fetch") && typeof globalThis.fetch != "function") throw c();
+	let d = u.grant.bind(l.grants), f = Object.hasOwn(l, "fetch") ? l.fetch.bind(t) : globalThis.fetch.bind(globalThis), p = Object.hasOwn(l, "maxCachedAssets") ? i(l.maxCachedAssets, 0, 4096) : 32, m = Object.hasOwn(l, "maxCachedBytes") ? i(l.maxCachedBytes, 1, 268435456) : 16777216, h = Object.hasOwn(l, "maxInFlight") ? i(l.maxInFlight, 1, 64) : 4, g = Object.hasOwn(l, "maxResponseBytes") ? i(l.maxResponseBytes, 1, 268435456) : 16777216, _ = Object.hasOwn(l, "maxReadChunks") ? i(l.maxReadChunks, 1, 65536) : 4096, v = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), b = !1, x = null, S = () => [...v.values()].reduce((e, t) => e + t.bytes.length, 0);
+	return Object.freeze({
+		load: (t, n) => {
+			try {
+				let i = o(t);
+				if (b || !(n instanceof AbortSignal) || n.aborted) throw c();
+				if (y.size >= h) throw new e({
+					budget: "geometryAssetReadJobs",
+					limit: h
+				});
+				let l = new AbortController(), u = () => l.abort(), x = () => {
+					if (b || l.signal.aborted) throw c();
+				};
+				n.addEventListener("abort", u, { once: !0 });
+				let C = Promise.resolve().then(async () => {
+					x();
+					let t = d(i, l.signal);
+					if (!(t instanceof Promise)) throw c();
+					let n = a(await t);
+					if (x(), n.size > g) throw new e({
+						budget: "geometryAssetResponseBytes",
+						limit: g
+					});
+					let o = JSON.stringify([
+						i.tenantId,
+						i.worldId,
+						i.layerSetId,
+						i.key,
+						n.checksum,
+						n.size,
+						n.contentType
+					]), u = v.get(o), h;
+					if (u) v.delete(o), v.set(o, u), h = u.bytes;
+					else {
+						let t = await s(() => n.url, f, l.signal, Math.min(g, n.size), _, (e) => {
+							let t = e.headers.get("content-length"), r = e.headers.get("content-encoding");
+							if ((r === null || r === "identity") && t !== null && Number(t) !== n.size) throw c();
+						}, {
+							contentType: n.contentType,
+							credentials: "omit"
+						});
+						if (x(), h = t.bytes, h.length !== n.size || await r(h) !== n.checksum) throw c();
+						if (x(), p > 0) {
+							if (h.length > m) throw new e({
+								budget: "geometryAssetCachedBytes",
+								limit: m
+							});
+							for (; v.size >= p || S() + h.length > m;) {
+								let e = v.keys().next().value;
+								if (e === void 0) throw c();
+								v.delete(e);
+							}
+							v.set(o, { bytes: h });
+						}
+					}
+					x();
+					let y = Object.freeze({
+						tenantId: i.tenantId,
+						worldId: i.worldId,
+						layerSetId: i.layerSetId,
+						version: i.version
+					});
+					return Object.freeze({
+						root: y,
+						key: i.key,
+						checksum: n.checksum,
+						size: n.size,
+						contentType: n.contentType,
+						bytes: () => new Uint8Array(h)
+					});
+				}).catch((t) => {
+					throw t instanceof e ? t : c();
+				});
+				return y.set(C, l), C.then(() => {
+					n.removeEventListener("abort", u), y.delete(C);
+				}, () => {
+					n.removeEventListener("abort", u), y.delete(C);
+				}), C;
+			} catch (t) {
+				return Promise.reject(t instanceof e ? t : c());
+			}
+		},
+		observation: () => Object.freeze({
+			cached: v.size,
+			cachedBytes: S(),
+			active: y.size,
+			closed: b
+		}),
+		close: () => {
+			b = !0, v.clear();
+			for (let e of y.values()) e.abort();
+			if (!x) {
+				let e = Promise.allSettled([...y.keys()]).then(() => void 0);
+				x = e, e.then(() => {
+					x = null;
+				}, () => {
+					x = null;
+				});
+			}
+			return x;
+		}
+	});
+};
+//#endregion
+export { l as makeGrantedGeometryAssetCache };

package/dist/geometryAssetPorts.js

@@ -0,0 +1,5 @@
+import { Context as e, Layer as t } from "effect";
+//#region src/geometryAssetPorts.ts
+var n = class extends e.Service()("@voltro/GeometryAssetManifestPort") {}, r = (e) => t.succeed(n, e), i = class extends e.Service()("@voltro/GeometryAssetReadGrantPort") {};
+//#endregion
+export { n as GeometryAssetManifestPort, i as GeometryAssetReadGrantPort, r as geometryAssetManifestLayer };

package/dist/geometryAssetRpc.js

@@ -0,0 +1,30 @@
+import { ProtocolError as e } from "./errors.js";
+import { defineAction as t } from "@voltro/protocol";
+import { Schema as n } from "effect";
+//#region src/geometryAssetRpc.ts
+var r = t({
+	name: "rooms.geometry.assetUrl",
+	input: n.Struct({
+		worldId: n.String,
+		layerSetId: n.String,
+		version: n.String,
+		key: n.String
+	}),
+	output: n.Struct({
+		url: n.String,
+		checksum: n.String,
+		size: n.Int,
+		contentType: n.String
+	}),
+	error: e,
+	openAccess: "Asset URL minting requires current authenticated tenant Subject admission, actual published catalogue and current World/Storage read policy; payloads contain requested asset intentions only"
+}), i = Object.freeze([{
+	tag: "rooms.geometry.assetUrl",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-rooms/rpc",
+		name: "geometryAssetUrlDescriptor"
+	}
+}]);
+//#endregion
+export { i as geometryAssetRpcImports, r as geometryAssetUrlDescriptor };

package/dist/geometryAssetRpcRoutes.js

@@ -0,0 +1,40 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryAssetReadGrant as n, captureGeometryAssetReadRequest as r } from "./geometryAssetData.js";
+import { geometryAssetUrlDescriptor as i } from "./geometryAssetRpc.js";
+import { captureWorldCatalog as a } from "./world.js";
+import { Effect as o } from "effect";
+//#region src/geometryAssetRpcRoutes.ts
+var s = (s, c) => {
+	let l = a(s);
+	return [{
+		...i,
+		execute: (i, a) => {
+			try {
+				let s = t(i, [
+					"worldId",
+					"layerSetId",
+					"version",
+					"key"
+				]), u = l.find((e) => e.name === s.worldId), d = a.request.subject;
+				if (!u?.geometry || d.type !== "user" || !d.tenantId.trim()) throw new e({ detail: "Geometry asset grant requires actual World and authenticated tenant Subject" });
+				let f = r({
+					tenantId: d.tenantId,
+					worldId: u.name,
+					layerSetId: s.layerSetId,
+					version: s.version,
+					key: s.key
+				}), p = c.grant(f, d);
+				if (!o.isEffect(p)) throw new e({ detail: "Actual geometry asset grant Effect required" });
+				return p.pipe(o.flatMap((t) => o.try({
+					try: () => n(t),
+					catch: () => new e({ detail: "Actual geometry asset grant response is unavailable" })
+				})), o.mapError(() => new e({ detail: "Actual geometry asset read grant remains unavailable" })));
+			} catch {
+				return o.fail(new e({ detail: "Geometry asset intention could not be captured" }));
+			}
+		}
+	}];
+};
+//#endregion
+export { s as geometryAssetRpcRoutes };

package/dist/geometryAssetStorageGrant.js

@@ -0,0 +1,103 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceInteger as r } from "./geometryPersistenceData.js";
+import { captureGeometryAssetManifest as i, captureGeometryAssetReadRequest as a } from "./geometryAssetData.js";
+import { captureWorldCatalog as o } from "./world.js";
+import { captureRoomSnapshotEffectRunner as s } from "./snapshotBlobIndex.js";
+import { Subject as c } from "@voltro/protocol";
+import { Effect as l, Schema as u } from "effect";
+//#region src/geometryAssetStorageGrant.ts
+var d = () => new t({ detail: "Actual current geometry asset catalogue, Storage reference or read authorization remains unconfirmed" }), f = (t, f) => {
+	let p = n(f, [
+		"worlds",
+		"manifest",
+		"origin",
+		"authorize",
+		"expiresInSec",
+		"maxAssets",
+		"maxManifestBytes",
+		"maxAssetBytes"
+	], [
+		"worlds",
+		"manifest",
+		"origin",
+		"authorize"
+	]), m = o(p.worlds), h = n(t, ["head", "mintUrl"]), g = n(p.manifest, ["observe"]), _ = Object.hasOwn(p, "expiresInSec") ? r(p.expiresInSec, 1, 3600) : 300, v = Object.hasOwn(p, "maxAssets") ? r(p.maxAssets, 1, 4096) : 1024, y = Object.hasOwn(p, "maxManifestBytes") ? r(p.maxManifestBytes, 512, 16777216) : 524288, b = Object.hasOwn(p, "maxAssetBytes") ? r(p.maxAssetBytes, 1, 268435456) : 16777216;
+	if (!m.some((e) => e.geometry) || typeof p.origin != "string" || typeof p.authorize != "function" || typeof h.head != "function" || typeof h.mintUrl != "function" || typeof g.observe != "function") throw d();
+	let x = new URL(p.origin);
+	if (!["http:", "https:"].includes(x.protocol) || x.username || x.password || x.search || x.hash || x.pathname !== "/") throw d();
+	let S = p.authorize.bind(f), C = p.manifest, w = g.observe.bind(C), T = h.head.bind(t), E = h.mintUrl.bind(t), D = (t, r, i) => {
+		if (!t) throw d();
+		let a = n(t, Object.keys(t), [
+			"id",
+			"tenantId",
+			"bucket",
+			"checksum",
+			"size",
+			"contentType"
+		]);
+		if (a.id !== i.fileId || a.tenantId !== r.tenantId || a.bucket !== i.bucket || a.checksum !== i.checksum || a.size !== i.size || a.contentType !== i.contentType) throw d();
+		if (i.size > b) throw new e({
+			budget: "geometryAssetReadBytes",
+			limit: b
+		});
+		return t;
+	};
+	return Object.freeze({ grant: (t, n) => {
+		try {
+			let r = a(t), o = u.decodeUnknownSync(c)(structuredClone(n));
+			if (!m.find((e) => e.name === r.worldId && e.geometry) || o.type !== "user" || o.tenantId !== r.tenantId || !o.id.trim()) throw d();
+			o.scopes && Object.freeze(o.scopes), Object.freeze(o);
+			let f = Object.freeze({
+				tenantId: r.tenantId,
+				worldId: r.worldId,
+				layerSetId: r.layerSetId,
+				version: r.version
+			});
+			return l.flatMap(l.context(), (t) => l.uninterruptible(l.tryPromise({
+				try: async () => {
+					let e = s(t), n = async () => {
+						let t = S(r, o);
+						if (!l.isEffect(t) || await e(t) !== void 0) throw d();
+					}, a = async () => {
+						let t = w(f);
+						if (!l.isEffect(t)) throw d();
+						let n = i(await e(t), v, y);
+						if (JSON.stringify({
+							tenantId: n.tenantId,
+							worldId: n.worldId,
+							layerSetId: n.layerSetId,
+							version: n.version
+						}) !== JSON.stringify(f)) throw d();
+						return n;
+					};
+					await n();
+					let c = await a(), u = c.assets.find((e) => e.key === r.key);
+					if (!u) throw d();
+					let p = T(u.fileId, { tenantId: r.tenantId });
+					if (!l.isEffect(p)) throw d();
+					D(await e(p), r, u);
+					let m = E(u.fileId, o, { expiresInSec: _ });
+					if (!l.isEffect(m)) throw d();
+					let h = await e(m);
+					if (typeof h != "string" || h.length > 16384) throw d();
+					let g = new URL(h, x);
+					if (!["http:", "https:"].includes(g.protocol) || g.username || g.password || g.hash || (await a()).manifestSha256 !== c.manifestSha256) throw d();
+					let b = T(u.fileId, { tenantId: r.tenantId });
+					if (!l.isEffect(b)) throw d();
+					return D(await e(b), r, u), await n(), Object.freeze({
+						url: g.href,
+						checksum: u.checksum,
+						size: u.size,
+						contentType: u.contentType
+					});
+				},
+				catch: (t) => t instanceof e ? t : d()
+			})));
+		} catch (t) {
+			return l.fail(t instanceof e ? t : d());
+		}
+	} });
+};
+//#endregion
+export { f as storageGeometryAssetReadGrants };

package/dist/geometryBoxOverlap.js

@@ -0,0 +1,110 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { addUint64 as n, compareUint64 as r, multiplyWords as i } from "./fixedWords.js";
+import { geometryOwnData as a } from "./geometryTileCodec.js";
+import { captureGeometryPreparedInventory as o } from "./geometryPrepared.js";
+//#region src/geometryBoxOverlap.ts
+function s() {
+	throw new t({ detail: "Geometry box overlap needs a complete genuine native collision region and a supported bounded profile" });
+}
+var c = (e) => typeof e == "number" && Number.isSafeInteger(e) && e >= -2147483648 && e <= 2147483647 ? e === 0 ? 0 : e : s(), l = (e, t, a) => {
+	let o = [
+		e.xRaw,
+		e.yRaw,
+		e.zRaw
+	];
+	if (e.kind === "aabb") {
+		let n = [
+			e.halfXRaw,
+			e.halfYRaw,
+			e.halfZRaw
+		];
+		return o.every((e, r) => e + n[r] >= t[r] && e - n[r] < a[r]);
+	}
+	let s = o.map((e, n) => e < t[n] ? t[n] - e : e >= a[n] ? e - a[n] : 0);
+	if (s.some((t) => t > e.radiusRaw)) return !1;
+	let c = s.reduce((e, t) => n(e, i(t, t)), {
+		hi: 0,
+		lo: 0
+	}), l = r(c, i(e.radiusRaw, e.radiusRaw));
+	return l < 0 || l === 0 && o.every((e, t) => e < a[t]);
+}, u = (t, n, r, i) => {
+	let u = o(t), d = u.scope.kind, f = d === "3d-voxel" || d === "3d-shapes", p = a(r, f ? [
+		"minXRaw",
+		"minYRaw",
+		"minZRaw",
+		"maxXRaw",
+		"maxYRaw",
+		"maxZRaw"
+	] : [
+		"minXRaw",
+		"minYRaw",
+		"maxXRaw",
+		"maxYRaw"
+	]), m = [
+		c(p.minXRaw),
+		c(p.minYRaw),
+		...f ? [c(p.minZRaw)] : []
+	], h = [
+		c(p.maxXRaw),
+		c(p.maxYRaw),
+		...f ? [c(p.maxZRaw)] : []
+	];
+	if (d === "2d-heightfield" || !Number.isSafeInteger(n) || n < 1 || n > 2147483647 || !Number.isSafeInteger(i) || i < 1 || i > 1048576 || m.some((e, t) => e >= h[t])) return s();
+	let g = 0, _ = () => {
+		if (++g > i) throw new e({
+			budget: "geometryOverlapTests",
+			limit: i
+		});
+	}, v = (e) => m.map((t, n) => ({
+		first: Math.floor(t / e),
+		last: Math.floor((h[n] - 1) / e)
+	})), y = (t) => {
+		let n = 1;
+		for (let r of t) {
+			let t = r.last - r.first + 1;
+			if (t > i || n * t > i) throw new e({
+				budget: "geometryOverlapTests",
+				limit: i
+			});
+			n *= t;
+		}
+	}, b = (e, t) => {
+		for (let n = f ? e[2].first : 0; n <= (f ? e[2].last : 0); n++) for (let r = e[1].first; r <= e[1].last; r++) for (let i = e[0].first; i <= e[0].last; i++) if (t(i, r, f ? n : void 0)) return !0;
+		return !1;
+	};
+	if (d === "3d-shapes") {
+		let e = v(n);
+		return y(e), b(e, (e, t, r) => {
+			_();
+			let i = u.at({
+				cx: e,
+				cy: t,
+				cz: r
+			}).collision;
+			if (i.kind !== "3d-shapes" || i.view.chunk.extentXRaw !== n || i.view.chunk.extentYRaw !== n || i.view.chunk.extentZRaw !== n) return s();
+			let a = [
+				e * n,
+				t * n,
+				r * n
+			], o = m.map((e, t) => Math.max(0, e - a[t])), c = h.map((e, t) => Math.min(n, e - a[t]));
+			for (let e of i.view.chunk.shapes) if (_(), l(e, o, c)) return !0;
+			return !1;
+		});
+	}
+	let x = u.at({
+		cx: Math.floor(m[0] / n),
+		cy: Math.floor(m[1] / n),
+		...f ? { cz: Math.floor(m[2] / n) } : {}
+	}).collision, S = x.kind === "2d-tiles" ? x.view.chunk.width : x.kind === "3d-voxel" ? x.view.chunk.side : s(), C = x.kind === "2d-tiles" ? x.view.chunk.tileSizeRaw : x.kind === "3d-voxel" ? x.view.chunk.voxelSizeRaw : s(), w = v(C);
+	return x.kind !== d || S * C !== n || x.kind === "2d-tiles" && x.view.chunk.height !== S ? s() : (y(w), b(w, (e, t, n) => {
+		_();
+		let r = Math.floor(e / S), i = Math.floor(t / S), a = f ? Math.floor(n / S) : void 0, o = u.at({
+			cx: r,
+			cy: i,
+			...a === void 0 ? {} : { cz: a }
+		}).collision, c = e - r * S, l = t - i * S, p = f ? n - a * S : void 0;
+		return d === "2d-tiles" && o.kind === "2d-tiles" && o.view.chunk.width === S && o.view.chunk.height === S && o.view.chunk.tileSizeRaw === C ? o.view.solidAt(c, l) : d === "3d-voxel" && o.kind === "3d-voxel" && o.view.chunk.side === S && o.view.chunk.voxelSizeRaw === C ? o.view.solidAt(c, l, p) : s();
+	}));
+};
+//#endregion
+export { u as overlapsPreparedGeometryBox };