@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryJournalPatch.js

@@ -0,0 +1,46 @@
+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 { captureGeometryReceipt as i } from "./geometryPersistenceData.js";
+import { decodeGeometryPatch as a } from "./geometryPatch.js";
+import { assertGeometryJournalPatchReceipt as o } from "./geometryJournalArchiveData.js";
+import { Effect as s } from "effect";
+// src/geometryJournalPatch.ts
+var c = (c = {}) => {
+	let l = r(c, ["archive", "maxPatchBytes"], []), u = Object.hasOwn(l, "maxPatchBytes") ? l.maxPatchBytes : 262144;
+	if (typeof u != "number" || !Number.isSafeInteger(u) || u < 512 || u > 16777216) throw new t({ detail: "Geometry journal patch budget refused" });
+	let d = Object.hasOwn(l, "archive") ? r(l.archive, [
+		"archive",
+		"load",
+		"exportSubject",
+		"eraseSubject"
+	]) : void 0;
+	if (d && Object.values(d).some((e) => typeof e != "function")) throw new t({ detail: "Geometry journal reader requires the actual complete archive index" });
+	let f = d ? d.load.bind(l.archive) : null, p = {
+		maxBytes: u,
+		maxMetadataBytes: Math.min(4096, u - 16)
+	};
+	return (r) => {
+		let c, l;
+		try {
+			c = i(r.receipt), l = n(r.patch, u, "geometryJournalPatchBytes");
+		} catch (n) {
+			return s.fail(n instanceof e ? n : new t({ detail: "Geometry journal patch could not be captured" }));
+		}
+		let d = (e) => {
+			let t = n(e, u, "geometryJournalPatchBytes");
+			return o(c, a(t, p).metadata), t;
+		};
+		return l.length ? s.try({
+			try: () => d(l),
+			catch: (n) => n instanceof e ? n : new t({ detail: "Inline geometry journal patch refused" })
+		}) : f ? s.uninterruptible(s.suspend(() => {
+			let n = f(c.scope, c.requestId);
+			return s.isEffect(n) ? n.pipe(s.flatMap((n) => s.try({
+				try: () => d(n),
+				catch: (n) => n instanceof e ? n : new t({ detail: "Archived geometry journal patch refused" })
+			}))) : s.fail(new t({ detail: "Archive patch reader requires its actual Effect" }));
+		})).pipe(s.catchCause(() => s.fail(new t({ detail: "Indexed native geometry journal bytes remain unavailable" })))) : s.fail(new t({ detail: "Indexed geometry journal bytes require their explicit archive source" }));
+	};
+};
+export { c as makeGeometryJournalPatchReader };

package/dist/geometryJournalRetention.js

@@ -0,0 +1,111 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryPersistenceScope as r, captureGeometryReceipt as i, geometryPersistenceId as a, geometryPersistenceInteger as o } from "./geometryPersistenceData.js";
+import { captureRoomSnapshotEffectRunner as s } from "./snapshotBlobIndex.js";
+import { geometryPersistenceDigest as c, geometryPersistenceScopeKey as l } from "./geometryPersistenceCapture.js";
+import { GEO_JOURNAL_TABLE as u } from "./geometryPersistence.js";
+import { and as d, eq as f, gt as p, lt as m, neq as h } from "@voltro/database";
+import { Context as g, Effect as _, Layer as v } from "effect";
+// src/geometryJournalRetention.ts
+var y = Object.freeze({ eligible: (e) => e.createdAtMs < e.cutoffMs }), b = class extends g.Service()("@voltro/GeometryJournalRetentionPort") {}, x = () => new t({ detail: "Geometry journal retention page remains unconfirmed" }), S = (e) => v.succeed(b, e), C = (t, g) => {
+	let v = n(g, [
+		"compaction",
+		"epochNow",
+		"authorize",
+		"keepInlineMs",
+		"pageSize",
+		"maxMetadataBytes",
+		"strategies"
+	], [
+		"compaction",
+		"epochNow",
+		"authorize"
+	]), b = n(v.compaction, ["compact"]), S = v.epochNow, C = v.authorize, w = Object.hasOwn(v, "keepInlineMs") ? o(v.keepInlineMs, 0, 31536e7) : 2592e6, T = Object.hasOwn(v, "pageSize") ? o(v.pageSize, 1, 256) : 32, E = Object.hasOwn(v, "maxMetadataBytes") ? o(v.maxMetadataBytes, 512, 16777216) : 262144, D = n(Object.hasOwn(v, "strategies") ? v.strategies : {}, ["eligible"], []), O = Object.hasOwn(D, "eligible") ? D.eligible : y.eligible;
+	if (typeof b.compact != "function" || typeof S != "function" || typeof C != "function" || typeof O != "function") throw x();
+	let k = b.compact.bind(v.compaction), A = S, j = C, M = O;
+	return Object.freeze({ run: (g) => {
+		let v, y;
+		try {
+			let e = n(g, ["scope", "after"], ["scope"]);
+			v = r(e.scope), y = Object.hasOwn(e, "after") && e.after !== null ? a(e.after) : null;
+		} catch {
+			return _.fail(x());
+		}
+		return _.flatMap(_.context(), (n) => _.uninterruptible(_.tryPromise({
+			try: async () => {
+				let r = s(n), g = async (e) => {
+					if (!_.isEffect(e)) throw x();
+					return r(e);
+				}, b = Math.max(0, o(A(), 0, 864e13) - w);
+				if (await g(j(v, b)) !== void 0) throw x();
+				let S = await t.query({
+					table: u,
+					predicate: d(f("tenantId", v.tenantId), f("scopeKey", l(v)), m("createdAt", new Date(b)), h("patch", /* @__PURE__ */ new Uint8Array()), ...y === null ? [] : [p("id", y)]),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: T + 1,
+					skip: void 0,
+					projection: [
+						"id",
+						"tenantId",
+						"scopeKey",
+						"requestKey",
+						"receipt",
+						"createdAt"
+					]
+				});
+				if (S.length > T + 1) throw x();
+				for (let e = 0; e < S.length; e++) {
+					let t = S[e], n = i(t.receipt), r = a(t.id);
+					if (t.tenantId !== v.tenantId || t.scopeKey !== l(v) || JSON.stringify(n.scope) !== JSON.stringify(v) || t.requestKey !== c(JSON.stringify([v.tenantId, n.requestId])) || y !== null && r <= y || e > 0 && r <= a(S[e - 1].id)) throw x();
+				}
+				let C = 0, D = S.slice(0, T).map((t, n) => {
+					let r = i(t.receipt), o = a(t.id), s = t.createdAt instanceof Date ? t.createdAt.getTime() : typeof t.createdAt == "string" ? Date.parse(t.createdAt) : NaN;
+					if (!Number.isSafeInteger(s) || s < 0 || s >= b || t.tenantId !== v.tenantId || t.scopeKey !== l(v) || JSON.stringify(r.scope) !== JSON.stringify(v) || t.requestKey !== c(JSON.stringify([v.tenantId, r.requestId])) || y !== null && o <= y || n > 0 && o <= a(S[n - 1].id)) throw x();
+					if (C += new TextEncoder().encode(JSON.stringify({
+						rowId: o,
+						receipt: r,
+						createdAtMs: s
+					})).length, C > E) throw new e({
+						budget: "geometryJournalRetentionMetadataBytes",
+						limit: E
+					});
+					let u = M(Object.freeze({
+						createdAtMs: s,
+						cutoffMs: b
+					}));
+					if (typeof u != "boolean") throw x();
+					return {
+						id: o,
+						receipt: r,
+						eligible: u
+					};
+				}), O = 0, N = 0, P = 0;
+				for (let e of D) {
+					if (!e.eligible) {
+						P++;
+						continue;
+					}
+					if (await g(j(v, b)) !== void 0) throw x();
+					let t = await g(k(v, e.receipt.requestId));
+					if (typeof t != "boolean") throw x();
+					t ? O++ : N++;
+				}
+				if (await g(j(v, b)) !== void 0) throw x();
+				return Object.freeze({
+					scope: v,
+					cutoffMs: b,
+					selected: D.length,
+					compacted: O,
+					alreadyArchived: N,
+					skipped: P,
+					nextAfter: S.length > T ? D.at(-1)?.id ?? null : null
+				});
+			},
+			catch: (t) => t instanceof e ? t : x()
+		})));
+	} });
+};
+export { b as GeometryJournalRetentionPort, C as dataStoreGeometryJournalRetention, y as defaultGeometryJournalRetentionStrategies, S as geometryJournalRetentionLayer };

package/dist/geometryJournalRetentionSchemas.js

@@ -0,0 +1,35 @@
+import { Schema as e } from "effect";
+// src/geometryJournalRetentionSchemas.ts
+var t = e.Struct({
+	runKey: e.NonEmptyString.pipe(e.check(e.isMaxLength(191))),
+	maxPages: e.Int.pipe(e.check(e.isBetween({
+		minimum: 1,
+		maximum: 4096
+	})))
+}), n = e.Struct({
+	scopes: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 4096
+	}))),
+	pages: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 4096
+	}))),
+	selected: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 1048576
+	}))),
+	compacted: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 1048576
+	}))),
+	alreadyArchived: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 1048576
+	}))),
+	skipped: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 1048576
+	})))
+});
+export { t as GeometryJournalRetentionWorkflowPayload, n as GeometryJournalRetentionWorkflowResult };

package/dist/geometryJournalRetentionSweep.js

@@ -0,0 +1,111 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryPersistenceScope as r, geometryPersistenceId as i, geometryPersistenceInteger as a } from "./geometryPersistenceData.js";
+import { captureWorldCatalog as o } from "./world.js";
+import { captureRoomSnapshotEffectRunner as s } from "./snapshotBlobIndex.js";
+import { geometryPersistenceScopeKey as c } from "./geometryPersistenceCapture.js";
+import { GEO_CHUNK_DELTAS_TABLE as l } from "./geometryPersistence.js";
+import { captureGeometryJournalRetentionPayload as u, captureGeometryJournalRetentionResult as d } from "./geometryJournalRetentionWorkflowData.js";
+import { Context as f, Effect as p, Layer as m } from "effect";
+// src/geometryJournalRetentionSweep.ts
+var h = class extends f.Service()("@voltro/GeometryJournalRetentionSweepPort") {}, g = () => new t({ detail: "Geometry journal retention sweep remains unconfirmed" }), _ = (e) => m.succeed(h, e), v = (t, f) => {
+	let m = n(f, [
+		"worlds",
+		"retention",
+		"authorize",
+		"maxScopes",
+		"maxMetadataBytes"
+	], [
+		"worlds",
+		"retention",
+		"authorize"
+	]), h = o(m.worlds), _ = n(m.retention, ["run"]), v = Object.hasOwn(m, "maxScopes") ? a(m.maxScopes, 1, 4096) : 256, y = Object.hasOwn(m, "maxMetadataBytes") ? a(m.maxMetadataBytes, 512, 16777216) : 262144;
+	if (typeof _.run != "function" || typeof m.authorize != "function" || !h.some((e) => e.geometry)) throw g();
+	let b = _.run.bind(m.retention), x = m.authorize;
+	return Object.freeze({ run: (o) => {
+		let f;
+		try {
+			f = u(o);
+		} catch {
+			return p.fail(g());
+		}
+		return p.flatMap(p.context(), (o) => p.uninterruptible(p.tryPromise({
+			try: async () => {
+				let u = s(o), m = async (e) => {
+					if (!p.isEffect(e)) throw g();
+					return u(e);
+				}, _ = async () => {
+					if (await m(x(f)) !== void 0) throw g();
+				};
+				await _();
+				let S = await t.query({
+					table: l,
+					predicate: void 0,
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: v + 1,
+					skip: void 0,
+					projection: [
+						"id",
+						"tenantId",
+						"scopeKey",
+						"scope"
+					]
+				});
+				if (S.length > v) throw new e({
+					budget: "geometryJournalRetentionScopes",
+					limit: v
+				});
+				let C = 0, w = "", T = /* @__PURE__ */ new Set(), E = S.map((t) => {
+					let n = r(t.scope), a = i(t.id), o = c(n), s = h.find((e) => e.name === n.worldId);
+					if (a <= w || t.tenantId !== n.tenantId || t.scopeKey !== o || T.has(o) || !s?.geometry) throw g();
+					if (w = a, T.add(o), C += new TextEncoder().encode(JSON.stringify({
+						rowId: a,
+						key: o,
+						scope: n
+					})).length, C > y) throw new e({
+						budget: "geometryJournalRetentionScopeBytes",
+						limit: y
+					});
+					return n;
+				}), D = 0, O = 0, k = 0, A = 0, j = 0;
+				for (let t of E) {
+					let o = null;
+					do {
+						if (D >= f.maxPages) throw new e({
+							budget: "geometryJournalRetentionWorkflowPages",
+							limit: f.maxPages
+						});
+						await _();
+						let s = await m(b(Object.freeze({
+							scope: t,
+							...o === null ? {} : { after: o }
+						}))), c = n(s, [
+							"scope",
+							"cutoffMs",
+							"selected",
+							"compacted",
+							"alreadyArchived",
+							"skipped",
+							"nextAfter"
+						]), l = r(c.scope), u = a(c.selected, 0, 256), d = a(c.compacted, 0, 256), p = a(c.alreadyArchived, 0, 256), h = a(c.skipped, 0, 256), v = c.nextAfter === null ? null : i(c.nextAfter);
+						if (a(c.cutoffMs, 0, 864e13), JSON.stringify(l) !== JSON.stringify(t) || d + p + h !== u || v !== null && (u === 0 || o !== null && v <= o)) throw g();
+						D++, O += u, k += d, A += p, j += h, o = v;
+					} while (o !== null);
+				}
+				return await _(), d({
+					scopes: E.length,
+					pages: D,
+					selected: O,
+					compacted: k,
+					alreadyArchived: A,
+					skipped: j
+				});
+			},
+			catch: (t) => t instanceof e ? t : g()
+		})));
+	} });
+};
+export { h as GeometryJournalRetentionSweepPort, v as dataStoreGeometryJournalRetentionSweep, _ as geometryJournalRetentionSweepLayer };

package/dist/geometryJournalRetentionWorkflow.js

@@ -0,0 +1,27 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { GeometryJournalRetentionWorkflowResult as n } from "./geometryJournalRetentionSchemas.js";
+import { captureGeometryJournalRetentionPayload as r, captureGeometryJournalRetentionResult as i } from "./geometryJournalRetentionWorkflowData.js";
+import { GeometryJournalRetentionSweepPort as a } from "./geometryJournalRetentionSweep.js";
+import { Effect as o, Schema as s } from "effect";
+import { step as c } from "@voltro/workflow";
+// src/geometryJournalRetentionWorkflow.ts
+var l = (l) => o.gen(function* () {
+	let u = yield* o.try({
+		try: () => r(l),
+		catch: () => new t({ detail: "Geometry retention workflow payload refused" })
+	}), d = yield* a;
+	return yield* c({
+		name: "compact-geometry-journal-bodies",
+		input: u,
+		success: n,
+		error: s.Union([t, e]),
+		execute: o.uninterruptible(o.suspend(() => {
+			let e = d.run(u);
+			return o.isEffect(e) ? e : o.fail(new t({ detail: "Geometry retention needs its actual sweep Effect" }));
+		})).pipe(o.flatMap((e) => o.try({
+			try: () => i(e),
+			catch: () => new t({ detail: "Geometry retention workflow result refused" })
+		})))
+	});
+});
+export { l as geometryJournalRetentionWorkflowExecutor };

package/dist/geometryJournalRetentionWorkflowData.js

@@ -0,0 +1,30 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { geometryPersistenceId as n, geometryPersistenceInteger as r } from "./geometryPersistenceData.js";
+// src/geometryJournalRetentionWorkflowData.ts
+var i = (e) => {
+	let i = t(e, ["runKey", "maxPages"]);
+	return Object.freeze({
+		runKey: n(i.runKey),
+		maxPages: r(i.maxPages, 1, 4096)
+	});
+}, a = (n) => {
+	let i = t(n, [
+		"scopes",
+		"pages",
+		"selected",
+		"compacted",
+		"alreadyArchived",
+		"skipped"
+	]), a = r(i.scopes, 0, 4096), o = r(i.pages, 0, 4096), s = r(i.selected, 0, 1048576), c = r(i.compacted, 0, 1048576), l = r(i.alreadyArchived, 0, 1048576), u = r(i.skipped, 0, 1048576);
+	if (c + l + u !== s || o < a || o === 0 && s !== 0) throw new e({ detail: "Geometry retention result cannot confirm its counts" });
+	return Object.freeze({
+		scopes: a,
+		pages: o,
+		selected: s,
+		compacted: c,
+		alreadyArchived: l,
+		skipped: u
+	});
+};
+export { i as captureGeometryJournalRetentionPayload, a as captureGeometryJournalRetentionResult };

package/dist/geometryJournalStorage.js

@@ -0,0 +1,147 @@
+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 { geometrySha256 as i } from "./geometryDigest.js";
+import { captureGeometryReceipt as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { decodeGeometryPatch as c } from "./geometryPatch.js";
+import { assertGeometryJournalPatchReceipt as l, captureGeometryJournalArchiveReference as u } from "./geometryJournalArchiveData.js";
+import { captureRoomSnapshotEffectRunner as d } from "./snapshotBlobIndex.js";
+import { geometryPersistenceDigest as f, geometryPersistenceScopeKey as p } from "./geometryPersistenceCapture.js";
+import { Context as m, Effect as h, Layer as g, Stream as _ } from "effect";
+// src/geometryJournalStorage.ts
+var v = class extends m.Service()("@voltro/GeometryJournalArchivePort") {}, y = (e) => g.succeed(v, e), b = () => new t({ detail: "Geometry journal Storage archive remains unconfirmed" }), x = (e, t) => {
+	if (!e || typeof e != "object") throw b();
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	if (!n?.enumerable || !("value" in n) || typeof n.value != "function") throw b();
+	return n.value.bind(e);
+}, S = (t, m) => {
+	let g = r(m, [
+		"bucket",
+		"metadata",
+		"destination",
+		"maxPatchBytes",
+		"maxBodyParts",
+		"authorize"
+	], [
+		"bucket",
+		"metadata",
+		"authorize"
+	]), v = o(g.bucket), y = Object.hasOwn(g, "destination") ? o(g.destination) : void 0, S = Object.hasOwn(g, "maxPatchBytes") ? s(g.maxPatchBytes, 512, 16777216) : 262144, C = Object.hasOwn(g, "maxBodyParts") ? s(g.maxBodyParts, 1, 1048576) : 4096, w = x(t, "put"), T = x(t, "head"), E = x(t, "getStream"), D = x(t, "delete"), O = x(g.metadata, "lookup"), k = g.authorize;
+	if (typeof k != "function") throw b();
+	let A = k, j = {
+		maxBytes: S,
+		maxMetadataBytes: Math.min(4096, S - 16)
+	}, M = (e) => "geometry:journal:" + f(JSON.stringify(e)), N = (e) => "geometry:journal:" + f(JSON.stringify([p(e.receipt.scope), e.receipt.requestId])), P = (e) => ({
+		tenantId: e.receipt.scope.tenantId,
+		bucket: v,
+		operationId: M(e)
+	}), F = (e, t, n) => {
+		if (!e || n !== void 0 && e.id !== n || e.tenantId !== t.receipt.scope.tenantId || e.bucket !== v || e.checksum !== t.patchSha256 || e.size !== t.size || e.visibility !== "private" || e.contentType !== "application/octet-stream") throw b();
+		return o(e.id), e;
+	}, I = async (e, t) => {
+		if (!h.isEffect(t)) throw b();
+		return e(t);
+	}, L = (t) => h.flatMap(h.context(), (n) => h.uninterruptible(h.tryPromise({
+		try: () => t(d(n)),
+		catch: (t) => t instanceof e ? t : b()
+	}))), R = async (e, t, n) => {
+		if (await I(e, A(t, n)) !== void 0) throw b();
+	}, z = (t) => {
+		let n = u(t);
+		if (n.size > S) throw new e({
+			budget: "geometryJournalArchivePatchBytes",
+			limit: S
+		});
+		return n;
+	};
+	return Object.freeze({
+		store: (t, r) => {
+			let o, s;
+			try {
+				o = a(t), s = n(r, S, "geometryJournalArchivePatchBytes"), l(o, c(s, j).metadata);
+			} catch (t) {
+				return h.fail(t instanceof e ? t : b());
+			}
+			return L(async (e) => {
+				let t = z({
+					receipt: o,
+					patchSha256: await i(s),
+					size: s.length
+				});
+				await R(e, "store", t);
+				let n = F(await I(e, w({
+					tenantId: o.scope.tenantId,
+					bytes: new Uint8Array(s),
+					contentType: "application/octet-stream",
+					visibility: "private",
+					operationId: M(t),
+					claim: N(t),
+					key: "geometry/journal/" + f(JSON.stringify(t)),
+					...y === void 0 ? {} : { destination: y }
+				})), t), r = await O(P(t), N(t));
+				if (!r || r.state !== "ready" || !r.held || F(r.ref, t, n.id).size !== s.length) throw b();
+				return await R(e, "store", t), t;
+			});
+		},
+		load: (t) => {
+			let n;
+			try {
+				n = z(t);
+			} catch (t) {
+				return h.fail(t instanceof e ? t : b());
+			}
+			return L(async (t) => {
+				await R(t, "load", n);
+				let r = await O(P(n), N(n));
+				if (!r || r.state !== "ready" || !r.held) throw b();
+				let a = F(r.ref, n);
+				F(await I(t, T(a.id, { tenantId: n.receipt.scope.tenantId })), n, a.id);
+				let o = await I(t, E(a.id, { tenantId: n.receipt.scope.tenantId }));
+				F(o.ref, n, a.id);
+				let s = new Uint8Array(n.size), u = 0, d = 0;
+				if (await I(t, _.runForEach(o.stream, (t) => h.sync(() => {
+					if (++d > C) throw new e({
+						budget: "geometryJournalArchiveBodyParts",
+						limit: C
+					});
+					if (!(t instanceof Uint8Array) || t.buffer instanceof SharedArrayBuffer || t.length > s.length - u) throw b();
+					s.set(t, u), u += t.length;
+				}))), u !== s.length || await i(s) !== n.patchSha256) throw b();
+				l(n.receipt, c(s, j).metadata);
+				let f = await O(P(n), N(n));
+				if (!f || f.state !== "ready" || !f.held) throw b();
+				return F(f.ref, n, a.id), await R(t, "load", n), s;
+			});
+		},
+		release: (t) => {
+			let n;
+			try {
+				n = z(t);
+			} catch (t) {
+				return h.fail(t instanceof e ? t : b());
+			}
+			return L(async (e) => {
+				await R(e, "release", n);
+				let t = await O(P(n), N(n));
+				if (!t) {
+					await R(e, "release", n);
+					return;
+				}
+				if (t.state === "reserved") throw b();
+				let r = F(t.ref, n);
+				if (t.state === "deleted" || t.state === "ready" && !t.held) {
+					await R(e, "release", n);
+					return;
+				}
+				if (await I(e, D(r.id, {
+					tenantId: n.receipt.scope.tenantId,
+					claim: N(n)
+				})) !== void 0) throw b();
+				let i = await O(P(n), N(n));
+				if (!i || i.state !== "deleted" && i.state !== "ready" || i.held) throw b();
+				F(i.ref, n, r.id), await R(e, "release", n);
+			});
+		}
+	});
+};
+export { v as GeometryJournalArchivePort, y as geometryJournalArchiveLayer, S as storageGeometryJournal };

package/dist/geometryLoader.js

@@ -0,0 +1,117 @@
+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 { assertGeometryArtifactScope as i, captureGeometryCodecProfiles as a, captureGeometryDense as o, geometryPersistenceInteger as s, geometryPersistenceRefusal as c } from "./geometryPersistenceData.js";
+import { captureGeometryDerivationStrategies as l } from "./geometryDerivationStrategies.js";
+import { captureGeometryPreparedCoordinate as u, captureGeometryPreparedScope as d, prepareGeometryInventory as f } from "./geometryPrepared.js";
+import { geometryChunkHasWorldExtent as p } from "./geometryWorldExtent.js";
+import { captureWorldCatalog as m } from "./world.js";
+import { captureRoomSnapshotEffectRunner as h } from "./snapshotBlobIndex.js";
+import { GeometryPersistencePort as g } from "./geometryPersistencePorts.js";
+import { Effect as _ } from "effect";
+// src/geometryLoader.ts
+var v = (v, y, b, x = {}) => {
+	try {
+		let S = m([v])[0], C = S.geometry, w = d(y);
+		if (!C || w.worldId !== S.name || w.kind !== C.kind) return _.fail(new t({ detail: "Geometry load needs the exact declared World kind" }));
+		let T = n(x, [
+			"maxChunks",
+			"maxAccountedBytes",
+			"codecLimits",
+			"maxConcurrent",
+			"strategies",
+			"navEnabled"
+		], []), E = Object.hasOwn(T, "maxChunks") ? s(T.maxChunks, 1, C.budgets.maxPreparedChunks) : C.budgets.maxPreparedChunks, D = Object.hasOwn(T, "maxAccountedBytes") ? s(T.maxAccountedBytes, 512, C.budgets.maxPreparedBytes) : C.budgets.maxPreparedBytes, O = Object.hasOwn(T, "maxConcurrent") ? s(T.maxConcurrent, 1, Math.min(64, E)) : Math.min(4, E), k = Object.hasOwn(T, "codecLimits") ? a(T.codecLimits) : null, A = Object.hasOwn(T, "strategies") ? n(T.strategies, ["collisionDerive", "navDerive"], []) : {}, j = l({
+			collisionDerive: C.strategies.collisionDerive,
+			navDerive: C.strategies.navDerive,
+			...A
+		}), M = C.nav.derive === "grid", N = Object.freeze({
+			strategies: j,
+			navEnabled: M,
+			maxChunks: E,
+			maxAccountedBytes: D,
+			...k === null ? {} : { codecLimits: Object.freeze(Object.fromEntries(k)) }
+		}), P = o(b, E, (e) => u(w, e)), F = /* @__PURE__ */ new Set();
+		if (!P.length || Object.hasOwn(T, "navEnabled") && T.navEnabled !== M) return c();
+		for (let e of P) {
+			let t = JSON.stringify([
+				e.cx,
+				e.cy,
+				e.cz ?? null
+			]);
+			if (F.has(t)) return c();
+			F.add(t);
+		}
+		return _.flatMap(g, (a) => _.flatMap(_.context(), (o) => _.uninterruptible(_.tryPromise({
+			try: async () => {
+				let e = n(a, [
+					"publish",
+					"observe",
+					"commit",
+					"exportSubject",
+					"eraseSubject"
+				], ["observe"]).observe;
+				if (typeof e != "function") return c();
+				let t = e, l = h(o), m = Array(P.length), g = 0, v = !1, y, b = async () => {
+					for (; !v && g < P.length;) {
+						let e = g++, a = P[e];
+						try {
+							let o = t(a);
+							if (!_.isEffect(o)) return c();
+							let f = await l(o), h = n(f, [
+								"scope",
+								"revision",
+								"artifact"
+							]), g = u(w, {
+								cx: a.cx,
+								cy: a.cy,
+								...a.cz === void 0 ? {} : { cz: a.cz }
+							}), v = n(h.scope, [
+								"tenantId",
+								"kind",
+								"worldId",
+								"version",
+								"layerSetId",
+								"cx",
+								"cy",
+								"cz"
+							], [
+								"tenantId",
+								"kind",
+								"worldId",
+								"version",
+								"layerSetId",
+								"cx",
+								"cy"
+							]), y = r(h.artifact), b = d({
+								tenantId: v.tenantId,
+								kind: v.kind,
+								worldId: v.worldId,
+								layerSetId: v.layerSetId,
+								version: v.version
+							}), x = u(b, {
+								cx: v.cx,
+								cy: v.cy,
+								...Object.hasOwn(v, "cz") ? { cz: v.cz } : {}
+							});
+							if (JSON.stringify(x) !== JSON.stringify(g) || !p(y, C.chunkSizeRaw)) return c();
+							i(y, g), m[e] = Object.freeze({
+								scope: g,
+								revision: s(h.revision),
+								artifact: y
+							});
+						} catch (e) {
+							v || (v = !0, y = e);
+						}
+					}
+				};
+				if (await Promise.all(Array.from({ length: Math.min(O, P.length) }, () => b())), v) throw y;
+				return f(w, m, N);
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "Complete World geometry preparation remains unconfirmed" })
+		}))));
+	} catch {
+		return _.fail(new t({ detail: "World geometry load configuration could not be captured" }));
+	}
+};
+export { v as loadPreparedWorldGeometry };