@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryServer.js

@@ -0,0 +1,62 @@
+import { RoomGeometryReloadRequestSchema as e, RoomGeometryRollbackRequestSchema as t } from "./geometryAdminSchemas.js";
+import { captureRoomGeometryReloadRequest as n, captureRoomGeometryRollbackRequest as r } from "./geometryAdminData.js";
+import { RoomGeometryReloadPort as i, captureRoomGeometryReloadPort as a, roomGeometryReloadLayer as o } from "./geometryReloadPorts.js";
+import { RoomGeometryRollbackPort as s, captureRoomGeometryRollbackPort as c, roomGeometryRollbackLayer as l } from "./geometryRollbackPorts.js";
+import { GEO_JOURNAL_ARCHIVES_TABLE as u, geometryJournalArchivesTable as d } from "./geometryJournalArchiveTable.js";
+import { defaultGeometryMigrateDelta as f } from "./geometryMigrationStrategies.js";
+import { GeometryJournalRetentionWorkflowPayload as p, GeometryJournalRetentionWorkflowResult as m } from "./geometryJournalRetentionSchemas.js";
+import { geometryChunkHttpHeaders as h, geometryChunkHttpQuery as g, geometryChunkHttpResponse as _ } from "./geometryChunkHttp.js";
+import { GEO_MIGRATIONS_TABLE as v, geometryMigrationsTable as y } from "./geometryMigrationJournal.js";
+import { roomsGeometryHttpRoute as b } from "./geometryHttpRoutes.js";
+import { prepareGeometryVersionMigration as x } from "./geometryVersionMigration.js";
+import { makeGeometryJournalPatchReader as S } from "./geometryJournalPatch.js";
+import { GeometryPersistencePort as C, GeometryStaticSourcePort as w, geometryPersistenceLayer as T, geometryStaticSourceLayer as E } from "./geometryPersistencePorts.js";
+import { GEO_CHUNK_DELTAS_TABLE as D, GEO_JOURNAL_TABLE as O, GEO_VERSIONS_TABLE as k, dataStoreGeometryPersistence as A, geometryChunkDeltasTable as j, geometryJournalTable as M, geometryPersistencePrivacyHooks as N, geometryPersistenceTables as P, geometryVersionsTable as F } from "./geometryPersistence.js";
+import { GeometryVersionMigrationPort as I, captureGeometryMigrationReceipt as L, captureGeometryMigrationRequest as R, dataStoreGeometryMigrations as z, geometryMigrationContribution as B, geometryVersionMigrationLayer as V } from "./geometryMigrations.js";
+import { RoomGeometryAdministrationPort as H } from "./geometryAdministrationPorts.js";
+import { GeometryJournalRetentionSweepPort as U, dataStoreGeometryJournalRetentionSweep as W, geometryJournalRetentionSweepLayer as G } from "./geometryJournalRetentionSweep.js";
+import { GeometryJournalArchiveIndexPort as K, dataStoreGeometryJournalArchiveIndex as q, geometryJournalArchiveIndexLayer as J, geometryJournalArchiveIndexPrivacyHooks as Y } from "./geometryJournalArchiveIndex.js";
+import { GeometryAssetManifestPort as X, GeometryAssetReadGrantPort as Z, geometryAssetManifestLayer as Q } from "./geometryAssetPorts.js";
+import { GeometryStaticReadGrantPort as $ } from "./geometryReadPorts.js";
+import { GeometryManifestPort as ee, geometryManifestLayer as te } from "./geometryManifestPorts.js";
+import { captureGeometryStreamManifest as ne } from "./geometryManifestData.js";
+import { makeRoomGeometryResource as re } from "./geometryHost.js";
+import { loadPreparedWorldGeometry as ie } from "./geometryLoader.js";
+import { loadPreparedWorldCellGeometry as ae } from "./geometryCellLoader.js";
+import { dataStoreRoomHostGeometry as oe, recordedGeometryPlacement as se } from "./geometryHostDirectory.js";
+import { dataStoreGeometryManifest as ce } from "./geometryManifest.js";
+import { dataStoreGeometryAdministration as le, roomGeometryAdministrationLayer as ue } from "./geometryAdministration.js";
+import { prepareGeometryChunkSnapshot as de } from "./geometrySnapshotPreparation.js";
+import { makeRoomGeometrySnapshotServer as fe } from "./geometrySnapshotServer.js";
+import { makeGeometryManifestPublication as pe } from "./geometryManifestPublication.js";
+import { makeRoomGeometryStreams as me } from "./geometryHostStreams.js";
+import { makeGeometryCommitCoordinator as he } from "./geometryCommitCoordinator.js";
+import { prepareGeometryPlayerCommit as ge } from "./geometryPlayerEdits.js";
+import { prepareGeometryActivation as _e } from "./geometryActivation.js";
+import { makeGeometryPlayerEditOwner as ve } from "./geometryPlayerEditOwner.js";
+import { makeGeometryReliablePublication as ye } from "./geometryReliablePublication.js";
+import { makeGeometryEditIngress as be } from "./geometryEditIngress.js";
+import { makeRoomGeometryMutations as xe } from "./geometryHostMutations.js";
+import { bindGeometryChunkLeases as Se, makeGeometryChunkLeases as Ce } from "./geometryChunkLeases.js";
+import { makeGeometryRollbackCoordinator as we } from "./geometryRollbackCoordinator.js";
+import { bindRoomGeometryRollbackSource as Te, makeRoomGeometryRollbackSource as Ee } from "./geometryRollbackSource.js";
+import { GeometryRollbackPreparationPort as De, dataStoreGeometryRollbackPreparation as Oe, geometryRollbackPreparationLayer as ke } from "./geometryRollbackStore.js";
+import { worldEntityGeometrySubject as Ae } from "./geometryWorldEntitySubject.js";
+import { RoomGeometryControlPort as je } from "./geometryAdminPorts.js";
+import { storageGeometry as Me } from "./geometryStorage.js";
+import { storageGeometryReadGrants as Ne } from "./geometryStorageGrant.js";
+import { appStorageGeometry as Pe } from "./geometryAppStorage.js";
+import { publishGeometryArtifacts as Fe } from "./geometryPublication.js";
+import { importPngGeometry as Ie } from "./geometryImportPng.js";
+import { prepareGeometryImportPublication as Le } from "./geometryImportPublication.js";
+import { loadImportedGeometryPublication as Re } from "./geometryImportedSource.js";
+import { openGeometryProceduralWorker as ze } from "./geometryProceduralWorker.js";
+import { prepareProceduralGeometryPublication as Be } from "./geometryProceduralPublication.js";
+import { prepareGeometryVersionActivation as Ve } from "./geometryVersionActivation.js";
+import { bindRoomGeometryReloadSource as He, makeRoomGeometryReloadSource as Ue } from "./geometryReloadSource.js";
+import { storageGeometryAssetReadGrants as We } from "./geometryAssetStorageGrant.js";
+import { GeometryJournalArchivePort as Ge, geometryJournalArchiveLayer as Ke, storageGeometryJournal as qe } from "./geometryJournalStorage.js";
+import { GeometryJournalCompactionPort as Je, dataStoreGeometryJournalCompaction as Ye, geometryJournalCompactionLayer as Xe } from "./geometryJournalCompaction.js";
+import { GeometryJournalRetentionPort as Ze, dataStoreGeometryJournalRetention as Qe, defaultGeometryJournalRetentionStrategies as $e, geometryJournalRetentionLayer as et } from "./geometryJournalRetention.js";
+import { geometryJournalRetentionWorkflowExecutor as tt } from "./geometryJournalRetentionWorkflow.js";
+export { D as GEO_CHUNK_DELTAS_TABLE, u as GEO_JOURNAL_ARCHIVES_TABLE, O as GEO_JOURNAL_TABLE, v as GEO_MIGRATIONS_TABLE, k as GEO_VERSIONS_TABLE, X as GeometryAssetManifestPort, Z as GeometryAssetReadGrantPort, K as GeometryJournalArchiveIndexPort, Ge as GeometryJournalArchivePort, Je as GeometryJournalCompactionPort, Ze as GeometryJournalRetentionPort, U as GeometryJournalRetentionSweepPort, p as GeometryJournalRetentionWorkflowPayload, m as GeometryJournalRetentionWorkflowResult, ee as GeometryManifestPort, C as GeometryPersistencePort, De as GeometryRollbackPreparationPort, $ as GeometryStaticReadGrantPort, w as GeometryStaticSourcePort, I as GeometryVersionMigrationPort, H as RoomGeometryAdministrationPort, je as RoomGeometryControlPort, i as RoomGeometryReloadPort, e as RoomGeometryReloadRequestSchema, s as RoomGeometryRollbackPort, t as RoomGeometryRollbackRequestSchema, Pe as appStorageGeometry, Se as bindGeometryChunkLeases, He as bindRoomGeometryReloadSource, Te as bindRoomGeometryRollbackSource, L as captureGeometryMigrationReceipt, R as captureGeometryMigrationRequest, ne as captureGeometryStreamManifest, a as captureRoomGeometryReloadPort, n as captureRoomGeometryReloadRequest, c as captureRoomGeometryRollbackPort, r as captureRoomGeometryRollbackRequest, le as dataStoreGeometryAdministration, q as dataStoreGeometryJournalArchiveIndex, Ye as dataStoreGeometryJournalCompaction, Qe as dataStoreGeometryJournalRetention, W as dataStoreGeometryJournalRetentionSweep, ce as dataStoreGeometryManifest, z as dataStoreGeometryMigrations, A as dataStoreGeometryPersistence, Oe as dataStoreGeometryRollbackPreparation, oe as dataStoreRoomHostGeometry, $e as defaultGeometryJournalRetentionStrategies, f as defaultGeometryMigrateDelta, Q as geometryAssetManifestLayer, j as geometryChunkDeltasTable, h as geometryChunkHttpHeaders, g as geometryChunkHttpQuery, _ as geometryChunkHttpResponse, J as geometryJournalArchiveIndexLayer, Y as geometryJournalArchiveIndexPrivacyHooks, Ke as geometryJournalArchiveLayer, d as geometryJournalArchivesTable, Xe as geometryJournalCompactionLayer, et as geometryJournalRetentionLayer, G as geometryJournalRetentionSweepLayer, tt as geometryJournalRetentionWorkflowExecutor, M as geometryJournalTable, te as geometryManifestLayer, B as geometryMigrationContribution, y as geometryMigrationsTable, T as geometryPersistenceLayer, N as geometryPersistencePrivacyHooks, P as geometryPersistenceTables, ke as geometryRollbackPreparationLayer, E as geometryStaticSourceLayer, V as geometryVersionMigrationLayer, F as geometryVersionsTable, Ie as importPngGeometry, Re as loadImportedGeometryPublication, ae as loadPreparedWorldCellGeometry, ie as loadPreparedWorldGeometry, Ce as makeGeometryChunkLeases, he as makeGeometryCommitCoordinator, be as makeGeometryEditIngress, S as makeGeometryJournalPatchReader, pe as makeGeometryManifestPublication, ve as makeGeometryPlayerEditOwner, ye as makeGeometryReliablePublication, we as makeGeometryRollbackCoordinator, xe as makeRoomGeometryMutations, Ue as makeRoomGeometryReloadSource, re as makeRoomGeometryResource, Ee as makeRoomGeometryRollbackSource, fe as makeRoomGeometrySnapshotServer, me as makeRoomGeometryStreams, ze as openGeometryProceduralWorker, _e as prepareGeometryActivation, de as prepareGeometryChunkSnapshot, Le as prepareGeometryImportPublication, ge as prepareGeometryPlayerCommit, Ve as prepareGeometryVersionActivation, x as prepareGeometryVersionMigration, Be as prepareProceduralGeometryPublication, Fe as publishGeometryArtifacts, se as recordedGeometryPlacement, ue as roomGeometryAdministrationLayer, o as roomGeometryReloadLayer, l as roomGeometryRollbackLayer, b as roomsGeometryHttpRoute, Me as storageGeometry, We as storageGeometryAssetReadGrants, qe as storageGeometryJournal, Ne as storageGeometryReadGrants, Ae as worldEntityGeometrySubject };

package/dist/geometryShapeRaycast.js

@@ -0,0 +1,111 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryPreparedInventory as r } from "./geometryPrepared.js";
+import { clipGeometryRayInterval as i, compareGeometryRayTime as a, geometryRayRational as o, geometryRaySphereInterval as s, geometryRayTimeBounds as c } from "./geometryRayAlgebra.js";
+//#region src/geometryShapeRaycast.ts
+function l() {
+	throw new t({ detail: "Shape ray requires signed raw endpoints and complete matching prepared collision coverage" });
+}
+var u = (e) => typeof e == "number" && Number.isSafeInteger(e) && e >= -2147483648 && e <= 2147483647 ? e : l(), d = (e, t, n, r, i, s) => {
+	let { entry: c, exit: l, entryOpen: u, exitOpen: d } = e;
+	for (let e = 0; e < 3; e++) {
+		let f = t[e], p = n[e];
+		if (!p) {
+			if (f < r[e] || f > i[e] || s && f === i[e]) return null;
+			continue;
+		}
+		let m = Math.abs(p), h = o(p > 0 ? r[e] - f : f - i[e], m), g = o(p > 0 ? i[e] - f : f - r[e], m), _ = s && p < 0, v = s && p > 0, y = a(h, c), b = a(g, l);
+		y > 0 ? (c = h, u = _) : y || (u ||= _), b < 0 ? (l = g, d = v) : b || (d ||= v);
+		let x = a(c, l);
+		if (x > 0 || !x && (u || d)) return null;
+	}
+	return {
+		entry: c,
+		exit: l,
+		entryOpen: u,
+		exitOpen: d
+	};
+}, f = (t, f, p, m, h, g) => {
+	let _ = r(t), v = [
+		"xRaw",
+		"yRaw",
+		"zRaw"
+	], y = n(p, v), b = n(m, v), x = v.map((e) => u(y[e])), S = v.map((e) => u(b[e]));
+	if (_.scope.kind !== "3d-shapes" || !Number.isSafeInteger(f) || f < 1 || f > 2147483647 || !Number.isSafeInteger(h) || h < 1 || h > 1048576 || !Number.isSafeInteger(g) || g < 1 || g > 1048576) return l();
+	let C = x.map((e, t) => ({
+		low: Math.floor(Math.min(e, S[t]) / f),
+		high: Math.floor(Math.max(e, S[t]) / f)
+	})), w = S.map((e, t) => e - x[t]), T = {
+		entry: o(0),
+		exit: o(1),
+		entryOpen: !1,
+		exitOpen: !1
+	}, E = 1;
+	for (let t of C) {
+		let n = t.high - t.low + 1;
+		if (n > h || E * n > h) throw new e({
+			budget: "geometryRayVisitedCells",
+			limit: h
+		});
+		E *= n;
+	}
+	let D = 0, O = null;
+	for (let t = C[2].low; t <= C[2].high; t++) for (let n = C[1].low; n <= C[1].high; n++) for (let r = C[0].low; r <= C[0].high; r++) {
+		let o = _.at({
+			cx: r,
+			cy: n,
+			cz: t
+		}), c = o.collision;
+		if (c.kind !== "3d-shapes" || c.view.chunk.extentXRaw !== f || c.view.chunk.extentYRaw !== f || c.view.chunk.extentZRaw !== f) return l();
+		let u = c.view.chunk.shapes;
+		if (u.length > g - D) throw new e({
+			budget: "geometryRayShapeTests",
+			limit: g
+		});
+		D += u.length;
+		let p = [
+			r * f,
+			n * f,
+			t * f
+		], m = p.map((e) => e + f);
+		for (let e of u) {
+			let t = [
+				e.xRaw,
+				e.yRaw,
+				e.zRaw
+			].map((e, t) => e + p[t]), n;
+			if (e.kind === "aabb") {
+				let r = [
+					e.halfXRaw,
+					e.halfYRaw,
+					e.halfZRaw
+				];
+				n = d(T, x, w, t.map((e, t) => e - r[t]), t.map((e, t) => e + r[t]), !1);
+			} else {
+				let r = i(s(x, S, t, e.radiusRaw));
+				n = r ? {
+					...r,
+					entryOpen: !1,
+					exitOpen: !1
+				} : null;
+			}
+			n &&= d(n, x, w, p, m, !0), n && (!O || a(n.entry, O.time) < 0) && (O = {
+				time: n.entry,
+				scope: o.scope,
+				revision: o.revision,
+				shape: e
+			});
+		}
+	}
+	return O ? Object.freeze({
+		kind: "3d-shapes",
+		scope: O.scope,
+		revision: O.revision,
+		shape: O.shape,
+		fractionBounds: c(O.time),
+		visitedChunks: E,
+		testedShapes: D
+	}) : null;
+};
+//#endregion
+export { f as raycastPreparedGeometryShapes };

package/dist/geometryShapeSegments.js

@@ -0,0 +1,34 @@
+import { addUint64 as e, compareUint64 as t, multiplyWords as n } from "./fixedWords.js";
+import { clipFixedBoxSlabs as r } from "./fixedSlabs.js";
+import { compareWide as i, product as a, subtract as o } from "./fixedWide.js";
+//#region src/geometryShapeSegments.ts
+var s = {
+	hi: 0,
+	lo: 0
+}, c = (t) => t.reduce((t, r) => e(t, n(Math.abs(r), Math.abs(r))), s), l = (l, u, d) => {
+	let f = [
+		l.xRaw,
+		l.yRaw,
+		l.zRaw
+	], p = d.map((e, t) => e - u[t]);
+	if (l.kind === "aabb") {
+		let e = [
+			l.halfXRaw,
+			l.halfYRaw,
+			l.halfZRaw
+		];
+		return r(u, u, p, f.map((t, n) => t - e[n]), f.map((t, n) => t + e[n]), !1) !== null;
+	}
+	let m = u.map((e, t) => e - f[t]), h = n(l.radiusRaw, l.radiusRaw), g = c(m);
+	if (t(g, h) <= 0) return !0;
+	let _ = s, v = s;
+	for (let t = 0; t < 3; t++) {
+		let r = m[t], i = p[t], a = n(Math.abs(r), Math.abs(i));
+		r < 0 == i < 0 ? _ = e(_, a) : v = e(v, a);
+	}
+	if (t(v, _) <= 0) return !1;
+	let y = o(v, _), b = c(p);
+	return t(y, b) >= 0 ? t(c(d.map((e, t) => e - f[t])), h) <= 0 : i(a(b, o(g, h)), a(y, y)) <= 0;
+};
+//#endregion
+export { l as geometryShapeIntersectsSegment };

package/dist/geometryShapes.js

@@ -0,0 +1,223 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryEnvelopeMagic as t } from "./geometryEnvelope.js";
+import { addUint64 as n, compareUint64 as r, multiplyWords as i } from "./fixedWords.js";
+import { captureSimulationBytes as a } from "./simulationBytes.js";
+import { fieldId as o } from "./room.js";
+import { RoomInputCodec as s } from "./stateCodec.js";
+import { geometryOwnData as c, geometryTileRefusal as l } from "./geometryTileCodec.js";
+import { geometryShapeIntersectsSegment as u } from "./geometryShapeSegments.js";
+import { Result as d, Schema as f } from "effect";
+//#region src/geometryShapes.ts
+var p = f.Struct({
+	worldId: f.String.pipe(o(1)),
+	layerSetId: f.String.pipe(o(2)),
+	cx: f.Int.pipe(o(3)),
+	cy: f.Int.pipe(o(4)),
+	cz: f.Int.pipe(o(5))
+}), m = {
+	id: f.String.pipe(o(2)),
+	xRaw: f.Int.pipe(o(3)),
+	yRaw: f.Int.pipe(o(4)),
+	zRaw: f.Int.pipe(o(5))
+}, h = f.Struct({
+	kind: f.Literal("aabb").pipe(o(1)),
+	...m,
+	halfXRaw: f.Int.pipe(o(6)),
+	halfYRaw: f.Int.pipe(o(7)),
+	halfZRaw: f.Int.pipe(o(8))
+}), g = f.Struct({
+	kind: f.Literal("sphere").pipe(o(1)),
+	...m,
+	radiusRaw: f.Int.pipe(o(6))
+}), _ = f.Union([h, g]), v = f.Struct({
+	kind: f.Literal("3d-shapes").pipe(o(1)),
+	formatVersion: f.Literal(1).pipe(o(2)),
+	address: p.pipe(o(3)),
+	version: f.String.pipe(o(4)),
+	extentXRaw: f.Int.pipe(o(5)),
+	extentYRaw: f.Int.pipe(o(6)),
+	extentZRaw: f.Int.pipe(o(7)),
+	shapes: f.Array(_).pipe(o(8))
+}), y = Object.freeze({
+	maxShapes: 4096,
+	maxBytes: 1048576
+}), b = (e, t, n) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : l(), x = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : l(), S = (e) => {
+	let t = c(e, [
+		"worldId",
+		"layerSetId",
+		"cx",
+		"cy",
+		"cz"
+	]);
+	return Object.freeze({
+		worldId: x(t.worldId),
+		layerSetId: x(t.layerSetId),
+		cx: b(t.cx, -2147483648, 2147483647),
+		cy: b(t.cy, -2147483648, 2147483647),
+		cz: b(t.cz, -2147483648, 2147483647)
+	});
+}, C = [
+	"address",
+	"version",
+	"extentXRaw",
+	"extentYRaw",
+	"extentZRaw",
+	"shapes"
+], w = (n = {}) => {
+	let r = c(n, ["maxShapes", "maxBytes"], []), i = Object.freeze({
+		maxShapes: Object.hasOwn(r, "maxShapes") ? b(r.maxShapes, 1, 65536) : y.maxShapes,
+		maxBytes: Object.hasOwn(r, "maxBytes") ? b(r.maxBytes, 64, 16777216) : y.maxBytes
+	}), o = new s(v, {
+		maxBytes: i.maxBytes - 12,
+		maxCollectionLength: i.maxShapes,
+		maxFieldId: 16
+	}, "f64"), u = (e, t = !1) => {
+		let n = c(e, t ? C : [
+			"kind",
+			"formatVersion",
+			...C
+		]);
+		if (!t && (n.kind !== "3d-shapes" || n.formatVersion !== 1)) return l();
+		let r = b(n.extentXRaw, 1, 2147483647), a = b(n.extentYRaw, 1, 2147483647), o = b(n.extentZRaw, 1, 2147483647), s = n.shapes;
+		if (!Array.isArray(s) || s.length > i.maxShapes || Reflect.ownKeys(s).length !== s.length + 1) return l();
+		let u = [];
+		for (let e = 0; e < s.length; e++) {
+			let t = Object.getOwnPropertyDescriptor(s, String(e));
+			if (!t?.enumerable || !("value" in t)) return l();
+			let n = c(t.value, [
+				"kind",
+				"id",
+				"xRaw",
+				"yRaw",
+				"zRaw",
+				"halfXRaw",
+				"halfYRaw",
+				"halfZRaw",
+				"radiusRaw"
+			], [
+				"kind",
+				"id",
+				"xRaw",
+				"yRaw",
+				"zRaw"
+			]), i = n.kind, d = b(n.xRaw, 0, r), f = b(n.yRaw, 0, a), p = b(n.zRaw, 0, o), m = x(n.id);
+			if (i === "aabb") {
+				if (Reflect.ownKeys(n).length !== 8) return l();
+				let e = b(n.halfXRaw, 1, 2147483647), t = b(n.halfYRaw, 1, 2147483647), s = b(n.halfZRaw, 1, 2147483647);
+				if (d < e || f < t || p < s || d + e > r || f + t > a || p + s > o) return l();
+				u.push(Object.freeze({
+					kind: i,
+					id: m,
+					xRaw: d,
+					yRaw: f,
+					zRaw: p,
+					halfXRaw: e,
+					halfYRaw: t,
+					halfZRaw: s
+				}));
+			} else if (i === "sphere") {
+				if (Reflect.ownKeys(n).length !== 6) return l();
+				let e = b(n.radiusRaw, 1, 2147483647);
+				if (d < e || f < e || p < e || d + e > r || f + e > a || p + e > o) return l();
+				u.push(Object.freeze({
+					kind: i,
+					id: m,
+					xRaw: d,
+					yRaw: f,
+					zRaw: p,
+					radiusRaw: e
+				}));
+			} else return l();
+		}
+		t && u.sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id));
+		for (let e = 1; e < u.length; e++) if (u[e - 1].id >= u[e].id) return l();
+		return Object.freeze({
+			kind: "3d-shapes",
+			formatVersion: 1,
+			address: S(n.address),
+			version: x(n.version),
+			extentXRaw: r,
+			extentYRaw: a,
+			extentZRaw: o,
+			shapes: Object.freeze(u)
+		});
+	}, f = (e) => {
+		let n = o.full(u(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-shapes"]), i.setUint32(4, o.schemaHash, !0), i.setUint32(8, n.success.byteLength, !0), r.set(n.success, 12), r;
+	};
+	return Object.freeze({
+		limits: i,
+		schemaHash: o.schemaHash,
+		capture: (e) => u(e),
+		create: (e) => u(e, !0),
+		encode: f,
+		decode: (n) => {
+			let r;
+			try {
+				r = a(n, i.maxBytes, "geometryShapeBytes");
+			} catch (t) {
+				if (t instanceof e) throw t;
+				return l();
+			}
+			if (r.length < 12 || t["3d-shapes"].some((e, t) => r[t] !== e)) return l();
+			let s = new DataView(r.buffer, r.byteOffset, 12);
+			if (s.getUint32(4, !0) !== o.schemaHash || s.getUint32(8, !0) !== r.length - 12) return l();
+			let c = o.decodeFull(r.subarray(12));
+			if (d.isFailure(c)) return l();
+			let p = u(c.success), m = f(p);
+			return m.length !== r.length || m.some((e, t) => e !== r[t]) ? l() : p;
+		}
+	});
+}, T = (t, a = {}) => {
+	let o = w(a), s = o.capture(t);
+	return Object.freeze({
+		chunk: s,
+		intersectingSegmentRaw: (t, n, r = o.limits.maxShapes) => {
+			if (b(r, 1, o.limits.maxShapes), r < s.shapes.length) throw new e({
+				budget: "geometryShapeQuery",
+				limit: r
+			});
+			let i = (e) => {
+				let t = c(e, [
+					"xRaw",
+					"yRaw",
+					"zRaw"
+				]);
+				return [
+					b(t.xRaw, 0, s.extentXRaw),
+					b(t.yRaw, 0, s.extentYRaw),
+					b(t.zRaw, 0, s.extentZRaw)
+				];
+			}, a = i(t), l = i(n);
+			return Object.freeze(s.shapes.filter((e) => u(e, a, l)));
+		},
+		containingRaw: (t, a = o.limits.maxShapes) => {
+			if (b(a, 1, o.limits.maxShapes), a < s.shapes.length) throw new e({
+				budget: "geometryShapeQuery",
+				limit: a
+			});
+			let l = c(t, [
+				"xRaw",
+				"yRaw",
+				"zRaw"
+			]), u = {
+				xRaw: b(l.xRaw, 0, s.extentXRaw),
+				yRaw: b(l.yRaw, 0, s.extentYRaw),
+				zRaw: b(l.zRaw, 0, s.extentZRaw)
+			}, d = [];
+			for (let e of s.shapes) {
+				let t = Math.abs(u.xRaw - e.xRaw), a = Math.abs(u.yRaw - e.yRaw), o = Math.abs(u.zRaw - e.zRaw);
+				if (e.kind === "aabb") t <= e.halfXRaw && a <= e.halfYRaw && o <= e.halfZRaw && d.push(e);
+				else if (t <= e.radiusRaw && a <= e.radiusRaw && o <= e.radiusRaw) {
+					let s = n(n(i(t, t), i(a, a)), i(o, o));
+					r(s, i(e.radiusRaw, e.radiusRaw)) <= 0 && d.push(e);
+				}
+			}
+			return Object.freeze(d);
+		}
+	});
+};
+//#endregion
+export { h as GeometryBoxSchema, p as GeometryChunkAddress3DSchema, _ as GeometryShapeSchema, v as GeometryShapesChunkSchema, g as GeometrySphereSchema, w as createGeometryShapesCodec, T as createGeometryShapesView, y as defaultGeometryShapesLimits };

package/dist/geometrySnapshot.js

@@ -0,0 +1,76 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometrySha256 as r } from "./geometryDigest.js";
+import { captureGeometryArtifact as i } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as a, captureGeometryPersistenceScope as o, geometryPersistenceId as s, geometryPersistenceInteger as c, geometryPersistenceSha as l } from "./geometryPersistenceData.js";
+import { applyGeometryPatch as u, createGeometryPatch as d, decodeGeometryPatch as f } from "./geometryPatch.js";
+//#region src/geometrySnapshot.ts
+var p = () => new e({ detail: "Native geometry recovery snapshot does not match its exact static base and scoped revision" }), m = async (e, t, l, u = 262144, f = {}) => {
+	let p = i(t), m = n(l, [
+		"scope",
+		"revision",
+		"artifact"
+	]), g = o(m.scope), _ = c(m.revision), v = i(m.artifact), y = c(u, 512, 16777216);
+	a(p, g), a(v, g);
+	let b = d(p, v, 0, {
+		limits: {
+			maxBytes: y,
+			maxMetadataBytes: Math.min(4096, y - 16)
+		},
+		codecLimits: f
+	}).bytes();
+	return h({
+		scope: g,
+		requestId: s(e),
+		revision: _,
+		staticBlobSha256: p.blobSha256,
+		staticContentSha256: p.contentSha256,
+		blobSha256: v.blobSha256,
+		contentSha256: v.contentSha256,
+		patchSha256: await r(b),
+		patch: b
+	}, y);
+}, h = (e, r = 262144) => {
+	let i = n(e, [
+		"scope",
+		"requestId",
+		"revision",
+		"staticBlobSha256",
+		"staticContentSha256",
+		"blobSha256",
+		"contentSha256",
+		"patchSha256",
+		"patch"
+	]), a = c(r, 512, 16777216), u = o(i.scope), d = c(i.revision), m = t(i.patch, a, "geometrySnapshotPatchBytes"), h = f(m, {
+		maxBytes: a,
+		maxMetadataBytes: Math.min(4096, a - 16)
+	}).metadata, g = l(i.staticBlobSha256), _ = l(i.staticContentSha256), v = l(i.blobSha256), y = l(i.contentSha256);
+	if (h.kind !== u.kind || h.worldId !== u.worldId || h.layerSetId !== u.layerSetId || h.version !== u.version || h.cx !== u.cx || h.cy !== u.cy || h.cz !== u.cz || h.baseRevision !== 0 || h.revision !== +!!h.changed || h.changed && d === 0 || h.baseBlobSha256 !== g || h.baseContentSha256 !== _ || h.blobSha256 !== v || h.contentSha256 !== y) throw p();
+	return Object.freeze({
+		scope: u,
+		requestId: s(i.requestId),
+		revision: d,
+		staticBlobSha256: g,
+		staticContentSha256: _,
+		blobSha256: v,
+		contentSha256: y,
+		patchSha256: l(i.patchSha256),
+		patch: m
+	});
+}, g = async (e, t, n = 262144, o = {}) => {
+	let s = i(e), c = h(t, n);
+	if (a(s, c.scope), s.blobSha256 !== c.staticBlobSha256 || s.contentSha256 !== c.staticContentSha256 || await r(c.patch) !== c.patchSha256) throw p();
+	let l = f(c.patch, {
+		maxBytes: n,
+		maxMetadataBytes: Math.min(4096, n - 16)
+	}), d = await u(s, l, 0, o);
+	if (d.artifact.blobSha256 !== c.blobSha256 || d.artifact.contentSha256 !== c.contentSha256) throw p();
+	return Object.freeze({
+		scope: c.scope,
+		revision: c.revision,
+		artifact: d.artifact
+	});
+};
+//#endregion
+export { g as applyGeometryChunkSnapshot, h as captureGeometryChunkSnapshot, m as createGeometryChunkSnapshot };

package/dist/geometrySnapshotChannel.js

@@ -0,0 +1,160 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryDense as r, captureGeometryPersistenceScope as i, geometryPersistenceId as a, geometryPersistenceInteger as o, geometryPersistenceSha as s } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedCoordinate as c } from "./geometryPrepared.js";
+import { makeGeometryManifestReceiver as l } from "./geometryManifestChannel.js";
+import { captureGeometryChunkSnapshot as u } from "./geometrySnapshot.js";
+import { Schema as d } from "effect";
+//#region src/geometrySnapshotChannel.ts
+var f = d.Struct({
+	cx: d.Int,
+	cy: d.Int,
+	cz: d.optional(d.Int)
+}), p = d.Struct({
+	tenantId: d.String,
+	kind: d.Literals([
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	]),
+	worldId: d.String,
+	layerSetId: d.String,
+	version: d.String,
+	cx: d.Int,
+	cy: d.Int,
+	cz: d.optional(d.Int)
+}), m = d.Struct({
+	requestId: d.String,
+	coordinate: f
+}), h = Object.freeze({
+	schema: m,
+	direction: "client",
+	reliable: !0
+}), g = d.Struct({
+	type: d.Literal("GeoChunkSnapshotFragment"),
+	scope: p,
+	requestId: d.String,
+	revision: d.Int,
+	staticBlobSha256: d.String,
+	staticContentSha256: d.String,
+	blobSha256: d.String,
+	contentSha256: d.String,
+	patchSha256: d.String,
+	totalBytes: d.Int,
+	offset: d.Int,
+	bytes: d.Array(d.Int)
+}), _ = Object.freeze({
+	schema: g,
+	direction: "server",
+	reliable: !0
+}), v = () => new t({ detail: "Geometry recovery request or fragment escaped its exact native bounded operation" }), y = (e, t) => {
+	let r = n(t, ["requestId", "coordinate"]), i = c(e, r.coordinate);
+	return Object.freeze({
+		requestId: a(r.requestId),
+		coordinate: Object.freeze({
+			cx: i.cx,
+			cy: i.cy,
+			...i.cz === void 0 ? {} : { cz: i.cz }
+		})
+	});
+}, b = (e, t = 262144) => {
+	let c = n(e, [
+		"type",
+		"scope",
+		"requestId",
+		"revision",
+		"staticBlobSha256",
+		"staticContentSha256",
+		"blobSha256",
+		"contentSha256",
+		"patchSha256",
+		"totalBytes",
+		"offset",
+		"bytes"
+	]), l = o(c.totalBytes, 16, o(t, 512, 16777216)), u = o(c.offset, 0, l - 1), d = r(c.bytes, 8192, (e) => o(e, 0, 255));
+	if (c.type !== "GeoChunkSnapshotFragment" || u % 8192 || d.length !== Math.min(8192, l - u)) throw v();
+	return Object.freeze({
+		type: "GeoChunkSnapshotFragment",
+		scope: i(c.scope),
+		requestId: a(c.requestId),
+		revision: o(c.revision),
+		staticBlobSha256: s(c.staticBlobSha256),
+		staticContentSha256: s(c.staticContentSha256),
+		blobSha256: s(c.blobSha256),
+		contentSha256: s(c.contentSha256),
+		patchSha256: s(c.patchSha256),
+		totalBytes: l,
+		offset: u,
+		bytes: d
+	});
+}, x = (e, t = 262144) => {
+	let { patch: n, ...r } = u(e, t), i = [];
+	for (let e = 0; e < n.length; e += 8192) i.push(Object.freeze({
+		type: "GeoChunkSnapshotFragment",
+		...r,
+		totalBytes: n.length,
+		offset: e,
+		bytes: Object.freeze(Array.from(n.subarray(e, e + 8192)))
+	}));
+	return Object.freeze(i);
+}, S = (t = {}) => {
+	let r = n(t, [
+		"maxPatchBytes",
+		"maxPending",
+		"maxPendingBytes"
+	], []), s = Object.hasOwn(r, "maxPatchBytes") ? o(r.maxPatchBytes, 512, 16777216) : 262144, c = Object.hasOwn(r, "maxPending") ? o(r.maxPending, 1, 256) : 4, d = Object.hasOwn(r, "maxPendingBytes") ? o(r.maxPendingBytes, 1024, 67108864) : 1048576, f = /* @__PURE__ */ new Map(), p = () => [...f.values()].reduce((e, t) => e + t.receiver.observation().accountedBytes, 0);
+	return Object.freeze({
+		receive: (t) => {
+			let { type: n, totalBytes: r, offset: i, bytes: a, ...o } = b(t, s), m = JSON.stringify([o.scope, o.requestId]), h = JSON.stringify([o, r]), g = f.get(m);
+			if (g && g.fingerprint !== h) throw v();
+			if (!g) {
+				if (f.size >= c) throw new e({
+					budget: "geometrySnapshotPendingTransfers",
+					limit: c
+				});
+				if (p() + r + Math.ceil(r / 8192) > d) throw new e({
+					budget: "geometrySnapshotPendingBytes",
+					limit: d
+				});
+				g = {
+					fingerprint: h,
+					header: o,
+					receiver: l({
+						maxManifestBytes: Math.max(1024, s),
+						maxPending: 1,
+						maxPendingBytes: d
+					})
+				}, f.set(m, g);
+			}
+			let _ = o.scope, y = g.receiver.receive({
+				type: "GeoManifestFragment",
+				scope: {
+					tenantId: _.tenantId,
+					kind: _.kind,
+					worldId: _.worldId,
+					layerSetId: _.layerSetId,
+					version: _.version
+				},
+				payloadSha256: o.patchSha256,
+				totalBytes: r,
+				offset: i,
+				bytes: a
+			});
+			return y ? (f.delete(m), u({
+				...g.header,
+				patch: y.bytes
+			}, s)) : null;
+		},
+		drop: (e, t) => f.delete(JSON.stringify([i(e), a(t)])),
+		reset: () => {
+			f.clear();
+		},
+		observation: () => Object.freeze({
+			pending: f.size,
+			accountedBytes: p()
+		})
+	});
+};
+//#endregion
+export { m as GeometryChunkRequestSchema, g as GeometryChunkSnapshotFragmentSchema, y as captureGeometryChunkRequest, b as captureGeometryChunkSnapshotFragment, x as createGeometryChunkSnapshotFragments, h as geometryChunkRequestChannel, _ as geometryChunkSnapshotChannel, S as makeGeometrySnapshotReceiver };