@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryCms.js

@@ -0,0 +1,216 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { verifyGeometryArtifact as r } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as i, captureGeometryCodecProfiles as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryAssetManifest as c, captureGeometryAssetRoot as l } from "./geometryAssetData.js";
+import { geometryChunkHasWorldExtent as u } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as d } from "./world.js";
+import { captureRoomSnapshotEffectRunner as f } from "./snapshotBlobIndex.js";
+import { captureGeometryVersion as p } from "./geometryPersistenceCapture.js";
+import { Effect as m } from "effect";
+// src/geometryCms.ts
+function h() {
+	throw new t({ detail: "Published CMS geometry selection, immutable object custody or current authorization remains unconfirmed" });
+}
+var g = (e, t) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) return h();
+	let n = {};
+	for (let r of t) {
+		let t = Object.getOwnPropertyDescriptor(e, r);
+		if (!t?.enumerable || !("value" in t)) return h();
+		n[r] = t.value;
+	}
+	return n;
+}, _ = (c, l, _, v, y) => {
+	try {
+		let b = d([c])[0], x = b.geometry, S = n(v, [
+			"tenantId",
+			"version",
+			"contentType",
+			"scope",
+			"channel"
+		], [
+			"tenantId",
+			"version",
+			"contentType",
+			"scope"
+		]), C = n(S.scope, [
+			"site",
+			"environment",
+			"locale"
+		]), w = Object.freeze({
+			site: o(C.site),
+			environment: o(C.environment),
+			locale: o(C.locale)
+		}), T = o(S.tenantId), E = o(S.version, 96), D = o(S.contentType, 96), O = n(y, [
+			"maxChunks",
+			"maxArtifactBytes",
+			"maxManifestBytes",
+			"codecLimits",
+			"authorize"
+		], ["authorize"]), k = (e, t, n, r) => s(Object.hasOwn(O, e) ? O[e] : t, n, r), A = k("maxChunks", 256, 1, 4096), j = k("maxArtifactBytes", 52428800, 64, 268435456), M = k("maxManifestBytes", 262144, 256, 16777216), N = a(Object.hasOwn(O, "codecLimits") ? O.codecLimits : {}), P = g(l, ["contentType"]), F = g(_, ["load"]);
+		if (!x || x.static.kind !== "cms" || typeof O.authorize != "function" || typeof P.contentType != "function" || typeof F.load != "function") return h();
+		let I = Object.freeze({
+			tenantId: T,
+			version: E,
+			contentType: D,
+			scope: w,
+			worldId: b.name,
+			kind: x.kind,
+			geometryKey: x.static.key,
+			channel: Object.hasOwn(S, "channel") ? o(S.channel, 64) : x.static.channel
+		}), L = P.contentType.bind(l), R = F.load.bind(_), z = O.authorize;
+		return m.flatMap(m.context(), (a) => m.uninterruptible(m.tryPromise({
+			try: async () => {
+				let t = f(a), s = async () => {
+					let e = z(I);
+					if (!m.isEffect(e) || await t(e) !== void 0) return h();
+				}, c = async () => {
+					await s();
+					let t = await L(D).where("tenantId", "=", T).where("site", "=", w.site).where("environment", "=", w.environment).where("locale", "=", w.locale).where("geometryKey", "=", I.geometryKey).where("channel", "=", I.channel).where("geometryVersion", "=", E).where("worldId", "=", b.name).where("geometryKind", "=", x.kind).limit(2).all();
+					if (!Array.isArray(t) || t.length !== 1) return h();
+					let n = g(t[0], [
+						"id",
+						"revisionId",
+						"status",
+						"tenantId",
+						"site",
+						"environment",
+						"locale",
+						"geometryKey",
+						"channel",
+						"geometryVersion",
+						"worldId",
+						"geometryKind",
+						"geometryManifest"
+					]);
+					if (n.status !== "published" || n.tenantId !== T || n.site !== w.site || n.environment !== w.environment || n.locale !== w.locale || n.geometryKey !== I.geometryKey || n.channel !== I.channel || n.geometryVersion !== E || n.worldId !== b.name || n.geometryKind !== x.kind || typeof n.geometryManifest != "string") return h();
+					if (o(n.id), o(n.revisionId), new TextEncoder().encode(n.geometryManifest).length > M) throw new e({
+						budget: "geometryCmsManifestBytes",
+						limit: M
+					});
+					return Object.freeze(n);
+				}, l = await c(), d = n(JSON.parse(l.geometryManifest), [
+					"tenantId",
+					"kind",
+					"worldId",
+					"version",
+					"chunks",
+					"manifestSha256"
+				]), _ = p({
+					tenantId: d.tenantId,
+					kind: d.kind,
+					worldId: d.worldId,
+					version: d.version,
+					chunks: d.chunks
+				}, A, M);
+				if (_.tenantId !== T || _.worldId !== b.name || _.kind !== x.kind || _.version !== E || _.manifestSha256 !== d.manifestSha256) return h();
+				let v = [], y = 0;
+				for (let n of _.chunks) {
+					await s();
+					let a = R(n);
+					if (!m.isEffect(a)) return h();
+					let o = await t(a), c = await r(n.kind, o, n.blobSha256, N.get(n.kind) ?? {});
+					if (y += c.bytes().length, y > j) throw new e({
+						budget: "geometryCmsArtifactBytes",
+						limit: j
+					});
+					if (i(c, n), c.contentSha256 !== n.contentSha256 || !u(c, x.chunkSizeRaw)) return h();
+					v.push(c);
+				}
+				let S = await c();
+				return JSON.stringify(l) === JSON.stringify(S) ? (await s(), Object.freeze({
+					manifest: _,
+					artifacts: Object.freeze(v)
+				})) : h();
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "CMS geometry source remains unconfirmed; no implicit channel/version fallback" })
+		})));
+	} catch (n) {
+		return m.fail(n instanceof e ? n : new t({ detail: "CMS geometry source declaration could not be admitted" }));
+	}
+}, v = (r, i) => {
+	let a = n(i, [
+		"worlds",
+		"contentType",
+		"scope",
+		"authorize",
+		"maxAssets",
+		"maxManifestBytes"
+	], [
+		"worlds",
+		"contentType",
+		"scope",
+		"authorize"
+	]), u = d(a.worlds), p = n(a.scope, [
+		"site",
+		"environment",
+		"locale"
+	]), _ = Object.freeze({
+		site: o(p.site),
+		environment: o(p.environment),
+		locale: o(p.locale)
+	}), v = o(a.contentType, 96), y = Object.hasOwn(a, "maxAssets") ? s(a.maxAssets, 1, 4096) : 1024, b = Object.hasOwn(a, "maxManifestBytes") ? s(a.maxManifestBytes, 512, 16777216) : 524288, x = g(r, ["contentType"]);
+	if (typeof x.contentType != "function" || typeof a.authorize != "function" || !u.some((e) => e.geometry?.static.kind === "cms")) return h();
+	let S = x.contentType.bind(r), C = a.authorize.bind(i);
+	return Object.freeze({ observe: (n) => {
+		try {
+			let r = l(n), i = u.find((e) => e.name === r.worldId)?.geometry;
+			if (!i || i.static.kind !== "cms") return h();
+			let a = Object.freeze({
+				...r,
+				contentType: v,
+				scope: _,
+				geometryKey: i.static.key,
+				channel: i.static.channel,
+				geometryKind: i.kind
+			});
+			return m.flatMap(m.context(), (n) => m.uninterruptible(m.tryPromise({
+				try: async () => {
+					let t = f(n), s = async () => {
+						let e = C(a);
+						if (!m.isEffect(e) || await t(e) !== void 0) return h();
+					}, l = async () => {
+						await s();
+						let t = await S(v).where("tenantId", "=", r.tenantId).where("site", "=", _.site).where("environment", "=", _.environment).where("locale", "=", _.locale).where("geometryKey", "=", a.geometryKey).where("channel", "=", a.channel).where("geometryVersion", "=", r.version).where("worldId", "=", r.worldId).where("geometryKind", "=", i.kind).where("layerSetId", "=", r.layerSetId).limit(2).all();
+						if (!Array.isArray(t) || t.length !== 1) return h();
+						let n = g(t[0], [
+							"id",
+							"revisionId",
+							"status",
+							"tenantId",
+							"site",
+							"environment",
+							"locale",
+							"geometryKey",
+							"channel",
+							"geometryVersion",
+							"worldId",
+							"geometryKind",
+							"layerSetId",
+							"geometryAssetManifest"
+						]);
+						if (n.status !== "published" || n.tenantId !== r.tenantId || n.site !== _.site || n.environment !== _.environment || n.locale !== _.locale || n.geometryKey !== a.geometryKey || n.channel !== a.channel || n.geometryVersion !== r.version || n.worldId !== r.worldId || n.geometryKind !== i.kind || n.layerSetId !== r.layerSetId || typeof n.geometryAssetManifest != "string") return h();
+						if (o(n.id), o(n.revisionId), new TextEncoder().encode(n.geometryAssetManifest).length > b) throw new e({
+							budget: "geometryCmsAssetManifestBytes",
+							limit: b
+						});
+						return Object.freeze(n);
+					}, u = await l(), d = c(JSON.parse(u.geometryAssetManifest), y, b);
+					if (JSON.stringify({
+						tenantId: d.tenantId,
+						worldId: d.worldId,
+						layerSetId: d.layerSetId,
+						version: d.version
+					}) !== JSON.stringify(r) || JSON.stringify(d) !== u.geometryAssetManifest) return h();
+					let p = await l();
+					return JSON.stringify(u) === JSON.stringify(p) ? (await s(), d) : h();
+				},
+				catch: (n) => n instanceof e ? n : new t({ detail: "Published CMS asset catalogue remains unconfirmed; no draft/channel/scope fallback" })
+			})));
+		} catch (n) {
+			return m.fail(n instanceof e ? n : new t({ detail: "CMS asset catalogue scope could not be admitted" }));
+		}
+	} });
+};
+export { v as cmsGeometryAssetManifestSource, _ as loadCmsGeometryPublication };

package/dist/geometryCommitCoordinator.js

@@ -0,0 +1,240 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { captureSimulationBytes as n } from "./simulationBytes.js";
+import { geometryOwnData as r } from "./geometryTileCodec.js";
+import { captureGeometryOwner as i, captureGeometryPersistenceScope as a, captureGeometryPrivacyTarget as o, captureGeometryReceipt as s, captureGeometrySubject as c, geometryPersistenceId as l, geometryPersistenceInteger as u, geometryPersistenceRefusal as d } from "./geometryPersistenceData.js";
+import { decodeGeometryPatch as f } from "./geometryPatch.js";
+import { captureRoomSnapshotEffectRunner as p } from "./snapshotBlobIndex.js";
+import { geometryPersistenceDigest as m } from "./geometryPersistenceCapture.js";
+import { captureGeometryPlayerAdmission as h } from "./geometryPlayerAdmission.js";
+import { Effect as g, Option as _ } from "effect";
+import { HotError as v } from "@voltro/kv/hot/contract";
+// src/geometryCommitCoordinator.ts
+var y = () => new t({ detail: "Geometry coordinated operation or cleanup remains unconfirmed" }), b = (t, b, x) => {
+	let S = r(x, [
+		"tenantId",
+		"maxPending",
+		"maxPatchBytes",
+		"maxPendingBytes",
+		"maxSubjectFences"
+	], ["tenantId"]), C = l(S.tenantId), w = Object.hasOwn(S, "maxPending") ? u(S.maxPending, 1, 4096) : 64, T = Object.hasOwn(S, "maxPatchBytes") ? u(S.maxPatchBytes, 512, 16777216) : 262144, E = Object.hasOwn(S, "maxPendingBytes") ? u(S.maxPendingBytes, 512, 67108864) : 16777216, D = Object.hasOwn(S, "maxSubjectFences") ? u(S.maxSubjectFences, 1, 65536) : 4096, O = r(t, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	], ["commit", "eraseSubject"]), k = O.commit, A = O.eraseSubject, j = r(b, ["tenantId", "acquire"]), M = j.acquire;
+	if (typeof k != "function" || typeof A != "function" || typeof M != "function" || j.tenantId !== C) return d();
+	let N = k, P = A, F = M, I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Set(), R = !1, z = !1, B = !1, V = 0, H = () => [...I.values()].reduce((e, t) => e + t.input.patch.length, 0), U = () => Object.freeze({
+		pending: I.size,
+		pendingBytes: H(),
+		active: [...I.values()].filter((e) => e.active).length + V,
+		retainedReceipts: [...I.values()].filter((e) => e.receipt !== null).length,
+		subjectFences: L.size,
+		closing: R,
+		closed: z
+	}), W = async (e, t) => {
+		let n = t();
+		if (!g.isEffect(n)) throw y();
+		return e(n);
+	}, G = (t) => g.flatMap(g.context(), (n) => g.uninterruptible(g.tryPromise({
+		try: () => t(p(n)),
+		catch: (t) => t instanceof e ? t : t instanceof v ? new v({
+			operation: t.operation,
+			key: "geometryChunkLease",
+			reason: t.reason
+		}) : y()
+	}))), K = async (e, t) => {
+		if (!t.lease) return;
+		let n = t.lease;
+		if (typeof await W(e, () => n.release()) != "boolean") throw y();
+		t.lease = null;
+	}, q = (e) => {
+		let t = r(e, ["renew", "release"]);
+		return typeof t.renew != "function" || typeof t.release != "function" ? d() : Object.freeze({
+			renew: t.renew,
+			release: t.release
+		});
+	}, J = async (e, t, n) => {
+		n.active = !0, n.completion = new Promise((e) => {
+			n.finish = e;
+		});
+		let r = !1;
+		try {
+			r = !0, await K(e, n), r = !1;
+			let i = await W(e, () => F(n.input.scope));
+			if (_.isNone(i) || (n.lease = q(_.getOrThrow(i)), await W(e, () => n.lease.renew()) !== !0)) throw y();
+			n.attempted = !0;
+			let a = s(await W(e, () => N({
+				...n.input,
+				patch: new Uint8Array(n.input.patch)
+			}))), o = n.metadata;
+			if (JSON.stringify(a.scope) !== JSON.stringify(n.input.scope) || a.requestId !== n.input.requestId || a.baseRevision !== o.baseRevision || a.revision !== o.revision || a.changed !== o.changed || a.blobSha256 !== o.blobSha256 || a.contentSha256 !== o.contentSha256 || (n.receipt = a, await W(e, () => n.lease.renew()) !== !0)) throw y();
+			return r = !0, await K(e, n), r = !1, I.delete(t), a;
+		} catch (i) {
+			if (!r) try {
+				await K(e, n);
+			} catch {
+				throw y();
+			}
+			throw !n.attempted && n.lease === null && I.delete(t), i;
+		} finally {
+			n.active = !1, n.finish?.(), n.finish = null, n.completion = null;
+		}
+	}, Y = (e) => m(JSON.stringify([
+		C,
+		e.kind,
+		e.id
+	])), X = (e, t) => e.input.scope.tenantId === t.tenantId && e.input.subject.kind === t.subject.kind && e.input.subject.id === t.subject.id, Z = (e) => {
+		let t = o(e);
+		return t.tenantId === C ? t : d();
+	}, Q = async (t, n) => {
+		if (z) return;
+		if (B) throw y();
+		let r = Y(n.subject);
+		if (!L.has(r)) {
+			if (L.size >= D) throw new e({
+				budget: "geometryCoordinatedSubjectFences",
+				limit: D
+			});
+			L.add(r);
+		}
+		for (;;) {
+			let e = [...I.values()].filter((e) => X(e, n) && e.active);
+			if (!e.length) break;
+			await Promise.all(e.map((e) => e.completion ?? Promise.reject(y())));
+		}
+		for (let e of I.values()) X(e, n) && await K(t, e);
+	};
+	return Object.freeze({
+		observation: U,
+		commit: (t) => {
+			let o, s, u, d;
+			try {
+				let e = r(t, [
+					"scope",
+					"owner",
+					"subject",
+					"requestId",
+					"patch",
+					"actualSession"
+				], [
+					"scope",
+					"owner",
+					"subject",
+					"requestId",
+					"patch"
+				]), p = a(e.scope), _ = i(e.owner), v = c(e.subject), b = l(e.requestId), x = n(e.patch, T, "geometryCoordinatedPatchBytes"), S = f(x, {
+					maxBytes: T,
+					maxMetadataBytes: Math.min(4096, T - 16)
+				});
+				if (p.tenantId !== C || S.metadata.kind !== p.kind || S.metadata.version !== p.version || S.metadata.worldId !== p.worldId || S.metadata.layerSetId !== p.layerSetId || S.metadata.cx !== p.cx || S.metadata.cy !== p.cy || S.metadata.cz !== p.cz) return g.fail(y());
+				let w = Object.hasOwn(e, "actualSession") ? h(e.actualSession, p, _, v) : null;
+				o = Object.freeze({
+					scope: p,
+					owner: _,
+					subject: v,
+					requestId: b,
+					patch: x,
+					...w ? { actualSession: w.actualSession } : {}
+				}), s = S.metadata, d = m(JSON.stringify([C, b])), u = m(JSON.stringify([
+					p,
+					_,
+					v,
+					b,
+					m(x)
+				]));
+			} catch {
+				return g.fail(y());
+			}
+			return G(async (t) => {
+				if (z || B || L.has(Y(o.subject))) throw y();
+				let n = I.get(d);
+				if (n) {
+					if (n.active || n.fingerprint !== u) throw y();
+					n.input = o;
+				} else {
+					if (R) throw y();
+					if (I.size >= w) throw new e({
+						budget: "geometryCoordinatedPending",
+						limit: w
+					});
+					if (H() + o.patch.length > E) throw new e({
+						budget: "geometryCoordinatedPendingBytes",
+						limit: E
+					});
+					n = {
+						input: o,
+						metadata: s,
+						fingerprint: u,
+						active: !1,
+						completion: null,
+						finish: null,
+						attempted: !1,
+						receipt: null,
+						lease: null
+					}, I.set(d, n);
+				}
+				return J(t, d, n);
+			});
+		},
+		withdrawSubject: (t) => {
+			try {
+				let n = Z(t);
+				return G(async (t) => {
+					if (V >= w * 2) throw new e({
+						budget: "geometryCoordinatedPrivacyOperations",
+						limit: w * 2
+					});
+					V++;
+					try {
+						await Q(t, n);
+					} finally {
+						V--;
+					}
+				});
+			} catch {
+				return g.fail(y());
+			}
+		},
+		eraseSubject: (t) => {
+			try {
+				let n = Z(t);
+				return G(async (t) => {
+					if (z || B) throw y();
+					if (V >= w * 2) throw new e({
+						budget: "geometryCoordinatedPrivacyOperations",
+						limit: w * 2
+					});
+					V++;
+					try {
+						if (await Q(t, n), await W(t, () => P(n)) !== void 0) throw y();
+						for (let [e, t] of I) if (X(t, n)) {
+							if (t.active || t.lease !== null) throw y();
+							I.delete(e);
+						}
+					} finally {
+						V--;
+					}
+				});
+			} catch {
+				return g.fail(y());
+			}
+		},
+		close: () => G(async (e) => {
+			if (!z) {
+				if (B || V > 0 || [...I.values()].some((e) => e.active)) throw y();
+				R = !0, B = !0;
+				try {
+					for (let [t, n] of I) {
+						if (await K(e, n), n.attempted && n.receipt === null) throw y();
+						I.delete(t);
+					}
+					L.clear(), z = !0;
+				} finally {
+					B = !1;
+				}
+			}
+		})
+	});
+};
+export { b as makeGeometryCommitCoordinator };

package/dist/geometryCompactionFixture.js

@@ -0,0 +1,83 @@
+import { ProtocolError as e } from "./errors.js";
+import { createGeometryTileCodec as t } from "./geometryTileCodec.js";
+import { createGeometryArtifact as n } from "./geometryArtifacts.js";
+import { createGeometryPatch as r, defaultGeometryPatchLimits as i } from "./geometryPatch.js";
+import { defaultGeometryCompaction as a, prepareGeometryCompaction as o } from "./geometryCompactionStrategies.js";
+import { cmsGeometry as s } from "./worldGeometry.js";
+import { defineWorld as c, rect as l } from "./world.js";
+import { Effect as u } from "effect";
+// src/geometryCompactionFixture.ts
+var d = (r) => u.promise(async () => {
+	let a = c({
+		name: "compaction-fixture",
+		map: { bounds: l(0, 0, 2, 2) },
+		zones: [{
+			id: "zone",
+			room: "cell",
+			bounds: l(0, 0, 2, 2),
+			neighbors: []
+		}],
+		persistence: {
+			entities: "world",
+			snapshotEveryMs: 3e4,
+			journal: !0
+		},
+		handoff: {
+			marginUnits: 1,
+			ghostUnits: 2
+		},
+		spawn: () => ({
+			zone: "zone",
+			at: [1, 1]
+		}),
+		geometry: {
+			kind: "2d-tiles",
+			static: s("world:compaction"),
+			...r === void 0 ? {} : { strategies: { compaction: r } }
+		}
+	}), u = t(), d = u.create({
+		address: {
+			worldId: a.name,
+			layerSetId: "layer",
+			cx: 0,
+			cy: 0
+		},
+		version: "v1",
+		width: 1,
+		height: 1,
+		tileSizeRaw: 65536,
+		cells: [{
+			key: "air",
+			solid: !1
+		}]
+	}), f = u.capture({
+		...d,
+		palette: [{
+			key: "air",
+			solid: !0
+		}]
+	}), p = await n(d), m = await n(f);
+	try {
+		return await o({
+			static: p,
+			current: m,
+			limits: i,
+			codecLimits: {}
+		}, { compaction: a.geometry.strategies.compaction }), "preserved";
+	} catch (t) {
+		if (t instanceof e) return "refused";
+		throw t;
+	}
+}), f = {
+	kind: "slot",
+	defaultImplementation: a,
+	defaultProbe: {
+		run: () => d(),
+		expected: "preserved"
+	},
+	overrideProbe: {
+		run: () => d((e) => r(e.static, e.static, 0)),
+		expected: "refused"
+	}
+};
+export { f as geometryCompactionSlotFixture };

package/dist/geometryCompactionStrategies.js

@@ -0,0 +1,37 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { captureGeometryArtifact as n } from "./geometryArtifacts.js";
+import { captureGeometryCodecProfiles as r } from "./geometryPersistenceData.js";
+import { applyGeometryPatch as i, captureGeometryPatch as a, captureGeometryPatchLimits as o, createGeometryPatch as s, decodeGeometryPatch as c } from "./geometryPatch.js";
+// src/geometryCompactionStrategies.ts
+var l = (e) => s(e.static, e.current, 0, {
+	limits: e.limits,
+	codecLimits: e.codecLimits
+});
+function u() {
+	throw new e({ detail: "Native geometry compaction must preserve the complete confirmed current artifact from static revision zero" });
+}
+var d = (e = {}) => {
+	let n = t(e, ["compaction"], []), r = Object.hasOwn(n, "compaction") ? n.compaction : l;
+	return typeof r == "function" ? Object.freeze({ compaction: r }) : u();
+}, f = async (e, s = {}) => {
+	let f = t(e, [
+		"static",
+		"current",
+		"limits",
+		"codecLimits"
+	]), p = n(f.static), m = n(f.current), h = o(f.limits), g = r({ [p.chunk.kind]: f.codecLimits }).get(p.chunk.kind), _ = d(s), v = Object.freeze({
+		static: p,
+		current: m,
+		limits: h,
+		codecLimits: g
+	});
+	if (_.compaction === l) return l(v);
+	let y = _.compaction(v);
+	if (y instanceof Promise) return y.catch(() => void 0), u();
+	let b = a(y), x = c(b.bytes(), h);
+	if (x.metadata.baseRevision !== 0) return u();
+	let S = await i(p, x, 0, g), C = m.bytes(), w = S.artifact.bytes();
+	return S.artifact.blobSha256 !== m.blobSha256 || S.artifact.contentSha256 !== m.contentSha256 || w.length !== C.length || w.some((e, t) => e !== C[t]) ? u() : x;
+};
+export { d as captureGeometryCompactionStrategies, l as defaultGeometryCompaction, f as prepareGeometryCompaction };

package/dist/geometryConnectionClient.js

@@ -0,0 +1,22 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureRoomConnectionGeometrySession as t } from "./connection.js";
+import { makeRoomGeometryChunkCache as n } from "./geometryClientChunks.js";
+import { makeRoomGeometrySnapshotSource as r } from "./geometrySnapshotClient.js";
+// src/geometryConnectionClient.ts
+var i = (e, r, i, a, o = {}) => n(t(e), r, i, a, o), a = async (t, n, r, a, o, s, c = {}) => {
+	let l = () => new e({ detail: "World native geometry prefetch remains incomplete" });
+	if (!(s instanceof AbortSignal) || s.aborted) throw l();
+	let u = i(t, n, r, a, c), d, f = () => (d ||= Promise.resolve().then(() => u.close()).then(() => void 0, () => {}), d), p = () => {
+		f();
+	};
+	s.addEventListener("abort", p, { once: !0 });
+	try {
+		if (s.aborted || (await u.request(o), s.aborted || d)) throw l();
+		return u;
+	} catch {
+		throw await f(), l();
+	} finally {
+		s.removeEventListener("abort", p);
+	}
+}, o = (e, n, i) => r(t(e), n, i);
+export { i as makeRoomConnectionGeometryCache, o as makeRoomConnectionGeometrySnapshotSource, a as prefetchRoomConnectionGeometryCache };