@hopple/netcode 0.0.0-stage → 0.1.1-ci.1

package/lockstep.js

@@ -0,0 +1,672 @@
+import { ByteReader, ByteWriter } from "@hopple/bytes";
+//#region src/lockstep.ts
+/**
+* One way to run a match in lockstep: every device runs the same game, step by
+* step, on every player's input for that step. Optional: a game is welcome to
+* keep its devices in step its own way.
+*
+* **The match is a log.** Every device in a match — the sender included —
+* hears every message in the relay's one order, and every decision below is
+* made from that log alone. Two devices
+* that heard the same log run the same steps with the same inputs, whenever
+* the messages happened to reach each of them.
+*
+* **Input delay, as long as the slowest needs.** Each device's input for step t
+* is read some steps earlier, the delay, and sent, so it has time to cross the
+* relay before anybody needs it. A step runs once every seat's input for it has
+* come back through the log, this device's own included; until then the game
+* waits, and catches up after. Every device times its own messages' round trip
+* and says how many steps it needs, and every device reads with the most any
+* playing seat needs, within the game's bounds: the same delay for everybody,
+* so nobody's controls answer later than another's. It grows as soon as a seat
+* needs more, and shrinks once they have all needed less for a few seconds.
+* Where each device reads from changes nothing in the log's order, so the
+* delay can change without the devices agreeing on when.
+*
+* **Seats are handed to the game, and back.** A seat whose person left the
+* match, or went quiet for `timeoutMs` while the others waited, is dropped:
+* from a step every device works out from the log, its input arrives as `null`,
+* and the game plays it (its AI, or nobody). Its device, once caught up, asks
+* for it back, and gets it from a step that, again, the log decides. A drop
+* takes effect from the first step the seat's input is missing for in the log
+* before the drop, and a return after the furthest step any device could have
+* run, so no device has ever run a step the others will run differently.
+*
+* **Desyncs and lost devices are reported.** Every `hashEvery` steps each device
+* that plays sends a fingerprint of its state, and a difference is reported with
+* the step it was found at. A device whose connection dropped for a while
+* hears what it missed once it is back, and carries on: what it sent as the
+* connection went, and never heard come back before a later message of its
+* own, it sends again. One that missed more than the relay still held — a gap
+* in the relay's numbering — cannot follow the log any longer, and says so.
+*
+* **Rollback, optionally.** With `rollback`, a device does not wait for the
+* others' inputs: it runs on, up to `rollback.steps` steps ahead of the log,
+* guessing what they press from what they pressed last, and shows that. When an
+* input comes in that differs from the guess, it puts the game back where it was
+* before that step (`restore`) and runs the steps again, so the picture catches
+* up with what was pressed. The delay then has only to cover the round trip
+* beyond what guessing covers, and a player's own controls answer after a step
+* or two whatever the connection. Only the log confirms a step, this device's
+* own input included, so what every device agrees on, fingerprints, drops and
+* returns, is decided as it is without rollback; a guess past a drop or a return
+* is simply run again. Somebody who only watches runs confirmed steps alone.
+*
+* Messages are small: varints, inputs as the game's own bytes, `sendEvery`
+* steps a message. A match's other messages (a game's lobby, say) share the
+* log: tell them apart with `isLockstepMessage`.
+*
+* @module lockstep
+*/
+/**
+* The first byte of every message this helper sends. A game sending messages
+* of its own in the same match starts them with any other byte.
+*
+* @group Lockstep
+*/
+const LOCKSTEP_TAG = 245;
+/**
+* Whether a match message is one of a lockstep run's, for a game's own
+* listener to skip.
+*
+* @group Lockstep
+*/
+function isLockstepMessage(data) {
+	return data[0] === 245;
+}
+const NOTHING = /* @__PURE__ */ new Uint8Array(0);
+const FLAG_HASH = 1;
+const FLAG_DROP = 2;
+const FLAG_RETURN = 4;
+/** How far back round trips count towards the delay this device needs. */
+const TRIPS_MS = 2e3;
+/** How long a device needs less before it says so. */
+const SHRINK_AFTER_MS = 5e3;
+/** Steps between two steps that read nothing, while the delay shrinks. */
+const SHRINK_EVERY = 15;
+/** Steps of guessing left to absorb jitter, with rollback, before the delay grows. */
+const SLACK = 2;
+/** The most inputs in a message sending again what never came back. */
+const RESEND_MOST = 60;
+/**
+* Run a match in lockstep. See the module for how.
+*
+* ```ts
+* const run = lockstep({
+*   match, seq, run: 1, seats, me: match.me!.id,
+*   sample: () => Uint8Array.of(pad.bits()),
+*   step: (inputs) => world.step(inputs),
+*   hash: () => hash(world.summary()),
+* });
+* sdk.loop.tick((dt) => { run.advance(dt * 1000); draw(); });
+* ```
+*
+* With rollback, the game also says how to go back:
+*
+* ```ts
+* rollback: { steps: 8, save: () => world.save(), restore: (saved) => world.restore(saved) },
+* step: (inputs, tick, again) => world.step(inputs, { quiet: again }),
+* ```
+*
+* @group Lockstep
+*/
+function lockstep(options) {
+	return runLockstep(options.locals === void 0 ? options : perPlayer(options, options.locals));
+}
+/**
+* A run of one input per seat standing in for one input per player: each
+* device's players' inputs travel as one, a count and then each in turn, and
+* are taken apart again for the game.
+*/
+function perPlayer(options, locals) {
+	const counts = options.seats.map((_, seat) => Math.max(1, Math.floor(locals[seat] ?? 1)));
+	const firsts = counts.map((_, seat) => counts.slice(0, seat).reduce((sum, one) => sum + one, 0));
+	const mine = counts[options.seats.indexOf(options.me)] ?? 0;
+	const join = (inputs) => {
+		const out = new ByteWriter().uint(inputs.length);
+		for (const one of inputs) out.bytes(one);
+		return out.finish();
+	};
+	/** One seat's input as its players' inputs: none read is nothing pressed, and a seat handed to the game is each of its players handed over. */
+	const split = (input, seat) => {
+		const count = counts[seat] ?? 1;
+		if (input === null) return Array.from({ length: count }, () => null);
+		const players = Array.from({ length: count }, () => NOTHING);
+		if (input.length === 0) return players;
+		try {
+			const reader = new ByteReader(input);
+			const sent = reader.uint();
+			for (let at = 0; at < Math.min(sent, count); at++) players[at] = reader.bytes();
+		} catch {}
+		return players;
+	};
+	const own = options.rollback;
+	const predict = own?.predict;
+	const { locals: _, ...rest } = options;
+	return {
+		...rest,
+		sample(tick) {
+			const read = options.sample(tick);
+			const inputs = read instanceof Uint8Array ? [read] : [...read];
+			return join(inputs.slice(0, mine));
+		},
+		step: (inputs, tick, again) => options.step(inputs.flatMap((one, seat) => split(one, seat)), tick, again),
+		...own === void 0 ? {} : { rollback: {
+			...own,
+			...predict === void 0 ? {} : { predict: (last, seat) => join(split(last, seat).map((one, at) => predict(one ?? NOTHING, (firsts[seat] ?? 0) + at))) }
+		} }
+	};
+}
+function runLockstep(options) {
+	const { match } = options;
+	const minDelay = Math.max(1, Math.floor(options.delay?.min ?? 2));
+	const maxDelay = Math.max(minDelay, Math.floor(options.delay?.max ?? 20));
+	const rollback = options.rollback;
+	/** Steps guessing covers, the same on every device: the delay covers the rest. */
+	const covered = rollback ? Math.max(0, Math.floor(rollback.steps) - SLACK) : 0;
+	/** The most delay a device says it needs: what the bounds allow and guessing covers. */
+	const mostNeed = maxDelay + covered;
+	/** The delay a device needs before it has timed a round trip. */
+	const startNeed = Math.min(mostNeed, Math.max(minDelay, Math.floor(options.delay?.start ?? 6)));
+	/** The first step any seat reads its input for: every step before it is pressed by nobody. */
+	const start = Math.min(maxDelay, Math.max(minDelay, startNeed - covered));
+	const hashEvery = Math.max(1, Math.floor(options.hashEvery ?? 60));
+	const tickMs = options.tickMs ?? 1e3 / 60;
+	const sendEvery = Math.max(1, Math.floor(options.sendEvery ?? 2));
+	const timeoutMs = options.timeoutMs ?? 3e3;
+	const catchUp = Math.max(1, Math.floor(options.catchUp ?? 30));
+	const now = options.now ?? (() => globalThis.performance?.now() ?? Date.now());
+	const run = options.run;
+	const predict = rollback?.predict ?? ((last) => last);
+	const seats = options.seats.map((id) => ({
+		id,
+		inputs: /* @__PURE__ */ new Map(),
+		last: start - 1,
+		changes: [[0, true]],
+		heard: now(),
+		askedDrop: -Infinity,
+		need: startNeed,
+		prev: NOTHING
+	}));
+	const mine = seats.findIndex((seat) => seat.id === options.me);
+	/** How far the game may run ahead of the log: somebody who only watches waits for it. */
+	const window = rollback && mine >= 0 ? Math.max(0, Math.floor(rollback.steps)) : 0;
+	/** Steps the log has confirmed: the next step to confirm. */
+	let tick = 0;
+	/** Steps the game has run, on guesses past `tick`. */
+	let head = 0;
+	/** Past `tick`: what each step was run with, and the game as it was before it. */
+	const guessed = /* @__PURE__ */ new Map();
+	const saves = /* @__PURE__ */ new Map();
+	/** This device's own inputs as read, before they come back through the log. */
+	const local = /* @__PURE__ */ new Map();
+	let status = "running";
+	let lastSeq = options.seq;
+	let clock = 0;
+	let heardAny = now();
+	let rtt = null;
+	/** This device's recent round trips: [when heard, ms]. */
+	const trips = [];
+	/** The delay this device says it needs. */
+	let need = startNeed;
+	/** Since when it has needed less than it says, and the most it needed meanwhile. */
+	let lowSince = null;
+	let lowMost = 0;
+	/** The last step that read nothing, to shrink the delay. */
+	let skipped = -Infinity;
+	/** This device's messages still on their way through the relay, in the order sent: when, and the inputs they carry from which step. */
+	const inFlight = [];
+	/** This device's inputs that never came back through the log, to send again. */
+	const unheard = [];
+	/** Fingerprints by step: this device's, and the others'. */
+	const prints = /* @__PURE__ */ new Map();
+	let desynced = false;
+	let waiting = [];
+	/**
+	* The next step this device reads its input for — the step being run plus
+	* the delay, once it has grown or shrunk to it — or `null` while it sends
+	* none: it watches, or its seat was handed to the game and it has not asked
+	* for it back.
+	*/
+	let reading = mine >= 0 ? start : null;
+	let returning = false;
+	let askedBack = -Infinity;
+	const out = {
+		first: start,
+		inputs: [],
+		hash: null,
+		drops: [],
+		back: null
+	};
+	let sentAt = -Infinity;
+	function latest(seat) {
+		return seat.changes[seat.changes.length - 1][1];
+	}
+	function playedAt(seat, at) {
+		for (let i = seat.changes.length - 1; i >= 0; i--) if (seat.changes[i][0] <= at) return seat.changes[i][1];
+		return true;
+	}
+	/** The furthest step any device could have run, from what the log holds now. */
+	function furthest() {
+		let most = tick - 1;
+		for (const seat of seats) {
+			if (seat.last > most) most = seat.last;
+			for (const [at, played] of seat.changes) if (played && at - 1 > most) most = at - 1;
+		}
+		return most;
+	}
+	/** The delay to read with: the most any seat that plays says it needs, less what guessing covers, within the bounds. */
+	function delay() {
+		let most = 0;
+		seats.forEach((seat, index) => {
+			if (latest(seat)) most = Math.max(most, index === mine ? need : seat.need);
+		});
+		return Math.min(maxDelay, Math.max(minDelay, most - covered));
+	}
+	/**
+	* A round trip of this device's messages: the delay it needs covers nearly
+	* every recent one, and the steps an input waits to be sent. More is said at
+	* once; less only once it has lasted.
+	*/
+	function timed(trip) {
+		const at = now();
+		trips.push([at, trip]);
+		while (trips[0][0] < at - TRIPS_MS) trips.shift();
+		const sorted = trips.map(([, ms]) => ms).sort((a, b) => a - b);
+		const high = sorted[Math.floor((sorted.length - 1) * .9)];
+		const wanted = Math.min(mostNeed, Math.max(minDelay, Math.ceil(high / tickMs) + sendEvery));
+		if (wanted >= need) {
+			need = wanted;
+			lowSince = null;
+		} else if (lowSince === null) {
+			lowSince = at;
+			lowMost = wanted;
+		} else {
+			lowMost = Math.max(lowMost, wanted);
+			if (at - lowSince >= SHRINK_AFTER_MS) {
+				need = lowMost;
+				lowSince = null;
+			}
+		}
+	}
+	/**
+	* One of this device's messages, back through the log: a round trip. The
+	* relay passes on a device's messages in the order sent, so one sent before
+	* it and not heard never will be — it went with a dropped connection, or the
+	* relay refused it — and its inputs are sent again: every device would wait
+	* for them for good.
+	*/
+	function echoed(first, count) {
+		const index = inFlight.findIndex((one) => one.first === first && one.inputs.length === count);
+		if (index < 0) return;
+		for (const one of inFlight.splice(0, index)) if (one.inputs.length > 0) unheard.push(one);
+		rtt = now() - inFlight.shift().at;
+		timed(rtt);
+	}
+	/** The furthest step any seat's input has reached. */
+	function frontier() {
+		let most = -1;
+		for (const seat of seats) if (seat.last > most) most = seat.last;
+		return most;
+	}
+	function lost() {
+		if (status !== "running") return;
+		status = "lost";
+		stopListening();
+		stopWatching();
+		options.onLost?.();
+	}
+	function compare(at) {
+		const entry = prints.get(at);
+		if (entry === void 0 || entry.mine === null || desynced) return;
+		if (entry.theirs.some((one) => one !== entry.mine)) {
+			desynced = true;
+			options.onDesync?.(at);
+		}
+	}
+	/** A message of this run, from `seat`, in the log's order. */
+	function hear(seat, index, read) {
+		seat.heard = now();
+		const first = read.uint();
+		const count = read.uint();
+		for (let i = 0; i < count; i++) {
+			const at = first + i;
+			const input = read.bytes();
+			if (at >= tick) seat.inputs.set(at, input);
+			if (at > seat.last) seat.last = at;
+		}
+		if (index === mine) echoed(first, count);
+		seat.need = read.uint();
+		const flags = read.uint();
+		if (flags & FLAG_HASH) {
+			const at = read.uint();
+			const print = read.string();
+			if (index !== mine && at >= tick - hashEvery * 4) {
+				const entry = prints.get(at) ?? {
+					mine: null,
+					theirs: []
+				};
+				entry.theirs.push(print);
+				prints.set(at, entry);
+				compare(at);
+			}
+		}
+		if (flags & FLAG_DROP) {
+			const n = read.uint();
+			for (let i = 0; i < n; i++) {
+				const target = seats[read.uint()];
+				if (target === void 0 || target === seat || !latest(seat) || !latest(target)) continue;
+				let from = Math.max(target.changes[target.changes.length - 1][0], start, tick);
+				while (from <= target.last && target.inputs.has(from)) from++;
+				target.changes.push([from, false]);
+			}
+		}
+		if (flags & FLAG_RETURN) {
+			const asked = read.uint();
+			if (!latest(seat)) seat.changes.push([Math.max(asked, furthest() + 1), true]);
+		}
+	}
+	const stopListening = match.onMessage((data, from, seq) => {
+		if (status !== "running" || seq <= lastSeq) return;
+		if (seq !== lastSeq + 1) {
+			lost();
+			return;
+		}
+		lastSeq = seq;
+		heardAny = now();
+		if (data[0] !== 245) return;
+		const index = seats.findIndex((seat) => seat.id === from.id);
+		if (index < 0) return;
+		const read = new ByteReader(data.subarray(1));
+		try {
+			if (read.uint() !== run) return;
+			hear(seats[index], index, read);
+		} catch {}
+	});
+	const stopWatching = match.on(() => watch());
+	/** The last input a seat is known to have pressed before `at`. */
+	function lastBefore(seat, index, at) {
+		for (let k = at - 1; k >= tick; k--) {
+			const one = seat.inputs.get(k) ?? (index === mine ? local.get(k) : void 0);
+			if (one !== void 0) return one;
+		}
+		return seat.prev;
+	}
+	/** The inputs to run `at` with: every input heard for it, and guesses for the rest. */
+	function best(at) {
+		let real = true;
+		return {
+			inputs: seats.map((seat, index) => {
+				if (!playedAt(seat, at)) return null;
+				if (at < start) return NOTHING;
+				const heard = seat.inputs.get(at);
+				if (heard !== void 0) return heard;
+				real = false;
+				return (index === mine ? local.get(at) : void 0) ?? predict(lastBefore(seat, index, at), index);
+			}),
+			real
+		};
+	}
+	/** Every playing seat's input for `at`, or `null`, with `waiting` saying who is missing. */
+	function inputsFor(at) {
+		const inputs = [];
+		const missing = [];
+		for (const seat of seats) if (!playedAt(seat, at)) inputs.push(null);
+		else if (at < start) inputs.push(NOTHING);
+		else {
+			const input = seat.inputs.get(at);
+			if (input === void 0) missing.push(seat.id);
+			else inputs.push(input);
+		}
+		waiting = missing;
+		return missing.length === 0 ? inputs : null;
+	}
+	function restartReading() {
+		reading = head + delay();
+		out.first = reading;
+		out.inputs = [];
+	}
+	/** Follow this device's own seat: stop reading once it is handed over, and ask for it back once caught up. */
+	function settle(caughtUp) {
+		if (mine < 0) return;
+		if (latest(seats[mine])) {
+			returning = false;
+			return;
+		}
+		if (!returning) {
+			if (reading !== null) {
+				reading = null;
+				out.inputs = [];
+				out.hash = null;
+				local.clear();
+				unheard.length = 0;
+			}
+			if (!caughtUp) return;
+			returning = true;
+			restartReading();
+		} else if (now() - askedBack < 3e3) return;
+		askedBack = now();
+		out.back = reading;
+	}
+	/** A message of inputs from step `first`, with what else `extra` holds. */
+	function post(first, inputs, extra = null) {
+		const at = now();
+		const write = new ByteWriter().byte(245).uint(run).uint(first).uint(inputs.length);
+		for (const input of inputs) write.bytes(input);
+		write.uint(need);
+		if (extra === null) write.uint(0);
+		else {
+			write.uint((extra.hash ? FLAG_HASH : 0) | (extra.drops.length > 0 ? FLAG_DROP : 0) | (extra.back !== null ? FLAG_RETURN : 0));
+			if (extra.hash) write.uint(extra.hash[0]).string(extra.hash[1]);
+			if (extra.drops.length > 0) {
+				write.uint(extra.drops.length);
+				for (const seat of extra.drops) write.uint(seat);
+			}
+			if (extra.back !== null) write.uint(extra.back);
+		}
+		match.send(write.finish());
+		inFlight.push({
+			at,
+			first,
+			inputs
+		});
+		if (inFlight.length > 512) inFlight.shift();
+		sentAt = at;
+	}
+	function send(stalled, flush = false) {
+		if (reading === null) unheard.length = 0;
+		let again = null;
+		for (const one of unheard.splice(0)) {
+			if (again !== null && again.first + again.inputs.length === one.first && again.inputs.length + one.inputs.length <= RESEND_MOST) {
+				again.inputs.push(...one.inputs);
+				continue;
+			}
+			if (again !== null) post(again.first, again.inputs);
+			again = {
+				first: one.first,
+				inputs: [...one.inputs]
+			};
+		}
+		if (again !== null) post(again.first, again.inputs);
+		if (reading === null && out.drops.length === 0) return;
+		const at = now();
+		const urgent = out.drops.length > 0 || out.back !== null || flush && (out.inputs.length > 0 || out.hash !== null);
+		const ready = out.inputs.length >= sendEvery || out.hash !== null || stalled && out.inputs.length > 0;
+		const keepAlive = stalled && at - sentAt > 500;
+		if (!urgent && !ready && !keepAlive) return;
+		if (!urgent && at - sentAt < tickMs * sendEvery * .75) return;
+		post(out.first, out.inputs, out);
+		out.first += out.inputs.length;
+		out.inputs = [];
+		out.hash = null;
+		out.drops = [];
+		out.back = null;
+	}
+	/** Ask for the seats whose person left, or that kept everybody waiting too long, to be handed to the game. */
+	function watch() {
+		if (status !== "running" || mine < 0 || !latest(seats[mine])) return;
+		const at = now();
+		const present = new Set(match.players.map((one) => one.id));
+		const connected = at - heardAny < 1500;
+		seats.forEach((seat, index) => {
+			if (index === mine || !latest(seat) || at - seat.askedDrop < Math.min(timeoutMs, 5e3)) return;
+			const left = !present.has(seat.id);
+			const silent = connected && waiting.includes(seat.id) && at - seat.heard > timeoutMs;
+			if (left || silent) {
+				seat.askedDrop = at;
+				out.drops.push(index);
+			}
+		});
+	}
+	/** This device's input for the next step it reads, sent with the next message. */
+	function read() {
+		const sampled = options.sample(reading);
+		const input = sampled instanceof Uint8Array ? sampled : sampled[0] ?? NOTHING;
+		out.inputs.push(input);
+		if (window > 0) local.set(reading, input);
+		reading++;
+	}
+	function same(a, b) {
+		return a.every((one, i) => {
+			const other = b[i];
+			if (one === null || other === null) return one === other;
+			return one.length === other.length && one.every((byte, j) => byte === other[j]);
+		});
+	}
+	/** The log has every input for step `at`, the game ran it with them, and it is this device's to forget. */
+	function confirm(at, print) {
+		for (const seat of seats) {
+			const input = seat.inputs.get(at);
+			if (input !== void 0) seat.prev = input;
+			seat.inputs.delete(at);
+			while (seat.changes.length > 1 && seat.changes[1][0] <= at) seat.changes.shift();
+		}
+		local.delete(at);
+		saves.delete(at);
+		guessed.delete(at);
+		if (print !== null) {
+			const entry = prints.get(at) ?? {
+				mine: null,
+				theirs: []
+			};
+			entry.mine = print;
+			prints.set(at, entry);
+			compare(at);
+			if (reading !== null) out.hash = [at, print];
+		}
+		prints.delete(at - hashEvery * 4);
+		tick = at + 1;
+	}
+	/** Run step `at`: confirmed at once when it has every input and follows the last confirmed step, kept to go back to otherwise. */
+	function runStep(at, inputs, real, again) {
+		const settles = real && at === tick;
+		if (!settles) saves.set(at, rollback.save());
+		options.step(inputs, at, again);
+		const print = options.hash && at > 0 && at % hashEvery === 0 ? options.hash() : null;
+		if (settles) confirm(at, print);
+		else guessed.set(at, {
+			inputs,
+			real,
+			print
+		});
+	}
+	/** Confirm the guessed steps every input has come in for, as guessed; go back to the first guessed wrong, and run from there again. */
+	function correct() {
+		let wrong = -1;
+		for (let at = tick; at < head; at++) {
+			const was = guessed.get(at);
+			const now = best(at);
+			if (!same(was.inputs, now.inputs)) {
+				wrong = at;
+				break;
+			}
+			if (now.real) was.real = true;
+		}
+		while (tick < head && tick !== wrong && guessed.get(tick).real) confirm(tick, guessed.get(tick).print);
+		if (wrong < 0) return;
+		rollback.restore(saves.get(wrong));
+		for (let at = wrong; at < head && status === "running"; at++) {
+			const { inputs, real } = best(at);
+			runStep(at, inputs, real, true);
+		}
+	}
+	return {
+		advance(ms) {
+			if (status !== "running") return 0;
+			settle(false);
+			const lead = delay();
+			while (reading !== null && reading - head < lead) read();
+			if (window > 0) correct();
+			clock = Math.min(clock + Math.max(0, ms), tickMs * 3);
+			let budget = Math.floor(clock / tickMs);
+			const behind = frontier() - lead - head;
+			if (behind > 2) budget = Math.max(budget, Math.min(catchUp, behind));
+			let ran = 0;
+			let stalled = false;
+			while (ran < budget && status === "running") {
+				let inputs;
+				let real = true;
+				if (window === 0) inputs = inputsFor(head);
+				else {
+					({inputs, real} = best(head));
+					if (!real && head - tick >= window) {
+						inputsFor(tick);
+						inputs = null;
+					}
+				}
+				if (inputs === null) {
+					stalled = true;
+					break;
+				}
+				if (reading !== null) {
+					if (reading - head > lead && head - skipped >= SHRINK_EVERY) skipped = head;
+					else read();
+				}
+				if (window === 0) {
+					options.step(inputs, head, false);
+					confirm(head, options.hash && head > 0 && head % hashEvery === 0 ? options.hash() : null);
+				} else runStep(head, inputs, real, false);
+				head++;
+				ran++;
+			}
+			if (!stalled) waiting = [];
+			clock = Math.max(0, clock - ran * tickMs);
+			settle(stalled || frontier() - lead - head <= 2);
+			watch();
+			send(stalled);
+			return ran;
+		},
+		get tick() {
+			return head;
+		},
+		get confirmed() {
+			return tick;
+		},
+		get waiting() {
+			return waiting;
+		},
+		get status() {
+			return status;
+		},
+		playing(seat) {
+			const one = seats[seat];
+			return one !== void 0 && playedAt(one, head);
+		},
+		get rtt() {
+			return rtt;
+		},
+		get delay() {
+			return delay();
+		},
+		stop() {
+			if (status === "running") {
+				send(false, true);
+				status = "stopped";
+			}
+			stopListening();
+			stopWatching();
+		}
+	};
+}
+//#endregion
+export { LOCKSTEP_TAG, isLockstepMessage, lockstep };