@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/simulationRecoveryWire.js

@@ -0,0 +1,133 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { simulationOwnData as r } from "./simulationAuthoring.js";
+import { captureSimulationBytes as i } from "./simulationBytes.js";
+import { captureSimulationInputHistory as a } from "./simulationInputHistoryCapture.js";
+import { createSimulationSnapshotCodec as o } from "./simulationSnapshotWire.js";
+import { assertCapturedSimulation as s, captureSimulationInputs as c } from "./simulation.js";
+import { RoomInputCodec as l } from "./stateCodec.js";
+import { Result as u } from "effect";
+// src/simulationRecoveryWire.ts
+var d = 16, f = Object.freeze([
+	76,
+	83,
+	83,
+	2
+]);
+function p(e) {
+	throw new t({ detail: e });
+}
+var m = (e, t, n, r, i) => !Number.isInteger(i) || i < 1 || i > 4096 ? p("Recovery continuation exceeds tick/work limits") : a(e, t, n.map((e) => e.playerId), r, i), h = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o = !1;
+	constructor(e, t = {}) {
+		s(e), this.#e = e;
+		let i = r(t, [
+			"maxBytes",
+			"maxPlayers",
+			"maxTicks"
+		], []), a = Object.hasOwn(i, "maxBytes") ? i.maxBytes : 16777216, c = Object.hasOwn(i, "maxPlayers") ? i.maxPlayers : 64, u = Object.hasOwn(i, "maxTicks") ? i.maxTicks : 64;
+		if (!Number.isInteger(a) || a < 68 || a > 16777216 || !Number.isInteger(c) || c < 1 || c > 64 || !Number.isInteger(u) || u < 1 || u > 4096) throw new n({
+			room: "simulation",
+			detail: "Recovery envelope needs bounded byte/player/tick work"
+		});
+		this.#r = a, this.#i = c, this.#a = u, this.#t = o(e, { maxBytes: this.#r - d - 8 }), this.#n = new l(e.definition.input, e.inputCodec.limits);
+	}
+	get maxBytes() {
+		return this.#r;
+	}
+	work(e) {
+		if (this.#o) return p("Recovery codec cannot reenter capture/encoding/decoding");
+		this.#o = !0;
+		try {
+			return e();
+		} finally {
+			this.#o = !1;
+		}
+	}
+	encode(t) {
+		return this.work(() => {
+			let n = r(t, [
+				"snapshot",
+				"inputs",
+				"continuation"
+			], ["snapshot", "inputs"]), i = c(this.#e, n.inputs, this.#i);
+			if (!i.length) return p("Recovery requires a nonempty complete input base");
+			let o = this.#t.encode(n.snapshot), s = this.#t.decode(o), l = d + o.length, m = (t) => t.map((t) => {
+				let n = this.#n.full(t.input);
+				if (u.isFailure(n)) throw n.failure;
+				if (l += 8 + n.success.length, l > this.#r) throw new e({
+					budget: "simulationRecoveryBytes",
+					limit: this.#r
+				});
+				return n.success;
+			}), h = m(i), g = [], _ = a(this.#e, s.tick, i.map((e) => e.playerId), Object.hasOwn(n, "continuation") ? n.continuation : [], this.#a, (e) => {
+				l += 4, g.push(m(e.inputs));
+			}), v = new Uint8Array(l), y = new DataView(v.buffer);
+			v.set(f), y.setUint32(4, o.length, !0), y.setUint32(8, i.length, !0), y.setUint32(12, _.length, !0), v.set(o, d);
+			let b = d + o.length, x = (e, t) => {
+				for (let n = 0; n < e.length; n++) {
+					let r = t[n];
+					y.setUint32(b, e[n].playerId, !0), y.setUint32(b + 4, r.length, !0), v.set(r, b + 8), b += 8 + r.length;
+				}
+			};
+			x(i, h);
+			for (let e = 0; e < _.length; e++) {
+				let t = _[e];
+				y.setUint32(b, t.tick, !0), b += 4, x(t.inputs, g[e]);
+			}
+			return v;
+		});
+	}
+	decode(t) {
+		return this.work(() => {
+			let n = i(t, this.#r, "simulationRecoveryBytes");
+			if (n.length < d || f.some((e, t) => n[t] !== e)) return p("Recovery envelope is truncated or has an unknown layout");
+			let r = new DataView(n.buffer), a = r.getUint32(4, !0), o = r.getUint32(8, !0), s = r.getUint32(12, !0);
+			if (!o || o > this.#i) throw new e({
+				budget: "simulationRecoveryPlayers",
+				limit: this.#i
+			});
+			if (s > this.#a) throw new e({
+				budget: "simulationRecoveryTicks",
+				limit: this.#a
+			});
+			if (a < 44 || a > n.length - d - o * 8 * (s + 1) - s * 4) return p("Recovery snapshot/cell length exceeds the envelope");
+			let l = this.#t.decode(n.subarray(d, d + a)), h = d + a, g = () => {
+				let e = [], t = -1;
+				for (let i = 0; i < o; i++) {
+					if (h + 8 > n.length) return p("Recovery input header is truncated");
+					let i = r.getUint32(h, !0), a = r.getUint32(h + 4, !0);
+					if (h += 8, i <= t || a > n.length - h) return p("Recovery player ordering or exact input length is invalid");
+					let o = this.#n.decodeFull(n.subarray(h, h + a));
+					if (u.isFailure(o)) throw o.failure;
+					e.push({
+						playerId: i,
+						input: o.success
+					}), t = i, h += a;
+				}
+				return c(this.#e, e, this.#i);
+			}, _ = g(), v = [];
+			for (let e = 0; e < s; e++) {
+				if (h + 4 > n.length) return p("Recovery continuation tick is truncated");
+				let e = r.getUint32(h, !0);
+				h += 4, v.push({
+					tick: e,
+					inputs: g()
+				});
+			}
+			if (h !== n.length) return p("Recovery envelope has trailing bytes");
+			let y = m(this.#e, l.tick, _, v, this.#a);
+			return Object.freeze({
+				snapshot: l,
+				inputs: _,
+				continuation: y
+			});
+		});
+	}
+}, g = (e, t = {}) => new h(e, t);
+export { h as SimulationRecoveryCodec, m as captureSimulationRecoveryContinuation, g as createSimulationRecoveryCodec };

package/dist/simulationReplay.js

@@ -0,0 +1,126 @@
+import { BudgetExceeded as e, RoomAuthoringError as t } from "./errors.js";
+import { captureUint64Words as n, unsignedWord as r } from "./fixedWords.js";
+import { freezeSimulationValue as i, simulationOwnData as a } from "./simulationAuthoring.js";
+import { assertCapturedSimulation as o, captureSimulationInputs as s, captureSimulationSnapshot as c, createSimulationRunner as l } from "./simulation.js";
+import { RoomInputCodec as u } from "./stateCodec.js";
+import { Result as d } from "effect";
+// src/simulationReplay.ts
+function f(e) {
+	throw new t({
+		room: "simulation",
+		detail: e
+	});
+}
+var p = (t, p, m = {}) => {
+	o(t);
+	let h = a(m, [
+		"maxReplayTicks",
+		"maxInputBytes",
+		"maxPlayers",
+		"maxRejectionAttempts"
+	], []), g = {
+		maxReplayTicks: 1e4,
+		maxInputBytes: 1048576,
+		maxPlayers: 8,
+		maxRejectionAttempts: 64
+	}, _ = {
+		maxReplayTicks: 65536,
+		maxInputBytes: 16777216,
+		maxPlayers: 64,
+		maxRejectionAttempts: 65536
+	}, v = { ...g };
+	for (let e of Object.keys(g)) {
+		let t = Object.hasOwn(h, e) ? h[e] : g[e];
+		if (!Number.isInteger(t) || t < 1 || t > _[e]) return f("Invalid bounded replay work limit");
+		Object.defineProperty(v, e, {
+			value: t,
+			enumerable: !0
+		});
+	}
+	let y = a(p, [
+		"seed",
+		"options",
+		"base",
+		"inputs",
+		"baseInputs"
+	], [
+		"seed",
+		"options",
+		"base",
+		"inputs"
+	]), b = r(y.seed), x = i(t.optionsCodec.capture(y.options)), S = c(t, y.base, v.maxRejectionAttempts), C = y.inputs;
+	if (!Array.isArray(C) || C.length > v.maxReplayTicks) throw new e({
+		budget: "simulationReplayTicks",
+		limit: v.maxReplayTicks
+	});
+	if (Reflect.ownKeys(C).length !== C.length + 1 || C.length > 4294967295 - S.tick) return f("Replay needs a dense bounded contiguous tick history");
+	let w = new u(t.definition.input, {
+		maxBytes: v.maxInputBytes,
+		maxCollectionLength: t.inputCodec.limits.maxCollectionLength,
+		maxFieldId: Math.min(t.inputCodec.limits.maxFieldId, v.maxInputBytes * 7)
+	}), T = [], E = 0;
+	for (let i = 0; i < C.length; i++) {
+		let o = Object.getOwnPropertyDescriptor(C, String(i));
+		if (!o?.enumerable || !("value" in o)) return f("Replay matrix holes/accessors refuse");
+		let c = a(o.value, [
+			"tick",
+			"inputs",
+			"hash"
+		], [
+			"tick",
+			"inputs",
+			"hash"
+		]), l = r(c.tick);
+		if (l !== S.tick + i + 1) return f("Replay tick sequence is not contiguous from its actual base");
+		let u = s(t, c.inputs, v.maxPlayers);
+		E += 12;
+		for (let e of u) {
+			let t = w.full(e.input);
+			if (d.isFailure(t)) throw t.failure;
+			E += 8 + t.success.length;
+		}
+		if (E > v.maxInputBytes) throw new e({
+			budget: "simulationReplayInputBytes",
+			limit: v.maxInputBytes
+		});
+		T.push(Object.freeze({
+			tick: l,
+			inputs: u,
+			hash: n(c.hash)
+		}));
+	}
+	let D = l(t, b, x, {
+		rollbackHorizonTicks: 1,
+		maxReplaySteps: 1,
+		maxPlayers: v.maxPlayers,
+		maxRejectionAttempts: v.maxRejectionAttempts
+	});
+	if (S.tick === 0) {
+		let e = D.snapshot();
+		if (e.hash.hi !== S.hash.hi || e.hash.lo !== S.hash.lo) return Object.freeze({
+			_tag: "diverged",
+			tick: 0,
+			expected: S.hash,
+			actual: e.hash
+		});
+		if (Object.keys(e.rng).some((t) => e.rng[t] !== S.rng[t])) return f("Replay initial RNG does not match its declared seed/options");
+	}
+	D.installSnapshot(S, Object.hasOwn(y, "baseInputs") ? s(t, y.baseInputs, v.maxPlayers) : void 0);
+	for (let e of T) {
+		let t = D.advance(e.inputs);
+		if (t.hash.hi !== e.hash.hi || t.hash.lo !== e.hash.lo) return Object.freeze({
+			_tag: "diverged",
+			tick: e.tick,
+			expected: e.hash,
+			actual: t.hash
+		});
+	}
+	let O = D.snapshot();
+	return Object.freeze({
+		_tag: "verified",
+		ticks: T.length,
+		throughTick: O.tick,
+		hash: O.hash
+	});
+};
+export { p as verifySimulationReplay };

package/dist/simulationSnapshotWire.js

@@ -0,0 +1,111 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { simulationOwnData as r } from "./simulationAuthoring.js";
+import { captureSimulationBytes as i } from "./simulationBytes.js";
+import { assertCapturedSimulation as a, captureSimulationSnapshot as o } from "./simulation.js";
+import { RoomInputCodec as s, RoomStateCodec as c } from "./stateCodec.js";
+import { Result as l } from "effect";
+// src/simulationSnapshotWire.ts
+var u = 44, d = Object.freeze([
+	76,
+	83,
+	82,
+	1
+]);
+function f(e) {
+	throw new t({ detail: e });
+}
+var p = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = !1;
+	constructor(e, t = {}) {
+		a(e), this.#e = e;
+		let i = r(t, ["maxBytes"], []), o = Object.hasOwn(i, "maxBytes") ? i.maxBytes : e.stateCodec.limits.maxBytes + u;
+		if (!Number.isInteger(o) || o < u || o > 16777216) throw new n({
+			room: "simulation",
+			detail: "Snapshot envelope needs a bounded byte budget"
+		});
+		this.#r = o;
+		let l = this.#r - u;
+		if (l < 1) throw new n({
+			room: "simulation",
+			detail: "Snapshot envelope requires a positive state-payload budget"
+		});
+		this.#t = new c(e.definition.state, {
+			...e.stateCodec.limits,
+			maxBytes: l,
+			maxFieldId: Math.min(e.stateCodec.limits.maxFieldId, l * 7)
+		}), this.#n = new s(e.definition.input, {
+			maxBytes: e.inputCodec.limits.maxBytes,
+			maxCollectionLength: e.inputCodec.limits.maxCollectionLength,
+			maxFieldId: e.inputCodec.limits.maxFieldId
+		}).schemaHash;
+	}
+	get maxBytes() {
+		return this.#r;
+	}
+	work(e) {
+		if (this.#i) return f("Snapshot codec cannot reenter active capture/encoding/decoding");
+		this.#i = !0;
+		try {
+			return e();
+		} finally {
+			this.#i = !1;
+		}
+	}
+	encode(t) {
+		return this.work(() => {
+			let n = o(this.#e, t), r = this.#t.full(n.state);
+			if (l.isFailure(r)) throw r.failure;
+			let i = r.success;
+			if (i.length + u > this.#r) throw new e({
+				budget: "simulationSnapshotBytes",
+				limit: this.#r
+			});
+			let a = new Uint8Array(u + i.length), s = new DataView(a.buffer);
+			a.set(d);
+			let c = [
+				this.#t.schemaHash,
+				this.#n,
+				n.tick,
+				n.rng.stateHi,
+				n.rng.stateLo,
+				n.rng.incrementHi,
+				n.rng.incrementLo,
+				n.hash.hi,
+				n.hash.lo,
+				i.length
+			];
+			for (let e = 0; e < c.length; e++) s.setUint32(4 + e * 4, c[e], !0);
+			return a.set(i, u), a;
+		});
+	}
+	decode(e) {
+		return this.work(() => {
+			let t = i(e, this.#r, "simulationSnapshotBytes");
+			if (t.length < u || d.some((e, n) => e !== t[n])) return f("Snapshot envelope is truncated or has an unknown layout");
+			let n = new DataView(t.buffer), r = (e) => n.getUint32(4 + e * 4, !0);
+			if (r(0) !== this.#t.schemaHash || r(1) !== this.#n) return f("Snapshot state/input layout does not match the captured simulation");
+			if (r(9) !== t.length - u) return f("Snapshot payload length is not exact");
+			let a = this.#t.decodeFull(t.subarray(u));
+			if (l.isFailure(a)) throw a.failure;
+			return o(this.#e, {
+				tick: r(2),
+				state: a.success,
+				rng: {
+					stateHi: r(3),
+					stateLo: r(4),
+					incrementHi: r(5),
+					incrementLo: r(6)
+				},
+				hash: {
+					hi: r(7),
+					lo: r(8)
+				}
+			});
+		});
+	}
+}, m = (e, t = {}) => new p(e, t);
+export { p as SimulationSnapshotCodec, m as createSimulationSnapshotCodec };

package/dist/simulationState.js

@@ -0,0 +1,177 @@
+import { BudgetExceeded as e, RoomAuthoringError as t } from "./errors.js";
+import { multiplyUint64 as n } from "./fixedWords.js";
+import { simulationSchemaNode as r } from "./stateCodec.js";
+import { Schema as i } from "effect";
+// src/simulationState.ts
+function a(e) {
+	throw new t({
+		room: "simulation",
+		detail: e
+	});
+}
+function o(t, n) {
+	throw new e({
+		budget: t,
+		limit: n
+	});
+}
+var s = Object.freeze({
+	maxBytes: 1048576,
+	maxCollectionLength: 16384,
+	maxFieldId: 4096,
+	maxNodes: 65536
+}), c = (e) => {
+	if (!e || Object.getPrototypeOf(e) !== Object.prototype) return a("Simulation limits require own plain data");
+	let t = { ...s };
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		if (typeof n != "string" || !Object.hasOwn(s, n) || !r?.enumerable || !("value" in r) || !Number.isSafeInteger(r.value) || r.value < 1 || r.value > 4294967295) return a("Invalid simulation value limit");
+		Object.defineProperty(t, n, {
+			value: r.value,
+			enumerable: !0
+		});
+	}
+	return t.maxFieldId > t.maxBytes * 7 ? a("Simulation field-ID budget exceeds byte budget") : Object.freeze(t);
+}, l = (e, t) => {
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	return n && (!n.enumerable || !("value" in n)) ? a("Simulation values require own enumerable data, without accessors") : n;
+}, u = (e) => !e || typeof e != "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(e)) ? a("Simulation structs and records require plain own data") : e, d = (e) => typeof e == "number" && Number.isInteger(e) && e >= -2147483648 && e <= 2147483647 ? e === 0 ? 0 : e : a("Authoritative simulation numbers require signed 32-bit raw integers"), f = class {
+	#e = {
+		hi: 3421674724,
+		lo: 2216829733
+	};
+	byte(e) {
+		this.#e = n({
+			hi: this.#e.hi,
+			lo: (this.#e.lo ^ e) >>> 0
+		}, {
+			hi: 256,
+			lo: 435
+		});
+	}
+	uint(e) {
+		for (let t = 0; t < 4; t++) this.byte(e >>> t * 8 & 255);
+	}
+	string(e) {
+		this.uint(e.length);
+		for (let t of e) this.byte(t);
+	}
+	finish() {
+		return Object.freeze({ ...this.#e });
+	}
+}, p = (e, t, n = 0, r = !0) => {
+	if (n > 64) return a("Simulation schema exceeds nesting budget");
+	if (e.kind === "number") {
+		if (t && (!e.integer || e.q || e.wrap)) return a("Authoritative simulation numbers require Int raw values without quantization");
+	} else if (e.kind === "literal") {
+		if (t) for (let t of e.values) typeof t == "number" && d(t);
+	} else if (e.kind === "struct") {
+		if (e.transform) return a("Movement transforms are not deterministic simulation state");
+		for (let i of e.fields) {
+			if (i.nonAuthoritative && !r) return a("Non-authoritative annotations belong to simulation state, not input or init option schemas");
+			p(i.node, t && !i.nonAuthoritative, n + 1, r);
+		}
+	} else if (e.kind === "array" || e.kind === "record") p(e.element, t, n + 1, r);
+	else if (e.kind === "transform3d" || e.kind === "union") return a("Simulation state requires declared structs, collections and literal enums");
+}, m = (e, t, n, s) => {
+	let m = c(t), h = r(e, m, n);
+	p(h, s, 0, n);
+	let g = (t, n) => {
+		let r = 0, c = 0, p = new f(), g = (e) => {
+			c += e, c > m.maxBytes && o("simulationValueBytes", m.maxBytes);
+		}, _ = (e) => {
+			if (typeof e != "string" || !e.isWellFormed()) return a("Simulation text requires well-formed Unicode");
+			if (e.length > m.maxBytes - c) return o("simulationValueBytes", m.maxBytes);
+			let t = new TextEncoder().encode(e);
+			return g(4 + t.length), {
+				value: e,
+				bytes: t
+			};
+		}, v = (e, t, i) => {
+			if (++r > m.maxNodes) return o("simulationValueNodes", m.maxNodes);
+			g(1);
+			let s = n && i;
+			if (e.kind === "number") {
+				let e = i ? d(t) : typeof t == "number" && Number.isFinite(t) ? t : a("Cosmetic numbers must be finite");
+				return g(4), s && (p.byte(1), p.uint(e >>> 0)), e;
+			}
+			if (e.kind === "string") {
+				let e = _(t);
+				return s && (p.byte(2), p.string(e.bytes)), e.value;
+			}
+			if (e.kind === "boolean") return typeof t == "boolean" ? (s && (p.byte(3), p.byte(+!!t)), t) : a("Expected simulation boolean");
+			if (e.kind === "literal") {
+				if (!e.values.some((e) => Object.is(e, t) || e === t)) return a("Simulation value is outside its literal enum");
+				if (s && p.byte(4), t === null) return s && p.byte(0), null;
+				if (typeof t == "number") {
+					let e = i ? d(t) : t;
+					return g(4), s && (p.byte(1), p.uint(e >>> 0)), e;
+				}
+				if (typeof t == "string") {
+					let e = _(t);
+					return s && (p.byte(2), p.string(e.bytes)), e.value;
+				}
+				return typeof t == "boolean" ? (s && (p.byte(3), p.byte(+!!t)), t) : a("Invalid simulation literal");
+			}
+			if (e.kind === "array") {
+				if (!Array.isArray(t) || t.length > m.maxCollectionLength) return o("simulationCollectionLength", m.maxCollectionLength);
+				if (Reflect.ownKeys(t).length !== t.length + 1) return a("Simulation arrays must be dense own data without extra fields");
+				g(4), s && (p.byte(6), p.uint(t.length));
+				let n = [];
+				for (let r = 0; r < t.length; r++) {
+					let o = l(t, String(r));
+					if (!o) return a("Simulation arrays must be dense");
+					n.push(v(e.element, o.value, i));
+				}
+				return n;
+			}
+			if (e.kind === "struct") {
+				let r = u(t), o = Reflect.ownKeys(r);
+				if (o.length > e.fields.length || o.some((t) => typeof t != "string" || !e.fields.some((e) => e.name === t))) return a("Simulation state contains undeclared fields");
+				let c = {};
+				g(4), s && (p.byte(5), p.uint(e.fields.filter((e) => !e.nonAuthoritative).length));
+				for (let t of e.fields) {
+					let e = l(r, t.name), o = i && !t.nonAuthoritative;
+					if (!e && !t.optional) return a("Required simulation state field is absent");
+					g(5), n && o && (p.uint(t.id), p.byte(+!!e)), e && Object.defineProperty(c, t.name, {
+						value: v(t.node, e.value, o),
+						writable: !0,
+						enumerable: !0,
+						configurable: !0
+					});
+				}
+				return c;
+			}
+			if (e.kind === "record") {
+				let n = u(t), r = Reflect.ownKeys(n);
+				if (r.length > m.maxCollectionLength) return o("simulationCollectionLength", m.maxCollectionLength);
+				if (r.some((e) => typeof e != "string")) return a("Simulation records require string keys");
+				let c = r.sort(), d = Object.create(null);
+				g(4), s && (p.byte(7), p.uint(c.length));
+				for (let t of c) {
+					let r = l(n, t);
+					if (!r) return a("Simulation record field disappeared");
+					let o = _(t);
+					s && p.string(o.bytes), d[t] = v(e.element, r.value, i);
+				}
+				return d;
+			}
+			return a("Unsupported simulation schema node");
+		}, y = v(h, t, s);
+		return i.decodeUnknownSync(e)(y), {
+			value: y,
+			hash: p.finish()
+		};
+	};
+	return Object.freeze({
+		limits: m,
+		schemaDescription: () => JSON.stringify({
+			authoritativeIntegers: s,
+			explicitIds: n,
+			plan: h
+		}),
+		capture: (e) => g(e, !1).value,
+		hash: (e) => g(e, !0).hash
+	});
+}, h = (e, t = {}) => m(e, t, !0, !0), g = (e, t) => e.hash(t);
+export { h as createSimulationState, g as schemaSimulationHash, m as simulationValueCodec };

package/dist/snapshotBlob.js

@@ -0,0 +1,125 @@
+import { ProtocolError as e } from "./errors.js";
+import { canonicalRoomJson as t } from "./checkpointJson.js";
+import { RoomSnapshotBlobPort as n } from "./ports.js";
+import { Effect as r, Layer as i, Stream as a } from "effect";
+import { createHash as o } from "node:crypto";
+// src/snapshotBlob.ts
+function s(t) {
+	throw new e({ detail: t });
+}
+var c = (e) => o("sha256").update(e).digest("hex"), l = (e) => typeof e == "string" && e.trim() && e.length <= 191 ? e : s("Invalid snapshot blob identity"), u = (e) => !e || ![e.epoch, e.revision].every((e) => Number.isSafeInteger(e) && e > 0) ? s("Invalid snapshot blob durable counters") : Object.freeze({
+	tenantId: l(e.tenantId),
+	roomId: l(e.roomId),
+	epoch: e.epoch,
+	revision: e.revision
+}), d = (e, n, r) => {
+	let i = u(e), a = u(n);
+	return t(i) !== t(a) || e.version !== 1 || !Number.isSafeInteger(e.size) || e.size < 1 || e.size > r || !/^[a-f0-9]{64}$/.test(e.checksum) || !/^rooms:snapshot:[a-f0-9]{64}$/.test(e.claim) ? s("Snapshot blob reference scope or budget mismatch") : Object.freeze({
+		...i,
+		version: 1,
+		refId: l(e.refId),
+		claim: e.claim,
+		size: e.size,
+		checksum: e.checksum
+	});
+}, f = (e, t) => {
+	e && e.id === t.refId && e.tenantId === t.tenantId && e.visibility === "private" && e.size === t.size && e.checksum === t.checksum && e.contentType === "application/octet-stream" || s("Snapshot blob storage metadata or private ownership mismatch");
+}, p = (t) => r.flatMap(r.context(), (n) => r.uninterruptible(r.tryPromise({
+	try: () => t(r.runPromiseWith(n)),
+	catch: (t) => t instanceof e ? t : new e({ detail: "Snapshot blob storage operation remains unconfirmed" })
+}))), m = (t) => {
+	try {
+		return t();
+	} catch (t) {
+		return r.fail(t instanceof e ? t : new e({ detail: "Snapshot blob admission failed" }));
+	}
+}, h = (n, i = {}) => {
+	if (!i || typeof i != "object" || Array.isArray(i) || Object.keys(i).some((e) => ![
+		"maxBytes",
+		"destination",
+		"operations"
+	].includes(e))) return s("Invalid snapshot blob options");
+	let o = i.maxBytes ?? 1048576, h = i.destination === void 0 ? void 0 : l(i.destination);
+	if (!Number.isSafeInteger(o) || o < 1 || o > 67108864 || !n || ![
+		"put",
+		"head",
+		"getStream",
+		"delete"
+	].every((e) => typeof Reflect.get(n, e) == "function")) return s("Invalid snapshot blob budget or incomplete StorageService");
+	let g = n.put.bind(n), _ = n.head.bind(n), v = n.getStream.bind(n), y = n.delete.bind(n);
+	if (i.operations !== void 0 && (!i.operations || !i.operations.metadata || typeof i.operations.metadata.lookup != "function")) return s("Snapshot recovery requires the actual durable operation metadata lookup");
+	let b = i.operations === void 0 ? void 0 : l(i.operations.bucket), x = i.operations?.metadata.lookup.bind(i.operations.metadata);
+	if (i.operations !== void 0 && (!x || h !== void 0 && h !== b)) return s("Snapshot recovery requires the same durable destination and metadata boundary");
+	let S = (e) => c(t(e));
+	return Object.freeze({
+		write: (t) => m(() => {
+			let n = u(t), i = `rooms:snapshot:${c(l(t.claimId))}`;
+			if (!(t.bytes instanceof Uint8Array) || t.bytes.byteLength < 1 || t.bytes.byteLength > o) return r.fail(new e({ detail: "Snapshot blob bytes exceed their budget" }));
+			let a = Uint8Array.from(t.bytes), s = c(a), d = S(n);
+			return p(async (e) => {
+				let t = await e(g({
+					bytes: a,
+					tenantId: n.tenantId,
+					contentType: "application/octet-stream",
+					visibility: "private",
+					operationId: `rooms:snapshot:${d}`,
+					claim: i,
+					key: `rooms/${d}`,
+					...h ? { destination: h } : {}
+				})), r = Object.freeze({
+					...n,
+					version: 1,
+					refId: t.id,
+					claim: i,
+					size: a.byteLength,
+					checksum: s
+				});
+				return f(t, r), r;
+			});
+		}),
+		recover: (t) => m(() => {
+			let n = u(t), i = `rooms:snapshot:${c(l(t.claimId))}`, a = t.size, s = t.checksum;
+			return !x || !b ? r.fail(new e({ detail: "Snapshot upload recovery requires the actual durable Storage metadata boundary" })) : !Number.isSafeInteger(a) || a < 1 || a > o || !/^[a-f0-9]{64}$/.test(s) ? r.fail(new e({ detail: "Snapshot recovery payload identity is invalid" })) : p(async () => {
+				let e = await x({
+					tenantId: n.tenantId,
+					bucket: b,
+					operationId: `rooms:snapshot:${S(n)}`
+				}, i);
+				if (!e || e.state === "reserved") return Object.freeze({ state: "pending" });
+				let t = d({
+					...n,
+					version: 1,
+					refId: e.ref.id,
+					claim: i,
+					size: a,
+					checksum: s
+				}, n, o);
+				return f(e.ref, t), Object.freeze({
+					state: e.state === "deleted" ? "released" : "ready",
+					reference: t
+				});
+			});
+		}),
+		read: (e, t) => m(() => {
+			let n = d(e, t, o);
+			return p(async (e) => {
+				f(await e(_(n.refId, { tenantId: n.tenantId })), n);
+				let t = await e(v(n.refId, { tenantId: n.tenantId }));
+				f(t.ref, n);
+				let i = new Uint8Array(n.size), o = 0;
+				return await e(a.runForEach(t.stream, (e) => r.sync(() => {
+					if (!(e instanceof Uint8Array) || e.byteLength > i.byteLength - o) return s("Snapshot blob stream exceeds its recorded size");
+					i.set(e, o), o += e.byteLength;
+				}))), o !== i.byteLength || c(i) !== n.checksum ? s("Snapshot blob content integrity failed") : i;
+			});
+		}),
+		release: (e, t) => m(() => {
+			let n = d(e, t, o);
+			return p((e) => e(y(n.refId, {
+				tenantId: n.tenantId,
+				claim: n.claim
+			})));
+		})
+	});
+}, g = (e, t = {}) => i.succeed(n, h(e, t));
+export { d as captureRoomSnapshotBlobReference, g as roomSnapshotBlobLayer, h as storageRoomSnapshotBlobs };