@v12-engine/engine 0.1.0 → 0.4.0

package/dist/packs-g5thvmGn.js

@@ -1,3199 +0,0 @@
-import { $ as MissingGround, $d as atan, Cn as withData, F as tableItems, Fc as availableTo, Hi as footprintCell, J as objectFields, Kc as toMessage, L as TARGET_FIELDS, N as groupChoices, Q as targetName, Qt as createMap, Qu as worldFailed, R as campFields, U as mapFields, Vi as BuildGrid, X as reachedByDefault, Y as playerFields, Z as regionFields, _n as redefineIn, af as sin, bn as restoreRedefinitions, ci as siteOf, ct as savedGround, ef as atan2, et as applyTerrainPatch, ft as terrainPatchProblem, hn as mergeValues, ht as saveTerrain, if as hypot, ii as placementCells, jt as Rng, kn as errorFields, mt as loadTerrain, ot as groundOf, pt as withChanges, st as isGroundChanges, tf as cos, tn as DATA_KINDS, vn as redefinitions, xd as footprintOf, xt as mapTerrain } from "./debugCommands-CzjrSm66.js";
-import { P as groundKnownTo, X as hasGroundSpeeds, Y as groundSpeedOn, p as AirNavigation, r as createRegistry, s as maxPlayersOf } from "./game-DiJEN-Ks.js";
-import { Sn as shapeBounds, gt as RecastNavigation } from "./coreComponents-syuh2fPG.js";
-import { _ as readMessage, a as RemoteDebug, c as bytesByKey, g as protocolMismatch, h as isFiniteNumber, i as LocalDebug, l as diff, n as endSharedCaptures, o as askDebug, r as shareCaptures, s as apply, t as LocalSession, u as quantize } from "./local-Dkovq42k.js";
-//#region src/session/wire.ts
-/** The game's own messages to a player: the rest are a server's or a relay's (`ServerToPlayer`) */
-var GAME_TYPES = /* @__PURE__ */ new Set([
-	"welcome",
-	"pong",
-	"ground",
-	"failed",
-	"delta",
-	"debug"
-]);
-/**
-* Whether a message to a player is a server's or a relay's, not the game's
-*
-* @internal
-*/
-var isServerMessage = (message) => !GAME_TYPES.has(message.type);
-/** Every type a player is sent, each said once: what is not one of them is not read */
-var HOST_TYPES = {
-	welcome: true,
-	pong: true,
-	ground: true,
-	failed: true,
-	delta: true,
-	debug: true,
-	lobby: true,
-	seated: true,
-	watching: true,
-	full: true,
-	refused: true,
-	lobbyChat: true,
-	paused: true,
-	result: true,
-	waiting: true,
-	ended: true
-};
-/** Every type a host or a server is sent */
-var PLAYER_TYPES = {
-	command: true,
-	ack: true,
-	ping: true,
-	ground: true,
-	debug: true,
-	join: true,
-	start: true,
-	sit: true,
-	ready: true,
-	name: true,
-	resume: true,
-	setting: true,
-	seatSetting: true,
-	admin: true,
-	lobbyChat: true,
-	kick: true,
-	watch: true
-};
-/** A message as text, an object of a known type, or nothing: not JSON, not an object, a type that is not one of `types` */
-function read(text, types) {
-	let message;
-	try {
-		message = JSON.parse(text);
-	} catch {
-		return;
-	}
-	if (typeof message !== "object" || message === null || Array.isArray(message)) return void 0;
-	const { type } = message;
-	return typeof type === "string" && Object.hasOwn(types, type) ? message : void 0;
-}
-/**
-* What a host or a server sent, as text: one of its messages, or nothing for what is not (not JSON, not an object of a
-* type a player is sent). Its fields are its receiver's to check
-*
-* @internal
-*/
-var readHostMessage = (text) => read(text, HOST_TYPES);
-/**
-* What a player sent, as text: one of its messages, or nothing for what is not
-*
-* @internal
-*/
-var readPlayerMessage = (text) => read(text, PLAYER_TYPES);
-//#endregion
-//#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;
-}
-/**
-* 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(quantize);
-	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;
-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`
-	*/
-	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()
-		};
-		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;
-		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)) {
-					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);
-		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);
-	}
-	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, grid, nav } = this;
-		seen.clear();
-		let changed = false;
-		for (const entity of snapshot.entities) {
-			if (!this.registry.units.has(entity.type)) continue;
-			const def = this.registry.unit(entity.type);
-			if (!def.footprint) continue;
-			seen.add(entity.id);
-			if (known.has(entity.id)) continue;
-			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.kind }
-			});
-			grid.occupy(site.cellX, site.cellZ, w, d, entity.id);
-			nav.addObstacle(entity.id, site);
-			changed = true;
-		}
-		let released = false;
-		for (const [id, structure] of known) {
-			if (seen.has(id)) continue;
-			known.delete(id);
-			grid.release(structure.cellX, structure.cellZ, structure.w, structure.d, id);
-			nav.removeObstacle(id);
-			changed = released = true;
-		}
-		if (released) for (const [id, structure] of known) grid.occupy(structure.cellX, structure.cellZ, structure.w, structure.d, id);
-		if (changed) 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;
-	playerId;
-	team;
-	terrain;
-	environment;
-	doodads;
-	regions;
-	cameras;
-	paths;
-	registry;
-	tickRate;
-	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;
-	/** 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;
-		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);
-		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++;
-	}
-	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;
-		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 = newest - this.delay;
-		if (this.renderTick === void 0 || Math.abs(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;
-	}
-	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;
-	fog() {
-		return this.fogState;
-	}
-	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 */
-	findPath(from, to, flying = false) {
-		return (flying ? this.map.air : this.map.nav).findPath(from, to);
-	}
-	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 withChanges(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
-*
-* @beta
-*/
-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.game && typeof options.game.id === "string" ? options.game : options.game[welcome.game];
-	const own = "id" in options.game && typeof options.game.id === "string" ? options.game.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) => groundSpeedOn(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
-//#region src/session/delay.ts
-/** The tick a message to a player says it brings: of a delta from the head of its text, of the welcome from the frame it carries */
-var tickOf = (message) => {
-	const found = /^\{"type":"delta","tick":(\d+)/.exec(message) ?? (message.startsWith("{\"type\":\"welcome\"") ? /"first":\{"tick":(\d+)/.exec(message) : null);
-	return found ? Number(found[1]) : void 0;
-};
-/** How often what is held is looked at, to send on what is due: a second's tenth is near enough for a delay of seconds */
-var LOOK_EVERY = 100;
-/**
-* The host's end of a watcher's transport, with what goes to the watcher held for `seconds` (see the top of this
-* file). Closing it closes the watcher's, and what is held goes with it
-*
-* @beta
-*/
-function delayed(transport, seconds) {
-	const held = [];
-	let hostHears = () => {};
-	let hostClosed = () => {};
-	const timer = setInterval(() => {
-		const now = performance.now();
-		let due = 0;
-		while (due < held.length && held[due].at <= now) due++;
-		for (const { text } of held.splice(0, due)) transport.send(text);
-	}, LOOK_EVERY);
-	transport.onMessage((text) => {
-		if (text.startsWith("{\"type\":\"ack\"")) return;
-		hostHears(text);
-	});
-	transport.onClose(() => {
-		clearInterval(timer);
-		held.length = 0;
-		hostClosed();
-	});
-	return {
-		send(text) {
-			held.push({
-				at: performance.now() + seconds * 1e3,
-				text
-			});
-			const tick = tickOf(text);
-			if (tick !== void 0) queueMicrotask(() => hostHears(JSON.stringify({
-				type: "ack",
-				tick
-			})));
-		},
-		onMessage(handler) {
-			hostHears = handler;
-		},
-		onClose(handler) {
-			hostClosed = handler;
-		},
-		close() {
-			clearInterval(timer);
-			held.length = 0;
-			transport.close();
-		}
-	};
-}
-//#endregion
-//#region src/session/seed.ts
-/**
-* A seed of the moment, for a game no other was (the clock: a session's, never the rules'): where every new world made without a seed of its own gets its seed
-* (a map played in a page, on a server, in a worker). The same seed, the same game
-*
-* @beta
-*/
-var randomSeed = () => Date.now() % 1e5;
-//#endregion
-//#region src/noise.ts
-/**
-* Noise that repeats: a lattice of random values that wraps around, read smoothly between them, so that whatever is
-* made of it tiles. Seeded (`Rng`), so the same seed makes the same noise everywhere. What the map generator shapes
-* its ground with; the client makes the ground's textures with the same (`packages/client`, its own copy, so that a
-* worker of the page's loads nothing of the engine)
-*/
-/**
-* A value noise that repeats every `period` cells of its lattice: between 0 and 1, smooth
-*
-* @internal
-*/
-function tilingNoise(period, seed) {
-	const size = Math.max(1, Math.round(period));
-	const rng = new Rng(seed);
-	const values = Float32Array.from({ length: size * size }, () => rng.next());
-	return (u, v) => {
-		const x = u * size;
-		const z = v * size;
-		let x0 = Math.floor(x);
-		let z0 = Math.floor(z);
-		const fx = x - x0;
-		const fz = z - z0;
-		x0 = (x0 % size + size) % size;
-		z0 = (z0 % size + size) % size;
-		const x1 = x0 + 1 === size ? 0 : x0 + 1;
-		const z1 = z0 + 1 === size ? 0 : z0 + 1;
-		const sx = fx * fx * (3 - 2 * fx);
-		const sz = fz * fz * (3 - 2 * fz);
-		const r0 = z0 * size;
-		const r1 = z1 * size;
-		const top = values[r0 + x0] + (values[r0 + x1] - values[r0 + x0]) * sx;
-		return top + (values[r1 + x0] + (values[r1 + x1] - values[r1 + x0]) * sx - top) * sz;
-	};
-}
-/**
-* Several noises, each finer and fainter than the one before: what looks like ground and not like a pattern. 0..1
-*
-* @beta
-*/
-function layeredNoise(seed, periods) {
-	const noises = periods.map((period, i) => tilingNoise(period, seed + i * 101));
-	const weights = periods.map((_, i) => 1 / (1 << i));
-	const total = weights.reduce((sum, weight) => sum + weight, 0);
-	if (noises.length === 1) {
-		const [only] = noises;
-		return (u, v) => only(u, v);
-	}
-	return (u, v) => {
-		let sum = 0;
-		for (let i = 0; i < noises.length; i++) sum += noises[i](u, v) * weights[i];
-		return sum / total;
-	};
-}
-//#endregion
-//#region src/mapCheck/rules/players.ts
-/** How many players the map has, against what the game allows */
-var playerRules = {
-	id: "players",
-	check(map, registry, say, _context) {
-		const players = map.players.filter((player) => player.id !== 90 && player.id !== 0).length;
-		const most = registry.module ? maxPlayersOf(registry.module) : 32;
-		if (players > most) say({
-			message: `The map has ${players} players, and the game allows ${most}`,
-			error: true,
-			rule: "too-many-players"
-		});
-	}
-};
-//#endregion
-//#region src/mapCheck/rules/objects.ts
-/** What is placed and the camps: of types the game has, on the map, out of deep water */
-var objectRules = {
-	id: "objects",
-	check(map, registry, say, { terrain, onMap }) {
-		for (const object of map.objects) {
-			if (!registry.units.has(object.type)) {
-				say({
-					message: `"${object.type}" is no unit type of the game: it is left out`,
-					at: object,
-					rule: "unknown-type",
-					about: { object: object.id }
-				});
-				continue;
-			}
-			if (!onMap(object)) {
-				say({
-					message: `${registry.unit(object.type).name} stands off the map`,
-					error: true,
-					at: object,
-					rule: "off-map",
-					about: { object: object.id }
-				});
-				continue;
-			}
-			const def = registry.unit(object.type);
-			if (!def.flying && terrain.waterAt(object.x, object.z) === 2) say({
-				message: `${def.name} stands in deep water`,
-				at: object,
-				rule: "deep-water",
-				about: { object: object.id }
-			});
-		}
-		for (const camp of map.camps) {
-			const strangers = camp.units.filter((type) => !type.startsWith("@") && !registry.units.has(type));
-			if (strangers.length) say({
-				message: `A camp has creeps the game does not have: ${strangers.join(", ")}`,
-				at: camp,
-				rule: "unknown-creeps",
-				about: { camp: camp.id }
-			});
-			if (!onMap(camp)) say({
-				message: "A camp stands off the map",
-				error: true,
-				at: camp,
-				rule: "off-map",
-				about: { camp: camp.id }
-			});
-		}
-	}
-};
-//#endregion
-//#region src/mapCheck/rules/random.ts
-/** Random groups and item tables: something to draw from, and by names there are */
-var randomRules = {
-	id: "random",
-	check(map, registry, say, _context) {
-		const groups = new Map((map.randomGroups ?? []).map((group) => [group.name, group]));
-		const tables = new Set((map.itemTables ?? []).map((table) => table.name));
-		for (const group of groups.values()) if (!groupChoices(group, registry).length) say({
-			message: `The random group ${group.name} has nothing of the game to draw from`,
-			error: true,
-			rule: "empty-random-group"
-		});
-		for (const table of map.itemTables ?? []) if (!tableItems(table, registry).length) say({
-			message: `The item table ${table.name} has nothing of the game to draw from`,
-			error: true,
-			rule: "empty-item-table"
-		});
-		for (const object of map.objects) {
-			if (object.random && !groups.has(object.random)) say({
-				message: `It is drawn from "${object.random}", which is no random group of the map`,
-				error: true,
-				at: object,
-				rule: "unknown-random-group",
-				about: { object: object.id }
-			});
-			if (object.drops && !tables.has(object.drops)) say({
-				message: `It drops from "${object.drops}", which is no item table of the map`,
-				error: true,
-				at: object,
-				rule: "unknown-item-table",
-				about: { object: object.id }
-			});
-		}
-		for (const camp of map.camps) for (const unit of camp.units) if (unit.startsWith("@") && !groups.has(unit.slice(1))) say({
-			message: `A camp has "${unit}", which is no random group of the map`,
-			error: true,
-			at: camp,
-			rule: "unknown-random-group",
-			about: { camp: camp.id }
-		});
-	}
-};
-//#endregion
-//#region src/mapCheck/rules/names.ts
-/** One thing a name, and the cameras players start looking from */
-var nameRules = {
-	id: "names",
-	check(map, _registry, say, _context) {
-		const named = /* @__PURE__ */ new Map();
-		const name = (value, at, about) => {
-			if (value) named.set(value, [...named.get(value) ?? [], {
-				at,
-				about
-			}]);
-		};
-		for (const object of map.objects) name(object.name, object, { object: object.id });
-		for (const camp of map.camps) name(camp.name, camp, { camp: camp.id });
-		for (const region of map.regions) name(region.name, region.shape, { region: region.id });
-		for (const point of map.points) name(point.name, point, { point: point.id });
-		for (const path of map.paths) name(path.name, path.points[0] ?? {
-			x: 0,
-			z: 0
-		}, { path: path.id });
-		for (const [value, places] of named) if (places.length > 1) say({
-			message: `"${value}" is the name of ${places.length} things: the rules find only one`,
-			error: true,
-			at: places[1].at,
-			rule: "name-twice",
-			about: places[1].about
-		});
-		for (const player of map.players) if (player.camera && !map.cameras.some((camera) => camera.name === player.camera)) say({
-			message: `${player.name} starts looking from "${player.camera}", which is no camera of the map`,
-			at: player.start,
-			rule: "unknown-camera",
-			about: { player: player.id }
-		});
-	}
-};
-//#endregion
-//#region src/mapCheck/rules/regions.ts
-/** Regions on the map */
-var regionRules = {
-	id: "regions",
-	check(map, _registry, say, _context) {
-		const { width, depth } = map;
-		for (const region of map.regions) {
-			const { shape } = region;
-			const reach = shapeBounds(shape);
-			if (reach.x1 <= 0 || reach.z1 <= 0 || reach.x0 >= width || reach.z0 >= depth) say({
-				message: `The region ${region.name} is outside the map`,
-				error: true,
-				at: shape,
-				rule: "region-off-map",
-				about: { region: region.id }
-			});
-			else if (reach.x0 < 0 || reach.z0 < 0 || reach.x1 > width || reach.z1 > depth) say({
-				message: `The region ${region.name} goes past the edge of the map`,
-				at: shape,
-				rule: "region-past-edge",
-				about: { region: region.id }
-			});
-		}
-	}
-};
-//#endregion
-//#region src/mapCheck/rules/paths.ts
-/** Paths on the map: on it, and what they paint and carve there to be had */
-var pathRules = {
-	id: "paths",
-	check(map, registry, say, { onMap }) {
-		for (const path of map.paths) {
-			const about = { path: path.id };
-			if (path.points.some((point) => !onMap(point))) say({
-				message: `The path ${path.name} goes off the map`,
-				at: path.points[0],
-				rule: "path-off-map",
-				about
-			});
-			for (const tile of [path.paint, path.profile?.ground]) if (tile !== void 0 && !map.tileset.includes(tile) && !registry.tiles.some((def) => def.id === tile)) say({
-				message: `The path ${path.name} paints with ${tile}, which neither the map's tiles nor the game's are`,
-				at: path.points[0],
-				rule: "path-tile-missing",
-				about
-			});
-			if (path.profile && path.points.length < 2) say({
-				message: `The path ${path.name} carves its bed with one point: it carves nothing until it has two`,
-				at: path.points[0],
-				rule: "path-profile-short",
-				about
-			});
-		}
-	}
-};
-//#endregion
-//#region src/mapCheck/cells.ts
-/** The steepest ground something on foot walks, in radians: as the navigation mesh has it */
-var WALKABLE_SLOPE = 38 * Math.PI / 180;
-/**
-* Which cells of a map something on foot can stand on (1) and which have a building or a mine on them (`built`): for
-* the checks, and for what the editor shows of where one can walk and build. `steep` counts slopes too steep to walk
-*
-* @beta
-*/
-function mapCells(map, registry, terrain = mapTerrain(map), steep = false) {
-	const { width, depth } = map;
-	const open = new Uint8Array(width * depth);
-	const built = new Uint8Array(width * depth);
-	for (let c = 0; c < open.length; c++) {
-		const x = c % width;
-		const z = (c - x) / width;
-		open[c] = (terrain.water[c] !== 2 || terrain.blocked[c] === 3) && terrain.blocked[c] !== 2 && terrain.inPlay(x, z) && (!steep || terrain.slopeAt(x + .5, z + .5) <= WALKABLE_SLOPE) ? 1 : 0;
-	}
-	for (const object of map.objects) {
-		if (!registry.units.has(object.type)) continue;
-		const def = registry.unit(object.type);
-		if (def.kind === "unit") continue;
-		const { w, d } = footprintOf(def);
-		const corner = footprintCell(object.x, object.z, w, d);
-		for (let z = corner.z; z < corner.z + d; z++) for (let x = corner.x; x < corner.x + w; x++) {
-			if (x < 0 || z < 0 || x >= width || z >= depth) continue;
-			open[z * width + x] = 0;
-			built[z * width + x] = 1;
-		}
-	}
-	return {
-		open,
-		built
-	};
-}
-/** Cells something on foot can stand on, and which of them it can get to from which: a number per cell, 0 for none */
-function walkingAreas(map, registry) {
-	const { width, depth, levels, ramps } = map;
-	const { open } = mapCells(map, registry);
-	const passable = (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0;
-	const area = new Int32Array(width * depth);
-	let next = 0;
-	const queue = new Int32Array(width * depth);
-	for (let start = 0; start < area.length; start++) {
-		if (!open[start] || area[start]) continue;
-		next++;
-		let head = 0;
-		let tail = 0;
-		queue[tail++] = start;
-		area[start] = next;
-		while (head < tail) {
-			const c = queue[head++];
-			const x = c % width;
-			const z = (c - x) / width;
-			for (const [nx, nz] of [
-				[x - 1, z],
-				[x + 1, z],
-				[x, z - 1],
-				[x, z + 1]
-			]) {
-				if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
-				const n = nz * width + nx;
-				if (!open[n] || area[n] || !passable(c, n)) continue;
-				area[n] = next;
-				queue[tail++] = n;
-			}
-		}
-	}
-	/** The area a point is in, or the one next to it, for what stands on cells nothing walks on: a mine, a town hall */
-	const at = (point) => {
-		const cx = Math.floor(point.x);
-		const cz = Math.floor(point.z);
-		for (let r = 0; r <= 4; r++) for (let z = cz - r; z <= cz + r; z++) for (let x = cx - r; x <= cx + r; x++) {
-			if (x < 0 || z < 0 || x >= width || z >= depth) continue;
-			if (Math.max(Math.abs(x - cx), Math.abs(z - cz)) !== r) continue;
-			const found = area[z * width + x];
-			if (found) return found;
-		}
-		return 0;
-	};
-	return {
-		area,
-		at
-	};
-}
-//#endregion
-//#region src/mapCheck/rules/walking.ts
-/** Who can walk to whom: starts cut off from each other, mines nobody can walk to */
-var walkingRules = {
-	id: "walking",
-	check(map, registry, say, _context) {
-		const starts = map.players.filter((player) => player.start);
-		if (starts.length) {
-			const { at } = walkingAreas(map, registry);
-			const areas = starts.map((player) => at(player.start));
-			starts.forEach((player, i) => {
-				if (!areas[i]) say({
-					message: `${player.name} starts where nothing can walk`,
-					error: true,
-					at: player.start,
-					rule: "start-blocked",
-					about: { player: player.id }
-				});
-				else if (areas.some((other, j) => j !== i && other && other !== areas[i])) say({
-					message: `${player.name} cannot walk to every other start: a cliff, water or what is built is in the way`,
-					at: player.start,
-					rule: "starts-apart",
-					about: { player: player.id }
-				});
-			});
-			const reached = new Set(areas.filter(Boolean));
-			for (const object of map.objects) {
-				if (!registry.units.has(object.type)) continue;
-				const def = registry.unit(object.type);
-				if (!(registry.module?.editor?.reach ?? reachedByDefault)(def)) continue;
-				if (!reached.has(at(object))) say({
-					message: `Nobody can walk to the ${def.name} here`,
-					at: object,
-					rule: "unreachable",
-					about: { object: object.id }
-				});
-			}
-		}
-	}
-};
-//#endregion
-//#region src/mapCheck/rules/races.ts
-/**
-* What is wrong with the races of a map: a player fixed to a race the game has not got, or the map offering one, are
-* errors (a world is not made from it); what is placed for a player that their race may not have is a warning. What
-* the map offers is for the players it fixes no race for: one fixed to another is as the map means it
-*/
-function raceProblems(map, registry) {
-	const problems = [];
-	const known = (race) => race === "random" || registry.races.has(race);
-	const none = registry.races.size === 0;
-	for (const race of map.races ?? []) {
-		if (race === "random" || registry.races.has(race)) continue;
-		problems.push({
-			message: `The map offers the race "${race}", which ${none ? "the game does not have: it has no races" : "is no race of the game"}`,
-			error: true,
-			rule: "unknown-race"
-		});
-	}
-	for (const player of map.players) {
-		if (player.race === void 0) continue;
-		if (!known(player.race)) problems.push({
-			message: `${player.name} plays the race "${player.race}", which ${none ? "the game does not have: it has no races" : "is no race of the game"}`,
-			error: true,
-			at: player.start,
-			rule: "unknown-race",
-			about: { player: player.id }
-		});
-	}
-	const fixed = new Map(map.players.filter((player) => player.race && player.race !== "random" && registry.races.has(player.race)).map((player) => [player.id, player]));
-	for (const object of map.objects) {
-		const owner = fixed.get(object.owner);
-		if (!owner || !registry.units.has(object.type)) continue;
-		const def = registry.unit(object.type);
-		if (availableTo(def, owner.race)) continue;
-		problems.push({
-			message: `${def.name} is ${registry.race(def.race).name}, and ${owner.name} plays ${registry.race(owner.race).name}`,
-			at: object,
-			rule: "other-race",
-			about: { object: object.id }
-		});
-	}
-	return problems;
-}
-//#endregion
-//#region src/mapCheck.ts
-/**
-* The engine's checks of a map, in the order they run: players, what is placed, random groups, names, regions, paths,
-* walking, races, the fields that name things
-*
-* @beta
-*/
-var MAP_RULES = [
-	playerRules,
-	objectRules,
-	randomRules,
-	nameRules,
-	regionRules,
-	pathRules,
-	walkingRules,
-	{
-		id: "races",
-		check(map, registry, say) {
-			for (const problem of raceProblems(map, registry)) say(problem);
-		}
-	},
-	{
-		id: "targets",
-		check(map, registry, say, _context) {
-			const naming = (fields, data, about, at) => {
-				for (const field of fields) {
-					const kind = field.kind;
-					const id = data?.[field.id];
-					if (!TARGET_FIELDS.includes(field.kind) || typeof id !== "number") continue;
-					if (targetName(map, kind, id) === void 0) say({
-						message: `${field.name} names a ${kind} the map does not have`,
-						error: true,
-						rule: "missing-target",
-						...at && { at },
-						...about && { about }
-					});
-				}
-			};
-			for (const object of map.objects) naming(objectFields(registry, object.type), object.data, { object: object.id }, object);
-			for (const camp of map.camps) naming(campFields(registry), camp.data, { camp: camp.id }, camp);
-			for (const region of map.regions) naming(regionFields(registry), region.data, { region: region.id });
-			for (const player of map.players) naming(playerFields(registry), player.data, { player: player.id }, player.start);
-			naming(mapFields(registry), map.data, void 0);
-		}
-	}
-];
-/**
-* What is wrong with a map, before it is played: what the game does not have, names used twice or named and not
-* there, what stands off the map or in deep water, starts that cannot reach each other on foot, mines nobody can walk
-* to, regions outside the map (`MAP_RULES`); then the checks given (`more`: the client's of what the map looks like,
-* a game view's own, as the editor runs them); then the game's own (`MapEditorDef.check`). Errors keep it from being
-* played; the rest are warnings. Runs without the editor, for a test that goes over every map of a project
-*
-* @beta
-*/
-function checkMap(map, registry, more = []) {
-	const problems = [];
-	const { width, depth } = map;
-	let terrain;
-	const context = {
-		get terrain() {
-			return terrain ??= mapTerrain(map);
-		},
-		onMap: (p) => p.x >= 0 && p.z >= 0 && p.x <= width && p.z <= depth
-	};
-	const say = (problem) => void problems.push(problem);
-	for (const rule of [...MAP_RULES, ...more]) rule.check(map, registry, say, context);
-	const own = (registry.assembly?.check?.(map, registry) ?? []).map((problem) => ({
-		rule: "game",
-		...problem
-	}));
-	const silenced = /* @__PURE__ */ new Set([...registry.module?.editor?.silence ?? [], ...map.silence ?? []]);
-	return [...problems, ...own].filter((problem) => !problem.rule || !silenced.has(problem.rule));
-}
-//#endregion
-//#region src/generate.ts
-/**
-* Maps made by a generator (world plan G1): a map from a seed and a few sliders, made of passes a game adds to,
-* replaces or leaves out, each a function of a context that holds the map, the seed's numbers, noise that repeats
-* across the map, the symmetry and what the passes before put down. Deterministic: the engine's `Rng`, nothing of
-* the clock. The engine's own passes shape the ground (`terrainPass`), paint it (`tilesPass`), seat the players
-* (`startsPass`), scatter things over it (`scatterPass`: trees now, rocks and houses the same way later), put
-* resources near the starts (`resourcesPass`) and lay roads (`roadsPass`); `generateMap` runs them and checks the map
-* (`checkMap`), trying the next seed where a start is cut off or blocked. A game declares its generator
-* (`GameModule.generator`), for the editor and the page to find; `presetGenerator` is the engine's to take whole
-*/
-/**
-* The map a generator makes of options: its passes run in order on a map of the size and players asked, with the
-* game's tiles; then checked (`checkMap`). A map with a problem that keeps it from being played (a start cut off from
-* the others, or where nothing walks) is thrown away and the next seed tried, `tries` times; the last is given with
-* its problems. The map says how it was made (`GameMap.generated`)
-*
-* @beta
-*/
-function generateMap(generator, options, registry) {
-	const tries = Math.max(1, generator.tries ?? 4);
-	let last;
-	for (let attempt = 0; attempt < tries; attempt++) {
-		const seed = options.seed + attempt;
-		const map = createMap({
-			name: options.name ?? `Generated ${seed}`,
-			width: options.width,
-			depth: options.depth,
-			players: options.players,
-			game: registry.module?.id,
-			tileset: registry.tileIds
-		});
-		const ctx = createContext(map, {
-			...options,
-			seed
-		}, registry, generator);
-		for (const pass of generator.passes) pass.run(ctx);
-		map.generated = {
-			seed,
-			options: {
-				...options,
-				seed
-			}
-		};
-		const problems = checkMap(map, registry);
-		last = {
-			map,
-			problems,
-			seed
-		};
-		if (!problems.some(unplayable)) return last;
-	}
-	return last;
-}
-/** What keeps a map from being played, so that the next seed is tried: an error, or a start cut off from the others or blocked */
-var unplayable = (problem) => problem.error || problem.rule === "starts-apart" || problem.rule === "start-blocked";
-var SYMMETRIES = [
-	"none",
-	"x",
-	"z",
-	"both",
-	"half",
-	"quarter"
-];
-/**
-* The places a point is mirrored or turned to, the point first (as the editor's `mirrors`)
-*
-* @beta
-*/
-function symmetricPlaces(symmetry, width, depth, x, z) {
-	const out = [{
-		x,
-		z
-	}];
-	const add = (px, pz) => {
-		if (!out.some((other) => Math.abs(other.x - px) < 1e-6 && Math.abs(other.z - pz) < 1e-6)) out.push({
-			x: px,
-			z: pz
-		});
-	};
-	switch (symmetry) {
-		case "x":
-			add(width - x, z);
-			break;
-		case "z":
-			add(x, depth - z);
-			break;
-		case "both":
-			add(width - x, z);
-			add(x, depth - z);
-			add(width - x, depth - z);
-			break;
-		case "half":
-			add(width - x, depth - z);
-			break;
-		case "quarter": {
-			const cx = width / 2;
-			const cz = depth / 2;
-			for (let k = 1; k < 4; k++) {
-				let px = x - cx;
-				let pz = z - cz;
-				for (let i = 0; i < k; i++) [px, pz] = [-pz, px];
-				add(cx + px, cz + pz);
-			}
-			break;
-		}
-	}
-	return out;
-}
-/** How many places a mirrored set has at most: four, for quarter turns and both ways */
-var MIRRORS = 4;
-/** The first of a point's mirrored set, by row then column: where a noise is read, so the noise is mirrored as the map is */
-function firstPlace(symmetry, width, depth, x, z, out) {
-	out.x = x;
-	out.z = z;
-	const take = (px, pz) => takeFirst(out, px, pz);
-	switch (symmetry) {
-		case "x":
-			take(width - x, z);
-			break;
-		case "z":
-			take(x, depth - z);
-			break;
-		case "both":
-			take(width - x, z);
-			take(x, depth - z);
-			take(width - x, depth - z);
-			break;
-		case "half":
-			take(width - x, depth - z);
-			break;
-		case "quarter": {
-			const cx = width / 2;
-			const cz = depth / 2;
-			let px = x - cx;
-			let pz = z - cz;
-			for (let k = 1; k < 4; k++) {
-				[px, pz] = [-pz, px];
-				take(cx + px, cz + pz);
-			}
-			break;
-		}
-	}
-}
-/** The earlier of a place and another, by row then column, kept in `out` */
-function takeFirst(out, px, pz) {
-	if (pz < out.z - 1e-6 || Math.abs(pz - out.z) < 1e-6 && px < out.x) {
-		out.x = px;
-		out.z = pz;
-	}
-}
-function createContext(map, options, registry, generator) {
-	const { width, depth } = map;
-	const symmetry = options.symmetry ?? "none";
-	if (!SYMMETRIES.includes(symmetry)) throw new Error(`generateMap: there is no symmetry "${symmetry}": ${SYMMETRIES.join(", ")}`);
-	if (symmetry === "quarter" && (width !== depth || width % 2)) throw new Error("generateMap: quarter turns need a square map with even sides");
-	const rng = new Rng(options.seed);
-	const defaults = Object.fromEntries(generator.params.map((param) => [param.id, param.default]));
-	const given = options.params ?? {};
-	const noises = /* @__PURE__ */ new Map();
-	const placed = [];
-	let nextId = 1;
-	const mirrors = new Int32Array(width * depth * MIRRORS).fill(-1);
-	const canon = new Int32Array(width * depth);
-	for (let c = 0; c < canon.length; c++) {
-		const cx = c % width;
-		const cz = (c - cx) / width;
-		let first = c;
-		let n = 0;
-		for (const place of symmetricPlaces(symmetry, width, depth, cx + .5, cz + .5)) {
-			const mx = Math.floor(place.x);
-			const mz = Math.floor(place.z);
-			if (mx < 0 || mz < 0 || mx >= width || mz >= depth) continue;
-			const m = mz * width + mx;
-			mirrors[c * MIRRORS + n++] = m;
-			first = Math.min(first, m);
-		}
-		canon[c] = first;
-	}
-	const GRID = 8;
-	const cols = Math.ceil(width / GRID);
-	const rows = Math.ceil(depth / GRID);
-	const grid = Array.from({ length: cols * rows }, () => []);
-	let widest = 0;
-	const point = {
-		x: 0,
-		z: 0
-	};
-	const drawn = /* @__PURE__ */ new Map();
-	return {
-		map,
-		rng,
-		options,
-		registry,
-		param: (id, fallback) => given[id] ?? defaults[id] ?? fallback,
-		symmetric: (x, z) => symmetricPlaces(symmetry, width, depth, x, z),
-		canonical: (cx, cz) => canon[cz * width + cx] === cz * width + cx,
-		once: (x, z, draw) => {
-			const cx = Math.min(Math.max(Math.floor(x), 0), width - 1);
-			const cz = Math.min(Math.max(Math.floor(z), 0), depth - 1);
-			const key = canon[cz * width + cx];
-			if (drawn.has(key)) return drawn.get(key);
-			const value = draw();
-			drawn.set(key, value);
-			return value;
-		},
-		mirrorsOf: (c) => {
-			const out = [];
-			for (let i = 0; i < MIRRORS; i++) {
-				const m = mirrors[c * MIRRORS + i];
-				if (m >= 0) out.push(m);
-			}
-			return out;
-		},
-		setCell: (array, c, value) => {
-			for (let i = 0; i < MIRRORS; i++) {
-				const m = mirrors[c * MIRRORS + i];
-				if (m >= 0) array[m] = value;
-			}
-		},
-		noise(name, cells = [
-			32,
-			16,
-			8
-		]) {
-			let known = noises.get(name);
-			if (!known) {
-				let salt = 0;
-				for (const letter of name) salt = salt * 31 + letter.charCodeAt(0) >>> 0;
-				const size = Math.max(width, depth);
-				const noise = layeredNoise(options.seed + salt, cells.map((each) => Math.max(1, Math.round(size / each))));
-				known = symmetry === "none" ? (x, z) => noise(x / size, z / size) : (x, z) => {
-					firstPlace(symmetry, width, depth, x, z, point);
-					return noise(point.x / size, point.z / size);
-				};
-				noises.set(name, known);
-			}
-			return known;
-		},
-		placed,
-		mark: (kind, x, z, radius) => {
-			placed.push({
-				kind,
-				x,
-				z,
-				radius
-			});
-			widest = Math.max(widest, radius);
-			const gx = Math.min(Math.max(Math.floor(x / GRID), 0), cols - 1);
-			const gz = Math.min(Math.max(Math.floor(z / GRID), 0), rows - 1);
-			grid[gz * cols + gx].push(placed.length - 1);
-		},
-		free: (x, z, radius, kinds) => {
-			const reach = Math.ceil((radius + widest) / GRID);
-			const gx = Math.floor(x / GRID);
-			const gz = Math.floor(z / GRID);
-			for (let dz = -reach; dz <= reach; dz++) for (let dx = -reach; dx <= reach; dx++) {
-				const gxx = gx + dx;
-				const gzz = gz + dz;
-				if (gxx < 0 || gzz < 0 || gxx >= cols || gzz >= rows) continue;
-				for (const i of grid[gzz * cols + gxx]) {
-					const each = placed[i];
-					if (kinds && !kinds.includes(each.kind)) continue;
-					if (hypot(each.x - x, each.z - z) < radius + each.radius) return false;
-				}
-			}
-			return true;
-		},
-		levelAt: (x, z) => {
-			const cx = Math.min(Math.max(Math.floor(x), 0), width - 1);
-			const cz = Math.min(Math.max(Math.floor(z), 0), depth - 1);
-			return map.levels[cz * width + cx];
-		},
-		walkable: (x, z) => {
-			if (x < 0 || z < 0 || x >= width || z >= depth) return false;
-			return map.water[Math.floor(z) * width + Math.floor(x)] !== 2;
-		},
-		addDoodad(doodad) {
-			const { scale = 1, yaw = 0, ...rest } = doodad;
-			const made = {
-				id: nextId++,
-				yaw,
-				scale: typeof scale === "number" ? [
-					scale,
-					scale,
-					scale
-				] : scale,
-				...rest
-			};
-			map.doodads.push(made);
-			return made;
-		},
-		addObject(type, owner, x, z, more = {}) {
-			const made = {
-				id: nextId++,
-				type,
-				owner,
-				x,
-				z,
-				facing: 0,
-				scale: 1,
-				...more
-			};
-			map.objects.push(made);
-			return made;
-		},
-		addCamp(x, z, units, more = {}) {
-			const made = {
-				id: nextId++,
-				x,
-				z,
-				units,
-				...more
-			};
-			map.camps.push(made);
-			return made;
-		},
-		addRegion(name, shape, more = {}) {
-			const made = {
-				id: nextId++,
-				name,
-				shape,
-				...more
-			};
-			map.regions.push(made);
-			return made;
-		}
-	};
-}
-/**
-* The lie of a bay, for `terrainPass`'s `shape`: the corners high, the ground falling to a sea in the middle, an
-* island in it. With `water` at 0.25–0.35 the sea takes the middle and the shore runs round it; the starts in the
-* corners (`startsPass` with a spread of 0.4), the way between them along the shore
-*
-* @beta
-*/
-function basinShape(options = {}) {
-	const island = Math.min(Math.max(options.island ?? .14, 0), .5);
-	const roughness = Math.min(Math.max(options.roughness ?? .25, 0), 1);
-	const height = Math.min(Math.max(options.height ?? .4, 0), 1);
-	return (x, z, noise, map) => {
-		const d = hypot((x / map.width - .5) * 2, (z / map.depth - .5) * 2) / Math.SQRT2;
-		const r = island > 0 ? d / island : 1;
-		return d + (r < 1 ? (1 - r * r * r * r) * height : 0) + (noise - .5) * roughness;
-	};
-}
-/** Whether a cell is on the map */
-var on = (map, cx, cz) => cx >= 0 && cz >= 0 && cx < map.width && cz < map.depth;
-/** The four cells next to one */
-var NEIGHBOURS = [
-	[-1, 0],
-	[1, 0],
-	[0, -1],
-	[0, 1]
-];
-/** How steep a cell is, in radians, from the heights at its corners: as `Terrain.slopeAt` has it, read straight off the terrain */
-function cellSlope(terrain, cx, cz) {
-	const { heights, vertsX } = terrain;
-	const v = cz * vertsX + cx;
-	const dx = (heights[v + 1] + heights[v + vertsX + 1] - heights[v] - heights[v + vertsX]) / 2;
-	const dz = (heights[v + vertsX] + heights[v + vertsX + 1] - heights[v] - heights[v + 1]) / 2;
-	return atan(hypot(dx, dz));
-}
-/** The engine's passes reach the mirror table of the context they are given; a context of a game's own has none, and mirrors by `symmetric` */
-function internals(ctx) {
-	const own = ctx;
-	if (own.mirrorsOf && own.setCell) return own;
-	const { width } = ctx.map;
-	const mirrorsOf = (c) => {
-		const cx = c % width;
-		const cz = (c - cx) / width;
-		return ctx.symmetric(cx + .5, cz + .5).flatMap((place) => {
-			const mx = Math.floor(place.x);
-			const mz = Math.floor(place.z);
-			return on(ctx.map, mx, mz) ? [mz * width + mx] : [];
-		});
-	};
-	return {
-		mirrorsOf,
-		setCell: (array, c, value) => mirrorsOf(c).forEach((m) => array[m] = value)
-	};
-}
-/**
-* The ground: a height field of noise, mirrored as the map is, quantised into cliff levels with the ground rolling
-* within each, water in the low ground, and ramps cut between the levels so that every part can be walked to
-*
-* @beta
-*/
-function terrainPass(options = {}) {
-	return {
-		id: "terrain",
-		name: "The ground",
-		run(ctx) {
-			const { map } = ctx;
-			const { width, depth } = map;
-			const levels = Math.min(Math.max(Math.round(options.levels ?? ctx.param("levels", 2)), 1), 4);
-			const waterShare = Math.min(Math.max(options.water ?? ctx.param("water", .15), 0), .6);
-			const roughness = Math.min(Math.max(options.roughness ?? ctx.param("roughness", .4), 0), 1);
-			const hills = Math.max(4, options.hills ?? ctx.param("hills", 24));
-			const plateau = ctx.noise("plateau", [hills * 2, hills]);
-			const roll = ctx.noise("roll", [
-				hills / 2,
-				hills / 4,
-				hills / 8
-			]);
-			const values = new Float32Array(width * depth);
-			for (let c = 0; c < values.length; c++) {
-				const x = c % width + .5;
-				const z = Math.floor(c / width) + .5;
-				values[c] = options.shape ? options.shape(x, z, plateau(x, z), map) : plateau(x, z);
-			}
-			const stride = Math.max(1, Math.floor(values.length / 16384));
-			const sorted = Float32Array.from({ length: Math.floor(values.length / stride) }, (_, i) => values[i * stride]).sort();
-			const quantile = (q) => sorted[Math.min(Math.max(Math.round(q * (sorted.length - 1)), 0), sorted.length - 1)];
-			const waterAt = quantile(waterShare);
-			const steps = Array.from({ length: levels - 1 }, (_, i) => quantile(waterShare + (1 - waterShare) * (i + 1) / levels));
-			for (let c = 0; c < values.length; c++) {
-				let level = 0;
-				for (const step of steps) if (values[c] >= step) level++;
-				map.levels[c] = level;
-				map.water[c] = values[c] < waterAt ? 2 : 0;
-			}
-			const { setCell } = internals(ctx);
-			const counts = /* @__PURE__ */ new Int32Array(5);
-			for (let round = 0; round < 2; round++) {
-				const before = map.levels.slice();
-				for (let c = 0; c < before.length; c++) {
-					const cx = c % width;
-					const cz = (c - cx) / width;
-					if (!ctx.canonical(cx, cz)) continue;
-					counts.fill(0);
-					for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) if (on(map, cx + dx, cz + dz)) counts[before[(cz + dz) * width + cx + dx]]++;
-					let best = before[c];
-					let most = counts[best];
-					for (let level = 0; level < counts.length; level++) if (counts[level] > most) [best, most] = [level, counts[level]];
-					if (best !== before[c]) setCell(map.levels, c, best);
-				}
-			}
-			for (let c = 0; c < values.length; c++) if (map.levels[c] > 0) map.water[c] = 0;
-			const deep = map.water.slice();
-			for (let c = 0; c < deep.length; c++) {
-				if (deep[c] !== 2) continue;
-				const cx = c % width;
-				const cz = (c - cx) / width;
-				let rim = false;
-				for (const [dx, dz] of NEIGHBOURS) if (on(map, cx + dx, cz + dz) && deep[(cz + dz) * width + cx + dx] !== 2) rim = true;
-				if (rim) map.water[c] = 1;
-			}
-			const vx = width + 1;
-			for (let iz = 0; iz <= depth; iz++) for (let ix = 0; ix <= width; ix++) {
-				const v = iz * vx + ix;
-				map.ground[v] = 1 + (roll(ix, iz) - .5) * roughness * 1.5;
-			}
-			if (options.ramps !== false) cutRamps(ctx, Math.max(2, Math.round(options.rampWidth ?? 3)));
-		}
-	};
-}
-/**
-* Ramps between the levels, so that every part of the ground joins the rest: the parts of a level (a flood fill on the
-* level map, water left out) joined by a ramp each across the straightest stretch of cliff between two of them, the
-* nearest the middle of both first, until all are one; mirrored as the map is
-*/
-function cutRamps(ctx, rampWidth) {
-	const { map } = ctx;
-	const { width, depth, levels, water, ramps } = map;
-	const { setCell } = internals(ctx);
-	const part = new Int32Array(width * depth).fill(-1);
-	const parts = [];
-	const queue = new Int32Array(width * depth);
-	for (let start = 0; start < part.length; start++) {
-		if (part[start] >= 0 || water[start] === 2) continue;
-		const id = parts.length;
-		const sum = {
-			cells: 0,
-			x: 0,
-			z: 0
-		};
-		parts.push(sum);
-		let head = 0;
-		let tail = 0;
-		queue[tail++] = start;
-		part[start] = id;
-		while (head < tail) {
-			const c = queue[head++];
-			const cx = c % width;
-			const cz = (c - cx) / width;
-			sum.cells++;
-			sum.x += cx + .5;
-			sum.z += cz + .5;
-			for (const [dx, dz] of NEIGHBOURS) {
-				const nx = cx + dx;
-				const nz = cz + dz;
-				if (!on(map, nx, nz)) continue;
-				const n = nz * width + nx;
-				if (part[n] >= 0 || water[n] === 2 || levels[n] !== levels[c]) continue;
-				part[n] = id;
-				queue[tail++] = n;
-			}
-		}
-	}
-	for (const each of parts) {
-		each.x /= each.cells;
-		each.z /= each.cells;
-	}
-	if (parts.length < 2) return;
-	const half = Math.floor(rampWidth / 2);
-	const candidates = [];
-	const straight = (cx, cz, dx, dz) => {
-		const low = cz * width + cx;
-		const high = (cz + dz) * width + cx + dx;
-		if (Math.abs(levels[low] - levels[high]) !== 1) return void 0;
-		const cells = [];
-		for (let along = -half; along < rampWidth - half; along++) for (let deep = -1; deep <= 2; deep++) {
-			const x = cx + dz * along + dx * deep;
-			const z = cz + dx * along + dz * deep;
-			if (!on(map, x, z)) return void 0;
-			const c = z * width + x;
-			if (water[c] !== 0) return void 0;
-			if (levels[c] !== (deep <= 0 ? levels[low] : levels[high])) return void 0;
-			if (deep >= 0 && deep <= 1) cells.push(c);
-		}
-		return cells;
-	};
-	for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
-		if (!ctx.canonical(cx, cz)) continue;
-		for (const [dx, dz] of [[1, 0], [0, 1]]) {
-			if (!on(map, cx + dx, cz + dz)) continue;
-			const cells = straight(cx, cz, dx, dz);
-			if (!cells) continue;
-			const a = part[cz * width + cx];
-			const b = part[(cz + dz) * width + cx + dx];
-			if (a < 0 || b < 0 || a === b) continue;
-			const mx = (parts[a].x + parts[b].x) / 2;
-			const mz = (parts[a].z + parts[b].z) / 2;
-			candidates.push({
-				a,
-				b,
-				cells,
-				cost: hypot(cx + .5 - mx, cz + .5 - mz)
-			});
-		}
-	}
-	candidates.sort((p, q) => p.cost - q.cost);
-	const root = parts.map((_, i) => i);
-	const find = (i) => root[i] === i ? i : root[i] = find(root[i]);
-	for (const candidate of candidates) {
-		const a = find(candidate.a);
-		const b = find(candidate.b);
-		if (a === b) continue;
-		root[a] = b;
-		for (const c of candidate.cells) setCell(ramps, c, 1);
-	}
-}
-/**
-* The paint: each cell a tile by what the ground is there, through the game's tiles by name
-*
-* @beta
-*/
-function tilesPass(options = {}) {
-	return {
-		id: "tiles",
-		name: "The paint",
-		run(ctx) {
-			const { map, registry } = ctx;
-			const { width, depth } = map;
-			const tiles = registry.tileIds;
-			if (!tiles.length) return;
-			const terrain = mapTerrain(map);
-			const moisture = ctx.noise("moisture", [20, 10]);
-			let top = 0;
-			for (const level of map.levels) top = Math.max(top, level);
-			const by = options.by ?? ((cell, ids) => {
-				const has = (id) => ids.includes(id) ? id : void 0;
-				if (cell.shore) return has("sand");
-				if (cell.slope > .5) return has("rock");
-				if (cell.level === top && top >= 3) return has("snow") ?? has("rock");
-				if (cell.moisture < .35) return has("dirt");
-			});
-			for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
-				const c = cz * width + cx;
-				if (map.water[c] === 2) continue;
-				let shore = map.water[c] === 1;
-				if (!shore) {
-					for (const [dx, dz] of NEIGHBOURS) if (on(map, cx + dx, cz + dz) && map.water[(cz + dz) * width + cx + dx] !== 0) shore = true;
-				}
-				const id = by({
-					x: cx,
-					z: cz,
-					level: map.levels[c],
-					slope: cellSlope(terrain, cx, cz),
-					moisture: moisture(cx + .5, cz + .5),
-					shore
-				}, tiles);
-				map.tiles[c] = id ? registry.tile(id) : 0;
-			}
-		}
-	};
-}
-/**
-* The starts: as far apart as the symmetry allows (mirrored from one, or around the middle), each on flat, dry ground
-* (a clearing made for it), the player's `start` set, and what the game puts there
-*
-* @beta
-*/
-function startsPass(options = {}) {
-	return {
-		id: "starts",
-		name: "The starts",
-		run(ctx) {
-			const { map, rng } = ctx;
-			const { width, depth } = map;
-			const players = map.players.filter((player) => player.id !== 0 && player.id !== 90);
-			if (!players.length) return;
-			const clearing = Math.max(2, options.clearing ?? 6);
-			const spread = Math.min(Math.max(options.spread ?? .36, .1), .48);
-			const symmetry = ctx.options.symmetry ?? "none";
-			const setSize = ctx.symmetric(width * .3, depth * .2).length;
-			const seeds = Math.ceil(players.length / setSize);
-			const places = [];
-			const angle0 = symmetry === "none" ? rng.next() * Math.PI * 2 : symmetry === "x" ? Math.PI : symmetry === "z" ? Math.PI / 2 : Math.PI * 1.25;
-			for (let i = 0; i < seeds + players.length && places.length < players.length; i++) {
-				const angle = angle0 + i * Math.PI * 2 / Math.max(seeds * setSize, 1);
-				const x = width / 2 + cos(angle) * width * spread;
-				const z = depth / 2 + sin(angle) * depth * spread;
-				for (const place of ctx.symmetric(x, z)) if (places.length < players.length) places.push(place);
-			}
-			players.forEach((player, i) => {
-				const at = dryGround(ctx, places[i], clearing);
-				clear(ctx, at, clearing);
-				player.start = {
-					x: at.x,
-					z: at.z
-				};
-				ctx.mark("start", at.x, at.z, clearing);
-				options.from?.(player, at, ctx);
-			});
-		}
-	};
-}
-/**
-* The nearest place to one that is not in the water, at a cell's middle: for a pass of a game's own that puts something
-* down where the ground may be wet
-*
-* @beta
-*/
-var nearestDryGround = (ctx, at, reach) => dryGround(ctx, at, reach);
-/**
-* The ground around a place made flat and dry: one level (the one there, or `level`), no water, no ramps, the ground at
-* one height eased into what is around; mirrored as the map is, unless `alone`. What a start's clearing and a mine's
-* are made with, for a pass of a game's own
-*
-* @beta
-*/
-var clearGround = (ctx, at, radius, alone = false, level) => clear(ctx, at, radius, alone, level ?? ctx.levelAt(at.x, at.z));
-/** The nearest place to one that is not in the water, at a cell's middle */
-function dryGround(ctx, at, reach) {
-	const { map } = ctx;
-	const { width, depth } = map;
-	const cx = Math.min(Math.max(Math.floor(at.x), 1), width - 2);
-	const cz = Math.min(Math.max(Math.floor(at.z), 1), depth - 2);
-	for (let r = 0; r <= reach * 3; r++) for (let dz = -r; dz <= r; dz++) for (let dx = -r; dx <= r; dx++) {
-		if (Math.max(Math.abs(dx), Math.abs(dz)) !== r) continue;
-		const x = cx + dx;
-		const z = cz + dz;
-		if (x < 1 || z < 1 || x >= width - 1 || z >= depth - 1) continue;
-		if (map.water[z * width + x] === 0) return {
-			x: x + .5,
-			z: z + .5
-		};
-	}
-	return {
-		x: cx + .5,
-		z: cz + .5
-	};
-}
-/** The ground around a place made flat and dry: one level, no water, no ramps, the ground at one height. Mirrored, unless `alone` */
-function clear(ctx, at, radius, alone = false, level = ctx.levelAt(at.x, at.z)) {
-	const { map } = ctx;
-	const { width, depth } = map;
-	const vx = width + 1;
-	let height = 0;
-	let count = 0;
-	for (let iz = Math.max(Math.floor(at.z - radius), 0); iz <= Math.min(Math.ceil(at.z + radius), depth); iz++) for (let ix = Math.max(Math.floor(at.x - radius), 0); ix <= Math.min(Math.ceil(at.x + radius), width); ix++) {
-		height += map.ground[iz * vx + ix];
-		count++;
-	}
-	height /= Math.max(count, 1);
-	for (const place of alone ? [at] : ctx.symmetric(at.x, at.z)) {
-		for (let cz = Math.max(Math.floor(place.z - radius), 0); cz < Math.min(Math.ceil(place.z + radius), depth); cz++) for (let cx = Math.max(Math.floor(place.x - radius), 0); cx < Math.min(Math.ceil(place.x + radius), width); cx++) {
-			if (hypot(cx + .5 - place.x, cz + .5 - place.z) > radius) continue;
-			const c = cz * width + cx;
-			map.levels[c] = level;
-			map.water[c] = 0;
-			map.ramps[c] = 0;
-		}
-		for (let iz = Math.max(Math.floor(place.z - radius), 0); iz <= Math.min(Math.ceil(place.z + radius), depth); iz++) for (let ix = Math.max(Math.floor(place.x - radius), 0); ix <= Math.min(Math.ceil(place.x + radius), width); ix++) {
-			const d = hypot(ix - place.x, iz - place.z);
-			if (d > radius) continue;
-			const t = Math.min(Math.max((d - radius * .6) / (radius * .4), 0), 1);
-			const v = iz * vx + ix;
-			map.ground[v] = height + (map.ground[v] - height) * t * t * (3 - 2 * t);
-		}
-	}
-}
-/**
-* Things scattered over the map: as many as the density says, in patches of a noise, at least `spacing` apart, off
-* the starts and what else they avoid, where they may go; each put down by `what`, mirrored as the map is. Trees now;
-* rocks, houses, ruins and the rest the same way, with another `what`
-*
-* @beta
-*/
-function scatterPass(options) {
-	return {
-		id: `scatter:${options.kind}`,
-		name: `Scattered: ${options.kind}`,
-		run(ctx) {
-			const { map, rng } = ctx;
-			const { width, depth } = map;
-			const density = Math.min(Math.max(options.density ?? ctx.param(options.kind, .12), 0), 1);
-			if (density <= 0) return;
-			const spacing = Math.max(.5, options.spacing ?? 1.5);
-			const radius = options.radius ?? spacing / 2;
-			const avoid = options.avoid ?? 10;
-			const patches = Math.min(Math.max(options.patches ?? .6, 0), 1);
-			const noise = ctx.noise(`scatter:${options.kind}`, [
-				24,
-				12,
-				6
-			]);
-			let made;
-			const terrain = () => made ??= mapTerrain(map);
-			const cell = spacing;
-			const cols = Math.ceil(width / cell);
-			const rows = Math.ceil(depth / cell);
-			const grid = Array.from({ length: cols * rows }, () => []);
-			const tooClose = (x, z) => {
-				const gx = Math.floor(x / cell);
-				const gz = Math.floor(z / cell);
-				for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
-					const gxx = gx + dx;
-					const gzz = gz + dz;
-					if (gxx < 0 || gzz < 0 || gxx >= cols || gzz >= rows) continue;
-					for (const other of grid[gzz * cols + gxx]) if (hypot(other.x - x, other.z - z) < spacing) return true;
-				}
-				return false;
-			};
-			const put = (x, z) => {
-				grid[Math.floor(z / cell) * cols + Math.floor(x / cell)].push({
-					x,
-					z
-				});
-				ctx.mark(options.kind, x, z, radius);
-				options.what(ctx, {
-					x,
-					z
-				});
-			};
-			for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
-				if (!ctx.canonical(cx, cz)) continue;
-				const c = cz * width + cx;
-				const x = cx + rng.next();
-				const z = cz + rng.next();
-				const n = noise(x, z);
-				const chance = density * (1 - patches + patches * Math.min(Math.max((n - .35) / .3, 0), 1) * 2);
-				if (rng.next() >= chance) continue;
-				if (map.water[c] !== 0) continue;
-				if (options.where) {
-					const shore = NEIGHBOURS.some(([dx, dz]) => on(map, cx + dx, cz + dz) && map.water[(cz + dz) * width + cx + dx] !== 0);
-					if (!options.where({
-						x,
-						z,
-						level: map.levels[c],
-						slope: cellSlope(terrain(), cx, cz),
-						noise: n,
-						shore
-					})) continue;
-				}
-				if (map.ramps[c]) continue;
-				if (!ctx.free(x, z, avoid, ["start"])) continue;
-				if (options.avoidKinds && Object.entries(options.avoidKinds).some(([kind, far]) => !ctx.free(x, z, far, [kind]))) continue;
-				const places = ctx.symmetric(x, z).filter((place) => place.x >= 0 && place.z >= 0 && place.x < width && place.z < depth);
-				if (places.some((place) => tooClose(place.x, place.z))) continue;
-				for (const place of places) put(place.x, place.z);
-			}
-		}
-	};
-}
-/**
-* Resources: one near each start (towards the map's middle, as far as `main` says), and more spread over the map,
-* mirrored as the map is, each put down by the game
-*
-* @beta
-*/
-function resourcesPass(options) {
-	return {
-		id: "resources",
-		name: "The resources",
-		run(ctx) {
-			const { map, rng } = ctx;
-			const { width, depth } = map;
-			const main = options.main ?? 8;
-			const spacing = options.spacing ?? 20;
-			const clearing = options.clearing ?? 3;
-			for (const player of map.players) {
-				if (!player.start || main === false) continue;
-				const toward = atan2(depth / 2 - player.start.z, width / 2 - player.start.x) + (rng.next() - .5) * .8;
-				const at = dryGround(ctx, {
-					x: player.start.x + cos(toward) * main,
-					z: player.start.z + sin(toward) * main
-				}, 4);
-				if (clearing > 0) clear(ctx, at, clearing, true, ctx.levelAt(player.start.x, player.start.z));
-				ctx.mark("resource", at.x, at.z, 3);
-				options.from(ctx, at, player);
-			}
-			const extra = Math.max(0, Math.round(options.extra ?? 2));
-			let placed = 0;
-			for (let attempt = 0; attempt < extra * 40 && placed < extra; attempt++) {
-				const x = 4 + rng.next() * (width - 8);
-				const z = 4 + rng.next() * (depth - 8);
-				if (!ctx.canonical(Math.floor(x), Math.floor(z))) continue;
-				const places = ctx.symmetric(x, z);
-				if (!places.every((place) => ctx.walkable(place.x, place.z) && ctx.free(place.x, place.z, spacing, ["start", "resource"]))) continue;
-				for (const place of places) {
-					const at = dryGround(ctx, place, 4);
-					if (clearing > 0) clear(ctx, at, clearing, true);
-					ctx.mark("resource", at.x, at.z, 3);
-					options.from(ctx, at);
-				}
-				placed++;
-			}
-		}
-	};
-}
-/**
-* Roads between the starts (or places given), the way something on foot would go (over the level map, by ramps, around
-* water; the gentlest ground preferred), painted with a tile
-*
-* @beta
-*/
-function roadsPass(options) {
-	return {
-		id: "roads",
-		name: "The roads",
-		run(ctx) {
-			const { map, registry } = ctx;
-			if (!registry.tileIds.includes(options.tile)) return;
-			const tile = registry.tile(options.tile);
-			const wide = Math.max(1, Math.round(options.width ?? 2));
-			const places = options.between ?? map.players.flatMap((player) => player.start ? [player.start] : []);
-			const terrain = mapTerrain(map);
-			for (let i = 0; i < places.length; i++) for (let j = i + 1; j < places.length; j++) {
-				const path = findPath(map, terrain, places[i], places[j]);
-				for (const c of path) {
-					const cx = c % map.width;
-					const cz = (c - cx) / map.width;
-					for (let dz = 0; dz < wide; dz++) for (let dx = 0; dx < wide; dx++) {
-						const x = cx + dx - Math.floor(wide / 2);
-						const z = cz + dz - Math.floor(wide / 2);
-						if (on(map, x, z) && map.water[z * map.width + x] === 0) map.tiles[z * map.width + x] = tile;
-					}
-				}
-			}
-		}
-	};
-}
-/** The cells of the way from one place to another over the level map: A* with the gentlest ground preferred; nothing where there is none */
-function findPath(map, terrain, from, to) {
-	const { width, depth, levels, ramps, water } = map;
-	const start = Math.floor(from.z) * width + Math.floor(from.x);
-	const goal = Math.floor(to.z) * width + Math.floor(to.x);
-	const passable = (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0;
-	const cost = new Float32Array(width * depth).fill(Infinity);
-	const came = new Int32Array(width * depth).fill(-1);
-	const closed = new Uint8Array(width * depth);
-	const heapCells = [];
-	const heapCosts = [];
-	const push = (estimate, c) => {
-		heapCells.push(c);
-		heapCosts.push(estimate);
-		let i = heapCells.length - 1;
-		while (i > 0) {
-			const parent = i - 1 >> 1;
-			if (heapCosts[parent] <= heapCosts[i]) break;
-			[heapCosts[parent], heapCosts[i]] = [heapCosts[i], heapCosts[parent]];
-			[heapCells[parent], heapCells[i]] = [heapCells[i], heapCells[parent]];
-			i = parent;
-		}
-	};
-	const pop = () => {
-		const top = heapCells[0];
-		const lastCell = heapCells.pop();
-		const lastCost = heapCosts.pop();
-		if (heapCells.length) {
-			heapCells[0] = lastCell;
-			heapCosts[0] = lastCost;
-			let i = 0;
-			for (;;) {
-				const l = i * 2 + 1;
-				const r = l + 1;
-				let best = i;
-				if (l < heapCells.length && heapCosts[l] < heapCosts[best]) best = l;
-				if (r < heapCells.length && heapCosts[r] < heapCosts[best]) best = r;
-				if (best === i) break;
-				[heapCosts[best], heapCosts[i]] = [heapCosts[i], heapCosts[best]];
-				[heapCells[best], heapCells[i]] = [heapCells[i], heapCells[best]];
-				i = best;
-			}
-		}
-		return top;
-	};
-	const h = (c) => hypot(c % width - goal % width, Math.floor(c / width) - Math.floor(goal / width));
-	cost[start] = 0;
-	push(h(start), start);
-	while (heapCells.length) {
-		const c = pop();
-		if (closed[c]) continue;
-		closed[c] = 1;
-		if (c === goal) break;
-		const cx = c % width;
-		const cz = (c - cx) / width;
-		for (const [dx, dz] of NEIGHBOURS) {
-			const nx = cx + dx;
-			const nz = cz + dz;
-			if (!on(map, nx, nz)) continue;
-			const n = nz * width + nx;
-			if (closed[n] || water[n] === 2 || !passable(c, n)) continue;
-			const step = 1 + terrain.slopeAt(nx + .5, nz + .5) * 4 + (water[n] ? 2 : 0);
-			const next = cost[c] + step;
-			if (next >= cost[n]) continue;
-			cost[n] = next;
-			came[n] = c;
-			push(next + h(n), n);
-		}
-	}
-	if (came[goal] < 0 && goal !== start) return [];
-	const path = [];
-	for (let c = goal; c >= 0; c = came[c]) {
-		path.push(c);
-		if (c === start) break;
-	}
-	return path.reverse();
-}
-/**
-* A generator to take whole: hills and water, the paint, the starts, trees in patches and rocks about, with the
-* parameters `levels`, `water`, `roughness`, `hills`, `trees` and `rocks`; what the trees and rocks are is the game's
-* to say
-*
-* @beta
-*/
-function presetGenerator(options = {}) {
-	const { trees = [], rocks = [], treeScale = {} } = options;
-	const scale = treeScale.scale ?? 1;
-	const vary = treeScale.vary ?? .2;
-	return {
-		params: [
-			{
-				id: "levels",
-				name: "Cliff levels",
-				description: "How many levels the ground rises through",
-				default: 2,
-				min: 1,
-				max: 4,
-				step: 1
-			},
-			{
-				id: "water",
-				name: "Water",
-				description: "How much of the map is under water",
-				default: .15,
-				min: 0,
-				max: .5,
-				step: .05
-			},
-			{
-				id: "roughness",
-				name: "Roughness",
-				description: "How much the ground rolls",
-				default: .4,
-				min: 0,
-				max: 1,
-				step: .05
-			},
-			{
-				id: "hills",
-				name: "Hills",
-				description: "How many cells a hill is across",
-				default: 24,
-				min: 8,
-				max: 64,
-				step: 4
-			},
-			{
-				id: "trees",
-				name: "Trees",
-				description: "How much of the map is woods",
-				default: trees.length ? .12 : 0,
-				min: 0,
-				max: .5,
-				step: .02
-			},
-			{
-				id: "rocks",
-				name: "Rocks",
-				description: "How many rocks lie about",
-				default: rocks.length ? .02 : 0,
-				min: 0,
-				max: .2,
-				step: .01
-			}
-		],
-		passes: [
-			terrainPass(),
-			tilesPass(),
-			startsPass({ from: options.start }),
-			...trees.length ? [scatterPass({
-				kind: "trees",
-				spacing: 1.6,
-				what: (ctx, at) => {
-					const size = scale * (1 + (ctx.rng.next() - .5) * 2 * vary);
-					ctx.addDoodad({
-						model: trees[ctx.rng.int(0, trees.length - 1)],
-						x: at.x,
-						z: at.z,
-						yaw: ctx.rng.next() * Math.PI * 2,
-						scale: size,
-						blocks: "walk",
-						radius: .5
-					});
-				}
-			})] : [],
-			...rocks.length ? [scatterPass({
-				kind: "rocks",
-				spacing: 3,
-				patches: .3,
-				avoidKinds: { trees: 1 },
-				what: (ctx, at) => {
-					const size = scale * (.8 + ctx.rng.next() * .6);
-					ctx.addDoodad({
-						model: rocks[ctx.rng.int(0, rocks.length - 1)],
-						x: at.x,
-						z: at.z,
-						yaw: ctx.rng.next() * Math.PI * 2,
-						scale: size,
-						blocks: "walk",
-						radius: .6
-					});
-				}
-			})] : []
-		]
-	};
-}
-//#endregion
-//#region src/packs.ts
-/**
-* Why a pack's file is not one, where it is first wrong
-*
-* @beta
-*/
-var PackError = class extends Error {};
-var ID = /^[a-z0-9][a-z0-9._-]*$/i;
-var VERSION = /^\d+(\.\d+){0,2}$/;
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/**
-* Checks a pack's file as it is read (the schema's rules a loader needs: the pack's schema has all of them):
-* its id and version, and that each list is of definitions with an id, once each. Throws `PackError` saying where
-*
-* @beta
-*/
-function checkPack(json, where = "the pack") {
-	const wrong = (why) => {
-		throw new PackError(`${where}: ${why}`);
-	};
-	if (!isRecord(json)) return wrong("is no object");
-	if (typeof json.id !== "string" || !ID.test(json.id)) wrong("its id is letters, digits, dots and dashes");
-	if (typeof json.version !== "string" || !VERSION.test(json.version)) wrong("its version is major.minor.patch");
-	if (json.requires !== void 0 && (!Array.isArray(json.requires) || json.requires.some((each) => typeof each !== "string"))) wrong("requires is a list of words");
-	for (const kind of DATA_KINDS) {
-		const list = json[kind];
-		if (list === void 0) continue;
-		if (!Array.isArray(list)) wrong(`${kind} is no list`);
-		const seen = /* @__PURE__ */ new Set();
-		for (const [at, def] of list.entries()) {
-			if (!isRecord(def) || typeof def.id !== "string" || !def.id) wrong(`${kind}[${at}] has no id`);
-			const id = def.id;
-			if (seen.has(id)) wrong(`${kind} has "${id}" twice`);
-			seen.add(id);
-		}
-	}
-	for (const part of [
-		"rules",
-		"data",
-		"looks"
-	]) if (json[part] !== void 0 && !isRecord(json[part])) wrong(`${part} is no object`);
-	const known = /* @__PURE__ */ new Set([
-		"$schema",
-		"id",
-		"version",
-		"name",
-		"requires",
-		...DATA_KINDS,
-		"rules",
-		"data",
-		"looks"
-	]);
-	const unknown = Object.keys(json).find((key) => !known.has(key));
-	if (unknown) wrong(`"${unknown}" is nothing a pack has`);
-	return json;
-}
-/** A word with its article: an object, a number */
-var an = (word) => `${/^[aeiou]/.test(word) ? "an" : "a"} ${word}`;
-/** The type of a value as a schema says it */
-var typeOf = (value) => value === null ? "null" : Array.isArray(value) ? "array" : Number.isInteger(value) ? "integer" : typeof value;
-/**
-* Checks a pack's file against the pack's schema (`@v12-engine/engine/schemas/pack.schema.json`, made of `PackFile`):
-* where it is first wrong, in words with its place (`units[2].stats.health: is a string, not a number`), or nothing
-* for one that is right. A small reader of the schema, as far as it uses JSON Schema: what a page that loads packs
-* fetches with them, so that a game without packs carries none of it
-*
-* @beta
-*/
-function checkPackSchema(json, schema) {
-	const root = schema;
-	const resolve = (part) => {
-		let at = part;
-		for (let hops = 0; at.$ref && hops < 32; hops++) at = root.definitions?.[decodeURIComponent(at.$ref.replace("#/definitions/", ""))] ?? {};
-		return at;
-	};
-	const check = (value, given, where) => {
-		const part = resolve(given);
-		const type = typeOf(value);
-		if (part.type !== void 0) {
-			const types = Array.isArray(part.type) ? part.type : [part.type];
-			if (!types.some((each) => each === type || each === "number" && type === "integer")) return `${where || "the pack"}: is ${an(type)}, not ${types.join(" or ")}`;
-		}
-		if ("const" in part && value !== part.const) return `${where || "the pack"}: is not ${JSON.stringify(part.const)}`;
-		if (part.enum && !part.enum.includes(value)) return `${where || "the pack"}: is none of ${part.enum.map((each) => JSON.stringify(each)).join(", ")}`;
-		if (part.not && check(value, part.not, where) === void 0) return `${where || "the pack"}: is what it may not be`;
-		if (part.anyOf) {
-			const wrongs = part.anyOf.map((each) => check(value, each, where));
-			if (wrongs.every((wrong) => wrong !== void 0)) return wrongs.reduce((deepest, wrong) => wrong.length > deepest.length ? wrong : deepest);
-		}
-		if (type === "object" && (part.properties || part.required || part.additionalProperties !== void 0 || part.propertyNames)) {
-			const object = value;
-			for (const field of part.required ?? []) if (!(field in object)) return `${where || "the pack"}: has no ${field}`;
-			for (const [field, each] of Object.entries(object)) {
-				const at = where ? `${where}.${field}` : field;
-				if (part.propertyNames) {
-					const name = check(field, part.propertyNames, at);
-					if (name) return name;
-				}
-				const own = part.properties?.[field];
-				if (own) {
-					const wrong = check(each, own, at);
-					if (wrong) return wrong;
-				} else if (part.additionalProperties === false) return `${at}: is nothing ${where || "a pack"} has`;
-				else if (typeof part.additionalProperties === "object") {
-					const wrong = check(each, part.additionalProperties, at);
-					if (wrong) return wrong;
-				}
-			}
-		}
-		if (type === "array") {
-			const list = value;
-			if (part.minItems !== void 0 && list.length < part.minItems) return `${where || "the pack"}: has fewer than ${part.minItems}`;
-			if (part.maxItems !== void 0 && list.length > part.maxItems) return `${where || "the pack"}: has more than ${part.maxItems}`;
-			if (part.items) for (const [at, each] of list.entries()) {
-				const item = Array.isArray(part.items) ? part.items[at] : part.items;
-				const wrong = item && check(each, item, `${where}[${at}]`);
-				if (wrong) return wrong;
-			}
-		}
-	};
-	return check(json, root, "");
-}
-/** FNV-1a, twice over with different starts, of a text: as the game's hash is */
-function hashOf(text) {
-	let a = 2166136261;
-	let b = 1523705862;
-	for (let i = 0; i < text.length; i++) {
-		const c = text.charCodeAt(i);
-		a = Math.imul(a ^ c, 16777619);
-		b = Math.imul(b ^ c, 1540483477);
-	}
-	return (a >>> 0).toString(16).padStart(8, "0") + (b >>> 0).toString(16).padStart(8, "0");
-}
-var byId = (defs) => [...defs].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-/** The builder's collection of a kind of the game's data */
-var collectionOf = (game, kind) => game[kind];
-/**
-* Makes a mod of a pack's file (its text, or what was parsed of it): checked, then applying its definitions (each
-* list in the order of its ids, a definition the game has put in its place), its `data` over the whole and its
-* `rules`. Its hash, of the text as given, goes with the game's mods
-*
-* @beta
-*/
-function packFromJson(json, where) {
-	const text = typeof json === "string" ? json : JSON.stringify(json);
-	let parsed;
-	try {
-		parsed = typeof json === "string" ? JSON.parse(json) : json;
-	} catch (error) {
-		throw new PackError(`${where ?? "the pack"}: is not JSON (${error instanceof Error ? error.message : String(error)})`);
-	}
-	const pack = checkPack(parsed, where);
-	return {
-		id: pack.id,
-		version: pack.version,
-		...pack.name !== void 0 && { name: pack.name },
-		...pack.requires !== void 0 && { requires: pack.requires },
-		pack,
-		hash: hashOf(text),
-		apply(game) {
-			for (const kind of DATA_KINDS) {
-				const defs = pack[kind];
-				if (!defs) continue;
-				const collection = collectionOf(game, kind);
-				for (const def of byId(defs)) {
-					const own = structuredClone(def);
-					if (collection.has(def.id)) collection.override(def.id, () => own);
-					else collection.add(own);
-				}
-			}
-			if (pack.data) layData(game, pack.data);
-			if (pack.rules) game.rules(pack.rules);
-		}
-	};
-}
-/** A `data.json`'s values laid over the game as the builder has it: each definition it changes put in its place, those it takes out gone */
-function layData(game, data) {
-	const before = game.current;
-	const after = withData(before, data);
-	for (const kind of DATA_KINDS) {
-		const collection = collectionOf(game, kind);
-		const was = new Map((before[kind] ?? []).map((def) => [def.id, def]));
-		const now = after[kind] ?? [];
-		for (const def of now) {
-			if (!was.has(def.id)) collection.add(def);
-			else if (was.get(def.id) !== def) collection.override(def.id, () => def);
-			was.delete(def.id);
-		}
-		for (const id of was.keys()) collection.remove(id);
-	}
-	if (after.ai !== before.ai) game.set("ai", after.ai);
-}
-/**
-* Whether a game was made with packs, and which: those of the mods its composition kept a hash of, by id and version
-*
-* @beta
-*/
-var packsOf = (game) => (game.mods ?? []).filter((mod) => mod.hash !== void 0).map(({ id, version }) => ({
-	id,
-	version
-}));
-//#endregion
-export { connectAs as A, randomSeed as C, SessionHost as D, RemoteSession as E, readHostMessage as F, readPlayerMessage as I, loopback as M, toRuns as N, SessionRefused as O, isServerMessage as P, tilingNoise as S, MAX_JITTER as T, tilesPass as _, packsOf as a, mapCells as b, generateMap as c, resourcesPass as d, roadsPass as f, terrainPass as g, symmetricPlaces as h, packFromJson as i, fromRuns as j, connect as k, nearestDryGround as l, startsPass as m, checkPack as n, basinShape as o, scatterPass as p, checkPackSchema as r, clearGround as s, PackError as t, presetGenerator as u, MAP_RULES as v, delayed as w, layeredNoise as x, checkMap as y };
-
-//# sourceMappingURL=packs-g5thvmGn.js.map