@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryPersistence.js

@@ -0,0 +1,448 @@
+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 { verifyGeometryArtifact as i } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as a, captureGeometryCodecProfiles as o, captureGeometryOwner as s, captureGeometryPersistenceScope as c, captureGeometryPrivacyTarget as l, captureGeometryReceipt as u, captureGeometrySubject as ee, geometryPersistenceId as d, geometryPersistenceInteger as f, geometryPersistenceRefusal as p, geometryPersistenceSha as m } from "./geometryPersistenceData.js";
+import { GEO_JOURNAL_ARCHIVES_TABLE as h } from "./geometryJournalArchiveTable.js";
+import { applyGeometryPatch as g, decodeGeometryPatch as _ } from "./geometryPatch.js";
+import { captureGeometryCompactionStrategies as te, prepareGeometryCompaction as ne } from "./geometryCompactionStrategies.js";
+import { captureWorldCatalog as v } from "./world.js";
+import { assertRoomSubjectAdmission as re } from "./subjectAdmission.js";
+import { captureGeometryJournalArchiveReference as y } from "./geometryJournalArchiveData.js";
+import { captureRoomSnapshotEffectRunner as b } from "./snapshotBlobIndex.js";
+import { assertGeometryPrivacyFence as ie } from "./geometryPrivacyFence.js";
+import { captureGeometryStoredVersion as ae, captureGeometryVersion as oe, geometryPersistenceDigest as x, geometryPersistenceScopeKey as S, geometryPersistenceVersionKey as se } from "./geometryPersistenceCapture.js";
+import { assertGeometrySqlOwner as ce } from "./geometrySqlOwner.js";
+import { makeGeometryJournalPatchReader as le } from "./geometryJournalPatch.js";
+import { captureGeometryPlayerAdmission as ue } from "./geometryPlayerAdmission.js";
+import { GeometryPersistencePort as C, GeometryStaticSourcePort as de, geometryPersistenceLayer as w, geometryStaticSourceLayer as fe } from "./geometryPersistencePorts.js";
+import { and as T, bytes as E, eq as D, generateId as pe, id as O, integer as k, json as A, table as j, text as M, timestamp as N } from "@voltro/database";
+import { Effect as P } from "effect";
+// src/geometryPersistence.ts
+var F = "_voltro_geo_versions", I = "_voltro_geo_chunk_deltas", L = "_voltro_geo_journal", R = j(F, {
+	id: O({ prefix: "gver" }),
+	tenantId: M().maxLength(191),
+	versionKey: M().maxLength(64),
+	worldId: M().maxLength(96),
+	kind: M().maxLength(24),
+	version: M().maxLength(96),
+	manifestChunks: k(),
+	manifest: A(),
+	manifestSha256: M().maxLength(64),
+	createdAt: N()
+}).unique("byGeometryVersion", ["tenantId", "versionKey"]), me = j(I, {
+	id: O({ prefix: "gdelta" }),
+	tenantId: M().maxLength(191),
+	scopeKey: M().maxLength(64),
+	scope: A(),
+	revision: k(),
+	blobSha256: M().maxLength(64),
+	contentSha256: M().maxLength(64),
+	delta: E(),
+	updatedAt: N()
+}).unique("byGeometryChunkDelta", ["tenantId", "scopeKey"]), z = j(L, {
+	id: O({ prefix: "gjour" }),
+	tenantId: M().maxLength(191),
+	scopeKey: M().maxLength(64),
+	requestKey: M().maxLength(64),
+	requestDigest: M().maxLength(64),
+	owner: A(),
+	subjectId: M().maxLength(191),
+	subjectKind: M().maxLength(8),
+	receipt: A(),
+	patch: E(),
+	createdAt: N()
+}).unique("byGeometryRequest", ["tenantId", "requestKey"]).index(["tenantId", "scopeKey"]).index([
+	"tenantId",
+	"subjectId",
+	"subjectKind"
+]), B = Object.freeze([
+	R,
+	me,
+	z
+]), V = (e) => T(D("tenantId", e.tenantId), D("versionKey", se(e))), H = (e) => T(D("tenantId", e.tenantId), D("scopeKey", S(e))), he = (e, t) => T(D("tenantId", e.tenantId), D("requestKey", x(JSON.stringify([e.tenantId, t])))), U = (e) => T(D("tenantId", e.tenantId), D("subjectId", e.subject.id), D("subjectKind", e.subject.kind)), W = (e, t, n, r = !1, i = 2) => e.query({
+	table: t,
+	predicate: n,
+	order: [{
+		column: "id",
+		direction: "asc"
+	}],
+	take: i,
+	skip: void 0,
+	projection: void 0,
+	...r ? { lock: "update" } : {}
+}), ge = (e, t) => JSON.stringify(e) === JSON.stringify(t), _e = (C, de) => {
+	let w = r(de, [
+		"staticSource",
+		"epochNow",
+		"authorize",
+		"quiesceSubject",
+		"eraseSubjectContent",
+		"codecLimits",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxDeltaBytes",
+		"maxReceiptsPerChunk",
+		"maxPrivacyRows",
+		"maxPrivacyBytes",
+		"requirePlayerSession",
+		"journalArchiveIndex",
+		"worlds",
+		"strategies"
+	], [
+		"staticSource",
+		"epochNow",
+		"authorize",
+		"quiesceSubject",
+		"eraseSubjectContent"
+	]), fe = r(w.staticSource, ["load"]).load, E = w.epochNow, O = w.authorize, k = w.quiesceSubject, A = w.eraseSubjectContent;
+	if (typeof fe != "function" || typeof E != "function" || typeof O != "function" || typeof k != "function" || typeof A != "function" || Object.hasOwn(w, "requirePlayerSession") && typeof w.requirePlayerSession != "boolean") return p();
+	let j = w.requirePlayerSession === !0, M = Object.hasOwn(w, "worlds") ? new Map(v(w.worlds).map((e) => [e.name, e])) : null, N = r(Object.hasOwn(w, "strategies") ? w.strategies : {}, ["compaction"], []), R = te(N), me = E, z = fe, B = O, _e = k, ve = A, G = (e, t, n, r) => Object.hasOwn(w, e) ? f(w[e], n, r) : t, ye = G("maxManifestChunks", 256, 1, 4096), be = G("maxManifestBytes", 262144, 1024, 16777216), K = G("maxDeltaBytes", 262144, 512, 16777216), xe = G("maxReceiptsPerChunk", 4096, 1, 65536), q = G("maxPrivacyRows", 4096, 1, 65536), J = G("maxPrivacyBytes", 16777216, 512, 67108864), Y = Object.freeze({
+		maxBytes: K,
+		maxMetadataBytes: Math.min(4096, K - 16)
+	}), Se = le({
+		maxPatchBytes: K,
+		...Object.hasOwn(w, "journalArchiveIndex") ? { archive: w.journalArchiveIndex } : {}
+	}), Ce = Object.hasOwn(w, "journalArchiveIndex") ? r(w.journalArchiveIndex, [
+		"archive",
+		"load",
+		"exportSubject",
+		"eraseSubject"
+	]) : void 0, we = Ce ? Ce.eraseSubject.bind(w.journalArchiveIndex) : void 0, Te = Object.hasOwn(w, "codecLimits") ? o(w.codecLimits) : /* @__PURE__ */ new Map(), X = (e) => Te.get(e) ?? {}, Ee = () => new Date(f(me(), 0, 864e13)), Z = async (e, t) => P.isEffect(t) ? e(t) : p(), Q = (n) => P.flatMap(P.context(), (r) => P.uninterruptible(P.tryPromise({
+		try: () => n(b(r)),
+		catch: (n) => n instanceof e || n instanceof t ? n : new t({ detail: "Geometry SQL operation remains unconfirmed" })
+	}))), $ = () => P.fail(new t({ detail: "Geometry persistence request could not be captured" })), De = (e, t) => ae(e, t, ye, be), Oe = async (e, t, n) => {
+		let r = t.chunks.find((e) => S(e) === S(n));
+		if (!r) return p();
+		let o = await Z(e, z(r)), s = await i(n.kind, o, r.blobSha256, X(n.kind));
+		return a(s, n), s.contentSha256 === r.contentSha256 ? s : p();
+	}, ke = (e, t) => {
+		let r = c(e.scope);
+		return e.tenantId !== t.tenantId || e.scopeKey !== S(t) || !ge(r, t) ? p() : Object.freeze({
+			id: d(e.id),
+			revision: f(e.revision, 1),
+			blobSha256: m(e.blobSha256),
+			contentSha256: m(e.contentSha256),
+			delta: n(e.delta, K, "geometryNetDeltaBytes")
+		});
+	}, Ae = async (e, t) => {
+		let n = await C.transactional(async (e) => {
+			let n = await W(e, F, V(t)), r = await W(e, I, H(t));
+			return n.length !== 1 || r.length > 1 ? p() : {
+				manifest: De(n[0], t),
+				delta: r.length ? ke(r[0], t) : null
+			};
+		}), r = await Oe(e, n.manifest, t), i = r, a = 0;
+		if (n.delta) {
+			let e = _(n.delta.delta, Y);
+			if (i = (await g(r, e, 0, X(t.kind))).artifact, a = n.delta.revision, i.blobSha256 !== n.delta.blobSha256 || i.contentSha256 !== n.delta.contentSha256) return p();
+		}
+		return {
+			manifest: n.manifest,
+			base: r,
+			delta: n.delta,
+			observation: Object.freeze({
+				scope: t,
+				revision: a,
+				artifact: i
+			})
+		};
+	}, je = (e, t, n, r) => {
+		let i = u(e.receipt);
+		return e.tenantId !== t.tenantId || e.scopeKey !== S(t) || e.requestKey !== x(JSON.stringify([t.tenantId, n])) || e.requestDigest !== r || i.requestId !== n || !ge(i.scope, t) ? p() : i;
+	};
+	return Object.freeze({
+		publish: (e) => {
+			try {
+				let t = oe(e, ye, be);
+				return Q(async (e) => {
+					if (await Z(e, B("publish", t)) !== void 0) return p();
+					for (let n of t.chunks) await Oe(e, t, n);
+					return C.transactional(async (e) => {
+						let n = await W(e, F, V(t), !0);
+						if (n.length > 1) return p();
+						if (n.length) {
+							let e = De(n[0], t);
+							return e.manifestSha256 === t.manifestSha256 ? e : p();
+						}
+						return await e.insert(F, {
+							id: pe({
+								kind: "typeid",
+								prefix: "gver"
+							}, F),
+							tenantId: t.tenantId,
+							versionKey: se(t),
+							worldId: t.worldId,
+							kind: t.kind,
+							version: t.version,
+							manifestChunks: t.chunks.length,
+							manifest: t,
+							manifestSha256: t.manifestSha256,
+							createdAt: Ee()
+						}), t;
+					});
+				});
+			} catch {
+				return $();
+			}
+		},
+		observe: (e) => {
+			try {
+				let t = c(e);
+				return Q(async (e) => await Z(e, B("observe", t)) === void 0 ? (await Ae(e, t)).observation : p());
+			} catch {
+				return $();
+			}
+		},
+		commit: (t) => {
+			try {
+				let n = r(t, [
+					"scope",
+					"owner",
+					"subject",
+					"requestId",
+					"patch",
+					"actualSession"
+				], [
+					"scope",
+					"owner",
+					"subject",
+					"requestId",
+					"patch"
+				]), i = c(n.scope), a = s(n.owner), o = ee(n.subject), l = d(n.requestId), f = _(n.patch, Y), m = f.bytes(), h = x(JSON.stringify([
+					i,
+					a,
+					o,
+					l,
+					x(m)
+				])), te = Object.freeze({
+					owner: a,
+					subject: o,
+					requestId: l
+				}), v = Object.hasOwn(n, "actualSession") ? ue(n.actualSession, i, a, o) : null;
+				if (j && !v) return $();
+				let y = f.metadata;
+				if (y.kind !== i.kind || y.version !== i.version || y.worldId !== i.worldId || y.layerSetId !== i.layerSetId || y.cx !== i.cx || y.cy !== i.cy || y.cz !== i.cz) return $();
+				let b = M?.get(i.worldId);
+				if (M && !b?.geometry) return $();
+				let ie = Object.hasOwn(N, "compaction") ? R.compaction : b?.geometry?.strategies.compaction ?? R.compaction, ae = b?.geometry ? Math.min(K, b.geometry.dynamic.maxDeltaBytesPerChunk) : K, oe = Object.freeze({
+					maxBytes: ae,
+					maxMetadataBytes: Math.min(Y.maxMetadataBytes, ae - 16)
+				});
+				return Q(async (t) => {
+					if (v?.assertCurrent(), await Z(t, B("commit", i, te)) !== void 0) return p();
+					v?.assertCurrent();
+					let n = await W(C, L, he(i, l));
+					if (n.length > 1 || !n.length && b?.geometry && b.geometry.kind !== i.kind) return p();
+					let r = n.length ? null : await Ae(t, i), s = r ? await g(r.observation.artifact, f, r.observation.revision, X(i.kind)) : null, c = r && s ? await ne({
+						static: r.base,
+						current: s.artifact,
+						limits: oe,
+						codecLimits: X(i.kind)
+					}, { compaction: ie }) : null;
+					return C.transactional(async (t) => {
+						let n = await W(t, F, V(i), !0);
+						if (n.length !== 1) return p();
+						let ee = De(n[0], i);
+						await ce(t, i, a), await re(t, {
+							tenantId: i.tenantId,
+							subjectId: o.id
+						}), v && await v.assertConsumedSeat(t);
+						let d = await W(t, L, he(i, l), !0);
+						if (d.length > 1) return p();
+						if (d.length) {
+							if (d[0].subjectId !== o.id || d[0].subjectKind !== o.kind) return p();
+							let e = je(d[0], i, l, h);
+							return v?.assertCurrent(), e;
+						}
+						if (!r || !s || !c || ee.manifestSha256 !== r.manifest.manifestSha256) return p();
+						let f = await W(t, I, H(i), !0);
+						if (f.length > 1) return p();
+						let g = f.length ? ke(f[0], i) : null;
+						if ((g?.revision ?? 0) !== r.observation.revision || (g?.blobSha256 ?? r.base.blobSha256) !== r.observation.artifact.blobSha256 || (g?.contentSha256 ?? r.base.contentSha256) !== r.observation.artifact.contentSha256) return p();
+						if ((await W(t, "_voltro_geo_journal", H(i), !0, xe + 1)).length >= xe) throw new e({
+							budget: "geometryReceiptRows",
+							limit: xe
+						});
+						let _ = u({
+							scope: i,
+							requestId: l,
+							baseRevision: y.baseRevision,
+							revision: y.revision,
+							changed: y.changed,
+							blobSha256: s.artifact.blobSha256,
+							contentSha256: s.artifact.contentSha256
+						});
+						if (y.changed) {
+							let e = {
+								revision: s.revision,
+								blobSha256: s.artifact.blobSha256,
+								contentSha256: s.artifact.contentSha256,
+								delta: c.bytes(),
+								updatedAt: Ee()
+							};
+							if (g) {
+								if (await t.updateMany("_voltro_geo_chunk_deltas", e, { where: T(H(i), D("id", g.id), D("revision", g.revision), D("blobSha256", g.blobSha256)) }) !== 1) return p();
+							} else await t.insert(I, {
+								id: pe({
+									kind: "typeid",
+									prefix: "gdelta"
+								}, I),
+								tenantId: i.tenantId,
+								scopeKey: S(i),
+								scope: i,
+								...e
+							});
+						}
+						return v?.assertCurrent(), await t.insert(L, {
+							id: pe({
+								kind: "typeid",
+								prefix: "gjour"
+							}, L),
+							tenantId: i.tenantId,
+							scopeKey: S(i),
+							requestKey: x(JSON.stringify([i.tenantId, l])),
+							requestDigest: h,
+							owner: a,
+							subjectId: o.id,
+							subjectKind: o.kind,
+							receipt: _,
+							patch: m,
+							createdAt: Ee()
+						}), v?.assertCurrent(), _;
+					});
+				});
+			} catch {
+				return $();
+			}
+		},
+		exportSubject: (t) => {
+			try {
+				let n = l(t);
+				return Q(async (t) => {
+					if (await Z(t, B("export", n)) !== void 0) return p();
+					let r = await W(C, L, U(n), !1, q + 1);
+					if (r.length > q) throw new e({
+						budget: "geometryPrivacyRows",
+						limit: q
+					});
+					let i = 0, a = [];
+					for (let o of r) {
+						let r = u(o.receipt), c = await Z(t, Se(o)), l = _(c, Y);
+						if (i += c.length + new TextEncoder().encode(JSON.stringify(r)).length, i > J) throw new e({
+							budget: "geometryPrivacyBytes",
+							limit: J
+						});
+						if (o.tenantId !== n.tenantId || o.subjectId !== n.subject.id || o.subjectKind !== n.subject.kind || r.scope.tenantId !== n.tenantId || o.scopeKey !== S(r.scope) || o.requestKey !== x(JSON.stringify([n.tenantId, r.requestId])) || l.metadata.revision !== r.revision || l.metadata.baseRevision !== r.baseRevision || l.metadata.changed !== r.changed || l.metadata.blobSha256 !== r.blobSha256 || l.metadata.contentSha256 !== r.contentSha256 || l.metadata.kind !== r.scope.kind || l.metadata.version !== r.scope.version || l.metadata.worldId !== r.scope.worldId || l.metadata.layerSetId !== r.scope.layerSetId || l.metadata.cx !== r.scope.cx || l.metadata.cy !== r.scope.cy || l.metadata.cz !== r.scope.cz || m(o.requestDigest) !== x(JSON.stringify([
+							r.scope,
+							s(o.owner),
+							n.subject,
+							r.requestId,
+							x(c)
+						]))) return p();
+						a.push(Object.freeze({
+							receipt: r,
+							patch: c
+						}));
+					}
+					return Object.freeze(a);
+				});
+			} catch {
+				return $();
+			}
+		},
+		eraseSubject: (t) => {
+			try {
+				let n = l(t);
+				return Q(async (t) => {
+					if (await Z(t, B("erase", n)) !== void 0 || (await ie(C, n), await Z(t, _e(n)) !== void 0) || await Z(t, ve(n)) !== void 0 || we && await Z(t, we(n)) !== void 0 || await Z(t, B("erase", n)) !== void 0) return p();
+					await C.transactional(async (t) => {
+						await ie(t, n);
+						let r = await W(t, L, U(n), !0, q + 1);
+						if (r.length > q) throw new e({
+							budget: "geometryPrivacyRows",
+							limit: q
+						});
+						for (let e of r) if (e.tenantId !== n.tenantId || e.subjectId !== n.subject.id || e.subjectKind !== n.subject.kind) return p();
+						if (we) {
+							let i = await W(t, h, U(n), !0, q + 1);
+							if (i.length > q) throw new e({
+								budget: "geometryArchiveReleaseRows",
+								limit: q
+							});
+							let a = 0;
+							for (let t of i) {
+								let i = y(t.archive), o = t.releasedAt, c = o instanceof Date ? o.getTime() : typeof o == "string" ? Date.parse(o) : NaN;
+								if (a += new TextEncoder().encode(JSON.stringify(i)).length, a > J) throw new e({
+									budget: "geometryArchiveReleaseBytes",
+									limit: J
+								});
+								if (!Number.isSafeInteger(c) || c < 0 || t.tenantId !== n.tenantId || t.subjectId !== n.subject.id || t.subjectKind !== n.subject.kind || i.receipt.scope.tenantId !== n.tenantId || t.scopeKey !== S(i.receipt.scope) || t.requestKey !== x(JSON.stringify([n.tenantId, i.receipt.requestId]))) return p();
+								d(t.id), d(t.journalId), m(t.requestDigest);
+								let l = r.find((e) => e.id === t.journalId);
+								if (l && (l.requestDigest !== t.requestDigest || !ge(u(l.receipt), i.receipt) || t.requestDigest !== x(JSON.stringify([
+									i.receipt.scope,
+									s(l.owner),
+									n.subject,
+									i.receipt.requestId,
+									i.patchSha256
+								])))) return p();
+							}
+							await t.deleteMany(h, { where: U(n) });
+						}
+						await t.deleteMany(L, { where: U(n) });
+					});
+				});
+			} catch {
+				return $();
+			}
+		}
+	});
+}, ve = (e) => {
+	let n = r(e, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]), i = n.exportSubject, a = n.eraseSubject;
+	if (typeof i != "function" || typeof a != "function") return p();
+	let o = (e, t) => {
+		let n = r(t, [
+			"tenantId",
+			"requestId",
+			"kind",
+			"completed"
+		], [
+			"tenantId",
+			"requestId",
+			"kind"
+		]);
+		return l({
+			tenantId: n.tenantId,
+			requestId: n.requestId,
+			subject: {
+				id: e,
+				kind: n.kind
+			}
+		});
+	};
+	return Object.freeze({
+		tables: B,
+		onErase: (e, n) => {
+			try {
+				return a(o(e, n));
+			} catch {
+				return P.fail(new t({ detail: "Geometry privacy target could not be admitted" }));
+			}
+		},
+		onExport: (e, n) => {
+			try {
+				return i(o(e, n));
+			} catch {
+				return P.fail(new t({ detail: "Geometry privacy target could not be admitted" }));
+			}
+		}
+	});
+};
+export { I as GEO_CHUNK_DELTAS_TABLE, L as GEO_JOURNAL_TABLE, F as GEO_VERSIONS_TABLE, C as GeometryPersistencePort, de as GeometryStaticSourcePort, _e as dataStoreGeometryPersistence, me as geometryChunkDeltasTable, z as geometryJournalTable, w as geometryPersistenceLayer, ve as geometryPersistencePrivacyHooks, B as geometryPersistenceTables, fe as geometryStaticSourceLayer, R as geometryVersionsTable };

package/dist/geometryPersistenceCapture.js

@@ -0,0 +1,68 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { assertGeometryArtifactScope as n, captureGeometryCodecProfiles as r, captureGeometryDense as i, captureGeometryKind as a, captureGeometryOwner as o, captureGeometryPersistenceScope as s, captureGeometryPrivacyTarget as c, captureGeometryReceipt as l, captureGeometryStaticReference as u, captureGeometrySubject as d, geometryPersistenceId as f, geometryPersistenceInteger as p, geometryPersistenceRefusal as m, geometryPersistenceSha as h } from "./geometryPersistenceData.js";
+import { createHash as g } from "node:crypto";
+// src/geometryPersistenceCapture.ts
+var _ = (e) => g("sha256").update(e).digest("hex"), v = (e) => _(JSON.stringify([
+	e.tenantId,
+	e.kind,
+	e.worldId,
+	e.version,
+	e.layerSetId,
+	e.cx,
+	e.cy,
+	e.cz ?? null
+])), y = (e) => _(JSON.stringify([
+	e.tenantId,
+	e.kind,
+	e.worldId,
+	e.version
+])), b = (n, r, o) => {
+	let s = t(n, [
+		"tenantId",
+		"kind",
+		"worldId",
+		"version",
+		"chunks"
+	]), c = f(s.tenantId), l = a(s.kind), d = f(s.worldId, 96), p = f(s.version, 96), h = [...i(s.chunks, r, u)];
+	if (!h.length) return m();
+	let g = /* @__PURE__ */ new Set();
+	for (let e of h) {
+		let t = v(e);
+		if (e.tenantId !== c || e.kind !== l || e.worldId !== d || e.version !== p || g.has(t)) return m();
+		g.add(t);
+	}
+	h.sort((e, t) => e.layerSetId < t.layerSetId ? -1 : e.layerSetId > t.layerSetId ? 1 : e.cx - t.cx || e.cy - t.cy || (e.cz ?? 0) - (t.cz ?? 0));
+	let y = Object.freeze({
+		tenantId: c,
+		kind: l,
+		worldId: d,
+		version: p,
+		chunks: Object.freeze(h)
+	}), b = JSON.stringify(y);
+	if (new TextEncoder().encode(b).length > o) throw new e({
+		budget: "geometryManifestBytes",
+		limit: o
+	});
+	return Object.freeze({
+		...y,
+		manifestSha256: _(b)
+	});
+}, x = (e, n, r, i) => {
+	let a = t(e.manifest, [
+		"tenantId",
+		"kind",
+		"worldId",
+		"version",
+		"chunks",
+		"manifestSha256"
+	]), o = b({
+		tenantId: a.tenantId,
+		kind: a.kind,
+		worldId: a.worldId,
+		version: a.version,
+		chunks: a.chunks
+	}, r, i);
+	return e.tenantId !== n.tenantId || e.versionKey !== y(n) || y(o) !== y(n) || e.worldId !== o.worldId || e.kind !== o.kind || e.version !== o.version || e.manifestChunks !== o.chunks.length || h(e.manifestSha256) !== o.manifestSha256 || h(a.manifestSha256) !== o.manifestSha256 ? m() : o;
+};
+export { n as assertGeometryArtifactScope, r as captureGeometryCodecProfiles, i as captureGeometryDense, a as captureGeometryKind, o as captureGeometryOwner, s as captureGeometryPersistenceScope, c as captureGeometryPrivacyTarget, l as captureGeometryReceipt, u as captureGeometryStaticReference, x as captureGeometryStoredVersion, d as captureGeometrySubject, b as captureGeometryVersion, _ as geometryPersistenceDigest, f as geometryPersistenceId, p as geometryPersistenceInteger, m as geometryPersistenceRefusal, v as geometryPersistenceScopeKey, h as geometryPersistenceSha, y as geometryPersistenceVersionKey };

package/dist/geometryPersistenceData.js

@@ -0,0 +1,139 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { geometryArtifactStateCodec as n } from "./geometryArtifacts.js";
+// src/geometryPersistenceData.ts
+function r() {
+	throw new e({ detail: "Geometry persistence could not admit the exact durable scope" });
+}
+var i = (e, t = 0, n = 2147483647) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : r(), a = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(e) ? e : r(), o = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e) ? e : r(), s = (e) => [
+	"2d-tiles",
+	"2d-heightfield",
+	"3d-shapes",
+	"3d-voxel"
+].includes(e) ? e : r(), c = [
+	"tenantId",
+	"kind",
+	"worldId",
+	"version",
+	"layerSetId",
+	"cx",
+	"cy",
+	"cz"
+], l = (e) => {
+	let n = t(e, c, c.filter((e) => e !== "cz")), o = s(n.kind), l = o === "3d-shapes" || o === "3d-voxel";
+	return Object.hasOwn(n, "cz") === l ? Object.freeze({
+		tenantId: a(n.tenantId),
+		kind: o,
+		worldId: a(n.worldId, 96),
+		version: a(n.version, 96),
+		layerSetId: a(n.layerSetId, 96),
+		cx: i(n.cx, -2147483648),
+		cy: i(n.cy, -2147483648),
+		...l ? { cz: i(n.cz, -2147483648) } : {}
+	}) : r();
+}, u = (e) => {
+	let n = t(e, [
+		...c,
+		"blobSha256",
+		"contentSha256"
+	], [
+		...c.filter((e) => e !== "cz"),
+		"blobSha256",
+		"contentSha256"
+	]), r = l(Object.fromEntries(c.filter((e) => Object.hasOwn(n, e)).map((e) => [e, n[e]])));
+	return Object.freeze({
+		...r,
+		blobSha256: o(n.blobSha256),
+		contentSha256: o(n.contentSha256)
+	});
+}, d = (e, t, n) => {
+	if (!Array.isArray(e) || Object.getPrototypeOf(e) !== Array.prototype || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return r();
+	let i = [];
+	for (let t = 0; t < e.length; t++) {
+		let a = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!a?.enumerable || !("value" in a)) return r();
+		i.push(n(a.value));
+	}
+	return Object.freeze(i);
+}, f = (e) => {
+	let n = t(e, [
+		"roomId",
+		"hostId",
+		"epoch"
+	]);
+	return Object.freeze({
+		roomId: a(n.roomId),
+		hostId: a(n.hostId),
+		epoch: i(n.epoch, 1)
+	});
+}, p = (e) => {
+	let n = t(e, ["id", "kind"]);
+	return n.kind !== "user" && n.kind !== "guest" ? r() : Object.freeze({
+		id: a(n.id),
+		kind: n.kind
+	});
+}, m = (e) => {
+	let n = t(e, [
+		"tenantId",
+		"subject",
+		"requestId"
+	]);
+	return Object.freeze({
+		tenantId: a(n.tenantId),
+		subject: p(n.subject),
+		requestId: a(n.requestId)
+	});
+}, h = (e, t) => {
+	let { chunk: n } = e, i = n.address;
+	(n.kind !== t.kind || n.version !== t.version || i.worldId !== t.worldId || i.layerSetId !== t.layerSetId || i.cx !== t.cx || i.cy !== t.cy || ("cz" in i ? i.cz : void 0) !== t.cz) && r();
+}, g = (e) => {
+	let n = t(e, [
+		"scope",
+		"requestId",
+		"baseRevision",
+		"revision",
+		"changed",
+		"blobSha256",
+		"contentSha256"
+	]), s = i(n.baseRevision), c = i(n.revision);
+	return typeof n.changed != "boolean" || (n.changed ? s === 2147483647 || c !== s + 1 : c !== s) ? r() : Object.freeze({
+		scope: l(n.scope),
+		requestId: a(n.requestId),
+		baseRevision: s,
+		revision: c,
+		changed: n.changed,
+		blobSha256: o(n.blobSha256),
+		contentSha256: o(n.contentSha256)
+	});
+}, _ = (e) => {
+	let r = t(e, [
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	], []), a = /* @__PURE__ */ new Map();
+	for (let e of Object.keys(r)) {
+		let o = e === "2d-tiles" ? [
+			"maxSide",
+			"maxCells",
+			"maxPalette",
+			"maxRuns",
+			"maxBytes"
+		] : e === "2d-heightfield" ? [
+			"maxSide",
+			"maxSamples",
+			"maxBytes"
+		] : e === "3d-shapes" ? ["maxShapes", "maxBytes"] : [
+			"maxSide",
+			"maxVoxels",
+			"maxPalette",
+			"maxSections",
+			"maxRunsPerSection",
+			"maxBytes"
+		], s = t(r[e], o, []), c = Object.freeze({ ...s });
+		for (let e of Object.values(s)) i(e, 1, 16777216);
+		n(e, c), a.set(e, c);
+	}
+	return a;
+};
+export { h as assertGeometryArtifactScope, _ as captureGeometryCodecProfiles, d as captureGeometryDense, s as captureGeometryKind, f as captureGeometryOwner, l as captureGeometryPersistenceScope, m as captureGeometryPrivacyTarget, g as captureGeometryReceipt, u as captureGeometryStaticReference, p as captureGeometrySubject, a as geometryPersistenceId, i as geometryPersistenceInteger, r as geometryPersistenceRefusal, o as geometryPersistenceSha };

package/dist/geometryPersistencePorts.js

@@ -0,0 +1,4 @@
+import { Context as e, Layer as t } from "effect";
+// src/geometryPersistencePorts.ts
+var n = class extends e.Service()("@voltro/GeometryStaticSourcePort") {}, r = class extends e.Service()("@voltro/GeometryPersistencePort") {}, i = (e) => t.succeed(r, e), a = (e) => t.succeed(n, e);
+export { r as GeometryPersistencePort, n as GeometryStaticSourcePort, i as geometryPersistenceLayer, a as geometryStaticSourceLayer };

package/dist/geometryPlayerAdmission.js

@@ -0,0 +1,33 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOM_SEATS_TABLE as t } from "./identities.js";
+import { captureRoomAdmittedSessionReader as n } from "./serverSession.js";
+import { and as r, eq as i } from "@voltro/database";
+// src/geometryPlayerAdmission.ts
+var a = (a, o, s, c) => {
+	let l = n(a), u = l.identity(), d = () => {
+		throw new e({ detail: "Geometry player edit lost its native current Room admission" });
+	};
+	if (!u || u.tenantId !== o.tenantId || u.roomId !== s.roomId || u.epoch !== s.epoch || u.subjectId !== c.id || u.role !== "player") return d();
+	let f = () => {
+		let e = l.identity();
+		if (!e || JSON.stringify(e) !== JSON.stringify(u)) return d();
+	};
+	return f(), Object.freeze({
+		actualSession: a,
+		assertCurrent: f,
+		assertConsumedSeat: async (e) => {
+			f();
+			let n = await e.query({
+				table: t,
+				predicate: r(i("tenantId", o.tenantId), i("roomId", s.roomId), i("sessionId", u.sessionId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			}), a = n[0];
+			if (f(), n.length !== 1 || a?.tenantId !== o.tenantId || a.roomId !== s.roomId || a.sessionId !== u.sessionId || a.subjectId !== c.id || a.epoch !== s.epoch || a.state !== "connected" || a.role !== "player" || a.nonce !== u.nonce || a.token !== u.credentialDigest) return d();
+		}
+	});
+};
+export { a as captureGeometryPlayerAdmission };