@v12-engine/engine 0.1.1 → 0.4.0

package/dist/session/remote.js

@@ -0,0 +1,1394 @@
+import { footprintOf } from "../defs.js";
+import { worldFailed } from "../engineEvents.js";
+import { toMessage } from "../messages.js";
+import { hasGroundSpeeds, navigationSpeedOn } from "../groundSpeed.js";
+import { groundKnownTo } from "../cellLayers.js";
+import { formationPreview } from "../formation.js";
+import { BuildGrid } from "../grid.js";
+import { placementCells, siteOf } from "../orders/build.js";
+import { errorFields } from "../log.js";
+import { mergeValues, redefineIn, redefinitions, restoreRedefinitions } from "../gameData.js";
+import { loadTerrain, saveTerrain } from "../terrainSave.js";
+import { MissingGround, applyGroundChanges, applyTerrainPatch, groundOf, isGroundChanges, savedGround, terrainPatchProblem } from "../ground.js";
+import { RecastNavigation } from "../navigation/recast.js";
+import { AirNavigation } from "../navigation/air.js";
+import { createRegistry } from "../game.js";
+import { isServerMessage, readHostMessage } from "./wire.js";
+import { isFiniteNumber, protocolMismatch, readMessage } from "./protocol.js";
+import { apply, bytesByKey, diff, quantize } from "./delta.js";
+import { LocalDebug, RemoteDebug, askDebug } from "./debug.js";
+import { LocalSession, endSharedCaptures, shareCaptures } from "./local.js";
+//#region src/session/remote.ts
+/**
+* Two ends of a connection in the page, `[client, host]`: everything sent is text, delivered after the latency the
+* options give. The whole networked way, in one page and in tests
+*
+* @beta
+*/
+function loopback(options = {}) {
+	const { latency = 0, jitter = 0, loss = 0, random = Math.random } = options;
+	/** One end: what it is handed to deliver, and the transport its side holds */
+	class End {
+		lossy;
+		peer;
+		bytesSent = 0;
+		messagesSent = 0;
+		handler = () => {};
+		closed = () => {};
+		open = true;
+		/** When the last message sent is due: none overtakes the one before */
+		last = 0;
+		constructor(lossy) {
+			this.lossy = lossy;
+		}
+		send(message) {
+			if (!this.open) return;
+			this.bytesSent += message.length;
+			this.messagesSent++;
+			if (this.lossy && loss > 0 && message.startsWith("{\"type\":\"delta\"") && random() < loss) return;
+			const due = Math.max(performance.now() + latency + random() * jitter, this.last);
+			this.last = due;
+			const { peer } = this;
+			setTimeout(() => peer.deliver(message), Math.max(due - performance.now(), 0));
+		}
+		deliver(message) {
+			if (this.open) this.handler(message);
+		}
+		onMessage(handler) {
+			this.handler = handler;
+		}
+		onClose(handler) {
+			this.closed = handler;
+		}
+		close() {
+			this.shut();
+			const { peer } = this;
+			setTimeout(() => peer.shut(), Math.max(this.last - performance.now(), latency, 0));
+		}
+		shut() {
+			if (!this.open) return;
+			this.open = false;
+			this.closed();
+		}
+	}
+	const client = new End(false);
+	const host = new End(true);
+	client.peer = host;
+	host.peer = client;
+	return [client, host];
+}
+/** Whether what a player sent as a command is one to look at: an object with a type. Its fields are its definition's to check */
+var isCommand = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
+/**
+* Runs of equal values: how many 0s, then how many 1s, and so on
+*
+* @internal
+*/
+function toRuns(cells) {
+	const runs = [];
+	let value = 0;
+	let count = 0;
+	for (let i = 0; i < cells.length; i++) {
+		const cell = cells[i] ? 1 : 0;
+		if (cell === value) count++;
+		else {
+			runs.push(count);
+			value = cell;
+			count = 1;
+		}
+	}
+	runs.push(count);
+	return runs;
+}
+/**
+* Cells back from `toRuns`, into `out`
+*
+* @internal
+*/
+function fromRuns(runs, out) {
+	let at = 0;
+	let value = 0;
+	for (const run of runs) {
+		out.fill(value, at, Math.min(at + run, out.length));
+		at += run;
+		value ^= 1;
+	}
+	return out;
+}
+/** The fog for the wire: nothing of its cells when the whole map is lit, which they say nothing about then */
+var fogMessage = (fog) => fog.revealed ? {
+	revealed: true,
+	visible: [],
+	explored: []
+} : {
+	revealed: false,
+	visible: toRuns(fog.visible),
+	explored: toRuns(fog.explored)
+};
+/** The runs of a team's fog, by its cells, as they were at a version of the fog: the seats of a team share them */
+var fogRuns = /* @__PURE__ */ new WeakMap();
+var revealedFog = {
+	revealed: true,
+	visible: [],
+	explored: []
+};
+/** The fog for the wire, its runs made once for every seat of a team while it stays as it is */
+function fogMessageOf(fog) {
+	if (fog.revealed) return revealedFog;
+	const known = fogRuns.get(fog.visible);
+	if (known && known.version === fog.version) return known.message;
+	const message = fogMessage(fog);
+	fogRuns.set(fog.visible, {
+		version: fog.version,
+		message
+	});
+	return message;
+}
+/**
+* What each state told was rounded to (`quantize`), by the very object: a state that did not change is the object it
+* was (`LocalSession` hands back what it told while it still says the truth), so it is rounded once and stays the same
+* object round after round, which the diff then passes over without looking inside (`diff`)
+*/
+var quantizedStates = /* @__PURE__ */ new WeakMap();
+function quantizedOf(state) {
+	let made = quantizedStates.get(state);
+	if (!made) quantizedStates.set(state, made = quantize(state));
+	return made;
+}
+/**
+* The entities of a frame as the wire has them (`quantize`), one list between the seats of a round told the very same
+* (the seats of a side, the observers: what they are told of an entity is one object between them, `LocalSession`), so
+* that it is rounded once and a diff of the same two lists is worked out once (`diff`). `made` is this round's so far
+*/
+function quantizedList(entities, made) {
+	for (const { told, sent } of made) {
+		if (told.length !== entities.length) continue;
+		let alike = true;
+		for (let i = 0; i < told.length; i++) if (told[i] !== entities[i]) {
+			alike = false;
+			break;
+		}
+		if (alike) return sent;
+	}
+	const sent = entities.map(quantizedOf);
+	made.push({
+		told: entities,
+		sent
+	});
+	return sent;
+}
+/** Milliseconds between two pings, to measure the time to the host and back */
+var PING_EVERY = 2e3;
+/** Seconds of jitter the interpolation buffer makes room for, at most */
+var MAX_JITTER = .2;
+/**
+* Seconds with no snapshot after which the host is taken to have gone quiet, at the least (three of its usual gaps
+* between two where they are longer), as it does while its world stands still (a replay held, a game paused): the
+* screen then comes to the newest snapshot it has, there being nothing to make room for
+*/
+var QUIET = .5;
+var emptyTiming = (since, byKey = false) => ({
+	since,
+	ticks: 0,
+	tickTime: 0,
+	tickMax: 0,
+	sends: 0,
+	sendTime: 0,
+	sendMax: 0,
+	parts: {
+		capture: 0,
+		quantize: 0,
+		fog: 0,
+		diff: 0,
+		stringify: 0
+	},
+	bytes: 0,
+	...byKey && { keys: {} }
+});
+/** Frames kept on either side, at most: more than a second and a half of ticks a player has not said it got */
+var KEPT_FRAMES = 64;
+/**
+* Bytes of the frames kept for one player, at most (`SessionHostOptions.keptBytes`): 8 MB, some thirty frames of a
+* thousand units (a frame of them is about 250 KB). A player who has said nothing for longer is sent everything again
+*/
+var KEPT_BYTES = 8388608;
+/** What each list of entities a frame keeps takes as the wire writes it: one list between the seats of a side (`quantizedList`) */
+var listBytes = /* @__PURE__ */ new WeakMap();
+/** Entities of a list written out to tell what the list takes: the rest are taken to be as big */
+var SAMPLED = 8;
+/**
+* What a frame kept for a player takes, about: its entities as the wire writes them (some of them written out, the rest
+* taken to be as big: writing out all of a thousand units' at every send costs more than the send itself), its fog,
+* its players
+*/
+function frameBytes(frame) {
+	const { entities, players } = frame.snapshot;
+	let bytes = listBytes.get(entities);
+	if (bytes === void 0) {
+		const sampled = Math.min(entities.length, SAMPLED);
+		let written = 0;
+		for (let i = 0; i < sampled; i++) written += JSON.stringify(entities[Math.floor(i * entities.length / sampled)]).length;
+		listBytes.set(entities, bytes = sampled ? Math.round(written / sampled * entities.length) : 0);
+	}
+	let fog = listBytes.get(frame.fog);
+	if (fog === void 0) listBytes.set(frame.fog, fog = JSON.stringify(frame.fog).length);
+	let told = listBytes.get(players);
+	if (told === void 0) listBytes.set(players, told = JSON.stringify(players).length);
+	return bytes + fog + told;
+}
+/**
+* Snapshots waiting for the screen, at most (`RemoteSession.update`): three seconds of them at 20 a second. A page
+* whose screen stops asking (a tab in the background) folds the oldest into the next, their events kept, rather than
+* keeping every one for as long as it is away
+*/
+var KEPT_SNAPSHOTS = 64;
+/** Events the folded snapshots carry together, at most: the newest kept. What is the screen's only (the state is in the snapshot) */
+var KEPT_SCREEN_EVENTS = 2e3;
+/**
+* Runs a world for players connected to it over transports: the server's job, done anywhere. It steps the world by
+* the clock (`start`) or by hand (`update`), and at most `sendRate` times a second sends every player what changed in
+* what they may know (`Delta`), as their `LocalSession` seat sees it: against the last tick they said they got, with
+* the events they have not. Their commands come in as they arrive, and go in at the next tick
+*
+* @beta
+*/
+var SessionHost = class {
+	world;
+	seats = /* @__PURE__ */ new Set();
+	accumulator = 0;
+	sinceSent = Infinity;
+	timer;
+	last = 0;
+	sendEvery;
+	/** Simulation speed multiplier, 0 pauses */
+	speed = 1;
+	constructor(world, options = {}) {
+		this.world = world;
+		this.sendEvery = 1 / (options.sendRate ?? 20);
+		this.maxTicks = options.maxTicksPerUpdate ?? 8;
+		this.onSlowTick = options.onSlowTick;
+		this.ownsWorld = options.ownsWorld ?? false;
+		this.dropSilentAfter = options.dropSilentAfter ?? 15;
+		this.keptEvents = options.keptEvents ?? 600;
+		this.keptFrames = Math.max(2, options.keptFrames ?? KEPT_FRAMES);
+		this.keptBytes = Math.max(1, options.keptBytes ?? KEPT_BYTES);
+		this.groundPart = Math.max(1, options.groundPart ?? GROUND_PART);
+		this.byKey = options.bytesByKey ?? false;
+		this.timing = emptyTiming(performance.now(), this.byKey);
+		this.onError = options.onError;
+		this.stopFailed = world.events.on(worldFailed, (failure) => {
+			for (const seat of this.seats) this.post(seat, {
+				type: "failed",
+				message: failure.message
+			});
+		});
+	}
+	onError;
+	stopFailed;
+	dropSilentAfter;
+	keptFrames;
+	keptBytes;
+	groundPart;
+	keptEvents;
+	/** Whether the characters sent are counted by what they carry (`bytesByKey`) */
+	byKey;
+	ownsWorld;
+	maxTicks;
+	onSlowTick;
+	/**
+	* Seats a player at the world, on the host's end of a transport. The welcome goes out at once: everything the player
+	* may know, also to one who comes back. `readOnly` for who only watches: their commands go nowhere but their lines
+	* of chat and their pings, which go to who watches alone (`observers`, said by `name`); and with `observer` they see
+	* everything, from `player`'s side. `allow` decides on each command before it goes in: a limit of how many, a game
+	* paused. One it lets go is answered, refused (the `command` event of its `seq`): with what it gives for why, or
+	* `cannotDoThat` for `false`. `inOrder` for a transport that loses nothing and keeps the order (a worker's messages):
+	* each frame is the base of the next once it went, with no answer waited for, so the player always gets what changed
+	* since the frame it has, and takes it in without looking over the rest
+	*/
+	connect(player, transport, options = {}) {
+		const session = new LocalSession(this.world, player, { observer: options.observer });
+		const seat = {
+			transport,
+			session,
+			frames: /* @__PURE__ */ new Map(),
+			frameSizes: /* @__PURE__ */ new Map(),
+			keptBytes: 0,
+			acked: -1,
+			heardUpTo: -1,
+			events: [],
+			eventsMade: 0,
+			sentAt: /* @__PURE__ */ new Map(),
+			roundTrip: 100,
+			heard: this.world.tick,
+			answers: [],
+			groundSent: /* @__PURE__ */ new Set(),
+			inOrder: options.inOrder ?? false
+		};
+		this.seats.add(seat);
+		transport.onMessage((text) => {
+			const message = readMessage(text);
+			if (!message) return;
+			if (message.type === "ack") {
+				if (isFiniteNumber(message.tick)) this.acknowledge(seat, message.tick, isFiniteNumber(message.events) ? message.events : void 0);
+			} else if (message.type === "ping") {
+				if (isFiniteNumber(message.at)) this.post(seat, {
+					type: "pong",
+					at: message.at
+				});
+			} else if (message.type === "ground") {
+				const parts = this.groundParts();
+				const { part } = message;
+				if (parts && Number.isInteger(part) && part >= 0 && part < parts.length && !seat.groundSent.has(part)) {
+					seat.groundSent.add(part);
+					this.post(seat, {
+						type: "ground",
+						part,
+						parts: parts.length,
+						text: parts[part]
+					});
+				}
+			} else if (message.type === "debug") {
+				if (!this.world.debugPlayers.has(player)) return;
+				seat.debug ??= {
+					view: new LocalDebug(this.world),
+					sentAt: -Infinity
+				};
+				askDebug(seat.debug.view, message);
+				seat.debug.sentAt = -Infinity;
+			} else if (message.type === "command" && options.readOnly) {
+				const { command } = message;
+				if (!isCommand(command) || command.type !== "chat" && command.type !== "ping") return;
+				session.send({
+					...command,
+					to: "observers",
+					by: options.name ?? "A watcher"
+				});
+				this.heardOutside = true;
+			} else if (message.type === "command") {
+				const allowed = options.allow?.() ?? true;
+				const seq = isFiniteNumber(message.seq) ? message.seq : void 0;
+				if (!isCommand(message.command)) return;
+				if ((message.command.type === "chat" || message.command.type === "ping") && message.command.to === "observers") return;
+				if (allowed === true) {
+					session.send(message.command, seq);
+					if (this.world.registry.command(message.command.type)?.outsideTick) this.heardOutside = true;
+				} else if (seq !== void 0) seat.answers.push({
+					type: "command",
+					seq,
+					refusal: allowed ? toMessage(allowed) : { key: "cannotDoThat" }
+				});
+			}
+		});
+		transport.onClose(() => this.leave(seat));
+		const { registry } = this.world;
+		this.post(seat, {
+			type: "welcome",
+			protocol: 13,
+			player,
+			tickRate: this.world.tickRate,
+			game: registry.game,
+			hash: registry.dataHash,
+			terrain: savedGround(groundKnownTo(this.world, options.observer ? void 0 : this.world.player(player).team), this.world.ground, this.world.registry.module?.maps, this.world.registry.module ?? {}),
+			...this.world.map.environment && { environment: this.world.map.environment },
+			...this.world.map.doodads.length > 0 && { doodads: [...this.world.map.doodads] },
+			...this.world.map.regions.length > 0 && { regions: [...this.world.map.regions] },
+			...this.world.map.cameras.length > 0 && { cameras: [...this.world.map.cameras] },
+			...this.world.map.paths.length > 0 && { paths: [...this.world.map.paths] },
+			...this.world.states.has(redefinitions) && { redefinitions: structuredClone(this.world.state(redefinitions)) },
+			first: this.deltaFor(seat),
+			...options.observer ? { observer: true } : {},
+			...this.world.debugPlayers.has(player) && { debug: true }
+		});
+	}
+	/** The ground the world started as, whole, in parts small enough to go one at a time: made the first time one is asked for */
+	groundParts() {
+		const base = this.world.ground;
+		if (!base) return void 0;
+		if (!this.ground) {
+			const text = JSON.stringify(saveTerrain(base.terrain));
+			this.ground = [];
+			for (let i = 0; i < text.length; i += this.groundPart) this.ground.push(text.slice(i, i + this.groundPart));
+		}
+		return this.ground;
+	}
+	ground;
+	/** The player has the frame of `tick`: what comes next is made against it, and what it has is not sent again */
+	acknowledge(seat, tick, events) {
+		if (events !== void 0) seat.events = seat.events.filter((sent) => sent.n > events);
+		if (tick <= seat.heardUpTo || tick > this.world.tick) return;
+		seat.heardUpTo = tick;
+		seat.heard = this.world.tick;
+		const sent = seat.sentAt.get(tick) ?? (seat.whole?.tick === tick ? seat.whole.at : void 0);
+		if (sent !== void 0) seat.roundTrip += (performance.now() - sent - seat.roundTrip) * .2;
+		if (seat.whole && tick >= seat.whole.tick) seat.whole = void 0;
+		for (const kept of seat.sentAt.keys()) if (kept <= tick) seat.sentAt.delete(kept);
+		seat.events = seat.events.filter((sent) => sent.tick > tick);
+		if (!seat.frames.has(tick)) return;
+		seat.acked = tick;
+		for (const kept of [...seat.frames.keys()]) if (kept < tick) this.forget(seat, kept);
+	}
+	/**
+	* Whether a player is sent nothing this round: it has no frame kept to make a delta against, and the whole one it
+	* was sent last is on its way still. Another would be as big, and come no sooner than the answer to the first
+	*/
+	holding(seat, now) {
+		return !!seat.whole && !seat.frames.has(seat.acked) && now - seat.whole.at <= seat.roundTrip * 1.5 + this.sendEvery * 1e3;
+	}
+	leave(seat) {
+		if (!this.seats.delete(seat)) return;
+		seat.session.dispose();
+		seat.debug?.view.dispose();
+		if (this.seats.size === 0) this.stop();
+	}
+	/** How many players are connected */
+	get players() {
+		return this.seats.size;
+	}
+	/**
+	* How much the host keeps for each connected player, for a test of its limits (`keptFrames`, `keptEvents`): the
+	* frames it may make a delta against, when each was sent, and the events not yet said to be had
+	*
+	* @internal
+	*/
+	kept() {
+		return [...this.seats].map((seat) => ({
+			frames: seat.frames.size,
+			bytes: seat.keptBytes,
+			sentAt: seat.sentAt.size,
+			events: seat.events.length
+		}));
+	}
+	post(seat, message) {
+		seat.transport.send(JSON.stringify(message));
+	}
+	/** Lets `dt` seconds pass: the ticks that fit into it, then what changed to everyone, when it is time to send */
+	update(dt) {
+		const { world } = this;
+		let stepped = false;
+		this.accumulator += dt * this.speed * world.cheats.speed;
+		if (world.cheats.speed === 0 && this.speed > 0 && world.debugWaiting) this.accumulator += world.dt;
+		this.sinceSent += dt;
+		let ticks = 0;
+		while (this.accumulator >= world.dt) {
+			if (ticks++ >= this.maxTicks) {
+				this.accumulator = 0;
+				break;
+			}
+			const began = performance.now();
+			world.step();
+			const took = performance.now() - began;
+			const { timing, totals } = this;
+			timing.ticks++;
+			timing.tickTime += took;
+			timing.tickMax = Math.max(timing.tickMax, took);
+			totals.ticks++;
+			totals.tickTime += took;
+			totals.lastTick = took;
+			if (took > world.dt * 1e3) this.onSlowTick?.(took, world.tick);
+			this.accumulator -= world.dt;
+			stepped = true;
+		}
+		if (stepped || this.heardOutside) this.sendDue();
+	}
+	/** What the debug tools of a seat follow, as the world stands: when they follow, list or log anything */
+	sendDebug(seat, debug, now) {
+		debug.sentAt = now;
+		const { view } = debug;
+		view.refresh();
+		if (!view.inspection && !view.world && !view.logging) return;
+		this.post(seat, {
+			type: "debug",
+			inspection: view.inspection,
+			world: view.world,
+			log: view.logging ? [...view.log()] : []
+		});
+	}
+	/** Moves the game on by `ticks` at the next update, however fast it goes: a step of a held game (`speed` 0) */
+	advance(ticks = 1) {
+		this.accumulator += this.world.dt * Math.max(0, Math.floor(ticks));
+	}
+	/**
+	* Sends everyone what changed, when it is time to, for a world something else steps: the page's own game, shared with
+	* those who watch it (`shareGame`). `dt` is the seconds since the last call. Nothing goes while the world stands still
+	*/
+	publish(dt) {
+		this.sinceSent += dt;
+		if (this.world.tick !== this.sentTick || this.heardOutside) this.sendDue();
+	}
+	/** The tick what changed went out at last */
+	sentTick = -1;
+	/** Talk was carried out since what changed went out last: it goes out with no tick to wait for (RV14) */
+	heardOutside = false;
+	/** What changed to everyone, when the rate allows */
+	sendDue() {
+		if (this.sinceSent < this.sendEvery) return;
+		this.sentTick = this.world.tick;
+		this.heardOutside = false;
+		this.sinceSent = Math.min(this.sinceSent - this.sendEvery, this.sendEvery);
+		const began = performance.now();
+		const silent = this.dropSilentAfter * this.world.tickRate;
+		shareCaptures(this.world);
+		this.roundEntities = [];
+		try {
+			for (const seat of [...this.seats]) {
+				if (this.world.tick - seat.heard > silent) {
+					seat.transport.close();
+					this.leave(seat);
+				} else if (this.holding(seat, began)) this.sentTick = -1;
+				else {
+					const delta = this.deltaFor(seat);
+					const made = performance.now();
+					const text = JSON.stringify({
+						type: "delta",
+						...delta
+					});
+					this.timing.parts.stringify += performance.now() - made;
+					this.timing.bytes += text.length;
+					if (this.timing.keys) bytesByKey(delta, text, this.timing.keys);
+					seat.transport.send(text);
+				}
+				if (seat.debug && began - seat.debug.sentAt >= 100) this.sendDebug(seat, seat.debug, began);
+			}
+		} finally {
+			endSharedCaptures(this.world);
+			this.roundEntities = [];
+		}
+		const took = performance.now() - began;
+		const { timing, totals } = this;
+		timing.sends++;
+		timing.sendTime += took;
+		timing.sendMax = Math.max(timing.sendMax, took);
+		totals.sends++;
+		totals.sendTime += took;
+	}
+	/**
+	* Where the host's time went since it was last asked (`takeTiming`): ticks of the simulation, and rounds of sending
+	* everyone what changed (the snapshots, the diffs, the JSON), each in milliseconds, added up and at most
+	*/
+	timing;
+	/**
+	* Where the host's time went since it started, never counted anew: ticks and rounds of sending, with the
+	* milliseconds they took, and how long the last tick took. What a server's numbers are made of (`/metrics`)
+	*/
+	totals = {
+		ticks: 0,
+		tickTime: 0,
+		lastTick: 0,
+		sends: 0,
+		sendTime: 0
+	};
+	/** Where the time went since the last call, and starts counting anew: for a server to print */
+	takeTiming() {
+		const now = performance.now();
+		const timing = {
+			...this.timing,
+			seconds: (now - this.timing.since) / 1e3
+		};
+		this.timing = emptyTiming(now, this.byKey);
+		return timing;
+	}
+	/** The lists of entities told this round so far, and what each was sent as, for the seats told the same to share one (`quantizedList`) */
+	roundEntities = [];
+	/** What the player knows now, as what changed since the tick they last said they got */
+	deltaFor(seat) {
+		const { session } = seat;
+		const { parts } = this.timing;
+		const began = performance.now();
+		const snapshot = session.snapshot();
+		const captured = performance.now();
+		const told = seat.answers.length ? [...snapshot.events, ...seat.answers.splice(0)] : snapshot.events;
+		if (told.length) seat.events.push({
+			tick: snapshot.tick,
+			n: ++seat.eventsMade,
+			events: told
+		});
+		let over = seat.events.length - this.keptEvents;
+		while (over-- > 0 && seat.events[0].sentAt !== void 0) seat.events.shift();
+		const entities = quantizedList(snapshot.entities, this.roundEntities);
+		const quantized = performance.now();
+		const fog = fogMessageOf(session.fog());
+		const fogged = performance.now();
+		const frame = {
+			snapshot: {
+				...snapshot,
+				entities,
+				events: []
+			},
+			fog,
+			camps: session.camps().map((camp) => ({ ...camp })),
+			team: session.team
+		};
+		const now = performance.now();
+		const overdue = seat.roundTrip * 1.5 + this.sendEvery * 1e3;
+		const events = seat.events.filter((sent) => sent.sentAt === void 0 || now - sent.sentAt > overdue);
+		for (const sent of events) sent.sentAt = now;
+		const base = seat.frames.get(seat.acked);
+		const delta = {
+			...diff(base, frame, this.world.registry),
+			events: events.map(({ tick, n, events }) => ({
+				tick,
+				n,
+				events
+			}))
+		};
+		if (!base) seat.whole = {
+			tick: frame.snapshot.tick,
+			at: now
+		};
+		parts.capture += captured - began;
+		parts.quantize += quantized - captured;
+		parts.fog += fogged - quantized;
+		parts.diff += performance.now() - fogged;
+		this.keep(seat, frame);
+		if (seat.inOrder) {
+			seat.acked = frame.snapshot.tick;
+			seat.whole = void 0;
+			for (const kept of [...seat.frames.keys()]) if (kept < seat.acked) this.forget(seat, kept);
+		}
+		seat.sentAt.set(frame.snapshot.tick, now);
+		if (seat.sentAt.size > this.keptFrames) seat.sentAt.delete(seat.sentAt.keys().next().value);
+		return delta;
+	}
+	/**
+	* Keeps the frame a player was sent, to make the next delta against: the oldest let go past `keptFrames` of them or
+	* `keptBytes` together, the newest kept whatever it takes. A player who says nothing for long is sent everything
+	* again, once its base is no longer kept
+	*/
+	keep(seat, frame) {
+		const { tick } = frame.snapshot;
+		const bytes = frameBytes(frame);
+		seat.frames.set(tick, frame);
+		seat.frameSizes.set(tick, bytes);
+		seat.keptBytes += bytes;
+		while (seat.frames.size > 1 && (seat.frames.size > this.keptFrames || seat.keptBytes > this.keptBytes)) this.forget(seat, seat.frames.keys().next().value);
+	}
+	/** Lets go of a frame kept for a player */
+	forget(seat, tick) {
+		if (!seat.frames.delete(tick)) return;
+		seat.keptBytes -= seat.frameSizes.get(tick) ?? 0;
+		seat.frameSizes.delete(tick);
+	}
+	/** Runs the world by the clock, `rate` updates a second, until `stop` or `dispose` */
+	start(rate = this.world.tickRate) {
+		this.stop();
+		this.last = performance.now();
+		this.timer = setInterval(() => {
+			const now = performance.now();
+			const dt = Math.min((now - this.last) / 1e3, .25);
+			this.last = now;
+			try {
+				this.update(dt);
+			} catch (error) {
+				this.stop();
+				if (this.onError) this.onError(error);
+				else this.world.log.error("server", "stepping the game threw: it is stopped", { error: errorFields(error) });
+			}
+		}, 1e3 / rate);
+	}
+	/** Stops stepping the world by the clock; does nothing if it was not started */
+	stop() {
+		if (this.timer !== void 0) clearInterval(this.timer);
+		this.timer = void 0;
+	}
+	/** Whether it runs by the clock */
+	get running() {
+		return this.timer !== void 0;
+	}
+	/** Stops, and closes every connection. The world goes too, when it is the host's (`ownsWorld`) */
+	/**
+	* Stops, and lets every player go: their connections closed, unless `closeTransports` is false (a server that keeps
+	* them for its lobby, after the game)
+	*/
+	dispose(options = {}) {
+		this.stop();
+		this.stopFailed();
+		for (const seat of [...this.seats]) {
+			if (options.closeTransports !== false) seat.transport.close();
+			this.leave(seat);
+		}
+		if (this.ownsWorld) this.world.dispose();
+	}
+};
+/**
+* What the player's side keeps of the map, to answer the screen without asking the host: a placement grid and the
+* ways to walk of the map as it was made, with the structures the player has seen on them. What they have not seen
+* is not there: a path preview never goes around a building in the dark, and gives it away
+*/
+var ClientWorld = class {
+	terrain;
+	registry;
+	nav;
+	air;
+	grid;
+	known = /* @__PURE__ */ new Map();
+	seen = /* @__PURE__ */ new Set();
+	constructor(terrain, registry, nav, air) {
+		this.terrain = terrain;
+		this.registry = registry;
+		this.nav = nav;
+		this.air = air;
+		this.grid = new BuildGrid(terrain);
+	}
+	/** Whether a resource of a kind that it knows of covers just this ground, with nothing it knows of standing on it */
+	resourceAt(kind, cellX, cellZ, w, d) {
+		let found = false;
+		for (const structure of this.known.values()) {
+			if (structure.cellX !== cellX || structure.cellZ !== cellZ || structure.w !== w || structure.d !== d) continue;
+			if (structure.resource !== kind) return false;
+			found = true;
+		}
+		return found;
+	}
+	/** Brings the structures up to date with a snapshot: those in it stand, those no longer in it are gone */
+	sync(snapshot) {
+		const { seen, known } = this;
+		seen.clear();
+		let changed = false;
+		for (const entity of snapshot.entities) {
+			if (!this.registry.units.has(entity.type)) continue;
+			if (!this.registry.unit(entity.type).footprint) continue;
+			seen.add(entity.id);
+			if (this.stand(entity)) changed = true;
+		}
+		const gone = [];
+		for (const id of known.keys()) if (!seen.has(id)) gone.push(id);
+		this.settle(gone, changed);
+	}
+	/**
+	* Brings the structures up to date with a snapshot made on the one before it, from what came and went alone: the
+	* last `added` of its entities (`apply` puts those that came after the rest), and the ids of those `removed`. What
+	* `sync` does, without looking over every entity of the map
+	*/
+	change(snapshot, added, removed) {
+		const { entities } = snapshot;
+		let changed = false;
+		const gone = removed.filter((id) => this.known.has(id));
+		for (const id of gone) this.release(id);
+		for (let i = entities.length - added; i < entities.length; i++) {
+			const entity = entities[i];
+			if (!this.registry.units.has(entity.type) || !this.registry.unit(entity.type).footprint) continue;
+			if (this.stand(entity)) changed = true;
+		}
+		this.settle([], changed || gone.length > 0, gone.length > 0);
+	}
+	/** Puts a structure on the map, where it is not on it yet: whether it was put */
+	stand(entity) {
+		const { known, grid, nav } = this;
+		if (known.has(entity.id)) return false;
+		const def = this.registry.unit(entity.type);
+		const site = siteOf(def, entity);
+		const { w, d } = footprintOf(def);
+		known.set(entity.id, {
+			cellX: site.cellX,
+			cellZ: site.cellZ,
+			w,
+			d,
+			...def.resource && { resource: def.resource.id }
+		});
+		grid.occupy(site.cellX, site.cellZ, w, d, entity.id);
+		nav.addObstacle(entity.id, site);
+		return true;
+	}
+	/** Takes a structure off the map */
+	release(id) {
+		const structure = this.known.get(id);
+		this.known.delete(id);
+		this.grid.release(structure.cellX, structure.cellZ, structure.w, structure.d, id);
+		this.nav.removeObstacle(id);
+	}
+	/** Takes off those gone, gives the ground back to what stood on them, and has the navmesh take in what changed */
+	settle(gone, changed, released = false) {
+		for (const id of gone) this.release(id);
+		released ||= gone.length > 0;
+		if (released) for (const [id, structure] of this.known) this.grid.occupy(structure.cellX, structure.cellZ, structure.w, structure.d, id);
+		if (changed || released) this.nav.update(0);
+	}
+};
+/**
+* The host said no, with why: to come back to a game that is over, or a player let go. Trying again does not help
+*
+* @beta
+*/
+var SessionRefused = class extends Error {
+	reason;
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+		this.name = "SessionRefused";
+	}
+};
+/**
+* A player's seat at a world that runs elsewhere, over a transport (see `connect`). It rebuilds what the host sends
+* as changes (`Delta`) into whole snapshots, keeping the objects of what did not change, says which ticks it got, and
+* answers the screen's questions from those and its own copy of the map (`ClientWorld`). No debug access, and no
+* checkpoints: those belong to a simulation in the page
+*
+* @beta
+*/
+var RemoteSession = class {
+	transport;
+	map;
+	limits;
+	/**
+	* A seat over a wire can none of what a game in this page can (`SessionCan`), but the debug tools' view of the world
+	* for a player the host lets use them (`inspect`, said over the wire)
+	*/
+	can;
+	/** The debug tools' view of the world, for a player the host lets use them (the welcome's `debug`) */
+	get debugView() {
+		return this.remoteDebug;
+	}
+	remoteDebug;
+	/** The player this seat plays, as the host welcomed it */
+	playerId;
+	/** The team of that player; updated when a snapshot says it changed */
+	team;
+	/** The ground, built from the welcome and the parts the host sent */
+	terrain;
+	/** The map's look (sky, mist, light) from the welcome, when it has one */
+	environment;
+	/** The map's scenery objects from the welcome */
+	doodads;
+	/** The map's named regions from the welcome */
+	regions;
+	/** The map's named camera positions from the welcome */
+	cameras;
+	/** The map's named paths from the welcome */
+	paths;
+	/** The definitions of the game, from the rules the player connected with */
+	registry;
+	/** Simulation ticks per second the host runs at, from the welcome */
+	tickRate;
+	/** How far, 0..1, the shown tick is between the last two snapshots, for blending the drawing */
+	alpha = 1;
+	/** What the player knows by tick, for the deltas to come: from the base of the last one on */
+	frames = /* @__PURE__ */ new Map();
+	latest;
+	incoming = [];
+	/** What the host's definitions were changed to while it ran (`world.redefine`), as this screen heard it */
+	redefined = {};
+	/** The number of the last batch of events that went to the screen (`Delta.events`): those sent again are not applied twice */
+	eventsUpTo = -1;
+	fogState;
+	closed = false;
+	/** The tick the screen shows, between the last two snapshots given out */
+	renderTick;
+	/** The tick of the snapshot given out last, and of the one before it */
+	shownTick;
+	shownBefore;
+	/** Ticks between two snapshots, evened out */
+	interval = 1;
+	/** How far off the time snapshots arrive at is from the ticks between them, in seconds, evened out */
+	jitter = 0;
+	/** Seconds between two snapshots' arrivals, evened out: a seek's come as often as any, their ticks far apart */
+	gap = 0;
+	/** When the last snapshot arrived, and its tick */
+	arrival;
+	constructor(transport, welcome, registry, map, limits = {}) {
+		this.transport = transport;
+		this.map = map;
+		this.limits = limits;
+		this.playerId = welcome.player;
+		this.tickRate = welcome.tickRate;
+		this.observer = welcome.observer ?? false;
+		this.remoteDebug = welcome.debug ? new RemoteDebug((ask) => this.tell({
+			type: "debug",
+			...ask
+		})) : void 0;
+		this.can = this.remoteDebug ? { inspect: this.remoteDebug } : {};
+		this.registry = registry;
+		this.terrain = map.terrain;
+		this.environment = welcome.environment;
+		this.doodads = welcome.doodads ?? [];
+		this.regions = welcome.regions ?? [];
+		this.cameras = welcome.cameras ?? [];
+		this.paths = welcome.paths ?? [];
+		restoreRedefinitions(registry, welcome.redefinitions);
+		this.heardRedefined(welcome.redefinitions);
+		const cells = this.terrain.width * this.terrain.depth;
+		this.fogState = {
+			width: this.terrain.width,
+			depth: this.terrain.depth,
+			version: 0,
+			revealed: false,
+			visible: new Uint8Array(cells),
+			explored: new Uint8Array(cells)
+		};
+		const first = this.take(welcome.first);
+		this.latest = first;
+		this.team = first.team;
+		this.incoming.length = 0;
+		this.shownTick = this.shownBefore = first.snapshot.tick;
+		this.attach(transport);
+	}
+	/** Talks through a transport from now on: what comes in is taken, and its closing is a drop */
+	attach(transport) {
+		this.transport = transport;
+		this.closed = false;
+		this.leaving = false;
+		transport.onMessage((text) => {
+			const message = readHostMessage(text);
+			if (message) this.receive(message);
+		});
+		transport.onClose(() => {
+			if (this.transport !== transport) return;
+			this.closed = true;
+			clearInterval(this.pinger);
+			if (!this.leaving) this.onDisconnect?.();
+		});
+		this.sendPing();
+		clearInterval(this.pinger);
+		this.pinger = setInterval(() => this.sendPing(), this.limits.pingEvery ?? PING_EVERY);
+	}
+	/** Whether the host has gone */
+	get disconnected() {
+		return this.closed;
+	}
+	/**
+	* Told when the connection drops, not by this side's leaving (`dispose`): to try again (`resume`), or to say the
+	* game is lost
+	*/
+	onDisconnect;
+	/** This side closed it: not a drop */
+	leaving = false;
+	/**
+	* Goes on with the same game over a new connection, once the host has welcomed it there again (a server does, to who
+	* comes back with their seat's token): everything known sent again, and the screen catches up. What the host says
+	* besides the game before the welcome goes to `onServer`; a `refused` fails it with the reason, as does a connection
+	* that closes first, or a host that runs another game
+	*/
+	async resume(transport) {
+		const welcome = await new Promise((resolve, reject) => {
+			transport.onClose(() => reject(/* @__PURE__ */ new Error("The host closed the connection before it took the player back")));
+			transport.onMessage((text) => {
+				const message = readHostMessage(text);
+				if (!message) return;
+				if (message.type === "welcome") resolve(message);
+				else if (message.type === "refused") reject(new SessionRefused(String(message.reason ?? "refused")));
+				else if (isServerMessage(message)) this.onServer?.(message);
+			});
+		});
+		const problem = welcomeProblem(welcome);
+		if (problem) {
+			transport.close();
+			throw new Error(problem);
+		}
+		if (welcome.game !== this.registry.game || welcome.hash !== this.registry.dataHash || welcome.player !== this.playerId) {
+			transport.close();
+			throw new Error("The host took the player back to another game");
+		}
+		restoreRedefinitions(this.registry, welcome.redefinitions);
+		this.heardRedefined(welcome.redefinitions);
+		this.eventsUpTo = -1;
+		this.attach(transport);
+		this.frames.clear();
+		this.incoming.length = 0;
+		this.arrival = void 0;
+		this.interval = 1;
+		this.jitter = 0;
+		this.gap = 0;
+		if (welcome.first.tick < this.shownTick) {
+			this.shownTick = this.shownBefore = welcome.first.tick;
+			this.renderTick = void 0;
+			this.eventsUpTo = welcome.first.tick - 1;
+		}
+		this.take(welcome.first);
+		this.remoteDebug?.askAgain();
+	}
+	/** Keeps what the host's definitions were changed to, over what was kept before */
+	heardRedefined(data) {
+		for (const [kind, byId] of Object.entries(data ?? {})) for (const [id, values] of Object.entries(byId)) {
+			const kept = this.redefined[kind] ??= {};
+			kept[id] = mergeValues(kept[id] ?? {}, values);
+		}
+	}
+	/**
+	* Takes a new version of the game into this screen's registry (hot reload, a game in a worker): its definitions as
+	* the new version has them, what the host changed of them while it ran over them again
+	*/
+	takeGame(game) {
+		this.registry.takeFrom(createRegistry(game));
+		restoreRedefinitions(this.registry, this.redefined);
+	}
+	/** Takes in a message of the host's: what the transport hands it, and what came in while the session was made */
+	receive(message) {
+		if (message.type === "delta") this.take(message);
+		else if (message.type === "debug") this.remoteDebug?.take(message);
+		else if (message.type === "pong") {
+			const took = performance.now() - message.at;
+			this.ping = this.ping === void 0 ? took : this.ping + (took - this.ping) * .3;
+		} else if (message.type === "failed") {
+			if (typeof message.message === "string") this.failure = { message: message.message };
+		} else if (isServerMessage(message)) {
+			if (message.type === "paused") {
+				this.pause = message.paused === true ? {
+					...typeof message.player === "number" && { player: message.player },
+					...typeof message.seconds === "number" && { until: Date.now() + message.seconds * 1e3 }
+				} : null;
+				this.onPause?.(this.pause);
+			}
+			this.onServer?.(message);
+		}
+	}
+	/**
+	* The game paused by the server, for everyone: by a player (`player`, until a time at most, in `Date.now()`'s
+	* milliseconds) or an admin (neither). Null while it goes on
+	*/
+	pause = null;
+	/** Told each time the server pauses the game or lets it go on */
+	onPause;
+	/** Says something to the server beside the game: a lobby's message (`{ type: 'resume' }`) */
+	tell(message) {
+		if (!this.closed) this.transport.send(JSON.stringify(message));
+	}
+	/** Why the game ended on an error in its rules, once the host said so */
+	failure = null;
+	/** Milliseconds a message takes to the host and back, evened out: measured every couple of seconds */
+	ping;
+	/** Whether the player only watches, and sees everything */
+	observer;
+	pinger;
+	/** Asks the host to answer at once, to measure the time there and back */
+	sendPing() {
+		if (!this.closed) this.transport.send(JSON.stringify({
+			type: "ping",
+			at: performance.now()
+		}));
+	}
+	/** Told of what the host says besides the game: a server's messages (see `ConnectOptions.onServer`) */
+	onServer;
+	/** Rebuilds the frame a delta makes, says it got it, and has its snapshot wait for the screen */
+	take(delta) {
+		const base = delta.base === null ? void 0 : this.frames.get(delta.base);
+		if (delta.base !== null && !base) return void 0;
+		const frame = apply(base, delta, this.latest);
+		const { snapshot } = frame;
+		this.frames.set(snapshot.tick, frame);
+		for (const tick of this.frames.keys()) if (delta.base !== null && tick < delta.base) this.frames.delete(tick);
+		if (delta.rest.fog) this.takeFog(delta.rest.fog);
+		if (delta.rest.team !== void 0) this.team = delta.rest.team;
+		const events = [];
+		for (const sent of delta.events) {
+			if (sent.n <= this.eventsUpTo) continue;
+			events.push(...sent.events);
+			this.eventsUpTo = sent.n;
+			for (const event of sent.events) {
+				if (event.type === "redefined") {
+					redefineIn(this.registry, event.kind, event.definition, event.values);
+					this.heardRedefined({ [event.kind]: { [event.definition]: event.values } });
+				}
+				if (event.type === "ground" && !terrainPatchProblem(this.terrain, event.patch)) applyTerrainPatch(this.terrain, event.patch);
+				if (event.type !== "cells") continue;
+				const layer = this.terrain.cellLayer(event.layer);
+				for (const c of event.at) if (c >= 0 && c < layer.length) layer[c] = event.value;
+			}
+		}
+		this.incoming.push({
+			...snapshot,
+			events
+		});
+		if (this.incoming.length > (this.limits.keptSnapshots ?? KEPT_SNAPSHOTS)) this.fold();
+		this.arrived(snapshot.tick);
+		if (base && base === this.latest) this.map.change(snapshot, delta.added.length, delta.removed);
+		else this.map.sync(snapshot);
+		this.latest = frame;
+		if (!this.closed) this.transport.send(JSON.stringify({
+			type: "ack",
+			tick: snapshot.tick,
+			events: this.eventsUpTo
+		}));
+		return frame;
+	}
+	/**
+	* The oldest snapshot waiting let go, its events put before the next one's: the screen, when it asks again, jumps
+	* to the newest anyway. The state is in every snapshot; the events (deaths, sounds, lines said) are what would be lost
+	*/
+	fold() {
+		const oldest = this.incoming.shift();
+		if (!oldest.events.length) return;
+		const next = this.incoming[0];
+		const events = oldest.events.concat(next.events);
+		const mostEvents = this.limits.keptScreenEvents ?? KEPT_SCREEN_EVENTS;
+		this.incoming[0] = {
+			...next,
+			events: events.length > mostEvents ? events.slice(-mostEvents) : events
+		};
+	}
+	/**
+	* Snapshots come in and not yet given to the screen (`update`): a few normally, never more than a few seconds of
+	* them, however long the screen does not ask
+	*
+	* @beta
+	*/
+	get waiting() {
+		return this.incoming.length;
+	}
+	takeFog(message) {
+		const fog = this.fogState;
+		fog.revealed = message.revealed;
+		fromRuns(message.visible, fog.visible);
+		fromRuns(message.explored, fog.explored);
+		fog.version++;
+	}
+	/** The newest snapshot the host sent */
+	snapshot() {
+		return this.latest.snapshot;
+	}
+	/** The tick the screen is shown at, between two snapshots: behind the newest by `delay` */
+	get shownAt() {
+		return this.renderTick ?? this.shownTick;
+	}
+	/**
+	* The ticks between two snapshots, and the jitter the interpolation makes room for, as it has them evened out. A
+	* test may set the jitter, as a late line would have
+	*
+	* @internal
+	*/
+	get pacing() {
+		return {
+			interval: this.interval,
+			jitter: this.jitter
+		};
+	}
+	/** @internal */
+	set pacing(pacing) {
+		this.jitter = pacing.jitter;
+	}
+	/** How far behind the newest snapshot the screen is shown, in ticks: about two snapshots, and room for the jitter */
+	get delay() {
+		return this.interval * 2 + Math.min(this.jitter, this.limits.maxJitter ?? .2) * this.tickRate * 2;
+	}
+	/** Takes note of when a snapshot arrived, for how far apart they come and how unevenly */
+	arrived(tick) {
+		const now = performance.now();
+		const last = this.arrival;
+		this.arrival = {
+			at: now,
+			tick
+		};
+		if (!last || tick <= last.tick) return;
+		const ticks = tick - last.tick;
+		this.interval += (ticks - this.interval) * .1;
+		this.gap += ((now - last.at) / 1e3 - this.gap) * .1;
+		const off = Math.abs((now - last.at) / 1e3 - ticks / this.tickRate);
+		this.jitter += (off - this.jitter) * .1;
+	}
+	/**
+	* Lets the screen's clock go on by `dt`, and gives out the snapshots it has come to, oldest first: the screen draws
+	* between the last two (`alpha`). The time is the host's: the clock follows the snapshots, not the other way around
+	*/
+	update(dt) {
+		const newest = this.incoming.length ? this.incoming[this.incoming.length - 1].tick : this.shownTick;
+		const target = !!this.arrival && performance.now() - this.arrival.at > Math.max(QUIET, this.gap * 3) * 1e3 ? newest : newest - this.delay;
+		if (this.renderTick === void 0 || target - this.renderTick > this.tickRate) this.renderTick = target;
+		else {
+			const rate = 1 + Math.max(-.1, Math.min((target - this.renderTick) * .05, .1));
+			this.renderTick += dt * this.tickRate * rate;
+		}
+		this.renderTick = Math.min(this.renderTick, newest);
+		const out = [];
+		while (this.incoming.length && this.renderTick >= this.shownTick) {
+			const next = this.incoming.shift();
+			this.shownBefore = this.shownTick;
+			this.shownTick = next.tick;
+			out.push(next);
+		}
+		const span = this.shownTick - this.shownBefore;
+		this.alpha = span > 0 ? Math.max(0, Math.min((this.renderTick - this.shownBefore) / span, 1)) : 1;
+		return out;
+	}
+	/** Sends a command to the host and returns the number it was given, which the host's answer names; does nothing once closed */
+	send(command) {
+		const seq = ++this.lastSeq;
+		if (!this.closed) this.transport.send(JSON.stringify({
+			type: "command",
+			seq,
+			command
+		}));
+		return seq;
+	}
+	/** The number of the last command sent */
+	lastSeq = 0;
+	/** The team's fog as built from what the host sent */
+	fog() {
+		return this.fogState;
+	}
+	/** The creep camps as the newest frame has them */
+	camps() {
+		return this.latest.camps;
+	}
+	/**
+	* Whether the player could build this here, as far as they can tell: on their copy of the map, with the structures
+	* they know, on ground they have explored. The game's own say (the `canPlace` hook) is the host's: it may still refuse
+	*/
+	canPlace(unitType, point) {
+		if (!this.registry.units.has(unitType)) return false;
+		const def = this.registry.unit(unitType);
+		const site = siteOf(def, point);
+		const { w, d } = footprintOf(def);
+		if (def.builtOn !== void 0 ? !this.map.resourceAt(def.builtOn, site.cellX, site.cellZ, w, d) : !this.map.grid.canPlace(site.cellX, site.cellZ, w, d)) return false;
+		const fog = this.fogState;
+		if (fog.revealed) return true;
+		const explored = (x, z) => fog.explored[Math.floor(z) * fog.width + Math.floor(x)] === 1;
+		return explored(site.x - site.hw + .5, site.z - site.hd + .5) && explored(site.x + site.hw - .5, site.z - site.hd + .5) && explored(site.x - site.hw + .5, site.z + site.hd - .5) && explored(site.x + site.hw - .5, site.z + site.hd - .5);
+	}
+	/** Which cells of a building's ground are in the way, as `canPlace` sees them: on the player's copy of the map, explored */
+	placeCells(unitType, point) {
+		if (!this.registry.units.has(unitType)) return void 0;
+		const fog = this.fogState;
+		return placementCells(this.registry.unit(unitType), point, (x, z) => this.map.grid.canPlace(x, z, 1, 1), fog.revealed ? void 0 : (x, z) => fog.explored[z * fog.width + x] === 1);
+	}
+	/** The way a unit would walk, on the player's copy of the map: around the structures they know, and no others */
+	/** Where a group would stand sent to a point in a formation, `rows` when none is named: the rules are the host's (`GameSession.formationPlaces`) */
+	formationPlaces(units, point, facing, formation = "rows") {
+		return formationPreview(this.registry, units, point, this.map, formation, facing);
+	}
+	/** A path over the ground the player has, on the air layer when `flying`; null when there is none */
+	findPath(from, to, flying = false) {
+		return (flying ? this.map.air : this.map.nav).findPath(from, to);
+	}
+	/** Stops pinging, closes the connection and frees the navigation made from the ground */
+	dispose() {
+		clearInterval(this.pinger);
+		this.leaving = true;
+		if (!this.closed) this.transport.close();
+		this.closed = true;
+		this.map.nav.dispose();
+		this.map.air.dispose();
+	}
+};
+/** How much of the ground goes in one message, for a player who does not have its map: well under what a connection holds */
+var GROUND_PART = 262144;
+/**
+* The ground of a welcome: all of it, or the map it started as among the player's (S36), the changes put on it. A
+* player without that map asks the host for it, a part at a time, and puts the changes on what it is sent
+*/
+async function groundOfWelcome(transport, ground, maps, game, early, dropped) {
+	try {
+		return groundOf(ground, maps, game).terrain;
+	} catch (error) {
+		if (!(error instanceof MissingGround) || !isGroundChanges(ground)) throw error;
+	}
+	const whole = await new Promise((resolve, reject) => {
+		const parts = [];
+		transport.onClose(() => {
+			dropped();
+			reject(/* @__PURE__ */ new Error("The host closed the connection while the ground was sent"));
+		});
+		transport.onMessage((text) => {
+			const message = readHostMessage(text);
+			if (message?.type !== "ground") {
+				early.push(text);
+				return;
+			}
+			parts[message.part] = message.text;
+			if (message.part + 1 < message.parts) transport.send(JSON.stringify({
+				type: "ground",
+				part: message.part + 1
+			}));
+			else {
+				transport.onMessage((later) => early.push(later));
+				resolve(JSON.parse(parts.join("")));
+			}
+		});
+		transport.send(JSON.stringify({
+			type: "ground",
+			part: 0
+		}));
+	});
+	return applyGroundChanges(loadTerrain(whole), ground);
+}
+/**
+* What is wrong with a welcome, before anything of it is used: another version of the wire (`PROTOCOL_VERSION`), or a
+* shape that is not one. What comes after it is the host's word, trusted as the welcome said it would be
+*/
+function welcomeProblem(welcome) {
+	if (welcome.protocol !== 13) return protocolMismatch(welcome.protocol);
+	return Number.isInteger(welcome.player) && isFiniteNumber(welcome.tickRate) && welcome.tickRate > 0 && typeof welcome.game === "string" && typeof welcome.hash === "string" && typeof welcome.terrain === "object" && welcome.terrain !== null && typeof welcome.first === "object" && welcome.first !== null ? void 0 : "The host sent a welcome this player cannot read";
+}
+/**
+* Connects to a host over a transport (the player's end of it), and waits for the welcome: what the session is
+* made of. Fails when the host runs another version of the game, or of the engine's wire (`PROTOCOL_VERSION`), and
+* when the connection closes before the session is made: while the map is made from the welcome too
+*
+* @public
+*/
+function connect(transport, options) {
+	return connectAs(transport, options, (...made) => new RemoteSession(...made));
+}
+/** `connect`, for a session of a kind of its own: `make` is given what a `RemoteSession` is made of */
+async function connectAs(transport, options, make) {
+	let dropped = false;
+	const drop = () => {
+		dropped = true;
+	};
+	const welcome = await new Promise((resolve, reject) => {
+		transport.onClose(() => {
+			drop();
+			reject(/* @__PURE__ */ new Error("The host closed the connection before the game started"));
+		});
+		transport.onMessage((text) => {
+			const message = readHostMessage(text);
+			if (!message) return;
+			if (message.type === "welcome") resolve(message);
+			else if (isServerMessage(message)) options.onServer?.(message);
+		});
+	});
+	const problem = welcomeProblem(welcome);
+	if (problem) {
+		transport.close();
+		throw new Error(problem);
+	}
+	const game = "id" in options.rules && typeof options.rules.id === "string" ? options.rules : options.rules[welcome.game];
+	const own = "id" in options.rules && typeof options.rules.id === "string" ? options.rules.id : void 0;
+	const others = otherPacks(welcome.game, game?.id ?? own);
+	if (!game) {
+		transport.close();
+		throw new Error(others ?? `The host runs ${welcome.game}, which this player does not have`);
+	}
+	const registry = createRegistry(game);
+	if (welcome.game !== registry.game || welcome.hash !== registry.dataHash) {
+		transport.close();
+		throw new Error(others ?? `The host runs ${welcome.game} (${welcome.hash}), this is ${registry.game} (${registry.dataHash}): not the same game`);
+	}
+	const early = [];
+	transport.onMessage((text) => early.push(text));
+	transport.onClose(drop);
+	const lost = "The host closed the connection while the map was made";
+	if (dropped) throw new Error(lost);
+	const terrain = await groundOfWelcome(transport, welcome.terrain, options.maps ?? game.maps, game, early, drop);
+	transport.onClose(drop);
+	const speedAt = hasGroundSpeeds(registry) ? (x, z) => navigationSpeedOn(registry, terrain, x, z) : void 0;
+	const nav = await RecastNavigation.create(terrain, {
+		agentRadius: .5,
+		...speedAt && { speedAt },
+		...options.navigation
+	});
+	if (dropped) {
+		nav.dispose();
+		throw new Error(lost);
+	}
+	const session = make(transport, welcome, registry, new ClientWorld(terrain, registry, nav, new AirNavigation(terrain.width, terrain.depth)), options.limits);
+	session.onServer = options.onServer;
+	for (const text of early) {
+		const message = readHostMessage(text);
+		if (message) session.receive(message);
+	}
+	return session;
+}
+/**
+* What a player is told who joins a game of the same base as theirs with other packs of content or mods
+* (`melee+gnomes` against `melee`): the host's and theirs. Nothing for games of other bases, or the same
+*/
+function otherPacks(host, own) {
+	if (own === void 0 || own === host) return void 0;
+	const [hostBase, ...hostPacks] = host.split("+");
+	const [ownBase, ...ownPacks] = own.split("+");
+	if (hostBase !== ownBase) return void 0;
+	const list = (packs) => packs.length ? packs.join(", ") : "none";
+	return `The host plays ${hostBase} with the packs ${list(hostPacks)}, this player with ${list(ownPacks)}: the host's are the game's`;
+}
+//#endregion
+export { ClientWorld, MAX_JITTER, RemoteSession, SessionHost, SessionRefused, connect, connectAs, fromRuns, loopback, toRuns };
+
+//# sourceMappingURL=remote.js.map