@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepAdmissionCodec.js

@@ -0,0 +1,93 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { freezeSimulationValue as n, simulationOwnData as r } from "./simulationAuthoring.js";
+import { createSimulationOptionsCodec as i } from "./simulationOptionsWire.js";
+import { assertCapturedSimulation as a } from "./simulation.js";
+import { RoomInputCodec as o, RoomStateCodec as s } from "./stateCodec.js";
+import { lockstepJournalIdentity as c } from "./lockstepJournalCodec.js";
+import { createHash as l } from "node:crypto";
+// src/lockstepAdmissionCodec.ts
+function u(t) {
+	throw new e({ detail: t });
+}
+var d = (e) => l("sha256").update(JSON.stringify(e)).digest("hex"), f = (e) => n({
+	...e,
+	digest: d(e)
+}), p = (e, n, i, a = 67108864) => {
+	let o = [
+		"version",
+		"roomId",
+		"tenantId",
+		"ownerEpoch",
+		"hostId",
+		"initial",
+		"adoption",
+		"digest"
+	], s = r(e, o, o), l = t(s.ownerEpoch), d = c(s.hostId);
+	if (s.version !== 1 || s.roomId !== n.roomId || s.tenantId !== n.tenantId || l < 1 || l > n.epoch || i !== void 0 && (d !== i || l !== n.epoch)) return u("Lockstep creation metadata changed scope or current owner");
+	let p = [
+		"requestId",
+		"creatorSubjectId",
+		"name",
+		"seed",
+		"options",
+		"stateSchemaHash",
+		"inputSchemaHash"
+	], m = r(s.initial, p, p), h = m.options;
+	if (typeof h != "string" || h.length > Math.ceil(a * 4 / 3) || !/^[A-Za-z0-9_-]*$/.test(h)) return u("Invalid bounded creation options bytes");
+	let g = Buffer.from(h, "base64url");
+	if (g.byteLength > a || g.toString("base64url") !== h) return u("Noncanonical creation options bytes");
+	let _ = null;
+	if (s.adoption !== null) {
+		let e = r(s.adoption, ["requestId", "priorEpoch"], ["requestId", "priorEpoch"]), n = t(e.priorEpoch);
+		if (n < 1 || n >= l) return u("Invalid immutable creation successor receipt");
+		_ = {
+			requestId: c(e.requestId),
+			priorEpoch: n
+		};
+	}
+	let v = f({
+		version: 1,
+		roomId: n.roomId,
+		tenantId: n.tenantId,
+		ownerEpoch: l,
+		hostId: d,
+		initial: {
+			requestId: c(m.requestId),
+			creatorSubjectId: c(m.creatorSubjectId),
+			name: c(m.name),
+			seed: t(m.seed),
+			options: h,
+			stateSchemaHash: t(m.stateSchemaHash),
+			inputSchemaHash: t(m.inputSchemaHash)
+		},
+		adoption: _
+	});
+	return s.digest !== v.digest || Buffer.byteLength(JSON.stringify(v), "utf8") > a ? u("Creation metadata digest or byte budget does not match") : v;
+}, m = (e, t) => {
+	if (e.initial.creatorSubjectId !== t) return null;
+	let { name: n, requestId: r, seed: i, stateSchemaHash: a, inputSchemaHash: o } = e.initial;
+	return Object.freeze({
+		roomId: e.roomId,
+		name: n,
+		requestId: r,
+		seed: i,
+		stateSchemaHash: a,
+		inputSchemaHash: o
+	});
+}, h = (e, t = 16777216) => {
+	a(e);
+	let n = i(e), r = new s(e.definition.state, e.stateCodec.limits), c = new o(e.definition.input, e.inputCodec.limits);
+	return Object.freeze({
+		optionsWire: n,
+		stateWire: r,
+		inputWire: c,
+		captureStored: (e, i, a) => {
+			let o = p(e, i, a, t);
+			if (o.initial.stateSchemaHash !== r.schemaHash || o.initial.inputSchemaHash !== c.schemaHash) return u("Creation simulation layouts changed");
+			let s = Buffer.from(o.initial.options, "base64url"), l = n.decode(s);
+			return Buffer.from(n.encode(l)).equals(s) ? o : u("Creation options are not canonical declared LSO");
+		}
+	});
+};
+export { p as captureRoomLockstepAdmissionEnvelope, h as createRoomLockstepAdmissionCodec, m as roomLockstepCreationProjection, f as sealRoomLockstepAdmission };

package/dist/lockstepAdmissionPorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/lockstepAdmissionPorts.ts
+var t = class extends e.Service()("@voltro/RoomLockstepAdmissionPort") {};
+export { t as RoomLockstepAdmissionPort };

package/dist/lockstepClientSession.js

@@ -0,0 +1,577 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { unsignedWord as r } from "./fixedWords.js";
+import { freezeSimulationValue as i, simulationOwnData as a } from "./simulationAuthoring.js";
+import { captureSimulationBytes as o } from "./simulationBytes.js";
+import { createSimulationOptionsCodec as s } from "./simulationOptionsWire.js";
+import { createSimulationInputHistoryCodec as c } from "./simulationInputHistoryWire.js";
+import { createSimulationRecoveryCodec as l } from "./simulationRecoveryWire.js";
+import { assertCapturedSimulation as u, captureSimulationInputs as d } from "./simulation.js";
+import { RoomInputCodec as f, RoomStateCodec as p } from "./stateCodec.js";
+import { RoomTransportCleanupFailure as m } from "./transportCleanup.js";
+import { captureRoomLockstepWireRoster as h, roomLockstepWireMask as g } from "./lockstepWireRoster.js";
+import { decodeRoomFrame as _, encodeRoomFrame as v } from "./wire.js";
+import { roomCodecs as y } from "./web.js";
+import { captureLockstepClientOptions as b, captureLockstepClientPolicy as x, createLockstepClientSimulation as S } from "./lockstep.js";
+import { Result as C } from "effect";
+// src/lockstepClientSession.ts
+var w = /* @__PURE__ */ new WeakSet(), T = (e) => typeof e == "object" && !!e && w.has(e);
+function E(e) {
+	throw new t({ detail: e });
+}
+var D = (e) => e === "left" || e === "kicked" || e === "faulted", O = (e, t) => e.length === t.length && e.every((e, n) => e === t[n]), k = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = null;
+	#a = [];
+	#o = null;
+	#s;
+	#c;
+	#l;
+	#u;
+	#d;
+	#f;
+	#p;
+	#m = [];
+	#h = /* @__PURE__ */ new Set();
+	#g = [];
+	#_ = /* @__PURE__ */ new Set();
+	#v = /* @__PURE__ */ new Map();
+	#y;
+	#b = null;
+	#x = null;
+	#S = "connecting";
+	#C = null;
+	#w = !1;
+	#T = !1;
+	#E = null;
+	#D = null;
+	#O = 0;
+	#k = 0;
+	#A = 0;
+	#j = 0;
+	#M = null;
+	#N = /* @__PURE__ */ new Map();
+	#P = /* @__PURE__ */ new Map();
+	#F = null;
+	#I = 0;
+	#L = !1;
+	#R = !1;
+	constructor(e, t, i, o) {
+		u(t), this.#t = t, this.#e = e;
+		let c = [
+			"localPlayerId",
+			"initialInputs",
+			"inputDelayTicks",
+			"rollbackHorizonTicks",
+			"maxFutureTicks",
+			"maxPlayers",
+			"maxRejectionAttempts",
+			"inputPrediction"
+		], g = a(o, [
+			...c,
+			"roster",
+			"redundantInputs",
+			"hashEvery",
+			"hashHistoryTicks",
+			"maxPendingWrites",
+			"maxFrameBytes",
+			"maxBootstrapTicks"
+		], []), _ = {
+			redundantInputs: 4,
+			hashEvery: 10,
+			hashHistoryTicks: 64,
+			maxPendingWrites: 16,
+			maxFrameBytes: 65536,
+			maxBootstrapTicks: 4096,
+			delay: 2,
+			horizon: 8
+		}, v = { ..._ };
+		for (let e of Object.keys(_)) {
+			let t = e === "delay" ? "inputDelayTicks" : e === "horizon" ? "rollbackHorizonTicks" : e, r = Object.hasOwn(g, t) ? g[t] : _[e], i = e === "delay" ? 0 : 1, a = e === "maxFrameBytes" || e === "maxBootstrapTicks" ? 65536 : e === "redundantInputs" ? 64 : 4096;
+			if (!Number.isInteger(r) || r < i || r > a) throw new n({
+				room: "lockstep",
+				detail: "Invalid bounded network client limit"
+			});
+			Object.defineProperty(v, e, {
+				value: r,
+				enumerable: !0
+			});
+		}
+		let { localPlayerId: b, initialInputs: S, ...C } = Object.fromEntries(c.filter((e) => Object.hasOwn(g, e)).map((e) => [e, g[e]])), T = x(C), O = Object.hasOwn(g, "initialInputs") ? d(t, g.initialInputs, T.maxPlayers) : Object.freeze([]);
+		Object.hasOwn(g, "initialInputs") && !O.length && E("Authored initial intentions require a nonempty complete matrix"), this.#l = Object.hasOwn(g, "localPlayerId") ? r(g.localPlayerId) : null, this.#c = Object.hasOwn(g, "roster") ? h(g.roster, T.maxPlayers) : null;
+		let k = this.#c?.map((e) => e.playerId);
+		k && (this.#l !== null && !k.includes(this.#l) || Object.hasOwn(g, "initialInputs") && (O.length !== k.length || O.some((e) => !k.includes(e.playerId)))) && E("Expected initial intentions/local player must match the complete expected roster"), this.#s = Object.freeze({
+			...T,
+			...Object.hasOwn(g, "initialInputs") ? { initialInputs: O } : {}
+		}), this.#n = null, this.#L = T.inputDelayTicks <= 1, this.#r = Object.freeze(v), this.#u = y(i), this.#d = new f(t.definition.input, t.inputCodec.limits);
+		let A = new p(t.definition.state, t.stateCodec.limits);
+		(this.#u.input.schemaHash !== this.#d.schemaHash || this.#u.state.schemaHash !== A.schemaHash) && E("Network manifest does not match the captured simulation state/input layout"), this.#f = s(t), this.#p = l(t, {
+			maxBytes: v.maxFrameBytes,
+			maxTicks: T.maxFutureTicks
+		}), this.#y = new m(async () => {
+			let t = await Promise.allSettled([...this.#h, ...e.closeAsync ? [e.closeAsync(1e3, "Lockstep client closed")] : []]), n = [...this.#g, ...t.flatMap((e) => e.status === "rejected" ? [e.reason] : [])];
+			if (n.length) throw AggregateError(n, "Lockstep client cleanup failed");
+		}), this.#m.push(e.reliable.onFrame((e) => this.receive(e))), e.unreliable && this.#m.push(e.unreliable.onFrame((e) => this.receive(e, !0)));
+		let j = () => {
+			D(this.#S) || (this.#S = "left", this.release(), this.notify());
+		};
+		e.signal.addEventListener("abort", j, { once: !0 }), this.#m.push(() => e.signal.removeEventListener("abort", j)), e.signal.aborted && j(), w.add(this);
+	}
+	work(e) {
+		if (this.#T) return E("Network client cannot reenter simulation or frame mutation");
+		this.#T = !0;
+		try {
+			return e();
+		} finally {
+			this.#T = !1;
+		}
+	}
+	live() {
+		return D(this.#S) || !this.#x ? E("Lockstep client has no current admitted simulation") : this.#x;
+	}
+	current(e) {
+		if (D(this.#S) || this.#x !== e) return E("Client ownership was withdrawn during an author callback");
+	}
+	notify() {
+		this.#b = null;
+		for (let e of this.#_) try {
+			e();
+		} catch {
+			this.#O++, this.#b = null;
+		}
+	}
+	subscribe(e) {
+		return typeof e == "function" ? (this.#_.add(e), () => {
+			this.#_.delete(e);
+		}) : E("Invalid client observer");
+	}
+	onMessage(e, t) {
+		let n = this.#u.channels.find((t) => t.name === e);
+		if (D(this.#S) || !n || n.direction === "client" || typeof t != "function") return E("Message observation needs a declared server-sendable channel");
+		let r = this.#v.get(e) ?? /* @__PURE__ */ new Set();
+		return r.add(t), this.#v.set(e, r), () => {
+			r.delete(t), !r.size && this.#v.get(e) === r && this.#v.delete(e);
+		};
+	}
+	get status() {
+		return this.#S;
+	}
+	get failure() {
+		return this.#C;
+	}
+	get id() {
+		return this.#E;
+	}
+	get epoch() {
+		return this.#D;
+	}
+	roster() {
+		return this.#i === null ? null : this.rosterAt(2 ** 53 - 1);
+	}
+	rosterAt(e) {
+		let t = this.#i ?? [];
+		return this.#a.length ? [...t, ...this.#a.filter((t) => t.tick <= e).map((e) => Object.freeze({
+			slot: e.slot,
+			playerId: e.playerId
+		}))].sort((e, t) => e.slot - t.slot) : t;
+	}
+	get localPlayerId() {
+		return this.#n?.localPlayerId ?? null;
+	}
+	snapshot() {
+		return this.#x?.snapshot() ?? null;
+	}
+	observation() {
+		return this.#b ??= Object.freeze({
+			status: this.status,
+			sessionId: this.id,
+			epoch: this.epoch,
+			localPlayerId: this.localPlayerId,
+			roster: this.roster(),
+			snapshot: this.snapshot(),
+			metrics: this.metrics()
+		});
+	}
+	metrics() {
+		return Object.freeze({
+			status: this.#S,
+			tick: this.#x?.tick ?? null,
+			confirmedThroughTick: this.#x?.confirmedThroughTick ?? null,
+			catchUpTicks: this.#x ? Math.max(0, this.#x.confirmedThroughTick - this.#x.tick) : 0,
+			pendingWrites: this.#h.size,
+			pendingIntent: this.#F !== null,
+			retainedLocalInputs: this.#N.size,
+			retainedHashClaims: this.#P.size,
+			stalls: this.#k,
+			resyncs: this.#A,
+			hashFlags: this.#j,
+			waitingFor: this.#M,
+			observerErrors: this.#O,
+			rollbackReplays: this.#x?.metrics.rollbackReplays ?? 0,
+			rollbackSteps: this.#x?.metrics.rollbackSteps ?? 0
+		});
+	}
+	encode(e) {
+		let t = v(e, {
+			maxBytes: this.#r.maxFrameBytes,
+			maxInputs: 4096
+		});
+		if (C.isFailure(t)) throw t.failure;
+		return t.success;
+	}
+	write(n, r = !0) {
+		if (this.#e.signal.aborted || D(this.#S)) return Promise.reject(new t({ detail: "Lockstep transport is closed" }));
+		if (this.#h.size >= this.#r.maxPendingWrites) return Promise.reject(new e({
+			budget: "lockstepClientWrites",
+			limit: this.#r.maxPendingWrites
+		}));
+		let i = this.encode(n), a = Promise.resolve().then(() => {
+			if (this.#e.signal.aborted || D(this.#S)) return E("Lockstep transport was withdrawn before write");
+			if (!r && this.#e.unreliable && i.byteLength <= this.#e.unreliable.maxDatagramBytes) this.#e.unreliable.send(i);
+			else return this.#e.reliable.send(i);
+		});
+		return this.#h.add(a), a.then(() => this.#h.delete(a), () => this.#h.delete(a)), a;
+	}
+	start(e) {
+		return this.work(() => {
+			if (this.#w || this.#S !== "connecting") return Promise.reject(new t({ detail: "Lockstep Hello may be sent only once" }));
+			let n = {
+				kind: "Hello",
+				protocolVersion: 1,
+				token: o(e, this.#r.maxFrameBytes, "lockstepSeatTokenBytes"),
+				schemaHash: this.#u.schemaHash,
+				transportCaps: this.#e.unreliable ? 3 : 1
+			};
+			return this.encode(n), this.#w = !0, this.write(n);
+		});
+	}
+	message(e, t) {
+		try {
+			return this.work(() => {
+				this.live();
+				let n = this.#u.channels.findIndex((t) => t.name === e), r = this.#u.channels[n];
+				if (!r || r.direction === "server") return E("Channel is not client-sendable");
+				let i = r.codec.full(t);
+				if (C.isFailure(i)) throw i.failure;
+				return this.write({
+					kind: "ClientMessage",
+					channelId: n,
+					payload: i.success
+				}, r.reliable);
+			});
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	}
+	receive(e, n = !1) {
+		if (!D(this.#S)) try {
+			this.work(() => {
+				let t = _(e, {
+					maxBytes: this.#r.maxFrameBytes,
+					maxInputs: 4096
+				});
+				if (C.isFailure(t)) throw t.failure;
+				let r = t.success;
+				if (n && r.kind !== "LsInputs" && (r.kind !== "ServerMessage" || this.#u.channels[r.channelId]?.reliable !== !1)) return E("Lockstep control and reliable channels need the actual reliable server lane");
+				if (r.kind === "Welcome") {
+					if (!this.#w || this.#S !== "connecting" || n || r.tick !== 0 || !r.sessionId || r.epoch < 1) return E("Lockstep bootstrap requires one reliable current initial Welcome");
+					this.#E = r.sessionId, this.#D = r.epoch, this.#S = "waitingStart";
+					return;
+				}
+				if (r.kind === "LsStart") {
+					if (this.#S !== "waitingStart" || this.#x) return E("Lockstep start requires one reliable current Welcome");
+					let e = this.#f.decode(r.options), t = this.#s;
+					if (!t) return E("Client initial intent ownership was withdrawn");
+					let n = h(r.roster, t.maxPlayers ?? 8);
+					if (this.#l !== null && r.localPlayerId !== this.#l || this.#c !== null && (n.length !== this.#c.length || n.some((e, t) => e.slot !== this.#c[t].slot || e.playerId !== this.#c[t].playerId))) return E("Reliable Start does not match the expected host identity");
+					let i = r.history ? c(this.#t, {
+						maxBytes: this.#r.maxFrameBytes,
+						maxTicks: this.#r.maxBootstrapTicks,
+						maxPlayers: 64
+					}).decode(r.history) : null, a = i?.joins ?? [], o = new Set(a.map((e) => e.playerId)), s = !n.some((e) => e.playerId === r.localPlayerId), l = {
+						...t,
+						localPlayerId: r.localPlayerId,
+						playerIds: n.filter((e) => !o.has(e.playerId)).map((e) => e.playerId),
+						...s ? { lateJoin: !0 } : {}
+					}, u = b(this.#t, l), d = n.map((e) => e.playerId).sort((e, t) => e - t), f = r.snapshot ? this.#p.decode(r.snapshot) : null, p = f ? f.continuation?.at(-1)?.tick ?? f.snapshot.tick : null;
+					if (i && f || r.startTick > 0 && !i && !f || i && (i.fromTick !== 0 || i.inputs.length !== r.startTick || i.playerIds.length !== d.length || i.playerIds.some((e, t) => e !== d[t])) || f && (f.snapshot.tick < 1 || p !== r.startTick || f.inputs.length !== d.length || f.inputs.some((e, t) => e.playerId !== d[t]) || (f.continuation?.length ?? 0) > u.maxFutureTicks)) return E("Reliable Start bootstrap must reach its exact frontier with the admitted public roster");
+					let m = S(this.#t, r.seed, e, l), _ = [...a].sort((e, t) => e.tick - t.tick).map((e) => {
+						let t = n.find((t) => t.playerId === e.playerId);
+						return t ? (m.join(e.tick, e.playerId), Object.freeze({
+							tick: e.tick,
+							slot: t.slot,
+							playerId: e.playerId
+						})) : E("History join names no Start roster slot");
+					});
+					if (i && m.installConfirmedHistory(i, {
+						maxBytes: this.#r.maxFrameBytes,
+						maxTicks: this.#r.maxBootstrapTicks,
+						maxPlayers: u.maxPlayers
+					}), f && m.installServerSnapshot(f.snapshot, f.inputs, f.continuation), D(this.#S) || this.#s !== t) return E("Client start was withdrawn during author init");
+					let v = n.filter((e) => !o.has(e.playerId));
+					this.#i = v, this.#a = _, this.#o = g(v), this.#n = u, this.#I = r.startTick, this.#x = m, this.#S = "joined";
+					return;
+				}
+				let a = this.live(), o = this.#i, s = this.#o;
+				if (!o || !s) return E("Current simulation needs its reliable host roster");
+				switch (r.kind) {
+					case "ServerMessage": {
+						let e = this.#u.channels[r.channelId];
+						if (!e || e.direction === "client") return E("Channel is not server-sendable");
+						let t = e.codec.decodeFull(r.payload);
+						if (C.isFailure(t)) throw t.failure;
+						let n = i(t.success);
+						for (let t of this.#v.get(e.name) ?? []) try {
+							t(n);
+						} catch {
+							this.#O++;
+						}
+						return;
+					}
+					case "LsJoin": {
+						let e = this.rosterAt(2 ** 53 - 1);
+						if (r.tick <= a.confirmedThroughTick || e.some((e) => e.slot === r.slot || e.playerId === r.playerId) || this.#a.some((e) => e.tick > r.tick)) return E("Late join must be new, ordered and ahead of the confirmed frontier");
+						this.current(a), a.join(r.tick, r.playerId), this.current(a), this.#a.push(Object.freeze({
+							tick: r.tick,
+							slot: r.slot,
+							playerId: r.playerId
+						}));
+						return;
+					}
+					case "LsInputs": {
+						let e = [];
+						for (let t = 0; t < r.matrices.length; t++) {
+							let n = r.matrices[t], a = r.firstTick + t, o = this.rosterAt(a), s = g(o);
+							if (n.players.hi !== s.hi || n.players.lo !== s.lo || n.inputs.length !== o.length) return E("Server matrix does not name the complete actual roster");
+							let c = o.map((e, t) => {
+								let r = this.#d.decodeFull(n.inputs[t]);
+								if (C.isFailure(r)) throw r.failure;
+								return Object.freeze({
+									playerId: e.playerId,
+									input: i(this.#t.inputCodec.capture(r.success))
+								});
+							});
+							e.push({
+								tick: r.firstTick + t,
+								inputs: Object.freeze(c)
+							});
+						}
+						this.current(a);
+						for (let t of e) a.confirm(t.tick, t.inputs), this.current(a);
+						this.#M = null, this.#S = "joined", this.prune();
+						return;
+					}
+					case "LsStall": {
+						let e = g(this.rosterAt(2 ** 53 - 1));
+						if ((r.waitingFor.hi & ~e.hi) !== 0 || (r.waitingFor.lo & ~e.lo) !== 0) return E("Server stall names unknown roster slots");
+						this.#M = Object.freeze({ ...r.waitingFor }), this.#k++, this.#S = "stalled";
+						return;
+					}
+					case "LsDesync": {
+						if (!this.#P.has(r.tick)) return E("Server desync must refer to this Session's actual immutable hash claim");
+						if (r.action === "end") {
+							this.#S = "kicked", this.release(), this.#e.close(1e3, "Lockstep ended");
+							return;
+						}
+						if (r.action === "flag") {
+							this.#j++;
+							return;
+						}
+						if (r.snapshot === void 0) return E("Server resync frame lacks its recovery snapshot");
+						let e = this.#p.decode(r.snapshot), t = e.snapshot;
+						if (t.tick < r.tick) return E("Server resync snapshot precedes its actual incident");
+						this.current(a), a.installServerSnapshot(t, e.inputs, e.continuation), this.current(a);
+						for (let e of this.#N.keys()) e <= t.tick && this.#N.delete(e);
+						this.#F && this.#F.firstTick + this.#F.inputs.length - 1 <= t.tick && (this.#F = null), this.#I = t.tick, this.#L = !0, this.prune(), this.#M = null, this.#A++, this.#S = "joined";
+						return;
+					}
+					case "Kick":
+						this.#S = "kicked", this.release(), this.#e.close(1e3, "Lockstep kicked");
+						return;
+					case "Pong": return;
+					default: return E("Unexpected state-sync or client-only frame on lockstep server lane");
+				}
+			}), this.notify();
+		} catch {
+			this.#C = new t({ detail: "Lockstep client refused a frame or simulation operation" }), this.#S = "faulted", this.release();
+			try {
+				this.#e.close(1002, "Lockstep protocol error");
+			} catch (e) {
+				this.#g.push(e);
+			}
+			this.notify();
+		}
+	}
+	prune() {
+		let e = (this.#x?.tick ?? 0) - this.#r.horizon;
+		for (let t of this.#N.keys()) t < e && this.#N.delete(t);
+		let t = (this.#x?.tick ?? 0) - this.#r.hashHistoryTicks;
+		for (let e of this.#P.keys()) e < t && this.#P.delete(e);
+	}
+	advance() {
+		let e = this.work(() => {
+			let e = this.live();
+			if (this.#I > 0 && e.tick === this.#I && !this.#L) return E("Sample actual initial intentions at the recovered frontier before advancing further");
+			let t = e.advance();
+			return this.current(e), this.#S = t._tag === "stalled" ? "stalled" : "joined", this.prune(), t;
+		});
+		return this.notify(), e;
+	}
+	sendIntent(e) {
+		let t = this.work(() => {
+			let t = this.live();
+			if (t.tick < this.#I) return E("Consume reliable history before sampling current intentions");
+			if (!this.#L) return E("Send the explicit initial intentions before delayed local sampling");
+			if (this.#F) return E("Retry the retained intent write before replacing it");
+			let n = r(t.tick + Math.max(1, this.#r.delay)), a = i(this.#t.inputCodec.capture(e)), o = this.#d.full(a);
+			if (C.isFailure(o)) throw o.failure;
+			let s = this.#N.get(n);
+			if (s && !O(s, o.success)) return E("Sent local intent is immutable for its target tick");
+			let c = this.#r.redundantInputs - 1, l = c === 0 ? [] : [...this.#N.entries()].filter(([e]) => e < n).sort((e, t) => e[0] - t[0]).slice(-c);
+			l.push([n, s ?? o.success]);
+			let u = l.length - 1;
+			for (; u > 0 && l[u - 1][0] + 1 === l[u][0];) u--;
+			let d = l.slice(u), f = {
+				kind: "LsInput",
+				firstTick: d[0][0],
+				inputs: Object.freeze(d.map((e) => e[1]))
+			};
+			return this.encode(f), this.current(t), s || (t.submitLocal(a), this.current(t), this.#N.set(n, o.success)), this.#F = f, f;
+		});
+		return this.deliverIntent(t);
+	}
+	deliverIntent(e) {
+		if (this.#R) return Promise.reject(new t({ detail: "Lockstep intent delivery cannot overlap its retained write" }));
+		this.#R = !0;
+		try {
+			if (this.#e.unreliable) {
+				let t = this.encode(e);
+				if (t.length <= this.#e.unreliable.maxDatagramBytes) return this.#e.unreliable.send(t), this.#F === e && (this.#F = null), Promise.resolve();
+			}
+			let t = this.handOff(e);
+			return t.accepted && this.#F === e && (this.#F = null), t.task;
+		} catch (e) {
+			return Promise.reject(e);
+		} finally {
+			this.#R = !1, this.notify();
+		}
+	}
+	handOff(n) {
+		if (this.#e.signal.aborted || D(this.#S)) return {
+			accepted: !1,
+			task: Promise.reject(new t({ detail: "Lockstep transport is closed" }))
+		};
+		if (this.#h.size >= this.#r.maxPendingWrites) return {
+			accepted: !1,
+			task: Promise.reject(new e({
+				budget: "lockstepClientWrites",
+				limit: this.#r.maxPendingWrites
+			}))
+		};
+		let r = this.encode(n), i;
+		try {
+			i = this.#e.reliable.send(r);
+		} catch (e) {
+			return {
+				accepted: !1,
+				task: Promise.reject(e)
+			};
+		}
+		let a = () => {
+			this.#h.delete(i), this.notify();
+		};
+		return this.#h.add(i), i.then(a, a), {
+			accepted: !0,
+			task: i
+		};
+	}
+	sendInitialIntents(e) {
+		let t = this.work(() => {
+			let t = this.live();
+			if (this.#L || t.tick !== this.#I || this.#F || !this.#n) return E("Initial intentions are admitted exactly once at the actual bootstrap frontier");
+			let n = this.#r.delay - 1;
+			if (n < 1 || n > this.#r.redundantInputs) return E("Initial intent batch exceeds the explicit redundant-input budget");
+			let a = this.#n.initialInputs.find((e) => e.playerId === this.#n?.localPlayerId);
+			if (e === void 0 && !a) return E("Sample a real local intention when no authored initial matrix exists");
+			let o = e === void 0 ? a.input : i(this.#t.inputCodec.capture(e)), s = this.#d.full(o);
+			if (C.isFailure(s)) throw s.failure;
+			let c = r(t.tick + 1);
+			if (c > 4294967295 - n + 1) return E("Bootstrap intention ticks are exhausted");
+			let l = {
+				kind: "LsInput",
+				firstTick: c,
+				inputs: Object.freeze(Array.from({ length: n }, () => s.success))
+			};
+			this.encode(l), this.current(t);
+			for (let e = 0; e < n; e++) this.#N.set(c + e, s.success);
+			return this.#L = !0, this.#F = l, l;
+		});
+		return this.deliverIntent(t);
+	}
+	resendRetainedIntent() {
+		let e = this.work(() => {
+			let e = this.live();
+			if (this.#F) return E("Retry the retained write before resending another intention");
+			let t = r(e.tick + Math.max(1, this.#r.delay)), n = this.#N.get(t);
+			if (!n) return E("No actual retained local intention exists for this target tick");
+			let i = {
+				kind: "LsInput",
+				firstTick: t,
+				inputs: Object.freeze([n])
+			};
+			return this.encode(i), this.current(e), this.#F = i, i;
+		});
+		return this.deliverIntent(e);
+	}
+	retryIntent() {
+		this.live();
+		let e = this.#F;
+		return e ? this.deliverIntent(e) : Promise.reject(new t({ detail: "No retained lockstep intent write" }));
+	}
+	sendHash(e) {
+		let t = this.work(() => {
+			let t = this.live();
+			if (r(e), e < 1 || e % this.#r.hashEvery !== 0) return E("Hash tick is outside the configured cadence");
+			let n = t.confirmedSnapshot(e), i = this.#P.get(e);
+			if (i && (i.hi !== n.hash.hi || i.lo !== n.hash.lo)) return E("Client cannot change an immutable sent hash claim");
+			let a = Object.freeze({ ...n.hash }), o = {
+				kind: "LsHash",
+				tick: e,
+				hi: a.hi,
+				lo: a.lo
+			};
+			return this.encode(o), this.current(t), this.#P.set(e, a), o;
+		});
+		return this.write(t);
+	}
+	release() {
+		for (let e of this.#m.splice(0)) try {
+			e();
+		} catch (e) {
+			this.#g.push(e);
+		}
+		this.#x = null, this.#n = null, this.#s = null, this.#i = null, this.#a = [], this.#o = null, this.#N.clear(), this.#P.clear(), this.#F = null, this.#M = null, this.#v.clear();
+	}
+	close() {
+		this.work(() => {
+			if (!D(this.#S)) {
+				this.#S = "left", this.release();
+				try {
+					this.#e.close(1e3, "Lockstep client closed");
+				} catch (e) {
+					this.#g.push(e);
+				}
+			}
+		}), this.notify(), this.#_.clear();
+	}
+	closeAsync() {
+		return this.close(), this.#y.cleanupAsync();
+	}
+	async settled() {
+		let e = (await Promise.allSettled([...this.#h])).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+		if (e.length) throw AggregateError(e, "Lockstep client writes failed");
+	}
+}, A = (e, t, n, r) => new k(e, t, n, r);
+export { k as RoomLockstepClientSession, A as createRoomLockstepClientSession, T as isRoomLockstepClientSession };