@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/local-Dkovq42k.js

@@ -0,0 +1,1379 @@
+import { Ao as assertPlainData, Fd as orderSays, Jl as checkpoint, Ki as declaredRefusal, Ol as SessionView, Vn as illusion, Xi as notReady, Zs as shieldOf, _i as decidedUnlocks, cl as fighting, gi as decidedAvailability, ii as placementCells, ll as moving, rl as deposit, ro as dashing, sd as changedStats, ti as canPlaceStructure, uc as heroSummaries, xi as techOf, yd as baseStats } from "./debugCommands-CzjrSm66.js";
+import { Bt as minesFor, Ct as campsFor, an as shownEffects, ct as saveWorld, k as lanesOf, zt as names } from "./coreComponents-syuh2fPG.js";
+import { i as setInspected, n as inspect, r as listWorld, t as EventLog } from "./inspect-D9dWHmZ0.js";
+//#region src/session/protocol.ts
+/**
+* Whether a command is one of the engine's of a kind, narrowed to its shape (`isCommand(sent, 'order')`: its units and
+* its order): what reads a command it did not write, a game's own (`ModCommand`) passed over
+*
+* @beta
+*/
+function isCommand(command, type) {
+	return command.type === type;
+}
+/**
+* The version of what goes over the wire between a host and its players: the messages here and in `session/remote.ts`,
+* and how deltas are made (`session/delta.ts`). The host says it in its welcome and a player says it when joining a
+* server; a player of another version is refused with a reason, not left to fail somewhere strange. Raised by one on
+* any change of their shape, which a game's own data (`Registry.dataHash`) does not show
+*
+* @beta
+*/
+var PROTOCOL_VERSION = 13;
+/**
+* What a player is told when the host's version of the wire is not its own (`PROTOCOL_VERSION`)
+*
+* @internal
+*/
+function protocolMismatch(host, player = 13) {
+	return `The host runs another version of the engine (protocol ${typeof host === "number" ? host : "unknown"}, this player's is ${player}): update the game`;
+}
+/**
+* Reads a message that came over a wire: an object with a `type` that is a string, or nothing. What is not JSON, or is
+* JSON of another shape (`null`, a number, a list), is nothing, so that a peer that sends anything at all makes whoever
+* reads it drop the message, not fall over. The other fields are still the sender's word: check each before it is used
+*
+* @internal
+*/
+function readMessage(text) {
+	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" ? message : void 0;
+}
+/**
+* A number that is a number: not `NaN`, not infinite, not a string of digits
+*
+* @internal
+*/
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+//#endregion
+//#region src/session/can.ts
+/** A session's pace, as `SessionCan.pace`: its own `speed` and `advance` */
+function paceOf(session) {
+	return {
+		get speed() {
+			return session.speed;
+		},
+		set speed(speed) {
+			session.speed = speed;
+		},
+		advance: (ticks) => session.advance(ticks)
+	};
+}
+/** A session's saves, as `SessionCan.saves`: its own `save` and `checkpoint` */
+function savesOf(session) {
+	return {
+		save: () => session.save(),
+		get checkpoint() {
+			return session.checkpoint;
+		}
+	};
+}
+//#endregion
+//#region src/session/delta.ts
+/** Rounded to `step` */
+var round = (value, step) => Math.round(value / step) * step;
+/**
+* Seconds rounded up to whole ones, a hair over one (what floating point leaves over) not counted: what a plate
+* sweeps changes once a second on the wire, not every round (the plate counts down between)
+*/
+var secondsUp = (value) => Math.ceil(value - 1e-6);
+/** Positions on the wire, in 256ths of a unit, and the facing in 256ths of a turn: whole numbers, short to write */
+var POSITION = 256;
+var TURN = 256 / (Math.PI * 2);
+/** An entity's numbers as they go over the wire: whole numbers where they can be. `decode` takes them back */
+function encode(state) {
+	const out = { ...state };
+	if (out.x !== void 0) out.x = Math.round(out.x * POSITION);
+	if (out.z !== void 0) out.z = Math.round(out.z * POSITION);
+	if (out.facing !== void 0) out.facing = (Math.round(out.facing * TURN) % 256 + 256) % 256;
+	return out;
+}
+function decode(state) {
+	const out = { ...state };
+	if (out.x !== void 0) out.x /= POSITION;
+	if (out.z !== void 0) out.z /= POSITION;
+	if (out.facing !== void 0) out.facing /= TURN;
+	return out;
+}
+/**
+* An entity's state with its numbers rounded for the wire: positions to 1/256 of a unit (16 bits over a map of 256),
+* the facing to a 256th of a turn, health and shield up to whole points (what is alive keeps at least one), mana down
+* (an ability is never shown ready that the simulation would refuse), what is under way to hundredths, the seconds
+* left of buffs and of shared cooldowns up to whole seconds
+*
+* @beta
+*/
+function quantize(state) {
+	const out = { ...state };
+	out.x = Math.round(state.x * POSITION) / POSITION;
+	out.z = Math.round(state.z * POSITION) / POSITION;
+	out.facing = (Math.round(state.facing * TURN) % 256 + 256) % 256 / TURN;
+	out.hp = Math.ceil(state.hp);
+	if (state.shield !== void 0) out.shield = Math.ceil(state.shield);
+	if (state.mana !== void 0) out.mana = Math.floor(state.mana);
+	if (state.buffTimes) out.buffTimes = state.buffTimes.map((left) => left < 0 ? left : secondsUp(left));
+	if (state.abilities?.some((ability) => ability.cooldown)) out.abilities = state.abilities.map((ability) => ability.cooldown ? {
+		...ability,
+		cooldown: secondsUp(ability.cooldown)
+	} : ability);
+	if (state.lifetime) out.lifetime = {
+		left: round(state.lifetime.left, .1),
+		total: state.lifetime.total
+	};
+	return out;
+}
+/**
+* Whether two values of a field are the same: the very same, or equal as data. Two flat objects (an entity's `stats`, a
+* `lifetime`, a `leap`'s points) are compared field by field; what nests deeper as text
+*/
+function same(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!same(a[i], b[i])) return false;
+		return true;
+	}
+	const left = a;
+	const right = b;
+	for (const key in left) {
+		if (!(key in right)) return false;
+		const x = left[key];
+		const y = right[key];
+		if (x === y) continue;
+		if (typeof x !== "object" || typeof y !== "object" || x === null || y === null) return false;
+		if (!same(x, y)) return false;
+	}
+	for (const key in right) if (!(key in left)) return false;
+	return true;
+}
+/** How deep a patch goes into lists and objects: past it, what changed is sent whole */
+var PATCH_DEPTH = 4;
+var isObject = (value) => typeof value === "object" && value !== null;
+/**
+* What to send of a value that changed (`same` said so) to whoever has `before`: the parts of a list or an object
+* that changed (`WirePatch`), or `after` whole where every part did, or where it is not the same kind of thing
+*/
+function patchOf(before, after, depth = PATCH_DEPTH) {
+	if (depth === 0 || !isObject(before) || !isObject(after) || Array.isArray(before) !== Array.isArray(after)) return after;
+	const parts = {};
+	let changed = 0;
+	if (Array.isArray(before)) {
+		const list = after;
+		if (list.length !== before.length) return after;
+		for (let i = 0; i < list.length; i++) {
+			if (same(before[i], list[i])) continue;
+			parts[i] = patchOf(before[i], list[i], depth - 1);
+			changed++;
+		}
+		return changed === list.length ? after : { $patch: parts };
+	}
+	const left = before;
+	const right = after;
+	let fields = 0;
+	let unset;
+	for (const key in right) {
+		if (right[key] === void 0) continue;
+		fields++;
+		if (same(left[key], right[key])) continue;
+		parts[key] = patchOf(left[key], right[key], depth - 1);
+		changed++;
+	}
+	for (const key in left) if (left[key] !== void 0 && right[key] === void 0) (unset ??= []).push(key);
+	if (changed === fields && !unset) return after;
+	return unset ? {
+		$patch: parts,
+		$unset: unset
+	} : { $patch: parts };
+}
+var isPatch = (value) => isObject(value) && !Array.isArray(value) && "$patch" in value;
+/** A value a patch was made against, with the patch put in: new lists and objects where it says, the very parts it does not */
+function patched(base, patch) {
+	const made = Array.isArray(base) ? [...base] : { ...base };
+	for (const [key, part] of Object.entries(patch.$patch)) made[key] = isPatch(part) ? patched(base[key], part) : part;
+	for (const key of patch.$unset ?? []) delete made[key];
+	return made;
+}
+/** Whether two entities' components say the same: each as it knows how (`Component.same`), or as text */
+function sameComponents(registry, a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	for (const id in a) if (!(id in b)) return false;
+	for (const id in b) {
+		if (!(id in a)) return false;
+		const compare = registry?.component(id)?.same;
+		if (compare ? !compare(a[id], b[id]) : !same(a[id], b[id])) return false;
+	}
+	return true;
+}
+/**
+* The fields of an object that changed, and those that are gone, or nothing when none did. A field named in `skip` is
+* left to the caller (an entity's `own` part goes field by field on its own)
+*/
+function fieldsOf(registry, before, after, skip) {
+	let set;
+	let unset;
+	for (const key in after) {
+		if (key === skip || after[key] === void 0) continue;
+		if (key === "components" ? !sameComponents(registry, before[key], after[key]) : !same(before[key], after[key])) (set ??= {})[key] = after[key];
+	}
+	for (const key in before) if (key !== skip && before[key] !== void 0 && after[key] === void 0) (unset ??= []).push(key);
+	return set || unset ? {
+		set: set ?? {},
+		...unset ? { unset } : {}
+	} : void 0;
+}
+/** What changed of an entity, or nothing when nothing did. What only its owner is told goes field by field too */
+function changeOf(registry, before, after) {
+	const ownBefore = before.own;
+	const ownAfter = after.own;
+	const fields = fieldsOf(registry, before, after, "own");
+	let own;
+	let ownPatch;
+	let unsetOwn = false;
+	if (ownBefore && ownAfter) {
+		own = fieldsOf(registry, ownBefore, ownAfter);
+		if (own) for (const key in own.set) {
+			const field = key;
+			if (!isObject(ownBefore[field])) continue;
+			const patch = patchOf(ownBefore[field], own.set[field]);
+			if (!isPatch(patch)) continue;
+			(ownPatch ??= {})[field] = patch;
+			delete own.set[field];
+		}
+	} else if (ownAfter) own = { set: ownAfter };
+	else if (ownBefore) unsetOwn = true;
+	if (!fields && !own && !unsetOwn) return void 0;
+	const unset = [...fields?.unset ?? [], ...unsetOwn ? ["own"] : []];
+	const set = fields?.set ?? {};
+	if (set.x !== void 0) set.x = Math.round(set.x * POSITION);
+	if (set.z !== void 0) set.z = Math.round(set.z * POSITION);
+	if (set.facing !== void 0) set.facing = (Math.round(set.facing * TURN) % 256 + 256) % 256;
+	const change = [after.id, set];
+	if (unset.length || own) change.push(unset.length ? unset : 0);
+	if (own) {
+		change.push(Object.keys(own.set).length || !ownPatch ? own.set : 0);
+		if (own.unset || ownPatch) change.push(own.unset ?? 0);
+		if (ownPatch) change.push(ownPatch);
+	}
+	return change;
+}
+/**
+* Every part of a frame besides its tick, its entities and its events: the snapshot's parts, the engine's and a pack's
+* (`SnapshotPart`), and the fog, the camps and the team
+*/
+var restOf = (frame) => {
+	const { snapshot, fog, camps, team } = frame;
+	const { tick: _tick, entities: _entities, events: _events, ...parts } = snapshot;
+	return {
+		...parts,
+		fog,
+		camps,
+		team
+	};
+};
+/** A frame's entities by id, worked out once: a base is diffed against round after round while the player's answer is on its way */
+var BY_ID = /* @__PURE__ */ new WeakMap();
+function entitiesById(frame) {
+	let byId = BY_ID.get(frame);
+	if (!byId) {
+		byId = /* @__PURE__ */ new Map();
+		for (const entity of frame.snapshot.entities) byId.set(entity.id, entity);
+		BY_ID.set(frame, byId);
+	}
+	return byId;
+}
+var entityDiffs = /* @__PURE__ */ new WeakMap();
+var wholeDiffs = /* @__PURE__ */ new WeakMap();
+function entitiesDiff(then, now, base, registry) {
+	let byBase = then && entityDiffs.get(then);
+	const known = then ? byBase?.get(now) : wholeDiffs.get(now);
+	if (known) return known;
+	const made = {
+		added: [],
+		changed: [],
+		removed: []
+	};
+	const before = base ? entitiesById(base) : void 0;
+	const seen = before && before.size ? /* @__PURE__ */ new Set() : void 0;
+	for (const entity of now) {
+		const old = before?.get(entity.id);
+		if (old) seen.add(entity.id);
+		if (!old || old.type !== entity.type) {
+			if (old) made.removed.push(old.id);
+			made.added.push(encode(entity));
+			continue;
+		}
+		const change = changeOf(registry, old, entity);
+		if (change) made.changed.push(change);
+	}
+	if (before) {
+		for (const id of before.keys()) if (!seen.has(id)) made.removed.push(id);
+	}
+	if (then) {
+		if (!byBase) entityDiffs.set(then, byBase = /* @__PURE__ */ new WeakMap());
+		byBase.set(now, made);
+	} else wholeDiffs.set(now, made);
+	return made;
+}
+/**
+* A frame as what changed since `base`, or all of it without one. Events are the caller's to add. `registry`: the game's, whose
+* components say how a change of theirs is found (`Component.same`); without it, as text
+*
+* @internal
+*/
+function diff(base, next, registry) {
+	const delta = {
+		tick: next.snapshot.tick,
+		base: base ? base.snapshot.tick : null,
+		added: [],
+		changed: [],
+		removed: [],
+		rest: {}
+	};
+	const { added, changed, removed } = entitiesDiff(base?.snapshot.entities, next.snapshot.entities, base, registry);
+	delta.added = added;
+	delta.changed = changed;
+	delta.removed = removed;
+	const now = restOf(next);
+	const then = base && restOf(base);
+	const keys = then ? /* @__PURE__ */ new Set([...Object.keys(now), ...Object.keys(then)]) : Object.keys(now);
+	for (const key of keys) {
+		const before = then?.[key];
+		const after = now[key];
+		if (then && same(before, after)) continue;
+		const patch = then && key !== "fog" ? patchOf(before, after) : after;
+		if (isPatch(patch)) (delta.restPatch ??= {})[key] = patch;
+		else delta.rest[key] = after;
+	}
+	return delta;
+}
+/**
+* The frame a delta makes of the one at its base (none, for a whole one). Entities that did not change are the very
+* objects they were, so that whoever compares them by identity knows they did not. That is the frame before
+* (`latest`) whose object is the same as what is made, which is not always the base: the base is the last frame the
+* host heard was got, a frame or two behind, and the frames in between have objects of their own
+*
+* @internal
+*/
+function apply(base, delta, latest) {
+	const removed = new Set(delta.removed);
+	const changed = /* @__PURE__ */ new Map();
+	for (const change of delta.changed) changed.set(change[0], change);
+	const before = /* @__PURE__ */ new Map();
+	if (latest && latest !== base) for (const entity of latest.snapshot.entities) before.set(entity.id, entity);
+	/** The frame before's object for what is made, where it is the same as it; else what is made */
+	const kept = (made) => {
+		const was = before.get(made.id);
+		return was && (was === made || sameEntity(was, made)) ? was : made;
+	};
+	const entities = [];
+	for (const entity of base?.snapshot.entities ?? []) {
+		if (removed.has(entity.id)) continue;
+		const change = changed.get(entity.id);
+		if (!change) {
+			entities.push(kept(entity));
+			continue;
+		}
+		const [, set, unset, ownSet, ownUnset, ownPatch] = change;
+		const next = {
+			...entity,
+			...decode(set)
+		};
+		for (const field of unset || []) delete next[field];
+		if (ownSet || ownUnset || ownPatch) {
+			const own = {
+				...entity.own,
+				...ownSet || {}
+			};
+			for (const field of ownUnset || []) delete own[field];
+			for (const [field, patch] of Object.entries(ownPatch ?? {})) own[field] = patched(entity.own?.[field], patch);
+			next.own = own;
+		}
+		entities.push(kept(next));
+	}
+	for (const added of delta.added) entities.push(kept(decode(added)));
+	const rest = {
+		...base ? restOf(base) : {},
+		...delta.rest
+	};
+	for (const [key, patch] of Object.entries(delta.restPatch ?? {})) rest[key] = patched(base && restOf(base)[key], patch);
+	const { fog, camps, team, ...parts } = rest;
+	return {
+		snapshot: {
+			tick: delta.tick,
+			...parts,
+			entities,
+			events: []
+		},
+		fog,
+		camps,
+		team
+	};
+}
+/**
+* Whether two states of an entity say the same, field by field
+*
+* @internal
+*/
+function sameEntity(a, b) {
+	if (a.type !== b.type) return false;
+	return fieldsOf(void 0, a, b) === void 0;
+}
+/**
+* Characters of a delta's text by what they carry, added to `into`: each field of an entity, of those added and those
+* changed together (`entity.hp`; of what only its owner is told, `entity.own.abilities`), the other parts (`rest.fog`),
+* `events`, `removed`, and what is left (ids, brackets, the tick) as `other`, so that they add up to `text`'s length.
+* A field is its key, its value and the comma between, as `JSON.stringify` writes them
+*/
+function bytesByKey(delta, text, into) {
+	let counted = 0;
+	const add = (key, characters) => {
+		into[key] = (into[key] ?? 0) + characters;
+		counted += characters;
+	};
+	const fields = (prefix, values) => {
+		for (const [key, value] of Object.entries(values)) {
+			if (value === void 0) continue;
+			if (key === "own" && prefix === "entity." && value && typeof value === "object") {
+				add("entity.own", key.length + 5);
+				fields("entity.own.", value);
+			} else add(prefix + key, key.length + 4 + JSON.stringify(value).length);
+		}
+	};
+	for (const entity of delta.added) fields("entity.", entity);
+	for (const [, set, unset, ownSet, ownUnset, ownPatch] of delta.changed) {
+		fields("entity.", set);
+		if (unset) add("entity.unset", JSON.stringify(unset).length + 1);
+		if (ownSet) fields("entity.own.", ownSet);
+		if (ownUnset) add("entity.own.unset", JSON.stringify(ownUnset).length + 1);
+		if (ownPatch) fields("entity.own.", ownPatch);
+	}
+	for (const part of [delta.rest, delta.restPatch ?? {}]) for (const [key, value] of Object.entries(part)) if (value !== void 0) add(`rest.${key}`, key.length + 4 + JSON.stringify(value).length);
+	if (delta.events.length) add("events", JSON.stringify(delta.events).length);
+	if (delta.removed.length) add("removed", JSON.stringify(delta.removed).length);
+	add("other", text.length - counted);
+}
+//#endregion
+//#region src/session/debug.ts
+/** Ticks between two lists of everything in the world: thousands of trees need not be listed every tick */
+var LIST_EVERY = 10;
+/**
+* The debug tools' view of a world running in the same page. What it hands out is worked out again whenever a
+* snapshot is, and at once when the client asks for something else: a remote one would wait for the answer instead
+*/
+var LocalDebug = class {
+	simulation;
+	inspection = null;
+	world = null;
+	target = null;
+	listedAt = -Infinity;
+	events = new EventLog();
+	constructor(simulation) {
+		this.simulation = simulation;
+	}
+	inspect(target) {
+		this.target = target;
+		this.refresh();
+	}
+	set(path, value) {
+		if (!this.target) return;
+		setInspected(this.simulation, this.target, path, value);
+		this.refresh();
+	}
+	get listing() {
+		return this.world !== null;
+	}
+	set listing(on) {
+		this.listedAt = -Infinity;
+		this.world = on ? listWorld(this.simulation) : null;
+	}
+	get logging() {
+		return this.events.attached;
+	}
+	set logging(on) {
+		if (on === this.logging) return;
+		if (on) this.events.attach(this.simulation);
+		else this.events.detach();
+	}
+	log() {
+		return this.events.entries;
+	}
+	clearLog() {
+		this.events.clear();
+	}
+	/** Works what is handed out again. The session does when a tick went by */
+	refresh() {
+		const world = this.simulation;
+		this.inspection = this.target && inspect(world, this.target);
+		if (this.world && world.tick - this.listedAt >= LIST_EVERY) {
+			this.world = listWorld(world);
+			this.listedAt = world.tick;
+		}
+	}
+	dispose() {
+		this.events.detach();
+	}
+};
+/** What is followed, as the wire says it: an entity, a player or the world, or nothing; anything else is not */
+function targetOf(value) {
+	if (value === null) return null;
+	if (typeof value !== "object") return void 0;
+	const target = value;
+	if (isFiniteNumber(target.entity)) return { entity: target.entity };
+	if (isFiniteNumber(target.player)) return { player: target.player };
+	if (target.world === true) return { world: true };
+}
+/**
+* Does what the debug tools of a screen asked of a world here (`DebugAsk`), each field checked first: it comes from
+* anyone who can send anything
+*/
+function askDebug(view, ask) {
+	const target = targetOf(ask.inspect);
+	if (target !== void 0) view.inspect(target);
+	const set = ask.set;
+	if (set && Array.isArray(set.path) && set.path.every((key) => typeof key === "string" || isFiniteNumber(key)) && (isFiniteNumber(set.value) || typeof set.value === "boolean")) view.set(set.path, set.value);
+	if (typeof ask.listing === "boolean") view.listing = ask.listing;
+	if (typeof ask.logging === "boolean") view.logging = ask.logging;
+	if (ask.clearLog === true) view.clearLog();
+}
+/**
+* The debug tools' view of a world elsewhere, a server's or a worker's: what it asked to follow, said over the wire
+* (`DebugAsk`), and what came back last (`take`)
+*/
+var RemoteDebug = class {
+	ask;
+	inspection = null;
+	world = null;
+	listed = false;
+	logged = false;
+	target = null;
+	events = [];
+	constructor(ask) {
+		this.ask = ask;
+	}
+	inspect(target) {
+		this.target = target;
+		if (!target) this.inspection = null;
+		this.ask({ inspect: target });
+	}
+	/** Asks again for all it follows: of a world it is served from anew (a session resumed, a replay gone back) */
+	askAgain() {
+		if (this.target || this.listed || this.logged) this.ask({
+			inspect: this.target,
+			listing: this.listed,
+			logging: this.logged
+		});
+	}
+	set(path, value) {
+		this.ask({ set: {
+			path,
+			value
+		} });
+	}
+	get listing() {
+		return this.listed;
+	}
+	set listing(on) {
+		this.listed = on;
+		if (!on) this.world = null;
+		this.ask({ listing: on });
+	}
+	get logging() {
+		return this.logged;
+	}
+	set logging(on) {
+		this.logged = on;
+		this.ask({ logging: on });
+	}
+	log() {
+		return this.events;
+	}
+	clearLog() {
+		this.events = [];
+		this.ask({ clearLog: true });
+	}
+	/** What the world's side said of what is followed */
+	take(said) {
+		this.inspection = said.inspection;
+		this.world = this.listed ? said.world : null;
+		if (this.logged) this.events = said.log;
+	}
+};
+//#endregion
+//#region src/session/entityState.ts
+/**
+* What a player is told of an entity (design review E7): what everyone in sight of it is, worked out once a tick for
+* every seat of a host (`commonEntityState`), and on it what is one player's own (`playerEntityState`). A seat
+* (`LocalSession`) puts them in its snapshots; nothing here keeps anything between ticks
+*/
+/** A rule of `GameRules.hud` for one unit: its value, or what its function decides */
+var ruleOf = (world, entity, rule) => typeof rule === "function" ? rule(world, entity) : rule;
+/** The seconds left of a unit's buffs, in their order: -1 for one with no end, or kept up by an aura or a passive */
+function buffTimesOf(entity) {
+	const times = new Array(entity.buffs.length);
+	for (let i = 0; i < entity.buffs.length; i++) {
+		const buff = entity.buffs[i];
+		times[i] = Number.isFinite(buff.remaining) && !buff.kept ? Math.max(buff.remaining, 0) : -1;
+	}
+	return times;
+}
+/**
+* What everyone in sight of an entity is told of it this tick, the same for every seat (`EntityState`): where it is,
+* its health and mana, its stats where they changed, its buffs, what the rules share for the plates over it. `name`
+* is what the map calls it, where it has a name
+*
+* @internal
+*/
+function commonEntityState(world, entity, name) {
+	const state = {
+		id: entity.id,
+		type: entity.def.id,
+		owner: entity.owner,
+		x: entity.pos.x,
+		z: entity.pos.z,
+		facing: entity.facing,
+		hp: entity.hp,
+		stats: changedStats(world, entity),
+		visible: true
+	};
+	const base = baseStats(entity.def, world.registry);
+	if (entity.maxHp !== base.health) state.maxHp = entity.maxHp;
+	if (entity.buffs.length) state.shield = shieldOf(entity) || void 0;
+	const dash = entity.get(dashing);
+	if (dash?.height) state.leap = {
+		from: dash.from,
+		to: {
+			x: dash.x,
+			z: dash.z
+		},
+		height: dash.height
+	};
+	if (entity.maxMana > 0) {
+		state.mana = entity.mana;
+		if (entity.maxMana !== base.mana) state.maxMana = entity.maxMana;
+	}
+	if (entity.buffs.length) state.buffs = entity.buffs.map((buff) => buff.id);
+	for (const buff of entity.buffs) if (buff.stacks) (state.stacks ??= {})[buff.id] = buff.stacks;
+	const { hud } = world.rules;
+	if (hud.shareBuffTimes !== void 0 && entity.buffs.length && ruleOf(world, entity, hud.shareBuffTimes) === true) state.buffTimes = buffTimesOf(entity);
+	if (hud.shareAbilities !== void 0 && entity.abilities.length) {
+		const share = ruleOf(world, entity, hud.shareAbilities);
+		if (share === "icons" || share === "cooldowns") {
+			const abilities = [];
+			for (const { id, level, cooldown } of entity.abilities) if (level >= 1) abilities.push(share === "cooldowns" ? {
+				id,
+				level,
+				cooldown
+			} : {
+				id,
+				level
+			});
+			if (abilities.length) state.abilities = abilities;
+		}
+	}
+	if (entity.get(deposit)) state.resource = entity.get(deposit).amount;
+	if (entity.on !== void 0) state.on = entity.on;
+	if (entity.asleep) state.asleep = true;
+	if (entity.scale !== 1) state.scale = entity.scale;
+	if (entity.look) state.look = entity.look;
+	if (world.sight.isInvisible(entity)) state.unseen = true;
+	if (name !== void 0) state.name = name;
+	if (entity.expires !== null && !entity.has(illusion)) state.lifetime = {
+		left: entity.expires,
+		total: entity.lifetime
+	};
+	return state;
+}
+/**
+* Whether an entity has a component replicated to its owner, or shaping itself for each player (`Component.snapshot`)
+*
+* @internal
+*/
+function hasOnePlayersPart(world, entity) {
+	for (const held of entity.heldComponents()) {
+		const component = world.registry.component(held.id);
+		if (component?.replicate === "owner" || component?.replicate && component.snapshot) return true;
+	}
+	return false;
+}
+/**
+* What one player is told of an entity, on what everyone is (`shared`, `commonEntityState`): an illusion's lifetime on
+* its own side, the components replicated to the player and what they make of themselves for them, and its own part
+* (`own`: its orders, where it goes, its abilities) for one of the player's side. `shared` itself where there is
+* nothing more
+*
+* @internal
+*/
+function playerEntityState(view, entity, shared) {
+	const { world, player, observer } = view;
+	let state = shared;
+	/** This player's copy of the shared state, made once something of this player's is added */
+	const mine = () => state === shared ? state = { ...shared } : state;
+	if (entity.expires !== null && entity.has(illusion) && view.isAlly(entity.owner)) mine().lifetime = {
+		left: entity.expires,
+		total: entity.lifetime
+	};
+	let seen;
+	for (const held of entity.heldComponents()) {
+		const { id } = held;
+		const component = world.registry.component(id);
+		const audience = component?.replicate;
+		if (!audience) continue;
+		const ally = view.isAlly(entity.owner);
+		if (!(audience === "everyone" || (audience === "allies" ? ally : entity.owner === player))) continue;
+		const value = entity.get(held);
+		const sent = component.snapshot ? component.snapshot(value, entity, seen ??= {
+			world,
+			player: observer ? void 0 : player,
+			own: entity.owner === player,
+			ally,
+			observer,
+			knows: view.knows,
+			isAlly: view.isAlly,
+			sees: view.sees
+		}) : structuredClone(value);
+		if (sent !== void 0) (mine().components ??= {})[id] = sent;
+	}
+	if (!view.isAlly(entity.owner)) return state;
+	const shareBuffTimes = world.rules.hud.shareBuffTimes;
+	if (shareBuffTimes !== void 0 && entity.buffs.length && !shared.buffTimes && ruleOf(world, entity, shareBuffTimes) === "allies") mine().buffTimes = buffTimesOf(entity);
+	const m = entity.get(moving);
+	let waypoints;
+	for (let i = 1; i < entity.orders.length; i++) {
+		const order = entity.orders[i];
+		const target = world.get(order.init.target);
+		const point = target && view.knows(target) ? target.pos : order.init.point;
+		if (point) (waypoints ??= []).push({
+			x: point.x,
+			z: point.z
+		});
+	}
+	const own = mine().own = {
+		...entity.owner !== player && !observer && world.mayCommand(player, entity) && { shared: true },
+		hidden: entity.hidden,
+		order: entity.orders[0]?.type ?? null,
+		build: entity.orders[0]?.type === "build" && !orderSays(world, entity, "building") ? entity.orders[0].init.unitType : void 0,
+		orders: entity.orders.length,
+		passive: entity.get(fighting)?.passive ?? false,
+		fighting: !!entity.get(fighting)?.autoTarget,
+		goal: m?.status === "moving" ? {
+			x: m.navGoal.x,
+			z: m.navGoal.z
+		} : void 0,
+		...waypoints && { waypoints }
+	};
+	if (entity.abilities.length) {
+		const hooked = world.hooks.has("canCast");
+		own.abilities = entity.abilities.map(({ id, level, cooldown, charges, refill, autocast }) => {
+			const info = {
+				id,
+				level,
+				cooldown,
+				autocast
+			};
+			if (charges !== void 0) Object.assign(info, {
+				charges,
+				refill
+			});
+			if (!hooked || level < 1) return info;
+			const ability = world.registry.ability(id);
+			const declared = declaredRefusal(world, entity, ability);
+			const decided = notReady(world, entity, ability);
+			if (declared?.key !== decided?.key) info.decided = decided ?? null;
+			return info;
+		});
+	}
+	return state;
+}
+//#endregion
+//#region src/session/local.ts
+/**
+* A seat at a world running in the same page. It does the job a server will do later:
+* run the simulation, and hand the player only what their team is allowed to know.
+*/
+/** The effects of the rules a player was shown that are kept, for a stop to be told to them: the latest so many */
+var MOST_EFFECTS = 1024;
+/**
+* The events a computer player's seat hears (`forComputer`): the facts a brain reads and a save keeps for it (deaths,
+* damage, healing, pings, chat, the game's own events) and the answers to its commands. The rest is for a screen (an
+* attack's swing, a shot, a buff, a hammer blow, a line said), and a computer's seat is spared hearing it
+*
+* @beta
+*/
+var COMPUTER_EVENTS = /* @__PURE__ */ new Set([
+	"death",
+	"damage",
+	"heal",
+	"ping",
+	"chat",
+	"game",
+	"command"
+]);
+var SHARED = /* @__PURE__ */ new WeakMap();
+/**
+* From here until `endSharedCaptures`, the sessions of the world describe each entity once between them (what
+* everyone is told; what is one player's goes on a copy): for a host's round of sending, where every seat is captured
+* from the same world. Not while the world changes: what was described is said again
+*
+* @internal
+*/
+function shareCaptures(world) {
+	SHARED.set(world, {
+		common: /* @__PURE__ */ new Map(),
+		sides: /* @__PURE__ */ new Map()
+	});
+}
+/** @internal */
+function endSharedCaptures(world) {
+	SHARED.delete(world);
+}
+/** @beta */
+var LocalSession = class {
+	world;
+	playerId;
+	terrain;
+	environment;
+	doodads;
+	regions;
+	cameras;
+	paths;
+	registry;
+	tickRate;
+	alpha = 1;
+	/** What the world says (`World.log`): a session in the page has it, and the client shows it with its own */
+	get log() {
+		return this.world.log;
+	}
+	/** Why the game ended on an error, once it has (`World.failure`) */
+	get failure() {
+		return this.world.failure;
+	}
+	/** Simulation speed multiplier, 0 pauses. A debug control, a real server sets the pace itself */
+	speed = 1;
+	accumulator = 0;
+	/** Whether the team saw the whole map at the last snapshot (the debug switch): what it saw then only is forgotten after */
+	wasRevealed = false;
+	/** What the player's team remembers, or an observer's own (`SessionView.memory`) */
+	get memory() {
+		return this.view.memory;
+	}
+	/** Ids of what made it into the snapshot being put together as in sight. Kept to be cleared, not made anew */
+	inSight = /* @__PURE__ */ new Set();
+	/** The names the map or the rules gave entities, by id, as of the snapshot being put together (`world.named`) */
+	namesNow = /* @__PURE__ */ new Map();
+	disposers = [];
+	pendingCheckpoint;
+	checkpoint;
+	debug;
+	/** Its pace, saves of its world, the debug tools' view, and what a computer player's brain reads (`SessionCan`) */
+	can = {
+		pace: paceOf(this),
+		saves: savesOf(this),
+		inspect: void 0,
+		computer: {
+			mines: () => this.mines(),
+			lanes: () => this.lanes(),
+			pendingEvents: () => this.pendingEvents(),
+			restoreEvents: (events) => this.restoreEvents(events)
+		}
+	};
+	/**
+	* Who only watches, and sees everything: every entity, the whole map, every player's resources and heroes. From
+	* `playerId`'s side all the same (who is an ally, an enemy). For a server's watchers, whose commands go nowhere
+	*/
+	observer;
+	/**
+	* Whose seat is a computer player's (`forComputer`): its snapshots leave out projectiles, missiles, corpses, reveals
+	* and the events a brain never reads, and it listens for none of those, so twelve computers cost the world less
+	*/
+	forComputer;
+	/** The seat's side of the world: whose it is, what they may know, what was told to them since the last snapshot */
+	view;
+	constructor(world, playerId, options = {}) {
+		this.world = world;
+		this.playerId = playerId;
+		this.observer = options.observer ?? false;
+		this.ownsWorld = options.ownsWorld ?? false;
+		this.forComputer = options.forComputer ?? false;
+		this.view = new SessionView(world, playerId, {
+			observer: this.observer,
+			forComputer: this.forComputer,
+			mostEffects: options.mostEffects ?? MOST_EFFECTS
+		});
+		if (options.debug) world.debugPlayers.add(playerId);
+		this.terrain = world.terrain;
+		this.environment = world.map.environment;
+		this.doodads = world.map.doodads;
+		this.regions = world.map.regions;
+		this.cameras = world.map.cameras;
+		this.paths = world.map.paths;
+		this.registry = world.registry;
+		this.tickRate = world.tickRate;
+		this.debug = new LocalDebug(world);
+		this.can.inspect = this.debug;
+		const { events } = world;
+		const { view } = this;
+		for (const replication of world.registry.replications) {
+			if (!this.hears(replication.as)) continue;
+			this.disposers.push(events.on(replication.event, (payload) => {
+				const said = replication.tell(payload, view);
+				if (said) view.events.push(said);
+			}));
+		}
+		this.disposers.push(events.on(checkpoint, ({ label }) => this.pendingCheckpoint = label));
+		if (this.hears("game")) this.disposers.push(events.watch((type, payload) => {
+			if (typeof type !== "string") return;
+			const audience = world.registry.event(type)?.replicate;
+			if (!audience) return;
+			if (audience !== "everyone" && !audience(payload, view)) return;
+			if (this.world.checks.events) assertPlainData(payload, `Event "${type}"`);
+			view.events.push({
+				type: "game",
+				event: type,
+				payload
+			});
+		}));
+	}
+	/** Whether the seat is told of events of a kind: a player's seat of all of them, a computer's of what a brain reads */
+	hears(kind) {
+		return !this.forComputer || COMPUTER_EVENTS.has(kind);
+	}
+	/** The player's team: theirs now, as the rules may move them to another (`setTeam`) */
+	get team() {
+		return this.view.team;
+	}
+	isAlly(owner) {
+		return this.view.isAlly(owner);
+	}
+	/** Whether the player's team sees a spot of the map right now: an observer sees all of it */
+	sees(x, z) {
+		return this.view.sees(x, z);
+	}
+	/**
+	* How many effects of the rules are kept for their stop to be told (`mostEffects`), for a test of the bound
+	*
+	* @internal
+	*/
+	get keptEffects() {
+		return shownEffects(this.view).size;
+	}
+	/** Whether the player's team can see the entity right now */
+	knows(entity) {
+		return this.view.knows(entity);
+	}
+	/**
+	* What everyone in sight of an entity is told of it this tick, the same for every seat: worked out once for all
+	* the sessions of a world while a host's round of sending is on (`shareCaptures`), else for this session alone
+	*/
+	common(entity) {
+		const shared = SHARED.get(this.world)?.common;
+		const known = shared?.get(entity.id);
+		if (known) return known;
+		const state = commonEntityState(this.world, entity, this.namesNow.get(entity.id));
+		shared?.set(entity.id, state);
+		return state;
+	}
+	/**
+	* What this player is told of an entity: what everyone is (`common`, shared between the seats of a host), and on a
+	* copy of it what is this player's to know: an illusion's lifetime on its own side, the components replicated to it
+	* and what they make of themselves for it, and its own part (`own`) for an ally's
+	*/
+	describe(entity) {
+		const side = this.sideNow;
+		if (!side) return playerEntityState(this.view, entity, this.common(entity));
+		if (this.isOnePlayers(entity)) {
+			const state = playerEntityState(this.view, entity, this.common(entity));
+			const first = side.alike.get(entity.id);
+			if (!first) side.alike.set(entity.id, state);
+			else if (first !== state && sameEntity(first, state)) return first;
+			return state;
+		}
+		const known = side.all.get(entity.id);
+		if (known) return known;
+		const state = playerEntityState(this.view, entity, this.common(entity));
+		side.all.set(entity.id, state);
+		return state;
+	}
+	/**
+	* What the seats of this one's side are told alike this round (`Round.sides`), by entity: none outside a host's round.
+	* Set as the capture starts (`capture`)
+	*/
+	sideNow;
+	/**
+	* Which seats are told the same of an entity where nothing of it is one player's: an observer's, or a team's with the
+	* same allies among the players (relations are a pair of players', not a team's)
+	*/
+	sideKey() {
+		if (this.observer) return "observer";
+		let key = `team ${this.team}:`;
+		for (const player of this.world.players.keys()) key += this.isAlly(player) ? "1" : "0";
+		return key;
+	}
+	/**
+	* Whether what this player is told of an entity is theirs alone, not their side's: a component replicated to its owner
+	* or shaping itself for each player (`Component.snapshot`), or control of another's unit shared with this player
+	*/
+	isOnePlayers(entity) {
+		if (hasOnePlayersPart(this.world, entity)) return true;
+		return entity.owner !== this.playerId && !this.observer && this.isAlly(entity.owner) && this.world.mayCommand(this.playerId, entity);
+	}
+	/** Where in the list being captured are those that may be one player's (`SideSeen.mine`): while the first seat of a side captures */
+	mineNow;
+	/**
+	* What the team remembers of a structure is every teammate's to be told, not this seat's: without the parts of the
+	* description shaped for one player (components replicated to the owner, or made by their `snapshot` for whoever is
+	* told), which the seat that happened to see it first would otherwise give to the whole team
+	*/
+	forTeam(entity, state) {
+		if (!state.components || !hasOnePlayersPart(this.world, entity)) return state;
+		const components = {};
+		for (const [id, part] of Object.entries(state.components)) {
+			const component = this.world.registry.component(id);
+			if (component?.replicate === "owner" || component?.replicate && component.snapshot) continue;
+			components[id] = part;
+		}
+		return {
+			...state,
+			components
+		};
+	}
+	/** Adds what the player sees of an entity in sight to the snapshot, and remembers structures for when they are out of sight */
+	see(entity, out, remembered) {
+		const before = remembered[entity.id];
+		const kept = entity.isResource && before?.visible && before.resource === entity.get(deposit)?.amount;
+		const state = kept ? before : this.describe(entity);
+		if (!kept && this.mineNow && (this.isAlly(entity.owner) || hasOnePlayersPart(this.world, entity))) this.mineNow.push(out.length);
+		out.push(state);
+		this.inSight.add(entity.id);
+		if (entity.isStructure && !this.isAlly(entity.owner)) {
+			if (state !== before) remembered[entity.id] = this.forTeam(entity, state);
+		} else if (before) delete remembered[entity.id];
+	}
+	/** Throws when what was taken to be in sight is not what testing every entity gives. See `debugChecks` */
+	checkSight() {
+		for (const entity of this.world.entities.values()) {
+			if (!entity.alive || this.knows(entity) === this.inSight.has(entity.id)) continue;
+			const said = this.inSight.has(entity.id) ? "in sight" : "out of sight";
+			throw new Error(`Snapshot for player ${this.playerId} has ${entity.def.id}#${entity.id} ${said}, it is not`);
+		}
+	}
+	/** The scenery the player's team sees right now */
+	*sceneryInSight() {
+		const { world } = this;
+		if (this.observer || world.fog.isRevealed(this.team)) {
+			for (const entity of world.entities.values()) if (entity.scenery) yield entity;
+		} else yield* world.sceneryInSight.get(this.team) ?? [];
+	}
+	/**
+	* On a map explored from the start, what stands on it and belongs to no player (trees, mines, rocks, neutral
+	* buildings, the creeps' own) known to the team from the first snapshot, as it stands, out of sight: the genre's melee
+	* maps. Once for a team (`TeamMemory.startKnown`); units, and players' buildings, only once seen
+	*/
+	knowStart(remembered) {
+		const { world } = this;
+		if (this.observer || !world.fog.exploredFromStart) return;
+		const memory = this.memory;
+		if (memory.startKnown) return;
+		memory.startKnown = true;
+		for (const entity of world.entities.values()) {
+			if (!entity.alive || !entity.isStructure || this.inSight.has(entity.id) || remembered[entity.id]) continue;
+			const owner = world.players.get(entity.owner);
+			if (!owner?.neutral && !owner?.creeps) continue;
+			remembered[entity.id] = {
+				...this.forTeam(entity, this.describe(entity)),
+				visible: false
+			};
+		}
+	}
+	capture() {
+		const { world } = this;
+		const round = SHARED.get(world);
+		if (round) {
+			const key = this.sideKey();
+			let side = round.sides.get(key);
+			if (!side) round.sides.set(key, side = {
+				all: /* @__PURE__ */ new Map(),
+				alike: /* @__PURE__ */ new Map()
+			});
+			this.sideNow = side;
+		} else this.sideNow = void 0;
+		const remembered = this.memory.structures;
+		this.namesNow.clear();
+		if (world.states.has(names)) for (const [name, id] of Object.entries(world.state(names))) this.namesNow.set(id, name);
+		const seen = this.sideNow?.seen;
+		const entities = seen ? this.seeAsSide(seen) : this.seeAll(remembered);
+		if (this.world.checks.sight) this.checkSight();
+		if (seen) return this.finish(entities);
+		this.knowStart(remembered);
+		const revealed = this.observer || world.fog.isRevealed(this.team);
+		if (this.wasRevealed && !revealed) {
+			for (const [key, state] of Object.entries(remembered)) if (!this.inSight.has(Number(key)) && !world.fog.isExplored(this.team, state.x, state.z)) delete remembered[Number(key)];
+		}
+		this.wasRevealed = revealed;
+		const forget = world.rules.fog?.explored === "nothing" && !revealed;
+		for (const [key, state] of Object.entries(remembered)) {
+			const id = Number(key);
+			if (this.inSight.has(id)) continue;
+			if (forget) {
+				delete remembered[id];
+				continue;
+			}
+			if (!world.get(id) && this.sees(state.x, state.z)) {
+				delete remembered[id];
+				continue;
+			}
+			const memory = state.visible ? {
+				...state,
+				visible: false
+			} : state;
+			if (memory !== state) remembered[id] = memory;
+			entities.push(memory);
+		}
+		if (this.sideNow) this.sideNow.seen = {
+			entities: [...entities],
+			inSight: new Set(this.inSight),
+			mine: this.mineNow ?? []
+		};
+		this.mineNow = void 0;
+		return this.finish(entities);
+	}
+	/** The entities in sight, and what the side remembers out of it, as the first seat of a side (or a seat on its own) sees them */
+	seeAll(remembered) {
+		const { world } = this;
+		const entities = [];
+		this.inSight.clear();
+		this.mineNow = this.sideNow ? [] : void 0;
+		for (const entity of world.actors.values()) if (entity.alive && this.knows(entity)) this.see(entity, entities, remembered);
+		for (const entity of this.sceneryInSight()) if (entity.alive && entity.scenery) this.see(entity, entities, remembered);
+		return entities;
+	}
+	/**
+	* What another seat of the side saw this round, as this one sees it: the same, but what may be this player's alone
+	* described again for them. The side's memory is the first seat's to keep
+	*/
+	seeAsSide(seen) {
+		const entities = [...seen.entities];
+		this.inSight.clear();
+		for (const id of seen.inSight) this.inSight.add(id);
+		for (const at of seen.mine) entities[at] = this.describe(this.world.get(entities[at].id));
+		this.wasRevealed = this.observer || this.world.fog.isRevealed(this.team);
+		return entities;
+	}
+	/** The rest of a snapshot, round its entities: the players, and every feature's part (`SnapshotPart`) */
+	finish(entities) {
+		const { world } = this;
+		const players = [];
+		for (const player of world.players.values()) {
+			const state = {
+				id: player.id,
+				name: player.name,
+				team: player.team,
+				color: player.color,
+				neutral: player.neutral,
+				creeps: player.creeps || void 0,
+				...player.race !== void 0 && { race: player.race },
+				defeated: player.defeated,
+				relation: player.id === this.playerId ? "self" : world.areAllies(this.playerId, player.id) ? "ally" : world.areEnemies(this.playerId, player.id) ? "enemy" : "neutral"
+			};
+			if (state.relation === "ally" && !player.neutral && !this.observer) {
+				const me = world.player(this.playerId);
+				state.shared = {
+					control: world.sides.controlOf(this.playerId).includes(player.id),
+					vision: me.team === player.team || world.sides.visionOf(me.team).includes(player.team)
+				};
+			}
+			if (player.id === this.playerId || this.observer && !player.neutral) {
+				state.own = {
+					resources: { ...player.resources },
+					supplyUsed: player.supplyUsed,
+					supplyCap: player.supplyCap,
+					...Object.keys(player.supplies).length > 0 && { supplies: structuredClone(player.supplies) },
+					upkeep: world.rules.economy.upkeep(world, player.id),
+					upgrades: Object.fromEntries(player.upgrades),
+					researching: [...player.researching],
+					tech: [...techOf(world, player.id)],
+					heroes: heroSummaries(world, player.id),
+					objectives: world.objectives.of(player.id).map((objective) => structuredClone(objective)),
+					...world.timers.shownTo(player.id).length && { timers: world.timers.shownTo(player.id) }
+				};
+				if (world.hooks.has("requirement") && player.id === this.playerId) state.own.unlocks = decidedUnlocks(world, player.id);
+				if (world.hooks.has("available") && player.id === this.playerId) {
+					const availability = decidedAvailability(world, player.id);
+					if (availability) state.own.availability = availability;
+				}
+			}
+			players.push(state);
+		}
+		const { view } = this;
+		const snapshot = { tick: world.tick };
+		const parts = world.registry.snapshotParts;
+		const take = (part) => {
+			const value = part.capture(view);
+			if (value !== void 0) snapshot[part.key] = value;
+		};
+		for (const part of parts) if (part.head) take(part);
+		snapshot.entities = entities;
+		snapshot.players = players;
+		for (const part of parts) if (!part.head) take(part);
+		return snapshot;
+	}
+	snapshot() {
+		return this.capture();
+	}
+	/**
+	* Moves the game on by `ticks` at the next update, however fast it goes: a step of a paused game (`speed` 0), as
+	* an editor's Step does. Ticks asked for while it runs are taken on top of its pace
+	*/
+	advance(ticks = 1) {
+		this.accumulator += this.world.dt * Math.max(0, Math.floor(ticks));
+	}
+	/** A save of the world as it stands (`saveWorld`): at once, as a promise for what a session elsewhere answers later */
+	save() {
+		try {
+			return Promise.resolve(saveWorld(this.world));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	/**
+	* Runs the game on by itself, a tick at a time, as fast as the page can, until `until` holds of the world, `most`
+	* ticks have run, the game is over, or `deadline` (`performance.now()`'s) is past: what an editor's "Play to" does a
+	* slice a frame, its pace and `advance` aside. The ticks are the same ticks the game runs at its own pace, so the
+	* same game comes to the same moment. What happened in them is in the next snapshot (`update`), as after a slow frame.
+	* `until` is asked before the first tick too: what holds already runs none
+	*/
+	runUntil(until, options = {}) {
+		const { world } = this;
+		const most = options.most ?? Infinity;
+		const deadline = options.deadline ?? Infinity;
+		let ticks = 0;
+		const over = () => world.failure !== null || world.winner !== null;
+		while (!until(world)) {
+			if (ticks >= most || over()) return this.ran(ticks, false, over());
+			if (ticks % 8 === 7 && performance.now() > deadline) return this.ran(ticks, false, false);
+			this.tickOnce();
+			ticks++;
+		}
+		return this.ran(ticks, true, over());
+	}
+	/** What `runUntil` gives back, the debug tools' view brought up to date where it ran */
+	ran(ticks, reached, over) {
+		if (ticks) {
+			this.debug.refresh();
+			this.ranOn = true;
+		}
+		return {
+			ticks,
+			reached,
+			over
+		};
+	}
+	/** Whether `runUntil` ran ticks since the last update: its next snapshot describes them, paused or not */
+	ranOn = false;
+	/** A tick of the world, and the checkpoint it marked saved as the world stood at its end, not at the end of the frame */
+	tickOnce() {
+		this.world.step();
+		if (this.pendingCheckpoint) {
+			this.checkpoint = {
+				label: this.pendingCheckpoint,
+				save: saveWorld(this.world)
+			};
+			this.pendingCheckpoint = void 0;
+		}
+	}
+	update(dt) {
+		const { world } = this;
+		let stepped = this.ranOn;
+		this.ranOn = false;
+		this.accumulator += dt * this.speed * world.cheats.speed;
+		while (this.accumulator >= world.dt) {
+			this.tickOnce();
+			this.accumulator -= world.dt;
+			stepped = true;
+		}
+		this.alpha = this.speed * world.cheats.speed > 0 ? this.accumulator / world.dt : 1;
+		if (!stepped) return this.view.events.length ? [this.capture()] : [];
+		this.debug.refresh();
+		return [this.capture()];
+	}
+	/** Sends a command. `seq` is the sender's own number for it, for a host passing on what a remote player numbered */
+	send(command, seq = ++this.lastSeq) {
+		this.world.issue({
+			...command,
+			player: this.playerId,
+			seq
+		});
+		return seq;
+	}
+	/**
+	* The number of the last command sent: a computer's seat keeps it through a save, so the commands it sends after a
+	* load are numbered as they would have been
+	*
+	* @beta
+	*/
+	lastSeq = 0;
+	fog() {
+		const { fog } = this.world;
+		const cells = fog.cells(this.team);
+		return {
+			width: fog.width,
+			depth: fog.depth,
+			version: fog.version,
+			revealed: this.observer || fog.isRevealed(this.team) || !cells,
+			visible: cells?.visible ?? /* @__PURE__ */ new Uint8Array(0),
+			explored: cells?.explored ?? /* @__PURE__ */ new Uint8Array(0)
+		};
+	}
+	/** Where the game's money is mined, as the map shows it, seen or not (`GameSession.mines`, `minesFor`) */
+	mines() {
+		return minesFor(this.view);
+	}
+	/** The lanes of the map, as the map shows them (`GameSession.lanes`) */
+	lanes() {
+		return lanesOf(this.world);
+	}
+	/** The camps as the player knows them (`GameSession.camps`, `campsFor`): worked out once a tick */
+	camps() {
+		return campsFor(this.view);
+	}
+	canPlace(unitType, point) {
+		return this.registry.units.has(unitType) && canPlaceStructure(this.world, this.registry.unit(unitType), point, this.playerId, true);
+	}
+	/** Which cells of a building's ground are in the way for the player: taken, or not explored by their team (`placementCells`) */
+	placeCells(unitType, point) {
+		if (!this.registry.units.has(unitType)) return void 0;
+		const { world } = this;
+		const { team } = world.player(this.playerId);
+		return placementCells(this.registry.unit(unitType), point, (x, z) => world.grid.canPlace(x, z, 1, 1), (x, z) => world.fog.isExplored(team, x + .5, z + .5));
+	}
+	findPath(from, to, flying = false) {
+		return (flying ? this.world.air : this.world.nav).findPath(from, to);
+	}
+	/** What happened since the last snapshot, not yet given in one: a copy, for a computer's save */
+	pendingEvents() {
+		return structuredClone(this.view.events);
+	}
+	/** Takes back what `pendingEvents` gave, ahead of what has happened since: in a game loaded from a save */
+	restoreEvents(events) {
+		this.view.events = [...structuredClone(events), ...this.view.events];
+	}
+	/** Whether the world goes with the session */
+	ownsWorld;
+	dispose() {
+		for (const dispose of this.disposers.splice(0)) dispose();
+		this.debug.dispose();
+		if (this.ownsWorld) this.world.dispose();
+	}
+};
+//#endregion
+export { readMessage as _, RemoteDebug as a, bytesByKey as c, paceOf as d, savesOf as f, protocolMismatch as g, isFiniteNumber as h, LocalDebug as i, diff as l, isCommand as m, endSharedCaptures as n, askDebug as o, PROTOCOL_VERSION as p, shareCaptures as r, apply as s, LocalSession as t, quantize as u };
+
+//# sourceMappingURL=local-Dkovq42k.js.map