@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/fixedSlabs.js

@@ -0,0 +1,33 @@
+import { signedProductDifferenceSign as e } from "./fixedWords.js";
+// src/fixedSlabs.ts
+var t = (t, n) => e(t.numerator, n.denominator, n.numerator, t.denominator), n = (e, n, r, i, a, o) => {
+	let s = {
+		numerator: 0,
+		denominator: 1
+	}, c = {
+		numerator: 1,
+		denominator: 1
+	};
+	for (let l = 0; l < e.length; l++) {
+		let u = r[l];
+		if (u === 0) {
+			if (o ? n[l] <= i[l] || e[l] >= a[l] : n[l] < i[l] || e[l] > a[l]) return null;
+			continue;
+		}
+		let d = Math.abs(u), f = {
+			numerator: u > 0 ? i[l] - n[l] : e[l] - a[l],
+			denominator: d
+		}, p = {
+			numerator: u > 0 ? a[l] - e[l] : n[l] - i[l],
+			denominator: d
+		};
+		t(f, s) > 0 && (s = f), t(p, c) < 0 && (c = p);
+		let m = t(s, c);
+		if (o ? m >= 0 : m > 0) return null;
+	}
+	return Object.freeze({
+		entry: Object.freeze(s),
+		exit: Object.freeze(c)
+	});
+};
+export { n as clipFixedBoxSlabs, t as compareFixedSlabFraction };

package/dist/fixedTrig.js

@@ -0,0 +1,47 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { signedProductDifferenceSign as t } from "./fixedWords.js";
+import { fixedRawInteger as n } from "./fixedRaw.js";
+// src/fixedTrig.ts
+var r = Object.freeze([
+	0,
+	6424,
+	12785,
+	19024,
+	25080,
+	30893,
+	36410,
+	41576,
+	46341,
+	50660,
+	54491,
+	57798,
+	60547,
+	62714,
+	64277,
+	65220,
+	65536
+]), i = (t) => {
+	if (t === 16384) return 65536;
+	let n = t >>> 10, i = t & 1023, a = r[n], o = r[n + 1];
+	if (a === void 0 || o === void 0) throw new e({
+		room: "fixed",
+		detail: "Fixed trig table domain invariant failed"
+	});
+	return a + Math.trunc((o - a) * i / 1024);
+}, a = (e) => {
+	let t = e & 65535, n = t >>> 14, r = t & 16383, a = i(n & 1 ? 16384 - r : r), o = n & 2 ? -a : a;
+	return o === 0 ? 0 : o;
+}, o = (e) => a(n(e)), s = (e) => a((n(e) & 65535) + 16384), c = (r, a) => {
+	let o = n(a), s = n(r);
+	if (o === 0 && s === 0) throw new e({
+		room: "fixed",
+		detail: "Fixed atan2 requires a nonzero vector"
+	});
+	let c = Math.abs(o), l = Math.abs(s), u = 0, d = 16384;
+	for (; u < d;) {
+		let e = Math.floor((u + d) / 2);
+		t(c, i(e), l, i(16384 - e)) >= 0 ? d = e : u = e + 1;
+	}
+	return (o >= 0 ? s >= 0 ? u : 65536 - u : s >= 0 ? 32768 - u : 32768 + u) & 65535;
+};
+export { c as atan2Fx, s as cosFx, r as fixedQuarterSine, o as sinFx };

package/dist/fixedTrig32.js

@@ -0,0 +1,37 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { captureUint64Words as t, multiplyWords as n } from "./fixedWords.js";
+import { fixedQuarterSine as r } from "./fixedTrig.js";
+import { compareWide as i, invert as a, magnitude as o, negative as s, product as c } from "./fixedWide.js";
+// src/fixedTrig32.ts
+var l = (e) => t(e), u = (t) => {
+	if (t === 1073741824) return 4294967296;
+	let i = t >>> 26, a = t & 67108863, o = r[i], s = r[i + 1];
+	if (o === void 0 || s === void 0) throw new e({
+		room: "fixed",
+		detail: "Fixed32 table phase invariant failed"
+	});
+	let c = n((s - o) * 65536, a);
+	return o * 65536 + c.hi * 64 + (c.lo >>> 26);
+}, d = (e) => ({
+	hi: Math.floor(e / 4294967296),
+	lo: e >>> 0
+}), f = (e) => {
+	let t = e >>> 30, n = e & 1073741823, r = d(u(t & 1 ? 1073741824 - n : n));
+	return l(t & 2 ? a(r) : r);
+}, p = (e) => f(l(e).lo), m = (e) => f(l(e).lo + 1073741824 >>> 0), h = (t, n) => {
+	let r = l(n), a = l(t);
+	if (!r.hi && !r.lo && !a.hi && !a.lo) throw new e({
+		room: "fixed",
+		detail: "Fixed32 atan2 requires a nonzero vector"
+	});
+	let f = o(r), p = o(a), m = 0, h = 1073741824;
+	for (; m < h;) {
+		let e = Math.floor((m + h) / 2);
+		i(c(f, d(u(e))), c(p, d(u(1073741824 - e)))) >= 0 ? h = e : m = e + 1;
+	}
+	return l({
+		hi: 0,
+		lo: (s(r) ? s(a) ? 2147483648 + m : 2147483648 - m : s(a) ? 4294967296 - m : m) >>> 0
+	});
+};
+export { h as atan2Fx32, m as cosFx32, p as sinFx32 };

package/dist/fixedVectors.js

@@ -0,0 +1,112 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { createFixed as t } from "./fixedMath.js";
+// src/fixedVectors.ts
+var n = t(), r = (t, n) => {
+	if (!t || typeof t != "object" || Object.getPrototypeOf(t) !== Object.prototype || Reflect.ownKeys(t).length !== n.length) throw new e({
+		room: "fixed",
+		detail: "Fixed shapes require exact own plain data"
+	});
+	let r = {};
+	for (let i of n) {
+		let n = Object.getOwnPropertyDescriptor(t, i);
+		if (!n?.enumerable || !("value" in n)) throw new e({
+			room: "fixed",
+			detail: "Fixed shape accessors and absent fields refuse"
+		});
+		Object.defineProperty(r, i, {
+			value: n.value,
+			enumerable: !0
+		});
+	}
+	return r;
+}, i = (e) => {
+	let t = r(e, ["x", "y"]);
+	return Object.freeze({
+		x: n.raw(t.x),
+		y: n.raw(t.y)
+	});
+}, a = (e) => {
+	let t = r(e, [
+		"x",
+		"y",
+		"z"
+	]);
+	return Object.freeze({
+		x: n.raw(t.x),
+		y: n.raw(t.y),
+		z: n.raw(t.z)
+	});
+}, o = (e = {}) => {
+	let n = t(e), r = (e, t) => Object.freeze({
+		x: n.raw(e),
+		y: n.raw(t)
+	}), o = (e, t, r) => Object.freeze({
+		x: n.raw(e),
+		y: n.raw(t),
+		z: n.raw(r)
+	}), s = (e, t) => n.add(n.mul(e.x, t.x), n.mul(e.y, t.y)), c = (e, t) => n.add(n.add(n.mul(e.x, t.x), n.mul(e.y, t.y)), n.mul(e.z, t.z));
+	return Object.freeze({
+		math: n,
+		vec2: r,
+		vec3: o,
+		add2: (e, t) => {
+			let a = i(e), o = i(t);
+			return r(n.add(a.x, o.x), n.add(a.y, o.y));
+		},
+		sub2: (e, t) => {
+			let a = i(e), o = i(t);
+			return r(n.sub(a.x, o.x), n.sub(a.y, o.y));
+		},
+		scale2: (e, t) => {
+			let a = i(e);
+			return r(n.mul(a.x, t), n.mul(a.y, t));
+		},
+		dot2: (e, t) => s(i(e), i(t)),
+		cross2: (e, t) => {
+			let r = i(e), a = i(t);
+			return n.sub(n.mul(r.x, a.y), n.mul(r.y, a.x));
+		},
+		length2: (e) => {
+			let t = i(e);
+			return n.sqrt(s(t, t));
+		},
+		normalize2: (e) => {
+			let t = i(e), a = n.sqrt(s(t, t));
+			return r(n.div(t.x, a), n.div(t.y, a));
+		},
+		lerp2: (e, t, a) => {
+			let o = i(e), s = i(t);
+			return r(n.lerp(o.x, s.x, a), n.lerp(o.y, s.y, a));
+		},
+		add3: (e, t) => {
+			let r = a(e), i = a(t);
+			return o(n.add(r.x, i.x), n.add(r.y, i.y), n.add(r.z, i.z));
+		},
+		sub3: (e, t) => {
+			let r = a(e), i = a(t);
+			return o(n.sub(r.x, i.x), n.sub(r.y, i.y), n.sub(r.z, i.z));
+		},
+		scale3: (e, t) => {
+			let r = a(e);
+			return o(n.mul(r.x, t), n.mul(r.y, t), n.mul(r.z, t));
+		},
+		dot3: (e, t) => c(a(e), a(t)),
+		cross3: (e, t) => {
+			let r = a(e), i = a(t);
+			return o(n.sub(n.mul(r.y, i.z), n.mul(r.z, i.y)), n.sub(n.mul(r.z, i.x), n.mul(r.x, i.z)), n.sub(n.mul(r.x, i.y), n.mul(r.y, i.x)));
+		},
+		length3: (e) => {
+			let t = a(e);
+			return n.sqrt(c(t, t));
+		},
+		normalize3: (e) => {
+			let t = a(e), r = n.sqrt(c(t, t));
+			return o(n.div(t.x, r), n.div(t.y, r), n.div(t.z, r));
+		},
+		lerp3: (e, t, r) => {
+			let i = a(e), s = a(t);
+			return o(n.lerp(i.x, s.x, r), n.lerp(i.y, s.y, r), n.lerp(i.z, s.z, r));
+		}
+	});
+};
+export { i as captureVec2, a as captureVec3, o as createFixedVectors, r as fixedOwnData };

package/dist/fixedVectors32.js

@@ -0,0 +1,94 @@
+import { fixedOwnData as e } from "./fixedVectors.js";
+import { createFixed32 as t } from "./fixed32.js";
+// src/fixedVectors32.ts
+var n = t(), r = (t) => {
+	let r = e(t, ["x", "y"]);
+	return Object.freeze({
+		x: n.raw(r.x),
+		y: n.raw(r.y)
+	});
+}, i = (t) => {
+	let r = e(t, [
+		"x",
+		"y",
+		"z"
+	]);
+	return Object.freeze({
+		x: n.raw(r.x),
+		y: n.raw(r.y),
+		z: n.raw(r.z)
+	});
+}, a = (e = {}) => {
+	let n = t(e), a = (e, t) => Object.freeze({
+		x: n.raw(e),
+		y: n.raw(t)
+	}), o = (e, t, r) => Object.freeze({
+		x: n.raw(e),
+		y: n.raw(t),
+		z: n.raw(r)
+	}), s = (e, t) => n.add(n.mul(e.x, t.x), n.mul(e.y, t.y)), c = (e, t) => n.add(n.add(n.mul(e.x, t.x), n.mul(e.y, t.y)), n.mul(e.z, t.z));
+	return Object.freeze({
+		math: n,
+		vec2: a,
+		vec3: o,
+		add2: (e, t) => {
+			let i = r(e), o = r(t);
+			return a(n.add(i.x, o.x), n.add(i.y, o.y));
+		},
+		sub2: (e, t) => {
+			let i = r(e), o = r(t);
+			return a(n.sub(i.x, o.x), n.sub(i.y, o.y));
+		},
+		scale2: (e, t) => {
+			let i = r(e);
+			return a(n.mul(i.x, t), n.mul(i.y, t));
+		},
+		dot2: (e, t) => s(r(e), r(t)),
+		cross2: (e, t) => {
+			let i = r(e), a = r(t);
+			return n.sub(n.mul(i.x, a.y), n.mul(i.y, a.x));
+		},
+		length2: (e) => {
+			let t = r(e);
+			return n.sqrt(s(t, t));
+		},
+		normalize2: (e) => {
+			let t = r(e), i = n.sqrt(s(t, t));
+			return a(n.div(t.x, i), n.div(t.y, i));
+		},
+		lerp2: (e, t, i) => {
+			let o = r(e), s = r(t);
+			return a(n.lerp(o.x, s.x, i), n.lerp(o.y, s.y, i));
+		},
+		add3: (e, t) => {
+			let r = i(e), a = i(t);
+			return o(n.add(r.x, a.x), n.add(r.y, a.y), n.add(r.z, a.z));
+		},
+		sub3: (e, t) => {
+			let r = i(e), a = i(t);
+			return o(n.sub(r.x, a.x), n.sub(r.y, a.y), n.sub(r.z, a.z));
+		},
+		scale3: (e, t) => {
+			let r = i(e);
+			return o(n.mul(r.x, t), n.mul(r.y, t), n.mul(r.z, t));
+		},
+		dot3: (e, t) => c(i(e), i(t)),
+		cross3: (e, t) => {
+			let r = i(e), a = i(t);
+			return o(n.sub(n.mul(r.y, a.z), n.mul(r.z, a.y)), n.sub(n.mul(r.z, a.x), n.mul(r.x, a.z)), n.sub(n.mul(r.x, a.y), n.mul(r.y, a.x)));
+		},
+		length3: (e) => {
+			let t = i(e);
+			return n.sqrt(c(t, t));
+		},
+		normalize3: (e) => {
+			let t = i(e), r = n.sqrt(c(t, t));
+			return o(n.div(t.x, r), n.div(t.y, r), n.div(t.z, r));
+		},
+		lerp3: (e, t, r) => {
+			let a = i(e), s = i(t);
+			return o(n.lerp(a.x, s.x, r), n.lerp(a.y, s.y, r), n.lerp(a.z, s.z, r));
+		}
+	});
+};
+export { r as captureVec2Fx32, i as captureVec3Fx32, a as createFixed32Vectors };

package/dist/fixedWide.js

@@ -0,0 +1,49 @@
+import { addUint64 as e } from "./fixedWords.js";
+// src/fixedWide.ts
+var t = (e) => e.hi >= 2147483648, n = (t) => e({
+	hi: ~t.hi >>> 0,
+	lo: ~t.lo >>> 0
+}, {
+	hi: 0,
+	lo: 1
+}), r = (e) => t(e) ? n(e) : e, i = (t, r) => e(t, n(r)), a = (e, t) => (e.hi | 0) < (t.hi | 0) ? -1 : (e.hi | 0) > (t.hi | 0) ? 1 : e.lo < t.lo ? -1 : +(e.lo > t.lo), o = (e) => [
+	e.lo & 65535,
+	e.lo >>> 16,
+	e.hi & 65535,
+	e.hi >>> 16
+], s = (e) => ({
+	lo: (e[0] ?? 0) + (e[1] ?? 0) * 65536 >>> 0,
+	hi: (e[2] ?? 0) + (e[3] ?? 0) * 65536 >>> 0
+}), c = (e, t) => {
+	let n = Array(e.length + t.length).fill(0);
+	for (let r = 0; r < e.length; r++) {
+		let i = 0;
+		for (let a = 0; a < t.length; a++) {
+			let o = r + a, s = n[o] + e[r] * t[a] + i;
+			n[o] = s % 65536, i = Math.floor(s / 65536);
+		}
+		n[r + t.length] = i;
+	}
+	return n;
+}, l = (e, t) => c(o(e), o(t)), u = (e, t) => {
+	for (let n = Math.max(e.length, t.length) - 1; n >= 0; n--) {
+		let r = e[n] ?? 0, i = t[n] ?? 0;
+		if (r !== i) return r < i ? -1 : 1;
+	}
+	return 0;
+}, d = (e, t) => {
+	let n = [], r = 0;
+	for (let i = 0; i < Math.max(e.length, t.length); i++) {
+		let a = (e[i] ?? 0) + (t[i] ?? 0) + r;
+		n.push(a % 65536), r = Math.floor(a / 65536);
+	}
+	return r && n.push(r), n;
+}, f = (e, t) => {
+	let n = [], r = 0;
+	for (let i = 0; i < e.length; i++) {
+		let a = e[i] - (t[i] ?? 0) - r;
+		n.push(a < 0 ? a + 65536 : a), r = +(a < 0);
+	}
+	return n;
+};
+export { d as addWide, a as compare, u as compareWide, n as invert, o as limbs, r as magnitude, c as multiplyWide, t as negative, l as product, i as subtract, f as subtractWide, s as words };

package/dist/fixedWords.js

@@ -0,0 +1,45 @@
+import { RoomAuthoringError as e } from "./errors.js";
+// src/fixedWords.ts
+var t = (t) => {
+	if (typeof t != "number" || !Number.isInteger(t) || t < 0 || t > 4294967295) throw new e({
+		room: "fixed",
+		detail: "Expected an unsigned 32-bit word"
+	});
+	return t;
+}, n = (n) => {
+	if (!n || Object.getPrototypeOf(n) !== Object.prototype || Reflect.ownKeys(n).length !== 2 || ["hi", "lo"].some((e) => {
+		let t = Object.getOwnPropertyDescriptor(n, e);
+		return !t?.enumerable || !("value" in t);
+	})) throw new e({
+		room: "fixed",
+		detail: "64-bit words require exact own hi/lo data"
+	});
+	return Object.freeze({
+		hi: t(n.hi),
+		lo: t(n.lo)
+	});
+}, r = (e, t) => {
+	let n = e & 65535, r = e >>> 16, i = t & 65535, a = t >>> 16, o = n * i, s = r * i + n * a + (o >>> 16);
+	return {
+		hi: r * a + Math.floor(s / 65536) >>> 0,
+		lo: ((s & 65535) << 16 | o & 65535) >>> 0
+	};
+}, i = (e, t) => {
+	let n = e.lo + t.lo;
+	return {
+		hi: e.hi + t.hi + +(n >= 4294967296) >>> 0,
+		lo: n >>> 0
+	};
+}, a = (e, t) => {
+	let n = r(e.lo, t.lo);
+	return {
+		hi: n.hi + Math.imul(e.hi, t.lo) + Math.imul(e.lo, t.hi) >>> 0,
+		lo: n.lo
+	};
+}, o = (e, t) => e.hi < t.hi ? -1 : e.hi > t.hi ? 1 : e.lo < t.lo ? -1 : +(e.lo > t.lo), s = (e, t, n, i) => {
+	let a = r(Math.abs(e), Math.abs(t)), s = r(Math.abs(n), Math.abs(i)), c = e !== 0 && t !== 0 && e < 0 != t < 0;
+	if (c !== (n !== 0 && i !== 0 && n < 0 != i < 0)) return c ? -1 : 1;
+	let l = o(a, s);
+	return l === 0 ? 0 : c ? -l : l;
+};
+export { i as addUint64, n as captureUint64Words, o as compareUint64, a as multiplyUint64, r as multiplyWords, s as signedProductDifferenceSign, t as unsignedWord };

package/dist/gateway.js

@@ -0,0 +1,56 @@
+import { decodeRoomFrame as e } from "./wire.js";
+import { gatewayRoomTransport as t } from "./transport.js";
+import { defineWebSocket as n } from "@voltro/protocol";
+import { Result as r } from "effect";
+// src/gateway.ts
+var i = (i, a = {}) => {
+	let o = /* @__PURE__ */ new WeakMap();
+	return n({
+		path: a.path ?? "/_voltro/rooms",
+		auth: "token",
+		verificationTimeoutMs: a.verificationTimeoutMs ?? 5e3,
+		limits: {
+			maxInboundMessagesPerSecond: 128,
+			burst: 30,
+			maxMessageBytes: 65536,
+			maxPendingBytes: 1048576,
+			maxPendingMessages: 64,
+			...a.limits
+		},
+		verify: async (t, n) => {
+			if (n.signal.aborted) return null;
+			let a = e(t);
+			if (r.isFailure(a) || a.success.kind !== "Hello") return null;
+			try {
+				let e = await i.verifySeat(a.success.token, n.signal);
+				if (n.signal.aborted) return null;
+				let r = () => {
+					o.delete(n.signal);
+				};
+				return o.set(n.signal, {
+					claims: e,
+					bytes: Uint8Array.from(t),
+					abort: r
+				}), n.signal.addEventListener("abort", r, { once: !0 }), { subject: {
+					type: "serviceAccount",
+					id: e.sessionId,
+					tenantId: e.tenantId,
+					auditActorId: e.subjectId,
+					scopes: []
+				} };
+			} catch {
+				return null;
+			}
+		},
+		onConnection: (e) => {
+			let n = o.get(e.signal);
+			if (o.delete(e.signal), !n) throw Error("Rooms gateway has no verified Hello");
+			e.signal.removeEventListener("abort", n.abort);
+			let r = i.connect(n.claims, t(e), n.bytes);
+			return () => {
+				r.close("reconnecting").catch(() => void 0);
+			};
+		}
+	});
+};
+export { i as roomsGateway };

package/dist/geometry-retention-app/rooms.geometryJournalRetention.workflow.server.tsx

@@ -0,0 +1,4 @@
+import type { AppContext } from '@voltro/runtime'
+import { geometryJournalRetentionWorkflowExecutor } from '@voltro/plugin-rooms/geometry/server'
+
+export default (_context: AppContext): typeof geometryJournalRetentionWorkflowExecutor => geometryJournalRetentionWorkflowExecutor

package/dist/geometry-retention-app/rooms.geometryJournalRetention.workflow.tsx

@@ -0,0 +1,14 @@
+import { workflow } from '@voltro/workflow/define'
+import { Schema } from 'effect'
+import { GeometryJournalRetentionWorkflowPayload, GeometryJournalRetentionWorkflowResult, BudgetExceeded, ProtocolError } from '@voltro/plugin-rooms/rpc'
+
+/** Explicit optional API module; ordinary cluster schedule/flow control owns firing. */
+export const RoomsGeometryJournalRetention = workflow({
+  name: 'rooms.geometryJournalRetention', payload: GeometryJournalRetentionWorkflowPayload,
+  success: GeometryJournalRetentionWorkflowResult, error: Schema.Union([ProtocolError, BudgetExceeded]),
+  internal: true, controls: { guards: [{ scope: 'rooms:operate' }] },
+  idempotencyKey: ({ runKey }) => `rooms.geometryJournalRetention:${runKey}`,
+  singleton: { key: () => 'rooms.geometryJournalRetention', mode: 'skip' },
+  schedule: { cron: '0 */15 * * * *', timezone: 'UTC', onOverlap: 'skip', backfill: 'skip',
+    payload: ({ scheduledAt }) => ({ runKey: scheduledAt.toISOString(), maxPages: 128 }) },
+})

package/dist/geometry-worker/worker.d.mts

@@ -0,0 +1,2 @@
+/** Bootstrap module for the owned procedural-geometry worker. */
+export {}

package/dist/geometry-worker/worker.mjs

@@ -0,0 +1,50 @@
+import { parentPort, workerData } from 'node:worker_threads'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+
+// Ordinary app-owned installed package resolution, in this separate isolate.
+// No callback serialization/eval, service construction or credential inheritance.
+if (!parentPort) throw new Error('Geometry procedural entry requires its owned Worker')
+const own = (value, fields, required = fields) => {
+  if (!value || typeof value !== 'object' || Object.getPrototypeOf(value) !== Object.prototype) throw new Error('Geometry worker admission refused')
+  for (const key of Reflect.ownKeys(value)) {
+    const field = Object.getOwnPropertyDescriptor(value, key)
+    if (typeof key !== 'string' || !fields.includes(key) || !field?.enumerable || !('value' in field)) throw new Error('Geometry worker admission refused')
+  }
+  if (required.some(key => !Object.hasOwn(value, key))) throw new Error('Geometry worker admission refused')
+  return value
+}
+const data = own(workerData, ['moduleUrl', 'exportName', 'worldId', 'kind', 'seed', 'chunkSizeRaw', 'codecLimits', 'maxBytes']),
+  requireFromApp = createRequire(data.moduleUrl),
+  worldApi = await import(pathToFileURL(requireFromApp.resolve('@voltro/plugin-rooms/world')).href),
+  geometryApi = await import(pathToFileURL(requireFromApp.resolve('@voltro/plugin-rooms/geometry')).href),
+  module = await import(data.moduleUrl), world = worldApi.captureWorldCatalog([module[data.exportName]])[0], geometry = world.geometry
+if (!geometry || world.name !== data.worldId || geometry.kind !== data.kind || geometry.chunkSizeRaw !== data.chunkSizeRaw ||
+  geometry.static.kind !== 'procedural' || geometry.static.seed !== data.seed) throw new Error('Geometry worker declaration refused')
+let busy = false
+parentPort.postMessage({ type: 'ready' })
+parentPort.on('message', async offered => {
+  if (busy) { parentPort.postMessage({ type: 'refused' }); return }
+  busy = true
+  let seq
+  try {
+    const job = own(offered, ['type', 'seq', 'context']), context = own(job.context, ['seed', 'kind', 'address', 'version']),
+      address = own(context.address, data.kind.startsWith('3d-') ? ['worldId', 'layerSetId', 'cx', 'cy', 'cz'] : ['worldId', 'layerSetId', 'cx', 'cy'])
+    seq = job.seq
+    if (job.type !== 'generate' || !Number.isSafeInteger(seq) || seq <= 0 || context.seed !== data.seed || context.kind !== data.kind || address.worldId !== data.worldId) throw new Error('Geometry worker request refused')
+    Object.freeze(address); Object.freeze(context)
+    const generate = async () => {
+      const chunk = geometry.static.generator(context)
+      if (chunk instanceof Promise) { void chunk.catch(() => undefined); throw new Error('Geometry author generator must be synchronous') }
+      const artifact = await geometryApi.createGeometryArtifact(chunk, data.codecLimits), bytes = artifact.bytes()
+      if (bytes.length > data.maxBytes || artifact.chunk.kind !== context.kind || artifact.chunk.version !== context.version ||
+        JSON.stringify(artifact.chunk.address) !== JSON.stringify(context.address)) throw new Error('Geometry worker output escaped its scope')
+      return { artifact, bytes }
+    }
+    const first = await generate(), second = await generate()
+    if (first.artifact.blobSha256 !== second.artifact.blobSha256 || first.artifact.contentSha256 !== second.artifact.contentSha256) throw new Error('Geometry generator changed on exact replay')
+    const buffer = first.bytes.buffer
+    parentPort.postMessage({ type: 'generated', seq, blobSha256: first.artifact.blobSha256, contentSha256: first.artifact.contentSha256, bytes: buffer }, [buffer])
+  } catch { parentPort.postMessage({ type: 'refused', ...(Number.isSafeInteger(seq) ? { seq } : {}) }) }
+  finally { busy = false }
+})