@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/simulationAuthoring.js

@@ -0,0 +1,28 @@
+import { RoomAuthoringError as e } from "./errors.js";
+// src/simulationAuthoring.ts
+function t(t) {
+	throw new e({
+		room: "simulation",
+		detail: t
+	});
+}
+var n = (e, n, r) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) return t("Simulation declarations require own plain data");
+	let i = {};
+	for (let r of Reflect.ownKeys(e)) {
+		let a = Object.getOwnPropertyDescriptor(e, r);
+		if (typeof r != "string" || !n.includes(r) || !a?.enumerable || !("value" in a)) return t("Simulation declarations contain unknown fields or accessors");
+		Object.defineProperty(i, r, {
+			value: a.value,
+			enumerable: !0
+		});
+	}
+	return r.some((e) => !Object.hasOwn(i, e)) ? t("Required simulation declaration is absent") : i;
+}, r = (e) => {
+	if (e && typeof e == "object") {
+		for (let t of Reflect.ownKeys(e)) r(Object.getOwnPropertyDescriptor(e, t)?.value);
+		Object.freeze(e);
+	}
+	return e;
+}, i = (e) => e instanceof Promise ? (Promise.prototype.then.call(e, void 0, () => void 0), t("Simulation init/step/hash/prediction callbacks must be synchronous")) : e;
+export { r as freezeSimulationValue, n as simulationOwnData, i as simulationSyncValue };

package/dist/simulationBytes.js

@@ -0,0 +1,26 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+// src/simulationBytes.ts
+function n(e) {
+	throw new t({ detail: e });
+}
+var r = Object.getPrototypeOf(Uint8Array.prototype), i = Object.getOwnPropertyDescriptor(r, "byteLength")?.get, a = Object.getOwnPropertyDescriptor(r, "byteOffset")?.get, o = Object.getOwnPropertyDescriptor(r, "buffer")?.get, s = (t, r, s = "simulationBytes") => {
+	if (!(t instanceof Uint8Array) || !i || !a || !o) return n("Simulation input requires actual byte-array data");
+	let c, l, u;
+	try {
+		c = i.call(t), l = a.call(t), u = o.call(t);
+	} catch {
+		return n("Simulation byte-array identity is invalid");
+	}
+	if (c > r) throw new e({
+		budget: s,
+		limit: r
+	});
+	if (!(u instanceof ArrayBuffer)) return n("Simulation input cannot borrow shared byte storage");
+	try {
+		let e = new Uint8Array(c);
+		return Uint8Array.prototype.set.call(e, new Uint8Array(u, l, c)), e;
+	} catch {
+		return n("Simulation byte storage changed during capture");
+	}
+};
+export { s as captureSimulationBytes };

package/dist/simulationConformance.js

@@ -0,0 +1,304 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n, SimulationConformanceDivergence as r, SimulationConformanceFailure as i } from "./errors.js";
+import { captureUint64Words as a, unsignedWord as o } from "./fixedWords.js";
+import { Pcg32 as s } from "./pcg32.js";
+import { freezeSimulationValue as c, simulationOwnData as l, simulationSyncValue as u } from "./simulationAuthoring.js";
+import { captureSimulationBytes as d } from "./simulationBytes.js";
+import { schemaSimulationHash as f } from "./simulationState.js";
+import { createSimulationOptionsCodec as p } from "./simulationOptionsWire.js";
+import { createSimulationInputHistoryCodec as m } from "./simulationInputHistoryWire.js";
+import { assertCapturedSimulation as h, createSimulationRunner as g } from "./simulation.js";
+import { RoomInputCodec as _, RoomStateCodec as v } from "./stateCodec.js";
+import { Result as y } from "effect";
+// src/simulationConformance.ts
+function b(e) {
+	throw new n({
+		room: "simulation-conformance",
+		detail: e
+	});
+}
+var x = (e, t) => e.length === t.length && e.every((e, n) => e === t[n]), S = (e, t, n, r, i) => {
+	let a = Object.hasOwn(e, t) ? e[t] : n;
+	return !Number.isSafeInteger(a) || a < r || a > i ? b("Conformance requires bounded integer work limits") : a;
+}, C = (e = {}) => {
+	let t = {
+		maxTicks: 65536,
+		maxCaseBytes: 16777216,
+		maxStateBytes: 1048576,
+		maxRetainedStateBytes: 67108864,
+		maxWorkSteps: 262144,
+		maxObservations: 65537,
+		rollbackHorizonTicks: 8,
+		replayEveryTicks: 8
+	}, n = l(e, Object.keys(t), []);
+	return Object.freeze({
+		maxTicks: S(n, "maxTicks", t.maxTicks, 1, 65536),
+		maxCaseBytes: S(n, "maxCaseBytes", t.maxCaseBytes, 32, 16777216),
+		maxStateBytes: S(n, "maxStateBytes", t.maxStateBytes, 1, 16777216),
+		maxRetainedStateBytes: S(n, "maxRetainedStateBytes", t.maxRetainedStateBytes, 1, 268435456),
+		maxWorkSteps: S(n, "maxWorkSteps", t.maxWorkSteps, 1, 4194304),
+		maxObservations: S(n, "maxObservations", t.maxObservations, 2, 65537),
+		rollbackHorizonTicks: S(n, "rollbackHorizonTicks", t.rollbackHorizonTicks, 1, 4096),
+		replayEveryTicks: S(n, "replayEveryTicks", t.replayEveryTicks, 1, 65536)
+	});
+}, w = (t, n) => {
+	h(t);
+	let r = l(n, [
+		"seed",
+		"options",
+		"playerIds",
+		"sample",
+		"inputSeed",
+		"ticks",
+		"maxBytes"
+	], [
+		"seed",
+		"options",
+		"playerIds",
+		"sample"
+	]), i = o(r.seed), a = Object.hasOwn(r, "inputSeed") ? o(r.inputSeed) : i, d = S(r, "ticks", 1e4, 1, 65536), f = S(r, "maxBytes", 16777216, 32, 16777216), g = r.playerIds;
+	if (typeof r.sample != "function" || !Array.isArray(g) || !g.length || g.length > 64 || Reflect.ownKeys(g).length !== g.length + 1) return b("Conformance case requires a synchronous sampler and a complete own player roster");
+	let x = Object.freeze(Array.from({ length: g.length }, (e, t) => {
+		let n = Object.getOwnPropertyDescriptor(g, String(t));
+		return !n?.enumerable || !("value" in n) ? b("Conformance roster holes/accessors refuse") : o(n.value);
+	}).sort((e, t) => e - t));
+	if (new Set(x).size !== x.length) return b("Conformance players must be unique");
+	let C = p(t).encode(r.options), w = new _(t.definition.input, t.inputCodec.limits), T = new s(a), E = r.sample, D = [], O = C.length + 16 + x.length * 4;
+	if (O > f) throw new e({
+		budget: "simulationConformanceCaseBytes",
+		limit: f
+	});
+	for (let n = 1; n <= d; n++) {
+		if (O += 4, O > f) throw new e({
+			budget: "simulationConformanceCaseBytes",
+			limit: f
+		});
+		let r = x.map((r) => {
+			let i = c(t.inputCodec.capture(u(E(Object.freeze({
+				tick: n,
+				playerId: r,
+				rng: T
+			}))))), a = w.full(i);
+			if (y.isFailure(a)) throw a.failure;
+			if (O += 4 + a.success.length, O > f) throw new e({
+				budget: "simulationConformanceCaseBytes",
+				limit: f
+			});
+			return Object.freeze({
+				playerId: r,
+				input: i
+			});
+		});
+		D.push(Object.freeze({
+			tick: n,
+			inputs: Object.freeze(r)
+		}));
+	}
+	let k = m(t, {
+		maxBytes: f - C.length,
+		maxTicks: d,
+		maxPlayers: x.length
+	}).encode({
+		fromTick: 0,
+		playerIds: x,
+		inputs: D
+	});
+	return Object.freeze({
+		seed: i,
+		stateSchemaHash: new v(t.definition.state, t.stateCodec.limits).schemaHash,
+		options: C,
+		inputs: k
+	});
+}, T = (t, n, r) => {
+	h(t);
+	let i = l(n, [
+		"seed",
+		"stateSchemaHash",
+		"options",
+		"inputs"
+	], [
+		"seed",
+		"stateSchemaHash",
+		"options",
+		"inputs"
+	]), a = o(i.seed), s = o(i.stateSchemaHash), c = d(i.options, r.maxCaseBytes, "simulationConformanceCaseBytes"), u = d(i.inputs, r.maxCaseBytes, "simulationConformanceCaseBytes");
+	if (c.length + u.length > r.maxCaseBytes) throw new e({
+		budget: "simulationConformanceCaseBytes",
+		limit: r.maxCaseBytes
+	});
+	if (t.stateCodec.limits.maxBytes > r.maxStateBytes) throw new e({
+		budget: "simulationConformanceStateBytes",
+		limit: r.maxStateBytes
+	});
+	if (s !== new v(t.definition.state, t.stateCodec.limits).schemaHash) return b("Conformance case requires the same captured state layout");
+	let f = p(t).decode(c), g = m(t, {
+		maxBytes: r.maxCaseBytes,
+		maxTicks: r.maxTicks,
+		maxPlayers: 64
+	}), _ = g.decode(u), y = _.inputs.length;
+	if (!x(g.encode(_), u)) return b("Conformance input case must use its canonical encoded intentions");
+	if (_.fromTick !== 0 || !y) return b("Conformance requires a nonempty complete tick-zero case");
+	if (y + 1 > r.maxObservations) throw new e({
+		budget: "simulationConformanceObservations",
+		limit: r.maxObservations
+	});
+	return {
+		seed: a,
+		options: f,
+		history: _,
+		ticks: y,
+		case: Object.freeze({
+			seed: a,
+			stateSchemaHash: s,
+			options: c,
+			inputs: u
+		})
+	};
+}, E = Object.freeze([
+	83,
+	67,
+	70,
+	1
+]), D = 20, O = (t, n, r = {}) => {
+	let i = C(r), a = T(t, n, i).case, o = D + a.options.length + a.inputs.length;
+	if (o > i.maxCaseBytes) throw new e({
+		budget: "simulationConformanceArtifactBytes",
+		limit: i.maxCaseBytes
+	});
+	let s = new Uint8Array(o), c = new DataView(s.buffer);
+	return s.set(E), c.setUint32(4, a.seed, !0), c.setUint32(8, a.stateSchemaHash, !0), c.setUint32(12, a.options.length, !0), c.setUint32(16, a.inputs.length, !0), s.set(a.options, D), s.set(a.inputs, D + a.options.length), s;
+}, k = (e, n, r = {}) => {
+	let i = C(r), a = d(n, i.maxCaseBytes, "simulationConformanceArtifactBytes");
+	if (a.length < D || E.some((e, t) => a[t] !== e)) throw new t({ detail: "Unknown or truncated simulation conformance artifact" });
+	let o = new DataView(a.buffer), s = o.getUint32(12, !0), c = o.getUint32(16, !0), l = a.length - D;
+	if (s < 12 || c < 20 || s > l || c !== l - s) throw new t({ detail: "Conformance artifact lengths exceed exact physical bytes" });
+	return T(e, {
+		seed: o.getUint32(4, !0),
+		stateSchemaHash: o.getUint32(8, !0),
+		options: a.subarray(D, D + s),
+		inputs: a.subarray(D + s)
+	}, i).case;
+}, A = (e, t) => Object.freeze({
+	tick: t.tick,
+	schemaHash: f(e.stateCodec, t.state),
+	hash: Object.freeze({ ...t.hash }),
+	rng: Object.freeze({ ...t.rng })
+}), j = (e, t) => e.hi === t.hi && e.lo === t.lo, M = (e, t, n) => {
+	if (e.tick !== t.tick) return b("Conformance observations must name the same contiguous tick");
+	for (let i of ["schemaHash", "hash"]) if (!j(e[i], t[i])) throw new r({
+		tick: e.tick,
+		phase: n,
+		component: i
+	});
+	if (e.rng.stateHi !== t.rng.stateHi || e.rng.stateLo !== t.rng.stateLo || e.rng.incrementHi !== t.rng.incrementHi || e.rng.incrementLo !== t.rng.incrementLo) throw new r({
+		tick: e.tick,
+		phase: n,
+		component: "rng"
+	});
+}, N = (e, t, n, r, a) => {
+	try {
+		return r();
+	} catch {
+		throw new i({
+			tick: a?.() ?? e,
+			phase: t,
+			operation: n
+		});
+	}
+}, P = (t, n, r = {}) => {
+	let i = C(r), a = T(t, n, i);
+	if (a.ticks > i.maxWorkSteps) throw new e({
+		budget: "simulationConformanceSteps",
+		limit: i.maxWorkSteps
+	});
+	if (t.stateCodec.limits.maxBytes > Math.floor(i.maxRetainedStateBytes / (i.rollbackHorizonTicks + 3))) throw new e({
+		budget: "simulationConformanceRetainedStateBytes",
+		limit: i.maxRetainedStateBytes
+	});
+	let o = N(0, "trace", "init", () => g(t, a.seed, a.options, {
+		maxPlayers: a.history.playerIds.length,
+		rollbackHorizonTicks: i.rollbackHorizonTicks,
+		maxReplaySteps: i.rollbackHorizonTicks
+	})), s = [A(t, o.snapshot())];
+	for (let e of a.history.inputs) s.push(N(e.tick, "trace", "step", () => A(t, o.advance(e.inputs))));
+	return Object.freeze({
+		case: a.case,
+		observations: Object.freeze(s)
+	});
+}, F = (t, n, r = {}) => {
+	let i = C(r), a = T(t, n, i), o = a.ticks * 3;
+	for (let e = 1; e <= a.ticks; e++) (e % i.replayEveryTicks === 0 || e === a.ticks) && (o += Math.min(e, i.rollbackHorizonTicks));
+	if (o > i.maxWorkSteps) throw new e({
+		budget: "simulationConformanceSteps",
+		limit: i.maxWorkSteps
+	});
+	if (t.stateCodec.limits.maxBytes > Math.floor(i.maxRetainedStateBytes / (4 * (i.rollbackHorizonTicks + 3)))) throw new e({
+		budget: "simulationConformanceRetainedStateBytes",
+		limit: i.maxRetainedStateBytes
+	});
+	let s = {
+		maxPlayers: a.history.playerIds.length,
+		rollbackHorizonTicks: i.rollbackHorizonTicks,
+		maxReplaySteps: i.rollbackHorizonTicks
+	}, c = N(0, "repeat", "init", () => g(t, a.seed, a.options, s)), l = N(0, "repeat", "init", () => g(t, a.seed, a.options, s)), u = N(0, "rollback", "init", () => g(t, a.seed, a.options, s)), d = [A(t, c.snapshot())];
+	M(d[0], A(t, l.snapshot()), "repeat"), M(d[0], A(t, u.snapshot()), "rollback");
+	let f = 2, p = 0, m = 0;
+	for (let e of a.history.inputs) {
+		let n = N(e.tick, "repeat", "step", () => A(t, c.advance(e.inputs)));
+		if (d.push(n), p++, M(n, N(e.tick, "repeat", "step", () => A(t, l.advance(e.inputs))), "repeat"), p++, f++, M(n, N(e.tick, "rollback", "step", () => A(t, u.advance(e.inputs))), "rollback"), p++, f++, e.tick % i.replayEveryTicks !== 0 && e.tick !== a.ticks) continue;
+		let r = Math.max(1, e.tick - i.rollbackHorizonTicks + 1), o = N(r, "rollback", "replay", () => u.replaceInputs(r, a.history.inputs[r - 1].inputs), () => u.lastFailedTransitionTick);
+		p += o.steps, m++;
+		for (let n = r; n <= e.tick; n++) M(d[n], A(t, u.snapshotAt(n)), "rollback"), f++;
+	}
+	let h = Object.freeze({
+		case: a.case,
+		observations: Object.freeze(d)
+	});
+	return Object.freeze({
+		scope: "local-repeat-and-rollback",
+		trace: h,
+		ticks: a.ticks,
+		stepsExecuted: p,
+		comparisons: f,
+		replays: m
+	});
+}, I = (e, t, n) => {
+	let r = l(t, ["case", "observations"], ["case", "observations"]), i = T(e, r.case, n), o = r.observations;
+	if (!Array.isArray(o) || o.length !== i.ticks + 1 || Reflect.ownKeys(o).length !== o.length + 1) return b("Trace observations require the complete own contiguous case frontier");
+	let c = Array.from({ length: o.length }, (e, t) => {
+		let n = Object.getOwnPropertyDescriptor(o, String(t));
+		if (!n?.enumerable || !("value" in n)) return b("Trace observation holes/accessors refuse");
+		let r = l(n.value, [
+			"tick",
+			"schemaHash",
+			"hash",
+			"rng"
+		], [
+			"tick",
+			"schemaHash",
+			"hash",
+			"rng"
+		]);
+		if (r.tick !== t) return b("Trace tick sequence changed");
+		let i = new s(0);
+		return i.restore(r.rng), Object.freeze({
+			tick: t,
+			schemaHash: a(r.schemaHash),
+			hash: a(r.hash),
+			rng: i.snapshot()
+		});
+	});
+	return Object.freeze({
+		case: i.case,
+		observations: Object.freeze(c)
+	});
+}, L = (e, t, n, r = {}) => {
+	let i = C(r), a = I(e, t, i), o = I(e, n, i);
+	if (a.case.seed !== o.case.seed || a.case.stateSchemaHash !== o.case.stateSchemaHash || !x(a.case.options, o.case.options) || !x(a.case.inputs, o.case.inputs)) return b("Trace comparison requires exactly the same encoded case");
+	for (let e = 0; e < a.observations.length; e++) M(a.observations[e], o.observations[e], "provided-trace");
+	return Object.freeze({
+		scope: "provided-trace-comparison",
+		ticks: a.observations.length - 1,
+		comparisons: a.observations.length
+	});
+};
+export { L as compareSimulationConformanceTraces, w as createSimulationConformanceCase, k as decodeSimulationConformanceCase, O as encodeSimulationConformanceCase, P as runSimulationConformanceTrace, F as simulationConformance };

package/dist/simulationInputHistoryCapture.js

@@ -0,0 +1,34 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { simulationOwnData as n } from "./simulationAuthoring.js";
+import { captureSimulationInputs as r } from "./simulation.js";
+// src/simulationInputHistoryCapture.ts
+function i(t) {
+	throw new e({ detail: t });
+}
+var a = (e, a, o, s, c, l = () => void 0, u = /* @__PURE__ */ new Map()) => {
+	if (t(a), !Number.isInteger(c) || c < 1 || c > 65536 || !Array.isArray(s) || s.length > c || Reflect.ownKeys(s).length !== s.length + 1 || s.length > 4294967295 - a) return i("Confirmed input continuation exceeds dense/tick/work limits");
+	if (!Array.isArray(o) || !o.length || o.length > 64 || Reflect.ownKeys(o).length !== o.length + 1) return i("Confirmed input history requires a bounded complete own roster");
+	let d = Array.from({ length: o.length }, (e, n) => {
+		let r = Object.getOwnPropertyDescriptor(o, String(n));
+		return !r?.enumerable || !("value" in r) ? i("Confirmed input roster holes/accessors refuse") : t(r.value);
+	}).sort((e, t) => e - t);
+	if (new Set(d).size !== d.length) return i("Confirmed input roster IDs must be unique");
+	for (let [e, t] of u) if (!d.includes(e) || !Number.isSafeInteger(t) || t <= a) return i("Confirmed input join must name a roster player inside the history");
+	let f = [];
+	for (let t = 0; t < s.length; t++) {
+		let o = Object.getOwnPropertyDescriptor(s, String(t));
+		if (!o?.enumerable || !("value" in o)) return i("Confirmed input continuation holes/accessors refuse");
+		let c = n(o.value, ["tick", "inputs"], ["tick", "inputs"]);
+		if (c.tick !== a + t + 1) return i("Confirmed input continuation must be contiguous after its actual base");
+		let p = u.size ? d.filter((e) => (u.get(e) ?? 0) <= c.tick) : d, m = r(e, c.inputs, d.length);
+		if (m.length !== p.length || m.some((e, t) => e.playerId !== p[t])) return i("Confirmed input continuation must match the complete actual roster");
+		let h = Object.freeze({
+			tick: c.tick,
+			inputs: m
+		});
+		l(h), f.push(h);
+	}
+	return Object.freeze(f);
+};
+export { a as captureSimulationInputHistory };

package/dist/simulationInputHistoryWire.js

@@ -0,0 +1,192 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { unsignedWord as r } from "./fixedWords.js";
+import { simulationOwnData as i } from "./simulationAuthoring.js";
+import { captureSimulationBytes as a } from "./simulationBytes.js";
+import { captureSimulationInputHistory as o } from "./simulationInputHistoryCapture.js";
+import { assertCapturedSimulation as s } from "./simulation.js";
+import { RoomInputCodec as c } from "./stateCodec.js";
+import { Result as l } from "effect";
+// src/simulationInputHistoryWire.ts
+var u = Object.freeze([
+	76,
+	83,
+	73,
+	1
+]), d = Object.freeze([
+	76,
+	83,
+	73,
+	2
+]), f = 16;
+function p(e) {
+	throw new t({ detail: e });
+}
+var m = class {
+	#e;
+	#t;
+	#n;
+	#r = !1;
+	constructor(e, t = {}) {
+		s(e), this.#e = e;
+		let r = i(t, [
+			"maxBytes",
+			"maxPlayers",
+			"maxTicks"
+		], []), a = {
+			maxBytes: 16777216,
+			maxPlayers: 64,
+			maxTicks: 4096
+		}, o = {
+			maxBytes: 16777216,
+			maxPlayers: 64,
+			maxTicks: 65536
+		}, l = { ...a };
+		for (let e of Object.keys(a)) {
+			let t = Object.hasOwn(r, e) ? r[e] : a[e];
+			if (!Number.isInteger(t) || t < (e === "maxBytes" ? 20 : 1) || t > o[e]) throw new n({
+				room: "simulation",
+				detail: "Input history requires bounded bytes/players/ticks"
+			});
+			Object.defineProperty(l, e, {
+				value: t,
+				enumerable: !0
+			});
+		}
+		this.#n = Object.freeze(l), this.#t = new c(e.definition.input, e.inputCodec.limits);
+	}
+	work(e) {
+		if (this.#r) return p("Input history codec cannot reenter capture/encoding/decoding");
+		this.#r = !0;
+		try {
+			return e();
+		} finally {
+			this.#r = !1;
+		}
+	}
+	pack(t) {
+		let n = i(t, [
+			"fromTick",
+			"playerIds",
+			"inputs",
+			"joins"
+		], [
+			"fromTick",
+			"playerIds",
+			"inputs"
+		]), a = r(n.fromTick), s = n.playerIds;
+		if (!Array.isArray(s) || !s.length || s.length > this.#n.maxPlayers || Reflect.ownKeys(s).length !== s.length + 1) return p("Input history roster exceeds complete own/count work");
+		let c = Object.freeze(Array.from({ length: s.length }, (e, t) => {
+			let n = Object.getOwnPropertyDescriptor(s, String(t));
+			return !n?.enumerable || !("value" in n) ? p("Input history roster holes/accessors refuse") : r(n.value);
+		}).sort((e, t) => e - t)), u = Object.hasOwn(n, "joins") ? n.joins : [];
+		if (!Array.isArray(u) || u.length > c.length || Reflect.ownKeys(u).length !== u.length + 1) return p("Input history joins exceed the roster");
+		let d = /* @__PURE__ */ new Map();
+		for (let e = 0; e < u.length; e++) {
+			let t = Object.getOwnPropertyDescriptor(u, String(e));
+			if (!t?.enumerable || !("value" in t)) return p("Input history join holes/accessors refuse");
+			let n = i(t.value, ["playerId", "tick"], ["playerId", "tick"]), a = r(n.playerId);
+			if (d.has(a)) return p("Input history joins name each player once");
+			d.set(a, r(n.tick));
+		}
+		let m = f + c.length * (d.size ? 8 : 4);
+		if (m > this.#n.maxBytes) throw new e({
+			budget: "simulationInputHistoryBytes",
+			limit: this.#n.maxBytes
+		});
+		let h = [], g = o(this.#e, a, c, n.inputs, this.#n.maxTicks, (t) => {
+			m += 4;
+			let n = t.inputs.map((t) => {
+				let n = this.#t.full(t.input);
+				if (l.isFailure(n)) throw n.failure;
+				if (m += 4 + n.success.length, m > this.#n.maxBytes) throw new e({
+					budget: "simulationInputHistoryBytes",
+					limit: this.#n.maxBytes
+				});
+				return n.success;
+			});
+			h.push(Object.freeze(n));
+		}, d), _ = Object.freeze([...d].sort((e, t) => e[0] - t[0]).map(([e, t]) => Object.freeze({
+			playerId: e,
+			tick: t
+		})));
+		return {
+			history: Object.freeze({
+				fromTick: a,
+				playerIds: c,
+				inputs: g,
+				...d.size ? { joins: _ } : {}
+			}),
+			payloads: h,
+			size: m,
+			joins: d
+		};
+	}
+	capture(e) {
+		return this.work(() => this.pack(e).history);
+	}
+	encode(e) {
+		return this.work(() => {
+			let { history: t, payloads: n, size: r, joins: i } = this.pack(e), a = new Uint8Array(r), o = new DataView(a.buffer);
+			a.set(i.size ? d : u), o.setUint32(4, t.fromTick, !0), o.setUint32(8, t.playerIds.length, !0), o.setUint32(12, t.inputs.length, !0);
+			let s = f;
+			for (let e of t.playerIds) o.setUint32(s, e, !0), s += 4, i.size && (o.setUint32(s, i.get(e) ?? 0, !0), s += 4);
+			for (let e = 0; e < t.inputs.length; e++) {
+				o.setUint32(s, t.inputs[e].tick, !0), s += 4;
+				for (let t of n[e]) o.setUint32(s, t.length, !0), s += 4, a.set(t, s), s += t.length;
+			}
+			return a;
+		});
+	}
+	decode(e) {
+		return this.work(() => {
+			let t = a(e, this.#n.maxBytes, "simulationInputHistoryBytes"), n = t.length >= f && u.slice(0, 3).every((e, n) => t[n] === e) ? t[3] : 0;
+			if (n !== 1 && n !== 2) return p("Input history has an unknown or truncated layout");
+			let r = n === 2 ? 8 : 4, i = new DataView(t.buffer), o = i.getUint32(4, !0), s = i.getUint32(8, !0), c = i.getUint32(12, !0);
+			if (!s || s > this.#n.maxPlayers || c > this.#n.maxTicks || c > 4294967295 - o) return p("Input history header exceeds player/tick work");
+			if (f + s * r + c * (r === 4 ? 4 + s * 4 : 4) > t.length) return p("Input history counts exceed physical bytes");
+			let d = f, m = -1, h = [], g = Array.from({ length: s }, () => {
+				let e = i.getUint32(d, !0);
+				if (d += 4, e <= m) return p("Input history roster must be canonical ascending unique IDs");
+				if (m = e, r === 8) {
+					let t = i.getUint32(d, !0);
+					d += 4, t > 0 && h.push({
+						playerId: e,
+						tick: t
+					});
+				}
+				return e;
+			});
+			if (r === 8 && !h.length) return p("Input history v2 must name a late join");
+			let _ = new Map(h.map((e) => [e.playerId, e.tick])), v = [];
+			for (let e = 0; e < c; e++) {
+				if (d + 4 > t.length) return p("Input history tick is truncated");
+				let n = i.getUint32(d, !0);
+				if (d += 4, n !== o + e + 1) return p("Input history ticks must be contiguous");
+				let r = [];
+				for (let e of g) {
+					if ((_.get(e) ?? 0) > n) continue;
+					if (d + 4 > t.length) return p("Input history cell is truncated");
+					let a = i.getUint32(d, !0);
+					if (d += 4, a > t.length - d) return p("Input history payload exceeds physical bytes");
+					let o = this.#t.decodeFull(t.subarray(d, d + a));
+					if (l.isFailure(o)) throw o.failure;
+					r.push({
+						playerId: e,
+						input: o.success
+					}), d += a;
+				}
+				v.push({
+					tick: n,
+					inputs: r
+				});
+			}
+			return d === t.length ? this.pack({
+				fromTick: o,
+				playerIds: g,
+				inputs: v,
+				...h.length ? { joins: h } : {}
+			}).history : p("Input history has trailing bytes");
+		});
+	}
+}, h = (e, t = {}) => new m(e, t);
+export { m as SimulationInputHistoryCodec, h as createSimulationInputHistoryCodec };

package/dist/simulationOptionsWire.js

@@ -0,0 +1,77 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { freezeSimulationValue as n } from "./simulationAuthoring.js";
+import { captureSimulationBytes as r } from "./simulationBytes.js";
+import { assertCapturedSimulation as i } from "./simulation.js";
+import { RoomInputCodec as a } from "./stateCodec.js";
+import { Result as o } from "effect";
+// src/simulationOptionsWire.ts
+var s = 12, c = (e, t) => {
+	if (Object.is(e, t)) return !0;
+	if (!e || !t || typeof e != "object" || typeof t != "object" || Array.isArray(e) !== Array.isArray(t)) return !1;
+	let n = Reflect.ownKeys(e);
+	return n.length === Reflect.ownKeys(t).length && n.every((n) => Object.hasOwn(t, n) && c(Object.getOwnPropertyDescriptor(e, n)?.value, Object.getOwnPropertyDescriptor(t, n)?.value));
+}, l = class {
+	#e;
+	#t;
+	#n = !1;
+	constructor(e) {
+		i(e), this.#e = e, this.#t = new a(e.definition.options, e.optionsCodec.limits, "f64");
+	}
+	get schemaHash() {
+		return this.#t.schemaHash;
+	}
+	get maxBytes() {
+		return this.#e.optionsCodec.limits.maxBytes + s;
+	}
+	work(t) {
+		if (this.#n) throw new e({ detail: "Options codec cannot reenter author capture" });
+		this.#n = !0;
+		try {
+			return t();
+		} finally {
+			this.#n = !1;
+		}
+	}
+	captureOwned(e) {
+		let r = n(this.#e.optionsCodec.capture(e)), i = this.#t.full(r);
+		if (o.isFailure(i)) throw i.failure;
+		let a = this.#t.decodeFull(i.success);
+		if (o.isFailure(a)) throw a.failure;
+		if (!c(r, n(this.#e.optionsCodec.capture(a.success)))) throw new t({
+			room: "simulation",
+			detail: "Declared option precision or quantization cannot preserve the captured game options"
+		});
+		return r;
+	}
+	capture(e) {
+		return this.work(() => this.captureOwned(e));
+	}
+	encode(e) {
+		return this.work(() => {
+			let t = this.captureOwned(e), n = this.#t.full(t);
+			if (o.isFailure(n)) throw n.failure;
+			let r = n.success, i = new Uint8Array(s + r.length), a = new DataView(i.buffer);
+			return i.set([
+				76,
+				83,
+				79,
+				1
+			]), a.setUint32(4, this.schemaHash, !0), a.setUint32(8, r.length, !0), i.set(r, s), i;
+		});
+	}
+	decode(t) {
+		return this.work(() => {
+			let n = r(t, this.maxBytes, "simulationOptionsBytes");
+			if (n.length < s || n[0] !== 76 || n[1] !== 83 || n[2] !== 79 || n[3] !== 1) throw new e({ detail: "Unknown or truncated simulation options envelope" });
+			let i = new DataView(n.buffer);
+			if (i.getUint32(4, !0) !== this.schemaHash || i.getUint32(8, !0) !== n.length - s) throw new e({ detail: "Simulation options layout or length changed" });
+			let a = this.#t.decodeFull(n.subarray(s));
+			if (o.isFailure(a)) throw a.failure;
+			let c = this.captureOwned(a.success), l = this.#t.full(c);
+			if (o.isFailure(l)) throw l.failure;
+			if (l.success.length !== n.length - s || l.success.some((e, t) => e !== n[t + s])) throw new e({ detail: "Noncanonical simulation options envelope" });
+			return c;
+		});
+	}
+}, u = (e) => new l(e);
+export { l as SimulationOptionsCodec, u as createSimulationOptionsCodec };