@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryPlayerEditOwner.js

@@ -0,0 +1,264 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryOwner as r, captureGeometryPrivacyTarget as i, captureGeometrySubject as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryEditAuthority as c, captureGeometryEditIntent as l, captureGeometryEditStrategies as u, runGeometryEditValidator as d } from "./geometryEdits.js";
+import { captureGeometryPreparedBaseline as f, captureGeometryPreparedProfile as p } from "./geometryPrepared.js";
+import { captureGeometryActorFrame as m } from "./geometryActorInventory.js";
+import { captureRoomSnapshotEffectRunner as h } from "./snapshotBlobIndex.js";
+import { captureGeometryPlayerAdmission as g } from "./geometryPlayerAdmission.js";
+import { prepareGeometryPlayerCommit as _ } from "./geometryPlayerEdits.js";
+import { prepareGeometryActivation as ee } from "./geometryActivation.js";
+import { Effect as v } from "effect";
+// src/geometryPlayerEditOwner.ts
+function y() {
+	throw new t({ detail: "Geometry accepted intent lifetime or publication remains unconfirmed" });
+}
+var b = (b, x, S) => {
+	m(b);
+	let C = n(S, [
+		"tenantId",
+		"now",
+		"authorizeIntent",
+		"publishCommitted",
+		"strategies",
+		"maxPending",
+		"maxPendingPatchBytes",
+		"maxOpsPerPump",
+		"maxSubjectWindows",
+		"maxSubjectFences",
+		"localWindowMs",
+		"localOpsPerWindow",
+		"localCooldownMs"
+	], [
+		"tenantId",
+		"now",
+		"authorizeIntent",
+		"publishCommitted"
+	]), w = o(C.tenantId), T = (e, t, n, r) => Object.hasOwn(C, e) ? s(C[e], n, r) : t, E = T("maxPending", 64, 1, 4096), D = T("maxPendingPatchBytes", 16777216, 512, 67108864), O = T("maxOpsPerPump", Math.min(16, E), 1, E), k = T("maxSubjectWindows", 4096, 1, 65536), A = T("maxSubjectFences", 4096, 1, 65536), j = T("localWindowMs", 1e3, 1, 864e5), M = T("localOpsPerWindow", 10, 1, 65536), N = T("localCooldownMs", 0, 0, 864e5), P = u(Object.hasOwn(C, "strategies") ? C.strategies : {}), F = n(x, [
+		"commit",
+		"observation",
+		"withdrawSubject",
+		"eraseSubject",
+		"close"
+	]);
+	if (typeof C.now != "function" || typeof C.authorizeIntent != "function" || typeof C.publishCommitted != "function" || typeof F.commit != "function" || typeof F.withdrawSubject != "function" || typeof F.eraseSubject != "function" || b.observation().scope.tenantId !== w) return y();
+	let te = C.now, ne = C.authorizeIntent, re = C.publishCommitted, I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Set(), z = -1, B = !1, V = null, H = null, U = null, W = !1, G = !1, K = 0, ie = () => {
+		let e = s(te(), 0, 2 ** 53 - 1);
+		return e < z ? y() : (z = e, e);
+	}, q = (e) => JSON.stringify([
+		w,
+		e.kind,
+		e.id
+	]), J = () => [...I.values()].reduce((e, t) => e + (t.commit?.patch.length ?? 0), 0), Y = (e, t) => e.scope.tenantId === t.tenantId && e.request.subject.id === t.subject.id && e.request.subject.kind === t.subject.kind, X = (e) => {
+		let t = i(e);
+		return t.tenantId === w ? t : y();
+	}, Z = /* @__PURE__ */ new Map(), ae = (e, t) => {
+		Z.delete(e), Z.set(e, t), Z.size > E * 4 && Z.delete(Z.keys().next().value);
+	}, Q = async (e, t) => v.isEffect(t) ? e(t) : y(), $ = (n) => v.flatMap(v.context(), (r) => v.uninterruptible(v.tryPromise({
+		try: () => n(h(r)),
+		catch: (n) => n instanceof e ? n : new t({ detail: "Geometry accepted intent or publication remains unconfirmed" })
+	}))), oe = async (t, n) => {
+		if (G) return;
+		let r = q(n.subject);
+		if (!R.has(r)) {
+			if (R.size >= A) throw new e({
+				budget: "geometryIntentSubjectFences",
+				limit: A
+			});
+			R.add(r);
+		}
+		if (V === r && H && await H, await Q(t, x.withdrawSubject(n)) !== void 0) return y();
+	};
+	return Object.freeze({
+		rejected: (e) => Z.has(e),
+		observation: () => Object.freeze({
+			pending: I.size,
+			prepared: [...I.values()].filter((e) => e.commit !== null).length,
+			pendingPatchBytes: J(),
+			active: B || K > 0,
+			subjectWindows: L.size,
+			subjectFences: R.size,
+			closing: W,
+			closed: G
+		}),
+		queue: (t) => {
+			if (G || K > 0) return y();
+			let i = n(t, [
+				"coordinate",
+				"owner",
+				"subject",
+				"requestId",
+				"intent",
+				"actualSession"
+			]), s = m(b), c = f(s, i.coordinate), u = r(i.owner), d = a(i.subject), h = o(i.requestId, 96), _ = l(i.intent), ee = g(i.actualSession, c.scope, u, d), v = Object.freeze({
+				cx: c.scope.cx,
+				cy: c.scope.cy,
+				...c.scope.cz === void 0 ? {} : { cz: c.scope.cz }
+			}), x = Object.freeze({
+				coordinate: v,
+				owner: u,
+				subject: d,
+				requestId: h,
+				intent: _,
+				actualSession: ee.actualSession
+			}), S = q(d), C = JSON.stringify([
+				c.scope,
+				u,
+				d,
+				h,
+				_
+			]), T = I.get(h);
+			if (c.scope.tenantId !== w || R.has(S)) return y();
+			let D = Z.get(h);
+			if (D !== void 0) return D === C ? "rejected" : y();
+			if (T) return B || T.fingerprint !== C ? y() : (T.request = x, "retained");
+			if (W || B || I.size >= E) throw new e({
+				budget: "geometryAcceptedIntents",
+				limit: E
+			});
+			let O = ie(), A = L.get(S), P = A && O - A.start < j ? A.count : 0;
+			if (P >= M || A && O - A.last < N) throw new e({
+				budget: "geometryLocalIntentRate",
+				limit: M
+			});
+			if (!A && L.size >= k) {
+				for (let [e, t] of L) if (O - t.start >= j && O - t.last >= N) {
+					L.delete(e);
+					break;
+				}
+				if (L.size >= k) throw new e({
+					budget: "geometryIntentSubjectWindows",
+					limit: k
+				});
+			}
+			return L.set(S, {
+				start: P ? A.start : O,
+				count: P + 1,
+				last: O
+			}), I.set(h, {
+				request: x,
+				scope: c.scope,
+				fingerprint: C,
+				before: c.artifact.chunk,
+				profile: p(s),
+				commit: null
+			}), "queued";
+		},
+		pump: () => $(async (t) => {
+			if (G || B || K > 0) return y();
+			B = !0, H = new Promise((e) => {
+				U = e;
+			});
+			let n = [];
+			try {
+				for (let [r, i] of [...I].slice(0, O)) {
+					let a = q(i.request.subject);
+					if (R.has(a)) return y();
+					V = a;
+					let o = i.commit === null, s, l;
+					try {
+						if (s = g(i.request.actualSession, i.scope, i.request.owner, i.request.subject), l = c(await Q(t, ne(Object.freeze({
+							...i.request,
+							scope: i.scope,
+							phase: o ? "prepare" : "retry"
+						})))), s.assertCurrent(), o) {
+							let e = m(b);
+							i.before = f(e, i.request.coordinate).artifact.chunk, i.profile = p(e);
+						}
+						d(P, Object.freeze({
+							chunk: i.before,
+							intent: i.request.intent,
+							authority: l,
+							placementId: i.request.requestId,
+							codecLimits: i.profile
+						}));
+					} catch (e) {
+						if (!o) throw e;
+						I.delete(r), ae(r, i.fingerprint), V = null;
+						continue;
+					}
+					if (!i.commit) {
+						let n = await Q(t, _(b, i.request, l, P));
+						if (J() + n.patch.length > D) throw new e({
+							budget: "geometryIntentPendingPatchBytes",
+							limit: D
+						});
+						i.commit = n;
+					}
+					let u = Object.freeze({
+						...i.commit,
+						patch: new Uint8Array(i.commit.patch),
+						actualSession: s.actualSession
+					}), h = await Q(t, ee(b, x, u));
+					if (b.activate(h), s.assertCurrent(), await Q(t, re(Object.freeze({
+						scope: i.scope,
+						requestId: i.request.requestId,
+						intent: i.request.intent,
+						receipt: h.receipt,
+						patch: new Uint8Array(i.commit.patch)
+					}))) !== void 0) return y();
+					I.delete(r), n.push(h.receipt), V = null;
+				}
+				return Object.freeze(n);
+			} finally {
+				V = null, B = !1, U?.(), U = null, H = null;
+			}
+		}),
+		discardUnsubmitted: (e) => {
+			try {
+				let t = X(e);
+				return $(async () => {
+					if (G || B || K > 0) return y();
+					let e = I.get(t.requestId);
+					return e ? !Y(e, t) || e.commit !== null ? y() : (I.delete(t.requestId), !0) : !1;
+				});
+			} catch {
+				return v.fail(new t({ detail: "Geometry local unsubmitted discard target refused" }));
+			}
+		},
+		withdrawSubject: (n) => {
+			try {
+				let t = X(n);
+				return $(async (n) => {
+					if (K >= E * 2) throw new e({
+						budget: "geometryIntentPrivacyOperations",
+						limit: E * 2
+					});
+					K++;
+					try {
+						await oe(n, t);
+					} finally {
+						K--;
+					}
+				});
+			} catch {
+				return v.fail(new t({ detail: "Geometry intent withdrawal target refused" }));
+			}
+		},
+		eraseSubject: (e) => {
+			try {
+				let t = X(e);
+				return $(async (e) => {
+					if (G || K >= E * 2) return y();
+					K++;
+					try {
+						if (await oe(e, t), await Q(e, x.eraseSubject(t)) !== void 0) return y();
+						for (let [e, n] of I) Y(n, t) && I.delete(e);
+						L.delete(q(t.subject));
+					} finally {
+						K--;
+					}
+				});
+			} catch {
+				return v.fail(new t({ detail: "Geometry intent erase target refused" }));
+			}
+		},
+		close: () => $(async () => {
+			if (!G) {
+				if (W = !0, B || K || I.size) return y();
+				L.clear(), R.clear(), G = !0;
+			}
+		})
+	});
+};
+export { b as makeGeometryPlayerEditOwner };

package/dist/geometryPlayerEdits.js

@@ -0,0 +1,48 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { createGeometryArtifact as r } from "./geometryArtifacts.js";
+import { captureGeometryOwner as i, captureGeometrySubject as a, geometryPersistenceId as o } from "./geometryPersistenceData.js";
+import { applyGeometryEdit as s, captureGeometryEditAuthority as c, captureGeometryEditIntent as l, captureGeometryEditStrategies as u } from "./geometryEdits.js";
+import { captureGeometryPreparedBaseline as d, captureGeometryPreparedProfile as f } from "./geometryPrepared.js";
+import { captureGeometryActorFrame as p } from "./geometryActorInventory.js";
+import { createGeometryPatch as m } from "./geometryPatch.js";
+import { captureGeometryPlayerAdmission as h } from "./geometryPlayerAdmission.js";
+import { Effect as g } from "effect";
+// src/geometryPlayerEdits.ts
+var _ = (_, v, y, b = {}) => {
+	try {
+		let x = p(_), S = n(v, [
+			"coordinate",
+			"owner",
+			"subject",
+			"requestId",
+			"intent",
+			"actualSession"
+		]), C = d(x, S.coordinate), w = i(S.owner), T = a(S.subject), E = o(S.requestId, 96), D = l(S.intent), O = c(y), k = u(b), A = f(x), j = h(S.actualSession, C.scope, w, T), M = s({
+			chunk: C.artifact.chunk,
+			intent: D,
+			authority: O,
+			placementId: E,
+			codecLimits: A
+		}, k);
+		return g.uninterruptible(g.tryPromise({
+			try: async () => {
+				j.assertCurrent();
+				let e = await r(M, A), n = m(C.artifact, e, C.revision, { codecLimits: A });
+				if (j.assertCurrent(), p(_) !== x) throw new t({ detail: "Geometry edit before-frame changed during preparation" });
+				return Object.freeze({
+					scope: C.scope,
+					owner: w,
+					subject: T,
+					requestId: E,
+					patch: n.bytes(),
+					actualSession: j.actualSession
+				});
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "Geometry player intent preparation was not admitted" })
+		}));
+	} catch (n) {
+		return g.fail(n instanceof e ? n : new t({ detail: "Geometry player intent or server authority could not be captured" }));
+	}
+};
+export { _ as prepareGeometryPlayerCommit };

package/dist/geometryPrepared.js

@@ -0,0 +1,187 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryOwnData as t } from "./geometryTileCodec.js";
+import { createGeometryHeightfieldView as n } from "./geometryHeightfield.js";
+import { createGeometryShapesView as r } from "./geometryShapes.js";
+import { createGeometryVoxelView as i } from "./geometryVoxel.js";
+import { admitGeometryChunkForKind as a, captureGeometryArtifact as o, geometryEncodedChunkSize as s } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as c, captureGeometryCodecProfiles as l, captureGeometryDense as u, captureGeometryKind as d, captureGeometryPersistenceScope as f, geometryPersistenceId as p, geometryPersistenceInteger as m, geometryPersistenceRefusal as h } from "./geometryPersistenceData.js";
+import { createGeometryTileView as g } from "./geometryTileView.js";
+import { captureGeometryDerivationStrategies as _, deriveGeometryCollision as v, deriveGeometryNavigation as y } from "./geometryDerivationStrategies.js";
+// src/geometryPrepared.ts
+var b = /* @__PURE__ */ new WeakMap(), x = (e) => {
+	let n = t(e, [
+		"tenantId",
+		"kind",
+		"worldId",
+		"layerSetId",
+		"version"
+	]);
+	return Object.freeze({
+		tenantId: p(n.tenantId),
+		kind: d(n.kind),
+		worldId: p(n.worldId, 96),
+		layerSetId: p(n.layerSetId, 96),
+		version: p(n.version, 96)
+	});
+}, S = (e, n) => {
+	let r = t(n, [
+		"cx",
+		"cy",
+		"cz"
+	], ["cx", "cy"]);
+	return f({
+		...e,
+		cx: r.cx,
+		cy: r.cy,
+		...Object.hasOwn(r, "cz") ? { cz: r.cz } : {}
+	});
+}, C = (e) => JSON.stringify([
+	e.cx,
+	e.cy,
+	e.cz ?? null
+]), w = (e, t) => e.tenantId === t.tenantId && e.kind === t.kind && e.worldId === t.worldId && e.layerSetId === t.layerSetId && e.version === t.version, T = (e) => {
+	switch (e.kind) {
+		case "2d-tiles": return e.width * e.height * Uint16Array.BYTES_PER_ELEMENT;
+		case "2d-heightfield": return e.width * e.height * Int32Array.BYTES_PER_ELEMENT;
+		case "3d-shapes": return 0;
+		case "3d-voxel": return e.sections.reduce((e, t) => e + t.runs.length * 2 * Uint16Array.BYTES_PER_ELEMENT, 0);
+	}
+}, E = (d, p, E = {}) => {
+	let D = x(d), O = t(E, [
+		"maxChunks",
+		"maxAccountedBytes",
+		"codecLimits",
+		"strategies",
+		"navEnabled"
+	], []), k = Object.hasOwn(O, "maxChunks") ? m(O.maxChunks, 1, 65536) : 256, A = Object.hasOwn(O, "maxAccountedBytes") ? m(O.maxAccountedBytes, 512, 268435456) : 52428800, j = Object.hasOwn(O, "codecLimits") ? l(O.codecLimits) : /* @__PURE__ */ new Map(), M = _(Object.hasOwn(O, "strategies") ? O.strategies : {}), N = Object.hasOwn(O, "navEnabled") ? O.navEnabled : D.kind === "2d-tiles", P = j.get(D.kind) ?? Object.freeze({}), F = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map();
+	if (typeof N != "boolean" || N && D.kind !== "2d-tiles") return h();
+	let L = u(p, k, (e) => {
+		let n = t(e, [
+			"scope",
+			"revision",
+			"artifact"
+		]), r = f(n.scope), i = m(n.revision), s = o(n.artifact);
+		return w(r, D) ? (c(s, r), a(D.kind, s.chunk, P), {
+			scope: r,
+			revision: i,
+			artifact: s
+		}) : h();
+	});
+	if (!L.length) return h();
+	let R = 0, z = /* @__PURE__ */ new Map();
+	for (let t of L) {
+		let n = C(t.scope), r = t.artifact.bytes().length + T(t.artifact.chunk);
+		if (z.has(n)) return h();
+		if (R += r, R > A) throw new e({
+			budget: "geometryPreparedAccountedBytes",
+			limit: A
+		});
+		z.set(n, r);
+	}
+	let B = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map();
+	for (let t of L) {
+		let n = C(t.scope), r = t.artifact.chunk, i = v(Object.freeze({
+			chunk: r,
+			codecLimits: P
+		}), M.collisionDerive), a = N ? y(Object.freeze({
+			chunk: i,
+			codecLimits: P
+		}), M.navDerive) : null, o = /* @__PURE__ */ new Set([i, ...a === null ? [] : [a]]);
+		o.delete(r);
+		let c = z.get(n);
+		for (let t of o) {
+			let n = s(t, P) + T(t);
+			if (R += n, c += n, R > A) throw new e({
+				budget: "geometryPreparedAccountedBytes",
+				limit: A
+			});
+		}
+		z.set(n, c), B.set(n, i), V.set(n, a);
+	}
+	let H = (e) => {
+		switch (e.kind) {
+			case "2d-tiles": return Object.freeze({
+				kind: e.kind,
+				view: g(e, P)
+			});
+			case "2d-heightfield": return Object.freeze({
+				kind: e.kind,
+				view: n(e, P)
+			});
+			case "3d-shapes": return Object.freeze({
+				kind: e.kind,
+				view: r(e, P)
+			});
+			case "3d-voxel": return Object.freeze({
+				kind: e.kind,
+				view: i(e, P)
+			});
+		}
+	};
+	for (let e of L) {
+		let { scope: t, revision: n, artifact: r } = e, i = C(t), a = H(r.chunk), o = B.get(i), s = o === r.chunk ? a : H(o), c = V.get(i), l = c === null ? null : c === o && s.kind === "2d-tiles" ? s.view : c === r.chunk && a.kind === "2d-tiles" ? a.view : g(c, P), u = Object.freeze({
+			...a,
+			scope: t,
+			revision: n,
+			blobSha256: r.blobSha256,
+			contentSha256: r.contentSha256,
+			accountedBytes: z.get(i),
+			collision: s,
+			navigation: l
+		});
+		F.set(i, u), I.set(i, r);
+	}
+	let U = Object.freeze([...F.values()].sort((e, t) => e.scope.cx - t.scope.cx || e.scope.cy - t.scope.cy || (e.scope.cz ?? 0) - (t.scope.cz ?? 0))), W = Object.freeze({
+		scope: D,
+		entries: U,
+		accountedBytes: R,
+		at: (e) => F.get(C(S(D, e))) ?? h(),
+		contains: (e) => F.has(C(S(D, e)))
+	});
+	return b.set(W, {
+		root: D,
+		entries: F,
+		artifacts: I,
+		options: Object.freeze({
+			strategies: M,
+			navEnabled: N,
+			maxChunks: k,
+			maxAccountedBytes: A,
+			codecLimits: Object.freeze(Object.fromEntries(j))
+		})
+	}), W;
+}, D = (e, t) => {
+	let n = b.get(e);
+	if (!n) return h();
+	let r = C(S(n.root, t)), i = n.entries.get(r), a = n.artifacts.get(r);
+	return !i || !a ? h() : Object.freeze({
+		scope: i.scope,
+		revision: i.revision,
+		artifact: a
+	});
+}, O = (e) => typeof e != "object" || !e || !b.has(e) ? h() : e, k = (e) => {
+	let t = b.get(e);
+	return t ? t.options.codecLimits?.[t.root.kind] ?? {} : h();
+}, A = (e) => {
+	let t = b.get(e);
+	return t ? Object.freeze({
+		strategies: _(t.options.strategies),
+		navEnabled: t.options.navEnabled === !0
+	}) : h();
+}, j = (e, n) => {
+	let r = b.get(e);
+	if (!r) return h();
+	let i = t(n, [
+		"scope",
+		"revision",
+		"artifact"
+	]), a = f(i.scope), o = C(a);
+	if (!w(a, r.root) || !r.entries.has(o)) return h();
+	let s = [...r.entries].map(([e, t]) => e === o ? n : Object.freeze({
+		scope: t.scope,
+		revision: t.revision,
+		artifact: r.artifacts.get(e)
+	}));
+	return E(r.root, s, r.options);
+};
+export { D as captureGeometryPreparedBaseline, S as captureGeometryPreparedCoordinate, A as captureGeometryPreparedDerivation, O as captureGeometryPreparedInventory, k as captureGeometryPreparedProfile, x as captureGeometryPreparedScope, j as deriveGeometryPreparedInventory, E as prepareGeometryInventory };

package/dist/geometryPrivacyFence.js

@@ -0,0 +1,23 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOM_SUBJECT_PRIVACY_TABLE as t } from "./identities.js";
+import { roomSubjectPrivacyKey as n } from "./subjectAdmission.js";
+import { captureRoomSubjectPrivacyJournal as r } from "./subjectPrivacy.js";
+import { and as i, eq as a } from "@voltro/database";
+// src/geometryPrivacyFence.ts
+var o = async (o, s) => {
+	let c = n(s.tenantId, s.subject.id), l = await o.query({
+		table: t,
+		predicate: i(a("tenantId", s.tenantId), a("subjectKey", c)),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	if (l.length !== 1 || l[0].tenantId !== s.tenantId || l[0].subjectKey !== c) throw new e({ detail: "Geometry erasure has no actual Rooms Subject fence" });
+	let u = r(l[0].journal);
+	if (u.kind !== s.subject.kind || u.phase === "pending") throw new e({ detail: "Geometry erasure requires the admitted current Subject kind and completed withdrawal" });
+};
+export { o as assertGeometryPrivacyFence };

package/dist/geometryProceduralPublication.js

@@ -0,0 +1,90 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryDense as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedCoordinate as a, captureGeometryPreparedScope as o } from "./geometryPrepared.js";
+import { captureWorldCatalog as s } from "./world.js";
+import { captureRoomSnapshotEffectRunner as c } from "./snapshotBlobIndex.js";
+import { captureGeometryVersion as l } from "./geometryPersistenceCapture.js";
+import { openGeometryProceduralWorker as u } from "./geometryProceduralWorker.js";
+import { Effect as d } from "effect";
+// src/geometryProceduralPublication.ts
+var f = (f, p, m, h, g = {}) => {
+	try {
+		let _ = s([f])[0], v = _.geometry, y = o(p), b = n(g, [
+			"maxChunks",
+			"maxArtifactBytes",
+			"maxManifestBytes",
+			"maxWorkers"
+		], []), x = (e, t, n, r) => i(Object.hasOwn(b, e) ? b[e] : t, n, r), S = x("maxChunks", 256, 1, 4096), C = x("maxArtifactBytes", 52428800, 64, 268435456), w = x("maxManifestBytes", 262144, 256, 16777216), T = r(m, S, (e) => a(y, e)), E = /* @__PURE__ */ new Set(), D = x("maxWorkers", Math.min(4, T.length), 1, Math.min(16, T.length)), O = n(h, [
+			"worldModuleUrl",
+			"moduleLoaderUrl",
+			"exportName",
+			"timeoutMs",
+			"maxArtifactBytes",
+			"maxOldGenerationMb",
+			"codecLimits"
+		], ["worldModuleUrl"]), k = Object.freeze({ ...O });
+		if (!v || v.static.kind !== "procedural" || v.kind !== y.kind || _.name !== y.worldId || !T.length) throw new t({ detail: "Procedural author publication needs the exact configured World and complete requested inventory" });
+		for (let e of T) {
+			let n = JSON.stringify([
+				e.cx,
+				e.cy,
+				e.cz ?? null
+			]);
+			if (E.has(n)) throw new t({ detail: "Procedural author inventory repeats a full coordinate" });
+			E.add(n);
+		}
+		let A = u(_, k);
+		return d.flatMap(d.context(), (n) => d.uninterruptible(d.tryPromise({
+			try: async () => {
+				let r = c(n), i = [], a = Array(T.length), o = 0, s = 0, u = !1, d;
+				try {
+					for (let e = 0; e < D; e++) i.push(await r(A));
+					if (await Promise.all(i.map(async (t) => {
+						for (; !u && o < T.length;) {
+							let n = o++;
+							try {
+								let i = await r(t.generate({
+									...y,
+									...T[n]
+								}));
+								if (s += i.bytes().length, s > C) throw new e({
+									budget: "geometryProceduralArtifactBytes",
+									limit: C
+								});
+								a[n] = i;
+							} catch (e) {
+								u || (u = !0, d = e);
+							}
+						}
+					})), u) throw d;
+				} finally {
+					if ((await Promise.allSettled(i.map((e) => r(e.close())))).some((e) => e.status === "rejected")) throw new t({ detail: "Procedural author workers did not confirm their native cleanup" });
+				}
+				let f = a.map((e) => {
+					if (!e) throw new t({ detail: "Procedural author inventory remains incomplete" });
+					return e;
+				}), p = l({
+					tenantId: y.tenantId,
+					kind: y.kind,
+					worldId: y.worldId,
+					version: y.version,
+					chunks: f.map((e) => ({
+						...y,
+						...e.chunk.address,
+						blobSha256: e.blobSha256,
+						contentSha256: e.contentSha256
+					}))
+				}, S, w);
+				return Object.freeze({
+					manifest: p,
+					artifacts: Object.freeze(f)
+				});
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "Whole procedural author version remains unconfirmed; no partial manifest returned" })
+		})));
+	} catch (n) {
+		return d.fail(n instanceof e ? n : new t({ detail: "Procedural author inventory could not be admitted before worker acquisition" }));
+	}
+};
+export { f as prepareProceduralGeometryPublication };