@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryWorldMetadata.js

@@ -0,0 +1,37 @@
+import { defaultGeometryApplyOp as e, defaultGeometryOpValidator as t } from "./geometryEdits.js";
+import { defaultGeometryCollisionDerive as n, defaultGeometryNavDerive as r } from "./geometryDerivationStrategies.js";
+import { defaultGeometryMigrateDelta as i } from "./geometryMigrationStrategies.js";
+import { defaultGeometryCompaction as a } from "./geometryCompactionStrategies.js";
+import { captureWorldCatalog as o } from "./world.js";
+// src/geometryWorldMetadata.ts
+var s = (s) => {
+	let c = {
+		opValidator: t,
+		applyOp: e,
+		collisionDerive: n,
+		navDerive: r,
+		compaction: a,
+		migrateDelta: i
+	};
+	return Object.freeze(o(s).flatMap((e) => {
+		let t = e.geometry;
+		if (!t) return [];
+		let n = Object.keys(c).filter((e) => t.strategies[e] !== c[e]);
+		return [Object.freeze({
+			worldId: e.name,
+			kind: t.kind,
+			bounds: e.map.bounds,
+			rooms: Object.freeze([...new Set(e.zones.map((e) => e.room))].sort()),
+			chunkSizeRaw: t.chunkSizeRaw,
+			sourceKind: t.static.kind,
+			dynamic: t.dynamic,
+			collision: t.collision,
+			nav: t.nav,
+			streaming: t.streaming,
+			lod: t.lod,
+			budgets: t.budgets,
+			nativeStrategies: Object.freeze(n)
+		})];
+	}));
+};
+export { s as geometryWorldMetadata };

package/dist/geometryWorldStrategyFixtures.js

@@ -0,0 +1,126 @@
+import { createGeometryTileCodec as e } from "./geometryTileCodec.js";
+import { createGeometryTileView as t } from "./geometryTileView.js";
+import { applyGeometryEdit as n, defaultGeometryApplyOp as r, defaultGeometryOpValidator as i } from "./geometryEdits.js";
+import { cmsGeometry as a } from "./worldGeometry.js";
+import { defineWorld as o, rect as s } from "./world.js";
+import { Effect as c } from "effect";
+// src/geometryWorldStrategyFixtures.ts
+var l = (e = {}) => o({
+	name: "geometry-slot-fixture",
+	map: { bounds: s(0, 0, 2, 2) },
+	zones: [{
+		id: "zone",
+		room: "cell",
+		bounds: s(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: a("world:slots"),
+		chunkSize: 2,
+		dynamic: { enabled: !0 },
+		strategies: e
+	}
+}), u = () => ({
+	chunk: e().create({
+		address: {
+			worldId: "geometry-slot-fixture",
+			layerSetId: "layer",
+			cx: 0,
+			cy: 0
+		},
+		version: "v1",
+		width: 1,
+		height: 1,
+		tileSizeRaw: 65536,
+		cells: [{
+			key: "air",
+			solid: !1
+		}]
+	}),
+	intent: {
+		op: "setTile",
+		x: 0,
+		y: 0,
+		material: "stone"
+	},
+	placementId: "fixture",
+	authority: {
+		dynamicEnabled: !0,
+		ownsChunk: !0,
+		canBuild: !0,
+		cooldownReady: !0,
+		remainingOps: 1,
+		maxReachRaw: 131072,
+		maxHeightUnits: 1,
+		position: {
+			xRaw: 0,
+			yRaw: 0,
+			zRaw: 0
+		},
+		materials: [{
+			key: "air",
+			solid: !1
+		}, {
+			key: "stone",
+			solid: !0
+		}],
+		shapes: []
+	}
+}), d = (e) => {
+	let { opValidator: t, applyOp: r } = e.geometry.strategies, i = n(u(), {
+		opValidator: t,
+		applyOp: r
+	});
+	if (i.kind !== "2d-tiles") throw Error("Actual native tile fixture required");
+	return i;
+}, f = {
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => c.sync(() => (d(l()), "accepted")),
+		expected: "accepted"
+	},
+	overrideProbe: {
+		run: () => c.sync(() => {
+			let e = l({ opValidator: (e) => {
+				throw i(e), Error("fixture-world-rule-refused");
+			} });
+			try {
+				return d(e), "accepted";
+			} catch (e) {
+				if (e instanceof Error && e.message === "fixture-world-rule-refused") return "custom-refused";
+				throw e;
+			}
+		}),
+		expected: "custom-refused"
+	}
+}, p = {
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => c.sync(() => t(d(l())).solidAt(0, 0)),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => c.sync(() => {
+			let e = l({ applyOp: (e) => e.chunk });
+			return t(d(e)).solidAt(0, 0);
+		}),
+		expected: !1
+	}
+};
+export { p as geometryWorldApplyOpSlotFixture, f as geometryWorldOpValidatorSlotFixture };

package/dist/geometryWorldView.js

@@ -0,0 +1,306 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { createGeometryTileCodec as n, geometryOwnData as r } from "./geometryTileCodec.js";
+import { createGeometryTileView as i } from "./geometryTileView.js";
+import { captureGeometryActorReadFrame as a, observeGeometryActorFrameChange as o } from "./geometryActorInventory.js";
+import { createGeometryTilePathSearch as s } from "./geometryTileNavigation.js";
+import { captureWorldCatalog as c } from "./world.js";
+import { raycastPreparedGeometryShapes as l } from "./geometryShapeRaycast.js";
+import { collidePreparedGeometryTiles as u } from "./geometryTileCollision.js";
+import { sweepPreparedGeometryGrid as d } from "./geometryGridSweep.js";
+import { raycastPreparedGeometryGrid as f } from "./geometryGridRaycast.js";
+import { overlapsPreparedGeometryBox as p } from "./geometryBoxOverlap.js";
+import { overlapsGeometryHeightfieldBox as m } from "./geometryHeightfieldVolume.js";
+import { sweepGeometryHeightfieldBox as h } from "./geometryHeightfieldSweep.js";
+import { raycastGeometryHeightfield as g } from "./geometryHeightfieldRaycast.js";
+// src/geometryWorldView.ts
+var _ = /* @__PURE__ */ new WeakMap();
+function v() {
+	throw new t({ detail: "Geometry world query requires its actual current native inventory, declared extent and complete loaded coordinate" });
+}
+var y = (e, t = -2147483648, n = 2147483647) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : v(), b = (e, t) => {
+	let n = e.view.chunk;
+	switch (n.kind) {
+		case "2d-tiles": return n.width * n.tileSizeRaw === t && n.height * n.tileSizeRaw === t;
+		case "2d-heightfield": return (n.width - 1) * n.sampleSpacingRaw === t && (n.height - 1) * n.sampleSpacingRaw === t;
+		case "3d-voxel": return n.side * n.voxelSizeRaw === t;
+		case "3d-shapes": return n.extentXRaw === t && n.extentYRaw === t && n.extentZRaw === t;
+	}
+}, x = (e, t) => {
+	if (e.fenced) return v();
+	let n = a(e.actor), i = n.scope.kind === "3d-voxel" || n.scope.kind === "3d-shapes", o = r(t, i ? [
+		"xRaw",
+		"yRaw",
+		"zRaw"
+	] : ["xRaw", "yRaw"]), s = y(o.xRaw), c = y(o.yRaw), l = i ? y(o.zRaw) : void 0, u = Math.floor(s / e.extent), d = Math.floor(c / e.extent), f = l === void 0 ? void 0 : Math.floor(l / e.extent), p = n.at({
+		cx: u,
+		cy: d,
+		...f === void 0 ? {} : { cz: f }
+	});
+	return b(p, e.extent) ? {
+		entry: p,
+		x: s - u * e.extent,
+		y: c - d * e.extent,
+		z: l === void 0 ? void 0 : l - f * e.extent
+	} : v();
+}, S = (e, t) => {
+	let n = c([e])[0], i = n.geometry, o = a(t);
+	if (!i || o.scope.worldId !== n.name || o.scope.kind !== i.kind || o.entries.some((e) => !b(e, i.chunkSizeRaw))) return v();
+	let s = {
+		actor: t,
+		extent: i.chunkSizeRaw,
+		root: o.scope,
+		navEnabled: i.nav.derive === "grid",
+		navMaximum: i.nav.maxAdvanceSteps,
+		rayMaximum: i.budgets.maxRayCells,
+		overlapMaximum: i.budgets.maxOverlapTests,
+		fenced: !1
+	}, S = (e) => {
+		let t = x(s, e);
+		return t.entry.kind === "2d-tiles" ? t.entry.view.materialAtRaw(t.x, t.y) : t.entry.kind === "3d-voxel" ? t.entry.view.materialAtRaw(t.x, t.y, t.z) : v();
+	}, C = (e) => {
+		let t = x(s, e);
+		return t.entry.collision.kind === "3d-shapes" ? Object.freeze(t.entry.collision.view.containingRaw({
+			xRaw: t.x,
+			yRaw: t.y,
+			zRaw: t.z
+		}).map((e) => Object.freeze({
+			scope: t.entry.scope,
+			revision: t.entry.revision,
+			shape: e
+		}))) : v();
+	}, w = (e, t) => {
+		let n = x(s, {
+			xRaw: e,
+			yRaw: t
+		});
+		return n.entry.collision.kind === "2d-heightfield" ? n.entry.collision.view.heightAtRaw(n.x, n.y) : v();
+	}, T = Object.freeze({
+		kind: i.kind,
+		get scope() {
+			return a(t).scope;
+		},
+		materialAtRaw: S,
+		shapesAtRaw: C,
+		solidAtRaw: (e) => {
+			if (s.root.kind === "2d-heightfield") {
+				let t = r(e, [
+					"xRaw",
+					"yRaw",
+					"zRaw"
+				]);
+				return y(t.zRaw) <= w(t.xRaw, t.yRaw);
+			}
+			let t = x(s, e), n = t.entry.collision;
+			return n.kind === "2d-tiles" ? n.view.materialAtRaw(t.x, t.y).solid : n.kind === "3d-voxel" ? n.view.materialAtRaw(t.x, t.y, t.z).solid : n.kind === "3d-shapes" ? n.view.containingRaw({
+				xRaw: t.x,
+				yRaw: t.y,
+				zRaw: t.z
+			}).length > 0 : v();
+		},
+		heightAtRaw: (e) => {
+			let t = x(s, e);
+			return t.entry.collision.kind === "2d-heightfield" ? t.entry.collision.view.heightAtRaw(t.x, t.y) : v();
+		},
+		raycastRaw: (e, n, i = {}) => {
+			if (s.fenced) return v();
+			let o = s.root.kind === "3d-shapes", c = r(i, o ? ["maxVisitedCells", "maxTests"] : ["maxVisitedCells"], []), u = Object.hasOwn(c, "maxVisitedCells") ? y(c.maxVisitedCells, 1, s.rayMaximum) : s.rayMaximum;
+			if (o) {
+				let r = Object.hasOwn(c, "maxTests") ? y(c.maxTests, 1, s.overlapMaximum) : s.overlapMaximum;
+				return l(a(t), s.extent, e, n, u, r);
+			}
+			if (s.root.kind === "2d-heightfield") {
+				let t = (e, t) => {
+					let n = x(s, {
+						xRaw: e,
+						yRaw: t
+					});
+					return n.entry.collision.kind === "2d-heightfield" ? {
+						heightRaw: n.entry.collision.view.heightAtRaw(n.x, n.y),
+						scope: n.entry.scope,
+						revision: n.entry.revision
+					} : v();
+				}, r = x(s, {
+					xRaw: e.xRaw,
+					yRaw: e.yRaw
+				});
+				if (r.entry.collision.kind !== "2d-heightfield" || e.zRaw === void 0 || n.zRaw === void 0) return v();
+				let i = Math.max(1, Math.floor(r.entry.collision.view.chunk.sampleSpacingRaw / 4));
+				return g({
+					xRaw: e.xRaw,
+					yRaw: e.yRaw,
+					zRaw: e.zRaw
+				}, {
+					xRaw: n.xRaw,
+					yRaw: n.yRaw,
+					zRaw: n.zRaw
+				}, t, {
+					stepRaw: i,
+					maxSamples: u
+				});
+			}
+			return f(a(t), s.extent, e, n, u);
+		},
+		collide: (e, n, i = {}) => {
+			if (s.fenced) return v();
+			let o = r(i, ["maxTests", "maxIterations"], []), c = Object.hasOwn(o, "maxTests") ? y(o.maxTests, 1, s.overlapMaximum) : s.overlapMaximum, l = Object.hasOwn(o, "maxIterations") ? y(o.maxIterations, 1, 256) : 8;
+			return u(a(t), s.extent, e, n, c, l);
+		},
+		sweepBoxRaw: (e, n, i = {}) => {
+			if (s.fenced) return v();
+			let o = r(i, ["maxTests"], []), c = Object.hasOwn(o, "maxTests") ? y(o.maxTests, 1, s.overlapMaximum) : s.overlapMaximum;
+			return d(a(t), s.extent, e, n, c);
+		},
+		sweepHeightfieldBoxRaw: (e, t, n = {}) => {
+			if (s.fenced || s.root.kind !== "2d-heightfield") return v();
+			let i = r(n, ["maxTests"], []), a = Object.hasOwn(i, "maxTests") ? y(i.maxTests, 1, s.overlapMaximum) : s.overlapMaximum, o = r(e, [
+				"minXRaw",
+				"minYRaw",
+				"minZRaw",
+				"maxXRaw",
+				"maxYRaw",
+				"maxZRaw"
+			]), c = x(s, {
+				xRaw: o.minXRaw,
+				yRaw: o.minYRaw
+			}).entry.collision;
+			if (c.kind !== "2d-heightfield") return v();
+			let l = c.view.chunk.sampleSpacingRaw;
+			return h(e, t, (e) => m(e, w, l, a), {
+				stepRaw: Math.max(1, Math.floor(l / 4)),
+				maxEvaluations: s.rayMaximum
+			});
+		},
+		overlapsBoxRaw: (e, n = {}) => {
+			if (s.fenced) return v();
+			let i = r(n, ["maxTests"], []), o = Object.hasOwn(i, "maxTests") ? y(i.maxTests, 1, s.overlapMaximum) : s.overlapMaximum;
+			if (s.root.kind === "2d-heightfield") {
+				let t = r(e, [
+					"minXRaw",
+					"minYRaw",
+					"minZRaw",
+					"maxXRaw",
+					"maxYRaw",
+					"maxZRaw"
+				]), n = x(s, {
+					xRaw: t.minXRaw,
+					yRaw: t.minYRaw
+				}).entry.collision;
+				return n.kind === "2d-heightfield" ? m(e, w, n.view.chunk.sampleSpacingRaw, o) : v();
+			}
+			return p(a(t), s.extent, e, o);
+		}
+	});
+	return _.set(T, s), T;
+}, C = (e, t) => {
+	let n = _.get(e);
+	return !n || n.fenced || n.root.tenantId !== t ? v() : (a(n.actor), e);
+}, w = (e) => {
+	let t = _.get(e);
+	if (!t) return v();
+	t.fenced = !0;
+}, T = (t, c, l, u, d = {}) => {
+	let f = _.get(t);
+	if (!f || f.fenced || !f.navEnabled || f.root.kind !== "2d-tiles") return v();
+	let p = a(f.actor), m = r(c, [
+		"minCx",
+		"minCy",
+		"chunksX",
+		"chunksY"
+	]), h = y(m.minCx), g = y(m.minCy), x = y(m.chunksX, 1, 1024), S = y(m.chunksY, 1, 1024), C = p.at({
+		cx: h,
+		cy: g
+	}), w = r(d, [
+		"maxRegionCells",
+		"maxDiscovered",
+		"maxOpen",
+		"maxPathLength",
+		"maxAdvanceExpansions"
+	], []), T = Object.hasOwn(w, "maxRegionCells") ? y(w.maxRegionCells, 1, 1048576) : 65536;
+	if (C.kind !== "2d-tiles" || !C.navigation || !b(C, f.extent)) return v();
+	let E = C.view.chunk.width, D = C.view.chunk.tileSizeRaw, O = E * x, k = E * S, A = O * k, j = y(h * E), M = y(g * E);
+	if (y(h + x - 1), y(g + S - 1), y(j + O - 1), y(M + k - 1), y(h * f.extent), y(g * f.extent), y((h + x) * f.extent - 1), y((g + S) * f.extent - 1), A > T) throw new e({
+		budget: "geometryWorldNavigationCells",
+		limit: T
+	});
+	if (O > 1024 || k > 1024) throw new e({
+		budget: "geometryWorldNavigationSide",
+		limit: 1024
+	});
+	let N = Array(A), P = Object.freeze({
+		key: "clear",
+		solid: !1
+	}), F = Object.freeze({
+		key: "blocked",
+		solid: !0
+	});
+	for (let e = 0; e < S; e++) for (let t = 0; t < x; t++) {
+		let n = p.at({
+			cx: h + t,
+			cy: g + e
+		});
+		if (n.kind !== "2d-tiles" || !n.navigation || n.view.chunk.width !== E || n.view.chunk.height !== E || n.view.chunk.tileSizeRaw !== D || !b(n, f.extent)) return v();
+		for (let r = 0; r < E; r++) for (let i = 0; i < E; i++) N[(e * E + r) * O + t * E + i] = (n.navigation ?? v()).solidAt(i, r) ? F : P;
+	}
+	let I = {
+		maxSide: 1024,
+		maxCells: T,
+		maxPalette: 2,
+		maxRuns: T,
+		maxBytes: 16777216
+	}, L = n(I).create({
+		address: {
+			worldId: p.scope.worldId,
+			layerSetId: p.scope.layerSetId,
+			cx: h,
+			cy: g
+		},
+		version: p.scope.version,
+		width: O,
+		height: k,
+		tileSizeRaw: D,
+		cells: N
+	}), R = (e) => {
+		let t = r(e, ["x", "y"]);
+		return {
+			x: y(t.x, j, j + O - 1) - j,
+			y: y(t.y, M, M + k - 1) - M
+		};
+	}, z = {
+		...Object.fromEntries([
+			"maxDiscovered",
+			"maxOpen",
+			"maxPathLength"
+		].filter((e) => Object.hasOwn(w, e)).map((e) => [e, y(w[e], 1, 1048576)])),
+		maxAdvanceExpansions: Object.hasOwn(w, "maxAdvanceExpansions") ? y(w.maxAdvanceExpansions, 1, f.navMaximum) : f.navMaximum
+	}, B = s(i(L, I), R(l), R(u), z), V = B.metrics, H = null, U, W = () => {
+		B && (B.cancel(), V = Object.freeze({
+			...B.metrics,
+			pathLength: 0
+		})), B = null, p = null, H = null, U?.(), U = void 0;
+	}, G = () => {
+		if (!B || !p) return !1;
+		try {
+			if (!f.fenced && a(f.actor) === p) return !0;
+		} catch {}
+		return W(), !1;
+	}, K = () => !G() || !B || B.status !== "found" || !B.path ? null : (H ||= Object.freeze(B.path.map((e) => Object.freeze({
+		x: e.x + j,
+		y: e.y + M
+	}))), H);
+	U = o(f.actor, W);
+	let q = () => G() && B ? B.status : "cancelled";
+	return Object.freeze({
+		get status() {
+			return q();
+		},
+		get metrics() {
+			return G() && B ? B.metrics : V;
+		},
+		get path() {
+			return K();
+		},
+		advance: (e) => G() && B ? B.advance(e === void 0 ? f.navMaximum : y(e, 1, f.navMaximum)) : "cancelled",
+		cancel: W
+	});
+};
+export { C as captureGeometryWorldView, T as createGeometryWorldTilePathSearch, w as fenceGeometryWorldView, S as makeGeometryWorldView };

package/dist/host.js

@@ -0,0 +1,127 @@
+import { RoomAuthoringError as e, RoomFull as t, RoomGone as n } from "./errors.js";
+// src/host.ts
+var r = class {
+	capacity;
+	rooms = /* @__PURE__ */ new Map();
+	pendingFaults = [];
+	retired = [];
+	faults = 0;
+	ticks = 0;
+	disposed = !1;
+	advancing = !1;
+	constructor(t) {
+		if (this.capacity = t, !Number.isSafeInteger(t) || t < 1) throw new e({
+			room: "host",
+			detail: "Host capacity must be a positive safe integer"
+		});
+	}
+	add(r) {
+		if (this.disposed) throw new n({ roomId: r.id });
+		if (this.advancing) throw new e({
+			room: "host",
+			detail: "Host membership cannot change inside its tick loop"
+		});
+		if (this.rooms.has(r.id)) throw new e({
+			room: "host",
+			detail: `Room ${r.id} is already hosted`
+		});
+		if (this.rooms.size + this.pendingFaults.length + this.retired.length >= this.capacity) throw new t({ roomId: r.id });
+		this.rooms.set(r.id, r);
+	}
+	advance(t = () => !0) {
+		if (this.disposed) return 0;
+		if (this.advancing) throw new e({
+			room: "host",
+			detail: "The host loop cannot reenter"
+		});
+		let n = 0;
+		this.advancing = !0;
+		try {
+			for (let e of this.rooms.values()) if (t(e.id)) try {
+				n += e.advance(), (e.isDisposed() || e.isRetiring?.()) && (this.rooms.delete(e.id), this.retired.push(e));
+			} catch (t) {
+				this.faults++, this.pendingFaults.push({
+					roomId: e.id,
+					tick: e.metrics().tick,
+					cause: t,
+					room: e
+				}), this.rooms.delete(e.id);
+			}
+		} finally {
+			this.advancing = !1;
+		}
+		return this.ticks += n, n;
+	}
+	drainFaults() {
+		return this.outsideTick(), this.pendingFaults.splice(0);
+	}
+	takeRetired() {
+		return this.outsideTick(), this.retired.splice(0);
+	}
+	activeRooms() {
+		return this.outsideTick(), [...this.rooms.values()];
+	}
+	take(e) {
+		this.outsideTick();
+		let t = this.rooms.get(e);
+		if (t) return this.rooms.delete(e), t;
+		let n = this.pendingFaults.findIndex((t) => t.roomId === e);
+		if (n >= 0) return this.pendingFaults.splice(n, 1)[0].room;
+		let r = this.retired.findIndex((t) => t.id === e);
+		return r >= 0 ? this.retired.splice(r, 1)[0] : null;
+	}
+	takeAll() {
+		this.outsideTick(), this.disposed = !0;
+		let e = [
+			...this.rooms.values(),
+			...this.pendingFaults.map((e) => e.room),
+			...this.retired
+		];
+		return this.rooms.clear(), this.pendingFaults.length = 0, this.retired.length = 0, e;
+	}
+	drainOutbox() {
+		this.outsideTick();
+		let e = [];
+		for (let t of this.rooms.values()) for (let n of t.drainOutbox()) e.push({
+			roomId: t.id,
+			command: n
+		});
+		return e;
+	}
+	outsideTick() {
+		if (this.advancing) throw new e({
+			room: "host",
+			detail: "Host I/O drains must run outside the tick loop"
+		});
+	}
+	metrics() {
+		let e = 0, t = 0;
+		for (let n of this.rooms.values()) {
+			let r = n.metrics();
+			e += r.clients, t += r.droppedTicks;
+		}
+		return {
+			rooms: this.rooms.size,
+			clients: e,
+			ticks: this.ticks,
+			droppedTicks: t,
+			faults: this.faults
+		};
+	}
+	dispose() {
+		if (this.outsideTick(), this.disposed) return;
+		this.disposed = !0;
+		let e = [];
+		for (let t of [
+			...this.rooms.values(),
+			...this.pendingFaults.map((e) => e.room),
+			...this.retired
+		]) try {
+			t.dispose();
+		} catch (t) {
+			e.push(t);
+		}
+		if (this.rooms.clear(), this.pendingFaults.length = 0, this.retired.length = 0, e.length) throw AggregateError(e, "Room host disposal failed");
+	}
+};
+export { r as RoomHost };