@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryVersionClient.js

@@ -0,0 +1,237 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryCodecProfiles as r, captureGeometryKind as i, geometryPersistenceId as a, geometryPersistenceInteger as o } from "./geometryPersistenceData.js";
+import { planGeometryClientInterest as s } from "./geometryClientInterest.js";
+import { captureRoomConnectionGeometrySession as c } from "./connection.js";
+import { makeRoomGeometryChunkCache as l } from "./geometryClientChunks.js";
+import { captureGeometryRenderLodCacheOptions as u, makeGeometryRenderLodCache as d } from "./geometryRenderCache.js";
+import { captureWorldCatalog as f } from "./world.js";
+import { makeRoomGeometrySnapshotSource as p } from "./geometrySnapshotClient.js";
+import { makeRoomGeometryManifestClient as m } from "./geometryManifestClient.js";
+// src/geometryVersionClient.ts
+var h = () => new t({ detail: "Geometry version handoff requires its current native manifest, admission and fully verified downloads" }), g = (t, c, g, _) => {
+	let v = f([c])[0], y = n(g, [
+		"tenantId",
+		"kind",
+		"worldId",
+		"layerSetId"
+	]), b = Object.freeze({
+		tenantId: a(y.tenantId),
+		kind: i(y.kind),
+		worldId: a(y.worldId, 96),
+		layerSetId: a(y.layerSetId, 96)
+	}), x = n(_, [
+		"staticSource",
+		"manifest",
+		"snapshot",
+		"cache",
+		"render"
+	], ["staticSource"]), S = n(x.staticSource, ["load"]);
+	if (!v.geometry || b.worldId !== v.name || b.kind !== v.geometry.kind || typeof S.load != "function") throw h();
+	let C = Object.freeze({ load: S.load.bind(x.staticSource) }), w = (e, t) => {
+		let i = { ...Object.hasOwn(x, e) ? n(x[e], t, []) : {} };
+		if (Object.hasOwn(i, "codecLimits") && (i.codecLimits = Object.freeze(Object.fromEntries(r(i.codecLimits)))), Object.hasOwn(i, "requestId")) {
+			if (typeof i.requestId != "function") throw h();
+			i.requestId = i.requestId.bind(x[e]);
+		}
+		return Object.freeze(i);
+	}, T = w("manifest", [
+		"channel",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxPending",
+		"maxPendingBytes",
+		"maxQueued",
+		"maxQueuedBytes"
+	]), E = w("snapshot", [
+		"requestChannel",
+		"responseChannel",
+		"requestId",
+		"maxPending",
+		"maxPatchBytes",
+		"maxPendingBytes",
+		"maxWaitMs",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"codecLimits"
+	]), D = w("cache", [
+		"channel",
+		"maxCachedChunks",
+		"maxConcurrent",
+		"maxCacheBytes",
+		"maxStagedBytes",
+		"maxChunkBytes",
+		"maxPendingDeltas",
+		"maxQueuedDeltaBytes",
+		"codecLimits"
+	]), O = u(Object.hasOwn(x, "render") ? x.render : {}), k = m(t, {
+		tenantId: b.tenantId,
+		kind: b.kind,
+		worldId: b.worldId,
+		layerSetId: b.layerSetId
+	}, T), A = /* @__PURE__ */ new Set(), j = null, M = null, N = !1, P = null, F = (e) => {
+		if (!e.retiring) {
+			let t = Promise.resolve().then(async () => {
+				if ((await Promise.allSettled([
+					(async () => {
+						if (!e.cacheClosed) {
+							if (e.cache) {
+								let t = e.cache.close();
+								if (!(t instanceof Promise) || await t !== void 0) throw h();
+							}
+							e.cacheClosed = !0;
+						}
+					})(),
+					(async () => {
+						if (e.sourceClosed) return;
+						let t = e.source.close();
+						if (!(t instanceof Promise) || await t !== void 0) throw h();
+						e.sourceClosed = !0;
+					})(),
+					(async () => {
+						if (!e.renderClosed) {
+							if (e.render) {
+								let t = e.render.close();
+								if (!(t instanceof Promise) || await t !== void 0) throw h();
+							}
+							e.renderClosed = !0;
+						}
+					})()
+				])).some((e) => e.status === "rejected")) throw h();
+				A.delete(e);
+			});
+			e.retiring = t, t.then(() => {
+				e.retiring = null;
+			}, () => {
+				e.retiring = null;
+			});
+		}
+		return e.retiring;
+	}, I = () => {
+		if (N || M || !j?.cache) throw h();
+		return k.current(), j.cache;
+	};
+	return Object.freeze({
+		at: (e) => I().at(e),
+		contains: (e) => I().contains(e),
+		render: (t, n) => {
+			try {
+				let e = I(), r = j;
+				if (!r.render) {
+					let t = b.kind === "2d-heightfield" ? D.codecLimits?.["2d-heightfield"] : void 0, n = t && !O.lod?.codecLimits ? {
+						...O,
+						lod: {
+							...O.lod,
+							codecLimits: t
+						}
+					} : O;
+					r.render = d(e, v, n);
+				}
+				return r.render.prepare(t, n);
+			} catch (t) {
+				return Promise.reject(t instanceof e ? t : h());
+			}
+		},
+		observation: () => {
+			let e = j?.cache;
+			return Object.freeze({
+				scope: j?.scope ?? null,
+				ready: !N && M === null && e != null && !e.observation().withdrawn && !k.observation().withdrawn,
+				active: M !== null,
+				withdrawn: N || k.observation().withdrawn,
+				retiring: [...A].filter((e) => e !== j).length,
+				renderEntries: j?.render?.observation().entries ?? 0,
+				renderEncodedBytes: j?.render?.observation().encodedBytes ?? 0,
+				renderJobs: j?.render?.observation().jobs ?? 0
+			});
+		},
+		stream: (r, i = {}) => {
+			try {
+				if (N || M) throw h();
+				let a = b.kind === "3d-voxel" || b.kind === "3d-shapes", c = n(r, a ? [
+					"xRaw",
+					"yRaw",
+					"zRaw"
+				] : ["xRaw", "yRaw"]), u = Object.freeze(Object.fromEntries(Object.entries(c).map(([e, t]) => [e, o(t, -2147483648, 2147483647)]))), d = { ...n(i, [
+					"maxChunks",
+					"maxVisitedCoordinates",
+					"velocity"
+				], []) };
+				if (Object.hasOwn(d, "velocity")) {
+					let e = n(d.velocity, a ? [
+						"xRaw",
+						"yRaw",
+						"zRaw"
+					] : ["xRaw", "yRaw"]);
+					d.velocity = Object.freeze(Object.fromEntries(Object.entries(e).map(([e, t]) => [e, o(t, -2147483648, 2147483647)])));
+				}
+				let f = Promise.resolve().then(async () => {
+					let n = null;
+					try {
+						for (let e of A) e !== j && await F(e);
+						if (await k.pump(), N) throw h();
+						let e = k.current().scope, r = D.maxCachedChunks ?? v.geometry.streaming.client.maxCachedChunks;
+						if (s(v, e, u, {
+							...d,
+							maxChunks: Object.hasOwn(d, "maxChunks") ? o(d.maxChunks, 1, r) : r
+						}), j && JSON.stringify(j.scope) !== JSON.stringify(e)) {
+							let e = j;
+							j = null, await F(e);
+						}
+						if (!j) {
+							let r = p(t, e, {
+								...E,
+								manifest: () => k.current(),
+								staticSource: C
+							});
+							n = {
+								scope: e,
+								source: r,
+								cache: null,
+								render: null,
+								renderClosed: !1,
+								sourceClosed: !1,
+								cacheClosed: !1,
+								retiring: null
+							}, A.add(n), n.cache = l(t, v, e, { load: (e, t) => r.load(e, t) }, D);
+						}
+						let i = j ?? n;
+						if (!i?.cache || N) throw h();
+						let a = await i.cache.stream(u, d);
+						if (N || JSON.stringify(k.current().scope) !== JSON.stringify(e)) throw h();
+						return j = i, n = null, a;
+					} catch (t) {
+						throw n && await F(n), t instanceof e ? t : h();
+					}
+				});
+				return M = f, f.then(() => {
+					M = null;
+				}, () => {
+					M = null;
+				}), f;
+			} catch (t) {
+				return Promise.reject(t instanceof e ? t : h());
+			}
+		},
+		close: () => {
+			if (N = !0, j = null, !P) {
+				let e = M, t = Promise.resolve().then(async () => {
+					let t = [...A].map(F);
+					if ((await Promise.allSettled([
+						k.close(),
+						...t,
+						...e ? [e.then(() => void 0, () => void 0)] : []
+					])).some((e) => e.status === "rejected")) throw h();
+					for (let e of A) await F(e);
+				});
+				P = t, t.then(() => {
+					P = null;
+				}, () => {
+					P = null;
+				});
+			}
+			return P;
+		}
+	});
+}, _ = (e, t, n, r) => g(c(e), t, n, r);
+export { _ as makeRoomConnectionGeometryVersionClient, g as makeRoomGeometryVersionClient };

package/dist/geometryVersionCompare.js

@@ -0,0 +1,39 @@
+import { ProtocolError as e } from "./errors.js";
+// src/geometryVersionCompare.ts
+function t() {
+	throw new e({ detail: "Geometry version comparison requires two manifests of the same tenant, World and kind with unique chunk addresses" });
+}
+var n = (e) => JSON.stringify([
+	e.layerSetId,
+	e.cx,
+	e.cy,
+	e.cz ?? null
+]), r = (e) => Object.freeze({
+	layerSetId: e.layerSetId,
+	cx: e.cx,
+	cy: e.cy,
+	...e.cz === void 0 ? {} : { cz: e.cz }
+}), i = (e, t) => e.layerSetId < t.layerSetId ? -1 : e.layerSetId > t.layerSetId ? 1 : e.cx - t.cx || e.cy - t.cy || (e.cz ?? 0) - (t.cz ?? 0), a = (e, a) => {
+	if (!e || !a || e.tenantId !== a.tenantId || e.worldId !== a.worldId || e.kind !== a.kind || !Array.isArray(e.chunks) || !Array.isArray(a.chunks)) return t();
+	let o = (e) => {
+		let r = /* @__PURE__ */ new Map();
+		for (let i of e) {
+			let e = n(i);
+			if (r.has(e)) return t();
+			r.set(e, i);
+		}
+		return r;
+	}, s = o(e.chunks), c = o(a.chunks), l = [], u = [], d = [], f = 0;
+	for (let [e, t] of c) {
+		let n = s.get(e);
+		n ? n.contentSha256 === t.contentSha256 ? f++ : d.push(r(t)) : l.push(r(t));
+	}
+	for (let [e, t] of s) c.has(e) || u.push(r(t));
+	return Object.freeze({
+		added: Object.freeze(l.sort(i)),
+		removed: Object.freeze(u.sort(i)),
+		changed: Object.freeze(d.sort(i)),
+		unchanged: f
+	});
+};
+export { a as compareGeometryVersions };

package/dist/geometryVersionMigration.js

@@ -0,0 +1,105 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { admitGeometryChunkForKind as r, captureGeometryArtifact as i, createGeometryArtifact as a } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as o, captureGeometryCodecProfiles as s, captureGeometryPersistenceScope as c, captureGeometryStaticReference as l, geometryPersistenceInteger as u } from "./geometryPersistenceData.js";
+import { defaultGeometryMigrateDelta as d } from "./geometryMigrationStrategies.js";
+import { captureGeometryCompactionStrategies as f, prepareGeometryCompaction as p } from "./geometryCompactionStrategies.js";
+import { geometryChunkHasWorldExtent as m } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as h } from "./world.js";
+import { Effect as g } from "effect";
+// src/geometryVersionMigration.ts
+function _() {
+	throw new t({ detail: "Geometry version migration requires exact genuine same-chunk artifacts and a bounded pure rule" });
+}
+var v = (v, y, b = {}) => {
+	try {
+		let x = h([v])[0], S = x.geometry;
+		if (!S) return _();
+		let C = n(y, ["from", "to"]), w = n(C.from, [
+			"reference",
+			"static",
+			"current"
+		]), T = n(C.to, ["reference", "static"]), E = n(w.current, [
+			"scope",
+			"revision",
+			"artifact"
+		]), D = l(w.reference), O = l(T.reference), k = i(w.static), A = i(T.static), j = i(E.artifact), M = c(E.scope), N = c({
+			tenantId: O.tenantId,
+			kind: O.kind,
+			worldId: O.worldId,
+			layerSetId: O.layerSetId,
+			version: O.version,
+			cx: O.cx,
+			cy: O.cy,
+			...O.cz === void 0 ? {} : { cz: O.cz }
+		}), P = u(E.revision), F = n(b, [
+			"strategies",
+			"maxAccountedBytes",
+			"maxPatchBytes",
+			"codecLimits"
+		], []), I = Object.hasOwn(F, "maxAccountedBytes") ? u(F.maxAccountedBytes, 512, S.budgets.maxPreparedBytes) : S.budgets.maxPreparedBytes, L = Object.hasOwn(F, "maxPatchBytes") ? u(F.maxPatchBytes, 512, S.dynamic.maxDeltaBytesPerChunk) : S.dynamic.maxDeltaBytesPerChunk, R = (Object.hasOwn(F, "codecLimits") ? s(F.codecLimits) : /* @__PURE__ */ new Map()).get(N.kind) ?? {}, z = Object.hasOwn(F, "strategies") ? n(F.strategies, ["migrateDelta", "compaction"], []) : {}, B = Object.hasOwn(z, "migrateDelta"), V = f({ compaction: Object.hasOwn(z, "compaction") ? z.compaction : S.strategies.compaction }), H = B ? z.migrateDelta : S.strategies.migrateDelta, U = H !== d;
+		if (D.version === O.version || !S.dynamic.enabled && P !== 0 || D.kind !== S.kind || O.kind !== S.kind || D.worldId !== x.name || O.worldId !== x.name || D.tenantId !== O.tenantId || D.layerSetId !== O.layerSetId || D.cx !== O.cx || D.cy !== O.cy || D.cz !== O.cz || JSON.stringify(M) !== JSON.stringify(c({
+			tenantId: D.tenantId,
+			kind: D.kind,
+			worldId: D.worldId,
+			layerSetId: D.layerSetId,
+			version: D.version,
+			cx: D.cx,
+			cy: D.cy,
+			...D.cz === void 0 ? {} : { cz: D.cz }
+		})) || typeof H != "function") return _();
+		for (let [e, t] of [[k, D], [A, O]]) if (o(e, t), e.blobSha256 !== t.blobSha256 || e.contentSha256 !== t.contentSha256) return _();
+		o(j, M);
+		let W = 0;
+		for (let t of [
+			k,
+			A,
+			j
+		]) {
+			if (r(N.kind, t.chunk, R), !m(t, S.chunkSizeRaw)) return _();
+			if (W += t.bytes().length, W > I) throw new e({
+				budget: "geometryMigrationAccountedBytes",
+				limit: I
+			});
+		}
+		let G = B ? H.bind(F.strategies) : H, K = Object.freeze({
+			static: k,
+			current: j,
+			revision: P
+		}), q = Object.freeze({ static: A }), J = k.contentSha256 !== A.contentSha256;
+		return g.uninterruptible(g.tryPromise({
+			try: async () => {
+				let t = G(K, q);
+				if (t instanceof Promise) return t.catch(() => void 0), _();
+				let n = t === null ? A : await a(r(N.kind, t, R), R);
+				if (o(n, N), !m(n, S.chunkSizeRaw)) return _();
+				let i = await p({
+					static: A,
+					current: n,
+					limits: {
+						maxBytes: L,
+						maxMetadataBytes: Math.min(4096, L - 16)
+					},
+					codecLimits: R
+				}, V);
+				if (W + n.bytes().length + i.bytes().length > I) throw new e({
+					budget: "geometryMigrationAccountedBytes",
+					limit: I
+				});
+				return Object.freeze({
+					fromScope: M,
+					scope: N,
+					fromRevision: P,
+					staticChanged: J,
+					decision: U ? "custom" : J ? "discarded" : "kept",
+					artifact: n,
+					patch: i
+				});
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "Actual native geometry migration preparation remains unavailable" })
+		}));
+	} catch (n) {
+		return g.fail(n instanceof e ? n : new t({ detail: "Geometry version migration input could not be captured" }));
+	}
+};
+export { d as defaultGeometryMigrateDelta, v as prepareGeometryVersionMigration };

package/dist/geometryVoxel.js

@@ -0,0 +1,252 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryEnvelopeMagic as t } from "./geometryEnvelope.js";
+import { createFixed as n } from "./fixedMath.js";
+import { captureSimulationBytes as r } from "./simulationBytes.js";
+import { fieldId as i } from "./room.js";
+import { RoomStateCodec as a } from "./stateCodec.js";
+import { GeometryTileMaterialSchema as o, GeometryTileRunSchema as s } from "./geometrySchemas.js";
+import { geometryOwnData as c, geometryTileRefusal as l } from "./geometryTileCodec.js";
+import { GeometryChunkAddress3DSchema as u } from "./geometryShapes.js";
+import { Result as d, Schema as f } from "effect";
+// src/geometryVoxel.ts
+var p = n(), m = f.Struct({
+	sx: f.Int.pipe(i(1)),
+	sy: f.Int.pipe(i(2)),
+	sz: f.Int.pipe(i(3)),
+	runs: f.Array(s).pipe(i(4))
+}), h = f.Struct({
+	kind: f.Literal("3d-voxel").pipe(i(1)),
+	formatVersion: f.Literal(1).pipe(i(2)),
+	address: u.pipe(i(3)),
+	version: f.String.pipe(i(4)),
+	side: f.Int.pipe(i(5)),
+	voxelSizeRaw: f.Int.pipe(i(6)),
+	palette: f.Array(o).pipe(i(7)),
+	sections: f.Array(m).pipe(i(8))
+}), g = Object.freeze({
+	maxSide: 64,
+	maxVoxels: 262144,
+	maxPalette: 256,
+	maxSections: 64,
+	maxRunsPerSection: 4096,
+	maxBytes: 1048576
+}), _ = Object.freeze({
+	maxSide: 128,
+	maxVoxels: 2097152,
+	maxPalette: 4096,
+	maxSections: 512,
+	maxRunsPerSection: 4096,
+	maxBytes: 16777216
+}), v = (e, t, n) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : l(), y = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : l(), b = (e) => {
+	let t = c(e, [
+		"worldId",
+		"layerSetId",
+		"cx",
+		"cy",
+		"cz"
+	]);
+	return Object.freeze({
+		worldId: y(t.worldId),
+		layerSetId: y(t.layerSetId),
+		cx: v(t.cx, -2147483648, 2147483647),
+		cy: v(t.cy, -2147483648, 2147483647),
+		cz: v(t.cz, -2147483648, 2147483647)
+	});
+}, x = (e) => {
+	let t = c(e, ["key", "solid"]);
+	return typeof t.key != "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(t.key) || typeof t.solid != "boolean" ? l() : Object.freeze({
+		key: t.key,
+		solid: t.solid
+	});
+}, S = (e, t, n) => {
+	if (!Array.isArray(e) || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return l();
+	let r = [];
+	for (let t = 0; t < e.length; t++) {
+		let i = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!i?.enumerable || !("value" in i)) return l();
+		r.push(n(i.value, t));
+	}
+	return Object.freeze(r);
+}, C = [
+	"address",
+	"version",
+	"side",
+	"voxelSizeRaw"
+], w = (e, t) => ({
+	sx: e % t,
+	sy: Math.floor(e / t) % t,
+	sz: Math.floor(e / (t * t))
+}), T = (n = {}) => {
+	let i = Object.keys(g), o = c(n, i, []), s = { ...g };
+	for (let e of i) Object.hasOwn(o, e) && (s[e] = v(o[e], e === "maxBytes" ? 64 : e === "maxSide" ? 16 : 1, _[e]));
+	let u = Object.freeze(s), f = new a(h, {
+		maxBytes: u.maxBytes - 12,
+		maxCollectionLength: Math.max(u.maxPalette, u.maxSections, u.maxRunsPerSection),
+		maxFieldId: 16
+	}), p = (t) => {
+		let n = v(t.side, 16, u.maxSide), r = v(t.voxelSizeRaw, 1, 2147483647);
+		if (n % 16 != 0 || n * r > 2147483647) return l();
+		let i = n / 16, a = i * i * i, o = n * n * n;
+		if (a > u.maxSections) throw new e({
+			budget: "geometryVoxelSections",
+			limit: u.maxSections
+		});
+		if (o > u.maxVoxels) throw new e({
+			budget: "geometryVoxels",
+			limit: u.maxVoxels
+		});
+		return {
+			side: n,
+			voxelSizeRaw: r,
+			edge: i,
+			sections: a,
+			voxels: o
+		};
+	}, m = (e) => {
+		let t = c(e, [
+			"kind",
+			"formatVersion",
+			...C,
+			"palette",
+			"sections"
+		]);
+		if (t.kind !== "3d-voxel" || t.formatVersion !== 1) return l();
+		let n = p(t), r = S(t.palette, u.maxPalette, x);
+		if (!r.length) return l();
+		for (let e = 1; e < r.length; e++) if (r[e - 1].key >= r[e].key) return l();
+		let i = new Uint8Array(r.length), a = S(t.sections, n.sections, (e, t) => {
+			let a = c(e, [
+				"sx",
+				"sy",
+				"sz",
+				"runs"
+			]), o = w(t, n.edge);
+			if (a.sx !== o.sx || a.sy !== o.sy || a.sz !== o.sz) return l();
+			let s = 0, d = -1, f = S(a.runs, u.maxRunsPerSection, (e) => {
+				let t = c(e, ["paletteIndex", "length"]), n = v(t.paletteIndex, 0, r.length - 1), a = v(t.length, 1, 4096);
+				return n === d || a > 4096 - s ? l() : (s += a, d = n, i[n] = 1, Object.freeze({
+					paletteIndex: n,
+					length: a
+				}));
+			});
+			return s === 4096 ? Object.freeze({
+				...o,
+				runs: f
+			}) : l();
+		});
+		return a.length !== n.sections || i.some((e) => e === 0) ? l() : Object.freeze({
+			kind: "3d-voxel",
+			formatVersion: 1,
+			address: b(t.address),
+			version: y(t.version),
+			side: n.side,
+			voxelSizeRaw: n.voxelSizeRaw,
+			palette: r,
+			sections: a
+		});
+	}, T = (t) => {
+		let n = c(t, [...C, "voxels"]), r = p(n), i = S(n.voxels, r.voxels, x);
+		if (i.length !== r.voxels) return l();
+		let a = /* @__PURE__ */ new Map();
+		for (let t of i) {
+			let n = a.get(t.key);
+			if (n && n.solid !== t.solid) return l();
+			if (a.set(t.key, t), a.size > u.maxPalette) throw new e({
+				budget: "geometryVoxelPalette",
+				limit: u.maxPalette
+			});
+		}
+		let o = [...a.values()].sort((e, t) => e.key < t.key ? -1 : +(e.key > t.key)), s = new Map(o.map((e, t) => [e.key, t])), d = [];
+		for (let t = 0; t < r.sections; t++) {
+			let n = w(t, r.edge), a = [];
+			for (let t = 0; t < 4096; t++) {
+				let o = n.sx * 16 + (t & 15), c = n.sy * 16 + (t >>> 4 & 15), l = n.sz * 16 + (t >>> 8), d = s.get(i[(l * r.side + c) * r.side + o].key), f = a.at(-1);
+				if (f?.paletteIndex === d ? a[a.length - 1] = {
+					paletteIndex: d,
+					length: f.length + 1
+				} : a.push({
+					paletteIndex: d,
+					length: 1
+				}), a.length > u.maxRunsPerSection) throw new e({
+					budget: "geometryVoxelRuns",
+					limit: u.maxRunsPerSection
+				});
+			}
+			d.push({
+				...n,
+				runs: a
+			});
+		}
+		return m({
+			kind: "3d-voxel",
+			formatVersion: 1,
+			address: n.address,
+			version: n.version,
+			side: r.side,
+			voxelSizeRaw: r.voxelSizeRaw,
+			palette: o,
+			sections: d
+		});
+	}, E = (e) => {
+		let n = f.full(m(e));
+		if (d.isFailure(n)) return l();
+		let r = new Uint8Array(12 + n.success.byteLength), i = new DataView(r.buffer);
+		return r.set(t["3d-voxel"]), i.setUint32(4, f.schemaHash, !0), i.setUint32(8, n.success.byteLength, !0), r.set(n.success, 12), r;
+	};
+	return Object.freeze({
+		limits: u,
+		schemaHash: f.schemaHash,
+		capture: m,
+		create: T,
+		encode: E,
+		decode: (n) => {
+			let i;
+			try {
+				i = r(n, u.maxBytes, "geometryVoxelBytes");
+			} catch (t) {
+				if (t instanceof e) throw t;
+				return l();
+			}
+			if (i.length < 12 || t["3d-voxel"].some((e, t) => i[t] !== e)) return l();
+			let a = new DataView(i.buffer, i.byteOffset, 12);
+			if (a.getUint32(4, !0) !== f.schemaHash || a.getUint32(8, !0) !== i.length - 12) return l();
+			let o = f.decodeFull(i.subarray(12));
+			if (d.isFailure(o)) return l();
+			let s = m(o.success), c = E(s);
+			return c.length !== i.length || c.some((e, t) => e !== i[t]) ? l() : s;
+		}
+	});
+}, E = (e, t = {}) => {
+	let n = T(t).capture(e), r = n.side / 16, i = n.sections.map((e) => {
+		let t = new Uint16Array(e.runs.length), n = new Uint16Array(e.runs.length), r = 0;
+		return e.runs.forEach((e, i) => {
+			r += e.length, t[i] = r, n[i] = e.paletteIndex;
+		}), {
+			ends: t,
+			palette: n
+		};
+	}), a = (e, t, a) => {
+		v(e, 0, n.side - 1), v(t, 0, n.side - 1), v(a, 0, n.side - 1);
+		let o = i[((a >>> 4) * r + (t >>> 4)) * r + (e >>> 4)], s = ((a & 15) * 16 + (t & 15)) * 16 + (e & 15), c = 0, l = o.ends.length;
+		for (; c < l;) {
+			let e = c + l >>> 1;
+			o.ends[e] > s ? l = e : c = e + 1;
+		}
+		return n.palette[o.palette[c]];
+	};
+	return Object.freeze({
+		chunk: n,
+		materialAt: a,
+		solidAt: (e, t, n) => a(e, t, n).solid,
+		materialAtRaw: (e, t, r) => {
+			let i = n.side * n.voxelSizeRaw;
+			return v(e, 0, i - 1), v(t, 0, i - 1), v(r, 0, i - 1), a(p.div(p.raw(e), p.raw(n.voxelSizeRaw)) >>> 16, p.div(p.raw(t), p.raw(n.voxelSizeRaw)) >>> 16, p.div(p.raw(r), p.raw(n.voxelSizeRaw)) >>> 16);
+		},
+		occupancy: () => {
+			let e = n.side * n.side * n.side, t = new Uint8Array(Math.ceil(e / 8));
+			for (let r = 0; r < e; r++) a(r % n.side, Math.floor(r / n.side) % n.side, Math.floor(r / (n.side * n.side))).solid && (t[r >>> 3] = t[r >>> 3] | 1 << (r & 7));
+			return t;
+		}
+	});
+};
+export { h as GeometryVoxelChunkSchema, m as GeometryVoxelSectionSchema, T as createGeometryVoxelCodec, E as createGeometryVoxelView, g as defaultGeometryVoxelLimits };

package/dist/geometryWorldEntitySubject.js

@@ -0,0 +1,31 @@
+import { ProtocolError as e } from "./errors.js";
+import { WORLD_ENTITIES_TABLE as t } from "./worldEntities.js";
+import { and as n, eq as r } from "@voltro/database";
+import { Effect as i } from "effect";
+// src/geometryWorldEntitySubject.ts
+var a = (a) => (o) => i.tryPromise({
+	try: async () => {
+		let e = await a.query({
+			table: t,
+			predicate: n(r("tenantId", o.tenantId), r("subjectId", o.subjectId), r("roomId", o.roomId)),
+			order: [],
+			take: 16,
+			skip: void 0,
+			projection: [
+				"tenantId",
+				"subjectId",
+				"subjectKind",
+				"roomId"
+			]
+		}), i = new Set(e.map((e) => e.subjectKind));
+		if (!e.length || i.size !== 1 || e.some((e) => e.tenantId !== o.tenantId || e.subjectId !== o.subjectId || e.roomId !== o.roomId)) throw Error("no entity");
+		let s = [...i][0];
+		if (s !== "user" && s !== "guest") throw Error("no kind");
+		return Object.freeze({
+			id: o.subjectId,
+			kind: s
+		});
+	},
+	catch: () => new e({ detail: "Geometry recipient has no World entity in this Room" })
+});
+export { a as worldEntityGeometrySubject };

package/dist/geometryWorldExtent.js

@@ -0,0 +1,11 @@
+// src/geometryWorldExtent.ts
+var e = (e, t) => {
+	let n = e.chunk;
+	switch (n.kind) {
+		case "2d-tiles": return n.width * n.tileSizeRaw === t && n.height * n.tileSizeRaw === t;
+		case "2d-heightfield": return (n.width - 1) * n.sampleSpacingRaw === t && (n.height - 1) * n.sampleSpacingRaw === t;
+		case "3d-shapes": return n.extentXRaw === t && n.extentYRaw === t && n.extentZRaw === t;
+		case "3d-voxel": return n.side * n.voxelSizeRaw === t;
+	}
+};
+export { e as geometryChunkHasWorldExtent };