@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryReliablePublication.js

@@ -0,0 +1,82 @@
+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 { captureGeometryDense as i, captureGeometryOwner as a, captureGeometryPersistenceScope as o, geometryPersistenceId as s, geometryPersistenceInteger as c } from "./geometryPersistenceData.js";
+import { captureGeometryEditIntent as l } from "./geometryEdits.js";
+import { captureGeometryPreparedScope as u } from "./geometryPrepared.js";
+import { GeometryDeltaFragmentSchema as d, createGeometryDeltaFragments as f } from "./geometryChannel.js";
+import { captureRoomSnapshotEffectRunner as p } from "./snapshotBlobIndex.js";
+import { captureRoomReliableChannelWriter as m } from "./serverSession.js";
+import { Effect as h } from "effect";
+//#region src/geometryReliablePublication.ts
+var g = (g) => {
+	let _ = r(g, [
+		"scope",
+		"owner",
+		"currentSessions",
+		"authorizeRecipient",
+		"channel",
+		"maxRecipients",
+		"maxPatchBytes",
+		"maxFragmentDeliveries"
+	], [
+		"scope",
+		"owner",
+		"currentSessions",
+		"authorizeRecipient"
+	]), v = u(_.scope), y = a(_.owner), b = Object.hasOwn(_, "channel") ? s(_.channel, 96) : "geometry", x = (e, t, n, r) => Object.hasOwn(_, e) ? c(_[e], n, r) : t, S = x("maxRecipients", 64, 1, 4096), C = x("maxPatchBytes", 262144, 512, 16777216), w = x("maxFragmentDeliveries", 8192, 1, 65536), T = new n(d).schemaHash;
+	if (typeof _.currentSessions != "function" || typeof _.authorizeRecipient != "function" || !/^[A-Za-z][A-Za-z0-9._-]*$/.test(b)) throw new t({ detail: "Geometry reliable publication needs actual native recipient and authorization capabilities" });
+	let E = _.currentSessions, D = _.authorizeRecipient;
+	return (n) => {
+		try {
+			let a = r(n, [
+				"scope",
+				"requestId",
+				"intent",
+				"receipt",
+				"patch"
+			]), c = o(a.scope), u = s(a.requestId);
+			l(a.intent);
+			let d = f(a.receipt, a.patch, { maxPatchBytes: C }), g = d[0].receipt;
+			if (c.tenantId !== v.tenantId || c.kind !== v.kind || c.worldId !== v.worldId || c.version !== v.version || c.layerSetId !== v.layerSetId || JSON.stringify(g.scope) !== JSON.stringify(c) || g.requestId !== u) throw new t({ detail: "Geometry reliable publication escaped its exact prepared scope/result" });
+			return h.flatMap(h.context(), (n) => h.uninterruptible(h.tryPromise({
+				try: async () => {
+					let r = p(n), a = /* @__PURE__ */ new Set(), o = i(E(), S, (e) => {
+						let n = m(e), r = n.identity();
+						if (!r || r.tenantId !== v.tenantId || r.roomId !== y.roomId || r.epoch !== y.epoch || a.has(r.sessionId)) throw new t({ detail: "Geometry publication recipient is not a unique current native owner Session" });
+						return a.add(r.sessionId), {
+							writer: n,
+							evidence: r,
+							recipient: Object.freeze({
+								tenantId: r.tenantId,
+								roomId: r.roomId,
+								sessionId: r.sessionId,
+								subjectId: r.subjectId,
+								epoch: r.epoch
+							})
+						};
+					});
+					if (o.length * d.length > w) throw new e({
+						budget: "geometryReliableFragmentDeliveries",
+						limit: w
+					});
+					for (let e of o) {
+						let n = D(e.recipient, c);
+						if (!h.isEffect(n)) throw new t({ detail: "Geometry recipient authorization must be an actual Effect" });
+						if (await r(n) !== void 0) throw new t({ detail: "Geometry recipient authorization did not confirm void" });
+						if (JSON.stringify(e.writer.identity()) !== JSON.stringify(e.evidence)) throw new t({ detail: "Geometry native recipient changed during authorization" });
+					}
+					for (let e of o) for (let n of d) {
+						if (JSON.stringify(e.writer.identity()) !== JSON.stringify(e.evidence)) throw new t({ detail: "Geometry native recipient changed before reliable handoff" });
+						await e.writer.write(b, n, T);
+					}
+				},
+				catch: (n) => n instanceof e ? n : new t({ detail: "Geometry reliable publication remains unconfirmed" })
+			})));
+		} catch (n) {
+			return h.fail(n instanceof e ? n : new t({ detail: "Geometry reliable publication could not capture its exact result" }));
+		}
+	};
+};
+//#endregion
+export { g as makeGeometryReliablePublication };

package/dist/geometryReloadPorts.js

@@ -0,0 +1,46 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureRoomGeometryReloadRequest as r } from "./geometryAdminData.js";
+import { captureGeometryVersionActivation as i } from "./geometryActorInventory.js";
+import { Context as a, Effect as o, Layer as s } from "effect";
+//#region src/geometryReloadPorts.ts
+var c = class extends a.Service()("@voltro/RoomGeometryReloadPort") {}, l = (a) => {
+	let s = n(a, [
+		"authorize",
+		"prepare",
+		"resume",
+		"release"
+	]);
+	if (Object.values(s).some((e) => typeof e != "function")) throw new t({ detail: "Host geometry reload requires the complete actual administrative source" });
+	let c = s.authorize.bind(a), l = s.prepare.bind(a), u = s.resume.bind(a), d = s.release.bind(a), f = (n) => o.suspend(() => {
+		try {
+			let r = n();
+			return o.isEffect(r) ? r.pipe(o.mapError((n) => n instanceof e ? n : new t({ detail: "Actual geometry reload source remains unconfirmed" }))) : o.fail(new t({ detail: "Geometry reload source must return its actual Effect" }));
+		} catch {
+			return o.fail(new t({ detail: "Actual geometry reload source refused admission" }));
+		}
+	}), p = (e) => e === void 0 ? o.void : o.fail(new t({ detail: "Geometry reload source did not confirm void completion" }));
+	return Object.freeze({
+		authorize: (e, t, n) => {
+			let i = r(n);
+			return f(() => c(e, t, i)).pipe(o.flatMap(p));
+		},
+		prepare: (e, n) => {
+			let a = r(n);
+			return f(() => l(e, a)).pipe(o.flatMap((n) => o.try({
+				try: () => i(e.inventory, n),
+				catch: () => new t({ detail: "Reload preparation did not return the actual native actor token" })
+			})));
+		},
+		resume: (e, t, n) => {
+			let a = r(t), s = i(e.inventory, n);
+			return f(() => u(e, a, s)).pipe(o.flatMap(p));
+		},
+		release: (e, t) => {
+			let n = r(t);
+			return f(() => d(e, n)).pipe(o.flatMap(p));
+		}
+	});
+}, u = (e) => s.succeed(c, l(e));
+//#endregion
+export { c as RoomGeometryReloadPort, l as captureRoomGeometryReloadPort, r as captureRoomGeometryReloadRequest, u as roomGeometryReloadLayer };

package/dist/geometryReloadSource.js

@@ -0,0 +1,278 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryArtifact as r } from "./geometryArtifacts.js";
+import { captureGeometryPersistenceScope as i, geometryPersistenceInteger as a } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadRequest as o } from "./geometryAdminData.js";
+import { captureGeometryPreparedBaseline as s } from "./geometryPrepared.js";
+import { captureGeometryActorReadFrame as c, captureGeometryVersionActivationDetails as l } from "./geometryActorInventory.js";
+import { captureRoomGeometryReloadPort as u } from "./geometryReloadPorts.js";
+import { captureRoomSnapshotEffectRunner as d } from "./snapshotBlobIndex.js";
+import { geometryPersistenceDigest as f } from "./geometryPersistenceCapture.js";
+import { captureGeometryMigrationRequest as p } from "./geometryMigrations.js";
+import { captureRoomGeometryResourceIdentity as m, captureRoomGeometryResourceState as h } from "./geometryHost.js";
+import { bindGeometryChunkLeases as g } from "./geometryChunkLeases.js";
+import { prepareGeometryVersionActivation as _ } from "./geometryVersionActivation.js";
+import { Effect as v, Option as y } from "effect";
+//#region src/geometryReloadSource.ts
+var b = () => new t({ detail: "Geometry version coordination, SQL preparation or compare-only cleanup remains unconfirmed" }), x = (t) => {
+	let g = n(t, [
+		"authorize",
+		"migrations",
+		"persistence",
+		"leases",
+		"maxChunks",
+		"maxAccountedBytes"
+	], [
+		"authorize",
+		"migrations",
+		"persistence",
+		"leases"
+	]), x = n(g.migrations, [
+		"migrate",
+		"exportSubject",
+		"eraseSubject"
+	]), S = n(g.persistence, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]);
+	if (typeof g.authorize != "function" || typeof g.leases != "function" || [...Object.values(x), ...Object.values(S)].some((e) => typeof e != "function")) throw b();
+	let C = g.migrations, w = g.persistence, T = g.authorize.bind(t), E = g.leases.bind(t), D = Object.freeze({
+		migrate: x.migrate.bind(C),
+		exportSubject: x.exportSubject.bind(C),
+		eraseSubject: x.eraseSubject.bind(C)
+	}), O = Object.freeze({
+		publish: S.publish.bind(w),
+		observe: S.observe.bind(w),
+		commit: S.commit.bind(w),
+		exportSubject: S.exportSubject.bind(w),
+		eraseSubject: S.eraseSubject.bind(w)
+	}), k = Object.hasOwn(g, "maxChunks") ? a(g.maxChunks, 1, 65536) : void 0, A = Object.hasOwn(g, "maxAccountedBytes") ? a(g.maxAccountedBytes, 512) : void 0, j = /* @__PURE__ */ new WeakMap(), M = async (e, t) => {
+		let n = t();
+		if (!v.isEffect(n)) throw b();
+		return e(n);
+	}, N = (t) => v.flatMap(v.context(), (n) => v.uninterruptible(v.tryPromise({
+		try: () => t(d(n)),
+		catch: (t) => t instanceof e ? t : b()
+	}))), P = (e, t) => {
+		m(e);
+		let n = o(t), r = j.get(e);
+		if (r) {
+			if (JSON.stringify(r.request) !== JSON.stringify(n) || r.active) throw b();
+			return r;
+		}
+		let i = {
+			resource: e,
+			request: n,
+			held: [],
+			active: !1
+		};
+		return j.set(e, i), i;
+	}, F = async (e, t) => {
+		let n = [];
+		for (let r of [...t.held].reverse()) try {
+			if (typeof await M(e, () => r.lease.release()) != "boolean") throw b();
+			t.held.splice(t.held.indexOf(r), 1);
+		} catch (e) {
+			n.push(e);
+		}
+		if (n.length) throw b();
+	}, I = async (e, t) => {
+		for (let n of t.held) if (await M(e, () => n.lease.renew()) !== !0) throw b();
+	}, L = async (e, t, r) => {
+		await F(e, t);
+		let i = await M(e, () => E(t.resource)), a = n(i, ["tenantId", "acquire"]);
+		if (a.tenantId !== t.resource.scope.tenantId || typeof a.acquire != "function") throw b();
+		let o = a.acquire.bind(i);
+		for (let i of [...r].sort((e, t) => {
+			let n = JSON.stringify([
+				e.cx,
+				e.cy,
+				e.cz ?? null
+			]), r = JSON.stringify([
+				t.cx,
+				t.cy,
+				t.cz ?? null
+			]);
+			return n < r ? -1 : +(n > r);
+		})) {
+			let r = await M(e, () => o(i));
+			if (y.isNone(r)) throw b();
+			let a = y.getOrThrow(r), s = n(a, ["renew", "release"]);
+			if (typeof s.renew != "function" || typeof s.release != "function") throw b();
+			t.held.push({
+				scope: i,
+				lease: Object.freeze({
+					renew: s.renew.bind(a),
+					release: s.release.bind(a)
+				})
+			}), await I(e, t);
+		}
+	}, R = (e) => Object.freeze({
+		roomId: e.scope.roomId,
+		hostId: e.scope.hostId,
+		epoch: e.scope.epoch
+	});
+	return u({
+		authorize: (e, t, n) => (h(t), T(e, t, n)),
+		prepare: (t, n) => {
+			let r = P(h(t), n);
+			return N(async (n) => {
+				if (r.active) throw b();
+				r.active = !0;
+				try {
+					await t.quiesce();
+					let o = c(t.inventory), s = k === void 0 ? t.world.geometry.budgets.maxPreparedChunks : a(k, 1, t.world.geometry.budgets.maxPreparedChunks);
+					if (A !== void 0 && a(A, 512, t.world.geometry.budgets.maxPreparedBytes), o.entries.length > s) throw new e({
+						budget: "geometryReloadLeaseChunks",
+						limit: s
+					});
+					await L(n, r, o.entries.map((e) => i({
+						...o.scope,
+						...e.scope
+					})));
+					let l = (e) => N(async (t) => {
+						await I(t, r);
+						let n = await M(t, e);
+						return await I(t, r), n;
+					}), u = {
+						...D,
+						migrate: (e) => l(() => D.migrate(e))
+					}, d = {
+						...O,
+						observe: (e) => l(() => O.observe(e))
+					}, f = await M(n, () => _(t.inventory, t.world, {
+						...r.request,
+						owner: R(t)
+					}, {
+						migrations: u,
+						persistence: d,
+						quiesce: () => v.sync(() => {
+							if (c(t.inventory) !== o) throw b();
+						}),
+						...k === void 0 ? {} : { maxChunks: k },
+						...A === void 0 ? {} : { maxAccountedBytes: A }
+					}));
+					return await I(n, r), f;
+				} finally {
+					r.active = !1;
+				}
+			});
+		},
+		resume: (t, o, c) => {
+			let u = P(h(t), o);
+			return N(async (o) => {
+				if (u.active) throw b();
+				u.active = !0;
+				try {
+					await t.quiesce();
+					let d = l(t.inventory, c), m = R(t);
+					if (d.after.scope.version !== u.request.version || c.receipts.length !== d.before.entries.length) throw b();
+					let h = k === void 0 ? t.world.geometry.budgets.maxPreparedChunks : a(k, 1, t.world.geometry.budgets.maxPreparedChunks);
+					if (A !== void 0 && a(A, 512, t.world.geometry.budgets.maxPreparedBytes), d.before.entries.length > h) throw new e({
+						budget: "geometryReloadLeaseChunks",
+						limit: h
+					});
+					for (let e of d.before.entries) {
+						let t = s(d.before, {
+							cx: e.scope.cx,
+							cy: e.scope.cy,
+							...e.scope.cz === void 0 ? {} : { cz: e.scope.cz }
+						}), n = i({
+							...t.scope,
+							version: u.request.version
+						}), r = p({
+							from: t.scope,
+							to: n,
+							owner: m,
+							expectedRevision: t.revision,
+							requestId: u.request.requestId + "." + f(JSON.stringify([
+								t.scope.cx,
+								t.scope.cy,
+								t.scope.cz ?? null
+							]))
+						}), a = c.receipts.find((e) => JSON.stringify(e.from) === JSON.stringify(t.scope));
+						if (!a || a.inputSha256 !== f(JSON.stringify(r)) || a.requestKey !== f(JSON.stringify([t.scope.tenantId, r.requestId]))) throw b();
+					}
+					await L(o, u, d.before.entries.map((e) => i({
+						...d.before.scope,
+						...e.scope
+					})));
+					for (let e of [d.before, d.after]) for (let t of e.entries) {
+						await I(o, u);
+						let s = i({
+							...e.scope,
+							...t.scope
+						}), c = n(await M(o, () => O.observe(s)), [
+							"scope",
+							"revision",
+							"artifact"
+						]), l = Object.freeze({
+							scope: i(c.scope),
+							revision: a(c.revision),
+							artifact: r(c.artifact)
+						});
+						if (JSON.stringify(l.scope) !== JSON.stringify(s) || l.revision !== t.revision || l.artifact.blobSha256 !== t.blobSha256 || l.artifact.contentSha256 !== t.contentSha256) throw b();
+						await I(o, u);
+					}
+					l(t.inventory, c);
+				} finally {
+					u.active = !1;
+				}
+			});
+		},
+		release: (e, t) => {
+			m(e);
+			let n = o(t), r = j.get(e);
+			return r ? JSON.stringify(r.request) === JSON.stringify(n) ? N(async (t) => {
+				if (r.active) throw b();
+				r.active = !0;
+				try {
+					await F(t, r), j.delete(e);
+				} finally {
+					r.active = !1;
+				}
+			}) : v.fail(b()) : v.void;
+		}
+	});
+}, S = (e, t) => {
+	let r = n(t, [
+		"authorize",
+		"migrations",
+		"persistence",
+		"namespace",
+		"ttlMs",
+		"maxChunks",
+		"maxAccountedBytes"
+	], [
+		"authorize",
+		"migrations",
+		"persistence",
+		"namespace",
+		"ttlMs"
+	]), i = Object.getOwnPropertyDescriptor(e, "connectionRegistry"), o = Object.getOwnPropertyDescriptor(e, "hotStore");
+	if (!i?.enumerable || !("value" in i) || !i.value || !o?.enumerable || !("value" in o) || typeof o.value != "function" || typeof r.namespace != "string") throw b();
+	let s = Object.freeze({
+		connectionRegistry: i.value,
+		hotStore: o.value.bind(e)
+	}), c = r.namespace, l = a(r.ttlMs, 1);
+	return x({
+		authorize: r.authorize,
+		migrations: r.migrations,
+		persistence: r.persistence,
+		...Object.hasOwn(r, "maxChunks") ? { maxChunks: a(r.maxChunks, 1, 65536) } : {},
+		...Object.hasOwn(r, "maxAccountedBytes") ? { maxAccountedBytes: a(r.maxAccountedBytes, 512) } : {},
+		leases: (e) => v.tryPromise({
+			try: () => g(s, {
+				namespace: c,
+				tenantId: e.scope.tenantId,
+				ttlMs: l
+			}),
+			catch: () => b()
+		})
+	});
+};
+//#endregion
+export { S as bindRoomGeometryReloadSource, x as makeRoomGeometryReloadSource };

package/dist/geometryRenderCache.js

@@ -0,0 +1,165 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { createGeometryHeightfieldCodec as r } from "./geometryHeightfield.js";
+import { captureGeometryArtifact as i } from "./geometryArtifacts.js";
+import { captureGeometryDense as a, geometryPersistenceInteger as o } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedCoordinate as s } from "./geometryPrepared.js";
+import { geometryClientFieldsAtDistance as c } from "./geometryClientInterest.js";
+import { geometryChunkHasWorldExtent as l } from "./geometryWorldExtent.js";
+import { captureOwnedRoomGeometryChunkCache as u, captureRoomGeometryChunkCacheArtifact as d, captureRoomGeometryChunkCacheRoot as f } from "./geometryClientChunks.js";
+import { prepareGeometryRenderLod as p } from "./geometryRenderLod.js";
+import { captureWorldCatalog as m } from "./world.js";
+//#region src/geometryRenderCache.ts
+var h = () => new t({ detail: "Geometry render cache requires its fresh native content, current admission and complete bounded projection" }), g = (e = {}) => {
+	let t = n(e, [
+		"maxEntries",
+		"maxEncodedBytes",
+		"maxConcurrent",
+		"lod",
+		"strategies"
+	], []), i = {};
+	if (Object.hasOwn(t, "maxEntries") && (i.maxEntries = o(t.maxEntries, 1, 65536)), Object.hasOwn(t, "maxEncodedBytes") && (i.maxEncodedBytes = o(t.maxEncodedBytes, 512)), Object.hasOwn(t, "maxConcurrent") && (i.maxConcurrent = o(t.maxConcurrent, 1, 256)), Object.hasOwn(t, "lod")) {
+		let e = n(t.lod, [
+			"maxStride",
+			"maxSamples",
+			"codecLimits",
+			"strategies"
+		], []), a = {};
+		if (Object.hasOwn(e, "maxStride") && (a.maxStride = o(e.maxStride, 1, 1024)), Object.hasOwn(e, "maxSamples") && (a.maxSamples = o(e.maxSamples, 4, 1050625)), Object.hasOwn(e, "codecLimits") && (a.codecLimits = r(n(e.codecLimits, [
+			"maxSide",
+			"maxSamples",
+			"maxBytes"
+		], [])).limits), Object.hasOwn(e, "strategies")) {
+			let t = n(e.strategies, ["sampleStride"], []);
+			if (Object.hasOwn(t, "sampleStride") && typeof t.sampleStride != "function") throw h();
+			a.strategies = Object.freeze({ ...t });
+		}
+		i.lod = Object.freeze(a);
+	}
+	if (Object.hasOwn(t, "strategies")) {
+		let e = n(t.strategies, ["prepare"], []);
+		if (Object.hasOwn(e, "prepare") && typeof e.prepare != "function") throw h();
+		i.strategies = Object.freeze({ ...e });
+	}
+	return Object.freeze(i);
+}, _ = (t, r, _ = {}) => {
+	let v = u(t), y = m([r])[0], b = f(v), x = y.geometry, S = g(_);
+	if (!x || x.kind !== b.kind || y.name !== b.worldId) throw h();
+	let C = S.maxEntries === void 0 ? Math.min(64, x.streaming.client.maxCachedChunks) : o(S.maxEntries, 1, x.streaming.client.maxCachedChunks), w = S.maxEncodedBytes === void 0 ? x.budgets.maxPreparedBytes : o(S.maxEncodedBytes, 512, x.budgets.maxPreparedBytes), T = S.maxConcurrent ?? 4, E = S.strategies?.prepare ?? p, D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), k = !1, A = () => [...D.values()].reduce((e, t) => e + t.encodedBytes, 0), j = (e, t) => {
+		if (k) throw h();
+		let n = s(b, e), r = Object.freeze({
+			cx: n.cx,
+			cy: n.cy,
+			...n.cz === void 0 ? {} : { cz: n.cz }
+		}), i = o(t, 0, 2147483647), a = d(v, r), l = c(y, i);
+		return {
+			coordinate: r,
+			distance: i,
+			artifact: a,
+			fields: l,
+			key: JSON.stringify([
+				n.cx,
+				n.cy,
+				n.cz ?? null,
+				a.blobSha256,
+				l,
+				S.strategies?.prepare ? i : null
+			])
+		};
+	}, M = (t, r, s) => {
+		let c = n(t, [
+			"fields",
+			"sampleStride",
+			"sourceBlobSha256",
+			"sourceContentSha256",
+			"artifact",
+			"coarseArtifact"
+		], [
+			"fields",
+			"sampleStride",
+			"sourceBlobSha256",
+			"sourceContentSha256",
+			"artifact"
+		]), u = a(c.fields, 4, (e) => typeof e == "string" ? e : (() => {
+			throw h();
+		})()), d = i(c.artifact), f = Object.hasOwn(c, "coarseArtifact") ? i(c.coarseArtifact) : void 0, p = o(c.sampleStride, 1, 1024), m = !s.includes("heightsCoarse") || s.includes("heights");
+		if (!s.includes("heightsCoarse") && (f !== void 0 || p !== 1) || JSON.stringify(u) !== JSON.stringify(s) || c.sourceBlobSha256 !== r.blobSha256 || c.sourceContentSha256 !== r.contentSha256 || m && d.blobSha256 !== r.blobSha256 || s.includes("heights") && s.includes("heightsCoarse") && !f) throw h();
+		for (let e of [d, ...f ? [f] : []]) if (e.chunk.kind !== b.kind || e.chunk.version !== b.version || JSON.stringify(e.chunk.address) !== JSON.stringify(r.chunk.address) || !l(e, x.chunkSizeRaw)) throw h();
+		if (r.chunk.kind === "2d-heightfield" && s.includes("heightsCoarse")) {
+			let e = s.includes("heights") ? f : d;
+			if (e.chunk.kind !== "2d-heightfield") throw h();
+			let t = r.chunk, n = e.chunk;
+			if ((t.width - 1) % p != 0 || (t.height - 1) % p != 0 || n.width !== (t.width - 1) / p + 1 || n.height !== (t.height - 1) / p + 1 || n.sampleSpacingRaw !== t.sampleSpacingRaw * p || n.baseHeightRaw !== t.baseHeightRaw || n.heightQuantumRaw !== t.heightQuantumRaw) throw h();
+			for (let e = 0; e < n.height; e++) for (let r = 0; r < n.width; r++) if (n.heights[e * n.width + r] !== t.heights[e * p * t.width + r * p]) throw h();
+		}
+		let g = Object.freeze({
+			fields: u,
+			sampleStride: p,
+			sourceBlobSha256: r.blobSha256,
+			sourceContentSha256: r.contentSha256,
+			artifact: d,
+			...f ? { coarseArtifact: f } : {}
+		}), _ = [.../* @__PURE__ */ new Set([d, ...f ? [f] : []])].reduce((e, t) => e + t.bytes().byteLength, 0);
+		if (_ > w) throw new e({
+			budget: "geometryRenderCacheEncodedBytes",
+			limit: w
+		});
+		return Object.freeze({
+			value: g,
+			encodedBytes: _
+		});
+	};
+	return Object.freeze({
+		at: (e, t) => {
+			let n = j(e, t), r = D.get(n.key);
+			if (!r) throw h();
+			return D.delete(n.key), D.set(n.key, r), r.value;
+		},
+		prepare: (t, n) => {
+			try {
+				let r = j(t, n), i = D.get(r.key);
+				if (i) return D.delete(r.key), D.set(r.key, i), Promise.resolve(i.value);
+				let a = O.get(r.key);
+				if (a) return a;
+				if (O.size >= T) throw new e({
+					budget: "geometryRenderCacheJobs",
+					limit: T
+				});
+				let o = Promise.resolve().then(async () => {
+					if (k) throw h();
+					let e = E(y, r.artifact, r.distance, S.lod ?? {});
+					if (!(e instanceof Promise)) throw h();
+					let t = M(await e, r.artifact, r.fields);
+					if (k || d(v, r.coordinate).blobSha256 !== r.artifact.blobSha256) throw h();
+					for (; D.size >= C || A() + t.encodedBytes > w;) {
+						let e = D.keys().next().value;
+						if (e === void 0) throw h();
+						D.delete(e);
+					}
+					return D.set(r.key, t), t.value;
+				}).catch((t) => {
+					throw t instanceof e ? t : h();
+				});
+				return O.set(r.key, o), o.then(() => {
+					O.delete(r.key);
+				}, () => {
+					O.delete(r.key);
+				}), o;
+			} catch (t) {
+				return Promise.reject(t instanceof e ? t : h());
+			}
+		},
+		observation: () => Object.freeze({
+			entries: D.size,
+			encodedBytes: A(),
+			jobs: O.size,
+			closed: k,
+			withdrawn: v.observation().withdrawn
+		}),
+		close: async () => {
+			k = !0, D.clear(), await Promise.allSettled([...O.values()]);
+		}
+	});
+};
+//#endregion
+export { g as captureGeometryRenderLodCacheOptions, _ as makeGeometryRenderLodCache };

package/dist/geometryRenderLod.js

@@ -0,0 +1,102 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { createGeometryHeightfieldCodec as r } from "./geometryHeightfield.js";
+import { captureGeometryArtifact as i, createGeometryArtifact as a } from "./geometryArtifacts.js";
+import { geometryPersistenceInteger as o } from "./geometryPersistenceData.js";
+import { geometryClientFieldsAtDistance as s } from "./geometryClientInterest.js";
+import { geometryChunkHasWorldExtent as c } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as l } from "./world.js";
+//#region src/geometryRenderLod.ts
+var u = () => new t({ detail: "Native geometry LOD requires exact admitted content, World extent and bounded pure sample selection" }), d = (e, t) => {
+	let r = n(e, [
+		"kind",
+		"formatVersion",
+		"address",
+		"version",
+		"width",
+		"height",
+		"sampleSpacingRaw",
+		"baseHeightRaw",
+		"heightQuantumRaw",
+		"heights"
+	]), i = o(t, 1, 1024), a = o(r.width, 2, 1025), s = o(r.height, 2, 1025);
+	if (r.kind !== "2d-heightfield" || r.formatVersion !== 1) throw u();
+	for (let e = Math.min(i, a - 1, s - 1); e >= 1; e--) if ((a - 1) % e == 0 && (s - 1) % e == 0) return e;
+	throw u();
+}, f = async (t, s = {}) => {
+	let c = i(t), l = n(s, [
+		"maxStride",
+		"maxSamples",
+		"codecLimits",
+		"strategies"
+	], []);
+	if (c.chunk.kind !== "2d-heightfield") throw u();
+	let f = Object.hasOwn(l, "codecLimits") ? n(l.codecLimits, [
+		"maxSide",
+		"maxSamples",
+		"maxBytes"
+	], []) : {}, p = r(f), m = p.capture(c.chunk), h = Object.hasOwn(l, "maxStride") ? o(l.maxStride, 1, 1024) : 4, g = Object.hasOwn(l, "maxSamples") ? o(l.maxSamples, 4, p.limits.maxSamples) : p.limits.maxSamples, _ = Object.hasOwn(l, "strategies") ? n(l.strategies, ["sampleStride"], []) : {}, v = Object.hasOwn(_, "sampleStride") ? _.sampleStride : d;
+	if (typeof v != "function") throw u();
+	let y;
+	try {
+		y = v(m, h);
+	} catch {
+		throw u();
+	}
+	if (y instanceof Promise) throw y.catch(() => void 0), u();
+	let b = o(y, 1, h);
+	if ((m.width - 1) % b != 0 || (m.height - 1) % b != 0) throw u();
+	let x = (m.width - 1) / b + 1, S = (m.height - 1) / b + 1;
+	if (x * S > g) throw new e({
+		budget: "geometryRenderLodSamples",
+		limit: g
+	});
+	if (b === 1) return Object.freeze({
+		fields: Object.freeze(["heightsCoarse"]),
+		sampleStride: 1,
+		sourceBlobSha256: c.blobSha256,
+		sourceContentSha256: c.contentSha256,
+		artifact: c
+	});
+	let C = [];
+	for (let e = 0; e < m.height; e += b) for (let t = 0; t < m.width; t += b) C.push(m.heights[e * m.width + t]);
+	let w = p.capture({
+		...m,
+		width: x,
+		height: S,
+		sampleSpacingRaw: o(m.sampleSpacingRaw * b, 1, 2147483647),
+		heights: C
+	}), T = await a(w, p.limits);
+	return Object.freeze({
+		fields: Object.freeze(["heightsCoarse"]),
+		sampleStride: b,
+		sourceBlobSha256: c.blobSha256,
+		sourceContentSha256: c.contentSha256,
+		artifact: T
+	});
+}, p = async (e, t, n, r = {}) => {
+	let a = l([e])[0], o = i(t), d = a.geometry, p = s(a, n);
+	if (!d || o.chunk.address.worldId !== a.name || o.chunk.kind !== d.kind || !c(o, d.chunkSizeRaw)) throw u();
+	if (p.includes("heightsCoarse")) {
+		let e = await f(o, r);
+		if (!c(e.artifact, d.chunkSizeRaw)) throw u();
+		return p.includes("heights") ? Object.freeze({
+			...e,
+			fields: p,
+			artifact: o,
+			coarseArtifact: e.artifact
+		}) : Object.freeze({
+			...e,
+			fields: p
+		});
+	}
+	return Object.freeze({
+		fields: p,
+		sampleStride: 1,
+		sourceBlobSha256: o.blobSha256,
+		sourceContentSha256: o.contentSha256,
+		artifact: o
+	});
+};
+//#endregion
+export { d as defaultGeometryHeightfieldLodStride, f as prepareGeometryHeightfieldLod, p as prepareGeometryRenderLod };