@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/stateCodec.js

@@ -0,0 +1,657 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { RoomFieldId as n, RoomNonAuthoritative as r, RoomPrecision as i, RoomQuantization as a, RoomTransform as o, dequantize as s, quantizationStep as c, quantize as l } from "./room.js";
+import { captureTransformRules as u } from "./transformRules.js";
+import { decodeQuaternionSmallestThree as d, encodeQuaternionSmallestThree as f, quaternionByteLength as p } from "./quaternion.js";
+import { shapeDigest as m } from "@voltro/protocol";
+import { Result as h, Schema as g } from "effect";
+// src/stateCodec.ts
+function _(t) {
+	throw new e({ detail: t });
+}
+function v(e) {
+	throw new t({
+		room: "state-codec",
+		detail: e
+	});
+}
+var y = (e) => typeof e == "object" && e && !Array.isArray(e) ? e : _("Expected a state object"), b = class {
+	limit;
+	input;
+	output = [];
+	at = 0;
+	constructor(e, t) {
+		this.limit = e, this.input = t;
+	}
+	byte(e) {
+		if (e !== void 0) return (!Number.isInteger(e) || e < 0 || e > 255 || this.output.length >= this.limit) && _("Invalid byte or state byte budget exceeded"), this.output.push(e), e;
+		let t = this.input?.[this.at++];
+		return t === void 0 ? _("Truncated state") : t;
+	}
+	writeUint(e) {
+		e < 0n && _("Negative unsigned integer");
+		do {
+			let t = Number(e & 127n);
+			e >>= 7n, this.byte(t | (e > 0n ? 128 : 0));
+		} while (e > 0n);
+	}
+	readUint(e = 53) {
+		let t = 0n;
+		for (let n = 0; n < Math.ceil(e / 7); n++) {
+			let r = this.byte(), i = r & 127;
+			if (t |= BigInt(i) << BigInt(n * 7), r < 128) return (n > 0 && i === 0 || t >= 1n << BigInt(e)) && _("Noncanonical or overflowing integer"), t;
+		}
+		return _("Integer exceeds its bit budget");
+	}
+	writeCount(e) {
+		(!Number.isSafeInteger(e) || e < 0) && _("Invalid count"), this.writeUint(BigInt(e));
+	}
+	count(e) {
+		let t = Number(this.readUint());
+		return t <= e ? t : _("Collection exceeds its budget");
+	}
+	string(e) {
+		if (e !== void 0) {
+			e.isWellFormed() || _("Invalid Unicode string"), e.length > this.limit && _("String exceeds its byte budget");
+			let t = new TextEncoder().encode(e);
+			this.writeCount(t.length);
+			for (let e of t) this.byte(e);
+			return e;
+		}
+		let t = this.count(this.limit);
+		(!this.input || t > this.input.length - this.at) && _("Truncated string");
+		let n = new Uint8Array(t);
+		for (let e = 0; e < t; e++) n[e] = this.byte();
+		return new TextDecoder("utf-8", { fatal: !0 }).decode(n);
+	}
+	float(e, t = "f32") {
+		let n = new Uint8Array(t === "f32" ? 4 : 8), r = new DataView(n.buffer);
+		if (e !== void 0) {
+			t === "f32" ? r.setFloat32(0, e, !0) : r.setFloat64(0, e, !0), Number.isFinite(t === "f32" ? r.getFloat32(0, !0) : r.getFloat64(0, !0)) || _("Number exceeds its finite precision range");
+			for (let e of n) this.byte(e);
+			return e;
+		}
+		for (let e = 0; e < n.length; e++) n[e] = this.byte();
+		let i = t === "f32" ? r.getFloat32(0, !0) : r.getFloat64(0, !0);
+		return Number.isFinite(i) ? i : _("Nonfinite state number");
+	}
+	end() {
+		this.input && this.at !== this.input.length && _("Trailing state bytes");
+	}
+}, x = (e, t) => {
+	for (let n = (e?.length ?? 0) - 1; n >= 0; n--) {
+		let r = e[n], i = r.annotations === void 0 ? void 0 : Reflect.get(r.annotations, t);
+		if (i !== void 0) return i;
+		if (r._tag === "FilterGroup") {
+			let e = x(r.checks, t);
+			if (e !== void 0) return e;
+		}
+	}
+}, S = (e, t) => {
+	let n = x(e.checks, t);
+	if (n !== void 0) return n;
+	let r = e.annotations === void 0 ? void 0 : Reflect.get(e.annotations, t);
+	if (r !== void 0) return r;
+	if (e._tag === "Union") {
+		let n = e.types.map((e) => S(e, t)).filter((e) => e !== void 0);
+		if (n.length === 1) return n[0];
+	}
+}, C = (e) => typeof e == "bigint" ? v("BigInt state literals require a declared integer representation") : e, w = (e) => e?.some((e) => e.annotations?.representation?.id === "effect/schema/isInt" || e._tag === "FilterGroup" && w(e.checks)) ?? !1, T = (e, t = 0) => {
+	t > 64 && v("State schema nesting exceeds its compile budget");
+	let n = [];
+	for (let r of e) {
+		if (r.encoding !== void 0) return;
+		if (r._tag === "Literal") n.push(C(r.literal));
+		else if (r._tag === "Null") n.push(null);
+		else if (r._tag === "Union") {
+			let e = T(r.types, t + 1);
+			if (e === void 0) return;
+			n.push(...e);
+		} else return;
+		if (n.length > 256) return;
+	}
+	return n;
+}, E = (e, t, s = 0, l = !1, d, f = "f32", p = !0, m, h = "f32") => {
+	s > 64 && v("State schema nesting exceeds its compile budget"), d = S(e, a) ?? d;
+	let _ = S(e, i), y = S(e, o) ?? m;
+	if (y !== void 0 && !p && v("Transform metadata belongs to authoritative state, not input intentions"), _ !== void 0 && (_ !== "f32" && _ !== "f64" && v("Number precision must be f32 or f64"), f = _), e.encoding !== void 0 && v("Transformed state/input schemas require an explicit supported binary representation"), y !== void 0 && e._tag !== "Objects" && e._tag !== "Union" && v("Transform metadata requires a declared movement struct"), e._tag === "Number") return d && c(d), {
+		kind: "number",
+		integer: l || w(e.checks),
+		precision: f,
+		q: d ? Object.freeze({ ...d }) : void 0
+	};
+	if (e._tag === "String") return { kind: "string" };
+	if (e._tag === "Boolean") return { kind: "boolean" };
+	if (e._tag === "Null") return {
+		kind: "literal",
+		values: [null]
+	};
+	if (e._tag === "Literal") return {
+		kind: "literal",
+		values: [C(e.literal)]
+	};
+	if (e._tag === "Union") {
+		let n = e.types.filter((e) => e._tag !== "Undefined");
+		if (n.length === 1 && n[0]) return E(n[0], t, s + 1, l, d, f, p, y, h);
+		y !== void 0 && v("Transform metadata cannot annotate state variants");
+		let r = T(n);
+		return r !== void 0 && r.length > 0 ? {
+			kind: "literal",
+			values: r
+		} : !p && n.length > 0 && n.length <= 256 ? {
+			kind: "union",
+			variants: n.map((e) => ({
+				node: E(e, t, s + 1, !1, void 0, h, !1, void 0, h),
+				matches: g.is(g.make(e))
+			}))
+		} : v("State unions must be literal enums; input unions are separate from state");
+	}
+	if (e._tag === "Arrays" && e.elements.length === 0 && e.rest.length === 1 && e.rest[0]) return {
+		kind: "array",
+		element: E(e.rest[0], t, s + 1, !1, void 0, h, p, void 0, h)
+	};
+	if (e._tag === "Objects") {
+		let a = y === void 0 ? void 0 : u(y), o = a?.bounds.min.length === 2 ? a : void 0, c = a?.bounds.min.length === 3 ? a : void 0;
+		if (o && (e.indexSignatures.length !== 0 || e.propertySignatures.some((e) => typeof e.name != "string" || ![
+			"x",
+			"y",
+			"rot",
+			"vx",
+			"vy"
+		].includes(e.name) || ["vx", "vy"].includes(e.name) && !(e.type.context?.isOptional ?? !1)) || [
+			"x",
+			"y",
+			"rot"
+		].some((t) => e.propertySignatures.filter((e) => e.name === t && !(e.type.context?.isOptional ?? !1)).length !== 1)) && v("Transform metadata requires x/y/rot and only optional vx/vy in a 2D struct"), c && (e.indexSignatures.length !== 0 || e.propertySignatures.length !== 7 || e.propertySignatures.some((e) => typeof e.name != "string" || (e.type.context?.isOptional ?? !1) || ![
+			"x",
+			"y",
+			"z",
+			"qx",
+			"qy",
+			"qz",
+			"qw"
+		].includes(e.name)) || [
+			"x",
+			"y",
+			"z",
+			"qx",
+			"qy",
+			"qz",
+			"qw"
+		].some((t) => e.propertySignatures.filter((e) => e.name === t).length !== 1)) && v("3D transform metadata requires exactly x/y/z/qx/qy/qz/qw"), e.propertySignatures.length === 0 && e.indexSignatures.length === 1 && e.indexSignatures[0]) {
+			let n = e.indexSignatures[0];
+			return n.parameter._tag !== "String" && v("State records require string keys"), {
+				kind: "record",
+				element: E(n.type, t, s + 1, !1, void 0, h, p, void 0, h)
+			};
+		}
+		e.indexSignatures.length !== 0 && v("Mixed record/struct state schemas are not allowed");
+		let l = /* @__PURE__ */ new Set(), d = (p ? e.propertySignatures : [...e.propertySignatures].sort((e, t) => String(e.name) < String(t.name) ? -1 : +(String(e.name) > String(t.name)))).map((e, a) => {
+			let u = (e.type.context?.annotations === void 0 ? void 0 : Reflect.get(e.type.context.annotations, n)) ?? S(e.type, n) ?? (p ? void 0 : a + 1);
+			if (typeof e.name != "string" || typeof u != "number" || !Number.isSafeInteger(u) || u < 1 || u > t.maxFieldId || l.has(u)) return v("Every struct field needs a unique fieldId within its configured budget");
+			l.add(u);
+			let d = E(e.type, t, s + 1, !1, void 0, h, p, void 0, h);
+			if (o) {
+				if ((d.kind !== "number" || d.integer || d.q || S(e.type, i) !== void 0) && v("Transform components must be ordinary numbers without competing encoding annotations"), e.name === "x" || e.name === "y") {
+					let t = e.name === "x" ? 0 : 1;
+					d = {
+						...d,
+						q: Object.freeze({
+							min: o.bounds.min[t],
+							max: o.bounds.max[t],
+							step: o.precision
+						})
+					};
+				} else if (e.name === "rot") {
+					let e = 2 ** (o.rotation?.bits ?? 9), t = 360 / e;
+					d = {
+						...d,
+						q: Object.freeze({
+							min: 0,
+							max: 360 - t,
+							step: t
+						}),
+						wrap: e
+					};
+				} else o.velocity === "send" && (d = {
+					...d,
+					q: Object.freeze({
+						min: -o.maxSpeed,
+						max: o.maxSpeed,
+						step: o.maxSpeed * 2 / 255
+					})
+				});
+			}
+			if (c && ((d.kind !== "number" || d.integer || d.q || S(e.type, i) !== void 0) && v("3D transform components must be ordinary numbers without competing encoding annotations"), e.name === "x" || e.name === "y" || e.name === "z")) {
+				let t = e.name === "x" ? 0 : e.name === "y" ? 1 : 2;
+				d = {
+					...d,
+					q: Object.freeze({
+						min: c.bounds.min[t],
+						max: c.bounds.max[t],
+						step: c.precision
+					})
+				};
+			}
+			let f = o && (e.name === "vx" || e.name === "vy") && (o.velocity === "derive" || o.velocity === "none");
+			return {
+				name: e.name,
+				id: u,
+				optional: e.type.context?.isOptional ?? !1,
+				node: d,
+				...f ? { omit: !0 } : {},
+				...(e.type.context?.annotations === void 0 ? void 0 : Reflect.get(e.type.context.annotations, r)) === !0 || S(e.type, r) === !0 ? { nonAuthoritative: !0 } : {}
+			};
+		}).sort((e, t) => e.id - t.id);
+		return c ? {
+			kind: "transform3d",
+			fields: d,
+			transform: c
+		} : {
+			kind: "struct",
+			fields: d,
+			...o ? { transform: o } : {}
+		};
+	}
+	return v(`State schema node ${e._tag} has no binary state representation`);
+}, D = (e, t, n = !0) => E(e.ast, t, 0, !1, void 0, "f32", n), O = (e, t) => {
+	if (typeof t != "number" || !Number.isFinite(t)) return _("Expected a finite number");
+	if (e.q) return e.wrap === void 0 ? l(t, e.q) : Math.round((t % 360 + 360) % 360 / c(e.q)) % e.wrap;
+	if (e.integer) return Number.isSafeInteger(t) ? t : _("Expected a safe integer");
+	let n = e.precision === "f64" ? t : Math.fround(t);
+	return Number.isFinite(n) ? n : _("Number exceeds finite f32 range");
+}, k = (e) => 1n << BigInt(e - 1), A = (e, t) => Array.isArray(e) && e.length <= t.maxCollectionLength ? e : _("Array exceeds its budget or has an invalid shape"), j = (e) => ({
+	kind: "struct",
+	fields: e.fields.filter((e) => [
+		"x",
+		"y",
+		"z"
+	].includes(e.name))
+}), M = (e, t) => {
+	let n = y(t), r = f({
+		qx: n.qx,
+		qy: n.qy,
+		qz: n.qz,
+		qw: n.qw
+	}, e.transform.rotation?.bits ?? 10);
+	if (h.isFailure(r)) throw r.failure;
+	return r.success;
+}, N = (e, t, n) => {
+	let r = M(e, t), i = M(e, n);
+	return r.length === i.length && r.every((e, t) => e === i[t]);
+}, P = (e, t) => {
+	let n = e.transform.rotation?.bits ?? 10, r = new Uint8Array(p(n));
+	for (let e = 0; e < r.length; e++) r[e] = t.byte();
+	let i = d(r, n);
+	if (h.isFailure(i)) throw i.failure;
+	return i.success;
+}, F = (e, t, n, r) => {
+	switch (e.kind) {
+		case "transform3d":
+			F(j(e), t, n, r);
+			for (let r of M(e, t)) n.byte(r);
+			return;
+		case "union": {
+			let i = e.variants.findIndex((e) => e.matches(t)), a = e.variants[i];
+			a || _("Input matches no declared union variant"), n.byte(i), F(a.node, t, n, r);
+			return;
+		}
+		case "number": {
+			let r = O(e, t);
+			if (e.q) n.writeCount(r);
+			else if (e.integer) {
+				let e = BigInt(r);
+				n.writeUint(e < 0n ? -e * 2n - 1n : e * 2n);
+			} else n.float(r, e.precision);
+			return;
+		}
+		case "string":
+			typeof t != "string" && _("Expected a string"), n.string(t);
+			return;
+		case "boolean":
+			typeof t != "boolean" && _("Expected a boolean"), n.byte(+!!t);
+			return;
+		case "literal": {
+			let r = e.values.indexOf(t);
+			r < 0 && _("Unknown literal"), n.byte(r);
+			return;
+		}
+		case "array": {
+			let i = A(t, r);
+			n.writeCount(i.length);
+			for (let t of i) F(e.element, t, n, r);
+			return;
+		}
+		case "record": {
+			let i = y(t), a = Object.keys(i).sort();
+			a.length > r.maxCollectionLength && _("Record exceeds its budget"), n.writeCount(a.length);
+			for (let t of a) n.string(t), F(e.element, i[t], n, r);
+			return;
+		}
+		case "struct": {
+			let i = y(t), a = e.fields.filter((e) => e.node.kind === "boolean");
+			a.length && n.writeUint(a.reduce((e, t, n) => i[t.name] === !0 ? e | k(n + 1) : e, 0n));
+			for (let t of e.fields) {
+				if (t.omit) continue;
+				let e = i[t.name];
+				t.optional && n.byte(e === void 0 ? 0 : 1), t.node.kind === "boolean" || e === void 0 && t.optional || F(t.node, e, n, r);
+			}
+		}
+	}
+}, I = (e, t, n) => {
+	Object.defineProperty(e, t, {
+		value: n,
+		writable: !0,
+		enumerable: !0,
+		configurable: !0
+	});
+}, L = (e, t, n) => {
+	switch (e.kind) {
+		case "transform3d": return Object.assign(y(L(j(e), t, n)), P(e, t));
+		case "union": {
+			let r = e.variants[t.byte()];
+			return r ? L(r.node, t, n) : _("Invalid input union variant");
+		}
+		case "number": {
+			if (e.q) return s(Number(t.readUint()), e.q);
+			if (!e.integer) return t.float(void 0, e.precision);
+			let n = t.readUint(54), r = n & 1n ? -(n + 1n) / 2n : n / 2n, i = Number(r);
+			return Number.isSafeInteger(i) ? i : _("Integer exceeds safe precision");
+		}
+		case "string": return t.string();
+		case "boolean": {
+			let e = t.byte();
+			return e < 2 ? e === 1 : _("Invalid boolean");
+		}
+		case "literal": {
+			let n = t.byte();
+			return n < e.values.length ? e.values[n] : _("Invalid literal index");
+		}
+		case "array": {
+			let r = t.count(n.maxCollectionLength), i = [];
+			for (let a = 0; a < r; a++) i.push(L(e.element, t, n));
+			return i;
+		}
+		case "record": {
+			let r = {}, i = t.count(n.maxCollectionLength);
+			for (let a = 0; a < i; a++) {
+				let i = t.string();
+				Object.hasOwn(r, i) && _("Duplicate record key"), I(r, i, L(e.element, t, n));
+			}
+			return r;
+		}
+		case "struct": {
+			let r = {}, i = e.fields.filter((e) => e.node.kind === "boolean"), a = i.length ? t.readUint(i.length) : 0n;
+			for (let o of e.fields) if (!o.omit) {
+				if (o.optional) {
+					let e = t.byte();
+					if (e > 1 && _("Invalid optional presence"), !e) continue;
+				}
+				I(r, o.name, o.node.kind === "boolean" ? (a & k(i.indexOf(o) + 1)) !== 0n : L(o.node, t, n));
+			}
+			return r;
+		}
+	}
+}, R = (e, t, n, r) => {
+	if (t === void 0 || n === void 0) return t === n;
+	if (e.kind === "number") return O(e, t) === O(e, n);
+	if (e.kind === "transform3d") return R(j(e), t, n, r) && N(e, t, n);
+	if (e.kind === "struct") return e.fields.every((e) => e.omit || R(e.node, y(t)[e.name], y(n)[e.name], r));
+	if (e.kind === "record") {
+		let i = y(t), a = y(n), o = Object.keys(i);
+		return o.length === Object.keys(a).length && o.every((t) => Object.hasOwn(a, t) && R(e.element, i[t], a[t], r));
+	}
+	if (e.kind === "array") {
+		let i = A(t, r), a = A(n, r);
+		return i.length === a.length && i.every((t, n) => R(e.element, t, a[n], r));
+	}
+	return t === n;
+}, z = (e, t, n, r, i) => {
+	if (e.kind === "transform3d") {
+		z(j(e), t, n, r, i);
+		let a = !N(e, t, n);
+		if (r.byte(+!!a), a) for (let n of M(e, t)) r.byte(n);
+	} else if (e.kind === "number" && (e.q || e.integer)) {
+		let i = BigInt(O(e, t)) - BigInt(O(e, n));
+		if (e.wrap !== void 0) {
+			let t = BigInt(e.wrap), n = t / 2n;
+			i = ((i + n) % t + t) % t - n;
+		}
+		r.writeUint(i < 0n ? -i * 2n - 1n : i * 2n);
+	} else if (e.kind === "array") {
+		let a = A(t, i), o = A(n, i);
+		if (a.length === 0) {
+			r.writeCount(1), r.byte(3);
+			return;
+		}
+		let s = Math.min(a.length, o.length), c = [];
+		for (let t = 0; t < s; t++) R(e.element, a[t], o[t], i) || c.push(t);
+		r.writeCount(c.length + Math.abs(a.length - o.length));
+		for (let t of c) r.byte(0), r.writeCount(t), F(e.element, a[t], r, i);
+		for (let e = o.length - 1; e >= a.length; e--) r.byte(2), r.writeCount(e);
+		for (let t = o.length; t < a.length; t++) r.byte(1), F(e.element, a[t], r, i);
+	} else if (e.kind === "struct") {
+		let a = y(t), o = y(n), s = e.fields.filter((e) => !e.omit && !R(e.node, a[e.name], o[e.name], i));
+		r.writeUint(s.reduce((e, t) => e | k(t.id), 0n));
+		let c = s.filter((e) => e.node.kind === "boolean");
+		c.length && r.writeUint(c.reduce((e, t, n) => a[t.name] === !0 ? e | k(n + 1) : e, 0n));
+		for (let e of s) {
+			let t = a[e.name], n = o[e.name];
+			e.optional && t === void 0 ? r.byte(0) : (r.byte(n === void 0 ? 1 : 2), e.node.kind !== "boolean" && (n === void 0 ? F(e.node, t, r, i) : z(e.node, t, n, r, i)));
+		}
+	} else if (e.kind === "record") {
+		let a = y(t), o = y(n), s = Object.keys(o).filter((e) => !Object.hasOwn(a, e)).sort(), c = Object.keys(a).filter((t) => !Object.hasOwn(o, t) || !R(e.element, a[t], o[t], i)).sort();
+		r.writeCount(s.length + c.length);
+		for (let e of s) r.byte(2), r.string(e);
+		for (let t of c) {
+			let n = Object.hasOwn(o, t);
+			r.byte(+!!n), r.string(t), n ? z(e.element, a[t], o[t], r, i) : F(e.element, a[t], r, i);
+		}
+	} else F(e, t, r, i);
+}, B = (e, t, n, r) => {
+	if (e.kind === "transform3d") {
+		let i = y(B(j(e), t, n, r)), a = n.byte();
+		return a > 1 && _("Invalid 3D quaternion delta flag"), a ? Object.assign(i, P(e, n)) : i;
+	}
+	if (e.kind === "number" && (e.q || e.integer)) {
+		let r = n.readUint(55), i = r & 1n ? -(r + 1n) / 2n : r / 2n, a = BigInt(O(e, t)) + i;
+		if (e.wrap !== void 0) {
+			let t = BigInt(e.wrap), n = t / 2n;
+			(i < -n || i >= n) && _("Noncanonical wrapped rotation delta"), a = (a % t + t) % t;
+		}
+		let o = Number(a);
+		return Number.isSafeInteger(o) || _("Numeric delta exceeds safe precision"), e.q ? s(o, e.q) : o;
+	}
+	if (e.kind === "array") {
+		let i = [...A(t, r)], a = n.count(r.maxCollectionLength * 2);
+		for (let t = 0; t < a; t++) {
+			let t = n.byte();
+			if (t === 0) {
+				let t = n.count(r.maxCollectionLength);
+				t >= i.length && _("Array set index is absent"), i[t] = L(e.element, n, r);
+			} else if (t === 1) i.length >= r.maxCollectionLength && _("Array exceeds its budget"), i.push(L(e.element, n, r));
+			else if (t === 2) {
+				let e = n.count(r.maxCollectionLength);
+				e >= i.length && _("Array remove index is absent"), i.splice(e, 1);
+			} else t === 3 && a === 1 ? i.length = 0 : _("Invalid array delta operation");
+		}
+		return i;
+	}
+	if (e.kind === "struct") {
+		let i = { ...y(t) }, a = n.readUint(r.maxFieldId);
+		(a & ~e.fields.reduce((e, t) => t.omit ? e : e | k(t.id), 0n)) !== 0n && _("Delta refers to an undeclared field");
+		let o = e.fields.filter((e) => e.node.kind === "boolean" && (a & k(e.id)) !== 0n), s = o.length ? n.readUint(o.length) : 0n;
+		for (let t of e.fields) {
+			if (t.omit) {
+				delete i[t.name];
+				continue;
+			}
+			if ((a & k(t.id)) === 0n) continue;
+			let e = n.byte();
+			e === 0 && t.optional ? delete i[t.name] : (e === 1 || e === 2) && t.node.kind === "boolean" && (e === 1 || i[t.name] !== void 0) ? Object.defineProperty(i, t.name, {
+				value: (s & k(o.indexOf(t) + 1)) !== 0n,
+				writable: !0,
+				enumerable: !0,
+				configurable: !0
+			}) : e === 1 ? Object.defineProperty(i, t.name, {
+				value: L(t.node, n, r),
+				writable: !0,
+				enumerable: !0,
+				configurable: !0
+			}) : e === 2 && i[t.name] !== void 0 ? Object.defineProperty(i, t.name, {
+				value: B(t.node, i[t.name], n, r),
+				writable: !0,
+				enumerable: !0,
+				configurable: !0
+			}) : _("Invalid field delta mode");
+		}
+		return i;
+	}
+	if (e.kind === "record") {
+		let i = {}, a = n.count(r.maxCollectionLength * 2);
+		for (let [e, n] of Object.entries(y(t))) I(i, e, n);
+		let o = /* @__PURE__ */ new Set();
+		for (let t = 0; t < a; t++) {
+			let t = n.byte(), a = n.string();
+			o.has(a) && _("Repeated record delta key"), o.add(a), t === 0 && !Object.hasOwn(i, a) ? I(i, a, L(e.element, n, r)) : t === 1 && Object.hasOwn(i, a) ? I(i, a, B(e.element, i[a], n, r)) : t === 2 && Object.hasOwn(i, a) ? delete i[a] : _("Invalid record operation"), Object.keys(i).length > r.maxCollectionLength && _("Record exceeds its budget");
+		}
+		return i;
+	}
+	return L(e, n, r);
+}, V = class {
+	schema;
+	schemaHash;
+	limits;
+	node;
+	constructor(e, t = {}, n = !0, r = "f32") {
+		this.schema = e, r !== "f32" && r !== "f64" && v("Invalid codec default number precision");
+		let i = t.maxBytes ?? 1048576;
+		this.limits = Object.freeze({
+			maxBytes: i,
+			maxCollectionLength: 16384,
+			maxFieldId: Number.isSafeInteger(i) && i > 0 ? Math.min(4096, i * 7) : 4096,
+			...t
+		});
+		for (let e of Object.values(this.limits)) (!Number.isSafeInteger(e) || e < 1) && v("Codec limits must be positive safe integers");
+		this.limits.maxFieldId > this.limits.maxBytes * 7 && v("Field-ID masks exceed the configured byte budget"), this.node = E(e.ast, this.limits, 0, !1, void 0, r, n, void 0, r), this.schemaHash = Number.parseInt(m(JSON.stringify(this.node)), 16);
+	}
+	fieldManifest() {
+		let e = [], t = (n, r) => {
+			if (n.kind === "struct" || n.kind === "transform3d") for (let i of n.fields) e.push(Object.freeze({
+				scope: r,
+				id: i.id,
+				name: i.name
+			})), t(i.node, `${r}/${i.id}`);
+			else n.kind === "array" ? t(n.element, `${r}/array`) : n.kind === "record" ? t(n.element, `${r}/record`) : n.kind === "union" && n.variants.forEach((e, n) => t(e.node, `${r}/variant/${n}`));
+		};
+		return t(this.node, "root"), Object.freeze(e);
+	}
+	description() {
+		return JSON.stringify(this.node);
+	}
+	transformRulesManifest() {
+		let e = [], t = (n, r) => {
+			if (n.kind === "struct" || n.kind === "transform3d") {
+				n.transform && e.push(Object.freeze({
+					scope: r,
+					rules: u(n.transform)
+				}));
+				for (let e of n.fields) t(e.node, `${r}/${e.id}`);
+			} else n.kind === "array" ? t(n.element, `${r}/array`) : n.kind === "record" ? t(n.element, `${r}/record`) : n.kind === "union" && n.variants.forEach((e, n) => t(e.node, `${r}/variant/${n}`));
+		};
+		return t(this.node, "root"), Object.freeze(e);
+	}
+	result(t) {
+		try {
+			return h.succeed(t());
+		} catch (t) {
+			return h.fail(t instanceof e ? t : new e({ detail: "State does not match its declared binary schema" }));
+		}
+	}
+	validated(e) {
+		return g.decodeUnknownSync(this.schema)(e), e;
+	}
+	full(e) {
+		return this.result(() => {
+			let t = new b(this.limits.maxBytes);
+			return F(this.node, this.validated(e), t, this.limits), Uint8Array.from(t.output);
+		});
+	}
+	decodeFull(e) {
+		return this.result(() => {
+			e.length > this.limits.maxBytes && _("State exceeds byte budget");
+			let t = new b(this.limits.maxBytes, e), n = L(this.node, t, this.limits);
+			return t.end(), this.validated(n);
+		});
+	}
+	delta(e, t, n = !1) {
+		return this.result(() => {
+			typeof n != "boolean" && _("Unchanged delta selection must be boolean");
+			let r = this.validated(e), i = this.validated(t);
+			if (R(this.node, r, i, this.limits) && !n) return null;
+			let a = new b(this.limits.maxBytes);
+			return z(this.node, r, i, a, this.limits), Uint8Array.from(a.output);
+		});
+	}
+	decodeDelta(e, t) {
+		return this.result(() => {
+			e.length > this.limits.maxBytes && _("Delta exceeds byte budget");
+			let n = this.validated(t), r = new b(this.limits.maxBytes, e), i = B(this.node, n, r, this.limits);
+			return r.end(), this.validated(i);
+		});
+	}
+}, H = class {
+	schema;
+	codec;
+	constructor(e, t = {}) {
+		this.schema = e, this.codec = new V(e, t, !0);
+	}
+	get schemaHash() {
+		return this.codec.schemaHash;
+	}
+	get limits() {
+		return this.codec.limits;
+	}
+	schemaDescription() {
+		return this.codec.description();
+	}
+	fieldManifest() {
+		return this.codec.fieldManifest();
+	}
+	transformRulesManifest() {
+		return this.codec.transformRulesManifest();
+	}
+	full(e) {
+		return this.codec.full(e);
+	}
+	decodeFull(e) {
+		return this.codec.decodeFull(e);
+	}
+	delta(e, t, n = !1) {
+		return this.codec.delta(e, t, n);
+	}
+	decodeDelta(e, t) {
+		return this.codec.decodeDelta(e, t);
+	}
+}, U = class {
+	schema;
+	codec;
+	constructor(e, t = {}, n = "f32") {
+		this.schema = e, this.codec = new V(e, t, !1, n);
+	}
+	get schemaHash() {
+		return this.codec.schemaHash;
+	}
+	get limits() {
+		return this.codec.limits;
+	}
+	schemaDescription() {
+		return this.codec.description();
+	}
+	full(e) {
+		return this.codec.full(e);
+	}
+	decodeFull(e) {
+		return this.codec.decodeFull(e);
+	}
+};
+export { U as RoomInputCodec, H as RoomStateCodec, D as simulationSchemaNode };