@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryManifest.js

@@ -0,0 +1,112 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryPersistenceScope as r, geometryPersistenceInteger as i, geometryPersistenceRefusal as a, geometryPersistenceSha as o } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedScope as s } from "./geometryPrepared.js";
+import { captureRoomSnapshotEffectRunner as c } from "./snapshotBlobIndex.js";
+import { captureGeometryStoredVersion as l, geometryPersistenceScopeKey as u, geometryPersistenceVersionKey as d } from "./geometryPersistenceCapture.js";
+import { GEO_CHUNK_DELTAS_TABLE as f, GEO_VERSIONS_TABLE as p } from "./geometryPersistence.js";
+import { captureGeometryStreamManifest as m } from "./geometryManifestData.js";
+import { and as h, eq as g } from "@voltro/database";
+import { Effect as _ } from "effect";
+// src/geometryManifest.ts
+var v = (v, y) => {
+	let b = n(y, [
+		"authorizeRoot",
+		"authorizeChunk",
+		"maxManifestChunks",
+		"maxManifestBytes"
+	], ["authorizeRoot", "authorizeChunk"]), x = Object.hasOwn(b, "maxManifestChunks") ? i(b.maxManifestChunks, 1, 4096) : 256, S = Object.hasOwn(b, "maxManifestBytes") ? i(b.maxManifestBytes, 1024, 16777216) : 262144;
+	if (typeof b.authorizeRoot != "function" || typeof b.authorizeChunk != "function") return a();
+	let C = b.authorizeRoot.bind(y), w = b.authorizeChunk.bind(y);
+	return Object.freeze({ observe: (n) => {
+		let y;
+		try {
+			y = s(n);
+		} catch {
+			return _.fail(new t({ detail: "Geometry manifest root could not be captured" }));
+		}
+		return _.flatMap(_.context(), (n) => _.uninterruptible(_.tryPromise({
+			try: async () => {
+				let e = c(n), t = async (t) => {
+					if (!_.isEffect(t) || await e(t) !== void 0) return a();
+				};
+				await t(C(y));
+				let s = async (e) => {
+					let t = await e.query({
+						table: p,
+						predicate: h(g("tenantId", y.tenantId), g("versionKey", d(y))),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: [
+							"tenantId",
+							"versionKey",
+							"worldId",
+							"kind",
+							"version",
+							"manifestChunks",
+							"manifest",
+							"manifestSha256"
+						]
+					});
+					return t.length === 1 ? l(t[0], y, x, S) : a();
+				}, b = await s(v), T = b.chunks.filter((e) => e.layerSetId === y.layerSetId);
+				if (!T.length) return a();
+				let E = [];
+				for (let e of T) {
+					let n = r({
+						tenantId: e.tenantId,
+						kind: e.kind,
+						worldId: e.worldId,
+						version: e.version,
+						layerSetId: e.layerSetId,
+						cx: e.cx,
+						cy: e.cy,
+						...e.cz === void 0 ? {} : { cz: e.cz }
+					});
+					await t(w(n)), E.push(n);
+				}
+				return v.transactional(async (e) => {
+					if ((await s(e)).manifestSha256 !== b.manifestSha256) return a();
+					let t = [];
+					for (let n of E) {
+						let s = await e.query({
+							table: f,
+							predicate: h(g("tenantId", n.tenantId), g("scopeKey", u(n))),
+							order: [],
+							take: 2,
+							skip: void 0,
+							projection: [
+								"tenantId",
+								"scopeKey",
+								"scope",
+								"revision",
+								"blobSha256",
+								"contentSha256"
+							]
+						});
+						if (s.length > 1) return a();
+						if (s.length) {
+							let e = s[0], c = r(e.scope);
+							if (e.tenantId !== n.tenantId || e.scopeKey !== u(n) || JSON.stringify(c) !== JSON.stringify(n)) return a();
+							t.push({
+								scope: c,
+								revision: i(e.revision, 1),
+								blobSha256: o(e.blobSha256),
+								contentSha256: o(e.contentSha256)
+							});
+						}
+					}
+					return m({
+						scope: y,
+						manifestSha256: b.manifestSha256,
+						chunks: T,
+						dirtyChunks: t
+					}, x, S);
+				});
+			},
+			catch: (n) => n instanceof e || n instanceof t ? n : new t({ detail: "Actual SQL geometry manifest remains unavailable" })
+		})));
+	} });
+};
+export { v as dataStoreGeometryManifest };

package/dist/geometryManifestChannel.js

@@ -0,0 +1,92 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryDense as r, geometryPersistenceInteger as i, geometryPersistenceSha as a } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedScope as o } from "./geometryPrepared.js";
+import { Schema as s } from "effect";
+// src/geometryManifestChannel.ts
+var c = s.Struct({
+	tenantId: s.String,
+	kind: s.Literals([
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	]),
+	worldId: s.String,
+	layerSetId: s.String,
+	version: s.String
+}), l = s.Struct({
+	type: s.Literal("GeoManifestFragment"),
+	scope: c,
+	payloadSha256: s.String,
+	totalBytes: s.Int,
+	offset: s.Int,
+	bytes: s.Array(s.Int)
+}), u = Object.freeze({
+	schema: l,
+	direction: "server",
+	reliable: !0
+}), d = 8192, f = () => new t({ detail: "Geometry manifest fragment escaped its bounded complete publication" }), p = (e, t = 262144) => {
+	let s = i(t, 1024, 16777216), c = n(e, [
+		"type",
+		"scope",
+		"payloadSha256",
+		"totalBytes",
+		"offset",
+		"bytes"
+	]), l = i(c.totalBytes, 1, s), u = i(c.offset, 0, l - 1), p = r(c.bytes, d, (e) => i(e, 0, 255));
+	if (c.type !== "GeoManifestFragment" || u % 8192 || p.length !== Math.min(8192, l - u)) throw f();
+	return Object.freeze({
+		type: "GeoManifestFragment",
+		scope: o(c.scope),
+		payloadSha256: a(c.payloadSha256),
+		totalBytes: l,
+		offset: u,
+		bytes: p
+	});
+}, m = (t = {}) => {
+	let r = n(t, [
+		"maxManifestBytes",
+		"maxPending",
+		"maxPendingBytes"
+	], []), a = Object.hasOwn(r, "maxManifestBytes") ? i(r.maxManifestBytes, 1024, 16777216) : 262144, o = Object.hasOwn(r, "maxPending") ? i(r.maxPending, 1, 256) : 4, s = Object.hasOwn(r, "maxPendingBytes") ? i(r.maxPendingBytes, 1024, 67108864) : 1048576, c = /* @__PURE__ */ new Map(), l = () => [...c.values()].reduce((e, t) => e + t.bytes.length + t.seen.length, 0);
+	return Object.freeze({
+		receive: (t) => {
+			let n = p(t, a), r = JSON.stringify([n.scope, n.payloadSha256]), i = Math.ceil(n.totalBytes / d), u = n.offset / d, m = c.get(r);
+			if (!m) {
+				if (c.size >= o) throw new e({
+					budget: "geometryManifestPendingTransfers",
+					limit: o
+				});
+				if (l() + n.totalBytes + i > s) throw new e({
+					budget: "geometryManifestPendingBytes",
+					limit: s
+				});
+				m = {
+					scope: n.scope,
+					hash: n.payloadSha256,
+					bytes: new Uint8Array(n.totalBytes),
+					seen: new Uint8Array(i),
+					count: 0
+				}, c.set(r, m);
+			}
+			if (m.bytes.length !== n.totalBytes) throw f();
+			if (m.seen[u]) {
+				if (n.bytes.some((e, t) => e !== m.bytes[n.offset + t])) throw f();
+			} else m.bytes.set(n.bytes, n.offset), m.seen[u] = 1, m.count++;
+			return m.count === i ? (c.delete(r), Object.freeze({
+				scope: m.scope,
+				payloadSha256: m.hash,
+				bytes: new Uint8Array(m.bytes)
+			})) : null;
+		},
+		reset: () => {
+			c.clear();
+		},
+		observation: () => Object.freeze({
+			pending: c.size,
+			accountedBytes: l()
+		})
+	});
+};
+export { l as GeometryManifestFragmentSchema, p as captureGeometryManifestFragment, d as geometryManifestFragmentBytes, u as geometryManifestReliableChannel, m as makeGeometryManifestReceiver };

package/dist/geometryManifestClient.js

@@ -0,0 +1,121 @@
+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 { geometrySha256 as i } from "./geometryDigest.js";
+import { captureGeometryKind as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureRoomConnectionGeometrySession as c } from "./connection.js";
+import { GeometryManifestFragmentSchema as l, captureGeometryManifestFragment as u, makeGeometryManifestReceiver as d } from "./geometryManifestChannel.js";
+import { captureRoomClientReliableChannel as f } from "./web.js";
+import { captureGeometryStreamManifest as p } from "./geometryManifestData.js";
+// src/geometryManifestClient.ts
+var m = () => new t({ detail: "Room geometry manifest requires its exact native admission and complete verified publication" }), h = (t, c, h = {}) => {
+	let g = r(c, [
+		"tenantId",
+		"kind",
+		"worldId",
+		"layerSetId"
+	]), _ = {
+		tenantId: o(g.tenantId),
+		kind: a(g.kind),
+		worldId: o(g.worldId, 96),
+		layerSetId: o(g.layerSetId, 96)
+	}, v = r(h, [
+		"channel",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxPending",
+		"maxPendingBytes",
+		"maxQueued",
+		"maxQueuedBytes"
+	], []), y = (e, t, n, r) => Object.hasOwn(v, e) ? s(v[e], n, r) : t, b = y("maxManifestChunks", 256, 1, 4096), x = y("maxManifestBytes", 262144, 1024, 16777216), S = y("maxQueued", 4, 1, 256), C = y("maxQueuedBytes", 1048576, 1024, 67108864), w = Object.hasOwn(v, "channel") ? o(v.channel, 96) : "geometryManifest", T = d({
+		maxManifestBytes: x,
+		maxPending: y("maxPending", 4, 1, 256),
+		maxPendingBytes: y("maxPendingBytes", 1048576, 1024, 67108864)
+	}), E = f(t, w, new n(l).schemaHash), D = E.identity(), O = [], k = [];
+	if (!D) throw m();
+	let A = null, j = !1, M = !1, N = null, P = () => O.reduce((e, t) => e + t.bytes.length, 0), F = (e) => e.tenantId === _.tenantId && e.kind === _.kind && e.worldId === _.worldId && e.layerSetId === _.layerSetId, I = () => !M && JSON.stringify(E.identity()) === JSON.stringify(D), L = () => {
+		M = !0, A = null, T.reset(), O.length = 0;
+		for (let e of k.splice(0)) e();
+	}, R = () => {
+		if (!I()) throw L(), m();
+	}, z = (t) => {
+		try {
+			R();
+			let n = u(t, x);
+			if (!F(n.scope)) throw m();
+			let r = T.receive(n);
+			if (!r) return;
+			if (O.length >= S) throw new e({
+				budget: "geometryManifestQueuedPublications",
+				limit: S
+			});
+			if (P() + r.bytes.length > C) throw new e({
+				budget: "geometryManifestQueuedBytes",
+				limit: C
+			});
+			O.push(r);
+		} catch {
+			L();
+		}
+	};
+	try {
+		k.push(E.onMessage(z)), k.push(E.subscribe(() => {
+			I() || L();
+		})), R();
+	} catch (e) {
+		throw L(), e;
+	}
+	return Object.freeze({
+		current: () => {
+			if (R(), !A) throw m();
+			return A;
+		},
+		observation: () => {
+			let e = T.observation();
+			return Object.freeze({
+				queued: O.length,
+				queuedBytes: P(),
+				receiving: e.pending,
+				receivingBytes: e.accountedBytes,
+				ready: A !== null,
+				active: j,
+				withdrawn: M
+			});
+		},
+		pump: async () => {
+			if (R(), j) throw m();
+			j = !0;
+			let e;
+			N = new Promise((t) => {
+				e = t;
+			});
+			let t = 0;
+			try {
+				for (; O.length;) {
+					let e = O[0], n = await i(e.bytes);
+					if (R(), n !== e.payloadSha256) throw m();
+					let r = new TextDecoder("utf-8", { fatal: !0 }).decode(e.bytes), a = p(JSON.parse(r), b, x);
+					if (JSON.stringify(a) !== r || JSON.stringify(a.scope) !== JSON.stringify(e.scope) || !F(a.scope)) throw m();
+					if (A && A.scope.version === a.scope.version) {
+						if (A.manifestSha256 !== a.manifestSha256 || JSON.stringify(A.chunks) !== JSON.stringify(a.chunks)) throw m();
+						for (let e of A.dirtyChunks) {
+							let t = a.dirtyChunks.find((t) => t.scope.cx === e.scope.cx && t.scope.cy === e.scope.cy && t.scope.cz === e.scope.cz);
+							if (!t || t.revision < e.revision || t.revision === e.revision && (t.blobSha256 !== e.blobSha256 || t.contentSha256 !== e.contentSha256)) throw m();
+						}
+					}
+					A = a, O.shift(), t++;
+				}
+				return Object.freeze({ accepted: t });
+			} catch {
+				throw L(), m();
+			} finally {
+				j = !1, e?.(), N = null;
+			}
+		},
+		close: async () => {
+			let e = N;
+			L(), e && await e;
+		}
+	});
+}, g = (e, t, n = {}) => h(c(e), t, n);
+export { g as makeRoomConnectionGeometryManifestClient, h as makeRoomGeometryManifestClient };

package/dist/geometryManifestData.js

@@ -0,0 +1,48 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryDense as n, captureGeometryPersistenceScope as r, captureGeometryStaticReference as i, geometryPersistenceInteger as a, geometryPersistenceRefusal as o, geometryPersistenceSha as s } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedScope as c } from "./geometryPrepared.js";
+// src/geometryManifestData.ts
+var l = (e) => JSON.stringify([
+	e.cx,
+	e.cy,
+	e.cz ?? null
+]), u = (e, t) => e.tenantId === t.tenantId && e.kind === t.kind && e.worldId === t.worldId && e.layerSetId === t.layerSetId && e.version === t.version, d = (d, f = 256, p = 262144) => {
+	let m = a(f, 1, 4096), h = a(p, 1024, 16777216), g = t(d, [
+		"scope",
+		"manifestSha256",
+		"chunks",
+		"dirtyChunks"
+	]), _ = c(g.scope), v = n(g.chunks, m, i), y = /* @__PURE__ */ new Set();
+	if (!v.length) return o();
+	for (let e of v) {
+		let t = l(e);
+		if (!u(e, _) || y.has(t)) return o();
+		y.add(t);
+	}
+	let b = /* @__PURE__ */ new Set(), x = n(g.dirtyChunks, m, (e) => {
+		let n = t(e, [
+			"scope",
+			"revision",
+			"blobSha256",
+			"contentSha256"
+		]), i = r(n.scope), c = l(i);
+		return !u(i, _) || !y.has(c) || b.has(c) ? o() : (b.add(c), Object.freeze({
+			scope: i,
+			revision: a(n.revision, 1),
+			blobSha256: s(n.blobSha256),
+			contentSha256: s(n.contentSha256)
+		}));
+	}), S = Object.freeze({
+		scope: _,
+		manifestSha256: s(g.manifestSha256),
+		chunks: v,
+		dirtyChunks: x
+	});
+	if (new TextEncoder().encode(JSON.stringify(S)).length > h) throw new e({
+		budget: "geometryStreamManifestBytes",
+		limit: h
+	});
+	return S;
+};
+export { d as captureGeometryStreamManifest };

package/dist/geometryManifestPorts.js

@@ -0,0 +1,4 @@
+import { Context as e, Layer as t } from "effect";
+// src/geometryManifestPorts.ts
+var n = class extends e.Service()("@voltro/GeometryManifestPort") {}, r = (e) => t.succeed(n, e);
+export { n as GeometryManifestPort, r as geometryManifestLayer };

package/dist/geometryManifestPublication.js

@@ -0,0 +1,108 @@
+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 { geometrySha256 as i } from "./geometryDigest.js";
+import { captureGeometryDense as a, captureGeometryOwner as o, geometryPersistenceId as s, geometryPersistenceInteger as c } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedScope as l } from "./geometryPrepared.js";
+import { GeometryManifestFragmentSchema as u, geometryManifestFragmentBytes as d } from "./geometryManifestChannel.js";
+import { captureRoomSnapshotEffectRunner as f } from "./snapshotBlobIndex.js";
+import { captureRoomReliableChannelWriter as p } from "./serverSession.js";
+import { captureGeometryStreamManifest as m } from "./geometryManifestData.js";
+import { Effect as h } from "effect";
+// src/geometryManifestPublication.ts
+var g = (g) => {
+	let _ = r(g, [
+		"scope",
+		"owner",
+		"source",
+		"currentSessions",
+		"authorizeRecipient",
+		"authorizeChunk",
+		"channel",
+		"maxRecipients",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxFragmentDeliveries"
+	], [
+		"scope",
+		"owner",
+		"source",
+		"currentSessions",
+		"authorizeRecipient",
+		"authorizeChunk"
+	]), v = l(_.scope), y = o(_.owner), b = r(_.source, ["observe"]), x = (e, t, n, r) => Object.hasOwn(_, e) ? c(_[e], n, r) : t, S = x("maxRecipients", 64, 1, 4096), C = x("maxManifestChunks", 256, 1, 4096), w = x("maxManifestBytes", 262144, 1024, 16777216), T = x("maxFragmentDeliveries", 8192, 1, 65536), E = Object.hasOwn(_, "channel") ? s(_.channel, 96) : "geometryManifest", D = new n(u).schemaHash;
+	if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(E) || [
+		"currentSessions",
+		"authorizeRecipient",
+		"authorizeChunk"
+	].some((e) => typeof _[e] != "function") || typeof b.observe != "function") throw new t({ detail: "Native manifest publication requires actual own source/recipient policies" });
+	let O = _.currentSessions.bind(g), k = _.authorizeRecipient.bind(g), A = _.authorizeChunk.bind(g), j = b.observe.bind(_.source);
+	return () => h.flatMap(h.context(), (n) => h.uninterruptible(h.tryPromise({
+		try: async () => {
+			let r = f(n), o = /* @__PURE__ */ new Set(), s = a(O(), S, (e) => {
+				let n = p(e), r = n.identity();
+				if (!r || r.tenantId !== v.tenantId || r.roomId !== y.roomId || r.epoch !== y.epoch || o.has(r.sessionId)) throw new t({ detail: "Manifest recipient is not a unique actual current Room Session" });
+				return o.add(r.sessionId), {
+					session: e,
+					writer: n,
+					actual: r,
+					recipient: Object.freeze({
+						tenantId: r.tenantId,
+						roomId: r.roomId,
+						sessionId: r.sessionId,
+						subjectId: r.subjectId,
+						epoch: r.epoch
+					})
+				};
+			}), c = async (e) => {
+				if (!h.isEffect(e) || await r(e) !== void 0) throw new t({ detail: "Manifest visibility did not confirm void" });
+			}, l = (e) => {
+				if (!a(O(), S, (e) => e).includes(e.session) || JSON.stringify(e.writer.identity()) !== JSON.stringify(e.actual)) throw new t({ detail: "Manifest recipient changed native admission" });
+			};
+			if (!s.length) return;
+			for (let e of s) await c(k(e.recipient, v)), l(e);
+			let u = j(v);
+			if (!h.isEffect(u)) throw new t({ detail: "Manifest source must return an actual Effect" });
+			let g = m(await r(u), C, w);
+			if (JSON.stringify(g.scope) !== JSON.stringify(v)) throw new t({ detail: "Manifest source changed the actual publication root" });
+			for (let e of s) for (let t of g.chunks) await c(A(e.recipient, {
+				tenantId: t.tenantId,
+				kind: t.kind,
+				worldId: t.worldId,
+				layerSetId: t.layerSetId,
+				version: t.version,
+				cx: t.cx,
+				cy: t.cy,
+				...t.cz === void 0 ? {} : { cz: t.cz }
+			})), l(e);
+			let _ = new TextEncoder().encode(JSON.stringify(g)), b = await i(_), x = Math.ceil(_.length / d);
+			if (s.length * x > T) throw new e({
+				budget: "geometryManifestFragmentDeliveries",
+				limit: T
+			});
+			for (let e of s) {
+				l(e), await c(k(e.recipient, v)), l(e);
+				for (let t of g.chunks) await c(A(e.recipient, {
+					tenantId: t.tenantId,
+					kind: t.kind,
+					worldId: t.worldId,
+					layerSetId: t.layerSetId,
+					version: t.version,
+					cx: t.cx,
+					cy: t.cy,
+					...t.cz === void 0 ? {} : { cz: t.cz }
+				})), l(e);
+				for (let t = 0; t < _.length; t += d) l(e), await e.writer.write(E, {
+					type: "GeoManifestFragment",
+					scope: v,
+					payloadSha256: b,
+					totalBytes: _.length,
+					offset: t,
+					bytes: Array.from(_.subarray(t, t + d))
+				}, D);
+			}
+		},
+		catch: (n) => n instanceof e ? n : new t({ detail: "Native geometry manifest publication remains unconfirmed" })
+	})));
+};
+export { g as makeGeometryManifestPublication };

package/dist/geometryManifestSource.js

@@ -0,0 +1,67 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.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, captureGeometryPersistenceScope as c, geometryPersistenceInteger as l } from "./geometryPersistenceData.js";
+import { captureGeometryStreamManifest as u } from "./geometryManifestData.js";
+// src/geometryManifestSource.ts
+var d = () => new e({ detail: "Manifest-directed native geometry source requires its current full scope and actual recovery" }), f = (e) => {
+	let f = n(e, [
+		"manifest",
+		"staticSource",
+		"recovery",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxChunkBytes",
+		"codecLimits"
+	], ["manifest", "staticSource"]), p = (e, t, n, r) => Object.hasOwn(f, e) ? l(f[e], n, r) : t, m = p("maxManifestChunks", 256, 1, 4096), h = p("maxManifestBytes", 262144, 1024, 16777216), g = p("maxChunkBytes", 16777216, 512, 16777216), _ = Object.hasOwn(f, "codecLimits") ? s(f.codecLimits) : /* @__PURE__ */ new Map(), v = n(f.staticSource, ["load"]), y = Object.hasOwn(f, "recovery") ? n(f.recovery, [
+		"load",
+		"close",
+		"observation"
+	], ["load"]) : void 0;
+	if (typeof f.manifest != "function" || typeof v.load != "function" || y && typeof y.load != "function") throw d();
+	let b = f.manifest.bind(e), x = v.load.bind(f.staticSource), S = y ? y.load.bind(f.recovery) : void 0, C = (e) => {
+		let t = u(b(), m, h), n = t.scope;
+		if (n.tenantId !== e.tenantId || n.kind !== e.kind || n.worldId !== e.worldId || n.layerSetId !== e.layerSetId || n.version !== e.version) throw d();
+		let r = t.chunks.find((t) => t.cx === e.cx && t.cy === e.cy && t.cz === e.cz);
+		if (!r) throw d();
+		return {
+			reference: r,
+			dirty: t.dirtyChunks.find((t) => t.scope.cx === e.cx && t.scope.cy === e.cy && t.scope.cz === e.cz)
+		};
+	};
+	return Object.freeze({ load: async (e, s) => {
+		let u = c(e);
+		if (!(s instanceof AbortSignal) || s.aborted) throw d();
+		let f = C(u), p = f.dirty && (f.dirty.blobSha256 !== f.reference.blobSha256 || f.dirty.contentSha256 !== f.reference.contentSha256);
+		if (p && !S) throw d();
+		let m = x(f.reference, s);
+		if (!(m instanceof Promise)) throw d();
+		let h = i(await m), v = f.dirty?.revision ?? 0;
+		if (o(h, u), r(u.kind, h.chunk, _.get(u.kind) ?? {}), h.blobSha256 !== f.reference.blobSha256 || h.contentSha256 !== f.reference.contentSha256) throw d();
+		if (p) {
+			if (!S || s.aborted) throw d();
+			let e = S(u, s);
+			if (!(e instanceof Promise)) throw d();
+			let r = n(await e, [
+				"scope",
+				"revision",
+				"bytes",
+				"blobSha256",
+				"contentSha256"
+			]), i = c(r.scope);
+			if (JSON.stringify(i) !== JSON.stringify(u) || (v = l(r.revision), h = await a(u.kind, t(r.bytes, g, "geometryManifestSourceChunkBytes"), r.blobSha256, _.get(u.kind) ?? {}), o(h, u), h.contentSha256 !== r.contentSha256)) throw d();
+		}
+		let y = C(u);
+		if (s.aborted || y.reference.blobSha256 !== f.reference.blobSha256 || y.reference.contentSha256 !== f.reference.contentSha256 || !y.dirty && (v !== 0 || h.blobSha256 !== y.reference.blobSha256 || h.contentSha256 !== y.reference.contentSha256) || v < (y.dirty?.revision ?? 0) || y.dirty && v === y.dirty.revision && (h.blobSha256 !== y.dirty.blobSha256 || h.contentSha256 !== y.dirty.contentSha256)) throw d();
+		let b = t(h.bytes(), g, "geometryManifestSourceChunkBytes");
+		return Object.freeze({
+			scope: u,
+			revision: v,
+			bytes: b,
+			blobSha256: h.blobSha256,
+			contentSha256: h.contentSha256
+		});
+	} });
+};
+export { f as makeManifestGeometryChunkSource };

package/dist/geometryMigrationJournal.js

@@ -0,0 +1,13 @@
+import { id as e, json as t, table as n, text as r, timestamp as i } from "@voltro/database";
+// src/geometryMigrationJournal.ts
+var a = "_voltro_geo_migrations", o = n(a, {
+	id: e({ prefix: "gmigrate" }),
+	tenantId: r().maxLength(191),
+	requestKey: r().maxLength(64),
+	inputSha256: r().maxLength(64),
+	fromScopeKey: r().maxLength(64),
+	toScopeKey: r().maxLength(64),
+	receipt: t(),
+	createdAt: i()
+}).unique("byGeometryMigrationRequest", ["tenantId", "requestKey"]).index(["tenantId", "fromScopeKey"]).index(["tenantId", "toScopeKey"]);
+export { a as GEO_MIGRATIONS_TABLE, o as geometryMigrationsTable };

package/dist/geometryMigrationStrategies.js

@@ -0,0 +1,6 @@
+// src/geometryMigrationStrategies.ts
+var e = (e, t) => e.static.contentSha256 === t.static.contentSha256 ? {
+	...e.current.chunk,
+	version: t.static.chunk.version
+} : null;
+export { e as defaultGeometryMigrateDelta };