@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryDerivationFixtures.js

@@ -0,0 +1,140 @@
+import { createGeometryTileCodec as e } from "./geometryTileCodec.js";
+import { createGeometryArtifact as t } from "./geometryArtifacts.js";
+import { defaultGeometryCollisionDerive as n, defaultGeometryNavDerive as r } from "./geometryDerivationStrategies.js";
+import { prepareGeometryInventory as i } from "./geometryPrepared.js";
+import { makeGeometryActorInventory as a } from "./geometryActorInventory.js";
+import { cmsGeometry as o } from "./worldGeometry.js";
+import { defineWorld as s, rect as c } from "./world.js";
+import { createGeometryWorldTilePathSearch as l, makeGeometryWorldView as u } from "./geometryWorldView.js";
+import { Effect as d } from "effect";
+// src/geometryDerivationFixtures.ts
+var f = () => e().create({
+	address: {
+		worldId: "derivation-fixture",
+		layerSetId: "layer",
+		cx: 0,
+		cy: 0
+	},
+	version: "v1",
+	width: 1,
+	height: 1,
+	tileSizeRaw: 65536,
+	cells: [{
+		key: "air",
+		solid: !1
+	}]
+}), p = (e, n) => d.promise(async () => {
+	let r = s({
+		name: "derivation-fixture",
+		map: { bounds: c(0, 0, 2, 2) },
+		zones: [{
+			id: "zone",
+			room: "cell",
+			bounds: c(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: o("world:derivation"),
+			chunkSize: 1,
+			strategies: e
+		}
+	}), d = await t(f()), p = {
+		tenantId: "tenant",
+		kind: d.chunk.kind,
+		worldId: r.name,
+		layerSetId: "layer",
+		version: "v1"
+	}, { collisionDerive: m, navDerive: h } = r.geometry.strategies, g = a(i(p, [{
+		scope: {
+			...p,
+			cx: 0,
+			cy: 0
+		},
+		revision: 0,
+		artifact: d
+	}], { strategies: {
+		collisionDerive: m,
+		navDerive: h
+	} }));
+	try {
+		let e = u(r, g);
+		if (!n) return e.solidAtRaw({
+			xRaw: 0,
+			yRaw: 0
+		});
+		let t = l(e, {
+			minCx: 0,
+			minCy: 0,
+			chunksX: 1,
+			chunksY: 1
+		}, {
+			x: 0,
+			y: 0
+		}, {
+			x: 0,
+			y: 0
+		});
+		try {
+			return t.advance(), t.status;
+		} finally {
+			t.cancel();
+		}
+	} finally {
+		g.close();
+	}
+}), m = {
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => p({}, !1),
+		expected: !1
+	},
+	overrideProbe: {
+		run: () => p({ collisionDerive: (t) => {
+			if (t.chunk.kind !== "2d-tiles") throw Error("Actual native tile fixture required");
+			return e().capture({
+				...t.chunk,
+				palette: [{
+					key: "air",
+					solid: !0
+				}]
+			});
+		} }, !1),
+		expected: !0
+	}
+}, h = {
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => p({}, !0),
+		expected: "found"
+	},
+	overrideProbe: {
+		run: () => p({ navDerive: (t) => {
+			if (t.chunk.kind !== "2d-tiles") throw Error("Actual native tile fixture required");
+			return e().capture({
+				...t.chunk,
+				palette: [{
+					key: "air",
+					solid: !0
+				}]
+			});
+		} }, !0),
+		expected: "unreachable"
+	}
+};
+export { m as geometryCollisionDeriveSlotFixture, h as geometryNavDeriveSlotFixture };

package/dist/geometryDerivationStrategies.js

@@ -0,0 +1,26 @@
+import { ProtocolError as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { admitGeometryEditResult as n } from "./geometryEdits.js";
+// src/geometryDerivationStrategies.ts
+var r = (e) => e.chunk, i = (e) => e.chunk.kind === "2d-tiles" ? e.chunk : null;
+function a() {
+	throw new e({ detail: "Geometry derivation requires synchronous native data under the original scope/layout/profile" });
+}
+var o = (e = {}) => {
+	let n = t(e, ["collisionDerive", "navDerive"], []), o = Object.hasOwn(n, "collisionDerive") ? n.collisionDerive : r, s = Object.hasOwn(n, "navDerive") ? n.navDerive : i;
+	return typeof o != "function" || typeof s != "function" ? a() : Object.freeze({
+		collisionDerive: o,
+		navDerive: s
+	});
+}, s = (e, t) => {
+	let r = t(e);
+	return r instanceof Promise ? (r.catch(() => void 0), a()) : r === e.chunk ? e.chunk : n(e.chunk, r, e.codecLimits);
+}, c = (e, t) => {
+	let r = t(e);
+	if (r === null) return null;
+	if (r instanceof Promise) return r.catch(() => void 0), a();
+	if (e.chunk.kind !== "2d-tiles") return a();
+	let i = r === e.chunk ? e.chunk : n(e.chunk, r, e.codecLimits);
+	return i.kind === "2d-tiles" ? i : a();
+};
+export { o as captureGeometryDerivationStrategies, r as defaultGeometryCollisionDerive, i as defaultGeometryNavDerive, s as deriveGeometryCollision, c as deriveGeometryNavigation };

package/dist/geometryDigest.js

@@ -0,0 +1,12 @@
+import { geometryTileRefusal as e } from "./geometryTileCodec.js";
+// src/geometryDigest.ts
+var t = async (t) => {
+	try {
+		if (!globalThis.crypto?.subtle) return e();
+		let n = new Uint8Array(t), r = await globalThis.crypto.subtle.digest("SHA-256", n.buffer);
+		return !(r instanceof ArrayBuffer) || r.byteLength !== 32 ? e() : [...new Uint8Array(r)].map((e) => e.toString(16).padStart(2, "0")).join("");
+	} catch {
+		return e();
+	}
+};
+export { t as geometrySha256 };

package/dist/geometryEditChannel.js

@@ -0,0 +1,69 @@
+import { geometryOwnData as e } from "./geometryTileCodec.js";
+import { geometryPersistenceId as t, geometryPersistenceInteger as n } from "./geometryPersistenceData.js";
+import { captureGeometryEditIntent as r } from "./geometryEdits.js";
+import { Schema as i } from "effect";
+// src/geometryEditChannel.ts
+var a = i.Union([
+	i.Struct({
+		op: i.Literal("setTile"),
+		x: i.Int,
+		y: i.Int,
+		material: i.String
+	}),
+	i.Struct({
+		op: i.Literal("raiseHeight"),
+		x: i.Int,
+		y: i.Int,
+		units: i.Int
+	}),
+	i.Struct({
+		op: i.Literal("setVoxel"),
+		x: i.Int,
+		y: i.Int,
+		z: i.Int,
+		material: i.String
+	}),
+	i.Struct({
+		op: i.Literal("placeShape"),
+		template: i.String,
+		xRaw: i.Int,
+		yRaw: i.Int,
+		zRaw: i.Int
+	}),
+	i.Struct({
+		op: i.Literal("removeShape"),
+		id: i.String
+	})
+]), o = i.Struct({
+	requestId: i.String,
+	coordinate: i.Struct({
+		cx: i.Int,
+		cy: i.Int,
+		cz: i.optional(i.Int)
+	}),
+	intent: a
+}), s = Object.freeze({
+	schema: o,
+	direction: "client",
+	reliable: !0
+}), c = (i) => {
+	let a = e(i, [
+		"requestId",
+		"coordinate",
+		"intent"
+	]), o = e(a.coordinate, [
+		"cx",
+		"cy",
+		"cz"
+	], ["cx", "cy"]);
+	return Object.freeze({
+		requestId: t(a.requestId, 96),
+		coordinate: Object.freeze({
+			cx: n(o.cx, -2147483648, 2147483647),
+			cy: n(o.cy, -2147483648, 2147483647),
+			...Object.hasOwn(o, "cz") ? { cz: n(o.cz, -2147483648, 2147483647) } : {}
+		}),
+		intent: r(a.intent)
+	});
+};
+export { o as GeometryEditMessageSchema, c as captureGeometryEditMessage, s as geometryEditChannel };

package/dist/geometryEditIngress.js

@@ -0,0 +1,262 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryOwner as r, captureGeometryPrivacyTarget as i, captureGeometryReceipt as a, captureGeometrySubject as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedCoordinate as c, captureGeometryPreparedScope as l } from "./geometryPrepared.js";
+import { captureGeometryEditMessage as u } from "./geometryEditChannel.js";
+import { captureRoomAdmittedSessionReader as d } from "./serverSession.js";
+import { Effect as f } from "effect";
+// src/geometryEditIngress.ts
+var p = () => new t({ detail: "Geometry native channel intent remains unconfirmed" }), m = (t, m) => {
+	let h = n(m, [
+		"scope",
+		"owner",
+		"resolveSubject",
+		"maxPending",
+		"maxPerPump",
+		"maxSubjectFences"
+	], [
+		"scope",
+		"owner",
+		"resolveSubject"
+	]), g = l(h.scope), _ = g.tenantId, v = r(h.owner), y = Object.hasOwn(h, "maxPending") ? s(h.maxPending, 1, 4096) : 64, b = Object.hasOwn(h, "maxPerPump") ? s(h.maxPerPump, 1, y) : Math.min(16, y), x = Object.hasOwn(h, "maxSubjectFences") ? s(h.maxSubjectFences, 1, 65536) : 4096, S = n(t, [
+		"queue",
+		"pump",
+		"discardUnsubmitted",
+		"withdrawSubject",
+		"eraseSubject",
+		"close",
+		"observation",
+		"rejected"
+	], [
+		"queue",
+		"pump",
+		"discardUnsubmitted",
+		"withdrawSubject",
+		"eraseSubject",
+		"close",
+		"observation"
+	]);
+	if (typeof h.resolveSubject != "function" || typeof S.queue != "function" || typeof S.pump != "function" || typeof S.discardUnsubmitted != "function" || typeof S.withdrawSubject != "function" || typeof S.eraseSubject != "function") throw p();
+	let C = h.resolveSubject.bind(m), w = S.queue.bind(t), T = S.pump.bind(t), E = S.discardUnsubmitted.bind(t), D = S.withdrawSubject.bind(t), O = S.eraseSubject.bind(t), k = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Set(), j = /* @__PURE__ */ new Set(), M = !1, N = !1, P = !1, F = null, I = null, L = null, R = null, z = null, B = (e) => {
+		let t = d(e), n = t.identity();
+		if (!n || n.tenantId !== _ || n.roomId !== v.roomId || n.epoch !== v.epoch || n.role !== "player") throw p();
+		return {
+			reader: t,
+			evidence: n,
+			scope: Object.freeze({
+				tenantId: _,
+				roomId: v.roomId,
+				epoch: v.epoch,
+				sessionId: n.sessionId,
+				subjectId: n.subjectId
+			})
+		};
+	}, V = (t) => f.uninterruptible(f.tryPromise({
+		try: t,
+		catch: (t) => t instanceof e ? t : p()
+	})), H = (e) => {
+		let t = i(e);
+		if (t.tenantId !== _) throw p();
+		return t;
+	}, U = (e) => JSON.stringify([
+		_,
+		e.kind,
+		e.id
+	]), W = async (t) => {
+		if (P) return;
+		let n = U(t.subject);
+		if (!A.has(n)) {
+			if (A.size >= x) throw new e({
+				budget: "geometryIngressSubjectFences",
+				limit: x
+			});
+			A.add(n);
+		}
+		let r = D(t);
+		if (!f.isEffect(r) || await f.runPromise(r) !== void 0) throw p();
+		I && await I;
+	};
+	return Object.freeze({
+		observation: () => Object.freeze({
+			pending: k.size,
+			active: M || L !== null,
+			closing: N,
+			closed: P,
+			subjectFences: A.size
+		}),
+		fence: () => {
+			N = !0;
+		},
+		stage: (t, n) => {
+			if (P) throw p();
+			let r = u(n), i = B(t), a = JSON.stringify([
+				_,
+				v,
+				i.scope.subjectId,
+				r
+			]), o = k.get(r.requestId);
+			if (R === r.requestId || z === i.scope.subjectId || o?.subject && A.has(U(o.subject))) throw p();
+			if (c(g, r.coordinate), o) {
+				if (F === r.requestId || o.fingerprint !== a) throw p();
+				return o.actualSession = t, o.admittedSubject = i.scope, "retained";
+			}
+			if (N || k.size >= y) throw new e({
+				budget: "geometryChannelIntents",
+				limit: y
+			});
+			return k.set(r.requestId, {
+				message: r,
+				fingerprint: a,
+				actualSession: t,
+				admittedSubject: i.scope,
+				subject: null
+			}), "queued";
+		},
+		pump: () => V(async () => {
+			if (P || M || L) throw p();
+			M = !0;
+			let e;
+			I = new Promise((t) => {
+				e = t;
+			});
+			try {
+				for (let [e, t] of [...k].slice(0, b)) {
+					F = e;
+					let n = B(t.actualSession), r = C(n.scope);
+					if (!f.isEffect(r)) throw p();
+					let i = o(await f.runPromise(r));
+					if (A.has(U(i)) || i.id !== n.scope.subjectId || JSON.stringify(n.reader.identity()) !== JSON.stringify(n.evidence)) throw p();
+					let a = w({
+						...t.message,
+						owner: v,
+						subject: i,
+						actualSession: t.actualSession
+					});
+					if (a === "rejected") k.delete(e);
+					else {
+						if (a !== "queued" && a !== "retained") throw p();
+						t.subject = i;
+					}
+				}
+				F = null;
+				let e = T();
+				if (!f.isEffect(e)) throw p();
+				let n = await f.runPromise(e);
+				if (!Array.isArray(n) || n.length > y) throw p();
+				let r = /* @__PURE__ */ new Set(), i = [];
+				for (let e of n) {
+					let t = a(e), n = k.get(t.requestId);
+					if (!n || r.has(t.requestId) || t.scope.tenantId !== _ || t.scope.worldId !== g.worldId || t.scope.kind !== g.kind || t.scope.version !== g.version || t.scope.layerSetId !== g.layerSetId || t.scope.cx !== n.message.coordinate.cx || t.scope.cy !== n.message.coordinate.cy || t.scope.cz !== n.message.coordinate.cz) throw p();
+					r.add(t.requestId), i.push(t);
+				}
+				for (let e of i) k.delete(e.requestId);
+				if (typeof S.rejected == "function") for (let e of [...k.keys()]) S.rejected.call(t, e) && k.delete(e);
+				return Object.freeze(i);
+			} finally {
+				M = !1, F = null, e?.(), I = null;
+			}
+		}),
+		discardUnsubmitted: (e) => {
+			let t;
+			try {
+				if (t = i(e), t.tenantId !== _) throw p();
+			} catch {
+				return f.fail(p());
+			}
+			return V(async () => {
+				if (P || M || L) throw p();
+				let e = k.get(t.requestId);
+				if (!e) return !1;
+				if (e.admittedSubject.subjectId !== t.subject.id) throw p();
+				let n;
+				L = new Promise((e) => {
+					n = e;
+				}), R = t.requestId;
+				try {
+					let n = e.subject;
+					if (!n) {
+						let t = C(e.admittedSubject);
+						if (!f.isEffect(t)) throw p();
+						n = o(await f.runPromise(t));
+					}
+					if (n.id !== t.subject.id || n.kind !== t.subject.kind || M || k.get(t.requestId) !== e) throw p();
+					let r = E(t);
+					if (!f.isEffect(r)) throw p();
+					let i = await f.runPromise(r);
+					if (typeof i != "boolean" || e.subject !== null && i !== !0) throw p();
+					return k.delete(t.requestId), !0;
+				} finally {
+					R = null, n?.(), L = null;
+				}
+			});
+		},
+		withdrawSubject: (t) => {
+			try {
+				let n = H(t);
+				return V(async () => {
+					if (j.size >= y * 2) throw new e({
+						budget: "geometryIngressWithdrawals",
+						limit: y * 2
+					});
+					let t = W(n);
+					j.add(t);
+					try {
+						await t;
+					} finally {
+						j.delete(t);
+					}
+				});
+			} catch {
+				return f.fail(p());
+			}
+		},
+		eraseSubject: (e) => {
+			let t;
+			try {
+				t = H(e);
+			} catch {
+				return f.fail(p());
+			}
+			return V(async () => {
+				if (P || L) throw p();
+				let e;
+				L = new Promise((t) => {
+					e = t;
+				}), z = t.subject.id;
+				try {
+					await W(t);
+					let e = [];
+					for (let [n, r] of k) if (r.admittedSubject.subjectId === t.subject.id) {
+						let i = r.subject;
+						if (!i) {
+							let e = C(r.admittedSubject);
+							if (!f.isEffect(e)) throw p();
+							i = o(await f.runPromise(e));
+						}
+						if (i.id !== r.admittedSubject.subjectId) throw p();
+						i.kind === t.subject.kind && e.push([n, r]);
+					}
+					let n = O(t);
+					if (!f.isEffect(n) || await f.runPromise(n) !== void 0) throw p();
+					for (let [t, n] of e) {
+						if (k.get(t) !== n) throw p();
+						k.delete(t);
+					}
+				} finally {
+					z = null, e?.(), L = null;
+				}
+			});
+		},
+		close: () => V(async () => {
+			if (!P) {
+				if (N = !0, await Promise.all([
+					I,
+					L,
+					...j
+				].filter((e) => e !== null)), k.size) throw p();
+				A.clear(), P = !0;
+			}
+		})
+	});
+};
+export { m as makeGeometryEditIngress };