@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryClient.js

@@ -0,0 +1,148 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { RoomInputCodec as n } from "./stateCodec.js";
+import { geometryOwnData as r } from "./geometryTileCodec.js";
+import { geometryPersistenceId as i, geometryPersistenceInteger as a } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedBaseline as o, captureGeometryPreparedInventory as s } from "./geometryPrepared.js";
+import { captureGeometryActorFrame as c, makeGeometryActorInventory as l, sealGeometryActivation as u } from "./geometryActorInventory.js";
+import { captureGeometryAssetManifest as d, captureGeometryAssetReadGrant as f, captureGeometryAssetReadRequest as p, captureGeometryAssetReference as m, captureGeometryAssetRoot as h, geometryAssetManifest as g } from "./geometryAssetData.js";
+import { makeGeometryAssetBundle as _ } from "./geometryAssetBundle.js";
+import { geometryClientFieldsAtDistance as v, geometryTransformInterest2D as y, planGeometryClientInterest as b } from "./geometryClientInterest.js";
+import { prepareGeometryClientDelta as x } from "./geometryClientDelta.js";
+import { decodeGeometryChunkHttpScope as S, geometryChunkHttpHeaders as C, geometryChunkHttpQuery as w, geometryChunkHttpResponse as T } from "./geometryChunkHttp.js";
+import { GeometryDeltaFragmentSchema as E, makeGeometryDeltaReceiver as D } from "./geometryChannel.js";
+import { captureRoomClientReliableChannel as O } from "./web.js";
+import { makeRoomGeometryChunkCache as k } from "./geometryClientChunks.js";
+import { defaultGeometryHeightfieldLodStride as A, prepareGeometryHeightfieldLod as j, prepareGeometryRenderLod as M } from "./geometryRenderLod.js";
+import { makeGeometryRenderLodCache as N } from "./geometryRenderCache.js";
+import { captureGeometryStreamManifest as P } from "./geometryManifestData.js";
+import { makeGeometryHttpChunkSource as F } from "./geometryClientHttp.js";
+import { makeRoomGeometrySnapshotSource as I } from "./geometrySnapshotClient.js";
+import { makeRoomConnectionGeometryCache as L, makeRoomConnectionGeometrySnapshotSource as R, prefetchRoomConnectionGeometryCache as z } from "./geometryConnectionClient.js";
+import { makeRoomConnectionGeometryManifestClient as B, makeRoomGeometryManifestClient as V } from "./geometryManifestClient.js";
+import { makeGeometryHttpStaticSource as H, reuseGeometryStaticArtifact as U } from "./geometryClientStatic.js";
+import { makeManifestGeometryChunkSource as W } from "./geometryManifestSource.js";
+import { geometryRpcReadGrants as G, makeGrantedGeometryHttpStaticCache as K, makeGrantedGeometryHttpStaticSource as q } from "./geometryReadClient.js";
+import { makeRoomConnectionGeometryVersionClient as J, makeRoomGeometryVersionClient as Y } from "./geometryVersionClient.js";
+import { geometryRpcAssetGrants as X } from "./geometryAssetClient.js";
+import { makeGrantedGeometryAssetCache as Z } from "./geometryAssetHttp.js";
+import { makeGeometryAdminClient as Q } from "./geometryAdminClient.js";
+// src/geometryClient.ts
+function $() {
+	throw new t({ detail: "Room geometry client lost its exact admitted baseline or delivery" });
+}
+var ee = (d, f, p = {}) => {
+	let m = s(f), h = l(m), g = m.scope, _ = r(p, [
+		"channel",
+		"maxQueued",
+		"maxQueuedBytes",
+		"maxPatchBytes",
+		"maxHistory",
+		"maxHistoryBytes"
+	], []), v = (e, t, n, r) => Object.hasOwn(_, e) ? a(_[e], n, r) : t, y = v("maxQueued", 4, 1, 256), b = v("maxPatchBytes", 262144, 512, 16777216), S = v("maxQueuedBytes", Math.max(1048576, b), 512, 67108864), C = v("maxHistory", 16, 1, 4096), w = v("maxHistoryBytes", Math.max(1048576, b), 512, 67108864), T = Object.hasOwn(_, "channel") ? i(_.channel, 96) : "geometry", k = O(d, T, new n(E).schemaHash), A = k.identity(), j = D({
+		maxPending: y,
+		maxPatchBytes: b,
+		maxPendingBytes: S
+	}), M = [], N = /* @__PURE__ */ new Map(), P = [];
+	if (!A) return $();
+	let F = null, I = null, L = !1, R = !1, z = null, B = () => M.reduce((e, t) => e + t.bytes.length, 0), V = () => [...N.values()].reduce((e, t) => e + t.bytes.length, 0), H = () => !R && JSON.stringify(k.identity()) === JSON.stringify(A), U = (e) => JSON.stringify([e.scope, e.requestId]), W = (e, t) => JSON.stringify(e.receipt) === JSON.stringify(t.receipt) && e.bytes.length === t.bytes.length && e.bytes.every((e, n) => e === t.bytes[n]), G = () => {
+		R = !0, j.reset(), M.length = 0, N.clear(), h.close();
+		for (let e of P.splice(0)) e();
+	}, K = (n) => {
+		if (!H()) G();
+		else try {
+			let t = j.receive(n);
+			if (t._tag === "pending") return;
+			let r = t.receipt.scope;
+			if (r.tenantId !== g.tenantId || r.kind !== g.kind || r.worldId !== g.worldId || r.layerSetId !== g.layerSetId || r.version !== g.version) return $();
+			if (M.length >= y) throw new e({
+				budget: "geometryClientQueuedOperations",
+				limit: y
+			});
+			if (B() + t.patch.length > S) throw new e({
+				budget: "geometryClientQueuedBytes",
+				limit: S
+			});
+			M.push({
+				receipt: t.receipt,
+				bytes: t.patch
+			});
+		} catch (n) {
+			z = n instanceof e ? n : new t({ detail: "Room geometry reliable delivery could not be admitted" }), G();
+		}
+	};
+	try {
+		if (P.push(k.onMessage(K)), P.push(k.subscribe(() => {
+			H() || G();
+		})), !H()) return $();
+	} catch (e) {
+		throw G(), e;
+	}
+	return Object.freeze({
+		at: (e) => H() ? h.at(e) : (G(), $()),
+		contains: (e) => H() ? h.contains(e) : (G(), $()),
+		observation: () => {
+			let e = j.observation();
+			return Object.freeze({
+				queued: M.length,
+				queuedBytes: B(),
+				receiving: e.pending,
+				receivingBytes: e.accountedBytes,
+				history: N.size,
+				historyBytes: V(),
+				active: L,
+				withdrawn: R,
+				failed: z !== null,
+				generation: h.observation().generation
+			});
+		},
+		pump: async () => {
+			if (z) throw z;
+			if (!H() || L) return $();
+			L = !0, F = new Promise((e) => {
+				I = e;
+			});
+			let n = 0, r = 0, i = 0;
+			try {
+				for (; M.length;) {
+					let t = M[0], a = U(t.receipt), s = c(h), l = t.receipt.scope, d = {
+						cx: l.cx,
+						cy: l.cy,
+						...l.cz === void 0 ? {} : { cz: l.cz }
+					}, f = o(s, d), p = N.get(a);
+					if (p) {
+						if (!W(p, t) || f.revision < t.receipt.revision || f.revision === t.receipt.revision && (f.artifact.blobSha256 !== t.receipt.blobSha256 || f.artifact.contentSha256 !== t.receipt.contentSha256)) return $();
+						M.shift(), r++;
+						continue;
+					}
+					if (t.bytes.length > w) throw new e({
+						budget: "geometryClientHistoryBytes",
+						limit: w
+					});
+					let m = await x(s, t.receipt, t.bytes, b);
+					if (!H() || c(h) !== s) return $();
+					let g = h.activate(u(h, s, m, t.receipt));
+					for (; N.size >= C || V() + t.bytes.length > w;) {
+						let e = N.keys().next().value;
+						if (e === void 0) return $();
+						N.delete(e);
+					}
+					N.set(a, t), M.shift(), g ? n++ : i++;
+				}
+				return Object.freeze({
+					applied: n,
+					duplicates: r,
+					unchanged: i
+				});
+			} catch (n) {
+				throw z = n instanceof e ? n : new t({ detail: "Room geometry baseline or native application requires explicit recovery" }), z;
+			} finally {
+				L = !1, I?.(), I = null, F = null;
+			}
+		},
+		close: async () => {
+			let e = F;
+			G(), e && await e;
+		}
+	});
+};
+export { d as captureGeometryAssetManifest, f as captureGeometryAssetReadGrant, p as captureGeometryAssetReadRequest, m as captureGeometryAssetReference, h as captureGeometryAssetRoot, P as captureGeometryStreamManifest, S as decodeGeometryChunkHttpScope, A as defaultGeometryHeightfieldLodStride, g as geometryAssetManifest, C as geometryChunkHttpHeaders, w as geometryChunkHttpQuery, T as geometryChunkHttpResponse, v as geometryClientFieldsAtDistance, X as geometryRpcAssetGrants, G as geometryRpcReadGrants, y as geometryTransformInterest2D, Q as makeGeometryAdminClient, _ as makeGeometryAssetBundle, F as makeGeometryHttpChunkSource, H as makeGeometryHttpStaticSource, N as makeGeometryRenderLodCache, Z as makeGrantedGeometryAssetCache, K as makeGrantedGeometryHttpStaticCache, q as makeGrantedGeometryHttpStaticSource, W as makeManifestGeometryChunkSource, L as makeRoomConnectionGeometryCache, B as makeRoomConnectionGeometryManifestClient, R as makeRoomConnectionGeometrySnapshotSource, J as makeRoomConnectionGeometryVersionClient, k as makeRoomGeometryChunkCache, ee as makeRoomGeometryClient, V as makeRoomGeometryManifestClient, I as makeRoomGeometrySnapshotSource, Y as makeRoomGeometryVersionClient, b as planGeometryClientInterest, z as prefetchRoomConnectionGeometryCache, j as prepareGeometryHeightfieldLod, M as prepareGeometryRenderLod, U as reuseGeometryStaticArtifact };

package/dist/geometryClientChunks.js

@@ -0,0 +1,329 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { captureSimulationBytes as n } from "./simulationBytes.js";
+import { RoomInputCodec as r } from "./stateCodec.js";
+import { geometryOwnData as i } from "./geometryTileCodec.js";
+import { verifyGeometryArtifact as a } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as o, captureGeometryCodecProfiles as s, captureGeometryDense as c, captureGeometryPersistenceScope as l, geometryPersistenceId as u, geometryPersistenceInteger as d } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedBaseline as f, captureGeometryPreparedCoordinate as p, captureGeometryPreparedScope as m, prepareGeometryInventory as ee } from "./geometryPrepared.js";
+import { planGeometryClientInterest as h } from "./geometryClientInterest.js";
+import { prepareGeometryClientDelta as g } from "./geometryClientDelta.js";
+import { GeometryDeltaFragmentSchema as _, captureGeometryDeltaFragment as v, makeGeometryDeltaReceiver as y } from "./geometryChannel.js";
+import { captureRoomClientReliableChannel as te } from "./web.js";
+import { geometryChunkHasWorldExtent as ne } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as re } from "./world.js";
+// src/geometryClientChunks.ts
+var b = /* @__PURE__ */ new WeakMap();
+function x() {
+	throw new t({ detail: "Room geometry chunk cache requires its exact current admission and actual verified source" });
+}
+var S = (S, ie, ae, C, oe = {}) => {
+	let w = re([ie])[0], T = m(ae), E = w.geometry;
+	if (!E || T.worldId !== w.name || T.kind !== E.kind) return x();
+	let D = i(oe, [
+		"channel",
+		"maxCachedChunks",
+		"maxConcurrent",
+		"maxCacheBytes",
+		"maxStagedBytes",
+		"maxChunkBytes",
+		"maxPendingDeltas",
+		"maxQueuedDeltaBytes",
+		"codecLimits"
+	], []), O = (e, t, n, r) => Object.hasOwn(D, e) ? d(D[e], n, r) : t, k = O("maxCachedChunks", E.streaming.client.maxCachedChunks, 1, E.streaming.client.maxCachedChunks), se = O("maxConcurrent", Math.min(E.streaming.client.maxConcurrent, k), 1, Math.min(E.streaming.client.maxConcurrent, k)), A = O("maxCacheBytes", E.budgets.maxPreparedBytes, 512, E.budgets.maxPreparedBytes), j = O("maxStagedBytes", A, 512, E.budgets.maxPreparedBytes), ce = O("maxChunkBytes", Math.min(16777216, j), 512, Math.min(16777216, j)), le = (Object.hasOwn(D, "codecLimits") ? s(D.codecLimits) : /* @__PURE__ */ new Map()).get(T.kind) ?? {}, ue = O("maxPendingDeltas", 64, 1, 256), de = E.dynamic.maxDeltaBytesPerChunk, fe = O("maxQueuedDeltaBytes", Math.min(1048576, j), 512, Math.min(67108864, j)), pe = Object.hasOwn(D, "channel") ? u(D.channel, 96) : "geometry", M = te(S, pe, new r(_).schemaHash), me = M.identity();
+	if (!me) return x();
+	let he = i(C, ["load"]);
+	if (typeof he.load != "function") return x();
+	let ge = he.load.bind(C), _e = new AbortController(), N = [], P = y({
+		maxPending: ue,
+		maxPatchBytes: de,
+		maxPendingBytes: fe
+	}), F = [], I = /* @__PURE__ */ new Map(), ve = () => F.reduce((e, t) => e + t.patch.length, 0), L = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Set(), z = /* @__PURE__ */ new Map(), B = !1, V = !1, H = 0, U = 0, W = null, G = null, K = (e) => ({
+		cx: e.cx,
+		cy: e.cy,
+		...e.cz === void 0 ? {} : { cz: e.cz }
+	}), q = (e) => JSON.stringify([
+		e.cx,
+		e.cy,
+		e.cz ?? null
+	]), ye = () => !V && JSON.stringify(M.identity()) === JSON.stringify(me), J = () => {
+		V = !0, _e.abort(), P.reset(), I.clear(), F.length = 0, z.clear(), L.clear(), R.clear();
+		for (let e of N.splice(0)) e();
+	}, Y = () => {
+		if (!ye()) return J(), x();
+	}, X = (e) => [...e.values()].reduce((e, t) => e + t.inventory.accountedBytes, 0), Z = (e, t) => {
+		let n = L.get(e), r = {
+			cx: t.scope.cx,
+			cy: t.scope.cy,
+			...t.scope.cz === void 0 ? {} : { cz: t.scope.cz }
+		}, i = t.inventory.at(r);
+		return !n || i.revision > n.revision || i.revision === n.revision && i.blobSha256 === n.blobSha256 && i.contentSha256 === n.contentSha256;
+	}, Q = () => {
+		for (let e of L.keys()) !z.has(e) && !R.has(e) && L.delete(e);
+		for (let [e, t] of I) !z.has(e) && !R.has(e) && (P.drop(t.scope, t.requestId), I.delete(e));
+	}, be = (t) => {
+		if (!ye()) J();
+		else try {
+			let n = v(t, { maxPatchBytes: de }), r = n.receipt, i = r.scope;
+			if (i.tenantId !== T.tenantId || i.kind !== T.kind || i.worldId !== T.worldId || i.layerSetId !== T.layerSetId || i.version !== T.version) return x();
+			let a = q(i);
+			if (!z.has(a) && !R.has(a)) return;
+			let o = L.get(a), s = z.get(a)?.inventory.at(K(i));
+			if (s && r.revision < s.revision || o && r.revision < o.revision) return;
+			if (o && r.revision === o.revision && (r.blobSha256 !== o.blobSha256 || r.contentSha256 !== o.contentSha256) || s && r.revision === s.revision && (r.blobSha256 !== s.blobSha256 || r.contentSha256 !== s.contentSha256)) return x();
+			L.set(a, {
+				revision: r.revision,
+				blobSha256: r.blobSha256,
+				contentSha256: r.contentSha256
+			});
+			let c = I.get(a);
+			c && c.requestId !== r.requestId && (P.drop(c.scope, c.requestId), I.delete(a));
+			let l = P.receive(n);
+			if (l._tag === "pending" ? I.set(a, {
+				scope: i,
+				requestId: r.requestId,
+				revision: r.revision
+			}) : I.delete(a), l._tag === "complete") {
+				if (F.length >= ue) throw new e({
+					budget: "geometryClientPendingDeltas",
+					limit: ue
+				});
+				if (ve() + l.patch.length > fe) throw new e({
+					budget: "geometryClientQueuedDeltaBytes",
+					limit: fe
+				});
+				F.push({
+					receipt: l.receipt,
+					patch: l.patch
+				});
+			}
+		} catch {
+			J();
+		}
+	};
+	try {
+		N.push(M.onMessage(be)), N.push(M.subscribe(() => {
+			ye() || J();
+		})), Y();
+	} catch (e) {
+		throw J(), e;
+	}
+	let $ = async (r, s) => {
+		if (Y(), B) return x();
+		let u = c(r, k, (e) => p(T, e)), f = /* @__PURE__ */ new Set();
+		for (let e of u) {
+			if (f.has(q(e))) return x();
+			f.add(q(e));
+		}
+		if (!u.length) return x();
+		let m = u.filter((e) => s || !z.has(q(e)) || !Z(q(e), z.get(q(e)))), h = /* @__PURE__ */ new Map();
+		for (let e of f) R.add(e);
+		B = !0;
+		let g;
+		W = new Promise((e) => {
+			g = e;
+		});
+		let _ = 0, v = !1, y, te = async () => {
+			for (; !v && _ < m.length;) {
+				let t = m[_++];
+				try {
+					Y();
+					let r = ge(t, _e.signal);
+					if (!(r instanceof Promise)) return x();
+					let s = i(await r, [
+						"scope",
+						"revision",
+						"bytes",
+						"blobSha256",
+						"contentSha256"
+					]), c = l(s.scope), u = d(s.revision), f = n(s.bytes, ce, "geometryClientChunkBytes");
+					if (JSON.stringify(c) !== JSON.stringify(t)) return x();
+					let p = await a(T.kind, f, s.blobSha256, le);
+					if (Y(), o(p, t), p.contentSha256 !== s.contentSha256 || !ne(p, E.chunkSizeRaw)) return x();
+					let m = ee(T, [{
+						scope: t,
+						revision: u,
+						artifact: p
+					}], {
+						maxChunks: 1,
+						maxAccountedBytes: j,
+						codecLimits: { [T.kind]: le }
+					});
+					if (U + m.accountedBytes > j) throw new e({
+						budget: "geometryClientStagedBytes",
+						limit: j
+					});
+					let g = q(t), _ = z.get(g)?.inventory.at(K(t)), v = {
+						scope: t,
+						inventory: m
+					};
+					if (_ && (u < _.revision || u === _.revision && (p.blobSha256 !== _.blobSha256 || p.contentSha256 !== _.contentSha256)) || !Z(g, v)) return x();
+					h.set(g, v), H++, U += m.accountedBytes;
+				} catch (e) {
+					v || (v = !0, y = e);
+				}
+			}
+		};
+		try {
+			if (await Promise.all(Array.from({ length: Math.min(se, m.length) }, () => te())), v) throw y;
+			Y();
+			let t = new Map(z);
+			for (let e of u) {
+				let n = q(e), r = h.get(n) ?? t.get(n);
+				if (!r || !Z(n, r)) return x();
+				t.delete(n), t.set(n, r);
+			}
+			for (; t.size > k || X(t) > A;) {
+				let n = [...t.keys()].find((e) => !f.has(e));
+				if (n === void 0) throw new e({
+					budget: "geometryClientCacheBytes",
+					limit: A
+				});
+				t.delete(n);
+			}
+			z = t, Q();
+		} catch (n) {
+			throw n instanceof e ? n : new t({ detail: "Complete verified client geometry download remains unavailable" });
+		} finally {
+			B = !1, H = 0, U = 0, h.clear(), R.clear(), Q(), g?.(), W = null;
+		}
+	}, xe = async () => {
+		if (Y(), B) return x();
+		B = !0;
+		let n;
+		W = new Promise((e) => {
+			n = e;
+		});
+		let r = 0, i = 0, a = 0, o = /* @__PURE__ */ new Map();
+		try {
+			for (; F.length;) {
+				Y();
+				let t = F[0], n = t.receipt.scope, s = q(n), c = z.get(s), l = {
+					cx: n.cx,
+					cy: n.cy,
+					...n.cz === void 0 ? {} : { cz: n.cz }
+				};
+				if (!c) {
+					F.shift(), a++;
+					continue;
+				}
+				let u = c.inventory.at(l);
+				if (u.revision > t.receipt.revision) {
+					F.shift(), a++;
+					continue;
+				}
+				if (u.revision === t.receipt.revision) {
+					if (u.blobSha256 !== t.receipt.blobSha256 || u.contentSha256 !== t.receipt.contentSha256) return x();
+					F.shift(), i++;
+					continue;
+				}
+				if (u.revision !== t.receipt.baseRevision) {
+					o.set(s, l), F.shift();
+					continue;
+				}
+				let d = await g(c.inventory, t.receipt, t.patch, de);
+				if (Y(), z.get(s) !== c || !ne(f(d, l).artifact, E.chunkSizeRaw)) return x();
+				let p = new Map(z);
+				for (p.delete(s), p.set(s, {
+					scope: n,
+					inventory: d
+				}); X(p) > A;) {
+					let t = [...p.keys()].find((e) => e !== s);
+					if (t === void 0) throw new e({
+						budget: "geometryClientCacheBytes",
+						limit: A
+					});
+					p.delete(t);
+				}
+				z = p, F.shift(), r++, Q();
+			}
+			return Object.freeze({
+				applied: r,
+				duplicates: i,
+				obsolete: a,
+				recovery: Object.freeze([...o.values()].map((e) => Object.freeze(e)))
+			});
+		} catch (n) {
+			throw n instanceof e ? n : new t({ detail: "Native streamed geometry Delta requires explicit source recovery" });
+		} finally {
+			B = !1, n?.(), W = null;
+		}
+	}, Se = (e, t = {}) => {
+		try {
+			if (Y(), B || G) return x();
+			let n = i(t, [
+				"maxChunks",
+				"maxVisitedCoordinates",
+				"velocity"
+			], []), r = Object.hasOwn(n, "maxChunks") ? d(n.maxChunks, 1, k) : k, a = h(w, T, e, {
+				...n,
+				maxChunks: r
+			}), o = Promise.resolve().then(async () => {
+				Y(), await xe();
+				let e = a.chunks.filter((e) => e.role === "visible").map((e) => e.coordinate);
+				await $(e, !1), Y(), a.chunks.length > e.length && await $(a.chunks.map((e) => e.coordinate), !1), Y();
+				let t = new Set(a.chunks.map((e) => q(e.coordinate))), n = (e) => Math.max(Math.abs(e.cx - a.center.cx), Math.abs(e.cy - a.center.cy), Math.abs((e.cz ?? 0) - (a.center.cz ?? 0)));
+				for (let [e, r] of z) !t.has(e) && n(r.scope) > a.radiusChunks + 2 && z.delete(e);
+				return Q(), a;
+			});
+			return G = o, o.then(() => {
+				G = null;
+			}, () => {
+				G = null;
+			}), o;
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	}, Ce = (e) => G ? Promise.reject(new t({ detail: "Geometry render streaming already owns the cache operation" })) : e(), we = Object.freeze({
+		observation: () => Object.freeze({
+			cached: z.size,
+			accountedBytes: X(z),
+			staged: H,
+			stagedBytes: U,
+			active: B || G !== null,
+			withdrawn: V,
+			stale: [...z].filter(([e, t]) => !Z(e, t)).length,
+			queuedDeltas: F.length,
+			queuedDeltaBytes: ve(),
+			receiving: P.observation().pending,
+			receivingBytes: P.observation().accountedBytes
+		}),
+		contains: (e) => {
+			Y();
+			let t = q(p(T, e)), n = z.get(t);
+			return n !== void 0 && Z(t, n);
+		},
+		at: (e) => {
+			Y();
+			let t = p(T, e), n = q(t), r = z.get(n);
+			return !r || !Z(n, r) ? x() : (z.delete(n), z.set(n, r), r.inventory.at(K(t)));
+		},
+		pump: () => Ce(xe),
+		stream: Se,
+		request: (e) => Ce(() => $(e, !1)),
+		refresh: (e) => Ce(() => $(e, !0)),
+		close: async () => {
+			let e = W, t = G;
+			J(), e && await e, t && await t.catch(() => void 0);
+		}
+	});
+	return b.set(we, {
+		session: S,
+		root: T,
+		artifactAt: (e) => {
+			Y();
+			let t = p(T, e), n = q(t), r = z.get(n);
+			return !r || !Z(n, r) ? x() : f(r.inventory, K(t)).artifact;
+		}
+	}), we;
+}, ie = (e, t, n) => {
+	if (!e || typeof e != "object") return x();
+	let r = b.get(e);
+	if (!r || r.session !== t || n !== void 0 && r.root.worldId !== n) return x();
+	let i = e;
+	return i.observation().withdrawn ? x() : i;
+}, ae = (e) => !e || typeof e != "object" || !b.has(e) ? x() : e, C = (e) => !e || typeof e != "object" ? x() : b.get(e)?.root ?? x(), oe = (e, t) => {
+	if (!e || typeof e != "object") return x();
+	let n = b.get(e);
+	return n ? n.artifactAt(t) : x();
+};
+export { ae as captureOwnedRoomGeometryChunkCache, ie as captureRoomGeometryChunkCache, oe as captureRoomGeometryChunkCacheArtifact, C as captureRoomGeometryChunkCacheRoot, S as makeRoomGeometryChunkCache };

package/dist/geometryClientDelta.js

@@ -0,0 +1,24 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureGeometryReceipt as t, geometryPersistenceInteger as n } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedBaseline as r, captureGeometryPreparedInventory as i, captureGeometryPreparedProfile as a, deriveGeometryPreparedInventory as o } from "./geometryPrepared.js";
+import { applyGeometryPatch as s, decodeGeometryPatch as c } from "./geometryPatch.js";
+// src/geometryClientDelta.ts
+var l = async (l, u, d, f) => {
+	let p = i(l), m = t(u), h = m.scope, g = n(f, 512, 16777216), _ = {
+		cx: h.cx,
+		cy: h.cy,
+		...h.cz === void 0 ? {} : { cz: h.cz }
+	}, v = r(p, _), y = p.scope, b = c(d, {
+		maxBytes: g,
+		maxMetadataBytes: Math.min(4096, g - 16)
+	}), x = b.metadata;
+	if (h.tenantId !== y.tenantId || h.kind !== y.kind || h.worldId !== y.worldId || h.layerSetId !== y.layerSetId || h.version !== y.version || JSON.stringify(v.scope) !== JSON.stringify(h) || v.revision !== m.baseRevision || x.kind !== h.kind || x.worldId !== h.worldId || x.layerSetId !== h.layerSetId || x.version !== h.version || x.cx !== h.cx || x.cy !== h.cy || x.cz !== h.cz || x.baseRevision !== m.baseRevision || x.revision !== m.revision || x.changed !== m.changed || x.blobSha256 !== m.blobSha256 || x.contentSha256 !== m.contentSha256) throw new e({ detail: "Native geometry client Delta does not match its exact admitted baseline and receipt" });
+	let S = await s(v.artifact, b, v.revision, a(p));
+	if (S.revision !== m.revision || S.artifact.blobSha256 !== m.blobSha256 || S.artifact.contentSha256 !== m.contentSha256) throw new e({ detail: "Native geometry client Delta digest or revision requires explicit recovery" });
+	return m.changed ? o(p, {
+		scope: h,
+		revision: S.revision,
+		artifact: S.artifact
+	}) : p;
+};
+export { l as prepareGeometryClientDelta };

package/dist/geometryClientHttp.js

@@ -0,0 +1,36 @@
+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 { decodeGeometryChunkHttpScope as i, geometryChunkHttpHeaders as a } from "./geometryChunkHttp.js";
+import { readGeometryHttp as o } from "./geometryHttpBody.js";
+// src/geometryClientHttp.ts
+var s = () => new e({ detail: "Authorized native geometry HTTP download remains unavailable" }), c = (e, t, n) => {
+	if (e === null || !/^(0|[1-9][0-9]{0,15})$/.test(e)) throw s();
+	return r(Number(e), t, n);
+}, l = (e) => {
+	let l = t(e, [
+		"urlFor",
+		"fetch",
+		"maxResponseBytes",
+		"maxReadChunks"
+	], ["urlFor"]), u = Object.hasOwn(l, "maxResponseBytes") ? r(l.maxResponseBytes, 512, 16777216) : 16777216, d = Object.hasOwn(l, "maxReadChunks") ? r(l.maxReadChunks, 1, 65536) : 4096;
+	if (typeof l.urlFor != "function" || Object.hasOwn(l, "fetch") && typeof l.fetch != "function" || !Object.hasOwn(l, "fetch") && typeof globalThis.fetch != "function") throw s();
+	let f = l.urlFor.bind(e), p = Object.hasOwn(l, "fetch") ? l.fetch.bind(e) : globalThis.fetch.bind(globalThis);
+	return Object.freeze({ load: async (e, t) => {
+		let r = n(e), l = await o(() => f(r), p, t, u, d, (e) => {
+			let t = i(e.headers.get(a.scope)), n = c(e.headers.get(a.revision), 0, 2 ** 53 - 1), o = e.headers.get("etag"), l = e.headers.get(a.contentSha256);
+			if (JSON.stringify(t) !== JSON.stringify(r) || o === null || !/^"[a-f0-9]{64}"$/.test(o) || l === null || !/^[a-f0-9]{64}$/.test(l)) throw s();
+			return {
+				scope: t,
+				revision: n,
+				blobSha256: o.slice(1, -1),
+				contentSha256: l
+			};
+		});
+		return Object.freeze({
+			...l.metadata,
+			bytes: l.bytes
+		});
+	} });
+};
+export { l as makeGeometryHttpChunkSource };

package/dist/geometryClientInterest.js

@@ -0,0 +1,108 @@
+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 { captureGeometryPreparedCoordinate as i, captureGeometryPreparedScope as a } from "./geometryPrepared.js";
+import { captureWorldCatalog as o } from "./world.js";
+// src/geometryClientInterest.ts
+function s() {
+	throw new t({ detail: "Client geometry interest requires its genuine World, exact root and bounded render focus" });
+}
+var c = (t, c, l, d = {}) => {
+	let f = o([t])[0], p = a(c), m = f.geometry;
+	if (!m || p.worldId !== f.name || p.kind !== m.kind) return s();
+	let h = p.kind === "3d-voxel" || p.kind === "3d-shapes", g = n(l, h ? [
+		"xRaw",
+		"yRaw",
+		"zRaw"
+	] : ["xRaw", "yRaw"]), _ = r(g.xRaw, -2147483648, 2147483647), v = r(g.yRaw, -2147483648, 2147483647), y = h ? r(g.zRaw, -2147483648, 2147483647) : void 0, b = n(d, [
+		"maxChunks",
+		"maxVisitedCoordinates",
+		"velocity"
+	], []), x = Object.hasOwn(b, "maxChunks") ? r(b.maxChunks, 1, m.streaming.client.maxCachedChunks) : m.streaming.client.maxCachedChunks, S = Object.hasOwn(b, "maxVisitedCoordinates") ? r(b.maxVisitedCoordinates, 1, 33554432) : 65536, C = Object.hasOwn(b, "velocity") ? n(b.velocity, h ? [
+		"xRaw",
+		"yRaw",
+		"zRaw"
+	] : ["xRaw", "yRaw"]) : null, w = C ? r(C.xRaw, -2147483648, 2147483647) : 0, T = C ? r(C.yRaw, -2147483648, 2147483647) : 0, E = C && h ? r(C.zRaw, -2147483648, 2147483647) : 0, D = m.streaming.client.radiusChunks, O = m.streaming.client.prefetchChunks, k = (O * 2 + 1) ** (h ? 3 : 2), A = Math.floor(_ / m.chunkSizeRaw), j = Math.floor(v / m.chunkSizeRaw), M = y === void 0 ? void 0 : Math.floor(y / m.chunkSizeRaw), N = _ / 65536, P = v / 65536;
+	if (N < f.map.bounds[0][0] || N >= f.map.bounds[1][0] || P < f.map.bounds[0][1] || P >= f.map.bounds[1][1]) return s();
+	if (k > S) throw new e({
+		budget: "geometryClientInterestCoordinates",
+		limit: S
+	});
+	let F = i(p, {
+		cx: A,
+		cy: j,
+		...M === void 0 ? {} : { cz: M }
+	}), I = [], L = /* @__PURE__ */ new Map(), R = (e) => {
+		let t = L.get(e);
+		if (t) return t;
+		let n = u(f, e);
+		return L.set(e, n), n;
+	};
+	for (let e = h ? -O : 0; e <= (h ? O : 0); e++) for (let t = -O; t <= O; t++) for (let n = -O; n <= O; n++) {
+		let r = i(p, {
+			cx: A + n,
+			cy: j + t,
+			...M === void 0 ? {} : { cz: M + e }
+		}), a = r.cx * m.chunkSize, o = r.cy * m.chunkSize, s = a + m.chunkSize, c = o + m.chunkSize;
+		if (s <= f.map.bounds[0][0] || a >= f.map.bounds[1][0] || c <= f.map.bounds[0][1] || o >= f.map.bounds[1][1]) continue;
+		let l = Math.max(Math.abs(n), Math.abs(t), Math.abs(e));
+		I.push(Object.freeze({
+			coordinate: Object.freeze({
+				cx: r.cx,
+				cy: r.cy,
+				...r.cz === void 0 ? {} : { cz: r.cz }
+			}),
+			distanceChunks: l,
+			role: l <= D ? "visible" : "prefetch",
+			fields: R(l)
+		}));
+	}
+	let z = (e) => (e.coordinate.cx - A) * w + (e.coordinate.cy - j) * T + ((e.coordinate.cz ?? 0) - (M ?? 0)) * E, B = (e) => (e.coordinate.cx - A) ** 2 + (e.coordinate.cy - j) ** 2 + ((e.coordinate.cz ?? 0) - (M ?? 0)) ** 2;
+	if (I.sort((e, t) => e.distanceChunks - t.distanceChunks || (e.role === "prefetch" && t.role === "prefetch" ? z(t) - z(e) || (w || T || E ? B(e) - B(t) : 0) : 0) || e.coordinate.cx - t.coordinate.cx || e.coordinate.cy - t.coordinate.cy || (e.coordinate.cz ?? 0) - (t.coordinate.cz ?? 0)), I.filter((e) => e.role === "visible").length > x) throw new e({
+		budget: "geometryClientVisibleChunks",
+		limit: x
+	});
+	let V = I.slice(0, x);
+	return Object.freeze({
+		scope: p,
+		center: Object.freeze({
+			cx: F.cx,
+			cy: F.cy,
+			...F.cz === void 0 ? {} : { cz: F.cz }
+		}),
+		radiusChunks: D,
+		prefetchChunks: O,
+		visitedCoordinates: k,
+		omittedPrefetch: Math.max(0, I.length - V.length),
+		chunks: Object.freeze(V)
+	});
+}, l = (e) => {
+	let t = n(e, [
+		"x",
+		"y",
+		"rot",
+		"vx",
+		"vy"
+	], [
+		"x",
+		"y",
+		"rot"
+	]), i = (e) => typeof e != "number" || !Number.isFinite(e) ? s() : r(Math.round(e * 65536), -2147483648, 2147483647);
+	return typeof t.rot != "number" || !Number.isFinite(t.rot) ? s() : Object.freeze({
+		focus: Object.freeze({
+			xRaw: i(t.x),
+			yRaw: i(t.y)
+		}),
+		velocity: Object.freeze({
+			xRaw: Object.hasOwn(t, "vx") ? i(t.vx) : 0,
+			yRaw: Object.hasOwn(t, "vy") ? i(t.vy) : 0
+		})
+	});
+}, u = (e, t) => {
+	let n = o([e])[0].geometry, i = r(t, 0, 2147483647);
+	if (!n) return s();
+	let a = Object.freeze([n.kind === "2d-tiles" ? "tiles" : n.kind === "2d-heightfield" ? "heights" : n.kind === "3d-voxel" ? "voxels" : "shapes"]);
+	for (let e of n.lod) i > n.streaming.client.radiusChunks && i >= e.beyondChunks && (a = e.fields);
+	return a;
+};
+export { u as geometryClientFieldsAtDistance, l as geometryTransformInterest2D, c as planGeometryClientInterest };