@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometry.js

@@ -0,0 +1,40 @@
+import { RoomGeometryReloadRequestSchema as e, RoomGeometryRollbackRequestSchema as t } from "./geometryAdminSchemas.js";
+import { GeometryChunkAddressSchema as n, GeometryTileChunkSchema as r, GeometryTileMaterialSchema as i, GeometryTileRunSchema as a } from "./geometrySchemas.js";
+import { createGeometryTileCodec as o, defaultGeometryTileLimits as s } from "./geometryTileCodec.js";
+import { GeometryHeightfieldChunkSchema as c, createGeometryHeightfieldCodec as l, createGeometryHeightfieldView as u, defaultGeometryHeightfieldLimits as d } from "./geometryHeightfield.js";
+import { GeometryBoxSchema as f, GeometryChunkAddress3DSchema as p, GeometryShapeSchema as m, GeometryShapesChunkSchema as h, GeometrySphereSchema as g, createGeometryShapesCodec as _, createGeometryShapesView as v, defaultGeometryShapesLimits as y } from "./geometryShapes.js";
+import { GeometryVoxelChunkSchema as b, GeometryVoxelSectionSchema as x, createGeometryVoxelCodec as S, createGeometryVoxelView as C, defaultGeometryVoxelLimits as w } from "./geometryVoxel.js";
+import { createGeometryArtifact as T, verifyGeometryArtifact as E } from "./geometryArtifacts.js";
+import { createGeometryTileView as D } from "./geometryTileView.js";
+import { applyGeometryEdit as O, captureGeometryEditAuthority as k, captureGeometryEditIntent as A, captureGeometryEditStrategies as j, defaultGeometryApplyOp as M, defaultGeometryOpValidator as N } from "./geometryEdits.js";
+import { captureGeometryDerivationStrategies as P, defaultGeometryCollisionDerive as F, defaultGeometryNavDerive as I } from "./geometryDerivationStrategies.js";
+import { prepareGeometryInventory as L } from "./geometryPrepared.js";
+import { makeGeometryActorInventory as R } from "./geometryActorInventory.js";
+import { defaultGeometryMigrateDelta as z } from "./geometryMigrationStrategies.js";
+import { GeometryPatchMetadataSchema as B, applyGeometryPatch as V, createGeometryPatch as H, decodeGeometryPatch as U, defaultGeometryPatchLimits as W } from "./geometryPatch.js";
+import { captureGeometryCompactionStrategies as G, defaultGeometryCompaction as K, prepareGeometryCompaction as q } from "./geometryCompactionStrategies.js";
+import { cmsGeometry as J, importedGeometry as Y, procedural as X } from "./worldGeometry.js";
+import { createGeometryTilePathSearch as Z, defaultGeometryTileNavigationLimits as Q } from "./geometryTileNavigation.js";
+import { GeometryManifestFragmentSchema as $, captureGeometryManifestFragment as ee, geometryManifestFragmentBytes as te, geometryManifestReliableChannel as ne, makeGeometryManifestReceiver as re } from "./geometryManifestChannel.js";
+import { GeometryDeltaFragmentSchema as ie, captureGeometryDeltaFragment as ae, createGeometryDeltaFragments as oe, geometryDeltaFragmentBytes as se, geometryReliableChannel as ce, makeGeometryDeltaReceiver as le } from "./geometryChannel.js";
+import { GeometryEditMessageSchema as ue, captureGeometryEditMessage as de, geometryEditChannel as fe } from "./geometryEditChannel.js";
+import { captureGeometryJournalArchiveReference as pe } from "./geometryJournalArchiveData.js";
+import { GeometryPersistencePort as me, GeometryStaticSourcePort as he, geometryPersistenceLayer as ge, geometryStaticSourceLayer as _e } from "./geometryPersistencePorts.js";
+import { GeometryInspectionSchema as ve, GeometryInspectionTableSchema as ye, decodeGeometryInspection as be } from "./geometryInspection.js";
+import { RoomGeometryAdministrationPort as xe } from "./geometryAdministrationPorts.js";
+import { applyGeometryChunkSnapshot as Se, captureGeometryChunkSnapshot as Ce, createGeometryChunkSnapshot as we } from "./geometrySnapshot.js";
+import { GeometryChunkRequestSchema as Te, GeometryChunkSnapshotFragmentSchema as Ee, captureGeometryChunkRequest as De, captureGeometryChunkSnapshotFragment as Oe, createGeometryChunkSnapshotFragments as ke, geometryChunkRequestChannel as Ae, geometryChunkSnapshotChannel as je, makeGeometrySnapshotReceiver as Me } from "./geometrySnapshotChannel.js";
+import { overlapsGeometryHeightfieldBox as Ne } from "./geometryHeightfieldVolume.js";
+import { sweepGeometryHeightfieldBox as Pe } from "./geometryHeightfieldSweep.js";
+import { raycastGeometryHeightfield as Fe } from "./geometryHeightfieldRaycast.js";
+import { createGeometryWorldTilePathSearch as Ie, makeGeometryWorldView as Le } from "./geometryWorldView.js";
+import { worldCellGeometryCoverage as Re, worldGeometryChunkOwner as ze, worldGeometryMapCoordinates as Be } from "./geometryCellCoverage.js";
+import { defaultGeometryRollbackStrategies as Ve, prepareGeometryRollback as He } from "./geometryRollback.js";
+import { RoomGeometryControlPort as Ue } from "./geometryAdminPorts.js";
+import { createGeometryTileArtifact as We, verifyGeometryTileArtifact as Ge } from "./geometryTileArtifact.js";
+import { importTiledGeometry as Ke } from "./geometryImportTiled.js";
+import { importLdtkGeometry as qe } from "./geometryImportLdtk.js";
+import { importVoxGeometry as Je } from "./geometryImportVox.js";
+import { importGltfGeometry as Ye } from "./geometryImportGltf.js";
+import { compareGeometryVersions as Xe } from "./geometryVersionCompare.js";
+export { f as GeometryBoxSchema, p as GeometryChunkAddress3DSchema, n as GeometryChunkAddressSchema, Te as GeometryChunkRequestSchema, Ee as GeometryChunkSnapshotFragmentSchema, ie as GeometryDeltaFragmentSchema, ue as GeometryEditMessageSchema, c as GeometryHeightfieldChunkSchema, ve as GeometryInspectionSchema, ye as GeometryInspectionTableSchema, $ as GeometryManifestFragmentSchema, B as GeometryPatchMetadataSchema, me as GeometryPersistencePort, m as GeometryShapeSchema, h as GeometryShapesChunkSchema, g as GeometrySphereSchema, he as GeometryStaticSourcePort, r as GeometryTileChunkSchema, i as GeometryTileMaterialSchema, a as GeometryTileRunSchema, b as GeometryVoxelChunkSchema, x as GeometryVoxelSectionSchema, xe as RoomGeometryAdministrationPort, Ue as RoomGeometryControlPort, e as RoomGeometryReloadRequestSchema, t as RoomGeometryRollbackRequestSchema, Se as applyGeometryChunkSnapshot, O as applyGeometryEdit, V as applyGeometryPatch, De as captureGeometryChunkRequest, Ce as captureGeometryChunkSnapshot, Oe as captureGeometryChunkSnapshotFragment, G as captureGeometryCompactionStrategies, ae as captureGeometryDeltaFragment, P as captureGeometryDerivationStrategies, k as captureGeometryEditAuthority, A as captureGeometryEditIntent, de as captureGeometryEditMessage, j as captureGeometryEditStrategies, pe as captureGeometryJournalArchiveReference, ee as captureGeometryManifestFragment, J as cmsGeometry, Xe as compareGeometryVersions, T as createGeometryArtifact, we as createGeometryChunkSnapshot, ke as createGeometryChunkSnapshotFragments, oe as createGeometryDeltaFragments, l as createGeometryHeightfieldCodec, u as createGeometryHeightfieldView, H as createGeometryPatch, _ as createGeometryShapesCodec, v as createGeometryShapesView, We as createGeometryTileArtifact, o as createGeometryTileCodec, Z as createGeometryTilePathSearch, D as createGeometryTileView, S as createGeometryVoxelCodec, C as createGeometryVoxelView, Ie as createGeometryWorldTilePathSearch, be as decodeGeometryInspection, U as decodeGeometryPatch, M as defaultGeometryApplyOp, F as defaultGeometryCollisionDerive, K as defaultGeometryCompaction, d as defaultGeometryHeightfieldLimits, z as defaultGeometryMigrateDelta, I as defaultGeometryNavDerive, N as defaultGeometryOpValidator, W as defaultGeometryPatchLimits, Ve as defaultGeometryRollbackStrategies, y as defaultGeometryShapesLimits, s as defaultGeometryTileLimits, Q as defaultGeometryTileNavigationLimits, w as defaultGeometryVoxelLimits, Ae as geometryChunkRequestChannel, je as geometryChunkSnapshotChannel, se as geometryDeltaFragmentBytes, fe as geometryEditChannel, te as geometryManifestFragmentBytes, ne as geometryManifestReliableChannel, ge as geometryPersistenceLayer, ce as geometryReliableChannel, _e as geometryStaticSourceLayer, Ye as importGltfGeometry, qe as importLdtkGeometry, Ke as importTiledGeometry, Je as importVoxGeometry, Y as importedGeometry, R as makeGeometryActorInventory, le as makeGeometryDeltaReceiver, re as makeGeometryManifestReceiver, Me as makeGeometrySnapshotReceiver, Le as makeGeometryWorldView, Ne as overlapsGeometryHeightfieldBox, q as prepareGeometryCompaction, L as prepareGeometryInventory, He as prepareGeometryRollback, X as procedural, Fe as raycastGeometryHeightfield, Pe as sweepGeometryHeightfieldBox, E as verifyGeometryArtifact, Ge as verifyGeometryTileArtifact, Re as worldCellGeometryCoverage, ze as worldGeometryChunkOwner, Be as worldGeometryMapCoordinates };

package/dist/geometryActivation.js

@@ -0,0 +1,81 @@
+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 { admitGeometryChunkForKind as i, geometryArtifactStateCodec as a } from "./geometryArtifacts.js";
+import { captureGeometryOwner as o, captureGeometryPersistenceScope as s, captureGeometryReceipt as c, captureGeometrySubject as l, geometryPersistenceId as u, geometryPersistenceInteger as d } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedBaseline as f, captureGeometryPreparedProfile as p, deriveGeometryPreparedInventory as m } from "./geometryPrepared.js";
+import { captureGeometryActorFrame as h, sealGeometryActivation as g } from "./geometryActorInventory.js";
+import { applyGeometryPatch as _, decodeGeometryPatch as v } from "./geometryPatch.js";
+import { captureRoomSnapshotEffectRunner as y } from "./snapshotBlobIndex.js";
+import { captureGeometryPlayerAdmission as b } from "./geometryPlayerAdmission.js";
+import { Effect as x } from "effect";
+import { HotError as S } from "@voltro/kv/hot/contract";
+// src/geometryActivation.ts
+var C = (C, w, T, E = {}) => {
+	try {
+		let D = r(E, ["maxPatchBytes"], []), O = Object.hasOwn(D, "maxPatchBytes") ? d(D.maxPatchBytes, 512, 16777216) : 262144, k = h(C), A = r(T, [
+			"scope",
+			"owner",
+			"subject",
+			"requestId",
+			"patch",
+			"actualSession"
+		], [
+			"scope",
+			"owner",
+			"subject",
+			"requestId",
+			"patch"
+		]), j = s(A.scope), M = o(A.owner), N = l(A.subject), P = u(A.requestId), F = n(A.patch, O, "geometryActivationPatchBytes"), I = v(F, {
+			maxBytes: O,
+			maxMetadataBytes: Math.min(4096, O - 16)
+		}), L = r(w, [
+			"commit",
+			"observation",
+			"withdrawSubject",
+			"eraseSubject",
+			"close"
+		], ["commit"]).commit, R = {
+			cx: j.cx,
+			cy: j.cy,
+			...j.cz === void 0 ? {} : { cz: j.cz }
+		}, z = f(k, R), B = p(k), V = Object.hasOwn(A, "actualSession") ? b(A.actualSession, j, M, N) : null;
+		if (typeof L != "function" || JSON.stringify(z.scope) !== JSON.stringify(j)) return x.fail(new t({ detail: "Geometry activation escaped its current CPU inventory scope" }));
+		let H = L, U = I.metadata;
+		return U.kind !== j.kind || U.worldId !== j.worldId || U.layerSetId !== j.layerSetId || U.version !== j.version || U.cx !== j.cx || U.cy !== j.cy || U.cz !== j.cz || U.stateSchemaHash !== a(j.kind, B).schemaHash ? x.fail(new t({ detail: "Geometry activation patch differs from its selected scope/layout" })) : (i(j.kind, z.artifact.chunk, B), x.flatMap(x.context(), (n) => x.uninterruptible(x.tryPromise({
+			try: async () => {
+				V?.assertCurrent();
+				let e = y(n), r = U.changed && z.revision === U.revision && z.artifact.blobSha256 === U.blobSha256 && z.artifact.contentSha256 === U.contentSha256, i = k;
+				if (!r) {
+					let e = await _(z.artifact, I, z.revision, B);
+					U.changed && (i = m(k, {
+						scope: j,
+						revision: e.revision,
+						artifact: e.artifact
+					}));
+				}
+				V?.assertCurrent();
+				let a = H({
+					scope: j,
+					owner: M,
+					subject: N,
+					requestId: P,
+					patch: new Uint8Array(F),
+					...V ? { actualSession: V.actualSession } : {}
+				});
+				if (!x.isEffect(a)) throw new t({ detail: "Geometry activation requires an actual server commit Effect" });
+				let o = c(await e(a));
+				if (JSON.stringify(o.scope) !== JSON.stringify(j) || o.requestId !== P || o.baseRevision !== U.baseRevision || o.revision !== U.revision || o.changed !== U.changed || o.blobSha256 !== U.blobSha256 || o.contentSha256 !== U.contentSha256) throw new t({ detail: "Geometry activation did not receive its exact committed SQL result" });
+				return V?.assertCurrent(), h(C), g(C, k, i, o);
+			},
+			catch: (n) => n instanceof e ? n : n instanceof S ? new S({
+				operation: n.operation,
+				key: "geometryActivation",
+				reason: n.reason
+			}) : new t({ detail: "Geometry preparation or committed activation remains unconfirmed" })
+		}))));
+	} catch {
+		return x.fail(new t({ detail: "Geometry activation request or before-frame could not be captured" }));
+	}
+};
+export { C as prepareGeometryActivation };

package/dist/geometryActorInventory.js

@@ -0,0 +1,107 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { captureGeometryPreparedInventory as n } from "./geometryPrepared.js";
+// src/geometryActorInventory.ts
+var r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new WeakMap(), a = /* @__PURE__ */ new WeakMap();
+function o() {
+	throw new t({ detail: "Geometry CPU inventory needs a current genuine confirmed activation" });
+}
+var s = (e) => {
+	let t = n(e), s = {
+		scope: t.scope,
+		current: t,
+		generation: 0,
+		readersFenced: !1,
+		observers: /* @__PURE__ */ new Set()
+	}, c = () => s.current ?? o(), l = Object.freeze({
+		at: (e) => s.readersFenced ? o() : c().at(e),
+		contains: (e) => s.readersFenced ? o() : c().contains(e),
+		activate: (e) => {
+			let t = a.get(e), n = c();
+			if (!t || t.actor !== l) return o();
+			if (n === t.after) return !1;
+			if (n !== t.before || s.generation === 2147483647) return o();
+			s.current = t.after, s.generation++;
+			for (let e of s.observers) e();
+			return !0;
+		},
+		activateVersion: (e) => {
+			let t = r.get(e), n = c();
+			if (!t || t.actor !== l || s.readersFenced) return o();
+			if (n === t.after) return !1;
+			if (n !== t.before || s.generation === 2147483647) return o();
+			s.current = t.after, s.scope = t.after.scope, s.generation++;
+			for (let e of s.observers) e();
+			return !0;
+		},
+		observation: () => Object.freeze({
+			scope: s.scope,
+			generation: s.generation,
+			chunks: s.current?.entries.length ?? 0,
+			accountedBytes: s.current?.accountedBytes ?? 0,
+			closed: s.current === null
+		}),
+		close: () => {
+			s.readersFenced = !0, s.current = null;
+			for (let e of s.observers) e();
+			s.observers.clear();
+		}
+	});
+	return i.set(l, s), l;
+}, c = (e) => {
+	let t = i.get(e);
+	if (!t) return o();
+	t.readersFenced = !0;
+	for (let e of t.observers) e();
+	t.observers.clear();
+}, l = (e) => {
+	let t = i.get(e);
+	return !t || t.readersFenced || !t.current ? o() : t.current;
+}, u = (e) => i.get(e)?.current ?? o(), d = (t, n) => {
+	let r = i.get(t);
+	if (!r?.current || r.readersFenced) return o();
+	if (r.observers.size >= 64) throw new e({
+		budget: "geometryNavigationReaders",
+		limit: 64
+	});
+	return r.observers.add(n), () => {
+		r.observers.delete(n);
+	};
+}, f = (e, t, r, i) => {
+	u(e), n(t), n(r);
+	let o = Object.freeze({
+		_tag: "GeometryActivation",
+		receipt: i
+	});
+	return a.set(o, {
+		actor: e,
+		before: t,
+		after: r
+	}), o;
+}, p = (e, t, i, a) => {
+	u(e), n(t), n(i);
+	let s = t.scope, c = i.scope;
+	if (s.version === c.version || s.tenantId !== c.tenantId || s.kind !== c.kind || s.worldId !== c.worldId || s.layerSetId !== c.layerSetId) return o();
+	let l = Object.freeze({
+		_tag: "GeometryVersionActivation",
+		receipts: a
+	});
+	return r.set(l, {
+		actor: e,
+		before: t,
+		after: i
+	}), l;
+}, m = (e, t) => {
+	let n = a.get(t), r = l(e);
+	return !n || n.actor !== e || r !== n.before && r !== n.after ? o() : t;
+}, h = (e, t) => {
+	let n = r.get(t), i = l(e);
+	return !n || n.actor !== e || i !== n.before && i !== n.after ? o() : t;
+}, g = (e, t) => {
+	h(e, t);
+	let n = r.get(t);
+	return Object.freeze({
+		before: n.before,
+		after: n.after
+	});
+};
+export { m as captureGeometryActivation, u as captureGeometryActorFrame, l as captureGeometryActorReadFrame, h as captureGeometryVersionActivation, g as captureGeometryVersionActivationDetails, c as fenceGeometryActorReaders, s as makeGeometryActorInventory, d as observeGeometryActorFrameChange, f as sealGeometryActivation, p as sealGeometryVersionActivation };

package/dist/geometryAdminClient.js

@@ -0,0 +1,86 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceId as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadRequest as a, captureRoomGeometryRollbackRequest as o } from "./geometryAdminData.js";
+// src/geometryAdminClient.ts
+var s = () => new t({ detail: "Geometry administrative outcome remains unconfirmed; repeat the exact request" }), c = (t) => {
+	let c = n(t, [
+		"caller",
+		"maxRetainedRequests",
+		"maxRetainedBytes"
+	], ["caller"]), l = n(c.caller, ["call"]), u = Object.hasOwn(c, "maxRetainedRequests") ? i(c.maxRetainedRequests, 1, 4096) : 32, d = Object.hasOwn(c, "maxRetainedBytes") ? i(c.maxRetainedBytes, 512, 16777216) : 65536;
+	if (typeof l.call != "function") throw s();
+	let f = l.call.bind(c.caller), p = /* @__PURE__ */ new Map(), m = "open", h = 0, g = null, _ = (t, i, c, l) => {
+		let g, _, v;
+		try {
+			let e = r(i), n = t === "rooms.geometry.reload" ? a(c) : o(c);
+			if (l !== void 0 && (!(l instanceof AbortSignal) || l.aborted)) throw s();
+			g = Object.freeze({
+				roomId: e,
+				request: n
+			}), v = n.requestId, _ = JSON.stringify([t, g]);
+		} catch {
+			return Promise.reject(s());
+		}
+		if (m === "closed") return Promise.reject(s());
+		let y = p.get(v);
+		if (y && y.fingerprint !== _) return Promise.reject(s());
+		if (y?.task) return y.task;
+		if (!y) {
+			if (m !== "open") return Promise.reject(s());
+			let n = new TextEncoder().encode(_).length;
+			if (p.size >= u) return Promise.reject(new e({
+				budget: "geometryAdminRetainedRequests",
+				limit: u
+			}));
+			if (n > d - h) return Promise.reject(new e({
+				budget: "geometryAdminRetainedBytes",
+				limit: d
+			}));
+			y = {
+				tag: t,
+				input: g,
+				fingerprint: _,
+				bytes: n,
+				task: null
+			}, p.set(v, y), h += n;
+		}
+		let b = y, x = Promise.resolve().then(async () => {
+			let e = f(b.tag, b.input, Object.freeze(l === void 0 ? {} : { signal: l }));
+			if (!(e instanceof Promise) || n(await e, ["ok"]).ok !== !0 || p.get(v) !== b) throw s();
+			p.delete(v), h -= b.bytes;
+		}).catch(() => {
+			throw s();
+		});
+		return b.task = x, x.then(() => {
+			b.task === x && (b.task = null);
+		}, () => {
+			b.task === x && (b.task = null);
+		}), x;
+	};
+	return Object.freeze({
+		reload: (e, t, n) => _("rooms.geometry.reload", e, t, n),
+		rollback: (e, t, n) => _("rooms.geometry.rollback", e, t, n),
+		observation: () => Object.freeze({
+			phase: m,
+			pending: [...p.values()].filter((e) => e.task !== null).length,
+			unconfirmed: [...p.values()].filter((e) => e.task === null).length,
+			retainedBytes: h
+		}),
+		close: () => {
+			if (m === "closed") return Promise.resolve();
+			if (g) return g;
+			m = "draining";
+			let e = Promise.resolve().then(async () => {
+				if (await Promise.allSettled([...p.values()].flatMap((e) => e.task === null ? [] : [e.task])), p.size !== 0) throw s();
+				m = "closed";
+			});
+			return g = e, e.then(() => {
+				g = null;
+			}, () => {
+				g = null;
+			}), e;
+		}
+	});
+};
+export { c as makeGeometryAdminClient };

package/dist/geometryAdminData.js

@@ -0,0 +1,31 @@
+import { geometryOwnData as e } from "./geometryTileCodec.js";
+import { captureGeometrySubject as t, geometryPersistenceId as n, geometryPersistenceInteger as r } from "./geometryPersistenceData.js";
+// src/geometryAdminData.ts
+var i = (t) => {
+	let r = e(t, ["version", "requestId"]);
+	return Object.freeze({
+		version: n(r.version, 96),
+		requestId: n(r.requestId, 126)
+	});
+}, a = (i) => {
+	let a = e(i, [
+		"cx",
+		"cy",
+		"cz",
+		"target",
+		"requestId"
+	], [
+		"cx",
+		"cy",
+		"target",
+		"requestId"
+	]);
+	return Object.freeze({
+		cx: r(a.cx, -2147483648),
+		cy: r(a.cy, -2147483648),
+		...Object.hasOwn(a, "cz") ? { cz: r(a.cz, -2147483648) } : {},
+		target: a.target === null ? null : t(a.target),
+		requestId: n(a.requestId)
+	});
+};
+export { i as captureRoomGeometryReloadRequest, a as captureRoomGeometryRollbackRequest };

package/dist/geometryAdminFixtures.js

@@ -0,0 +1,49 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomGeometryAdministrationPort as t } from "./geometryAdministrationPorts.js";
+import { RoomGeometryControlPort as n } from "./geometryAdminPorts.js";
+import { Effect as r, Layer as i, Result as a } from "effect";
+// src/geometryAdminFixtures.ts
+var o = () => r.fail(new e({ detail: "Geometry administrative carrier fixture is explicitly unconfigured" })), s = i.succeed(n, Object.freeze({
+	reload: o,
+	rollback: o
+})), c = {
+	kind: "port",
+	tag: n,
+	fakeLayer: s,
+	probe: {
+		run: () => r.gen(function* () {
+			let e = yield* n, t = yield* r.result(e.reload("host", "room", {
+				version: "v2",
+				requestId: "fixture"
+			}, {
+				type: "user",
+				id: "operator",
+				tenantId: "tenant"
+			}));
+			return a.isFailure(t) ? t.failure._tag : "unexpectedSuccess";
+		}).pipe(r.provide(s)),
+		expected: "ProtocolError"
+	}
+}, l = i.succeed(t, Object.freeze({
+	reload: o,
+	rollback: o
+})), u = {
+	kind: "port",
+	tag: t,
+	fakeLayer: l,
+	probe: {
+		run: () => r.gen(function* () {
+			let e = yield* t, n = yield* r.result(e.reload("room", {
+				version: "v2",
+				requestId: "fixture"
+			}, {
+				type: "user",
+				id: "operator",
+				tenantId: "tenant"
+			}));
+			return a.isFailure(n) ? n.failure._tag : "unexpectedSuccess";
+		}).pipe(r.provide(l)),
+		expected: "ProtocolError"
+	}
+};
+export { l as roomGeometryAdministrationFakeLayer, u as roomGeometryAdministrationPortFixture, s as roomGeometryControlFakeLayer, c as roomGeometryControlPortFixture };

package/dist/geometryAdminPorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/geometryAdminPorts.ts
+var t = class extends e.Service()("@voltro/RoomGeometryControlPort") {};
+export { t as RoomGeometryControlPort };

package/dist/geometryAdminRpc.js

@@ -0,0 +1,57 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { RoomGeometryChunksSchema as n, RoomGeometryReloadRequestSchema as r, RoomGeometryRollbackRequestSchema as i } from "./geometryAdminSchemas.js";
+import { defineAction as a, defineQuery as o } from "@voltro/protocol";
+import { Schema as s } from "effect";
+// src/geometryAdminRpc.ts
+var c = s.String.pipe(s.check(s.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/)), s.check(s.isMaxLength(191))), l = a({
+	name: "rooms.geometry.reload",
+	input: s.Struct({
+		roomId: c,
+		request: r
+	}),
+	output: s.Struct({ ok: s.Literal(!0) }),
+	error: s.Union([t, e]),
+	guards: [{ scope: "rooms:operate" }]
+}), u = a({
+	name: "rooms.geometry.rollback",
+	input: s.Struct({
+		roomId: c,
+		request: i
+	}),
+	output: s.Struct({ ok: s.Literal(!0) }),
+	error: s.Union([t, e]),
+	guards: [{ scope: "rooms:operate" }]
+}), d = o({
+	name: "rooms.geometry.chunks",
+	input: s.Struct({ roomId: c }),
+	output: n,
+	error: s.Union([t, e]),
+	source: "_voltro_geo_chunk_deltas",
+	guards: [{ scope: "rooms:operate" }]
+}), f = Object.freeze([
+	{
+		tag: "rooms.geometry.reload",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "geometryReloadDescriptor"
+		}
+	},
+	{
+		tag: "rooms.geometry.rollback",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "geometryRollbackDescriptor"
+		}
+	},
+	{
+		tag: "rooms.geometry.chunks",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "geometryChunksDescriptor"
+		}
+	}
+]);
+export { f as geometryAdminRpcImports, d as geometryChunksDescriptor, l as geometryReloadDescriptor, u as geometryRollbackDescriptor };

package/dist/geometryAdminRpcRoutes.js

@@ -0,0 +1,48 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryChunksDescriptor as t, geometryReloadDescriptor as n, geometryRollbackDescriptor as r } from "./geometryAdminRpc.js";
+import { geometryOwnData as i } from "./geometryTileCodec.js";
+import { geometryPersistenceId as a } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadRequest as o, captureRoomGeometryRollbackRequest as s } from "./geometryAdminData.js";
+import { Effect as c } from "effect";
+// src/geometryAdminRpcRoutes.ts
+var l = (l) => [
+	{
+		...n,
+		execute: (t, n) => {
+			try {
+				let r = i(t, ["roomId", "request"]), s = a(r.roomId), u = o(r.request), d = l.reload(s, u, n.request.subject);
+				if (!c.isEffect(d)) throw new e({ detail: "Actual geometry administration Effect required" });
+				return d.pipe(c.flatMap((t) => t === void 0 ? c.succeed({ ok: !0 }) : c.fail(new e({ detail: "Geometry reload did not confirm completion" }))));
+			} catch {
+				return c.fail(new e({ detail: "Geometry reload intention refused" }));
+			}
+		}
+	},
+	{
+		...r,
+		execute: (t, n) => {
+			try {
+				let r = i(t, ["roomId", "request"]), o = a(r.roomId), u = s(r.request), d = l.rollback(o, u, n.request.subject);
+				if (!c.isEffect(d)) throw new e({ detail: "Actual geometry administration Effect required" });
+				return d.pipe(c.flatMap((t) => t === void 0 ? c.succeed({ ok: !0 }) : c.fail(new e({ detail: "Geometry rollback did not confirm completion" }))));
+			} catch {
+				return c.fail(new e({ detail: "Geometry rollback intention refused" }));
+			}
+		}
+	},
+	{
+		...t,
+		execute: (t, n) => {
+			try {
+				let r = a(i(t, ["roomId"]).roomId);
+				if (!l.chunks) return c.fail(new e({ detail: "The geometry chunk view is not installed" }));
+				let o = l.chunks(r, n.request.subject);
+				if (!c.isEffect(o)) throw new e({ detail: "Actual geometry administration Effect required" });
+				return o;
+			} catch {
+				return c.fail(new e({ detail: "Geometry chunk view request refused" }));
+			}
+		}
+	}
+];
+export { l as geometryAdminRpcRoutes };

package/dist/geometryAdminSchemas.js

@@ -0,0 +1,38 @@
+import { Schema as e } from "effect";
+// src/geometryAdminSchemas.ts
+var t = e.String.pipe(e.check(e.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/)), e.check(e.isMaxLength(191))), n = e.Int.pipe(e.check(e.isBetween({
+	minimum: -2147483648,
+	maximum: 2147483647
+}))), r = e.Int.pipe(e.check(e.isBetween({
+	minimum: -2147483648,
+	maximum: 2147483647
+}))), i = e.Struct({
+	roomId: t,
+	worldId: t,
+	zoneId: t,
+	cellId: t,
+	truncated: e.Boolean,
+	chunks: e.Array(e.Struct({
+		cx: r,
+		cy: r,
+		cz: e.optional(r),
+		layerSetId: t,
+		version: t,
+		revision: e.Int.pipe(e.check(e.isGreaterThanOrEqualTo(0))),
+		changed: e.Boolean,
+		updatedAt: e.Int.pipe(e.check(e.isGreaterThanOrEqualTo(0)))
+	}))
+}), a = e.Struct({
+	version: t.pipe(e.check(e.isMaxLength(96))),
+	requestId: t.pipe(e.check(e.isMaxLength(126)))
+}), o = e.Struct({
+	cx: n,
+	cy: n,
+	cz: e.optional(n),
+	target: e.NullOr(e.Struct({
+		id: t,
+		kind: e.Literals(["user", "guest"])
+	})),
+	requestId: t
+});
+export { i as RoomGeometryChunksSchema, a as RoomGeometryReloadRequestSchema, o as RoomGeometryRollbackRequestSchema };