@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryRollback.js

@@ -0,0 +1,125 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { createGeometryTileCodec as n, geometryOwnData as r } from "./geometryTileCodec.js";
+import { createGeometryHeightfieldCodec as i } from "./geometryHeightfield.js";
+import { createGeometryShapesCodec as a } from "./geometryShapes.js";
+import { createGeometryVoxelCodec as o, createGeometryVoxelView as s } from "./geometryVoxel.js";
+import { captureGeometryArtifact as c, createGeometryArtifact as l } from "./geometryArtifacts.js";
+import { captureGeometryCodecProfiles as u, captureGeometryDense as d, captureGeometrySubject as f, geometryPersistenceInteger as p } from "./geometryPersistenceData.js";
+import { createGeometryTileView as m } from "./geometryTileView.js";
+import { admitGeometryEditResult as h } from "./geometryEdits.js";
+import { applyGeometryPatch as g, createGeometryPatch as _, decodeGeometryPatch as v } from "./geometryPatch.js";
+//#region src/geometryRollback.ts
+var y = Object.freeze({ rebaseHeight: (e) => e.target ? e.selected : e.selected + (e.after - e.before) });
+function b() {
+	throw new t({ detail: "Geometry rollback requires the complete exact native journal baseline" });
+}
+var x = (e, t) => JSON.stringify(e) === JSON.stringify(t), S = (t, n, r) => {
+	let i = t.kind === "3d-shapes" ? t.shapes.length : t.kind === "3d-voxel" ? t.side ** 3 : t.width * t.height;
+	if (i > r) throw new e({
+		budget: "geometryRollbackCells",
+		limit: r
+	});
+	if (t.kind === "3d-shapes") return new Map(t.shapes.map((e) => [e.id, e]));
+	if (t.kind === "2d-heightfield") return new Map(t.heights.map((e, t) => [String(t), e]));
+	if (t.kind === "2d-tiles") {
+		let e = m(t, n);
+		return new Map(Array.from({ length: i }, (n, r) => [String(r), e.materialAt(r % t.width, Math.floor(r / t.width))]));
+	}
+	let a = s(t, n);
+	return new Map(Array.from({ length: i }, (e, n) => [String(n), a.materialAt(n % t.side, Math.floor(n / t.side) % t.side, Math.floor(n / t.side ** 2))]));
+}, C = (e, t, r) => {
+	let { address: s, version: c } = e;
+	return e.kind === "2d-tiles" ? n(r).create({
+		address: s,
+		version: c,
+		width: e.width,
+		height: e.height,
+		tileSizeRaw: e.tileSizeRaw,
+		cells: Array.from({ length: e.width * e.height }, (e, n) => t.get(String(n)))
+	}) : e.kind === "3d-voxel" ? o(r).create({
+		address: e.address,
+		version: c,
+		side: e.side,
+		voxelSizeRaw: e.voxelSizeRaw,
+		voxels: Array.from({ length: e.side ** 3 }, (e, n) => t.get(String(n)))
+	}) : e.kind === "2d-heightfield" ? i(r).create({
+		address: s,
+		version: c,
+		width: e.width,
+		height: e.height,
+		sampleSpacingRaw: e.sampleSpacingRaw,
+		baseHeightRaw: e.baseHeightRaw,
+		heightQuantumRaw: e.heightQuantumRaw,
+		heightRawSamples: Array.from({ length: e.width * e.height }, (n, r) => e.baseHeightRaw + t.get(String(r)) * e.heightQuantumRaw)
+	}) : a(r).create({
+		address: e.address,
+		version: c,
+		extentXRaw: e.extentXRaw,
+		extentYRaw: e.extentYRaw,
+		extentZRaw: e.extentZRaw,
+		shapes: [...t.values()]
+	});
+}, w = async (t, n, i, a, o, s, m = {}) => {
+	let w = r(m, [
+		"maxEntries",
+		"maxJournalBytes",
+		"maxCells",
+		"maxComparedCells",
+		"codecLimits",
+		"strategies"
+	], []), T = (e, t, n) => Object.hasOwn(w, e) ? p(w[e], 1, n) : t, E = T("maxEntries", 4096, 65536), D = T("maxJournalBytes", 16777216, 268435456), O = T("maxCells", 65536, 1048576), k = T("maxComparedCells", 16777216, 1073741824), A = c(t), j = c(i), M = s === null ? null : f(s), N = u({ [A.chunk.kind]: w.codecLimits ?? {} }).get(A.chunk.kind), P = r(Object.hasOwn(w, "strategies") ? w.strategies : {}, ["rebaseHeight"], []), F = Object.hasOwn(P, "rebaseHeight") ? P.rebaseHeight : y.rebaseHeight;
+	if (typeof F != "function") return b();
+	let I = F;
+	p(n), p(a), h(A.chunk, j.chunk, N);
+	let L = 0, R = d(o, E, (t) => {
+		let n = r(t, ["subject", "patch"]), i = f(n.subject), a = v(n.patch);
+		if (L += a.bytes().length, L > D) throw new e({
+			budget: "geometryRollbackJournalBytes",
+			limit: D
+		});
+		return Object.freeze({
+			subject: i,
+			patch: a
+		});
+	}), z = t, B = n, V = S(A.chunk, N, O), H = V.size, U = 0, W = new Map(V);
+	for (let t of R) {
+		let n = await g(z, t.patch, B, N);
+		h(A.chunk, n.artifact.chunk, N);
+		let r = S(n.artifact.chunk, N, O), i = /* @__PURE__ */ new Set([...V.keys(), ...r.keys()]);
+		if (H += i.size, H > k) throw new e({
+			budget: "geometryRollbackComparedCells",
+			limit: k
+		});
+		let a = M === null || x(t.subject, M);
+		a && U++;
+		for (let e of i) if (!x(V.get(e), r.get(e))) {
+			let t = r.get(e);
+			if (A.chunk.kind === "2d-heightfield") {
+				let n = V.get(e), r = W.get(e);
+				if (typeof n != "number" || typeof t != "number" || typeof r != "number") return b();
+				W.set(e, p(I(Object.freeze({
+					key: e,
+					before: n,
+					after: t,
+					selected: r,
+					target: a
+				})), -(2 ** 53 - 1), 2 ** 53 - 1));
+			} else a || (t === void 0 ? W.delete(e) : W.set(e, t));
+		}
+		z = n.artifact, B = n.revision, V = r;
+	}
+	if (B !== a || z.blobSha256 !== j.blobSha256 || z.contentSha256 !== j.contentSha256) return b();
+	let G = 0;
+	for (let e of /* @__PURE__ */ new Set([...V.keys(), ...W.keys()])) x(V.get(e), W.get(e)) || G++;
+	let K = G === 0 ? i : await l(C(j.chunk, W, N), N), q = _(i, K, a, { codecLimits: N });
+	return Object.freeze({
+		artifact: K,
+		patch: q,
+		revision: a,
+		entries: R.length,
+		targetEntries: U,
+		restoredCells: G
+	});
+};
+//#endregion
+export { y as defaultGeometryRollbackStrategies, w as prepareGeometryRollback };

package/dist/geometryRollbackCoordinator.js

@@ -0,0 +1,203 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryOwner as r, captureGeometryPersistenceScope as i, captureGeometryPrivacyTarget as a, captureGeometrySubject as o, geometryPersistenceId as s, geometryPersistenceInteger as c } from "./geometryPersistenceData.js";
+import { captureGeometryActivation as l } from "./geometryActorInventory.js";
+import { captureRoomSnapshotEffectRunner as u } from "./snapshotBlobIndex.js";
+import { geometryPersistenceDigest as d } from "./geometryPersistenceCapture.js";
+import { makeGeometryCommitCoordinator as f } from "./geometryCommitCoordinator.js";
+import { prepareGeometryActivation as p } from "./geometryActivation.js";
+import { Effect as m, Option as h } from "effect";
+import { HotError as g } from "@voltro/kv/hot/contract";
+//#region src/geometryRollbackCoordinator.ts
+var _ = () => new t({ detail: "Geometry rollback execution or owned cleanup remains unconfirmed" }), v = (t, v, y, b) => {
+	let x = n(b, [
+		"tenantId",
+		"authorize",
+		"maxJobs",
+		"maxPatchBytes",
+		"maxPendingBytes",
+		"maxSubjectFences"
+	], ["tenantId", "authorize"]), S = s(x.tenantId), C = x.authorize, w = n(t, ["prepare"]).prepare, T = n(y, ["tenantId", "acquire"]), E = T.acquire, D = (e, t, n) => Object.hasOwn(x, e) ? c(x[e], 1, n) : t, O = D("maxJobs", 64, 4096), k = D("maxPatchBytes", 262144, 16777216), A = D("maxPendingBytes", 16777216, 67108864), j = D("maxSubjectFences", 4096, 65536);
+	if (typeof C != "function" || typeof w != "function" || typeof E != "function" || T.tenantId !== S) throw _();
+	let M = C, N = w, P = E, F = f(v, y, {
+		tenantId: S,
+		maxPending: O,
+		maxPatchBytes: k,
+		maxPendingBytes: A,
+		maxSubjectFences: j
+	}), I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Set(), R = !1, z = !1, B = !1, V = (e) => d(JSON.stringify([
+		S,
+		e.kind,
+		e.id
+	])), H = (e) => L.has(V(e.subject)) || e.target !== null && L.has(V(e.target)), U = () => [...I.values()].reduce((e, t) => e + (t.input?.patch.length ?? 0), 0), W = async (e, t) => {
+		if (!m.isEffect(t)) throw _();
+		return e(t);
+	}, G = (t) => m.flatMap(m.context(), (n) => m.uninterruptible(m.tryPromise({
+		try: () => t(u(n)),
+		catch: (t) => t instanceof e ? t : t instanceof g ? new g({
+			operation: t.operation,
+			key: "geometryRollbackLease",
+			reason: t.reason
+		}) : _()
+	}))), K = async (e, t) => {
+		if (t.lease) {
+			if (typeof await W(e, t.lease.release()) != "boolean") throw _();
+			t.lease = null;
+		}
+	}, q = (t, a) => {
+		let c, l, u;
+		try {
+			let e = n(t, [
+				"scope",
+				"owner",
+				"subject",
+				"target",
+				"requestId"
+			]);
+			if (c = Object.freeze({
+				scope: i(e.scope),
+				owner: r(e.owner),
+				subject: o(e.subject),
+				target: e.target === null ? null : o(e.target),
+				requestId: s(e.requestId)
+			}), c.scope.tenantId !== S) throw _();
+			l = d(JSON.stringify([S, c.requestId])), u = d(JSON.stringify(c));
+		} catch {
+			return m.fail(_());
+		}
+		return G(async (t) => {
+			if (z || B || H(c)) throw _();
+			let r = I.get(l);
+			if (r) {
+				if (r.active || r.fingerprint !== u) throw _();
+			} else {
+				if (R) throw _();
+				if (I.size >= O) throw new e({
+					budget: "geometryRollbackJobs",
+					limit: O
+				});
+				r = {
+					request: c,
+					fingerprint: u,
+					active: !1,
+					completion: null,
+					finish: null,
+					lease: null,
+					input: null,
+					attempted: !1,
+					receipt: null
+				}, I.set(l, r);
+			}
+			r.active = !0, r.completion = new Promise((e) => {
+				r.finish = e;
+			});
+			try {
+				if (await W(t, M(c)) !== void 0) throw _();
+				if (await K(t, r), !r.input) {
+					let i = await W(t, P(c.scope));
+					if (h.isNone(i)) throw _();
+					let a = n(h.getOrThrow(i), ["renew", "release"]);
+					if (typeof a.renew != "function" || typeof a.release != "function" || (r.lease = Object.freeze({
+						renew: a.renew,
+						release: a.release
+					}), await W(t, r.lease.renew()) !== !0)) throw _();
+					let { requestId: o, ...s } = c, l = (await W(t, N(s))).patch.bytes();
+					if (l.length > k || U() + l.length > A) throw new e({
+						budget: "geometryRollbackPendingBytes",
+						limit: A
+					});
+					if (await W(t, r.lease.renew()) !== !0) throw _();
+					r.input = Object.freeze({
+						scope: c.scope,
+						owner: c.owner,
+						subject: c.subject,
+						requestId: c.requestId,
+						patch: l
+					}), await K(t, r);
+				}
+				if (H(c) || await W(t, M(c)) !== void 0) throw _();
+				if (r.attempted = !0, a) {
+					let e = await W(t, p(a, F, r.input));
+					return r.receipt = e.receipt, e;
+				}
+				let i = await W(t, F.commit(r.input));
+				return r.receipt = i, i;
+			} catch (e) {
+				try {
+					await K(t, r);
+				} catch {
+					throw _();
+				}
+				throw !r.attempted && !r.input && !r.lease && I.delete(l), e;
+			} finally {
+				r.active = !1, r.finish?.(), r.finish = null, r.completion = null;
+			}
+		});
+	};
+	return Object.freeze({
+		observation: () => Object.freeze({
+			jobs: I.size,
+			active: [...I.values()].filter((e) => e.active).length,
+			patchBytes: U(),
+			unconfirmed: [...I.values()].filter((e) => e.attempted && !e.receipt).length,
+			subjectFences: L.size,
+			closing: R,
+			closed: z
+		}),
+		rollback: (e) => q(e).pipe(m.flatMap((e) => "_tag" in e ? m.fail(_()) : m.succeed(e))),
+		prepareActivation: (e, t) => q(t, e).pipe(m.flatMap((t) => {
+			try {
+				return "_tag" in t ? m.succeed(l(e, t)) : m.fail(_());
+			} catch {
+				return m.fail(_());
+			}
+		})),
+		withdrawSubject: (t) => {
+			let n;
+			try {
+				if (n = a(t), n.tenantId !== S) throw _();
+			} catch {
+				return m.fail(_());
+			}
+			return G(async (t) => {
+				if (z) return;
+				if (B) throw _();
+				let r = V(n.subject);
+				if (!L.has(r)) {
+					if (L.size >= j) throw new e({
+						budget: "geometryRollbackSubjectFences",
+						limit: j
+					});
+					L.add(r);
+				}
+				let i = (e) => V(e.request.subject) === r || e.request.target !== null && V(e.request.target) === r;
+				for (;;) {
+					let e = [...I.values()].filter((e) => i(e) && e.active);
+					if (!e.length) break;
+					await Promise.all(e.map((e) => e.completion ?? Promise.reject(_())));
+				}
+				for (let e of I.values()) i(e) && await K(t, e);
+				await W(t, F.withdrawSubject(n));
+			});
+		},
+		close: () => G(async (e) => {
+			if (!z) {
+				if (B) throw _();
+				R = !0, B = !0;
+				try {
+					for (;;) {
+						let e = [...I.values()].filter((e) => e.active);
+						if (!e.length) break;
+						await Promise.all(e.map((e) => e.completion ?? Promise.reject(_())));
+					}
+					if ((await Promise.allSettled([...I.values()].map((t) => K(e, t)))).some((e) => e.status === "rejected") || [...I.values()].some((e) => e.attempted && !e.receipt)) throw _();
+					await W(e, F.close()), I.clear(), L.clear(), z = !0;
+				} finally {
+					B = !1;
+				}
+			}
+		})
+	});
+};
+//#endregion
+export { v as makeGeometryRollbackCoordinator };

package/dist/geometryRollbackPorts.js

@@ -0,0 +1,46 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureRoomGeometryRollbackRequest as r } from "./geometryAdminData.js";
+import { captureGeometryActivation as i } from "./geometryActorInventory.js";
+import { Context as a, Effect as o, Layer as s } from "effect";
+//#region src/geometryRollbackPorts.ts
+var c = class extends a.Service()("@voltro/RoomGeometryRollbackPort") {}, l = (a) => {
+	let s = n(a, [
+		"authorize",
+		"prepare",
+		"resume",
+		"release"
+	]);
+	if (Object.values(s).some((e) => typeof e != "function")) throw new t({ detail: "Host rollback requires a complete actual administrative source" });
+	let c = s.authorize.bind(a), l = s.prepare.bind(a), u = s.resume.bind(a), d = s.release.bind(a), f = (n) => o.suspend(() => {
+		try {
+			let r = n();
+			return o.isEffect(r) ? r.pipe(o.mapError((n) => n instanceof e ? n : new t({ detail: "Actual Host rollback source remains unconfirmed" }))) : o.fail(new t({ detail: "Actual Host rollback source must return its Effect" }));
+		} catch {
+			return o.fail(new t({ detail: "Host rollback source refused admission" }));
+		}
+	}), p = (e) => e === void 0 ? o.void : o.fail(new t({ detail: "Host rollback source did not confirm void completion" }));
+	return Object.freeze({
+		authorize: (e, t, n) => {
+			let i = r(n);
+			return f(() => c(e, t, i)).pipe(o.flatMap(p));
+		},
+		prepare: (e, n, a) => {
+			let s = r(a);
+			return f(() => l(e, n, s)).pipe(o.flatMap((e) => o.try({
+				try: () => i(n.inventory, e),
+				catch: () => new t({ detail: "Rollback source did not return its genuine actor activation" })
+			})));
+		},
+		resume: (e, t, n, a) => {
+			let s = r(n), c = i(t.inventory, a);
+			return f(() => u(e, t, s, c)).pipe(o.flatMap(p));
+		},
+		release: (e, t) => {
+			let n = r(t);
+			return f(() => d(e, n)).pipe(o.flatMap(p));
+		}
+	});
+}, u = (e) => s.succeed(c, l(e));
+//#endregion
+export { c as RoomGeometryRollbackPort, l as captureRoomGeometryRollbackPort, r as captureRoomGeometryRollbackRequest, u as roomGeometryRollbackLayer };

package/dist/geometryRollbackSource.js

@@ -0,0 +1,209 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceId as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureRoomGeometryRollbackRequest as a } from "./geometryAdminData.js";
+import { captureGeometryPreparedBaseline as o } from "./geometryPrepared.js";
+import { captureGeometryActivation as s, captureGeometryActorReadFrame as c } from "./geometryActorInventory.js";
+import { captureRoomSnapshotEffectRunner as l } from "./snapshotBlobIndex.js";
+import { captureRoomGeometryResourceIdentity as u, captureRoomGeometryResourceState as d } from "./geometryHost.js";
+import { bindGeometryChunkLeases as f } from "./geometryChunkLeases.js";
+import { makeGeometryRollbackCoordinator as p } from "./geometryRollbackCoordinator.js";
+import { Effect as m, Option as h } from "effect";
+//#region src/geometryRollbackSource.ts
+var g = () => new t({ detail: "Actual administrative geometry rollback source remains unconfirmed" }), _ = (t) => {
+	let f = n(t, [
+		"authorize",
+		"preparation",
+		"persistence",
+		"leases",
+		"maxJobsPerResource",
+		"maxPatchBytes",
+		"maxPendingBytes"
+	], [
+		"authorize",
+		"preparation",
+		"persistence",
+		"leases"
+	]), _ = n(f.preparation, ["prepare"]), v = n(f.persistence, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]), y = f.authorize, b = f.leases, x = (e, t, n, r) => Object.hasOwn(f, e) ? i(f[e], n, r) : t, S = x("maxJobsPerResource", 64, 1, 4096), C = x("maxPatchBytes", 262144, 512, 16777216), w = x("maxPendingBytes", 16777216, 512, 67108864);
+	if (typeof y != "function" || typeof b != "function" || typeof _.prepare != "function" || Object.values(v).some((e) => typeof e != "function")) throw g();
+	let T = y.bind(t), E = b.bind(t), D = Object.freeze({ prepare: _.prepare.bind(f.preparation) }), O = Object.freeze({
+		publish: v.publish.bind(f.persistence),
+		observe: v.observe.bind(f.persistence),
+		commit: v.commit.bind(f.persistence),
+		exportSubject: v.exportSubject.bind(f.persistence),
+		eraseSubject: v.eraseSubject.bind(f.persistence)
+	}), k = /* @__PURE__ */ new WeakMap(), A = async (e, t) => {
+		if (!m.isEffect(t)) throw g();
+		return e(t);
+	}, j = (t) => m.flatMap(m.context(), (n) => m.uninterruptible(m.tryPromise({
+		try: () => t(l(n)),
+		catch: (t) => t instanceof e ? t : g()
+	}))), M = (e, t, n) => {
+		if (d(t), e.type !== "user" || e.tenantId !== t.scope.tenantId) throw g();
+		let i = c(t.inventory), a = {
+			cx: n.cx,
+			cy: n.cy,
+			...n.cz === void 0 ? {} : { cz: n.cz }
+		}, s = o(i, a);
+		return Object.freeze({
+			scope: s.scope,
+			owner: Object.freeze({
+				roomId: t.scope.roomId,
+				hostId: t.scope.hostId,
+				epoch: t.scope.epoch
+			}),
+			subject: Object.freeze({
+				id: r(e.id),
+				kind: e.type
+			}),
+			target: n.target,
+			requestId: n.requestId
+		});
+	}, N = (t, n, r) => {
+		let i = M(t, n, r), a = r.requestId, o = k.get(n), s = o?.get(a);
+		if (s) {
+			if (JSON.stringify(s.input) !== JSON.stringify(i) || s.active) throw g();
+			return s.caller = structuredClone(t), s;
+		}
+		let c = o ?? /* @__PURE__ */ new Map();
+		if (c.size >= S) throw new e({
+			budget: "geometryHostRollbackJobs",
+			limit: S
+		});
+		if ((c.size + 1) * C > w) throw new e({
+			budget: "geometryHostRollbackReservedBytes",
+			limit: w
+		});
+		let l = {
+			request: r,
+			input: i,
+			caller: structuredClone(t),
+			coordinator: null,
+			leases: null,
+			token: null,
+			held: null,
+			closed: !1,
+			active: !1,
+			completion: null,
+			finish: null
+		};
+		return c.set(a, l), k.set(n, c), l;
+	}, P = async (e, t) => {
+		if (t.held) {
+			if (typeof await A(e, t.held.release()) != "boolean") throw g();
+			t.held = null;
+		}
+	}, F = async (e, t, n, r) => {
+		if (M(t, n, r), await A(e, T(t, n, r)) !== void 0) throw g();
+	}, I = async (e, t) => {
+		if (e.active) throw g();
+		e.active = !0, e.completion = new Promise((t) => {
+			e.finish = t;
+		});
+		try {
+			return await t();
+		} finally {
+			e.active = !1, e.finish?.(), e.finish = null, e.completion = null;
+		}
+	};
+	return Object.freeze({
+		authorize: (e, t, n) => j(async (r) => {
+			let i = a(n);
+			await F(r, e, t, i);
+		}),
+		prepare: (e, t, r) => j(async (i) => {
+			let o = a(r);
+			await F(i, e, t, o);
+			let c = N(e, t, o);
+			return I(c, async () => {
+				if (await t.quiesce(), c.token) return s(t.inventory, c.token);
+				if (!c.coordinator) {
+					let e = await A(i, E(t)), r = n(e, ["tenantId", "acquire"]);
+					if (r.tenantId !== t.scope.tenantId || typeof r.acquire != "function") throw g();
+					c.leases = Object.freeze({
+						tenantId: t.scope.tenantId,
+						acquire: r.acquire.bind(e)
+					}), c.coordinator = p(D, O, c.leases, {
+						tenantId: t.scope.tenantId,
+						maxJobs: 1,
+						maxPatchBytes: C,
+						maxPendingBytes: C,
+						authorize: () => m.suspend(() => T(c.caller, t, c.request))
+					});
+				}
+				return c.token = await A(i, c.coordinator.prepareActivation(t.inventory, c.input)), c.token;
+			});
+		}),
+		resume: (e, t, r, i) => j(async (o) => {
+			let c = a(r), l = s(t.inventory, i);
+			await F(o, e, t, c);
+			let u = N(e, t, c);
+			if (u.token !== l || !u.leases) throw g();
+			return I(u, async () => {
+				await P(o, u);
+				let r = h.getOrThrow(await A(o, u.leases.acquire(u.input.scope))), i = n(r, ["renew", "release"]);
+				if (typeof i.renew != "function" || typeof i.release != "function" || (u.held = Object.freeze({
+					renew: i.renew,
+					release: i.release
+				}), await A(o, u.held.renew()) !== !0)) throw g();
+				let a = await A(o, O.observe(u.input.scope)), s = l.receipt;
+				if (JSON.stringify(a.scope) !== JSON.stringify(u.input.scope) || a.revision !== s.revision || a.artifact.blobSha256 !== s.blobSha256 || a.artifact.contentSha256 !== s.contentSha256 || await A(o, u.held.renew()) !== !0) throw g();
+				await F(o, e, t, c);
+			});
+		}),
+		release: (e, t) => j(async (n) => {
+			u(e);
+			let r = a(t), i = k.get(e)?.get(r.requestId);
+			if (i) {
+				if (JSON.stringify(i.request) !== JSON.stringify(r)) throw g();
+				i.active && await (i.completion ?? Promise.reject(g())), await P(n, i), i.coordinator && !i.closed && (await A(n, i.coordinator.close()), i.closed = !0, i.token || (i.coordinator = null, i.leases = null, i.closed = !1));
+			}
+		})
+	});
+}, v = (e, t) => {
+	let r = n(t, [
+		"authorize",
+		"preparation",
+		"persistence",
+		"namespace",
+		"ttlMs",
+		"maxJobsPerResource",
+		"maxPatchBytes",
+		"maxPendingBytes"
+	], [
+		"authorize",
+		"preparation",
+		"persistence",
+		"namespace",
+		"ttlMs"
+	]), a = Object.getOwnPropertyDescriptor(e, "connectionRegistry"), o = Object.getOwnPropertyDescriptor(e, "hotStore");
+	if (!a?.enumerable || !("value" in a) || !a.value || !o?.enumerable || !("value" in o) || typeof o.value != "function" || typeof r.namespace != "string") throw g();
+	let s = Object.freeze({
+		connectionRegistry: a.value,
+		hotStore: o.value.bind(e)
+	}), c = r.namespace, l = i(r.ttlMs, 1);
+	return _({
+		authorize: r.authorize,
+		preparation: r.preparation,
+		persistence: r.persistence,
+		...Object.hasOwn(r, "maxJobsPerResource") ? { maxJobsPerResource: i(r.maxJobsPerResource, 1, 4096) } : {},
+		...Object.hasOwn(r, "maxPatchBytes") ? { maxPatchBytes: i(r.maxPatchBytes, 512, 16777216) } : {},
+		...Object.hasOwn(r, "maxPendingBytes") ? { maxPendingBytes: i(r.maxPendingBytes, 512, 67108864) } : {},
+		leases: (e) => m.tryPromise({
+			try: () => f(s, {
+				namespace: c,
+				ttlMs: l,
+				tenantId: e.scope.tenantId
+			}),
+			catch: () => g()
+		})
+	});
+};
+//#endregion
+export { v as bindRoomGeometryRollbackSource, _ as makeRoomGeometryRollbackSource };