@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometrySnapshotClient.js

@@ -0,0 +1,158 @@
+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 { captureGeometryArtifact as i } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as a, captureGeometryCodecProfiles as o, captureGeometryPersistenceScope as s, geometryPersistenceId as c, geometryPersistenceInteger as l } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedScope as u } from "./geometryPrepared.js";
+import { captureRoomClientReliableChannel as d, captureRoomClientReliableIntention as f } from "./web.js";
+import { captureGeometryStreamManifest as p } from "./geometryManifestData.js";
+import { applyGeometryChunkSnapshot as m } from "./geometrySnapshot.js";
+import { GeometryChunkRequestSchema as h, GeometryChunkSnapshotFragmentSchema as g, captureGeometryChunkSnapshotFragment as _, makeGeometrySnapshotReceiver as v } from "./geometrySnapshotChannel.js";
+// src/geometrySnapshotClient.ts
+var y = () => new t({ detail: "Native geometry snapshot read requires its current admission and complete authorized recovery" }), b = (t, b, x) => {
+	let S = u(b), C = r(x, [
+		"manifest",
+		"staticSource",
+		"requestChannel",
+		"responseChannel",
+		"requestId",
+		"maxPending",
+		"maxPatchBytes",
+		"maxPendingBytes",
+		"maxWaitMs",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"codecLimits"
+	], ["manifest", "staticSource"]), w = (e, t, n, r) => Object.hasOwn(C, e) ? l(C[e], n, r) : t, T = w("maxPending", 4, 1, 256), E = w("maxPatchBytes", 262144, 512, 16777216), D = w("maxPendingBytes", 1048576, 1024, 67108864), O = w("maxWaitMs", 2e4, 1, 3e5), k = w("maxManifestChunks", 256, 1, 4096), A = w("maxManifestBytes", 262144, 1024, 16777216), j = Object.hasOwn(C, "requestChannel") ? c(C.requestChannel, 96) : "geometryRequests", M = Object.hasOwn(C, "responseChannel") ? c(C.responseChannel, 96) : "geometrySnapshots", N = v({
+		maxPending: T,
+		maxPatchBytes: E,
+		maxPendingBytes: D
+	}), P = r(C.staticSource, ["load"]), F = Object.hasOwn(C, "codecLimits") ? o(C.codecLimits) : /* @__PURE__ */ new Map();
+	if (j === M || typeof C.manifest != "function" || typeof P.load != "function" || Object.hasOwn(C, "requestId") && typeof C.requestId != "function") throw y();
+	let I = C.manifest.bind(x), L = P.load.bind(C.staticSource), R = Object.hasOwn(C, "requestId") ? C.requestId.bind(x) : () => crypto.randomUUID(), z = d(t, M, new n(g).schemaHash), B = f(t, j, new n(h).schemaHash), V = z.identity(), H = /* @__PURE__ */ new Map(), U = /* @__PURE__ */ new Set(), W = /* @__PURE__ */ new Set(), G = [];
+	if (!V || JSON.stringify(B.identity()) !== JSON.stringify(V)) throw y();
+	let K = !1, q = () => !K && JSON.stringify(z.identity()) === JSON.stringify(V) && JSON.stringify(B.identity()) === JSON.stringify(V), J = () => {
+		K = !0;
+		for (let e of U) e.abort();
+		for (let e of H.values()) e.reject(y());
+		H.clear(), N.reset();
+		for (let e of G.splice(0)) e();
+	}, Y = () => {
+		if (!q()) throw J(), y();
+	}, X = (e) => {
+		let t = p(I(), k, A);
+		if (JSON.stringify(t.scope) !== JSON.stringify(S)) throw y();
+		let n = t.chunks.find((t) => t.cx === e.cx && t.cy === e.cy && t.cz === e.cz);
+		if (!n) throw y();
+		return {
+			reference: n,
+			dirty: t.dirtyChunks.find((t) => t.scope.cx === e.cx && t.scope.cy === e.cy && t.scope.cz === e.cz)
+		};
+	}, Z = (e) => {
+		try {
+			Y();
+			let t = _(e, E), n = H.get(t.requestId);
+			if (!n) return;
+			if (JSON.stringify(t.scope) !== JSON.stringify(n.scope)) throw y();
+			let r = N.receive(t);
+			r && n.resolve(r);
+		} catch {
+			J();
+		}
+	};
+	try {
+		G.push(z.onMessage(Z)), G.push(z.subscribe(() => {
+			q() || J();
+		})), Y();
+	} catch (e) {
+		throw J(), e;
+	}
+	return Object.freeze({
+		load: (t, n) => {
+			if (W.size >= T) return Promise.reject(new e({
+				budget: "geometrySnapshotSourceJobs",
+				limit: T
+			}));
+			let r;
+			try {
+				if (Y(), !(n instanceof AbortSignal) || n.aborted) throw y();
+				r = s(t);
+				let e = {
+					tenantId: r.tenantId,
+					kind: r.kind,
+					worldId: r.worldId,
+					layerSetId: r.layerSetId,
+					version: r.version
+				};
+				if (JSON.stringify(e) !== JSON.stringify(S)) throw y();
+			} catch (e) {
+				return Promise.reject(e);
+			}
+			let o = Promise.resolve().then(async () => {
+				if (Y(), n.aborted) throw y();
+				let t = X(r), o = new AbortController(), s = () => {
+					o.abort();
+				};
+				U.add(o), n.addEventListener("abort", s, { once: !0 });
+				let l, u, d, f;
+				try {
+					n.aborted && o.abort();
+					let s = L(t.reference, o.signal);
+					if (!(s instanceof Promise)) throw y();
+					let p = i(await s);
+					if (Y(), a(p, r), o.signal.aborted || p.blobSha256 !== t.reference.blobSha256 || p.contentSha256 !== t.reference.contentSha256) throw y();
+					if (H.size >= T) throw new e({
+						budget: "geometrySnapshotPendingRequests",
+						limit: T
+					});
+					if (l = c(R()), H.has(l)) throw y();
+					let h = Promise.withResolvers(), g = l;
+					h.promise.catch(() => void 0), H.set(g, {
+						scope: r,
+						resolve: h.resolve,
+						reject: h.reject
+					});
+					let _ = () => {
+						h.reject(y());
+					};
+					if (o.signal.addEventListener("abort", _, { once: !0 }), f = () => o.signal.removeEventListener("abort", _), u = setTimeout(() => h.reject(y()), O), d = B.write({
+						requestId: g,
+						coordinate: {
+							cx: r.cx,
+							cy: r.cy,
+							...r.cz === void 0 ? {} : { cz: r.cz }
+						}
+					}), !(d instanceof Promise)) throw y();
+					let v = await Promise.allSettled([d, h.promise]);
+					if (v[0].status === "rejected" || v[1].status === "rejected" || (Y(), o.signal.aborted)) throw y();
+					let b = await m(p, v[1].value, E, F.get(r.kind) ?? {}), x = X(r);
+					if (o.signal.aborted || b.revision < (x.dirty?.revision ?? 0) || x.reference.blobSha256 !== t.reference.blobSha256 || x.reference.contentSha256 !== t.reference.contentSha256 || !x.dirty && (b.revision !== 0 || b.artifact.blobSha256 !== x.reference.blobSha256 || b.artifact.contentSha256 !== x.reference.contentSha256) || x.dirty && b.revision === x.dirty.revision && (b.artifact.blobSha256 !== x.dirty.blobSha256 || b.artifact.contentSha256 !== x.dirty.contentSha256)) throw y();
+					return Y(), Object.freeze({
+						scope: r,
+						revision: b.revision,
+						bytes: b.artifact.bytes(),
+						blobSha256: b.artifact.blobSha256,
+						contentSha256: b.artifact.contentSha256
+					});
+				} finally {
+					u && clearTimeout(u), f?.(), n.removeEventListener("abort", s), U.delete(o), l && (H.delete(l), N.drop(r, l)), d && await d.catch(() => void 0);
+				}
+			});
+			return W.add(o), o.then(() => W.delete(o), () => W.delete(o)), o;
+		},
+		close: async () => {
+			J(), await Promise.allSettled([...W]);
+		},
+		observation: () => {
+			let e = N.observation();
+			return Object.freeze({
+				pending: H.size,
+				jobs: W.size,
+				receiving: e.pending,
+				receivingBytes: e.accountedBytes,
+				withdrawn: K
+			});
+		}
+	});
+};
+export { b as makeRoomGeometrySnapshotSource };

package/dist/geometrySnapshotPreparation.js

@@ -0,0 +1,75 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryArtifact as r, verifyGeometryArtifact as i } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as a, captureGeometryCodecProfiles as o, captureGeometryPersistenceScope as s, geometryPersistenceId as c, geometryPersistenceInteger as l } from "./geometryPersistenceData.js";
+import { captureRoomSnapshotEffectRunner as u } from "./snapshotBlobIndex.js";
+import { captureGeometryStreamManifest as d } from "./geometryManifestData.js";
+import { createGeometryChunkSnapshot as f } from "./geometrySnapshot.js";
+import { Effect as p } from "effect";
+// src/geometrySnapshotPreparation.ts
+var m = (m, h, g) => {
+	try {
+		let _ = s(m), v = c(h), y = n(g, [
+			"manifest",
+			"persistence",
+			"staticSource",
+			"authorize",
+			"maxManifestChunks",
+			"maxManifestBytes",
+			"maxPatchBytes",
+			"codecLimits"
+		], [
+			"manifest",
+			"persistence",
+			"staticSource",
+			"authorize"
+		]), b = n(y.manifest, ["observe"]), x = n(y.persistence, [
+			"publish",
+			"observe",
+			"commit",
+			"exportSubject",
+			"eraseSubject"
+		]), S = n(y.staticSource, ["load"]), C = (e, t, n, r) => Object.hasOwn(y, e) ? l(y[e], n, r) : t, w = C("maxManifestChunks", 256, 1, 4096), T = C("maxManifestBytes", 262144, 1024, 16777216), E = C("maxPatchBytes", 262144, 512, 16777216), D = Object.hasOwn(y, "codecLimits") ? o(y.codecLimits) : /* @__PURE__ */ new Map();
+		if (typeof b.observe != "function" || typeof x.observe != "function" || typeof S.load != "function" || typeof y.authorize != "function") throw new t({ detail: "Actual geometry snapshot source and admission capabilities required" });
+		let O = y.authorize.bind(g), k = b.observe.bind(y.manifest), A = x.observe.bind(y.persistence), j = S.load.bind(y.staticSource);
+		return p.flatMap(p.context(), (o) => p.uninterruptible(p.tryPromise({
+			try: async () => {
+				let e = u(o), c = O(_);
+				if (!p.isEffect(c) || await e(c) !== void 0) throw new t({ detail: "Geometry snapshot admission did not confirm void" });
+				let m = {
+					tenantId: _.tenantId,
+					kind: _.kind,
+					worldId: _.worldId,
+					layerSetId: _.layerSetId,
+					version: _.version
+				}, h = k(m);
+				if (!p.isEffect(h)) throw new t({ detail: "Actual manifest Effect required" });
+				let g = d(await e(h), w, T);
+				if (JSON.stringify(g.scope) !== JSON.stringify(m)) throw new t({ detail: "Snapshot source changed admitted root" });
+				let y = g.chunks.find((e) => e.cx === _.cx && e.cy === _.cy && e.cz === _.cz);
+				if (!y) throw new t({ detail: "Snapshot has no actual immutable source reference" });
+				let b = j(y);
+				if (!p.isEffect(b)) throw new t({ detail: "Actual static source Effect required" });
+				let x = await i(_.kind, await e(b), y.blobSha256, D.get(_.kind) ?? {});
+				if (a(x, _), x.contentSha256 !== y.contentSha256) throw new t({ detail: "Snapshot static reference content did not verify" });
+				let S = A(_);
+				if (!p.isEffect(S)) throw new t({ detail: "Actual current source Effect required" });
+				let C = n(await e(S), [
+					"scope",
+					"revision",
+					"artifact"
+				]), M = {
+					scope: s(C.scope),
+					revision: l(C.revision),
+					artifact: r(C.artifact)
+				}, N = g.dirtyChunks.find((e) => e.scope.cx === _.cx && e.scope.cy === _.cy && e.scope.cz === _.cz);
+				if (JSON.stringify(s(M.scope)) !== JSON.stringify(_) || M.revision < (N?.revision ?? 0) || N && M.revision === N.revision && (M.artifact.blobSha256 !== N.blobSha256 || M.artifact.contentSha256 !== N.contentSha256)) throw new t({ detail: "Snapshot current source regressed its admitted metadata" });
+				return f(v, x, M, E, D.get(_.kind) ?? {});
+			},
+			catch: (n) => n instanceof e || n instanceof t ? n : new t({ detail: "Actual native geometry snapshot preparation remains unavailable" })
+		})));
+	} catch {
+		return p.fail(new t({ detail: "Geometry snapshot source request could not be captured" }));
+	}
+};
+export { m as prepareGeometryChunkSnapshot };

package/dist/geometrySnapshotServer.js

@@ -0,0 +1,190 @@
+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 { captureGeometryPrivacyTarget as i, captureGeometrySubject as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedCoordinate as c } from "./geometryPrepared.js";
+import { captureGeometryActorFrame as l } from "./geometryActorInventory.js";
+import { captureRoomAdmittedSessionReader as u, captureRoomReliableChannelWriter as d } from "./serverSession.js";
+import { GeometryChunkSnapshotFragmentSchema as f, captureGeometryChunkRequest as p, createGeometryChunkSnapshotFragments as m } from "./geometrySnapshotChannel.js";
+import { captureRoomGeometryResourceState as h } from "./geometryHost.js";
+import { prepareGeometryChunkSnapshot as g } from "./geometrySnapshotPreparation.js";
+import { Effect as _ } from "effect";
+// src/geometrySnapshotServer.ts
+var v = (v, y, b) => {
+	let x = h(v), S = l(x.inventory).scope, C = r(b, [
+		"manifest",
+		"persistence",
+		"staticSource",
+		"resolveSubject",
+		"authorize",
+		"requestChannel",
+		"responseChannel",
+		"maxPending",
+		"maxPerPump",
+		"maxFragmentDeliveries",
+		"maxSubjectFences",
+		"maxPendingSnapshotBytes",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxPatchBytes",
+		"codecLimits"
+	], [
+		"manifest",
+		"persistence",
+		"staticSource",
+		"resolveSubject",
+		"authorize"
+	]), w = (e, t, n, r) => Object.hasOwn(C, e) ? s(C[e], n, r) : t, T = w("maxPending", 64, 1, 4096), E = w("maxPerPump", Math.min(16, T), 1, T), D = w("maxFragmentDeliveries", 8192, 1, 65536), O = w("maxSubjectFences", 4096, 1, 65536), k = w("maxPendingSnapshotBytes", 16777216, 512, 67108864), A = Object.hasOwn(C, "requestChannel") ? o(C.requestChannel, 96) : "geometryRequests", j = Object.hasOwn(C, "responseChannel") ? o(C.responseChannel, 96) : "geometrySnapshots", M = C.resolveSubject, N = C.authorize, P = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Set(), I = new n(f).schemaHash;
+	if (typeof y != "function" || typeof M != "function" || typeof N != "function" || A === j) throw new t({ detail: "Actual readonly Host geometry recovery capabilities required" });
+	let L = r(C.manifest, ["observe"]), R = r(C.persistence, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]), z = r(C.staticSource, ["load"]);
+	if (typeof L.observe != "function" || Object.values(R).some((e) => typeof e != "function") || typeof z.load != "function") throw new t({ detail: "Readonly geometry recovery needs complete actual own source methods before Actor hooks" });
+	let B = C.manifest, V = C.persistence, H = C.staticSource, U = {
+		...Object.fromEntries(Object.entries(C).filter(([e]) => [
+			"maxManifestChunks",
+			"maxManifestBytes",
+			"maxPatchBytes",
+			"codecLimits"
+		].includes(e))),
+		manifest: Object.freeze({ observe: L.observe.bind(B) }),
+		persistence: Object.freeze({
+			publish: R.publish.bind(V),
+			observe: R.observe.bind(V),
+			commit: R.commit.bind(V),
+			exportSubject: R.exportSubject.bind(V),
+			eraseSubject: R.eraseSubject.bind(V)
+		}),
+		staticSource: Object.freeze({ load: z.load.bind(H) })
+	}, W = (e) => JSON.stringify([e.id, e.kind]), G = (e) => !J && !Y && y().includes(e.session) && JSON.stringify(u(e.session).identity()) === JSON.stringify(e.identity), K = (e) => ({
+		tenantId: e.identity.tenantId,
+		roomId: e.identity.roomId,
+		sessionId: e.identity.sessionId,
+		subjectId: e.identity.subjectId,
+		epoch: e.identity.epoch
+	}), q = async (e) => {
+		let n = M.call(b, K(e));
+		if (!_.isEffect(n)) throw new t({ detail: "Readonly geometry Subject lookup needs an actual Effect" });
+		let r = a(await _.runPromise(n));
+		if (r.id !== e.identity.subjectId || e.subject !== null && W(e.subject) !== W(r) || !G(e)) throw new t({ detail: "Readonly geometry Subject changed native admission" });
+		return e.subject = r, r;
+	}, J = !1, Y = !1, X = null;
+	return Object.freeze({
+		requestChannel: A,
+		responseChannel: j,
+		stage: (n, r) => {
+			if (J || Y || !y().includes(n)) throw new t({ detail: "Readonly geometry request has no owned current Session" });
+			let i = u(n).identity(), a = p(S, r);
+			if (!i || i.tenantId !== x.scope.tenantId || i.roomId !== x.scope.roomId || i.epoch !== x.scope.epoch) throw new t({ detail: "Readonly geometry request escaped actual Room owner" });
+			let o = JSON.stringify([
+				i.sessionId,
+				i.epoch,
+				a.requestId
+			]), s = c(S, a.coordinate), l = P.get(o);
+			if (l) {
+				if (l.session !== n || JSON.stringify(l.request) !== JSON.stringify(a)) throw new t({ detail: "Readonly geometry request identity changed intention" });
+			} else {
+				if (P.size >= T) throw new e({
+					budget: "geometryHostPendingReads",
+					limit: T
+				});
+				P.set(o, {
+					session: n,
+					identity: i,
+					request: a,
+					scope: s,
+					subject: null,
+					snapshot: null
+				});
+			}
+		},
+		withdrawSubject: async (n) => {
+			let r = i(n);
+			if (r.tenantId !== x.scope.tenantId || Y) throw new t({ detail: "Readonly geometry withdrawal requires its actual tenant" });
+			let a = W(r.subject);
+			if (!F.has(a) && F.size >= O) throw new e({
+				budget: "geometryHostReadSubjectFences",
+				limit: O
+			});
+			F.add(a);
+			let o = X;
+			o && await o.catch(() => void 0);
+			for (let [e, t] of P) {
+				if (!G(t)) {
+					P.delete(e);
+					continue;
+				}
+				let n = t.subject ?? await q(t);
+				W(n) === a && P.delete(e);
+			}
+		},
+		fence: () => {
+			J = !0;
+		},
+		pump: async () => {
+			if (J || Y) return;
+			if (X) throw new t({ detail: "Readonly geometry Host pump already active" });
+			let n = Promise.resolve().then(async () => {
+				let n = 0, r = 0;
+				for (let [i, a] of P) {
+					if (n >= E) break;
+					if (!G(a)) P.delete(i);
+					else {
+						try {
+							let n = await q(a);
+							if (F.has(W(n))) {
+								P.delete(i);
+								continue;
+							}
+							let o = N.call(b, K(a), a.scope);
+							if (!_.isEffect(o) || await _.runPromise(o) !== void 0 || !G(a) || F.has(W(n))) throw new t({ detail: "Readonly geometry current rights did not confirm" });
+							if (!a.snapshot) {
+								let t = await _.runPromise(g(a.scope, a.request.requestId, {
+									...U,
+									authorize: (e) => N.call(b, K(a), e)
+								}));
+								if ([...P.values()].reduce((e, t) => e + (t.snapshot?.patch.length ?? 0), 0) + t.patch.length > k) throw new e({
+									budget: "geometryHostPendingSnapshotBytes",
+									limit: k
+								});
+								a.snapshot = t;
+							}
+							let s = m(a.snapshot, U.maxPatchBytes ?? 262144);
+							if (r + s.length > D) throw new e({
+								budget: "geometryHostReadFragmentDeliveries",
+								limit: D
+							});
+							let c = d(a.session);
+							for (let e of s) {
+								let n = await q(a), i = N.call(b, K(a), a.scope);
+								if (!_.isEffect(i) || await _.runPromise(i) !== void 0 || !G(a) || F.has(W(n))) throw new t({ detail: "Readonly geometry current recipient rights were withdrawn" });
+								await c.write(j, e, I), r++;
+							}
+						} catch (t) {
+							if (t instanceof e && t.budget === "geometryHostReadFragmentDeliveries") break;
+							a.failures = (a.failures ?? 0) + 1, a.failures >= 8 && P.delete(i);
+							continue;
+						}
+						P.delete(i), n++;
+					}
+				}
+			});
+			X = n;
+			try {
+				await n;
+			} finally {
+				X = null;
+			}
+		},
+		close: async () => {
+			J = !0;
+			let e = X;
+			e && await e.catch(() => void 0), P.clear(), F.clear(), Y = !0;
+		}
+	});
+};
+export { v as makeRoomGeometrySnapshotServer };

package/dist/geometrySqlOwner.js

@@ -0,0 +1,20 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOMS_TABLE as t } from "./identities.js";
+import { and as n, eq as r } from "@voltro/database";
+// src/geometrySqlOwner.ts
+var i = async (i, a, o) => {
+	let s = await i.query({
+		table: t,
+		predicate: n(r("tenantId", a.tenantId), r("id", o.roomId)),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: 2,
+		skip: void 0,
+		projection: void 0,
+		lock: "update"
+	}), c = s[0];
+	if (s.length !== 1 || c?.tenantId !== a.tenantId || c.id !== o.roomId || c.hostId !== o.hostId || c.epoch !== o.epoch || c.state !== "live" || c.erasure != null || c.snapshotErasure != null) throw new e({ detail: "Geometry SQL owner remains unavailable" });
+};
+export { i as assertGeometrySqlOwner };

package/dist/geometryStorage.js

@@ -0,0 +1,126 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { admitGeometryChunkForKind as r, captureGeometryArtifact as i, verifyGeometryArtifact as a } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as o, captureGeometryCodecProfiles as s, captureGeometryStaticReference as c, geometryPersistenceId as l, geometryPersistenceInteger as u } from "./geometryPersistenceData.js";
+import { captureRoomSnapshotEffectRunner as d } from "./snapshotBlobIndex.js";
+import { geometryPersistenceScopeKey as f } from "./geometryPersistenceCapture.js";
+import { geometryStorageClaim as p, geometryStorageOperation as m } from "./geometryStorageIdentity.js";
+import { Effect as h, Stream as g } from "effect";
+// src/geometryStorage.ts
+function _() {
+	throw new t({ detail: "Geometry immutable Storage custody or exact claim remains unconfirmed" });
+}
+var v = (e, t) => {
+	if (!e || typeof e != "object") return _();
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	return !n?.enumerable || !("value" in n) || typeof n.value != "function" ? _() : n.value.bind(e);
+}, y = (y, b) => {
+	let x = n(b, [
+		"bucket",
+		"metadata",
+		"destination",
+		"visibility",
+		"maxBytes",
+		"codecLimits",
+		"authorize"
+	], [
+		"bucket",
+		"metadata",
+		"authorize"
+	]), S = l(x.bucket), C = Object.hasOwn(x, "destination") ? l(x.destination) : void 0, w = Object.hasOwn(x, "visibility") ? x.visibility : "private", T = Object.hasOwn(x, "maxBytes") ? u(x.maxBytes, 512, 16777216) : 16777216, E = s(Object.hasOwn(x, "codecLimits") ? x.codecLimits : {}), D = v(y, "put"), O = v(y, "head"), k = v(y, "getStream"), A = v(y, "delete"), j = v(x.metadata, "lookup"), M = x.authorize;
+	if (w !== "private" && w !== "public" || typeof M != "function") return _();
+	let N = M, P = (e) => E.get(e) ?? {}, F = (e) => ({
+		tenantId: e.tenantId,
+		bucket: S,
+		operationId: m(e)
+	}), I = (e, t, n) => !e || n !== void 0 && e.id !== n || e.tenantId !== t.tenantId || e.bucket !== S || e.checksum !== t.blobSha256 || e.visibility !== w || e.contentType !== "application/octet-stream" ? _() : (l(e.id), u(e.size, 12, T), e), L = async (e, t) => h.isEffect(t) ? e(t) : _(), R = async (e, t, n) => {
+		if (await L(e, N(t, n)) !== void 0) return _();
+	}, z = (n) => h.flatMap(h.context(), (r) => h.uninterruptible(h.tryPromise({
+		try: () => n(d(r)),
+		catch: (n) => n instanceof e ? n : new t({ detail: "Geometry immutable Storage operation remains unconfirmed" })
+	}))), B = () => h.fail(new t({ detail: "Geometry immutable Storage reference could not be captured" }));
+	return Object.freeze({
+		source: Object.freeze({ load: (e) => {
+			try {
+				let t = c(e);
+				return z(async (e) => {
+					await R(e, "load", t);
+					let n = await j(F(t), p(t));
+					if (!n || n.state !== "ready" || n.held !== !0) return _();
+					let r = I(n.ref, t);
+					if (I(await L(e, O(r.id, { tenantId: t.tenantId })), t, r.id).size !== r.size) return _();
+					let i = await L(e, k(r.id, { tenantId: t.tenantId }));
+					if (I(i.ref, t, r.id), i.ref.size !== r.size) return _();
+					let s = new Uint8Array(r.size), c = 0;
+					if (await L(e, g.runForEach(i.stream, (e) => h.sync(() => {
+						if (!(e instanceof Uint8Array) || e.buffer instanceof SharedArrayBuffer || e.length > s.length - c) return _();
+						s.set(e, c), c += e.length;
+					}))), c !== s.length) return _();
+					let l = await a(t.kind, s, t.blobSha256, P(t.kind));
+					if (o(l, t), l.contentSha256 !== t.contentSha256) return _();
+					let u = await j(F(t), p(t));
+					return !u || u.state !== "ready" || !u.held || I(u.ref, t, r.id).size !== r.size ? _() : (await R(e, "load", t), l.bytes());
+				});
+			} catch {
+				return B();
+			}
+		} }),
+		store: (n, a) => {
+			try {
+				let t = l(n), o = i(a), s = o.chunk, u = c({
+					tenantId: t,
+					kind: s.kind,
+					worldId: s.address.worldId,
+					layerSetId: s.address.layerSetId,
+					version: s.version,
+					cx: s.address.cx,
+					cy: s.address.cy,
+					..."cz" in s.address ? { cz: s.address.cz } : {},
+					blobSha256: o.blobSha256,
+					contentSha256: o.contentSha256
+				}), d = o.bytes();
+				if (d.length > T) throw new e({
+					budget: "geometryStaticStoreBytes",
+					limit: T
+				});
+				return r(u.kind, s, P(u.kind)), z(async (e) => {
+					await R(e, "store", u);
+					let n = await L(e, D({
+						tenantId: t,
+						bytes: new Uint8Array(d),
+						contentType: "application/octet-stream",
+						visibility: w,
+						operationId: m(u),
+						claim: p(u),
+						key: "geometry/" + f(u) + "/" + u.blobSha256,
+						...C === void 0 ? {} : { destination: C }
+					})), r = await j(F(u), p(u)), i = I(n, u);
+					return i.size !== d.length || !r || r.state !== "ready" || !r.held || I(r.ref, u).id !== i.id ? _() : (await R(e, "store", u), u);
+				});
+			} catch (n) {
+				return h.fail(n instanceof e ? n : new t({ detail: "Geometry actual artifact or Storage profile could not be captured" }));
+			}
+		},
+		release: (e) => {
+			try {
+				let t = c(e);
+				return z(async (e) => {
+					await R(e, "release", t);
+					let n = await j(F(t), p(t));
+					if (!n || n.state === "reserved") return _();
+					let r = I(n.ref, t);
+					if (n.state === "deleted" || n.state === "ready" && !n.held) return;
+					if (await L(e, A(r.id, {
+						tenantId: t.tenantId,
+						claim: p(t)
+					})) !== void 0) return _();
+					let i = await j(F(t), p(t));
+					if (!i || i.state !== "deleted" && i.state !== "ready" || i.held || I(i.ref, t).id !== r.id) return _();
+				});
+			} catch {
+				return B();
+			}
+		}
+	});
+};
+export { y as storageGeometry };

package/dist/geometryStorageGrant.js

@@ -0,0 +1,68 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryStaticReference as n, geometryPersistenceId as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureRoomSnapshotEffectRunner as a } from "./snapshotBlobIndex.js";
+import { geometryStorageClaim as o, geometryStorageOperation as s } from "./geometryStorageIdentity.js";
+import { Subject as c } from "@voltro/protocol";
+import { Effect as l, Schema as u } from "effect";
+// src/geometryStorageGrant.ts
+var d = (d, f) => {
+	let p = t(f, [
+		"bucket",
+		"metadata",
+		"origin",
+		"visibility",
+		"expiresInSec",
+		"maxBytes",
+		"authorize"
+	], [
+		"bucket",
+		"metadata",
+		"origin",
+		"authorize"
+	]), m = t(d, ["head", "mintUrl"]), h = r(p.bucket), g = p.metadata && typeof p.metadata == "object" ? Object.getOwnPropertyDescriptor(p.metadata, "lookup") : void 0, _ = { lookup: g?.enumerable && "value" in g ? g.value : void 0 }, v = Object.hasOwn(p, "visibility") ? p.visibility : "private", y = Object.hasOwn(p, "expiresInSec") ? i(p.expiresInSec, 1, 3600) : 300, b = Object.hasOwn(p, "maxBytes") ? i(p.maxBytes, 512, 16777216) : 16777216;
+	if (typeof p.origin != "string" || typeof p.authorize != "function" || typeof m.head != "function" || typeof m.mintUrl != "function" || typeof _.lookup != "function" || !["private", "public"].includes(v)) throw new e({ detail: "Actual scoped geometry Storage read grant capabilities required" });
+	let x = new URL(p.origin);
+	if (!["http:", "https:"].includes(x.protocol) || x.username || x.password || x.search || x.hash || x.pathname !== "/") throw new e({ detail: "Actual geometry Storage API origin required" });
+	let S = m.head.bind(d), C = m.mintUrl.bind(d), w = _.lookup.bind(p.metadata), T = p.authorize.bind(f), E = (t, n, a) => {
+		if (!t || t.tenantId !== n.tenantId || t.bucket !== h || t.checksum !== n.blobSha256 || t.visibility !== v || t.contentType !== "application/octet-stream" || a !== void 0 && t.id !== a) throw new e({ detail: "Geometry Storage URL has no exact held source reference" });
+		return r(t.id), i(t.size, 12, b), t;
+	};
+	return Object.freeze({ grant: (t, r) => {
+		try {
+			let i = n(t), d = u.decodeUnknownSync(c)(structuredClone(r));
+			if (d.type !== "user" || d.tenantId !== i.tenantId || !d.id.trim()) throw new e({ detail: "Geometry read URL requires actual authenticated tenant player" });
+			return d.scopes && Object.freeze(d.scopes), Object.freeze(d), l.flatMap(l.context(), (t) => l.uninterruptible(l.tryPromise({
+				try: async () => {
+					let n = a(t), r = async () => {
+						let t = T(i, d);
+						if (!l.isEffect(t) || await n(t) !== void 0) throw new e({ detail: "Geometry URL current read rights did not confirm void" });
+					}, c = {
+						tenantId: i.tenantId,
+						bucket: h,
+						operationId: s(i)
+					}, u = o(i);
+					await r();
+					let f = await w(c, u);
+					if (!f || f.state !== "ready" || !f.held) throw new e({ detail: "Geometry URL requires actual ready held Storage operation" });
+					let p = E(f.ref, i), m = S(p.id, { tenantId: i.tenantId });
+					if (!l.isEffect(m)) throw new e({ detail: "Geometry URL requires actual Storage head Effect" });
+					if (E(await n(m), i, p.id).size !== p.size) throw new e({ detail: "Geometry URL source size changed" });
+					let g = C(p.id, d, { expiresInSec: y });
+					if (!l.isEffect(g)) throw new e({ detail: "Geometry URL requires actual Storage access mint Effect" });
+					let _ = await n(g);
+					if (typeof _ != "string" || _.length > 16384) throw new e({ detail: "Geometry URL issuer returned invalid locator" });
+					let v = new URL(_, x);
+					if (!["http:", "https:"].includes(v.protocol) || v.username || v.password || v.hash) throw new e({ detail: "Geometry URL issuer returned forbidden locator authority" });
+					let b = await w(c, u);
+					if (!b || b.state !== "ready" || !b.held || E(b.ref, i, p.id).size !== p.size) throw new e({ detail: "Geometry URL claim changed while access minted" });
+					return await r(), v.href;
+				},
+				catch: () => new e({ detail: "Actual scoped geometry Storage URL remains unavailable" })
+			})));
+		} catch {
+			return l.fail(new e({ detail: "Geometry read grant scope/Subject could not be captured" }));
+		}
+	} });
+};
+export { d as storageGeometryReadGrants };

package/dist/geometryStorageIdentity.js

@@ -0,0 +1,8 @@
+import { geometryPersistenceDigest as e, geometryPersistenceScopeKey as t } from "./geometryPersistenceCapture.js";
+// src/geometryStorageIdentity.ts
+var n = (n) => "geometry:static:" + e(JSON.stringify([
+	t(n),
+	n.blobSha256,
+	n.contentSha256
+])), r = (e) => "geometry:static:" + t(e);
+export { r as geometryStorageClaim, n as geometryStorageOperation };

package/dist/geometryTileArtifact.js

@@ -0,0 +1,9 @@
+import { createGeometryArtifact as e, verifyGeometryArtifact as t } from "./geometryArtifacts.js";
+// src/geometryTileArtifact.ts
+var n = (e) => Object.freeze({
+	chunk: e.chunk,
+	blobSha256: e.blobSha256,
+	tileDataSha256: e.contentSha256,
+	bytes: e.bytes
+}), r = async (t, r = {}) => n(await e(t, r)), i = async (e, r, i = {}) => n(await t("2d-tiles", e, r, i));
+export { r as createGeometryTileArtifact, i as verifyGeometryTileArtifact };