@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryTileCodec.js

@@ -0,0 +1,193 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { geometryEnvelopeMagic as r } from "./geometryEnvelope.js";
+import { createFixed as i } from "./fixedMath.js";
+import { simulationOwnData as a } from "./simulationAuthoring.js";
+import { captureSimulationBytes as o } from "./simulationBytes.js";
+import { RoomStateCodec as s } from "./stateCodec.js";
+import { GeometryTileChunkSchema as c } from "./geometrySchemas.js";
+import { Result as l } from "effect";
+// src/geometryTileCodec.ts
+var u = i(), d = 12, f = r["2d-tiles"], p = Object.freeze({
+	maxSide: 256,
+	maxCells: 65536,
+	maxPalette: 256,
+	maxRuns: 65536,
+	maxBytes: 262144
+}), m = Object.freeze({
+	maxSide: 1024,
+	maxCells: 1048576,
+	maxPalette: 4096,
+	maxRuns: 1048576,
+	maxBytes: 16777216
+});
+function h() {
+	throw new n({
+		room: "geometry",
+		detail: "Geometry tile source or canonical chunk could not be admitted"
+	});
+}
+var g = (e, t, n = t) => {
+	try {
+		return a(e, t, n);
+	} catch {
+		return h();
+	}
+}, _ = (e, t, n) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : h(), v = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : h(), y = (e) => {
+	let t = g(e, ["key", "solid"]);
+	return typeof t.key != "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(t.key) || typeof t.solid != "boolean" ? h() : Object.freeze({
+		key: t.key,
+		solid: t.solid
+	});
+}, b = (e) => {
+	let t = g(e, [
+		"worldId",
+		"layerSetId",
+		"cx",
+		"cy"
+	]);
+	return Object.freeze({
+		worldId: v(t.worldId),
+		layerSetId: v(t.layerSetId),
+		cx: _(t.cx, -2147483648, 2147483647),
+		cy: _(t.cy, -2147483648, 2147483647)
+	});
+}, x = (e, t, n) => {
+	if (!Array.isArray(e) || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return h();
+	let r = [];
+	for (let t = 0; t < e.length; t++) {
+		let i = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!i?.enumerable || !("value" in i)) return h();
+		r.push(n(i.value));
+	}
+	return Object.freeze(r);
+}, S = (e) => {
+	let t = Object.keys(p), n = g(e, t, []), r = { ...p };
+	for (let e of t) Object.hasOwn(n, e) && (r[e] = _(n[e], e === "maxBytes" ? 64 : 1, m[e]));
+	return Object.freeze(r);
+}, C = (t, n) => {
+	let r = _(t.width, 1, n.maxSide), i = _(t.height, 1, n.maxSide), a = r * i;
+	if (a > n.maxCells) throw new e({
+		budget: "geometryCells",
+		limit: n.maxCells
+	});
+	let o = _(t.tileSizeRaw, 1, 2147483647);
+	return r * o > 2147483647 || i * o > 2147483647 ? h() : {
+		width: r,
+		height: i,
+		tileSizeRaw: u.raw(o),
+		cells: a
+	};
+}, w = (n = {}) => {
+	let r = S(n), i = new s(c, {
+		maxBytes: r.maxBytes - d,
+		maxCollectionLength: Math.max(r.maxPalette, r.maxRuns),
+		maxFieldId: 16
+	}), a = (e) => {
+		let t = g(e, [
+			"kind",
+			"formatVersion",
+			"address",
+			"version",
+			"width",
+			"height",
+			"tileSizeRaw",
+			"palette",
+			"runs"
+		]);
+		if (t.kind !== "2d-tiles" || t.formatVersion !== 1) return h();
+		let n = C(t, r), i = x(t.palette, r.maxPalette, y);
+		if (!i.length) return h();
+		for (let e = 1; e < i.length; e++) if (i[e - 1].key >= i[e].key) return h();
+		let a = 0, o = -1, s = new Uint8Array(i.length), c = x(t.runs, Math.min(r.maxRuns, n.cells), (e) => {
+			let t = g(e, ["paletteIndex", "length"]), r = _(t.paletteIndex, 0, i.length - 1), c = _(t.length, 1, n.cells);
+			return r === o || c > n.cells - a ? h() : (o = r, a += c, s[r] = 1, Object.freeze({
+				paletteIndex: r,
+				length: c
+			}));
+		});
+		return a !== n.cells || s.some((e) => e === 0) ? h() : Object.freeze({
+			kind: "2d-tiles",
+			formatVersion: 1,
+			address: b(t.address),
+			version: v(t.version),
+			width: n.width,
+			height: n.height,
+			tileSizeRaw: n.tileSizeRaw,
+			palette: i,
+			runs: c
+		});
+	}, u = (t) => {
+		let n = g(t, [
+			"address",
+			"version",
+			"width",
+			"height",
+			"tileSizeRaw",
+			"cells"
+		]), i = C(n, r), o = b(n.address), s = v(n.version), c = x(n.cells, i.cells, y);
+		if (c.length !== i.cells) return h();
+		let l = /* @__PURE__ */ new Map();
+		for (let t of c) {
+			let n = l.get(t.key);
+			if (n && n.solid !== t.solid) return h();
+			if (l.set(t.key, t), l.size > r.maxPalette) throw new e({
+				budget: "geometryPalette",
+				limit: r.maxPalette
+			});
+		}
+		let u = [...l.values()].sort((e, t) => e.key < t.key ? -1 : +(e.key > t.key)), d = new Map(u.map((e, t) => [e.key, t])), f = [];
+		for (let t of c) {
+			let n = d.get(t.key), i = f.at(-1);
+			if (i?.paletteIndex === n ? f[f.length - 1] = {
+				paletteIndex: n,
+				length: i.length + 1
+			} : f.push({
+				paletteIndex: n,
+				length: 1
+			}), f.length > r.maxRuns) throw new e({
+				budget: "geometryRuns",
+				limit: r.maxRuns
+			});
+		}
+		return a({
+			kind: "2d-tiles",
+			formatVersion: 1,
+			address: o,
+			version: s,
+			width: i.width,
+			height: i.height,
+			tileSizeRaw: i.tileSizeRaw,
+			palette: u,
+			runs: f
+		});
+	}, p = (e) => {
+		let n = i.full(a(e));
+		if (l.isFailure(n)) throw new t({ detail: "Canonical geometry payload could not fit its binary work budget" });
+		let r = new Uint8Array(d + n.success.byteLength), o = new DataView(r.buffer);
+		return r.set(f), o.setUint32(4, i.schemaHash, !0), o.setUint32(8, n.success.byteLength, !0), r.set(n.success, d), r;
+	};
+	return Object.freeze({
+		schemaHash: i.schemaHash,
+		limits: r,
+		capture: a,
+		create: u,
+		encode: p,
+		decode: (t) => {
+			let n;
+			try {
+				n = o(t, r.maxBytes, "geometryChunkBytes");
+			} catch (t) {
+				if (t instanceof e) throw t;
+				return h();
+			}
+			if (n.byteLength < d || f.some((e, t) => n[t] !== e)) return h();
+			let s = new DataView(n.buffer, n.byteOffset, d);
+			if (s.getUint32(4, !0) !== i.schemaHash || s.getUint32(8, !0) !== n.byteLength - d) return h();
+			let c = i.decodeFull(n.subarray(d));
+			if (l.isFailure(c)) return h();
+			let u = a(c.success), m = p(u);
+			return m.byteLength !== n.byteLength || m.some((e, t) => e !== n[t]) ? h() : u;
+		}
+	});
+};
+export { w as createGeometryTileCodec, p as defaultGeometryTileLimits, g as geometryOwnData, h as geometryTileRefusal };

package/dist/geometryTileCollision.js

@@ -0,0 +1,95 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryPreparedInventory as r } from "./geometryPrepared.js";
+import { collide as i } from "./collision.js";
+// src/geometryTileCollision.ts
+function a() {
+	throw new t({ detail: "World collision requires finite world-unit 2D bodies and complete prepared tile collision coverage" });
+}
+var o = (e) => typeof e == "number" && Number.isFinite(e) ? e : a(), s = (e) => {
+	let t = e * 65536;
+	return Number.isFinite(t) && t >= -2147483648 && t <= 2147483647 ? t : a();
+}, c = (e) => {
+	let t = o(e);
+	return t > 0 ? t : a();
+}, l = (t, l, u, d, f, p) => {
+	let m = r(t);
+	if (m.scope.kind !== "2d-tiles" || !Number.isSafeInteger(l) || l < 1 || l > 2147483647 || !Number.isSafeInteger(f) || f < 1 || f > 1048576 || !Number.isSafeInteger(p) || p < 1 || p > 256) return a();
+	let h = n(u, [
+		"x",
+		"y",
+		"rot",
+		"vx",
+		"vy"
+	], [
+		"x",
+		"y",
+		"rot"
+	]), g = {
+		x: o(h.x),
+		y: o(h.y),
+		rot: o(h.rot),
+		...h.vx === void 0 ? {} : { vx: o(h.vx) },
+		...h.vy === void 0 ? {} : { vy: o(h.vy) }
+	}, _ = n(d, [
+		"kind",
+		"radius",
+		"halfWidth",
+		"halfHeight"
+	], ["kind"]), v;
+	if (_.kind === "circle" && !Object.hasOwn(_, "halfWidth") && !Object.hasOwn(_, "halfHeight")) v = {
+		kind: "circle",
+		radius: c(_.radius)
+	};
+	else if (_.kind === "aabb" && !Object.hasOwn(_, "radius")) v = {
+		kind: "aabb",
+		halfWidth: c(_.halfWidth),
+		halfHeight: c(_.halfHeight)
+	};
+	else return a();
+	let y = m.at({
+		cx: Math.floor(s(g.x) / l),
+		cy: Math.floor(s(g.y) / l)
+	}).collision;
+	if (y.kind !== "2d-tiles") return a();
+	let b = y.view.chunk.width, x = y.view.chunk.tileSizeRaw, S = x / 131072;
+	if (y.view.chunk.height !== b || b * x !== l) return a();
+	let C = 0;
+	return i(g, v, {
+		maxObstacleRadius: Math.hypot(S, S),
+		maxIterations: p,
+		nearby: (t, n) => {
+			let r = Math.floor(s(t.x - n) / x), i = Math.floor(s(t.x + n) / x), o = Math.floor(s(t.y - n) / x), c = Math.floor(s(t.y + n) / x), l = i - r + 1, u = c - o + 1, d = f - C;
+			if (l > d || u > d || l * u > d) throw new e({
+				budget: "geometryCollisionTests",
+				limit: f
+			});
+			C += l * u;
+			let p = [];
+			for (let e = o; e <= c; e++) for (let t = r; t <= i; t++) {
+				let n = Math.floor(t / b), r = Math.floor(e / b), i = m.at({
+					cx: n,
+					cy: r
+				}).collision;
+				if (i.kind !== "2d-tiles" || i.view.chunk.width !== b || i.view.chunk.height !== b || i.view.chunk.tileSizeRaw !== x) return a();
+				i.view.solidAt(t - n * b, e - r * b) && p.push({
+					id: `tile:${t}:${e}`,
+					value: {
+						position: {
+							x: (t + .5) * x / 65536,
+							y: (e + .5) * x / 65536
+						},
+						body: {
+							kind: "aabb",
+							halfWidth: S,
+							halfHeight: S
+						},
+						solid: !0
+					}
+				});
+			}
+			return p;
+		}
+	});
+};
+export { l as collidePreparedGeometryTiles };

package/dist/geometryTileNavigation.js

@@ -0,0 +1,127 @@
+import { geometryOwnData as e, geometryTileRefusal as t } from "./geometryTileCodec.js";
+import { captureGeometryTileQuery as n } from "./geometryTileView.js";
+// src/geometryTileNavigation.ts
+var r = Object.freeze({
+	maxDiscovered: 4096,
+	maxOpen: 4096,
+	maxPathLength: 4096,
+	maxAdvanceExpansions: 64
+}), i = (e, n, r) => typeof e == "number" && Number.isSafeInteger(e) && e >= n && e <= r ? e : t(), a = (t) => {
+	let n = Object.keys(r), a = e(t, n, []), o = { ...r };
+	for (let e of n) Object.hasOwn(a, e) && (o[e] = i(a[e], 1, e === "maxAdvanceExpansions" ? 4096 : 1048576));
+	return Object.freeze(o);
+}, o = (r, o, s, c = {}) => {
+	let l = n(r), u = a(c), d = (t) => {
+		let n = e(t, ["x", "y"]);
+		return Object.freeze({
+			x: i(n.x, 0, l.width - 1),
+			y: i(n.y, 0, l.height - 1)
+		});
+	}, f = d(o), p = d(s), m = f.y * l.width + f.x, h = p.y * l.width + p.x, g = l.width * l.height, _ = {
+		scores: new Int32Array(g),
+		parents: new Int32Array(g),
+		closed: new Uint8Array(g),
+		positions: new Int32Array(g),
+		heap: [],
+		pathSlots: Array(Math.min(g, u.maxPathLength))
+	};
+	_.scores.fill(2147483647), _.parents.fill(-1), _.positions.fill(-1);
+	let v = "pending", y = 1, b = 0, x = 0, S = -1, C = -1, w = 0, T = null, E = (e) => Math.abs(e % l.width - p.x) + Math.abs(Math.floor(e / l.width) - p.y), D = (e, t) => {
+		let n = E(e), r = E(t), i = _.scores[e] + n, a = _.scores[t] + r;
+		return i < a || i === a && (n < r || n === r && e < t);
+	}, O = (e, t) => {
+		let n = _.heap[e], r = _.heap[t];
+		_.heap[e] = r, _.heap[t] = n, _.positions[n] = t, _.positions[r] = e;
+	}, k = (e) => {
+		let t = e;
+		for (; t > 0;) {
+			let e = t - 1 >>> 1;
+			if (!D(_.heap[t], _.heap[e])) break;
+			O(t, e), t = e;
+		}
+	}, A = (e) => {
+		_.positions[e] = _.heap.length, _.heap.push(e), k(_.heap.length - 1);
+	}, j = () => {
+		let e = _.heap[0], t = _.heap.pop();
+		if (_.positions[e] = -1, _.heap.length) {
+			_.heap[0] = t, _.positions[t] = 0;
+			let e = 0;
+			for (;;) {
+				let t = e * 2 + 1, n = t + 1;
+				if (t >= _.heap.length) break;
+				let r = n < _.heap.length && D(_.heap[n], _.heap[t]) ? n : t;
+				if (!D(_.heap[r], _.heap[e])) break;
+				O(e, r), e = r;
+			}
+		}
+		return e;
+	}, M = (e) => {
+		v = e, _.heap.length = 0, _.scores = /* @__PURE__ */ new Int32Array(), _.parents = /* @__PURE__ */ new Int32Array(), _.closed = /* @__PURE__ */ new Uint8Array(), _.positions = /* @__PURE__ */ new Int32Array(), _.pathSlots = [], S = -1, C = -1, w = 0;
+	}, N = () => {
+		let e = _.scores[h] + 1;
+		e > u.maxPathLength || e > g ? M("budget-exhausted") : (S = h, C = e - 1, w = e);
+	}, P = () => {
+		if (S < 0 || S >= g || C < 0 || C === 0 != (S === m)) return t();
+		_.pathSlots[C] = Object.freeze({
+			x: S % l.width,
+			y: Math.floor(S / l.width)
+		}), x++, S === m ? (_.pathSlots.length = w, T = Object.freeze(_.pathSlots), M("found")) : (S = _.parents[S], C--);
+	};
+	return _.scores[m] = 0, A(m), (l.solid(m) || l.solid(h)) && M("unreachable"), Object.freeze({
+		get status() {
+			return v;
+		},
+		get path() {
+			return T;
+		},
+		get metrics() {
+			return Object.freeze({
+				discovered: y,
+				expanded: b,
+				traced: x,
+				open: _.heap.length,
+				pathLength: T?.length ?? 0
+			});
+		},
+		advance: (e = u.maxAdvanceExpansions) => {
+			i(e, 1, u.maxAdvanceExpansions);
+			for (let t = 0; t < e && v === "pending"; t++) {
+				if (S >= 0) {
+					P();
+					continue;
+				}
+				if (!_.heap.length) {
+					M("unreachable");
+					break;
+				}
+				let e = j();
+				if (b++, _.closed[e] = 1, e === h) {
+					N();
+					continue;
+				}
+				let t = e % l.width, n = Math.floor(e / l.width), r = [];
+				n > 0 && r.push(e - l.width), t + 1 < l.width && r.push(e + 1), n + 1 < l.height && r.push(e + l.width), t > 0 && r.push(e - 1);
+				for (let t of r) {
+					if (_.closed[t] || l.solid(t)) continue;
+					let n = _.scores[e] + 1;
+					if (n >= _.scores[t]) continue;
+					if (_.scores[t] === 2147483647 && y >= u.maxDiscovered) {
+						M("budget-exhausted");
+						break;
+					}
+					let r = _.positions[t];
+					if (r < 0 && _.heap.length >= u.maxOpen) {
+						M("budget-exhausted");
+						break;
+					}
+					_.scores[t] === 2147483647 && y++, _.scores[t] = n, _.parents[t] = e, r < 0 ? A(t) : k(r);
+				}
+			}
+			return v === "pending" && S < 0 && !_.heap.length && M("unreachable"), v;
+		},
+		cancel: () => {
+			v === "pending" && M("cancelled");
+		}
+	});
+};
+export { o as createGeometryTilePathSearch, r as defaultGeometryTileNavigationLimits };

package/dist/geometryTileView.js

@@ -0,0 +1,34 @@
+import { createFixed as e } from "./fixedMath.js";
+import { createGeometryTileCodec as t, geometryTileRefusal as n } from "./geometryTileCodec.js";
+// src/geometryTileView.ts
+var r = e(), i = /* @__PURE__ */ new WeakMap(), a = (e) => i.get(e) ?? n(), o = (e, a = {}) => {
+	let o = t(a).capture(e), s = new Uint16Array(o.width * o.height), c = 0;
+	for (let e of o.runs) s.fill(e.paletteIndex, c, c + e.length), c += e.length;
+	let l = (e, t) => !Number.isSafeInteger(e) || !Number.isSafeInteger(t) || e < 0 || t < 0 || e >= o.width || t >= o.height ? n() : t * o.width + e, u = (e, t) => o.palette[s[l(e, t)]], d = Object.freeze({
+		chunk: o,
+		materialAt: u,
+		solidAt: (e, t) => u(e, t).solid,
+		materialAtRaw: (e, t) => {
+			if (!Number.isSafeInteger(e) || !Number.isSafeInteger(t) || e < 0 || t < 0 || e >= o.width * o.tileSizeRaw || t >= o.height * o.tileSizeRaw) return n();
+			let i = r.div(r.raw(e), r.raw(o.tileSizeRaw)) >>> 16, a = r.div(r.raw(t), r.raw(o.tileSizeRaw)) >>> 16;
+			return u(i, a);
+		},
+		cellBounds: (e, t) => (l(e, t), Object.freeze({
+			minXRaw: r.raw(e * o.tileSizeRaw),
+			minYRaw: r.raw(t * o.tileSizeRaw),
+			maxXRaw: r.raw((e + 1) * o.tileSizeRaw),
+			maxYRaw: r.raw((t + 1) * o.tileSizeRaw)
+		})),
+		occupancy: () => {
+			let e = new Uint8Array(Math.ceil(s.length / 8));
+			for (let t = 0; t < s.length; t++) o.palette[s[t]].solid && (e[t >>> 3] = e[t >>> 3] | 1 << (t & 7));
+			return e;
+		}
+	});
+	return i.set(d, Object.freeze({
+		width: o.width,
+		height: o.height,
+		solid: (e) => o.palette[s[e]].solid
+	})), d;
+};
+export { a as captureGeometryTileQuery, o as createGeometryTileView };

package/dist/geometryVersionActivation.js

@@ -0,0 +1,113 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryArtifact as r } from "./geometryArtifacts.js";
+import { captureGeometryOwner as i, captureGeometryPersistenceScope as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedBaseline as c, captureGeometryPreparedDerivation as l, captureGeometryPreparedProfile as u, prepareGeometryInventory as d } from "./geometryPrepared.js";
+import { captureGeometryActorReadFrame as f, sealGeometryVersionActivation as p } from "./geometryActorInventory.js";
+import { captureWorldCatalog as m } from "./world.js";
+import { captureRoomSnapshotEffectRunner as h } from "./snapshotBlobIndex.js";
+import { geometryPersistenceDigest as g } from "./geometryPersistenceCapture.js";
+import { captureGeometryMigrationReceipt as _, captureGeometryMigrationRequest as v } from "./geometryMigrations.js";
+import { Effect as y } from "effect";
+// src/geometryVersionActivation.ts
+var b = (b, x, S, C) => {
+	try {
+		let w = f(b), T = m([x])[0], E = T.geometry, D = n(S, [
+			"owner",
+			"version",
+			"requestId"
+		]), O = i(D.owner), k = o(D.version, 96), A = o(D.requestId, 126), j = n(C, [
+			"migrations",
+			"persistence",
+			"quiesce",
+			"maxChunks",
+			"maxAccountedBytes"
+		], [
+			"migrations",
+			"persistence",
+			"quiesce"
+		]), M = n(j.migrations, [
+			"migrate",
+			"exportSubject",
+			"eraseSubject"
+		]), N = n(j.persistence, [
+			"publish",
+			"observe",
+			"commit",
+			"exportSubject",
+			"eraseSubject"
+		]), P = j.migrations, F = j.persistence;
+		if (!E || w.scope.worldId !== T.name || w.scope.kind !== E.kind || w.scope.version === k || typeof j.quiesce != "function" || Object.values(M).some((e) => typeof e != "function") || Object.values(N).some((e) => typeof e != "function")) throw new t({ detail: "Version activation needs exact current World and real complete source capabilities" });
+		let I = Object.hasOwn(j, "maxChunks") ? s(j.maxChunks, 1, E.budgets.maxPreparedChunks) : E.budgets.maxPreparedChunks, L = Object.hasOwn(j, "maxAccountedBytes") ? s(j.maxAccountedBytes, 512, E.budgets.maxPreparedBytes) : E.budgets.maxPreparedBytes, R = M.migrate.bind(P), z = N.observe.bind(F), B = j.quiesce.bind(C);
+		return y.flatMap(y.context(), (i) => y.uninterruptible(y.tryPromise({
+			try: async () => {
+				let o = h(i);
+				if (JSON.stringify(f(b).scope) !== JSON.stringify(w.scope)) throw new t({ detail: "Version activation scope changed before writer quiescence" });
+				let m = B(b);
+				if (!y.isEffect(m) || await o(m) !== void 0) throw new t({ detail: "Version activation writer quiescence did not confirm void" });
+				let x = f(b), S = u(x), C = Object.freeze({
+					...x.scope,
+					version: k
+				}), T = () => {
+					if (f(b) !== x) throw new t({ detail: "Version activation settled before-frame was replaced or withdrawn" });
+				};
+				if (JSON.stringify(x.scope) !== JSON.stringify(w.scope)) throw new t({ detail: "Version activation scope changed during writer quiescence" });
+				if (x.entries.length > I) throw new e({
+					budget: "geometryVersionActivationChunks",
+					limit: I
+				});
+				let E = [], D = [];
+				for (let e of x.entries) {
+					T();
+					let i = c(x, {
+						cx: e.scope.cx,
+						cy: e.scope.cy,
+						...e.scope.cz === void 0 ? {} : { cz: e.scope.cz }
+					}), l = a({
+						...i.scope,
+						version: k
+					}), u = v({
+						from: i.scope,
+						to: l,
+						expectedRevision: i.revision,
+						owner: O,
+						requestId: A + "." + g(JSON.stringify([
+							i.scope.cx,
+							i.scope.cy,
+							i.scope.cz ?? null
+						]))
+					}), d = R(u);
+					if (!y.isEffect(d)) throw new t({ detail: "Actual migration Effect required" });
+					let f = _(await o(d));
+					if (JSON.stringify(f.from) !== JSON.stringify(u.from) || JSON.stringify(f.to) !== JSON.stringify(u.to) || f.fromRevision !== i.revision || f.requestKey !== g(JSON.stringify([u.from.tenantId, u.requestId])) || f.inputSha256 !== g(JSON.stringify(u))) throw new t({ detail: "Version activation migration receipt changed the actual request" });
+					T();
+					let p = z(l);
+					if (!y.isEffect(p)) throw new t({ detail: "Actual target rebuild Effect required" });
+					let m = n(await o(p), [
+						"scope",
+						"revision",
+						"artifact"
+					]), h = Object.freeze({
+						scope: a(m.scope),
+						revision: s(m.revision),
+						artifact: r(m.artifact)
+					});
+					if (JSON.stringify(h.scope) !== JSON.stringify(l) || h.revision !== f.revision || h.artifact.blobSha256 !== f.blobSha256 || h.artifact.contentSha256 !== f.contentSha256) throw new t({ detail: "Version activation target advanced beyond its confirmed migration" });
+					E.push(f), D.push(h);
+				}
+				T();
+				let j = d(C, D, {
+					...l(x),
+					maxChunks: I,
+					maxAccountedBytes: L,
+					codecLimits: { [x.scope.kind]: S }
+				});
+				return p(b, x, j, Object.freeze(E));
+			},
+			catch: (n) => n instanceof e ? n : new t({ detail: "Actual SQL version preparation remains incomplete; CPU inventory was not activated" })
+		})));
+	} catch (n) {
+		return y.fail(n instanceof e ? n : new t({ detail: "Version activation request or native before-frame could not be captured" }));
+	}
+};
+export { b as prepareGeometryVersionActivation };