@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,4701 @@
+import { $ as MissingGround, $c as refund, $l as commandHandled, $n as cinematicCommand, $o as REPATH_SPREAD, $r as defineHookType, $t as playerSlot, $u as xpGained, A as drawFromGroup, Aa as bool, Ac as readyAgain, Ad as inventorySlots, Ai as raceOf, Al as replicateEvent, An as logLine, Ar as allowed, As as defaultPickAttack, At as generateTerrain, Au as missileRemoved, B as fieldOptions, Ba as point, Bc as missingTech, Bd as angleTo, Bl as campCleared, Br as boardOrder, Bs as applyBuff, Bt as BLOCKS_WALK, Bu as projectileSpawned, Ca as fitToPlaces, Cc as xpWorth, Cd as innerEffects, Ci as unlockRefusal, Cl as scaledParts, Cn as withData, Co as waitUntil, Cr as lastTeamStanding, Cs as isShunned, Ct as updateMapTerrain, Cu as leftArea, Da as rowsFormation, Dd as passiveEffects, Di as defineRace, Dn as consoleSink, Dr as shareWith, Ds as spotFor, Dt as WATER_DEEP, Du as messageSent, Ea as noneFormation, Ec as queueOf, Ed as noStats, Ei as checkRaces, El as buffEnded, En as Logger, Er as give, Es as shun, Et as Terrain, Eu as manaChanged, F as tableItems, Fa as list, Fc as availableTo, Fd as orderSays, Fi as nearestId, Fl as attackStarted, Fn as dispelBuffs, Fs as rangeAgainst, Ft as LEGACY_TILESET, Fu as pauseAsked, G as mapPlayerData, Ga as defineEffect, Gc as engineMessage, Gd as distToRect, Gi as castTimeOf, Gl as channelEnded, Gn as takeCorpses, Gr as roomIn, Gs as isRooted, Gt as MAP_NEUTRAL, Gu as rustled, H as mapCampData, Ha as seconds, Hc as sellValue, Hd as closestPointOnRect, Hi as footprintCell, Hl as castStarted, Hn as summonEffects, Hr as cargo, Ht as DEFAULT_MAX_PLAYERS, Hu as resourceChanged, I as DEFAULT_HEIGHTS, Ia as number, Ic as availableToPlayer, Id as spawnStart, Ii as canHarvest, Il as boarded, In as dispelEffects, Is as reaches, It as MAX_TILES, Iu as pinged, J as objectFields, Jc as Player, Jd as lerp, Jl as checkpoint, Jn as autocastCommand, Js as isStunned, Jt as MAX_MAP_SIZE, Ju as unitHired, K as mapRegionData, Ka as effectTargets, Kc as toMessage, Kd as hashInts, Ki as declaredRefusal, Kl as channelStarted, Kn as worthless, Kr as shoreNear, Ks as isSilenced, Kt as MAX_LEVEL, Ku as teamChanged, La as object, Lc as chargesLeft, Ld as startingBase, Li as gathering, Ll as bounty, Ln as Path, Lr as BOARD_REACH, Ls as tooNear, Lt as defineTile, Lu as playerDefeated, Ma as ids, Mc as restoreCharges, Mi as setRace, Ml as teamMemory, Mn as rootLogger, Mr as ping, Ms as farthestReach, Mt as mapTileIds, Mu as morphCancelled, N as groupChoices, Na as index, Nc as abilityReach, Nd as defineComponent, Nl as abilityCast, Nn as coreEffects, Nr as pingKinds, Ns as groundAttack, Nt as playTileset, Nu as morphStarted, Oa as squareFormation, Oc as upgradeOf, Od as upgradesOf, Oi as isAvailable, Ol as SessionView, On as createLogRing, Or as CHAT_LENGTH, Os as ATTACK_STATS, Ot as WATER_NONE, Ou as missed, P as mapDrops, Pa as isObject, Pc as abilityRefusal, Pd as snapshotOf, Pi as editDistance, Pl as abilityImpact, Pn as homeOf, Po as plain, Ps as pickAttack, Pu as objectiveChanged, Qc as pay, Qd as vec2, Qi as validTarget, Ql as cinematicEnded, Qn as cinematicChoiceCommand, Qo as ARRIVE_RANGE, Qr as defineHook, Qs as silences, Qt as createMap, Qu as worldFailed, R as campFields, Ra as oneOf, Rc as costRefusal, Rd as TAU, Rl as buffApplied, Rn as corpseSystem, Ro as UPHILL_MISS, Rr as UNLOAD_REACH, Rs as AURA_LINGER, Rt as tileRemap, Ru as playerSurrendered, Sa as coreFormations, Sd as hourOf, Sl as formatNumber, Sn as valueAt, So as waitFor, Ss as isCrowded, St as tilesFor, Su as itemPicked, Ta as formationPoints, Tc as productionQueue, Td as isScenery, Ti as RANDOM_RACE, Tn as LOG_LEVELS, To as defineTimer, Tr as exchange, Ts as roomFor, Tt as profileReach, Tu as lineSaid, U as mapFields, Ua as string, Uc as targetRefusal, Ud as dist, Ul as cellsChanged, Un as summonHooks, Uo as canAttack, Ur as garrisonHooks, Us as hasBuff, Ut as MAP_CREEPS, Uu as resourcesDeposited, Va as rgb, Vc as requirementRefusal, Vd as clamp, Vi as BuildGrid, Vl as campReturned, Vn as illusion, Vo as attackReaches, Vr as canBoard, Vs as avoids, Vt as BRIDGE, Vu as researchFinished, W as mapObjectData, Wa as text, Wc as trainRefusal, Wd as distSq, Wi as castRange, Wl as cellsSeen, Wn as summoned, Wr as loadOrder, Ws as isCrowdControl, Wt as MAP_FORMAT, Wu as resourcesSpent, X as reachedByDefault, Xc as earn, Xd as rotateTowards, Xi as notReady, Xl as cinematicChoice, Xn as cancelTrainCommand, Xr as unloadOrder, Xs as removeBuff, Xt as PLAYER_COLORS, Xu as unloaded, Y as playerFields, Yc as currencyOf, Yd as lerpAngle, Yi as isSpell, Yl as chopped, Yn as cancelConstructionCommand, Yo as fireOnTheMove, Yr as unload, Ys as layerOf, Yt as MIN_MAP_SIZE, Yu as unitTrained, Z as regionFields, Za as startDash, Zc as giveBack, Zd as smoothstep, Zi as targetFacts, Zl as cinematicCued, Zn as castCommand, Zo as shootsUphill, Zs as shieldOf, Zt as RAMP_REACH, Zu as worked, _a as spendCharge, _c as reviveCost, _d as anyEffect, _l as underConstruction, _n as redefineIn, _o as defineSequence, _s as engageLayer, _t as unpackBytes, _u as heroLevelUp, aa as buy, ac as defaultHeroRules, ad as replicatedEvents, af as sin, ai as placementProblem, al as distanceToEdge, an as copyDefinition, ar as orderCommand, as as moveTo, at as groundHash, au as effectStarted, ba as FORMATION_GAP, bd as constructionOf, bi as morph, bl as abilityValues, bn as restoreRedefinitions, br as pausesLeft, bs as engagedWith, bt as mapCell, bu as inventoryChanged, ca as dropOnGround, cc as heroOfState, cd as cooldownOf, ci as siteOf, cl as fighting, cn as definitionIn, co as cueCinematic, cs as setAnchored, ct as savedGround, cu as entityDied, dc as heroesOf, dd as refreshVitals, dl as constructionSite, dn as editableValues, dr as smartCommand, ds as stepAside, dt as terrainPatch, du as entitySpawned, ea as createOrder, el as shortOf, en as COPY_OF, er as coreCommands, es as faceTowards, et as applyTerrainPatch, eu as commandRejected, fa as pickUp, fc as learn, fd as resisted, fn as effectFields, fr as stopCommand, fs as SHUN_TIME, ft as terrainPatchProblem, fu as environmentChanged, ga as shopStock, gc as respawning, gd as aimOf, gn as nested, gr as upgradeBuildingCommand, gs as defaultEngageRoom, gt as packBytes, gu as healed, ha as shopNear, hc as respawnIn, hd as CORE_STAT_KEYS, hi as upgradeLevel, hn as mergeValues, ho as Sequences, hr as trainCommand, hs as defaultEngageLayer, ht as saveTerrain, hu as groundReshaped, ia as atShop, ic as canLearn, if as hypot, ii as placementCells, il as detection, in as blankDefinition, is as makeWay, it as groundDifference, iu as damaged, j as drawFromTable, ja as id, jd as slotsOf, jl as snapshotPart, jn as rootConsole, jr as chat, js as farthestAcquisition, jt as Rng, ju as missileSpawned, ka as Invalid, kd as freeSlot, kn as errorFields, kr as PING_KINDS, ks as attackStat, kt as WATER_SHALLOW, ku as missileHit, la as findItem, lc as heroState, ld as invalidateStats, ll as moving, ln as definitionsIn, lo as playCinematic, lr as rallyCommand, ls as setGhost, lt as startedOn, lu as entityMorphed, ma as sell, mc as maxLevelOf, md as swingTiming, mn as fitValue, ms as bandOf, mt as loadTerrain, mu as gameOver, na as REACH, nc as scaled, nd as defineListener, nf as exactMath, ni as canRepair, nl as Entity, nn as NEW_DEFINITION, ns as isMovingTo, nt as findGround, nu as constructionFinished, oa as createItem, oc as grantXp, od as attackTiming, ol as edgeDistance, on as dataRulesProblem, oo as cinematic, os as moveToEntity, ot as groundOf, ou as effectStopped, pa as priceOf, pc as levelNeeded, pd as statsOf, pn as effectTypesOf, pr as surrenderCommand, ps as attackersOf, pt as withChanges, pu as exchanged, q as mapThings, qi as fire, ql as chatted, qn as attackCommand, qs as isSpellImmune, qt as MAX_MAP_PLAYERS, qu as traded, ra as SHOP_RANGE, rc as HEROES, rd as eventById, rl as deposit, rn as REQUIRED_FIELDS, ro as dashing, rs as lookAhead, rt as groundBase, ru as constructionStarted, sc as heroOf, sd as changedStats, sl as exposure, sn as definitionChanged, so as cinematicCue, sr as pauseCommand, st as isGroundChanges, su as enteredArea, ta as giveOrder, tc as casterFacts, td as defineEvent, tf as cos, ti as canPlaceStructure, tl as spend, tn as DATA_KINDS, tr as defineCommand, ts as halt, tt as cloneTerrain, tu as constructionCancelled, ua as giveItem, ud as mitigation, ui as playerFacts, ul as builtSoFar, un as editableFields, uo as regionCinematic, ur as researchCommand, us as standsInWay, ut as startingTerrain, uu as entityRemoved, va as takeItem, vc as reviveHero, vd as at, vi as meets, vl as STAT_WORDS, vn as redefinitions, vr as askPause, vs as engageWith, vt as adoptTileset, vu as heroRevived, wa as formationContext, wc as productionOf, wd as isNight, wi as unlocked, wl as valueText, wn as withValues, wo as Timers, ws as release, wt as PROFILE_SMOOTH, wu as lineEnded, xa as circleFormation, xd as footprintOf, xi as techOf, xl as describeAbility, xo as wait, xr as surrender, xs as isBlocked, xt as mapTerrain, xu as itemDropped, yc as setHeroLevel, yd as baseStats, yi as missing, yl as abilityText, yn as removeDefinition, ys as engagedLike, yt as blockByDoodads, yu as impact, z as defineMapField, za as optional, zc as gathers, zd as angleDiff, zi as harvesterOf, zl as buffRemoved, zn as corpses, zr as board, zt as BLOCKS_BUILD, zu as projectileRemoved } from "./debugCommands-CzjrSm66.js";
+import { $ as siteWords, A as withConcealment, B as isMadeOf, C as patrolPathOrder, D as viewLevel, E as expose, F as ModError, G as defaultRules, H as satisfies, I as composeGame, J as groundSpeedOfCell, K as resolveRules, L as compositionOf, M as cellsIn, N as defineCellLayer, O as coreHooks, Q as siteKey, R as defineMod, S as followPathOrder, T as EXPOSED_FOR, U as checkDamageTable, V as recompose, W as damageMultiplier, Z as upkeepOf, _ as FogOfWar, a as createWorldFromMap, b as UnlistedError, c as World, d as prefabsFrom, f as spawnPrefab, g as FOG_VISIBLE, h as FOG_UNEXPLORED, i as createWorld, j as cellLayerValues, k as patchAt, l as definePrefab, m as FOG_EXPLORED, n as coreSystems, o as loadWorld, q as groundSpeedAt, r as createRegistry, s as maxPlayersOf, t as assembleGame, u as nestedPartId, v as MAX_FOG_TEAMS, w as SizedNavigation, x as attackPathOrder, y as Registry, z as gameHash } from "./game-DiJEN-Ks.js";
+import { $ as ENTITY_DERIVED, A as mapLanes, At as tunings, B as captureAreaOf, C as LANE_SPAWNER_KIND, Cn as shapeReach, D as heroStrike, Dt as defineTunable, E as defaultWave, Et as spawnCamp, F as lastHitsOf, Ft as setGate, G as capturesOf, Gt as defineStat, H as capturePoint, I as mayDeny, K as capturing, Kt as engineStats, L as withLastHits, Lt as WorldMap, M as wavesSent, Mt as gateChanged, N as withLanes, Nt as gateStates, O as laneMinion, Ot as tunableChanged, P as denying, Pt as isGateOpen, R as CAPTURE_FIELDS, S as LANE_SPAWNER_FIELDS, Sn as shapeBounds, St as camps, T as coreVictory, Tt as respawnCamp, U as captured, V as captureOf, W as captures, Wt as Score, X as Scheduler, Y as PHASES, Yt as scoreData, Zt as scoreOn, _ as pileType, _n as defineArea, _t as campHooks, a as rankOf, b as LANE_END_REACH, bn as shapeAsBox, bt as campNamed, c as withVeterancy, ct as saveWorld, d as stance, dn as talk, dt as SidePaths, en as Objectives, et as ENTITY_SAVE, f as stanceCommand, ft as sideKnowledge, g as pileTaken, h as pileOf, hn as areaShapeOf, ht as DEFAULT_AVOIDANCE, i as grantVeterancy, in as playEffect, it as encodeSave, j as sendWave, jt as withTuning, k as lanesOf, kt as tuneCommand, l as DEFAULT_STANCE, ln as Dialog, m as withStances, mn as Areas, mt as AVOIDANCE_LEVELS, nn as objectiveVictory, nt as SaveError, o as rankedUp, on as stopEffect, ot as saveHeader, p as stanceOf, q as withCapture, qt as presetScore, r as VETERANCY_RANKS, rt as decodeSave, s as veterancy, st as saveProblem, tn as defineObjective, tt as SAVE_FORMAT, u as STANCES, un as LINE_SECONDS, ut as updateSave, v as rubbleType, vn as inShape, vt as campLayout, w as checkLanes, wt as campsOf, x as LANE_SPAWNERS, xn as shapeAt, xt as campRespawnSystem, y as withRemains, yn as shapeArea, yt as campMember, z as CAPTURE_KIND } from "./coreComponents-syuh2fPG.js";
+import { a as navigationData, c as serveNavigationBuilds, i as memoryNavigationCache, o as navigationKey, s as navigationWorker, t as buildNavigationData } from "./builds-C6LfgvEU.js";
+import { a as missionRulesOf, c as tellRules, d as checkMapObjectives, f as giveMapObjective, h as mapObjectivesOf, i as missionRuleState, l as MAP_OBJECTIVES, m as mapObjectives, n as MISSION_RULES, p as mapObjectivePlayers, r as checkMissionRules, s as ruleFired, t as MAP_RULES_KEY, u as MAP_OBJECTIVES_KEY } from "./missionRules-C-bGxm0Q.js";
+import { A as connectAs, C as randomSeed, D as SessionHost, E as RemoteSession, F as readHostMessage, I as readPlayerMessage, M as loopback, N as toRuns, O as SessionRefused, P as isServerMessage, S as tilingNoise, _ as tilesPass, a as packsOf, b as mapCells, c as generateMap, d as resourcesPass, f as roadsPass, g as terrainPass, h as symmetricPlaces, i as packFromJson, j as fromRuns, k as connect, l as nearestDryGround, m as startsPass, n as checkPack, o as basinShape, p as scatterPass, r as checkPackSchema, s as clearGround, t as PackError, u as presetGenerator, v as MAP_RULES, w as delayed, x as layeredNoise, y as checkMap } from "./packs-g5thvmGn.js";
+import { _ as hirerAt, c as makeHero, d as hireCommand, f as learnCommand, g as hireRefusal, h as hire, i as worldFingerprint, l as buyCommand, m as sellCommand, p as reviveCommand, r as saveDifference, s as withHeroes, u as heroCommands } from "./determinism-BCymQwiE.js";
+import { _ as readMessage, d as paceOf, f as savesOf, g as protocolMismatch, h as isFiniteNumber, l as diff, m as isCommand, p as PROTOCOL_VERSION, s as apply, t as LocalSession, u as quantize } from "./local-Dkovq42k.js";
+//#region src/map/schema.ts
+/**
+* Every field of a map, in the order its file has them (`format` before them, what the reader does not know of the
+* file before that). `satisfies` checks that none of `GameMap` is left out
+*
+* @internal
+*/
+var MAP_FIELDS = [
+	{
+		key: "name",
+		kind: "text",
+		written: "always",
+		empty: () => "Untitled"
+	},
+	{
+		key: "description",
+		kind: "text",
+		written: "always",
+		empty: () => ""
+	},
+	{
+		key: "game",
+		kind: "text",
+		written: "defined"
+	},
+	{
+		key: "width",
+		kind: "number",
+		written: "always",
+		required: true
+	},
+	{
+		key: "depth",
+		kind: "number",
+		written: "always",
+		required: true
+	},
+	{
+		key: "cliffHeight",
+		kind: "number",
+		written: "always",
+		empty: () => 3
+	},
+	{
+		key: "ground",
+		kind: "layer",
+		written: "always",
+		required: true,
+		perVertex: true,
+		what: "the ground"
+	},
+	{
+		key: "levels",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the levels"
+	},
+	{
+		key: "ramps",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the ramps"
+	},
+	{
+		key: "water",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the water"
+	},
+	{
+		key: "tiles",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the paint"
+	},
+	{
+		key: "cells",
+		kind: "layers",
+		written: "filled"
+	},
+	{
+		key: "pathing",
+		kind: "mask",
+		written: "filled",
+		what: "what is kept off cells"
+	},
+	{
+		key: "tileset",
+		kind: "names",
+		written: "always",
+		required: true,
+		what: "the tileset"
+	},
+	{
+		key: "players",
+		kind: "list",
+		written: "always",
+		required: true,
+		byId: true
+	},
+	{
+		key: "objects",
+		kind: "list",
+		written: "always",
+		required: true,
+		byId: true
+	},
+	{
+		key: "camps",
+		kind: "list",
+		written: "always",
+		required: true,
+		byId: true
+	},
+	{
+		key: "regions",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "points",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "paths",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "doodads",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "cameras",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "randomGroups",
+		kind: "list",
+		written: "filled"
+	},
+	{
+		key: "itemTables",
+		kind: "list",
+		written: "filled"
+	},
+	{
+		key: "forces",
+		kind: "list",
+		written: "filled"
+	},
+	{
+		key: "races",
+		kind: "names",
+		written: "filled"
+	},
+	{
+		key: "author",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "silence",
+		kind: "names",
+		written: "filled"
+	},
+	{
+		key: "meantFor",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "explored",
+		kind: "boolean",
+		written: "defined"
+	},
+	{
+		key: "loading",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "preview",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "environment",
+		kind: "object",
+		written: "filled"
+	},
+	{
+		key: "definitions",
+		kind: "object",
+		written: "filled",
+		plain: true
+	},
+	{
+		key: "generated",
+		kind: "object",
+		written: "defined"
+	},
+	{
+		key: "day",
+		kind: "object",
+		written: "filled"
+	},
+	{
+		key: "bounds",
+		kind: "object",
+		written: "defined"
+	},
+	{
+		key: "data",
+		kind: "object",
+		written: "filled",
+		empty: () => ({}),
+		plain: true
+	},
+	{
+		key: "editor",
+		kind: "object",
+		written: "filled",
+		plain: true
+	}
+];
+/** The fields as specs, for what walks them */
+var MAP_FIELD_SPECS = MAP_FIELDS;
+/** What a reader of this format knows in a file: `format` and every field. The rest is carried along (`GameMap.extra`) */
+var KNOWN = /* @__PURE__ */ new Set(["format", ...MAP_FIELDS.map((field) => field.key)]);
+/** The fields of a kind */
+var fieldsOf = (...kinds) => MAP_FIELD_SPECS.filter((field) => kinds.includes(field.kind));
+/** The lists of things with ids: merged thing by thing (`mergeMaps`), an entry to a line (`mapText`) */
+var BY_ID$1 = MAP_FIELD_SPECS.filter((field) => field.byId).map((field) => field.key);
+/** The layers of the ground every map has: merged cell by cell (`mergeMaps`), a row to a line (`mapText`) */
+var LAYERS$1 = fieldsOf("layer").map((field) => field.key);
+//#endregion
+//#region src/map/file.ts
+var isObject$1 = (value) => typeof value === "object" && value !== null;
+/** The steps from each format to the one after it, by the format they start from */
+var MIGRATIONS = {
+	1: (file) => ({
+		...file,
+		tileset: [...LEGACY_TILESET]
+	}),
+	2: (file) => {
+		const width = Number(file.width);
+		const depth = Number(file.depth);
+		const split = (key, count, bytes) => {
+			const packed = file[key];
+			const whole = typeof packed === "string" ? unpackBytes(packed, count * bytes) : void 0;
+			return whole ? rowsOf(whole, bytes) : packed;
+		};
+		return {
+			...file,
+			ground: split("ground", depth + 1, (width + 1) * 4),
+			levels: split("levels", depth, width),
+			ramps: split("ramps", depth, width),
+			water: split("water", depth, width),
+			tiles: split("tiles", depth, width)
+		};
+	}
+};
+/** The layers of cells of a map with anything in them, as the file has them: none when there are none */
+function mapCells$1(map) {
+	const layers = Object.entries(map.cells ?? {}).filter(([, cells]) => cells.some((value) => value !== 0));
+	return layers.length ? Object.fromEntries(layers.sort(([a], [b]) => a < b ? -1 : 1).map(([id, cells]) => [id, rowsOf(cells, map.width)])) : void 0;
+}
+/** Bytes as a line of text for each row of `bytes` of them */
+function rowsOf(bytes, row) {
+	const lines = [];
+	for (let at = 0; at < bytes.length; at += row) lines.push(pack(bytes.subarray(at, at + row)));
+	return lines;
+}
+/**
+* A map file brought up to the format this reader knows, step by step. Throws for what is not a map file, and for
+* one of a newer format: what changed in it cannot be known here. `to` and `steps` are the reader's own when left out
+*
+* @beta
+*/
+function migrateMap(data, to = 3, steps = MIGRATIONS) {
+	if (!isObject$1(data)) throw new Error("Map file: not a map");
+	let file = data;
+	const format = file.format;
+	if (typeof format !== "number" || !Number.isInteger(format) || format < 1) throw new Error(`Map file: format ${String(format)} is not one this game reads`);
+	if (format > to) throw new Error(`Map file: format ${format} is newer than this game reads (${to}): it was saved by a newer version of the editor`);
+	for (let from = format; from < to; from++) {
+		const step = steps[from];
+		if (!step) throw new Error(`Map file: there is no way from format ${from} to ${from + 1}`);
+		file = {
+			...step(file),
+			format: from + 1
+		};
+	}
+	return file;
+}
+var pack = packBytes;
+function unpack(text, length, what) {
+	const bytes = unpackBytes(text, length);
+	if (!bytes) throw new Error(`Map file: ${what} does not match the size of the map`);
+	return bytes;
+}
+/** Whether a value holds anything: text not empty, a list or an object with something in it, a layer with a cell set */
+function filled(value) {
+	if (value === void 0 || value === null || value === "" || value === false) return false;
+	if (value instanceof Uint8Array) return value.some((each) => each !== 0);
+	if (Array.isArray(value)) return value.length > 0;
+	if (typeof value === "object") return Object.keys(value).length > 0;
+	return true;
+}
+/** The bytes of a layer, and how many to a row: the heights by corner (four bytes each), the rest by cell */
+function layerBytes(map, field, layer) {
+	return field.perVertex ? {
+		bytes: new Uint8Array(layer.buffer, layer.byteOffset, layer.byteLength),
+		row: (map.width + 1) * 4
+	} : {
+		bytes: layer,
+		row: map.width
+	};
+}
+/** A field as its file has it, or none where the file leaves it out (`MapFieldSpec.written`) */
+function written(map, field) {
+	const value = map[field.key];
+	if (field.written === "defined" && value === void 0) return void 0;
+	if (field.kind === "layers") return mapCells$1(map);
+	if (field.written === "filled" && !filled(value)) return void 0;
+	switch (field.kind) {
+		case "layer":
+		case "mask": {
+			const { bytes, row } = layerBytes(map, field, value);
+			return rowsOf(bytes, row);
+		}
+		case "names": return field.written === "filled" ? [...value] : value;
+		case "object": return field.plain ? plain(value, field.key, "Map", "keep numbers, text, lists and plain objects with a map") : value;
+		default: return value;
+	}
+}
+/**
+* A map as its file. Throws when what the game keeps with it (`data`) is not plain data, saying where
+*
+* @beta
+*/
+function serializeMap(map) {
+	const file = {
+		...map.extra,
+		format: 3
+	};
+	for (const field of MAP_FIELD_SPECS) {
+		const value = written(map, field);
+		if (value === void 0 || field.kind === "object" && field.written === "filled" && !filled(value)) continue;
+		file[field.key] = value;
+	}
+	return file;
+}
+/**
+* The maps of map files, by the name of each file without its folder and `.vgmap.json`: `./maps/field.vgmap.json` is
+* `field`. The files by their paths, read (`parseMap`): imported one by one, or Vite's
+* `import.meta.glob('./maps/*.vgmap.json', { eager: true, import: 'default' })` where only a page reads them
+*
+*     export const maps = mapsFrom({ './maps/field.vgmap.json': field, './maps/hills.vgmap.json': hills })
+*
+* Throws for two files of one name, and with the path of a file that cannot be read
+*
+* @beta
+*/
+function mapsFrom(files) {
+	const maps = {};
+	for (const [path, file] of Object.entries(files)) {
+		const name = (path.split("/").pop() ?? path).replace(/\.vgmap\.json$|\.json$/, "");
+		if (name in maps) throw new Error(`mapsFrom: two files are named "${name}"`);
+		try {
+			maps[name] = parseMap(file);
+		} catch (error) {
+			throw new Error(`${path}: ${error.message}`);
+		}
+	}
+	return maps;
+}
+/**
+* Reads a map file, of this format or an older one. Throws with what is wrong with it
+*
+* @beta
+*/
+function parseMap(file) {
+	const data = migrateMap(file);
+	const width = Number(data.width);
+	const depth = Number(data.depth);
+	const inRange = (size) => Number.isInteger(size) && size >= 8 && size <= 512;
+	if (!inRange(width) || !inRange(depth)) throw new Error(`Map file: the size is out of range, between 8 and 512 cells each way`);
+	/** A layer of the ground as its rows have it, back in one piece: `bytes` to a row */
+	const rows = (lines, count, bytes, what) => {
+		if (!Array.isArray(lines) || lines.length !== count || lines.some((line) => typeof line !== "string")) throw new Error(`Map file: ${what} does not match the size of the map`);
+		const whole = new Uint8Array(count * bytes);
+		lines.forEach((line, row) => whole.set(unpack(line, bytes, what), row * bytes));
+		return whole;
+	};
+	const layer = (field, lines, what = field.what ?? field.key) => field.perVertex ? new Float32Array(rows(lines, depth + 1, (width + 1) * 4, what).buffer) : rows(lines, depth, width, what);
+	/** A list's entries, each an object, with an id where the list is of things with ids (`byId`) */
+	const entries = (field, list) => {
+		list.forEach((entry, at) => {
+			if (!isObject$1(entry) || Array.isArray(entry)) throw new Error(`Map file: ${field.key}[${at}] is not an object`);
+			if (field.byId && !Number.isFinite(entry.id)) throw new Error(`Map file: ${field.key}[${at}] has no id`);
+		});
+		return list;
+	};
+	const map = {};
+	for (const field of MAP_FIELD_SPECS) {
+		const value = data[field.key];
+		let read;
+		switch (field.kind) {
+			case "text":
+				read = typeof value === "string" ? value : void 0;
+				break;
+			case "number":
+				read = field.key === "width" ? width : field.key === "depth" ? depth : Number(value) || void 0;
+				break;
+			case "boolean":
+				read = typeof value === "boolean" ? value : void 0;
+				break;
+			case "layer":
+				read = layer(field, value);
+				break;
+			case "mask":
+				read = value === void 0 ? void 0 : layer(field, value);
+				break;
+			case "layers":
+				read = isObject$1(value) ? Object.fromEntries(Object.keys(value).map((id) => [id, layer(field, value[id], `the cells of ${id}`)])) : void 0;
+				break;
+			case "names":
+				if (field.required) {
+					if (!Array.isArray(value)) throw new Error(`Map file: ${field.key} is missing`);
+					if (value.length > 255 || value.some((id) => typeof id !== "string")) throw new Error("Map file: the tileset is not a list of tile names");
+					read = value;
+				} else read = Array.isArray(value) ? value.filter((name) => typeof name === "string") : void 0;
+				break;
+			case "list":
+				if (field.required && !Array.isArray(value)) throw new Error(`Map file: ${field.key} is missing`);
+				read = Array.isArray(value) ? entries(field, value) : void 0;
+				break;
+			case "object": read = isObject$1(value) && !(field.plain && Array.isArray(value)) ? value : void 0;
+		}
+		if (read === void 0) read = field.empty?.();
+		if (read !== void 0) map[field.key] = read;
+	}
+	map.objects = map.objects.map((object) => ({
+		...object,
+		scale: object.scale ?? 1
+	}));
+	const extra = Object.fromEntries(Object.entries(data).filter(([key]) => !KNOWN.has(key)));
+	if (Object.keys(extra).length > 0) map.extra = extra;
+	return map;
+}
+/** A copy of a field's value that shares nothing with it */
+function copied(field, value) {
+	switch (field.kind) {
+		case "layer":
+		case "mask": return value.slice();
+		case "layers": return Object.fromEntries(Object.entries(value).map(([id, cells]) => [id, cells.slice()]));
+		case "names": return [...value];
+		case "list":
+		case "object": return structuredClone(value);
+		default: return value;
+	}
+}
+/**
+* A copy that shares nothing with the original
+*
+* @beta
+*/
+function cloneMap(map) {
+	const copy = { ...map };
+	for (const field of MAP_FIELD_SPECS) {
+		const value = map[field.key];
+		if (value !== void 0) copy[field.key] = copied(field, value);
+	}
+	return copy;
+}
+/**
+* The map without what its editor keeps of its own (`GameMap.editor`): what a game is given to play. The very map
+* where it has none
+*
+* @beta
+*/
+function withoutEditor(map) {
+	if (!map.editor) return map;
+	const { editor: _, ...rest } = map;
+	return rest;
+}
+//#endregion
+//#region src/map/resize.ts
+/**
+* A map grown or cut on any side: the ground, cliffs, water and paint go on as they were at the old edge where it
+* grows; everything on it moves along, and what is no longer on the map is gone. The map itself is left as it was.
+* What the engine keeps moves (objects, camps, regions, points, paths, doodads, cameras, the players' starts, the bounds,
+* the game's own kinds' things in `data`); what others keep moves with the `resizers` given (the client's looks:
+* `mapLooksResizer`)
+*
+* @beta
+*/
+function resizeMap(map, sides, resizers = []) {
+	const { left, right, top, bottom } = sides;
+	const width = map.width + left + right;
+	const depth = map.depth + top + bottom;
+	if (width < 8 || depth < 8 || width > 512 || depth > 512) throw new Error(`A map is between 8 and 512 cells each way, not ${width} × ${depth}`);
+	const copy = cloneMap(map);
+	const layer = (old, oldRow, oldColumn, row, column) => {
+		const out = new old.constructor(row * column);
+		for (let z = 0; z < column; z++) {
+			const from = clamp(z - top, 0, oldColumn - 1) * oldRow;
+			for (let x = 0; x < row; x++) out[z * row + x] = old[from + clamp(x - left, 0, oldRow - 1)];
+		}
+		return out;
+	};
+	copy.width = width;
+	copy.depth = depth;
+	const grown = (old, perVertex = false) => perVertex ? layer(old, map.width + 1, map.depth + 1, width + 1, depth + 1) : layer(old, map.width, map.depth, width, depth);
+	const into = copy;
+	for (const field of fieldsOf("layer", "mask", "layers")) {
+		const value = map[field.key];
+		if (!value) continue;
+		into[field.key] = field.kind === "layers" ? Object.fromEntries(Object.entries(value).map(([id, cells]) => [id, grown(cells)])) : grown(value, field.perVertex);
+	}
+	const on = (p) => p.x >= 0 && p.z >= 0 && p.x <= width && p.z <= depth;
+	const moved = (p) => ({
+		...p,
+		x: p.x + left,
+		z: p.z + top
+	});
+	const inside = (p) => ({
+		...p,
+		x: clamp(p.x, 0, width),
+		z: clamp(p.z, 0, depth)
+	});
+	const shape = (shape) => {
+		if (shape.kind !== "rect") {
+			const center = moved(shape);
+			return on(center) ? center : void 0;
+		}
+		const x0 = Math.max(shape.x - shape.width / 2 + left, 0);
+		const z0 = Math.max(shape.z - shape.depth / 2 + top, 0);
+		const x1 = Math.min(shape.x + shape.width / 2 + left, width);
+		const z1 = Math.min(shape.z + shape.depth / 2 + top, depth);
+		return x1 > x0 && z1 > z0 ? {
+			...shape,
+			x: (x0 + x1) / 2,
+			z: (z0 + z1) / 2,
+			width: x1 - x0,
+			depth: z1 - z0
+		} : void 0;
+	};
+	copy.objects = copy.objects.map((object) => ({
+		...object,
+		...moved(object)
+	})).filter(on);
+	copy.camps = copy.camps.map((camp) => ({
+		...camp,
+		...moved(camp)
+	})).filter(on);
+	copy.points = copy.points.map((point) => ({
+		...point,
+		...moved(point)
+	})).filter(on);
+	copy.doodads = copy.doodads.map((doodad) => ({
+		...doodad,
+		...moved(doodad)
+	})).filter(on);
+	copy.cameras = copy.cameras.map((camera) => ({
+		...camera,
+		...inside(moved(camera))
+	}));
+	copy.paths = copy.paths.map((path) => ({
+		...path,
+		points: path.points.map((p) => inside(moved(p)))
+	}));
+	copy.players = copy.players.map((player) => {
+		if (!player.start) return player;
+		const start = moved(player.start);
+		const { start: _, ...rest } = player;
+		return on(start) ? {
+			...player,
+			start
+		} : rest;
+	});
+	copy.regions = copy.regions.flatMap((region) => {
+		const moved = shape(region.shape);
+		return moved ? [{
+			...region,
+			shape: moved
+		}] : [];
+	});
+	for (const [kind, kept] of Object.entries(copy.data)) if (Array.isArray(kept) && kept.length && kept.every(isThing)) copy.data[kind] = kept.map((thing) => moved(thing)).filter(on);
+	if (map.bounds) {
+		const x = Math.max(map.bounds.x + left, 0);
+		const z = Math.max(map.bounds.z + top, 0);
+		const bounds = {
+			x,
+			z,
+			width: Math.min(map.bounds.x + left + map.bounds.width, width) - x,
+			depth: Math.min(map.bounds.z + top + map.bounds.depth, depth) - z
+		};
+		if (bounds.width > 0 && bounds.depth > 0) copy.bounds = bounds;
+		else delete copy.bounds;
+	}
+	const resize = {
+		sides,
+		width,
+		depth,
+		moved,
+		on,
+		inside,
+		shape
+	};
+	for (const resizer of resizers) resizer(copy, resize);
+	return copy;
+}
+/** A thing of a game's own kind, as `mapThings` reads one: an id, and a place */
+var isThing = (thing) => typeof thing === "object" && thing !== null && Number.isInteger(thing.id) && Number.isFinite(thing.x) && Number.isFinite(thing.z);
+//#endregion
+//#region src/map/images.ts
+/**
+* Heights from the pixels of a picture (RGBA, as a canvas gives them): dark is `low`, light is `high`, the picture
+* stretched over the corners of the map's ground. A heightmap made elsewhere, read into a map
+*
+* @beta
+*/
+function heightsFromPixels(pixels, imageWidth, imageHeight, map, low, high) {
+	const row = map.width + 1;
+	const ground = new Float32Array(row * (map.depth + 1));
+	const at = (x, y) => {
+		const i = (clamp(y, 0, imageHeight - 1) * imageWidth + clamp(x, 0, imageWidth - 1)) * 4;
+		return (pixels[i] * .299 + pixels[i + 1] * .587 + pixels[i + 2] * .114) / 255;
+	};
+	for (let iz = 0; iz <= map.depth; iz++) for (let ix = 0; ix <= map.width; ix++) {
+		const fx = ix / map.width * (imageWidth - 1);
+		const fy = iz / map.depth * (imageHeight - 1);
+		const x = Math.floor(fx);
+		const y = Math.floor(fy);
+		const tx = fx - x;
+		const ty = fy - y;
+		const top = at(x, y) * (1 - tx) + at(x + 1, y) * tx;
+		const bottom = at(x, y + 1) * (1 - tx) + at(x + 1, y + 1) * tx;
+		ground[iz * row + ix] = low + (top * (1 - ty) + bottom * ty) * (high - low);
+	}
+	return ground;
+}
+/**
+* The heights of a terrain as the pixels of a picture (RGBA), a pixel a corner: the lowest black, the highest white
+*
+* @beta
+*/
+function heightsToPixels(heights, width, depth) {
+	let low = Infinity;
+	let high = -Infinity;
+	for (const h of heights) {
+		low = Math.min(low, h);
+		high = Math.max(high, h);
+	}
+	const span = high - low || 1;
+	const pixels = new Uint8ClampedArray((width + 1) * (depth + 1) * 4);
+	for (let i = 0; i < heights.length; i++) {
+		const value = Math.round((heights[i] - low) / span * 255);
+		pixels.set([
+			value,
+			value,
+			value,
+			255
+		], i * 4);
+	}
+	return {
+		pixels,
+		low,
+		high
+	};
+}
+//#endregion
+//#region src/mapFile.ts
+/** The order the parts of a map come in in its file. What is not listed comes after, by name */
+var PARTS = [
+	"format",
+	"name",
+	"description",
+	"author",
+	"meantFor",
+	"loading",
+	"explored",
+	"silence",
+	"game",
+	"width",
+	"depth",
+	"cliffHeight",
+	"data",
+	"editor",
+	"players",
+	"regions",
+	"points",
+	"paths",
+	"doodads",
+	"cameras",
+	"randomGroups",
+	"itemTables",
+	"definitions",
+	"forces",
+	"races",
+	"environment",
+	"day",
+	"camps",
+	"objects",
+	"tileset",
+	"preview"
+];
+/** The layers come last: lines nobody reads, a row of the ground to each (the map's table says which: `MAP_FIELDS`) */
+var LAYERS = [...fieldsOf("layer", "layers").map((field) => field.key)];
+/** Lists with one entry to a line, in the order of their ids */
+var LISTS = new Set(BY_ID$1);
+/** The order of what an entry holds. What is not listed comes after, by name */
+var FIELDS = [
+	"id",
+	"name",
+	"type",
+	"owner",
+	"team",
+	"color",
+	"race",
+	"start",
+	"x",
+	"z",
+	"facing",
+	"scale",
+	"look",
+	"units",
+	"shape",
+	"points",
+	"width",
+	"paint",
+	"keepClear",
+	"profile",
+	"health",
+	"mana",
+	"level",
+	"abilities",
+	"items",
+	"amount",
+	"underConstruction",
+	"lifetime",
+	"orders",
+	"data"
+];
+/** The keys of something in a set order: those listed first, in that order, then the rest by name */
+function inOrder(value, first) {
+	const keys = Object.keys(value);
+	return [...first.filter((key) => keys.includes(key)), ...keys.filter((key) => !first.includes(key)).sort()];
+}
+var entryText = (entry) => `{ ${inOrder(entry, FIELDS).filter((key) => entry[key] !== void 0).map((key) => `${JSON.stringify(key)}: ${JSON.stringify(entry[key])}`).join(", ")} }`;
+/**
+* A map as the text of its file, written to be read by a person comparing two versions of it: every part on a line
+* of its own in a set order, one object to a line in the order of their ids with what each holds in a set order
+* too, and the layers last. Moving one object changes one line, whatever was done before
+*
+* @beta
+*/
+function mapText(map) {
+	const file = serializeMap(map);
+	return `{\n${inOrder(file, [...PARTS, ...LAYERS]).sort((a, b) => Number(LAYERS.includes(a)) - Number(LAYERS.includes(b))).map((key) => {
+		const value = file[key];
+		if (key === "cells" && value && typeof value === "object") return `\t"cells": {\n${Object.entries(value).map(([id, rows]) => `\t\t${JSON.stringify(id)}: [\n${rows.map((row) => `\t\t\t${JSON.stringify(row)}`).join(",\n")}\n\t\t]`).join(",\n")}\n\t}`;
+		if (LAYERS.includes(key) && Array.isArray(value)) return `\t${JSON.stringify(key)}: [\n${value.map((row) => `\t\t${JSON.stringify(row)}`).join(",\n")}\n\t]`;
+		if (!LISTS.has(key) || !Array.isArray(value)) return `\t${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+		if (!value.length) return `\t${JSON.stringify(key)}: []`;
+		const entries = [...value].sort((a, b) => a.id - b.id);
+		return `\t${JSON.stringify(key)}: [\n${entries.map((entry) => `\t\t${entryText(entry)}`).join(",\n")}\n\t]`;
+	}).join(",\n")}\n}\n`;
+}
+/**
+* What a map file is called, without what comes after the first dot: the name of the map in small letters, with a
+* dash for whatever is not a letter or a number. `The Pass!` is `the-pass`
+*
+* @beta
+*/
+function mapFileStem(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "map";
+}
+/** A stem as the start of the name of a type: `the-pass` is `ThePass` */
+var typeName = (stem) => {
+	const name = stem.replace(/(^|-)([a-z0-9])/g, (_, __, letter) => letter.toUpperCase());
+	return /^[0-9]/.test(name) ? `Map${name}` : name;
+};
+/** A name as TypeScript writes text, in single quotes as the rest of the code has it. Whatever is in it stays inside */
+var quoted = (name) => `'${JSON.stringify(name).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+/** The names as a type: one to a line, so that naming one more thing changes one line */
+var union = (names) => names.length ? [...names].sort().map((name) => `\n\t| ${quoted(name)}`).join("") : " never";
+/**
+* The names of what is on a map as TypeScript, for a game's code to use: `world.named<RoadNames>('gaet')` does not
+* compile. The editor writes it next to the map (`road.names.ts` for `road.vgmap.json`), anew with every save
+*
+* @beta
+*/
+function mapNamesSource(stem, map) {
+	const type = typeName(stem);
+	const objects = map.objects.flatMap((object) => object.name ? [object.name] : []);
+	const camps = map.camps.flatMap((camp) => camp.name ? [camp.name] : []);
+	const regions = map.regions.map((region) => region.name);
+	const points = map.points.map((point) => point.name);
+	const paths = map.paths.map((path) => path.name);
+	const lights = namesIn(map.environment, "lights");
+	const effects = namesIn(map.environment, "effects");
+	return [
+		`// Written by the map editor with ${stem}.vgmap.json, anew with every save: not to be changed by hand`,
+		"",
+		`/** What is named on the map, for \`world.named<${type}Names>(...)\` */`,
+		`export type ${type}Names =${union(objects)}`,
+		"",
+		`/** The camps that are named on the map, for \`campNamed(world, ...)\` */`,
+		`export type ${type}Camps =${union(camps)}`,
+		"",
+		`/** The regions of the map, for \`world.areas\` and \`enteredArea\` */`,
+		`export type ${type}Regions =${union(regions)}`,
+		"",
+		`/** The points of the map, for \`world.map.point(...)\` */`,
+		`export type ${type}Points =${union(points)}`,
+		"",
+		`/** The paths of the map, for \`world.map.path(...)\` */`,
+		`export type ${type}Paths =${union(paths)}`,
+		"",
+		`/** The lights of the map that are named, for \`client.lights.named(...)\` */`,
+		`export type ${type}Lights =${union(lights)}`,
+		"",
+		`/** The effects of the map that are named, for \`client.mapEffects.named(...)\` */`,
+		`export type ${type}Effects =${union(effects)}`,
+		"",
+		`/** The ids of the regions, points and paths by name: what a field that names one keeps (it is handed the name) */`,
+		`export const ${type}Ids = ${idsOf(map)} as const`,
+		""
+	].join("\n");
+}
+/** The names of the things of a list of a map's environment that have one (`lights`, `effects`), as plain data */
+function namesIn(environment, list) {
+	const things = environment?.[list];
+	if (!Array.isArray(things)) return [];
+	return things.flatMap((thing) => typeof thing?.name === "string" && thing.name ? [thing.name] : []);
+}
+/** The ids of a map's regions, points and paths by name, as the text of an object */
+function idsOf(map) {
+	const part = (things) => `{ ${things.map((thing) => `${JSON.stringify(thing.name)}: ${thing.id}`).join(", ")} }`;
+	return `{ regions: ${part(map.regions)}, points: ${part(map.points)}, paths: ${part(map.paths)} }`;
+}
+//#endregion
+//#region src/mapMerge.ts
+/** The parts of a map file that are lists of things with ids, merged thing by thing: the map's table says (`MAP_FIELDS`) */
+var BY_ID = new Set(BY_ID$1);
+/** What they are as text, to be compared: the same value, the same text */
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+* The three-way choice of one value: what only one side changed is that side's; both alike, either; both otherwise,
+* ours, and a conflict. `undefined` is a value too: a part one side took out
+*/
+function pick(base, ours, theirs) {
+	if (same(ours, theirs)) return {
+		value: ours,
+		conflict: false
+	};
+	if (same(ours, base)) return {
+		value: theirs,
+		conflict: false
+	};
+	if (same(theirs, base)) return {
+		value: ours,
+		conflict: false
+	};
+	return {
+		value: ours,
+		conflict: true
+	};
+}
+/** What a thing of a list is called in what is said: its kind and its id, and its name or type where it has one */
+function nameOf(list, entry, id) {
+	return `${list === "objects" ? "object" : list.replace(/s$/, "")} ${id}${typeof entry?.name === "string" ? ` "${entry.name}"` : typeof entry?.type === "string" ? ` (${entry.type})` : ""}`;
+}
+/** Merges two lists of things by their ids: each thing chosen as a value of its own, in the order of their ids */
+function mergeList(list, base, ours, theirs, conflicts) {
+	const byId = (entries) => new Map(entries.map((entry) => [entry.id, entry]));
+	const [b, o, t] = [
+		byId(base),
+		byId(ours),
+		byId(theirs)
+	];
+	const ids = [.../* @__PURE__ */ new Set([
+		...b.keys(),
+		...o.keys(),
+		...t.keys()
+	])].sort((x, y) => x - y);
+	const merged = [];
+	for (const id of ids) {
+		const chosen = pick(b.get(id), o.get(id), t.get(id));
+		if (chosen.conflict) {
+			const what = nameOf(list, o.get(id) ?? t.get(id), id);
+			conflicts.push(o.has(id) && t.has(id) ? `${what} was changed on both sides: ours is kept` : `${what} was changed on one side and taken out on the other: ours is kept`);
+		}
+		if (chosen.value !== void 0) merged.push(chosen.value);
+	}
+	return merged;
+}
+/** Whether a value is a list of things with ids: what of a map's look is merged thing by thing (its lights, effects, decals) */
+var listOfIds = (value) => Array.isArray(value) && value.every((entry) => !!entry && typeof entry === "object" && typeof entry.id === "number");
+/**
+* Merges what a map looks like (`GameMap.environment`, the client's to read) part by part: a list of things with ids
+* (its lights, effects, decals, sounds) thing by thing, as the map's own lists are, and each other part as a value
+*/
+function mergeEnvironment(base, ours, theirs, conflicts) {
+	const plain = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+	if (![
+		base,
+		ours,
+		theirs
+	].every((value) => value === void 0 || plain(value))) return pick(base, ours, theirs);
+	const [b, o, t] = [
+		base,
+		ours,
+		theirs
+	].map((value) => value ?? {});
+	const merged = {};
+	for (const key of /* @__PURE__ */ new Set([
+		...Object.keys(b),
+		...Object.keys(o),
+		...Object.keys(t)
+	])) {
+		if ([
+			b[key],
+			o[key],
+			t[key]
+		].every((value) => value === void 0 || listOfIds(value))) {
+			const list = mergeList(key, b[key] ?? [], o[key] ?? [], t[key] ?? [], conflicts);
+			if (list.length || o[key] !== void 0) merged[key] = list;
+			continue;
+		}
+		const chosen = pick(b[key], o[key], t[key]);
+		if (chosen.conflict) conflicts.push(`the map's look's ${key} was changed on both sides: ours is kept`);
+		if (chosen.value !== void 0) merged[key] = chosen.value;
+	}
+	return {
+		value: Object.keys(merged).length || ours !== void 0 ? merged : void 0,
+		conflict: false
+	};
+}
+/**
+* Merges two versions of a map from the one they came from: parts and things by their ids (those of its look too: its
+* lights, effects, decals), the ground cell by cell. Never throws for what both changed: ours is kept there, and said
+* (`conflicts`). Maps of different sizes are not merged (ours, and said)
+*
+* @beta
+*/
+function mergeMaps(base, ours, theirs) {
+	const conflicts = [];
+	if (ours.width !== theirs.width || ours.depth !== theirs.depth || base.width !== ours.width || base.depth !== ours.depth) return {
+		map: ours,
+		conflicts: ["the size of the map changed: ours is kept whole"]
+	};
+	const [b, o, t] = [
+		base,
+		ours,
+		theirs
+	].map((map) => serializeMap(map));
+	const merged = { ...o };
+	const keys = /* @__PURE__ */ new Set([
+		...Object.keys(b),
+		...Object.keys(o),
+		...Object.keys(t)
+	]);
+	for (const key of keys) {
+		if (key === "format" || LAYERS$1.includes(key)) continue;
+		if (BY_ID.has(key) && [
+			b[key] ?? [],
+			o[key] ?? [],
+			t[key] ?? []
+		].every(Array.isArray)) {
+			const list = mergeList(key, b[key] ?? [], o[key] ?? [], t[key] ?? [], conflicts);
+			if (list.length || o[key] !== void 0) merged[key] = list;
+			else delete merged[key];
+			continue;
+		}
+		const chosen = key === "environment" ? mergeEnvironment(b[key], o[key], t[key], conflicts) : pick(b[key], o[key], t[key]);
+		if (chosen.conflict) conflicts.push(`the map's ${key} was changed on both sides: ours is kept`);
+		if (chosen.value === void 0) delete merged[key];
+		else merged[key] = chosen.value;
+	}
+	const map = parseMap(merged);
+	const paintable = same(o.tileset, t.tileset) && same(b.tileset, o.tileset);
+	for (const layer of LAYERS$1) {
+		if (layer === "tiles" && !paintable) {
+			if (!same(Array.from(ours.tiles), Array.from(theirs.tiles))) conflicts.push("the paint was changed on both sides with different tiles: ours is kept");
+			map.tiles = ours.tiles.slice();
+			continue;
+		}
+		const [from, mine, yours] = [
+			base[layer],
+			ours[layer],
+			theirs[layer]
+		];
+		const into = mine.slice();
+		let both = 0;
+		for (let i = 0; i < into.length; i++) {
+			if (mine[i] === yours[i]) continue;
+			if (mine[i] === from[i]) into[i] = yours[i];
+			else if (yours[i] !== from[i]) both++;
+		}
+		if (both) conflicts.push(`${both} ${layer === "ground" ? "corners of the ground" : `cells of the ${layer === "tiles" ? "paint" : layer}`} were changed on both sides: ours is kept there`);
+		map[layer] = into;
+	}
+	return {
+		map,
+		conflicts
+	};
+}
+//#endregion
+//#region src/presetGround.ts
+/**
+* Ready-made grounds a game takes or leaves, beside its own: the tiles of an RTS's ground (grass, dark grass, dirt,
+* road, sand, rock, snow), which the client draws with its `TILE_LOOKS`, and the blight a race spoils ground with,
+* which the client draws with its `blightLook`. They say only what there is; what they do is the game's
+*/
+/**
+* The tiles of an RTS's ground, by the ids the client's `TILE_LOOKS` has looks for: `tiles: presetTiles` in the rules,
+* `tiles: TILE_LOOKS` in the view. A game adds its own beside them, or takes some (`presetTiles.filter(...)`)
+*
+* @beta
+*/
+var presetTiles = [
+	defineTile({
+		id: "grass",
+		name: "Grass"
+	}),
+	defineTile({
+		id: "darkGrass",
+		name: "Dark grass"
+	}),
+	defineTile({
+		id: "dirt",
+		name: "Dirt"
+	}),
+	defineTile({
+		id: "road",
+		name: "Road"
+	}),
+	defineTile({
+		id: "sand",
+		name: "Sand"
+	}),
+	defineTile({
+		id: "rock",
+		name: "Rock"
+	}),
+	defineTile({
+		id: "snow",
+		name: "Snow"
+	})
+];
+/**
+* Blight: ground spoiled, a layer of cells a map's maker paints and the rules spread (`world.setCells('blight', …)`),
+* drawn by the client's `blightLook`. What it does (who builds on it, who heals on it) is the game's: melee's
+* undead in the example
+*
+* @beta
+*/
+var presetBlight = defineCellLayer({
+	id: "blight",
+	name: "Blight",
+	description: "Spoiled ground: what the game says of it, a race that builds on it, one that heals on it",
+	color: [
+		.45,
+		.3,
+		.55
+	]
+});
+//#endregion
+//#region src/presetBuildings.ts
+/**
+* A fountain: a building that keeps the game's aura on who is around it (`aura`, the id of a passive ability with an
+* `aura` effect: a fountain of health's regeneration, a fountain of mana's). It cannot be hurt; a map puts it down
+* for the neutral player, so the aura says `affects: 'all'` to reach everyone (the neutral player is nobody's ally).
+* What is given over the fountain's own goes over it: `presetFountain('healingWaters', { id: 'fountainOfHealth' })`
+*
+* @beta
+*/
+function presetFountain(aura, over = {}) {
+	return {
+		id: "fountain",
+		name: "Fountain",
+		kind: "building",
+		radius: 1.5,
+		footprint: {
+			w: 3,
+			d: 3
+		},
+		stats: { health: 1e3 },
+		sight: 6,
+		invulnerable: true,
+		abilities: [aura],
+		...over
+	};
+}
+/**
+* A marketplace's abilities: one for each trade (`MarketRate`), cast at once (`target: 'none'`), with an `exchange`
+* effect that trades the caster's owner's resources at its rate. A building of the game's lists their ids in its
+* `abilities` (`abilities: market.map((ability) => ability.id)`), the abilities go in the rules' `abilities`. With
+* less than the amount to sell, the player is told and nothing goes. The computer player does not cast them in a
+* fight (their `ai` says not now); its brain's `spells` may
+*
+* @beta
+*/
+function presetMarket(options) {
+	return options.rates.map(({ sell, buy, rate, amount = 100, id, name, hotkey }) => ({
+		id: id ?? `sell-${sell}-for-${buy}`,
+		name: name ?? `Sell ${sell} for ${buy}`,
+		description: `Trades ${amount} ${sell} for ${Math.floor(amount * rate + 1e-9)} ${buy}`,
+		target: "none",
+		maxLevel: 1,
+		...hotkey !== void 0 && { hotkey },
+		...options.cooldown !== void 0 && { cooldown: options.cooldown },
+		effects: [{
+			type: "exchange",
+			sell,
+			buy,
+			rate,
+			amount
+		}],
+		ai: () => null
+	}));
+}
+//#endregion
+//#region src/packs/heroes/respawn.ts
+/**
+* A game whose heroes come back by themselves after a while, at their side's home (see `RespawnOptions`): a saved timer
+* each, shown on the HUD as a revive is, and waited for by the computer player in place of reviving at an altar.
+* Revived at an altar in the meantime, it is back then, and the timer comes to nothing. For a game with the heroes pack
+* on (`withHeroes()`): one without it is refused
+*
+* @beta
+*/
+function withRespawn(options = {}) {
+	const time = options.time ?? ((_world, hero) => 4 + 2 * (heroOf(hero)?.level ?? 1));
+	const comeBack = defineTimer("respawn", (world, data) => {
+		const hero = world.get(data.hero) ?? [...world.index.with(heroState, data.player)].find((each) => each.id === data.hero);
+		const waiting = hero?.get(respawning);
+		if (!hero || !waiting || data.since !== void 0 && waiting.since !== data.since) return;
+		hero.remove(respawning);
+		if (hero.alive || !hero.has(heroState)) return;
+		const at = options.at?.(world, hero) ?? homeOf(world, hero.owner, hero.pos) ?? hero.pos;
+		reviveHero(world, hero, at);
+	});
+	const fell = defineListener({
+		id: "respawn.fell",
+		event: entityDied,
+		run(world, { entity }) {
+			if (!entity.has(heroState) || options.heroes && !options.heroes(world, entity)) return;
+			const wait = Math.max(0, time(world, entity));
+			entity.set(respawning, {
+				since: world.time,
+				wait
+			});
+			world.timers.after(wait, comeBack, {
+				hero: entity.id,
+				player: entity.owner,
+				since: world.time
+			});
+		}
+	});
+	return {
+		id: "respawn",
+		options,
+		requires: [HEROES],
+		components: [respawning],
+		timers: [comeBack],
+		listeners: [fell]
+	};
+}
+/**
+* Recall (features-plan F2): a hero stands and channels for a few seconds, then is at its side's home (`homeOf`),
+* however far; hurt in the meantime, or told to do something else, and it stays where it is. An ability to give heroes
+* (`UnitTypeDef.abilities`), made of the engine's parts: a channel (`AbilityDef.channel`) that `breaksOnDamage`, and the
+* `teleport` effect when it is `finished`. Its id, name, how long it takes, its cooldown and key are the game's to say
+*
+* @beta
+*/
+function recallAbility(options = {}) {
+	const duration = options.duration ?? 6;
+	return {
+		id: options.id ?? "recall",
+		name: options.name ?? "Recall",
+		description: `After ${duration} seconds standing still, unhurt, the hero is back home.`,
+		hotkey: options.hotkey ?? "B",
+		target: "none",
+		cooldown: options.cooldown ?? 20,
+		maxLevel: 1,
+		effects: [],
+		channel: {
+			duration,
+			breaksOnDamage: true,
+			finished: [{
+				type: "teleport",
+				to: "home"
+			}]
+		}
+	};
+}
+//#endregion
+//#region src/friendlyFire.ts
+/**
+* The friendly fire pack's id
+*
+* @beta
+*/
+var FRIENDLY_FIRE = "core.friendlyFire";
+/**
+* Friendly fire, as in classic RTS games: a unit told to attack (the attack command, never a right click) one of its own or
+* an ally's attacks it. Never of its own accord: units do not pick their own side to attack, nor fight back at it.
+* Nothing of a neutral player's (a rock, a critter) is made a target by it
+*
+* @beta
+*/
+function withFriendlyFire(options = {}) {
+	const attacks = options.attacks ?? (() => true);
+	return {
+		id: FRIENDLY_FIRE,
+		options,
+		hooks: [defineHook({
+			hook: "canAttack",
+			id: "friendlyFire",
+			run(world, event) {
+				const { attacker, target } = event;
+				if (event.allowed || !event.ordered || world.player(target.owner).neutral) return;
+				if (world.areEnemies(attacker.owner, target.owner)) return;
+				if (attackReaches(world, attacker, target) && attacks(world, attacker, target)) event.allowed = true;
+			}
+		})]
+	};
+}
+//#endregion
+//#region src/ids.ts
+/**
+* Ids the compiler knows. A game's ids are text to the engine (`world.spawn('skeleton', ...)`), and a slip of the
+* finger in one is found when the game runs, if it is found. Named once with `defineIds`, they are checked as they are
+* written, completed by the editor, and renamed in one place:
+*
+*     export const UNIT = defineIds('skeleton', 'runner', 'brute')
+*     export type TdUnit = IdOf<typeof UNIT>            // 'skeleton' | 'runner' | 'brute'
+*
+*     { id: UNIT.skeleton, ... }                        // in the unit's definition
+*     world.spawn(UNIT.skeletn, ...)                    // does not compile
+*     const view: GameView<TdUnit> = { units: { looks: { skeletn: ... } } }   // nor does this
+*
+* It is a help, not a rule: plain text works wherever an id goes, and what the compiler cannot see is checked when the
+* game is put together (`defineGame`)
+*
+* @beta
+*/
+function defineIds(...names) {
+	const out = {};
+	for (const name of names) {
+		if (name in out) throw new Error(`defineIds: "${name}" is there twice`);
+		out[name] = name;
+	}
+	return Object.freeze(out);
+}
+//#endregion
+//#region src/gameFiles.ts
+/**
+* A file of the game's own data, for `GameModule.files`: `defineGameFile('waves.json', wavesFile, readWaves)`, read by
+* the rules with `world.registry.file(waves)`
+*
+* @beta
+*/
+function defineGameFile(id, data, read) {
+	return {
+		id,
+		data,
+		read
+	};
+}
+//#endregion
+//#region src/packs/pack.ts
+/**
+* Whether a game has a pack on, by its id: `hasPack(game, HEROES)`, what the editor asks before it shows a hero's
+* fields
+*
+* @beta
+*/
+function hasPack(game, id) {
+	return !!game?.packs?.some((pack) => pack.id === id);
+}
+//#endregion
+//#region src/packs/director/index.ts
+/** @beta */
+var DIRECTOR = "director";
+/**
+* The cinematic playing on each player's screen, by its id, as their screen said (`cinematicPlaying`): whose
+* director's commands are taken
+*
+* @beta
+*/
+var directing = defineComponent("director.playing", { default: () => ({}) });
+/**
+* The units a cinematic made invulnerable (`director` with `invulnerable`): nothing hurts or kills them until it says
+* otherwise
+*
+* @beta
+*/
+var directorInvulnerable = defineComponent("director.invulnerable");
+/**
+* What a director's command does (`DirectorCommand.action`)
+*
+* @beta
+*/
+var DIRECTOR_ACTIONS = [
+	"spawn",
+	"remove",
+	"kill",
+	"teleport",
+	"scale",
+	"invulnerable",
+	"owner",
+	"order",
+	"facing"
+];
+/**
+* The orders a director's command gives (`order`): to a spot, or at a unit
+*
+* @beta
+*/
+var DIRECTOR_ORDERS = [
+	"move",
+	"attack",
+	"attackMove",
+	"patrol",
+	"stop",
+	"hold"
+];
+/**
+* A player's screen says a cinematic began on it (`playing: true`, its id) or ended: while one plays there, the
+* director's commands it sends are taken
+*
+* @beta
+*/
+var cinematicPlayingCommand = defineCommand("cinematicPlaying", {
+	cinematic: string,
+	playing: bool
+}, (world, player, command) => {
+	const known = directorOptions(world).cinematics;
+	if (command.playing && known && !known.includes(command.cinematic)) return refuse(world, player, `"${command.cinematic}" is no cinematic the director plays in (withDirector's cinematics)`);
+	const now = { ...world.state(directing) };
+	if (command.playing) now[player] = command.cinematic;
+	else if (now[player] === command.cinematic) delete now[player];
+	world.setState(directing, now);
+});
+/** The options the game's director pack was made with */
+var directorOptions = (world) => world.registry.module?.packs?.find((pack) => pack.id === "director")?.options ?? {};
+/** Turned away, and counted as what the player's own client never sends */
+var refuse = (world, player, reason) => world.events.emit(commandRejected, {
+	player,
+	type: "director",
+	kind: "notDirecting",
+	reason
+});
+/**
+* A cinematic's say over the game (see the top of this file): `action` with what it takes. `unit` is the one it is
+* done to (any player's); `spawn` puts one of `unitType` down for `owner` at `at`, turned to `facing`, named `name` for
+* what comes after it in the cinematic (`world.named`)
+*
+* @beta
+*/
+var directorCommand = defineCommand("director", {
+	cinematic: string,
+	action: oneOf(...DIRECTOR_ACTIONS),
+	unit: optional(id),
+	unitType: optional(string),
+	owner: optional(id),
+	at: optional(point),
+	facing: optional(number),
+	scale: optional(number),
+	on: optional(bool),
+	name: optional(string),
+	order: optional(oneOf(...DIRECTOR_ORDERS)),
+	target: optional(id)
+}, (world, player, command) => {
+	const playing = world.state(directing)[player];
+	if (playing !== command.cinematic) {
+		refuse(world, player, playing ? `the cinematic playing is "${playing}", not "${command.cinematic}"` : "no cinematic plays on their screen");
+		return;
+	}
+	const { action } = command;
+	if (action === "spawn") {
+		if (!command.unitType || !world.registry.units.has(command.unitType)) return refuse(world, player, `there is no unit type "${command.unitType}"`);
+		const owner = command.owner ?? player;
+		if (!world.players.has(owner)) return refuse(world, player, `there is no player ${owner}`);
+		if (!command.at) return refuse(world, player, "a unit put down needs where (at)");
+		world.spawn(command.unitType, owner, command.at, {
+			...command.facing !== void 0 && { facing: command.facing },
+			...command.name && { name: command.name }
+		});
+		return;
+	}
+	const entity = command.unit === void 0 ? void 0 : world.get(command.unit);
+	if (!entity?.alive) return refuse(world, player, `there is no unit ${command.unit}`);
+	act(world, entity, command);
+});
+/** What a director's command does to a unit there is */
+function act(world, entity, command) {
+	switch (command.action) {
+		case "remove":
+			world.kill(entity, void 0, false, "removed");
+			break;
+		case "kill":
+			world.kill(entity);
+			break;
+		case "teleport":
+			if (command.at) world.place(entity, command.at);
+			break;
+		case "scale":
+			if (command.scale !== void 0 && command.scale > 0) entity.scale = command.scale;
+			break;
+		case "invulnerable":
+			if (command.on === false) entity.remove(directorInvulnerable);
+			else entity.set(directorInvulnerable, true);
+			break;
+		case "owner":
+			if (command.owner !== void 0 && world.players.has(command.owner)) world.setOwner(entity, command.owner);
+			break;
+		case "facing":
+			if (command.facing !== void 0) entity.facing = command.facing;
+			break;
+		case "order": {
+			const kind = command.order ?? "move";
+			const target = command.target === void 0 ? void 0 : world.get(command.target);
+			const init = kind === "stop" || kind === "hold" ? { type: kind } : kind === "attack" && target ? {
+				type: "attack",
+				target: target.id
+			} : command.at ? {
+				type: kind === "attack" ? "attackMove" : kind,
+				point: command.at
+			} : void 0;
+			if (init) giveOrder(world, entity, createOrder(world, init));
+			break;
+		}
+	}
+}
+/** Nothing hurts or kills a unit a cinematic made invulnerable */
+var invulnerableHooks = [defineHook({
+	hook: "beforeDamage",
+	id: "director",
+	run(_world, damage) {
+		if (damage.target.has(directorInvulnerable)) damage.cancelled = true;
+	}
+}), defineHook({
+	hook: "beforeDeath",
+	id: "director",
+	run(_world, death) {
+		if (death.entity.has(directorInvulnerable) && death.reason !== "removed") death.prevented = true;
+	}
+})];
+/**
+* The director's pack (see the top of this file): its commands, what it keeps, and what keeps a unit it made
+* invulnerable so. `packs: [withDirector()]`, or `withDirector({ cinematics: ['intro'] })` for those alone
+*
+* @beta
+*/
+function withDirector(options = {}) {
+	return {
+		id: DIRECTOR,
+		options,
+		commands: [cinematicPlayingCommand, directorCommand],
+		components: [directing, directorInvulnerable],
+		hooks: invulnerableHooks
+	};
+}
+//#endregion
+//#region src/packs/moba/index.ts
+/**
+* The stats of a MOBA (`withMobaStats`): ability power, critical strikes, armor and magic penetration, life steal and
+* omnivamp, tenacity, slow resistance, heal and shield power, ability haste. The hero arena games' vocabulary and their
+* formulas, a pack a game opts into: one without it has none of these stats, and the engine's rules are the plainer
+* ones (no crits, mitigation by armor and magic resist alone, cooldowns as they are)
+*/
+/**
+* The MOBA stats pack's id
+*
+* @beta
+*/
+var MOBA_STATS = "core.mobaStats";
+/** The stats the pack brings, in the order a stat sheet shows them; `critDamage`'s default is the pack's option */
+var mobaStatDefs = (critDamage) => [
+	{
+		id: "abilityPower",
+		name: "Ability power",
+		description: "Makes abilities stronger, as far as they scale with it"
+	},
+	{
+		id: "critChance",
+		name: "Critical chance",
+		description: "Chance of a basic attack to strike critically, 0..1",
+		format: "percent"
+	},
+	{
+		id: "critDamage",
+		name: "Critical damage",
+		description: "What a critical strike multiplies the damage with",
+		default: critDamage,
+		format: "percent"
+	},
+	{
+		id: "armorPenetration",
+		name: "Armor penetration",
+		description: "Part of the target's armor that is ignored, 0..1",
+		format: "percent"
+	},
+	{
+		id: "lethality",
+		name: "Lethality",
+		description: "Armor of the target that is ignored, taken off after the part above"
+	},
+	{
+		id: "magicPenetrationPercent",
+		name: "Magic penetration %",
+		description: "Part of the target's magic resist that is ignored, 0..1",
+		format: "percent"
+	},
+	{
+		id: "magicPenetration",
+		name: "Magic penetration",
+		description: "Magic resist of the target that is ignored, taken off after the part above"
+	},
+	{
+		id: "lifeSteal",
+		name: "Life steal",
+		description: "Part of the damage of basic attacks that comes back as health",
+		format: "percent"
+	},
+	{
+		id: "omnivamp",
+		name: "Omnivamp",
+		description: "Part of all damage dealt that comes back as health",
+		format: "percent"
+	},
+	{
+		id: "tenacity",
+		name: "Tenacity",
+		description: "Part by which stuns, slows and the like are cut short, 0..1",
+		format: "percent"
+	},
+	{
+		id: "slowResist",
+		name: "Slow resist",
+		description: "Part by which slows are weakened, 0..1",
+		format: "percent"
+	},
+	{
+		id: "healShieldPower",
+		name: "Heal and shield power",
+		description: "Part by which the heals and shields this unit gives are stronger",
+		format: "percent"
+	},
+	{
+		id: "abilityHaste",
+		name: "Ability haste",
+		description: "Shortens cooldowns: 100 of it halve them"
+	}
+];
+/**
+* What is left of damage once the target's armor or magic resist, less what the source's penetration ignores, had its
+* say: the pack's `rules.combat.mitigation`
+*
+* @beta
+*/
+function penetratingMitigation(type, target, source) {
+	if (type === "true") return 1;
+	let resist = type === "physical" ? target.armor : target.magicResist;
+	if (source && resist > 0) {
+		const part = type === "physical" ? source.armorPenetration : source.magicPenetrationPercent;
+		const flat = type === "physical" ? source.lethality : source.magicPenetration;
+		resist = Math.max(resist * (1 - part) - flat, 0);
+	}
+	return resisted(resist);
+}
+/** Health back for damage dealt: omnivamp of everything, life steal of basic attacks. Before the engine's own handlers */
+var lifeSteal = defineHook({
+	hook: "afterDamage",
+	id: "mobaStats.lifeSteal",
+	priority: -1,
+	run(world, { target, source, taken, attack }) {
+		if (!source?.alive || taken <= 0 || source === target) return;
+		const stats = statsOf(world, source);
+		const back = taken * (stats.omnivamp + (attack ? stats.lifeSteal : 0));
+		if (back > 0) world.heal(source, back);
+	}
+});
+/** Stuns, slows and the like cut short by the target's tenacity: before what the game decides of a buff */
+var tenacity = defineHook({
+	hook: "beforeBuff",
+	id: "mobaStats.tenacity",
+	priority: -1,
+	run(world, event) {
+		if (event.duration !== Infinity && isCrowdControl(event.buff)) event.duration *= 1 - statsOf(world, event.target).tenacity;
+	}
+});
+/**
+* The stats of a MOBA, for a game that has them: ability power (what `scaling: { abilityPower }` reads), critical
+* strikes, armor and magic penetration, life steal and omnivamp, tenacity, slow resistance, heal and shield power,
+* ability haste, with the hero arena games' formulas for each. A game without it has none of these stats
+*
+* @beta
+*/
+function withMobaStats(options = {}) {
+	const { critDamage = 1.75, maxTenacity = .9 } = options;
+	return {
+		id: MOBA_STATS,
+		options,
+		stats: mobaStatDefs(critDamage),
+		hooks: [lifeSteal, tenacity],
+		rules: (rules) => {
+			const { combat } = rules;
+			const engine = defaultRules.combat;
+			const own = (key, pack) => combat[key] === engine[key] ? pack : combat[key];
+			const keep = combat.clampStats;
+			return { combat: {
+				critical: own("critical", (world, _attacker, stats) => stats.critChance > 0 && world.rng.next() < stats.critChance ? stats.critDamage : void 0),
+				mitigation: own("mitigation", penetratingMitigation),
+				clampStats(stats, all) {
+					stats.critChance = clamp(stats.critChance, 0, 1);
+					stats.tenacity = clamp(stats.tenacity, 0, maxTenacity);
+					stats.slowResist = clamp(stats.slowResist, 0, 1);
+					stats.armorPenetration = clamp(stats.armorPenetration, 0, 1);
+					stats.magicPenetrationPercent = clamp(stats.magicPenetrationPercent, 0, 1);
+					keep(stats, all);
+				},
+				cooldown: own("cooldown", (seconds, stats) => stats.abilityHaste > 0 ? seconds * 100 / (100 + stats.abilityHaste) : seconds),
+				slowTaken: own("slowTaken", (stats, slow) => slow * (1 - stats.slowResist)),
+				healPower: own("healPower", (world, source) => 1 + statsOf(world, source).healShieldPower)
+			} };
+		}
+	};
+}
+//#endregion
+//#region src/techTree.ts
+/**
+* The tech tree of a game's rules: its things that are made or make something (scenery and the map's creeps left
+* out), the edges between them, and each one's tier. Tiers go by what makes what from what nothing makes and from the
+* buildings that make the builders, require nothing and are no other's upgrade (a hall; else, where everything is
+* made of something, the buildings that require nothing, are no upgrade and make something),
+* each thing after what it requires; a loop of requirements stops at the number of things
+*
+* @beta
+*/
+function techTree(registry) {
+	const units = registry.units.all();
+	const upgrades = registry.upgrades.all();
+	const edges = [];
+	const known = /* @__PURE__ */ new Set([...units.map((unit) => unit.id), ...upgrades.map((upgrade) => upgrade.id)]);
+	const add = (from, to, kind) => {
+		if (known.has(from) && known.has(to) && from !== to) edges.push({
+			from,
+			to,
+			kind
+		});
+	};
+	for (const unit of units) {
+		for (const id of unit.trains ?? []) add(unit.id, id, "trains");
+		for (const id of unit.builds ?? []) add(unit.id, id, "builds");
+		for (const id of unit.hires ?? []) add(unit.id, id, "hires");
+		for (const id of unit.researches ?? []) add(unit.id, id, "researches");
+		for (const id of upgradesOf(unit)) add(unit.id, id, "upgradesTo");
+		for (const id of unit.requires ?? []) add(id, unit.id, "requires");
+	}
+	for (const upgrade of upgrades) for (const id of upgrade.requires?.[0] ?? []) add(id, upgrade.id, "requires");
+	const inTree = new Set(edges.flatMap((edge) => [edge.from, edge.to]));
+	const makes = edges.filter((edge) => edge.kind !== "requires");
+	const made = new Set(makes.map((edge) => edge.to));
+	const needs = /* @__PURE__ */ new Map();
+	for (const edge of edges) if (edge.kind === "requires") needs.set(edge.to, [...needs.get(edge.to) ?? [], edge.from]);
+	const buildings = new Set(units.filter((unit) => unit.kind !== "unit").map((unit) => unit.id));
+	const upgraded = new Set(edges.filter((edge) => edge.kind === "upgradesTo").map((edge) => edge.to));
+	let start = [...inTree].filter((id) => !made.has(id));
+	const builders = new Set(units.filter((unit) => unit.builds?.length).map((unit) => unit.id));
+	const first = [...inTree].filter((id) => buildings.has(id) && !needs.has(id) && !upgraded.has(id));
+	const halls = first.filter((id) => makes.some((edge) => edge.from === id && builders.has(edge.to)));
+	start = [.../* @__PURE__ */ new Set([...start, ...halls])];
+	if (!start.length) start = first.filter((id) => makes.some((edge) => edge.from === id));
+	if (!start.length) start = [...inTree].filter((id) => !needs.has(id));
+	const tier = new Map(start.map((id) => [id, 0]));
+	for (let queue = [...start]; queue.length;) {
+		const next = [];
+		for (const id of queue) for (const edge of makes) if (edge.from === id && !tier.has(edge.to)) {
+			tier.set(edge.to, tier.get(id) + 1);
+			next.push(edge.to);
+		}
+		queue = next;
+	}
+	for (let pass = 0; pass < inTree.size; pass++) {
+		let moved = false;
+		for (const [id, required] of needs) {
+			const after = Math.max(...required.map((other) => (tier.get(other) ?? 0) + 1));
+			if (after > (tier.get(id) ?? 0)) {
+				tier.set(id, after);
+				moved = true;
+			}
+		}
+		if (!moved) break;
+	}
+	const nodes = [];
+	for (const unit of units) if (inTree.has(unit.id)) nodes.push({
+		id: unit.id,
+		kind: unit.kind === "unit" ? "unit" : "building",
+		name: unit.name,
+		tier: tier.get(unit.id) ?? 0,
+		...unit.race && { race: unit.race }
+	});
+	for (const upgrade of upgrades) if (inTree.has(upgrade.id)) nodes.push({
+		id: upgrade.id,
+		kind: "upgrade",
+		name: upgrade.name,
+		tier: tier.get(upgrade.id) ?? 0,
+		...upgrade.race && { race: upgrade.race }
+	});
+	return {
+		nodes,
+		edges
+	};
+}
+//#endregion
+//#region src/hotReload.ts
+/**
+* A world took a new version of its game while it ran (`reloadGame`, hot reload): what the rules hear
+* (`world.events.on(gameReloaded, …)`), and every screen (`GameView.on`), to make again what it made of the old one
+*
+* @beta
+*/
+var gameReloaded = defineEvent("core.gameReloaded", { replicate: "everyone" });
+/**
+* Puts a new version of a world's game into it while it runs, as a game's files are saved during development (hot
+* reload): its unit types, abilities, buffs, items, upgrades and races, the code of their effects and of its orders,
+* and its rules. What `world.redefine` changed while it ran stays over them, and its units take their types as they
+* are now. What the world was made of otherwise (its systems, hooks, components, resources) is not: a change to those
+* wants a new game, which is said (`hotRules` loads the page again for one). Throws for another game, or a module that is no game (as `createRegistry`)
+*
+* @beta
+*/
+function reloadGame(world, game) {
+	const { registry } = world;
+	if (game.id !== registry.game) throw new Error(`The world plays "${registry.game}", not "${game.id}"`);
+	registry.takeFrom(createRegistry(game));
+	if (world.states.has(redefinitions)) restoreRedefinitions(registry, world.state(redefinitions));
+	world.retype();
+	world.score.listen();
+	try {
+		game.onReload?.(world);
+	} catch (error) {
+		world.log.error("game", `${game.id}'s onReload threw: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	world.log.info("game", `Took a new version of ${game.name ?? game.id}: its definitions and rules (its systems and hooks are the game's as it began)`);
+	world.events.emit(gameReloaded, { game: game.id });
+}
+/** What of a game a running world keeps as it was made (`reloadGame`): a new version that changes any loads the page again */
+var NOT_RELOADED = [
+	"systems",
+	"withoutSystems",
+	"hooks",
+	"withoutHooks",
+	"components",
+	"resources"
+];
+/**
+* What a part of a game is, in words, to tell a new version's from the old: its code by its source, its data by its
+* values, so that a module evaluated again with the same code is the same
+*/
+function shapeOf(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
+	if (typeof value === "function") return `f:${String(value)}`;
+	if (value === null || typeof value !== "object") return value === void 0 ? "u" : JSON.stringify(value);
+	if (seen.has(value) || depth > 8) return "…";
+	seen.add(value);
+	const shape = Array.isArray(value) ? `[${value.map((each) => shapeOf(each, depth + 1, seen)).join(",")}]` : `{${Object.keys(value).sort().map((key) => `${key}:${shapeOf(value[key], depth + 1, seen)}`).join(",")}}`;
+	seen.delete(value);
+	return shape;
+}
+/** Who hears of a new version of a game's rules or of a mod: the client, which tells the games and editors of the page */
+var listeners = /* @__PURE__ */ new Set();
+var modListeners = /* @__PURE__ */ new Set();
+/**
+* Hears of every new version of a game's rules taken in the page (`hotRules`). Returns what stops it
+*
+* @beta
+*/
+function onNewGameVersion(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+/**
+* Hears of every new version of a mod taken in the page (`hotMod`). Returns what stops it
+*
+* @beta
+*/
+function onNewModVersion(listener) {
+	modListeners.add(listener);
+	return () => modListeners.delete(listener);
+}
+/**
+* A mod's module's new version, taken while it runs (hot reload), as `hotRules` takes a game's: at its end,
+*
+*     if (import.meta.hot) import.meta.hot.accept((module) => hotMod(import.meta.hot, goldRush, module?.goldRush))
+*
+* The mod given is made the new one in place, and every game of the page played with it is made again of its parts as
+* they are now (`recompose`) and takes that. What does not go (no new module, another mod, mods that no longer go
+* together) loads the page again
+*
+* @beta
+*/
+function hotMod(hot, current, next) {
+	const mod = next;
+	if (!mod || typeof mod !== "object" || mod.id !== current.id) return hot?.invalidate(`${current.id}: its module is not there as it was`);
+	try {
+		replaceIn(current, mod);
+		for (const listener of modListeners) listener(current);
+	} catch (error) {
+		rootLogger.warn("game", `The mod ${current.id}'s new version could not be taken while it runs: the page loads again`, { error: String(error) });
+		hot?.invalidate();
+	}
+}
+/**
+* Puts what `next` has into `current`, in its place: everything that holds `current` has the new version
+*
+* @beta
+*/
+function replaceIn(current, next) {
+	for (const key of Object.keys(current)) if (!(key in next)) delete current[key];
+	Object.assign(current, next);
+}
+/**
+* A game's entry module's new version, taken while it runs (hot reload). At the module's end, the call to Vite written
+* out as it is (Vite finds a module that takes its own new versions by it):
+*
+*     if (import.meta.hot) import.meta.hot.accept((module) => hotRules(import.meta.hot, melee, module?.melee))
+*
+* As it or a file it reads (its units, its `data.json`) is saved in the dev server, the module given is made the new
+* one in place, so that what holds it has the new one, and the games and editors of the page playing it take its
+* definitions and rules (`reloadGame`, through `onNewGameVersion`). What does not go loads the page again, saying why
+* (`hot.invalidate(reason)`): no new module, another game, a component defined another way, or a change to what a
+* running world keeps as it was made (its `systems`, `hooks`, `components`, `resources`, and `withoutSystems` and
+* `withoutHooks`, compared by their code and values). No client is pulled into the rules, which a server reads too
+*
+* @beta
+*/
+function hotRules(hot, current, next) {
+	const game = next;
+	if (!game || typeof game !== "object" || game.id !== current.id) return hot?.invalidate(`${current.id}: its module is not there as it was`);
+	const kept = NOT_RELOADED.filter((key) => shapeOf(current[key]) !== shapeOf(game[key]));
+	if (kept.length) return hot?.invalidate(`${current.id}: its ${kept.join(", ")} changed, which a running game does not take`);
+	try {
+		replaceIn(current, game);
+		for (const listener of listeners) listener(current);
+	} catch (error) {
+		rootLogger.warn("game", `${current.id}'s new version could not be taken while it runs: the page loads again`, { error: String(error) });
+		hot?.invalidate();
+	}
+}
+//#endregion
+//#region src/session/worker.ts
+/** Milliseconds between two words of where the time went */
+var TIMING_EVERY = 1e3;
+var firstOfMap = (map) => (map.players.find((player) => player.start) ?? map.players[0])?.id;
+function firstOfWorld(world) {
+	for (const player of world.players.values()) if (!player.neutral && !player.creeps) return player.id;
+	throw new Error("The world has no player to play: every one of its players is neutral");
+}
+/**
+* What a game's worker file does: `serveWorld(game, { start })`. It waits for the page to say what to play (a map, a
+* save, or nothing for a world made here in code), makes the world, runs it by the clock, and seats the page's player
+* at it. A new game asked for ends the one before: a restart is the same worker, its navigation built already
+*
+* @beta
+*/
+function serveWorld(first, options = {}) {
+	/** The game's version now: the one it began with, or the one it took last (`reload`) */
+	let game = first;
+	const port = options.port ?? globalThis;
+	const post = (message, transfer) => port.postMessage(message, transfer);
+	/** The game running now, and what ends it */
+	let running;
+	/** Whether the systems are measured, as the page's stats ask: off until they do */
+	let profiling = false;
+	/** Each start has a number: one overtaken while its world was made is let go */
+	let starts = 0;
+	const start = async (asked) => {
+		const mine = ++starts;
+		running?.end();
+		running = void 0;
+		const log = new Logger();
+		const stopLog = log.to((entry) => post({
+			vg: "log",
+			entry
+		}));
+		let world;
+		try {
+			const seed = asked.seed ?? randomSeed();
+			world = asked.from ? await loadWorld(asked.from, {
+				game,
+				log
+			}) : asked.map ? await createWorldFromMap({
+				map: asked.map,
+				game,
+				seed,
+				log
+			}) : options.world ? await options.world({
+				rules: game,
+				seed,
+				args: asked.args,
+				log
+			}) : void 0;
+			if (!world) throw new Error("A game in a worker needs a map, a save to go on from, or a world made in the worker (serveWorld world)");
+			if (mine !== starts) return world.dispose();
+			world.errorPolicy ??= "end";
+			const player = asked.player ?? options.player?.(world, asked.map) ?? (asked.map && firstOfMap(asked.map)) ?? firstOfWorld(world);
+			if (!asked.from) await options.start?.(world, {
+				player,
+				map: asked.map,
+				args: asked.args
+			});
+			if (mine !== starts) return world.dispose();
+			if (asked.reveal) world.fog.setRevealed(world.player(player).team, true);
+			if (asked.debug) world.debugPlayers.add(player);
+			const made = world;
+			const host = new SessionHost(made, {
+				ownsWorld: true,
+				sendRate: made.tickRate,
+				dropSilentAfter: Infinity
+			});
+			let hear = () => {};
+			const transport = {
+				send: (text) => post(text),
+				onMessage: (handler) => hear = handler,
+				onClose: () => {},
+				close: () => {}
+			};
+			const stopCheckpoint = made.events.on(checkpoint, ({ label }) => {
+				setTimeout(() => {
+					if (running?.host === host) post({
+						vg: "checkpoint",
+						label,
+						save: saveWorld(made)
+					});
+				}, 0);
+			});
+			made.scheduler.profiling = profiling;
+			const timingTimer = setInterval(() => {
+				const timing = host.takeTiming();
+				post({
+					vg: "timing",
+					tick: timing.ticks ? timing.tickTime / timing.ticks : 0,
+					tickMax: timing.tickMax,
+					send: timing.sends ? timing.sendTime / timing.sends : 0,
+					systems: made.scheduler.timing()
+				});
+			}, TIMING_EVERY);
+			running = {
+				host,
+				hear: (text) => hear(text),
+				end: () => {
+					clearInterval(timingTimer);
+					stopCheckpoint();
+					stopLog();
+					host.dispose();
+				}
+			};
+			post({
+				vg: "ready",
+				player
+			});
+			host.connect(player, transport);
+			host.start();
+		} catch (error) {
+			stopLog();
+			world?.dispose();
+			if (mine === starts) post({
+				vg: "refused",
+				message: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : void 0
+			});
+		}
+	};
+	const heard = (message) => {
+		if (typeof message === "string") return running?.hear(message);
+		const said = message;
+		if (typeof said !== "object" || said === null) return;
+		switch (said.vg) {
+			case "start":
+				start(said);
+				return;
+			case "reload":
+				(async () => {
+					const world = running?.host.world;
+					if (!options.reload) {
+						world?.log.warn("game", `${game.id} in a worker has no reload (serveWorld reload): it keeps the version it began with`);
+						return;
+					}
+					try {
+						const next = await options.reload(Date.now());
+						if (!next) return;
+						game = next;
+						if (world && running?.host.world === world) reloadGame(world, next);
+					} catch (error) {
+						world?.log.error("game", `${game.id}'s new version could not be taken in the worker: ${error instanceof Error ? error.message : String(error)}`);
+					}
+				})();
+				return;
+			case "stop":
+				starts++;
+				running?.end();
+				running = void 0;
+				return;
+			case "speed":
+				if (running) running.host.speed = said.speed;
+				return;
+			case "advance": return running?.host.advance(said.ticks);
+			case "save":
+				try {
+					if (!running) throw new Error("There is no game to save");
+					post({
+						vg: "saved",
+						id: said.id,
+						save: saveWorld(running.host.world)
+					});
+				} catch (error) {
+					post({
+						vg: "saved",
+						id: said.id,
+						error: error instanceof Error ? error.message : String(error)
+					});
+				}
+				return;
+			case "navigation":
+				navigationData(said.build).then((data) => post({
+					vg: "built",
+					id: said.id,
+					data
+				}), (error) => post({
+					vg: "built",
+					id: said.id,
+					error: error instanceof Error ? error.message : String(error)
+				}));
+				return;
+			case "profile":
+				profiling = said.on;
+				if (running) running.host.world.scheduler.profiling = said.on;
+				return;
+		}
+	};
+	if (port.on) port.on("message", heard);
+	else port.addEventListener?.("message", (event) => heard(event.data));
+}
+/**
+* A seat at a game run in a worker of this page (`workerSession`): a `RemoteSession` whose host is a message away,
+* with what a game played in the page has besides: its pace held and stepped (`speed`, `advance`), a save of it
+* (`save`), the checkpoint to start again from, what it says in its log, the debug tools' view, and where its time went
+*
+* @beta
+*/
+var WorkerSession = class extends RemoteSession {
+	/** What the world says (`World.log`), said again here: the page shows it with its own */
+	log;
+	checkpoint;
+	/** The debug tools' view of the world, where they are on: over the session's own words, as a server's is */
+	get debug() {
+		return this.debugView;
+	}
+	/** Its pace held and stepped, saves of it, the debug tools' view where they are on, and where its time went and in which systems */
+	can = {
+		pace: paceOf(this),
+		saves: savesOf(this),
+		inspect: this.debugView,
+		timing: {
+			timing: () => this.timing(),
+			profile: (on) => this.postToWorker({
+				vg: "profile",
+				on
+			})
+		}
+	};
+	pace = 1;
+	timed;
+	/** Milliseconds the page took to take in what the worker sent, each time, evened out: its share of a game run there */
+	received = 0;
+	postToWorker = () => {};
+	saves = /* @__PURE__ */ new Map();
+	nextSave = 0;
+	stopHearing = () => {};
+	/** What `workerSession` gives it once it is made: the way to the worker, and what stops hearing it */
+	wire(post, log, stop) {
+		this.postToWorker = post;
+		this.log = log;
+		this.stopHearing = stop;
+	}
+	/** What the worker said that is not the session's own text */
+	heard(said) {
+		if (said.vg === "checkpoint") this.checkpoint = {
+			label: said.label,
+			save: said.save
+		};
+		else if (said.vg === "timing") this.timed = {
+			tick: said.tick,
+			tickMax: said.tickMax,
+			send: said.send,
+			systems: said.systems
+		};
+		else if (said.vg === "saved") {
+			const waiting = this.saves.get(said.id);
+			this.saves.delete(said.id);
+			if (said.save) waiting?.done(said.save);
+			else waiting?.failed(new Error(said.error ?? "The game could not be saved"));
+		}
+	}
+	/**
+	* How far behind the newest tick the screen is shown, in ticks: one, and room for how unevenly they come (a tick
+	* that took long comes late). Less than over a wire, where two are kept in hand: there is no line to stall here
+	*/
+	get delay() {
+		return this.interval + Math.min(this.jitter, this.limits.maxJitter ?? .2) * this.tickRate * 2;
+	}
+	get speed() {
+		return this.pace;
+	}
+	set speed(speed) {
+		this.pace = speed;
+		this.postToWorker({
+			vg: "speed",
+			speed
+		});
+	}
+	advance(ticks = 1) {
+		this.postToWorker({
+			vg: "advance",
+			ticks
+		});
+	}
+	/**
+	* Asks the worker to take a new version of the game (hot reload): it loads the game again itself, as its file says
+	* (`serveWorld` `reload`), and puts it into its world
+	*/
+	reloadGame() {
+		this.postToWorker({ vg: "reload" });
+	}
+	save() {
+		return new Promise((done, failed) => {
+			const id = ++this.nextSave;
+			this.saves.set(id, {
+				done,
+				failed
+			});
+			this.postToWorker({
+				vg: "save",
+				id
+			});
+		});
+	}
+	timing() {
+		return this.timed && {
+			...this.timed,
+			receive: this.received
+		};
+	}
+	/** Ends the game in the worker. The worker is the page's: it stays, for the next game, until the page ends it */
+	dispose() {
+		this.postToWorker({ vg: "stop" });
+		this.stopHearing();
+		for (const waiting of this.saves.values()) waiting.failed(/* @__PURE__ */ new Error("The game ended"));
+		this.saves.clear();
+		super.dispose();
+	}
+};
+/**
+* Plays a game in a worker, and seats this page's player at it: the worker's file calls `serveWorld` with the same
+* game. Settles once the world is made there and its welcome is in; fails with what the worker said went wrong
+*
+*     const session = await workerSession(new Worker(new URL('./game.worker.ts', import.meta.url), { type: 'module' }), { game, map })
+*
+* @beta
+*/
+async function workerSession(worker, options) {
+	const { game, navigation, maps, log: under, ...asked } = options;
+	let toSession = () => {};
+	let closed = () => {};
+	let session;
+	const builds = /* @__PURE__ */ new Map();
+	let nextBuild = 0;
+	let saying;
+	const log = (under ?? rootLogger).child({ context: () => ({
+		game: saying?.game,
+		tick: saying?.tick
+	}) });
+	const post = (message) => worker.postMessage(message);
+	let refuse = () => {};
+	const refused = new Promise((_, reject) => refuse = reject);
+	refused.catch(() => {});
+	const heard = (message) => {
+		if (typeof message === "string") {
+			const began = performance.now();
+			toSession(message);
+			if (session) session.received += (performance.now() - began - session.received) * .1;
+			return;
+		}
+		const said = message;
+		if (typeof said !== "object" || said === null) return;
+		if (said.vg === "refused") {
+			const error = new Error(said.message);
+			if (said.stack) error.stack = said.stack;
+			refuse(error);
+		} else if (said.vg === "log") {
+			saying = said.entry;
+			log.log(said.entry.level, said.entry.category, said.entry.message, said.entry.fields);
+			saying = void 0;
+		} else if (said.vg === "built") {
+			const waiting = builds.get(said.id);
+			builds.delete(said.id);
+			if (said.data) waiting?.done(said.data);
+			else waiting?.failed(new Error(said.error ?? "The navigation could not be built"));
+		} else session?.heard(said);
+	};
+	const broke = (error) => {
+		const reason = /* @__PURE__ */ new Error(`The game's worker stopped: ${error instanceof Error ? error.message : String(error?.message ?? error)}`);
+		log.error("game", reason.message, { error: errorFields(error) });
+		refuse(reason);
+		closed();
+	};
+	const onMessage = (event) => heard(event.data);
+	if (worker.on) {
+		worker.on("message", heard);
+		worker.on("error", broke);
+	} else {
+		worker.addEventListener?.("message", onMessage);
+		worker.addEventListener?.("error", broke);
+	}
+	const stop = () => {
+		if (worker.off) {
+			worker.off("message", heard);
+			worker.off("error", broke);
+		} else {
+			worker.removeEventListener?.("message", onMessage);
+			worker.removeEventListener?.("error", broke);
+		}
+	};
+	const transport = {
+		send: (text) => post(text),
+		onMessage: (handler) => toSession = handler,
+		onClose: (handler) => closed = handler,
+		close: () => {}
+	};
+	post({
+		vg: "start",
+		...asked
+	});
+	try {
+		session = await Promise.race([connectAs(transport, {
+			game,
+			maps,
+			navigation: {
+				...navigation,
+				builds: { builder: (build) => new Promise((done, failed) => {
+					const id = ++nextBuild;
+					builds.set(id, {
+						done,
+						failed
+					});
+					post({
+						vg: "navigation",
+						id,
+						build: {
+							positions: build.positions.slice(),
+							indices: build.indices.slice(),
+							config: build.config,
+							...build.speeds && { speeds: {
+								...build.speeds,
+								values: build.speeds.values.slice()
+							} }
+						}
+					});
+				}) }
+			}
+		}, (...made) => new WorkerSession(...made)), refused]);
+	} catch (error) {
+		post({ vg: "stop" });
+		stop();
+		throw error;
+	}
+	session.wire(post, log, stop);
+	return session;
+}
+//#endregion
+//#region src/session/socket.ts
+/**
+* The player's end of a connection to a server, over a WebSocket: what `connect` and a server's lobby talk through.
+* Resolves once the connection is open; fails when it cannot be made
+*
+* @beta
+*/
+function openSocket(url) {
+	return new Promise((resolve, reject) => {
+		const socket = new WebSocket(url);
+		let handler = () => {};
+		let closed = () => {};
+		socket.onmessage = (event) => handler(String(event.data));
+		socket.onclose = () => closed();
+		socket.onerror = () => reject(/* @__PURE__ */ new Error(`Could not connect to ${url}`));
+		socket.onopen = () => resolve({
+			send: (message) => {
+				if (socket.readyState === WebSocket.OPEN) socket.send(message);
+			},
+			onMessage: (next) => handler = next,
+			onClose: (next) => closed = next,
+			close: () => socket.close()
+		});
+	});
+}
+//#endregion
+//#region src/session/share.ts
+/** How often the host looks whether the world went on, a second: it sends at its own rate */
+var LOOKS$2 = 30;
+/**
+* Shares the page's world through a relay, for others to watch. Fails when the relay cannot be reached
+*
+* @beta
+*/
+async function shareGame(world, options) {
+	const relay = await openSocket(options.url);
+	const host = new SessionHost(world, { sendRate: options.sendRate });
+	/** Each watcher's end of the connection, as the host holds it: what the relay brings from them goes to it */
+	const ends = /* @__PURE__ */ new Map();
+	let state = "shared";
+	let changed = () => {};
+	const ask = (request) => relay.send(JSON.stringify(request));
+	const seat = (id) => {
+		const end = {
+			message: (_text) => {},
+			closed: () => {}
+		};
+		ends.set(id, end);
+		host.connect(options.player, {
+			send: (text) => ask({
+				type: "send",
+				to: id,
+				text
+			}),
+			onMessage: (handler) => end.message = handler,
+			onClose: (handler) => end.closed = handler,
+			close: () => {}
+		}, {
+			readOnly: true,
+			observer: true
+		});
+	};
+	let last = performance.now();
+	const timer = setInterval(() => {
+		const now = performance.now();
+		host.publish((now - last) / 1e3);
+		last = now;
+	}, 1e3 / LOOKS$2);
+	/** Over once: closed, or never shared as the key was taken */
+	const stop = (next = "closed") => {
+		if (state !== "shared") return;
+		clearInterval(timer);
+		host.dispose();
+		ends.clear();
+		state = next;
+		changed();
+	};
+	relay.onMessage((text) => {
+		const notice = JSON.parse(text);
+		if (notice.type === "taken") {
+			stop("taken");
+			relay.close();
+		} else if (notice.type === "watcher") {
+			seat(notice.id);
+			changed();
+		} else if (notice.type === "from") ends.get(notice.watcher)?.message(notice.text);
+		else if (notice.type === "gone") {
+			ends.get(notice.watcher)?.closed();
+			ends.delete(notice.watcher);
+			changed();
+		}
+	});
+	relay.onClose(() => stop());
+	ask({
+		type: "share",
+		key: options.key,
+		name: options.name
+	});
+	return {
+		get state() {
+			return state;
+		},
+		get watchers() {
+			return ends.size;
+		},
+		onChange(handler) {
+			changed = handler;
+		},
+		close() {
+			stop();
+			relay.close();
+		}
+	};
+}
+//#endregion
+//#region src/generateWorker.ts
+/**
+* What a worker's file of a game's maps does: it makes, with the game's generator (`GameModule.generator`) and its
+* registry, the map of each set of options it is sent, and sends it back. A worker's file of two lines, the game's rules
+* imported and this called with them; `port` is where it hears, as for `serveNavigationBuilds`: the worker's own scope
+* when left out
+*
+* @beta
+*/
+function serveMapGenerator(rules, port = globalThis) {
+	let registry;
+	const asked = (message) => {
+		const { id, options } = message;
+		try {
+			if (!rules.generator) throw new Error(`${rules.name} has no generator of maps (GameModule.generator)`);
+			registry ??= createRegistry(rules);
+			port.postMessage({
+				id,
+				made: generateMap(rules.generator, options, registry)
+			});
+		} catch (error) {
+			port.postMessage({
+				id,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	};
+	if (port.on) port.on("message", asked);
+	else port.addEventListener?.("message", (event) => asked(event.data));
+}
+/**
+* Maps made in a worker whose file serves them (`serveMapGenerator`): the page makes the worker as its bundler wants it,
+* `mapGeneratorWorker(() => new Worker(new URL('./generate.worker.ts', import.meta.url), { type: 'module' }))`. Given
+* as a function, the worker is made at the first map asked for: a menu that is never opened fetches none of it
+*
+* @beta
+*/
+function mapGeneratorWorker(given) {
+	let next = 0;
+	const waiting = /* @__PURE__ */ new Map();
+	const answered = (answer) => {
+		const wait = waiting.get(answer.id);
+		if (!wait) return;
+		waiting.delete(answer.id);
+		if (answer.made) wait.done(answer.made);
+		else wait.failed(new Error(answer.error ?? "The map could not be made"));
+	};
+	const broke = (error) => {
+		const reason = /* @__PURE__ */ new Error(`The maps' worker stopped: ${error instanceof Error ? error.message : String(error?.message ?? error)}`);
+		for (const wait of waiting.values()) wait.failed(reason);
+		waiting.clear();
+	};
+	let made;
+	const worker = () => {
+		if (made) return made;
+		made = typeof given === "function" ? given() : given;
+		if (made.on) {
+			made.on("message", (value) => answered(value));
+			made.on("error", broke);
+		} else {
+			made.addEventListener?.("message", (event) => answered(event.data));
+			made.addEventListener?.("error", broke);
+		}
+		return made;
+	};
+	if (typeof given !== "function") worker();
+	return (options) => new Promise((done, failed) => {
+		const id = ++next;
+		waiting.set(id, {
+			done,
+			failed
+		});
+		worker().postMessage({
+			id,
+			options
+		});
+	});
+}
+//#endregion
+//#region src/rulesCheck.ts
+/**
+* Checks a game's rules against themselves (`RulesProblem`): run by `defineGame` with the view's checks, and in a
+* game's tests (`expect(checkRules(rules).filter((p) => p.level === 'error')).toEqual([])`). Nothing is thrown
+*
+* @beta
+*/
+function checkRules(rules) {
+	const problems = [];
+	const ids = (list) => new Set((list ?? []).map((def) => def.id));
+	const units = ids(rules.units);
+	const abilities = ids(rules.abilities);
+	const buffs = ids(rules.buffs);
+	const items = ids(rules.items);
+	const upgrades = ids(rules.upgrades);
+	const resources = ids(rules.resources);
+	/** The types of effect something handles: the engine's own, and the game's (`GameModule.effects`) */
+	const handled = new Set([
+		...coreEffects,
+		...summonEffects,
+		...dispelEffects,
+		...rules.effects ?? []
+	].map((kind) => kind.type));
+	const effectTypes = (type) => handled.has(type);
+	const known = (where, id, set, what) => {
+		if (id === void 0 || set.has(id)) return;
+		const meant = nearestId(id, set);
+		problems.push({
+			level: "error",
+			where,
+			id,
+			message: `${where} names "${id}", which is no ${what} of the rules${meant ? `. Did you mean "${meant}"?` : ""}`
+		});
+	};
+	/** A number that does not do what it is there for: said as a warning, the engine making do with it */
+	const odd = (where, id, message) => problems.push({
+		level: "warning",
+		where,
+		id,
+		message
+	});
+	/** Whether a number, or any of its levels (`Scaled`), is under a bound: at `least`, or above it where `above` */
+	const under = (value, least, above = false) => value !== void 0 && (Array.isArray(value) ? value : [value]).some((each) => above ? each <= least : each < least);
+	const all = (where, list, set, what) => list?.forEach((id, index) => known(`${where}[${index}]`, id, set, what));
+	/** What a requirement names: a unit type (a building to have) or an upgrade */
+	const requirable = /* @__PURE__ */ new Set([...units, ...upgrades]);
+	for (const unit of rules.units) {
+		const at = `units.${unit.id}`;
+		all(`${at}.trains`, unit.trains, units, "unit type");
+		all(`${at}.builds`, unit.builds, units, "unit type");
+		all(`${at}.hires`, unit.hires, units, "unit type");
+		all(`${at}.researches`, unit.researches, upgrades, "upgrade");
+		all(`${at}.requires`, unit.requires, requirable, "unit type or upgrade");
+		all(`${at}.sells`, unit.sells, items, "item");
+		all(`${at}.abilities`, unit.abilities, abilities, "ability");
+		if (typeof unit.upgradesTo === "string") known(`${at}.upgradesTo`, unit.upgradesTo, units, "unit type");
+		else all(`${at}.upgradesTo`, unit.upgradesTo, units, "unit type");
+		if (Array.isArray(unit.drops)) unit.drops.forEach((drop, index) => known(`${at}.drops[${index}].item`, drop.item, items, "item"));
+		if (unit.hero) {
+			all(`${at}.hero.learns`, unit.hero.learns, abilities, "ability");
+			all(`${at}.hero.spells`, unit.hero.spells, abilities, "ability");
+			known(`${at}.hero.meter`, unit.hero.meter, buffs, "buff");
+		}
+	}
+	const effects = (where, list) => {
+		list?.map(anyEffect).forEach((effect, index) => {
+			const at = `${where}[${index}]`;
+			if (!effectTypes(effect.type)) problems.push({
+				level: "error",
+				where: `${at}.type`,
+				id: effect.type,
+				message: `${at} is of the type "${effect.type}", which nothing handles (GameModule.effects)`
+			});
+			known(`${at}.buff`, effect.buff, buffs, "buff");
+			known(`${at}.ifBuff`, effect.ifBuff, buffs, "buff");
+			known(`${at}.whileBuff`, effect.whileBuff, buffs, "buff");
+			known(`${at}.unit`, effect.unit, units, "unit type");
+			known(`${at}.ability`, effect.ability, abilities, "ability");
+			known(`${at}.sell`, effect.sell, resources, "resource");
+			known(`${at}.buy`, effect.buy, resources, "resource");
+			for (const field of ["arc", "bounce"]) if (effect[field] && effect.type !== "missile") odd(`${at}.${field}`, effect.type, `${at}.${field} is read of a missile alone, not of ${effect.type}`);
+			if (effect.arc && !(effect.arc.height > 0)) odd(`${at}.arc.height`, effect.type, `${at}.arc.height is not above 0: it is thrown flat`);
+			if (effect.arc?.time !== void 0 && !(effect.arc.time > 0)) odd(`${at}.arc.time`, effect.type, `${at}.arc.time is not above 0: it flies at its speed`);
+			if (effect.bounce && under(effect.bounce.count, 1)) odd(`${at}.bounce.count`, effect.type, `${at}.bounce.count is under 1 at a level: it does not spring on there`);
+			if (effect.bounce && !(effect.bounce.range > 0)) odd(`${at}.bounce.range`, effect.type, `${at}.bounce.range is not above 0: it finds nothing to spring to`);
+			effects(`${at}.effects`, effect.effects);
+			effects(`${at}.onEnd`, effect.onEnd);
+			effects(`${at}.otherwise`, effect.otherwise);
+		});
+	};
+	for (const ability of rules.abilities ?? []) {
+		const at = `abilities.${ability.id}`;
+		known(`${at}.charge`, ability.charge, buffs, "buff");
+		if (ability.charges && under(ability.charges.count, 1)) odd(`${at}.charges.count`, ability.id, `${at}.charges.count is under 1 at a level: it holds 1 there`);
+		if (ability.charges && under(ability.charges.refill, 0, true)) odd(`${at}.charges.refill`, ability.id, `${at}.charges.refill is not above 0 at a level: a use comes back at once there`);
+		effects(`${at}.effects`, ability.effects);
+		effects(`${at}.passive`, ability.passive);
+	}
+	for (const buff of rules.buffs ?? []) {
+		const at = `buffs.${buff.id}`;
+		if (Array.isArray(buff.onApply)) effects(`${at}.onApply`, buff.onApply);
+		effects(`${at}.onTick.effects`, buff.onTick?.effects);
+	}
+	for (const race of rules.races ?? []) {
+		const start = race.start;
+		if (!start || "spawn" in start) continue;
+		const at = `races.${race.id}.start`;
+		known(`${at}.hall`, start.hall, units, "unit type");
+		known(`${at}.workers.type`, start.workers?.type, units, "unit type");
+		known(`${at}.onMine`, start.onMine, units, "unit type");
+		start.units?.forEach((each, index) => known(`${at}.units[${index}].type`, each.type, units, "unit type"));
+	}
+	for (const item of rules.items ?? []) {
+		const at = `items.${item.id}`;
+		known(`${at}.ability`, item.ability, abilities, "ability");
+		known(`${at}.passive`, item.passive, abilities, "ability");
+		all(`${at}.from`, item.from, items, "item");
+	}
+	for (const upgrade of rules.upgrades ?? []) {
+		const at = `upgrades.${upgrade.id}`;
+		upgrade.requires?.forEach((level, index) => all(`${at}.requires[${index}]`, level, requirable, "unit type or upgrade"));
+		upgrade.effects.forEach((effect, index) => {
+			if (Array.isArray(effect.units)) all(`${at}.effects[${index}].units`, effect.units, units, "unit type");
+		});
+	}
+	const needs = /* @__PURE__ */ new Map();
+	for (const unit of rules.units) if (unit.requires?.length) needs.set(unit.id, unit.requires);
+	for (const upgrade of rules.upgrades ?? []) if (upgrade.requires?.[0]?.length) needs.set(upgrade.id, upgrade.requires[0]);
+	const reported = /* @__PURE__ */ new Set();
+	for (const start of needs.keys()) {
+		const loop = cycleFrom(start, needs);
+		if (!loop) continue;
+		const key = [...loop].sort().join(",");
+		if (reported.has(key)) continue;
+		reported.add(key);
+		problems.push({
+			level: "error",
+			where: `requires`,
+			id: start,
+			message: `What is required waits on itself: ${[...loop, loop[0]].join(" → ")}. None of them can be had`
+		});
+	}
+	const made = /* @__PURE__ */ new Set();
+	for (const unit of rules.units) {
+		for (const id of [
+			...unit.trains ?? [],
+			...unit.builds ?? [],
+			...unit.hires ?? [],
+			...unit.researches ?? []
+		]) made.add(id);
+		for (const id of upgradesOf(unit)) made.add(id);
+	}
+	for (const unit of rules.units) {
+		if (!unit.cost || made.has(unit.id)) continue;
+		problems.push({
+			level: "warning",
+			where: `units.${unit.id}`,
+			id: unit.id,
+			message: `units.${unit.id} has a cost, and nothing trains, builds or hires it`
+		});
+	}
+	for (const upgrade of rules.upgrades ?? []) {
+		if (made.has(upgrade.id)) continue;
+		problems.push({
+			level: "warning",
+			where: `upgrades.${upgrade.id}`,
+			id: upgrade.id,
+			message: `upgrades.${upgrade.id} is researched nowhere (UnitTypeDef.researches)`
+		});
+	}
+	const had = /* @__PURE__ */ new Set();
+	for (const unit of rules.units) for (const id of [
+		...unit.abilities ?? [],
+		...unit.hero?.learns ?? [],
+		...unit.hero?.spells ?? []
+	]) had.add(id);
+	for (const item of rules.items ?? []) for (const id of [item.ability, item.passive]) if (id) had.add(id);
+	const named = (ability) => {
+		const walk = (list) => list?.map(anyEffect).forEach((effect) => (effect.ability && had.add(effect.ability), walk(effect.otherwise)));
+		walk(ability.effects);
+		walk(ability.passive);
+	};
+	for (const ability of rules.abilities ?? []) named(ability);
+	for (const ability of rules.abilities ?? []) {
+		if (had.has(ability.id)) continue;
+		problems.push({
+			level: "warning",
+			where: `abilities.${ability.id}`,
+			id: ability.id,
+			message: `abilities.${ability.id} is on no unit, hero or item`
+		});
+	}
+	return problems.map((problem) => {
+		const at = locate(rules, problem.where);
+		return at ? {
+			...problem,
+			at
+		} : problem;
+	});
+}
+/**
+* The definition and field a place in the rules is (`abilities.holy-light.effects[0].buff`): the kind, the longest id
+* of it the place begins with (an id may have dots), and the rest as a path of the Data panel's (`effects.0.buff`)
+*/
+function locate(rules, where) {
+	const dot = where.indexOf(".");
+	const kind = where.slice(0, dot);
+	if (dot < 0 || !DATA_KINDS.includes(kind)) return void 0;
+	const rest = where.slice(dot + 1);
+	const id = (rules[kind] ?? []).map((def) => def.id).filter((each) => rest === each || rest.startsWith(`${each}.`)).sort((a, b) => b.length - a.length)[0];
+	if (id === void 0) return void 0;
+	return {
+		kind,
+		id,
+		path: rest.slice(id.length + 1).replace(/\[(\d+)\]/g, ".$1")
+	};
+}
+/** A loop of requirements through `start`, in order, or none */
+function cycleFrom(start, needs) {
+	const path = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (id === start && path.length) return [...path];
+		if (seen.has(id)) return void 0;
+		seen.add(id);
+		path.push(id);
+		for (const next of needs.get(id) ?? []) {
+			const found = visit(next);
+			if (found) return found;
+		}
+		path.pop();
+	};
+	return visit(start);
+}
+//#endregion
+//#region src/attributes.ts
+/**
+* The attributes pack's id
+*
+* @beta
+*/
+var ATTRIBUTES = "core.attributes";
+/**
+* The three attributes, in the order a hero's panel shows them
+*
+* @beta
+*/
+var ATTRIBUTE_KEYS = [
+	"strength",
+	"agility",
+	"intelligence"
+];
+/**
+* What a point of each attribute gives, as classic RTS games have it: strength 25 health and 0.05 health a second, agility 0.3
+* armor and 2% attack speed, intelligence 15 mana and 0.05 mana a second
+*
+* @beta
+*/
+var CLASSIC_ATTRIBUTES = {
+	strength: { stats: {
+		health: 25,
+		healthRegen: .05
+	} },
+	agility: {
+		stats: { armor: .3 },
+		percent: { attackSpeed: .02 }
+	},
+	intelligence: { stats: {
+		mana: 15,
+		manaRegen: .05
+	} }
+};
+var attributeStats = [
+	{
+		id: "strength",
+		name: "Strength",
+		description: "Each point adds to health and its regeneration",
+		min: 0
+	},
+	{
+		id: "agility",
+		name: "Agility",
+		description: "Each point adds to armor and attack speed",
+		min: 0
+	},
+	{
+		id: "intelligence",
+		name: "Intelligence",
+		description: "Each point adds to mana and its regeneration",
+		min: 0
+	}
+];
+/** Whether a unit's type starts with any attribute */
+function startsWithAttributes(entity) {
+	const stats = entity.def.stats;
+	return !!stats && !!(stats.strength || stats.agility || stats.intelligence);
+}
+/**
+* What a unit has of each attribute, everything counted (its type, its level, items, buffs, research): its stats'
+* `strength`, `agility` and `intelligence`
+*
+* @beta
+*/
+function attributesOf(world, entity) {
+	const stats = statsOf(world, entity);
+	return {
+		strength: stats.strength ?? 0,
+		agility: stats.agility ?? 0,
+		intelligence: stats.intelligence ?? 0
+	};
+}
+/**
+* A unit's primary attribute, as the attributes pack of its game says it (`AttributesOptions.primaryOf`, else its type's
+* `hero.primary`); none in a game without the pack
+*
+* @beta
+*/
+function primaryAttribute(world, entity) {
+	const pack = world.registry.assembly?.game.packs?.find((each) => each.id === ATTRIBUTES);
+	if (!pack) return void 0;
+	const options = pack.options;
+	return options.primaryOf ? options.primaryOf(world, entity) : entity.def.hero?.primary;
+}
+/**
+* Hero attributes, as in classic RTS games: strength, agility and intelligence are stats (`ATTRIBUTE_KEYS`), and every point
+* of them adds to the others (`AttributesOptions.perPoint`, `CLASSIC_ATTRIBUTES` when left out), the primary one's
+* to the attack too (`hero.primary`, `primaryOf`). What a unit has of them is what it has of any stat: its type's
+* `stats`, its hero's `growth` by level, items' `bonus`, buffs, research and the `stats` hook, all of it added up
+* before the points are turned into the rest. A game without it has no attributes
+*
+* @beta
+*/
+function withAttributes(options = {}) {
+	const perPoint = {
+		...CLASSIC_ATTRIBUTES,
+		...options.perPoint
+	};
+	const primaryBonus = options.primary ?? { stats: { attackDamage: 1 } };
+	const primaryOf = options.primaryOf ?? ((_world, entity) => entity.def.hero?.primary);
+	const points = {
+		id: "attributes",
+		stamp: (entity) => startsWithAttributes(entity) ? heroOf(entity)?.level ?? 1 : 0,
+		add() {},
+		derive(world, entity, sum) {
+			const strength = sum.get("strength");
+			const agility = sum.get("agility");
+			const intelligence = sum.get("intelligence");
+			if (strength) sum.add(perPoint.strength, strength);
+			if (agility) sum.add(perPoint.agility, agility);
+			if (intelligence) sum.add(perPoint.intelligence, intelligence);
+			const primary = primaryOf(world, entity);
+			const of = primary === "strength" ? strength : primary === "agility" ? agility : primary === "intelligence" ? intelligence : 0;
+			if (of) sum.add(primaryBonus, of);
+		}
+	};
+	const made = defineHook({
+		hook: "made",
+		id: "attributes",
+		run(world, entity) {
+			if (startsWithAttributes(entity)) refreshVitals(world, entity);
+		}
+	});
+	return {
+		id: ATTRIBUTES,
+		options,
+		stats: attributeStats,
+		statParts: [points],
+		hooks: [made]
+	};
+}
+//#endregion
+//#region src/manaBurn.ts
+/**
+* The mana burn pack's id
+*
+* @beta
+*/
+var MANA_BURN = "core.manaBurn";
+/**
+* Takes up to `amount` of a unit's mana and hurts it by as much as it took (times `ratio`), from `source`: what the
+* `manaBurn` effect does, for a game's own rules. Gives back the mana it took: none of a unit that has none, and no
+* damage then
+*
+* @beta
+*/
+function burnMana(world, target, amount, source, options = {}) {
+	const burnt = Math.min(Math.max(amount, 0), target.mana);
+	if (burnt <= 0) return 0;
+	target.mana -= burnt;
+	world.events.emit(manaChanged, {
+		entity: target,
+		amount: -burnt,
+		ability: options.ability,
+		source
+	});
+	const damage = burnt * (options.ratio ?? 1);
+	if (damage > 0) world.damage(target, damage, source, {
+		damageType: options.damageType ?? "magic",
+		ability: options.ability
+	});
+	return burnt;
+}
+var manaBurnEffect = defineEffect("manaBurn", (context, effect) => {
+	const { world, caster, level } = context;
+	const amount = scaled(world, caster, at(effect.amount, level), effect.scaling, level);
+	for (const entity of effectTargets(context, effect, "enemies")) burnMana(world, entity, amount, caster, {
+		ratio: effect.ratio,
+		damageType: effect.damageType,
+		ability: context.ability.id
+	});
+}, { fields: [
+	"amount",
+	"scaling",
+	"damageType",
+	{
+		path: "ratio",
+		kind: "number",
+		min: 0,
+		hint: "Times the mana taken it hurts by: 1 when left out"
+	}
+] });
+/**
+* Mana burn, as in classic RTS games: the `manaBurn` effect (`EffectTypes.manaBurn`) takes `amount` of what it reaches of its
+* mana and hurts it by as much (times `ratio`). The demon hunter's spell is an ability with it; Feedback is a passive
+* whose `onHit` has it. `burnMana` does it in code
+*
+* @beta
+*/
+function withManaBurn() {
+	return {
+		id: MANA_BURN,
+		effects: [manaBurnEffect]
+	};
+}
+//#endregion
+//#region src/destructibles.ts
+/**
+* The destructibles pack's id
+*
+* @beta
+*/
+var DESTRUCTIBLES = "core.destructibles";
+/**
+* Destructibles, as in classic RTS games: what is `destructible` (`UnitTypeDef.destructible`, a building of the neutral player
+* placed on the map: rocks, a barricade, a gate to break down) stands in the way until it is brought down, and any unit
+* whose attack reaches it attacks it when told to (the attack command), never of its own accord, as trees are felled
+* by what fells them. A gate that opens and shuts is the map's (`setGate`); one that is broken down is a destructible
+*
+* @beta
+*/
+function withDestructibles(options = {}) {
+	const destructible = options.destructible ?? ((_world, entity) => !!entity.def.destructible);
+	return {
+		id: DESTRUCTIBLES,
+		options,
+		hooks: [defineHook({
+			hook: "canAttack",
+			id: "destructibles",
+			run(world, event) {
+				if (event.allowed || !event.ordered) return;
+				if (destructible(world, event.target) && attackReaches(world, event.attacker, event.target)) event.allowed = true;
+			}
+		})]
+	};
+}
+//#endregion
+//#region src/portals.ts
+/**
+* The portals pack's id
+*
+* @beta
+*/
+var PORTALS = "core.portals";
+/**
+* Where a waygate leads: a point of the map by its name (as the editor's field keeps it), or a place. A waygate without
+* it, or with `null`, is shut
+*
+* @beta
+*/
+var waygate = defineComponent("core.waygate", { field: {
+	name: "Leads to",
+	hint: "The point of the map a unit that walks in comes out at",
+	kind: "point",
+	for: (def) => !!def.waygate
+} });
+/**
+* A unit went through a waygate, or a town portal: told to everyone who sees either end, for a sound and a flash
+*
+* @beta
+*/
+var portalUsed = defineEvent("core.portalUsed", { replicate: "everyone" });
+/** How near a waygate's edge a unit is in it */
+var REACH$1 = .6;
+/**
+* Where a waygate leads, or nothing for one that is shut or leads to a point the map does not have
+*
+* @beta
+*/
+function waygateTarget(world, gate) {
+	const to = gate.get(waygate);
+	if (!to || !gate.alive) return void 0;
+	if (typeof to !== "string") return to;
+	return world.map.points.some((point) => point.name === to) ? world.map.point(to) : void 0;
+}
+/**
+* Says where a waygate leads (a point of the map by its name, or a place), or shuts it (`null`): what the editor's
+* "Leads to" field says of a placed one, in code. Any building can be made a waygate so
+*
+* @beta
+*/
+function setWaygate(gate, to) {
+	gate.set(waygate, typeof to === "object" && to ? {
+		x: to.x,
+		z: to.z
+	} : to);
+}
+/**
+* Puts a unit somewhere at once, on the nearest ground it can stand on: what a waygate and a town portal do, for a game's
+* own rules. Told to everyone (`portalUsed`)
+*
+* @beta
+*/
+function portal(world, entity, to, gate) {
+	const from = {
+		x: entity.pos.x,
+		z: entity.pos.z
+	};
+	const spot = (entity.flying ? world.air : world.nav).closestPoint(to, 6) ?? to;
+	halt(world, entity);
+	world.place(entity, spot);
+	entity.prevPos.x = spot.x;
+	entity.prevPos.z = spot.z;
+	world.events.emit(portalUsed, {
+		entity: entity.id,
+		from,
+		to: {
+			x: spot.x,
+			z: spot.z
+		},
+		gate: gate?.id
+	});
+}
+/** Going through a waygate: walking into it, then out where it leads. Failed when it is shut, or there is no way to it */
+var enterOrder = {
+	type: "enterWaygate",
+	accepts(world, entity, init) {
+		const gate = world.get(init.target);
+		return !!entity.get(moving) && !!gate && !!waygateTarget(world, gate);
+	},
+	update(world, entity, order) {
+		const gate = world.get(order.init.target);
+		const to = gate && waygateTarget(world, gate);
+		if (!gate || !to) return "failed";
+		if (distanceToEdge(entity.pos, gate) - entity.def.radius <= REACH$1) {
+			portal(world, entity, to, gate);
+			return "done";
+		}
+		const m = entity.get(moving);
+		if (m.status === "moving") return "running";
+		if (m.status === "failed" && order.state.tried === world.tick - 1) return "failed";
+		order.state.tried = world.tick;
+		moveToEntity(world, entity, gate, REACH$1 * .5);
+		return "running";
+	}
+};
+/** Offsets around a spot, nearest first: where those a town portal brings stand */
+var AROUND = (() => {
+	const all = [];
+	for (let dz = -3; dz <= 3; dz++) for (let dx = -3; dx <= 3; dx++) all.push({
+		x: dx * 1.2,
+		z: dz * 1.2
+	});
+	return all.sort((a, b) => a.x * a.x + a.z * a.z - (b.x * b.x + b.z * b.z));
+})();
+/**
+* Takes a unit and as many as `count` of its owner's units within `radius` of it, nearest first, to its side's home
+* nearest `near` (`homeOf`), spread around it: what the `townPortal` effect does, in code. Gives back who went, none
+* when the side has no home
+*
+* @beta
+*/
+function townPortal(world, caster, near, radius = 7, count = 12) {
+	const home = homeOf(world, caster.owner, near);
+	if (!home) return [];
+	const going = [caster, ...world.spatial.query(caster.pos.x, caster.pos.z, radius).filter((entity) => entity !== caster && entity.alive && !entity.hidden && entity.owner === caster.owner && !!entity.get(moving) && distanceToEdge(caster.pos, entity) <= radius).map((entity) => ({
+		entity,
+		d: distSq(entity.pos, caster.pos)
+	})).sort((a, b) => a.d - b.d || a.entity.id - b.entity.id).slice(0, Math.max(0, count)).map(({ entity }) => entity)];
+	going.forEach((entity, i) => {
+		const offset = AROUND[i % AROUND.length];
+		portal(world, entity, {
+			x: home.x + offset.x,
+			z: home.z + offset.z
+		});
+	});
+	return going;
+}
+var townPortalEffect = defineEffect("townPortal", (context, effect) => {
+	const { world, caster, point, level } = context;
+	townPortal(world, caster, point, at(effect.radius, level, 7), Math.round(at(effect.count, level, 12)));
+}, { fields: ["count"] });
+/**
+* Portals, as in classic RTS games: waygates (`UnitTypeDef.waygate`), which a unit told to (a right-click, as any building is
+* walked up to) walks into and comes out of where the gate leads (the "Leads to" field of a placed one, a point of the
+* map; `setWaygate` in code), and the `townPortal` effect (`EffectTypes.townPortal`), which takes the caster and its
+* units around it to its side's home nearest where it was aimed (`homeOf`: the map's `home.<team>` point, or the
+* nearest of its buildings). `portal` and `townPortal` do them in code
+*
+* @beta
+*/
+function withPortals() {
+	const intoGate = defineHook({
+		hook: "beforeOrder",
+		id: "portals",
+		run(world, event) {
+			const { order, entity } = event;
+			if (order.type !== "move" || order.init.target === void 0) return;
+			const gate = world.get(order.init.target);
+			if (!gate?.def.waygate || !waygateTarget(world, gate) || !entity.get(moving)) return;
+			event.rejected = true;
+			giveOrder(world, entity, createOrder(world, {
+				type: "enterWaygate",
+				target: gate.id
+			}, order.groupId), event.queued);
+		}
+	});
+	return {
+		id: PORTALS,
+		orders: [enterOrder],
+		components: [waygate],
+		events: [portalUsed],
+		effects: [townPortalEffect],
+		hooks: [intoGate]
+	};
+}
+//#endregion
+//#region src/runes.ts
+/**
+* The runes pack's id
+*
+* @beta
+*/
+var RUNES = "core.runes";
+/**
+* Uses an item on the ground as a rune is used: whoever picked it casts its ability (where it stands, no mana), and it
+* is gone from the ground, told as an item picked (`itemPicked`). What the runes pack does as a unit walks over one;
+* false for an item not on the ground
+*
+* @beta
+*/
+function usePowerUp(world, entity, groundId) {
+	const index = world.items.findIndex((item) => item.id === groundId);
+	if (index < 0) return false;
+	const [item] = world.items.splice(index, 1);
+	const instance = createItem(world, item.item, item.charges);
+	instance.id = item.id;
+	world.events.emit(itemPicked, {
+		entity,
+		item: instance
+	});
+	const ability = world.registry.item(item.item).ability;
+	if (ability) fire(world, entity, world.registry.ability(ability), void 0, instance);
+	return true;
+}
+/**
+* Runes, as in classic RTS games: an item that is a power-up (`ItemDef.powerUp`, `RunesOptions.powerUp` in code) is used as
+* it is picked up, by a unit that walks over it (`RunesOptions.takes`) or is told to pick it up, and never carried:
+* whoever picked it casts its ability where it stands. A rune of healing is an item whose ability heals around; a tome
+* one whose ability has the tomes pack's `tome` effect. `usePowerUp` does it in code
+*
+* @beta
+*/
+function withRunes(options = {}) {
+	const powerUp = options.powerUp ?? ((item) => !!item.powerUp);
+	const takes = options.takes ?? ((world, entity) => entity.isUnit && !entity.hidden && !world.player(entity.owner).neutral && !entity.def.invulnerable);
+	const walkedOver = {
+		name: "runes",
+		phase: "cleanup",
+		every: Math.max(1, Math.round(options.every ?? 3)),
+		update(world) {
+			if (!world.items.length) return;
+			for (const item of [...world.items]) {
+				if (!powerUp(world.registry.item(item.item))) continue;
+				for (const entity of world.spatial.query(item.x, item.z, REACH)) {
+					if (!entity.alive || distanceToEdge(item, entity) > 1.2 || !takes(world, entity, item)) continue;
+					usePowerUp(world, entity, item.id);
+					break;
+				}
+			}
+		}
+	};
+	const ordered = defineHook({
+		hook: "beforePickUp",
+		id: "runes",
+		run(world, event) {
+			if (!powerUp(world.registry.item(event.item))) return;
+			event.cancelled = true;
+			usePowerUp(world, event.entity, event.ground);
+		}
+	});
+	return {
+		id: RUNES,
+		options,
+		systems: [walkedOver],
+		hooks: [ordered]
+	};
+}
+//#endregion
+//#region src/tomes.ts
+/**
+* The tomes pack's id
+*
+* @beta
+*/
+var TOMES = "core.tomes";
+/**
+* What a unit gained for good from tomes or the game's own rules (`gainStats`): saved with it
+*
+* @beta
+*/
+var gainedStats = defineComponent("core.gainedStats");
+/**
+* Gives a unit stats for good, as a tome does: added to what it gained before, kept with it in a save, its health and
+* mana raised with them. For the tomes pack's `tome` effect and a game's own rules (a shrine that makes a unit
+* stronger); it works in a game with the tomes pack (`withTomes`), which adds what was gained to the stats
+*
+* @beta
+*/
+function gainStats(world, entity, change) {
+	const had = entity.get(gainedStats);
+	const next = {
+		stats: { ...had?.stats },
+		percent: { ...had?.percent },
+		times: (had?.times ?? 0) + 1
+	};
+	for (const key in change.stats) next.stats[key] = (next.stats[key] ?? 0) + change.stats[key];
+	for (const key in change.percent) next.percent[key] = (next.percent[key] ?? 0) + change.percent[key];
+	entity.set(gainedStats, next);
+	invalidateStats(world, entity);
+	refreshVitals(world, entity);
+}
+/** A tome read: what it gives for good, the experience and the levels it gives a hero */
+var tomeEffect = defineEffect("tome", (context, effect) => {
+	const { world } = context;
+	for (const entity of effectTargets(context, effect, "allies")) {
+		if (effect.gain) gainStats(world, entity, effect.gain);
+		if (effect.xp) grantXp(world, entity, effect.xp);
+		for (let i = 0; i < (effect.levels ?? 0); i++) {
+			const hero = heroOf(entity);
+			if (!hero || hero.level >= maxLevelOf(world, entity)) break;
+			grantXp(world, entity, world.rules.heroes.xpForLevel(hero.level + 1) - hero.xp);
+		}
+	}
+}, { fields: [{
+	path: "xp",
+	kind: "integer",
+	min: 0,
+	hint: "Experience a hero gains"
+}, {
+	path: "levels",
+	kind: "integer",
+	min: 0,
+	hint: "Levels a hero gains"
+}] });
+/** What was gained, added to the stats: worked out again each time something is gained */
+var gained = {
+	id: "tomes",
+	stamp: (entity) => entity.get(gainedStats)?.times ?? 0,
+	add(_world, entity, sum) {
+		const had = entity.get(gainedStats);
+		if (had) sum.add(had);
+	}
+};
+/**
+* Tomes, as in classic RTS games: the `tome` effect (`EffectTypes.tome`) gives what it reaches stats for good (`gain`: a
+* point of strength with the attributes pack), a hero experience (`xp`) and levels (`levels`). A tome is an item whose
+* ability has the effect, with a charge, used from the inventory, or as it is picked up with the runes pack
+* (`withRunes`). What a unit gained is kept with it and in a save (`gainedStats`), and a game gives it from its own
+* rules with `gainStats`
+*
+* @beta
+*/
+function withTomes() {
+	return {
+		id: TOMES,
+		components: [gainedStats],
+		effects: [tomeEffect],
+		statParts: [gained]
+	};
+}
+//#endregion
+//#region src/walls.ts
+/**
+* A piece of wall took another shape, or turned: a piece came or went beside it
+*
+* @beta
+*/
+var wallJoined = defineEvent("core.wallJoined", { replicate: "everyone" });
+/** The four sides, as the cell beside and the facing toward it */
+var SIDES = [
+	{
+		dx: 1,
+		dz: 0,
+		facing: 0
+	},
+	{
+		dx: 0,
+		dz: 1,
+		facing: Math.PI / 2
+	},
+	{
+		dx: -1,
+		dz: 0,
+		facing: Math.PI
+	},
+	{
+		dx: 0,
+		dz: -1,
+		facing: -Math.PI / 2
+	}
+];
+var near = [];
+/** The live piece of a family standing on the cell of this point: by its footprint, a gate wider than a cell too */
+function pieceAt(world, family, x, z) {
+	const cx = Math.floor(x) + .5;
+	const cz = Math.floor(z) + .5;
+	for (const other of world.spatial.query(cx, cz, 2, near)) {
+		if (!other.alive || other.def.wall?.family !== family) continue;
+		const rect = other.rect;
+		if (Math.abs(cx - rect.x) < rect.hw && Math.abs(cz - rect.z) < rect.hd) return other;
+	}
+}
+/** The cell just past a piece's side: the next cell for a piece of one, past its footprint for a wider one (a gate) */
+var besideOf = (rect, dx, dz) => ({
+	x: rect.x + dx * (rect.hw + .5),
+	z: rect.z + dz * (rect.hd + .5)
+});
+/**
+* The shape of a piece by the sides it has a piece of its family on (east, north, west, south), and which way it faces:
+* an end toward its one neighbour, a straight piece along its line, a corner toward the first of its two sides, a tee
+* toward the side it has none on
+*
+* @internal
+*/
+function wallShapeOf(sides) {
+	const count = sides.filter(Boolean).length;
+	if (count === 0) return {
+		shape: "single",
+		facing: 0
+	};
+	if (count === 4) return {
+		shape: "cross",
+		facing: 0
+	};
+	if (count === 1) return {
+		shape: "end",
+		facing: SIDES[sides.indexOf(true)].facing
+	};
+	if (count === 3) return {
+		shape: "tee",
+		facing: SIDES[(sides.indexOf(false) + 2) % 4].facing
+	};
+	if (sides[0] === sides[2]) return {
+		shape: "straight",
+		facing: sides[0] ? 0 : Math.PI / 2
+	};
+	return {
+		shape: "corner",
+		facing: SIDES[sides[0] && sides[1] ? 0 : sides[1] && sides[2] ? 1 : sides[2] && sides[3] ? 2 : 3].facing
+	};
+}
+/** Works out a piece's shape from its neighbours again, and says so where it changed */
+function reshape(world, piece) {
+	const family = piece.def.wall?.family;
+	if (!family || !piece.alive) return;
+	const rect = piece.rect;
+	const { shape, facing } = wallShapeOf(SIDES.map(({ dx, dz }) => {
+		const beside = besideOf(rect, dx, dz);
+		return !!pieceAt(world, family, beside.x, beside.z);
+	}));
+	const look = piece.def.wall?.gate ? piece.look : shape;
+	if (piece.look === look && piece.facing === facing) return;
+	piece.look = look;
+	piece.facing = facing;
+	world.events.emit(wallJoined, {
+		entity: piece.id,
+		shape,
+		facing
+	});
+}
+/** A piece and the pieces of its family beside it, shaped again: one came, or went */
+function reshapeAround(world, rect, family, self) {
+	if (self) reshape(world, self);
+	for (const { dx, dz } of SIDES) {
+		const beside = besideOf(rect, dx, dz);
+		const other = pieceAt(world, family, beside.x, beside.z);
+		if (other && other !== self) reshape(world, other);
+	}
+}
+/**
+* The cells of a wall along a drag, as the genre lays one: along the longer of its two directions first, then the
+* other, a cell's middle each (`x + 0.5`), from where it started to where it ended, each once
+*
+* @beta
+*/
+function wallLine(from, to) {
+	const x0 = Math.floor(from.x);
+	const z0 = Math.floor(from.z);
+	const x1 = Math.floor(to.x);
+	const z1 = Math.floor(to.z);
+	const cells = [];
+	const stepX = Math.sign(x1 - x0);
+	const stepZ = Math.sign(z1 - z0);
+	const alongX = Math.abs(x1 - x0) >= Math.abs(z1 - z0);
+	let x = x0;
+	let z = z0;
+	cells.push({
+		x: x + .5,
+		z: z + .5
+	});
+	const walk = (axis) => {
+		if (axis === "x") while (x !== x1) {
+			x += stepX;
+			cells.push({
+				x: x + .5,
+				z: z + .5
+			});
+		}
+		else while (z !== z1) {
+			z += stepZ;
+			cells.push({
+				x: x + .5,
+				z: z + .5
+			});
+		}
+	};
+	walk(alongX ? "x" : "z");
+	walk(alongX ? "z" : "x");
+	return cells;
+}
+/**
+* Lays a wall along a drag with the player's builders: a build order for each cell of the line (`wallLine`), queued
+* after one another (after what they were doing, with `queue`), for the first builder of theirs among the ids that can
+* build the type. What cannot be built where it is (a unit, a tree in the way) is refused there as one built by hand is
+*
+* @beta
+*/
+var buildLineCommand = defineCommand("buildLine", {
+	entities: ids,
+	unitType: string,
+	from: point,
+	to: point,
+	queue: optional(bool)
+}, (world, player, command) => {
+	if (!world.registry.units.has(command.unitType)) return;
+	const builder = command.entities.map((id) => world.get(id)).find((entity) => entity?.alive && entity.owner === player && entity.def.builds?.includes(command.unitType));
+	if (!builder) return;
+	wallLine(command.from, command.to).forEach((cell, index) => {
+		giveOrder(world, builder, createOrder(world, {
+			type: "build",
+			unitType: command.unitType,
+			point: cell
+		}), index > 0 || !!command.queue);
+	});
+});
+/**
+* A gate of a wall (`UnitTypeDef.wall.gate`): whether it stands open, every screen told. Open, it is in nobody's way,
+* whoever walks; shut, it is a piece of the wall. Its owner opens and shuts it (`wallGateCommand`, `setWallGate`)
+*
+* @beta
+*/
+var wallGate = defineComponent("walls.gate", {
+	replicate: "everyone",
+	onSpawn(entity) {
+		if (!entity.def.wall?.gate) return;
+		entity.set(wallGate, { open: false });
+		entity.look = "shut";
+	},
+	passable: (gate) => gate.open
+});
+/**
+* A gate of a wall opened or shut (`setWallGate`)
+*
+* @beta
+*/
+var wallGateChanged = defineEvent("core.wallGateChanged", { replicate: "everyone" });
+/**
+* Opens or shuts a gate of a wall, for everyone: open, what walks goes through its cell, whoever's; shut, around it.
+* Its look is `open` or `shut`. False for what is no gate, or one still going up
+*
+* @beta
+*/
+function setWallGate(world, gate, open) {
+	const now = gate.get(wallGate);
+	if (!now || !gate.alive || gate.has(constructionSite)) return false;
+	if (now.open === open) return true;
+	gate.set(wallGate, { open });
+	gate.look = open ? "open" : "shut";
+	if (open) world.nav.removeObstacle(gate.id);
+	else if (!world.nav.addObstacle(gate.id, gate.rect)) world.log.warn("navigation", `There is no room for another obstacle: the gate ${gate.id} does not block the way`, { entity: gate.id });
+	world.events.emit(wallGateChanged, {
+		entity: gate.id,
+		open
+	});
+	return true;
+}
+/**
+* Its owner opens or shuts a gate of a wall (`setWallGate`), for everyone
+*
+* @beta
+*/
+var wallGateCommand = defineCommand("wallGate", {
+	entity: id,
+	open: bool
+}, (world, player, command) => {
+	const gate = world.get(command.entity);
+	if (gate?.owner === player) setWallGate(world, gate, command.open);
+});
+/**
+* Walls for a game: its pieces (types with `wall: { family }`) join with their neighbours as they are put down and
+* taken away, and a builder lays a line of them (`buildLineCommand`). A game's pieces draw by their shape with
+* `UnitLook.looks` (`single`, `end`, `straight`, `corner`, `tee`, `cross`); its gates (`wall.gate`) by `open` and `shut`,
+* opened and shut by their owner (`wallGateCommand`)
+*
+* @beta
+*/
+function withWalls() {
+	const spawnHook = defineHook({
+		hook: "spawn",
+		id: "core.walls.spawn",
+		run(world, entity) {
+			const family = entity.def.wall?.family;
+			if (family) reshapeAround(world, entity.rect, family, entity);
+		}
+	});
+	const removeHook = defineHook({
+		hook: "remove",
+		id: "core.walls.remove",
+		run(world, entity) {
+			const family = entity.def.wall?.family;
+			if (family) reshapeAround(world, entity.rect, family);
+		}
+	});
+	return {
+		id: "walls",
+		commands: [buildLineCommand, wallGateCommand],
+		components: [wallGate],
+		events: [wallJoined, wallGateChanged],
+		hooks: [spawnHook, removeHook]
+	};
+}
+//#endregion
+//#region src/mapMeasure.ts
+function walking(map, registry) {
+	const { width, depth, levels, ramps } = map;
+	const { open } = mapCells(map, registry, mapTerrain(map), true);
+	const cellAt = (point) => {
+		const cx = Math.floor(point.x);
+		const cz = Math.floor(point.z);
+		for (let r = 0; r <= 6; 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 || Math.max(Math.abs(x - cx), Math.abs(z - cz)) !== r) continue;
+			if (open[z * width + x]) return z * width + x;
+		}
+		return -1;
+	};
+	return {
+		width,
+		depth,
+		open,
+		passable: (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0,
+		cellAt
+	};
+}
+/** The way on foot between two cells: A* over the cells, eight ways, corners not cut. Nothing when there is none */
+function walk(walking, from, to) {
+	const { width, depth, open, passable } = walking;
+	if (from < 0 || to < 0) return void 0;
+	const cells = width * depth;
+	const cost = new Float32Array(cells).fill(Infinity);
+	const came = new Int32Array(cells).fill(-1);
+	const closed = new Uint8Array(cells);
+	const tx = to % width;
+	const tz = Math.floor(to / width);
+	const guess = (c) => {
+		const dx = Math.abs(c % width - tx);
+		const dz = Math.abs(Math.floor(c / width) - tz);
+		return Math.max(dx, dz) + (Math.SQRT2 - 1) * Math.min(dx, dz);
+	};
+	const heap = [];
+	const score = new Float32Array(cells);
+	const push = (c) => {
+		heap.push(c);
+		let i = heap.length - 1;
+		while (i > 0) {
+			const parent = i - 1 >> 1;
+			if (score[heap[parent]] <= score[heap[i]]) break;
+			[heap[parent], heap[i]] = [heap[i], heap[parent]];
+			i = parent;
+		}
+	};
+	const pop = () => {
+		const top = heap[0];
+		const last = heap.pop();
+		if (heap.length) {
+			heap[0] = last;
+			let i = 0;
+			for (;;) {
+				const left = i * 2 + 1;
+				const right = left + 1;
+				let least = i;
+				if (left < heap.length && score[heap[left]] < score[heap[least]]) least = left;
+				if (right < heap.length && score[heap[right]] < score[heap[least]]) least = right;
+				if (least === i) break;
+				[heap[least], heap[i]] = [heap[i], heap[least]];
+				i = least;
+			}
+		}
+		return top;
+	};
+	cost[from] = 0;
+	score[from] = guess(from);
+	push(from);
+	while (heap.length) {
+		const c = pop();
+		if (closed[c]) continue;
+		if (c === to) break;
+		closed[c] = 1;
+		const x = c % width;
+		const z = (c - x) / width;
+		for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
+			if (!dx && !dz) continue;
+			const nx = x + dx;
+			const nz = z + dz;
+			if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+			const n = nz * width + nx;
+			if (!open[n] || closed[n] || !passable(c, n)) continue;
+			if (dx && dz) {
+				const side1 = z * width + nx;
+				const side2 = nz * width + x;
+				if (!open[side1] || !open[side2] || !passable(c, side1) || !passable(c, side2)) continue;
+			}
+			const next = cost[c] + (dx && dz ? Math.SQRT2 : 1);
+			if (next >= cost[n]) continue;
+			cost[n] = next;
+			came[n] = c;
+			score[n] = next + guess(n);
+			push(n);
+		}
+	}
+	if (!Number.isFinite(cost[to])) return void 0;
+	const points = [];
+	for (let c = to; c >= 0; c = came[c]) points.push({
+		x: c % width + .5,
+		z: Math.floor(c / width) + .5
+	});
+	return {
+		length: cost[to],
+		points: points.reverse()
+	};
+}
+/**
+* The way on foot between two points of a map, with what the checks count as in the way. Nothing when there is none
+*
+* @beta
+*/
+function walkBetween(map, registry, from, to) {
+	const cells = walking(map, registry);
+	return walk(cells, cells.cellAt(from), cells.cellAt(to));
+}
+/**
+* How many cells each open cell is from what is not: half the width of the way there. A passage two cells wide has
+* cells 1 from its sides in its middle
+*/
+function clearance(walking) {
+	const { width, depth, open } = walking;
+	const far = new Float32Array(width * depth);
+	for (let c = 0; c < far.length; c++) far[c] = open[c] ? Infinity : 0;
+	const step = (c, x, z, dx, dz, weight) => {
+		const nx = x + dx;
+		const nz = z + dz;
+		const next = nx < 0 || nz < 0 || nx >= width || nz >= depth ? 0 : far[nz * width + nx];
+		if (next + weight < far[c]) far[c] = next + weight;
+	};
+	for (let z = 0; z < depth; z++) for (let x = 0; x < width; x++) {
+		const c = z * width + x;
+		if (!far[c]) continue;
+		step(c, x, z, -1, 0, 1);
+		step(c, x, z, 0, -1, 1);
+		step(c, x, z, -1, -1, Math.SQRT2);
+		step(c, x, z, 1, -1, Math.SQRT2);
+	}
+	for (let z = depth - 1; z >= 0; z--) for (let x = width - 1; x >= 0; x--) {
+		const c = z * width + x;
+		if (!far[c]) continue;
+		step(c, x, z, 1, 0, 1);
+		step(c, x, z, 0, 1, 1);
+		step(c, x, z, 1, 1, Math.SQRT2);
+		step(c, x, z, -1, 1, Math.SQRT2);
+	}
+	return far;
+}
+/**
+* How far around a start counts as its ground, for building and trees
+*
+* @beta
+*/
+var BUILD_REACH = 16;
+/**
+* How much more one start can have of something than another before it is not fair, as a part
+*
+* @internal
+*/
+var FAIR_MARGIN = .15;
+/** The ends of a way, in cells, where the bases stand: the narrowest place is looked for between them */
+var BASE_ROOM = 8;
+/**
+* What a map is like to play on: the way on foot between every two starts, the narrowest place on those ways, and for
+* each start the nearest mine and how much it holds, the ground around it that can be built on, and its trees; side
+* by side, with what one start has much more of than another said. Then what the game measures of its own
+*
+* @beta
+*/
+function measureMap(map, registry) {
+	const cells = walking(map, registry);
+	const terrain = mapTerrain(map);
+	const grid = new BuildGrid(terrain);
+	const { built } = mapCells(map, registry, terrain);
+	const starts = map.players.filter((player) => player.start);
+	const rushes = [];
+	for (let i = 0; i < starts.length; i++) for (let j = i + 1; j < starts.length; j++) {
+		const way = walk(cells, cells.cellAt(starts[i].start), cells.cellAt(starts[j].start));
+		rushes.push({
+			from: starts[i].id,
+			to: starts[j].id,
+			...way && {
+				length: Math.round(way.length * 10) / 10,
+				points: way.points
+			}
+		});
+	}
+	const far = clearance(cells);
+	let narrowest;
+	for (const rush of rushes) {
+		const points = rush.points ?? [];
+		for (let i = BASE_ROOM; i < points.length - BASE_ROOM; i++) {
+			const c = Math.floor(points[i].z) * cells.width + Math.floor(points[i].x);
+			const width = Math.round((far[c] * 2 - 1) * 10) / 10;
+			if (!narrowest || width < narrowest.width) narrowest = {
+				width,
+				at: points[i]
+			};
+		}
+	}
+	const mines = map.objects.filter((object) => {
+		if (!registry.units.has(object.type)) return false;
+		const def = registry.unit(object.type);
+		return def.kind === "resource" && footprintOf(def).w >= 2;
+	});
+	const measures = starts.map((player) => {
+		const start = player.start;
+		const from = cells.cellAt(start);
+		let mine;
+		for (const object of mines) {
+			const way = walk(cells, from, cells.cellAt(object));
+			if (!way || mine && way.length >= mine.distance) continue;
+			const def = registry.unit(object.type);
+			mine = {
+				distance: Math.round(way.length * 10) / 10,
+				amount: object.amount ?? def.resource?.amount ?? 0,
+				at: {
+					x: object.x,
+					z: object.z
+				}
+			};
+		}
+		let buildable = 0;
+		for (let z = Math.floor(start.z - 16); z <= Math.ceil(start.z + 16); z++) for (let x = Math.floor(start.x - 16); x <= Math.ceil(start.x + 16); x++) {
+			if (hypot(x + .5 - start.x, z + .5 - start.z) > 16) continue;
+			if (grid.isBuildable(x, z) && !built[z * map.width + x]) buildable++;
+		}
+		const trees = map.objects.filter((object) => {
+			if (!registry.units.has(object.type) || hypot(object.x - start.x, object.z - start.z) > 16) return false;
+			const def = registry.unit(object.type);
+			return def.kind === "resource" && footprintOf(def).w < 2;
+		}).length;
+		return {
+			player: player.id,
+			name: player.name,
+			...mine && { mine },
+			buildable,
+			trees
+		};
+	});
+	const unfair = [];
+	const compare = (what, value, more = "more") => {
+		const known = measures.map((start) => ({
+			start,
+			value: value(start)
+		})).filter((entry) => entry.value !== void 0);
+		if (known.length < 2) return;
+		const most = known.reduce((a, b) => b.value > a.value ? b : a);
+		const least = known.reduce((a, b) => b.value < a.value ? b : a);
+		if (most.value > least.value * 1.15 && most.value - least.value > 1) unfair.push(`${most.start.name} has ${more} ${what} than ${least.start.name}: ${most.value} against ${least.value}`);
+	};
+	compare("way to their nearest mine", (start) => start.mine?.distance, "a longer");
+	compare("gold in their nearest mine", (start) => start.mine?.amount);
+	compare("ground to build on", (start) => start.buildable);
+	compare("trees near their start", (start) => start.trees);
+	return {
+		rushes: rushes.map(({ points: _, ...rush }) => rush),
+		...narrowest && { narrowest },
+		starts: measures,
+		unfair,
+		game: registry.module?.editor?.measure?.(map, registry) ?? []
+	};
+}
+/**
+* Seconds a unit type takes over a way on foot, at the speed it starts with
+*
+* @beta
+*/
+var walkingTime = (registry, type, length) => {
+	if (!registry.units.has(type)) return void 0;
+	const speed = registry.unit(type).stats.moveSpeed ?? 0;
+	return speed > 0 ? Math.round(length / speed * 10) / 10 : void 0;
+};
+//#endregion
+//#region src/scenario.ts
+/**
+* The format scenarios are written in now
+*
+* @beta
+*/
+var SCENARIO_FORMAT = 1;
+/**
+* A scenario file as it is now, checked. Throws on what is wrong with it
+*
+* @beta
+*/
+function readScenario(data) {
+	if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error("A scenario is an object");
+	const file = data;
+	if (typeof file.format !== "number" || file.format > 1) throw new Error(`A scenario of format ${file.format}, which this engine does not know`);
+	if (typeof file.name !== "string" || !file.name) throw new Error("A scenario has a name");
+	if (typeof file.game !== "string" || !file.game) throw new Error(`The scenario ${file.name} does not say which game it is of`);
+	if (file.kind === "map") parseMap(file.map);
+	else if (file.kind === "save") {
+		if (typeof file.save !== "string") throw new Error(`The scenario ${file.name} has no save in it`);
+	} else throw new Error(`The scenario ${file.name} is neither a map nor a save`);
+	return {
+		...file,
+		format: 1
+	};
+}
+/**
+* A map made for a test, as a scenario
+*
+* @beta
+*/
+function scenarioOfMap(map, name, game, description) {
+	return {
+		format: 1,
+		name,
+		game,
+		...description && { description },
+		kind: "map",
+		map: serializeMap(map)
+	};
+}
+/**
+* A world at the moment that matters, as a scenario
+*
+* @beta
+*/
+function scenarioOfWorld(world, name, description) {
+	return {
+		format: 1,
+		name,
+		game: world.registry.game,
+		...description && { description },
+		kind: "save",
+		save: encodeSave(portableSave(world.registry, saveWorld(world)))
+	};
+}
+/** Only what is the game's: what an app keeps of its own in the world (`Component.portable` false) left out */
+function portableSave(registry, save) {
+	const keep = (values) => values && Object.fromEntries(Object.entries(values).filter(([id]) => registry.component(id)?.portable !== false));
+	return {
+		...save,
+		state: keep(save.state),
+		players: save.players.map((player) => ({
+			...player,
+			state: keep(player.state)
+		})),
+		entities: save.entities.map((entity) => entity.components ? {
+			...entity,
+			components: keep(entity.components)
+		} : entity),
+		detached: save.detached.map((entity) => entity.components ? {
+			...entity,
+			components: keep(entity.components)
+		} : entity)
+	};
+}
+/**
+* The world of a scenario, with the game's module: a map made into a world as a game would make it (with the seed 1,
+* so that it is the same every time), or a saved world loaded as it was
+*
+* @beta
+*/
+async function scenarioWorld(scenario, game) {
+	if (scenario.game !== game.id) throw new Error(`The scenario ${scenario.name} is of the game "${scenario.game}", not "${game.id}"`);
+	if (scenario.kind === "map") return createWorldFromMap({
+		map: parseMap(scenario.map),
+		game,
+		seed: 1
+	});
+	return loadWorld(decodeSave(scenario.save), { game });
+}
+//#endregion
+//#region src/packs/heroes/carry.ts
+/**
+* A hero of a world as a record, to carry into another (see `applyHeroRecord`). Throws for what is no hero
+*
+* @beta
+*/
+function heroRecord(world, hero) {
+	const state = heroOf(hero);
+	if (!state) throw new Error(`${hero.def.id} is no hero to carry over`);
+	const name = world.nameOf(hero);
+	return {
+		type: hero.def.id,
+		...name !== void 0 && { name },
+		level: state.level,
+		xp: state.xp,
+		points: state.points,
+		abilities: Object.fromEntries(hero.abilities.filter((ability) => ability.level > 0).map((ability) => [ability.id, ability.level])),
+		items: (slotsOf(hero) ?? []).map((slot) => slot ? {
+			item: slot.item,
+			charges: slot.charges,
+			...slot.data && { data: structuredClone(slot.data) }
+		} : null)
+	};
+}
+/**
+* Makes a hero of a world what a record says it was: its level, experience and points, its abilities as far as they
+* were learned, and its items in their slots. In place of what it had. What the game no longer has, an ability or an
+* item, is left out. Whole: health and mana full, nothing cooling down
+*
+* @beta
+*/
+function applyHeroRecord(world, hero, record) {
+	const state = heroOf(hero);
+	if (!state) throw new Error(`${hero.def.id} is no hero to carry a hero into`);
+	state.level = Math.max(1, Math.min(Math.floor(record.level), maxLevelOf(world, hero)));
+	state.xp = Math.max(record.xp, world.rules.heroes.xpForLevel(state.level));
+	state.points = Math.max(Math.floor(record.points), 0);
+	for (const ability of hero.abilities) {
+		const level = record.abilities[ability.id] ?? 0;
+		const max = world.registry.abilities.has(ability.id) ? world.registry.ability(ability.id).maxLevel ?? 3 : 0;
+		ability.level = Math.min(level, max);
+		readyAgain(ability);
+		ability.autocast = ability.level > 0 && (world.registry.ability(ability.id).autocast ?? false);
+	}
+	const slots = slotsOf(hero);
+	if (slots) {
+		slots.fill(null);
+		record.items.forEach((carried, slot) => {
+			if (!carried || slot >= slots.length || !world.registry.items.has(carried.item)) return;
+			const instance = createItem(world, carried.item, carried.charges);
+			if (carried.data) instance.data = structuredClone(carried.data);
+			slots[slot] = instance;
+		});
+		world.events.emit(inventoryChanged, { entity: hero });
+	}
+	refreshVitals(world, hero);
+	hero.hp = hero.maxHp;
+	hero.mana = hero.maxMana;
+}
+/**
+* A hero made from a record (see `heroRecord`) for a player at a point, under the name it had unless told another
+*
+* @beta
+*/
+function heroFromRecord(world, record, owner, at, options = {}) {
+	const name = options.name ?? record.name;
+	const hero = world.spawn(record.type, owner, at, {
+		...options,
+		...name !== void 0 && { name }
+	});
+	applyHeroRecord(world, hero, record);
+	return hero;
+}
+/**
+* A record read back from what was kept (a campaign's progress, a file), checked. Throws on what is wrong
+*
+* @beta
+*/
+function readHeroRecord(data) {
+	const record = data;
+	if (typeof record !== "object" || record === null) throw new Error("A hero record is an object");
+	if (typeof record.type !== "string" || !record.type) throw new Error("A hero record says what type of unit it is");
+	const number = (value, what) => {
+		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`A hero record's ${what} is a number`);
+		return value;
+	};
+	const abilities = record.abilities ?? {};
+	if (typeof abilities !== "object" || Array.isArray(abilities)) throw new Error("A hero record's abilities are levels by id");
+	return {
+		type: record.type,
+		...typeof record.name === "string" && { name: record.name },
+		level: number(record.level, "level"),
+		xp: number(record.xp ?? 0, "experience"),
+		points: number(record.points ?? 0, "points"),
+		abilities: Object.fromEntries(Object.entries(abilities).map(([id, level]) => [id, number(level, `level of ${id}`)])),
+		items: (Array.isArray(record.items) ? record.items : []).map((slot) => slot && typeof slot === "object" && typeof slot.item === "string" ? {
+			item: slot.item,
+			charges: number(slot.charges ?? 0, "charges"),
+			...slot.data && { data: slot.data }
+		} : null)
+	};
+}
+//#endregion
+//#region src/packs/heroes/campaign.ts
+/**
+* The format campaign progress is written in now
+*
+* @internal
+*/
+var CAMPAIGN_FORMAT = 1;
+/**
+* A campaign as it is before anything is played: at its first mission, with nothing carried
+*
+* @beta
+*/
+function newCampaignProgress(campaign, first) {
+	return {
+		format: 1,
+		campaign,
+		at: first,
+		done: {},
+		heroes: [],
+		data: {}
+	};
+}
+/**
+* Progress as it was kept, checked and brought up to date. Throws on what is wrong
+*
+* @beta
+*/
+function readCampaignProgress(data) {
+	const kept = data;
+	if (typeof kept !== "object" || kept === null) throw new Error("A campaign's progress is an object");
+	if (typeof kept.format !== "number" || kept.format > 1) throw new Error(`Campaign progress of format ${kept.format}, which this engine does not know`);
+	if (typeof kept.campaign !== "string" || typeof kept.at !== "string") throw new Error("A campaign's progress says which campaign it is and where it is at");
+	const done = {};
+	for (const [mission, result] of Object.entries(kept.done ?? {})) {
+		const { seconds, best, finished } = result ?? {};
+		if (typeof seconds !== "number" || !Number.isFinite(seconds)) throw new Error(`How long ${mission} took is a number`);
+		done[mission] = {
+			seconds,
+			best: typeof best === "number" ? best : seconds,
+			finished: typeof finished === "number" ? finished : 0
+		};
+	}
+	return {
+		format: 1,
+		campaign: kept.campaign,
+		at: kept.at,
+		...typeof kept.difficulty === "string" && { difficulty: kept.difficulty },
+		done,
+		heroes: (kept.heroes ?? []).map(readHeroRecord),
+		data: typeof kept.data === "object" && kept.data !== null ? kept.data : {}
+	};
+}
+/**
+* A mission won: how long it took, the best time kept, the heroes it ends with to carry on, the campaign at the
+* mission after it (`next`), or still at this one when it was the last, and what it carries of the game's own
+* (`data`: its keys over the ones kept, the rest kept as they were). A new progress: the one given is left as it was
+*
+* @beta
+*/
+function missionWon(progress, mission, seconds, heroes, next, data) {
+	const before = progress.done[mission];
+	return {
+		...progress,
+		at: next ?? progress.at,
+		done: {
+			...progress.done,
+			[mission]: {
+				seconds,
+				best: before ? Math.min(before.best, seconds) : seconds,
+				finished: Date.now()
+			}
+		},
+		heroes: structuredClone(heroes),
+		data: data ? {
+			...progress.data,
+			...structuredClone(data)
+		} : progress.data
+	};
+}
+/**
+* A player's units as records to carry on (`UnitRecord`): those alive, not structures, not heroes (`carryOut` carries
+* those), and of them what `filter` keeps (the footmen, the three nearest the gate). In the order of their ids
+*
+* @beta
+*/
+function carryUnits(world, player, filter = () => true) {
+	return [...world.index.ownedBy(player)].filter((unit) => unit.alive && unit.isUnit && !heroOf(unit) && filter(unit)).sort((a, b) => a.id - b.id).map((unit) => {
+		const name = world.nameOf(unit);
+		const rank = unit.get(veterancy);
+		const slots = slotsOf(unit);
+		return {
+			type: unit.def.id,
+			...name !== void 0 && { name },
+			health: unit.maxHp > 0 ? Math.min(Math.max(unit.hp / unit.maxHp, 0), 1) : 1,
+			...rank && { veterancy: { ...rank } },
+			...slots && { items: slots.map((slot) => slot ? {
+				item: slot.item,
+				charges: slot.charges,
+				...slot.data && { data: structuredClone(slot.data) }
+			} : null) }
+		};
+	});
+}
+/**
+* Brings carried units into a mission for a player, round a point (`spread` apart, in rings: 1.5 when left out), each
+* with its name, its share of health, its veterancy and its items. What the game no longer has, a type or an item, is
+* left out. The units made, in the order of the records
+*
+* @beta
+*/
+function placeUnits(world, player, records, at, spread = 1.5) {
+	const made = [];
+	records.filter((record) => world.registry.units.has(record.type)).forEach((record, i) => {
+		const point = ringPoint(at, i, spread);
+		const unit = world.spawn(record.type, player, point, record.name !== void 0 ? { name: record.name } : {});
+		if (record.veterancy) {
+			unit.set(veterancy, { ...record.veterancy });
+			refreshVitals(world, unit);
+		}
+		const slots = slotsOf(unit);
+		if (slots && record.items) {
+			slots.fill(null);
+			record.items.forEach((carried, slot) => {
+				if (!carried || slot >= slots.length || !world.registry.items.has(carried.item)) return;
+				const instance = createItem(world, carried.item, carried.charges);
+				if (carried.data) instance.data = structuredClone(carried.data);
+				slots[slot] = instance;
+			});
+			world.events.emit(inventoryChanged, { entity: unit });
+		}
+		unit.hp = Math.max(1, Math.round(unit.maxHp * Math.min(Math.max(record.health, 0), 1)));
+		made.push(unit);
+	});
+	return made;
+}
+/** The `index`-th place round a point: the point first, then rings of six, twelve, … `spread` apart */
+function ringPoint(at, index, spread) {
+	if (index === 0) return {
+		x: at.x,
+		z: at.z
+	};
+	let ring = 1;
+	let first = 1;
+	while (index >= first + ring * 6) {
+		first += ring * 6;
+		ring++;
+	}
+	const angle = (index - first) / (ring * 6) * Math.PI * 2;
+	return {
+		x: at.x + sin(angle) * ring * spread,
+		z: at.z + cos(angle) * ring * spread
+	};
+}
+/**
+* What a player has researched, to carry on (`giveResearch`): each upgrade's level, by its id
+*
+* @beta
+*/
+function carryResearch(world, player) {
+	return Object.fromEntries([...world.player(player).upgrades].filter(([, level]) => level > 0));
+}
+/**
+* Gives a player research carried in (`carryResearch`): each upgrade up to its level, never down, no further than it
+* goes, and what it does besides stats (`UpgradeDef.apply`) to the units the player has, as research finishing does.
+* What the game no longer has is left out
+*
+* @beta
+*/
+function giveResearch(world, player, research) {
+	const who = world.player(player);
+	for (const [upgrade, carried] of Object.entries(research)) {
+		if (!world.registry.upgrades.has(upgrade)) continue;
+		const def = world.registry.upgrade(upgrade);
+		const to = Math.min(Math.max(Math.floor(carried), 0), def.maxLevel ?? 1);
+		for (let level = (who.upgrades.get(upgrade) ?? 0) + 1; level <= to; level++) {
+			who.setUpgrade(upgrade, level);
+			if (def.apply) {
+				for (const entity of [...world.index.ownedBy(player)]) if (entity.alive) def.apply(world, entity, level);
+			}
+		}
+		who.researching.delete(upgrade);
+	}
+}
+/**
+* What a player has of each resource, to carry on (`giveResources`): a copy, all of it, or of the kinds named
+*
+* @beta
+*/
+function carryResources(world, player, kinds) {
+	const resources = world.player(player).resources;
+	return Object.fromEntries(Object.entries(resources).filter(([kind]) => !kinds || kinds.includes(kind)));
+}
+/**
+* Gives a player resources carried in (`carryResources`), on top of what the mission starts it with. What the game no
+* longer has is left out
+*
+* @beta
+*/
+function giveResources(world, player, resources) {
+	const purse = world.player(player).resources;
+	const known = new Set(world.registry.resources.map((resource) => resource.id));
+	for (const [kind, amount] of Object.entries(resources)) if (known.has(kind) && Number.isFinite(amount)) purse[kind] = (purse[kind] ?? 0) + amount;
+}
+/**
+* The heroes of a player as records to carry on (see `heroRecord`): fallen ones too, as a campaign brings them back
+*
+* @beta
+*/
+function carryOut(world, player) {
+	return heroesOf(world, player).map((hero) => heroRecord(world, hero));
+}
+/**
+* Brings carried heroes into a mission for a player. Each takes the place of the hero the map has for it: the one of
+* that player under the same name, else one of that player of the same type; a hero the map has none for is made at
+* `at`. The heroes, in the order of the records
+*
+* @beta
+*/
+function carryIn(world, heroes, player, at) {
+	const taken = /* @__PURE__ */ new Set();
+	return heroes.map((record) => {
+		const named = record.name !== void 0 ? world.named(record.name) : void 0;
+		const placed = named && named.owner === player && heroOf(named) && !taken.has(named) ? named : heroesOf(world, player).find((hero) => hero.def.id === record.type && !taken.has(hero));
+		const hero = placed ?? heroFromRecord(world, record, player, at);
+		if (placed) applyHeroRecord(world, placed, record);
+		taken.add(hero);
+		return hero;
+	});
+}
+//#endregion
+//#region src/session/commandReplay.ts
+/**
+* Replays of commands (determinism D4): a game kept as where it started and what its players told it, tick by tick,
+* and played back by running it again. A world comes out the same from the same start and the same commands (D1–D3),
+* so this is the whole game, from every side, in a few kilobytes where the frames a watcher was sent are megabytes.
+* Its hash every few seconds is kept with it: played back, a hash that differs says the game came apart there (rules
+* changed since, or a system a save does not bring back), and from then it is the game the rules make now
+*/
+/**
+* Records a world from now as its start and the commands given to it from outside a tick (the players', by a
+* session or a server; a computer player's are its system's, which runs again), with its hash every `every` ticks
+* (300, ten seconds at 30 a second, when left out). Starting takes a save of the world, as saving does (it puts the
+* crowd back as a load does)
+*
+* @beta
+*/
+function recordCommands(world, options) {
+	const every = options.every ?? 300;
+	const checkpointEvery = options.checkpoints ?? 0;
+	const checkpoints = [];
+	const from = world.tick;
+	const start = encodeSave(saveWorld(world));
+	const commands = [];
+	const saves = [];
+	const hashes = [];
+	const unwatch = world.watch({
+		command: (command) => void commands.push([world.tick, structuredClone(command)]),
+		saved: () => void saves.push(world.tick),
+		stepped: () => {
+			if ((world.tick - from) % every === 0) hashes.push([world.tick, worldFingerprint(world)]);
+			if (checkpointEvery > 0 && (world.tick - from) % checkpointEvery === 0) checkpoints.push([world.tick, encodeSave(saveWorld(world))]);
+		}
+	});
+	let replay;
+	return {
+		get ticks() {
+			return world.tick - from;
+		},
+		stop() {
+			if (replay) return replay;
+			unwatch();
+			replay = {
+				format: 2,
+				kind: "commands",
+				game: world.registry.game,
+				rules: world.registry.hash,
+				player: options.player,
+				tickRate: world.tickRate,
+				from,
+				to: world.tick,
+				start,
+				commands,
+				saves,
+				hashes,
+				...checkpoints.length && { checkpoints },
+				...world.debugPlayers.size > 0 && { debug: [...world.debugPlayers] }
+			};
+			return replay;
+		}
+	};
+}
+/**
+* A replay of commands run again, to its end or a tick, with no screen: the world as it is then, the first tick whose
+* hash differs from the one kept (none when all were the same), and what differed first at the first checkpoint
+* (`recordCommands`' `checkpoints`) where the world was not the one recorded: the entity and its field
+* (`entities[id 11].pos.x`), and what each held. A replay with no checkpoints says the tick alone. What a test of a
+* replay, and a server checking one, use
+*
+* @beta
+*/
+async function runReplay(replay, options) {
+	const run = await replayRun(replay, options.game, options.from, options.components);
+	run.stepTo(options.to ?? replay.to);
+	return {
+		world: run.world,
+		apart: run.apart,
+		difference: run.difference
+	};
+}
+/**
+* `components`: those the app kept in the world recorded beside the game's (`CreateWorldOptions.components`: where the
+* screen was played from), without which its saves do not load
+*/
+async function replayRun(replay, game, at = replay.from, components) {
+	let checkpoint = [replay.from, replay.start];
+	for (const kept of replay.checkpoints ?? []) if (kept[0] <= at && kept[0] > checkpoint[0]) checkpoint = kept;
+	const [startTick, save0] = checkpoint;
+	const world = await loadWorld(decodeSave(save0), {
+		game,
+		anyVersion: true,
+		components
+	});
+	for (const player of replay.debug ?? []) world.debugPlayers.add(player);
+	let command = replay.commands.findIndex(([tick]) => tick >= startTick);
+	if (command < 0) command = replay.commands.length;
+	let save = replay.saves.findIndex((tick) => tick > startTick);
+	if (save < 0) save = replay.saves.length;
+	let hash = replay.hashes.findIndex(([tick]) => tick > startTick);
+	if (hash < 0) hash = replay.hashes.length;
+	const ahead = (replay.checkpoints ?? []).filter(([tick]) => tick > startTick);
+	let next = 0;
+	let apart = null;
+	let difference = null;
+	const cameApart = (tick, what) => {
+		if (apart === null) apart = tick;
+		world.log.warn("replay", `The replay comes apart at tick ${tick}${what ?? ""}: the game is played on as these rules play it`, { tick });
+	};
+	return {
+		world,
+		get apart() {
+			return apart;
+		},
+		get difference() {
+			return difference;
+		},
+		stepTo(target, deadline = Infinity) {
+			let steps = 0;
+			while (world.tick < Math.min(target, replay.to) && !world.failure) {
+				if (++steps % 8 === 0 && performance.now() > deadline) return false;
+				while (command < replay.commands.length && replay.commands[command][0] <= world.tick) world.issue(structuredClone(replay.commands[command++][1]));
+				while (save < replay.saves.length && replay.saves[save] <= world.tick) {
+					saveWorld(world);
+					save++;
+				}
+				world.step();
+				while (hash < replay.hashes.length && replay.hashes[hash][0] < world.tick) hash++;
+				if (hash < replay.hashes.length && replay.hashes[hash][0] === world.tick) {
+					if (apart === null && worldFingerprint(world) !== replay.hashes[hash][1]) cameApart(world.tick);
+					hash++;
+				}
+				while (next < ahead.length && ahead[next][0] < world.tick) next++;
+				if (difference === null && next < ahead.length && ahead[next][0] === world.tick) {
+					const now = decodeSave(encodeSave(saveWorld(world, { reseat: false })));
+					const found = saveDifference(decodeSave(ahead[next][1]), now, world.registry);
+					if (found) {
+						difference = {
+							tick: world.tick,
+							...found
+						};
+						cameApart(world.tick, `, first at ${found.path} (${JSON.stringify(found.a)} recorded, ${JSON.stringify(found.b)} now)`);
+					}
+					next++;
+				}
+			}
+			return true;
+		}
+	};
+}
+/**
+* Two ends of a connection in the page, each message given to the other end once what runs now is done (a microtask):
+* in order, with no clock, and never inside the call that sent it
+*/
+function pair() {
+	const end = () => {
+		let handler = () => {};
+		let open = true;
+		const transport = {
+			send: (message) => {
+				if (open) queueMicrotask(() => other(transport).deliver(message));
+			},
+			onMessage: (on) => void (handler = on),
+			onClose: () => {},
+			close: () => void (open = false),
+			deliver: (message) => {
+				if (open) handler(message);
+			}
+		};
+		return transport;
+	};
+	const a = end();
+	const b = end();
+	const other = (one) => one === a ? b : a;
+	return [a, b];
+}
+/** How often a replay being played looks whether its game is due a tick, a second */
+var LOOKS$1 = 30;
+/**
+* Milliseconds of a look a replay being played spends running its game on, at most: what a seek has to catch up on
+* (minute 15 is 27,000 ticks from the start) is run a slice a look, the page drawn between them
+*
+* @beta
+*/
+var REPLAY_SLICE = 12;
+/**
+* Plays a replay of commands as a watcher's session: its world run again, `speed` times as fast, and served to the
+* session as a host serves one who watches (`SessionHost`), from `player`'s side, or `options.player`'s. A moment
+* asked for (`at`, `skipTo`) is run to a slice a look (`REPLAY_SLICE`), from the last checkpoint before it
+* (`recordCommands`' `checkpoints`) where it is behind: going back starts the world again from there, and the session
+* takes it up where it is (`RemoteSession.resume`). `behind` is how many ticks are still to run to it. `apart` is the
+* tick it came apart from the game recorded at, if it did, and `difference` what differed first at the first
+* checkpoint the world was not the one recorded (`runReplay`)
+*
+* @internal
+*/
+function playCommands(replay, options) {
+	let run;
+	let host;
+	let timer;
+	let stopped = false;
+	const within = (tick) => Math.min(Math.max(tick, replay.from), replay.to);
+	let due = within(options.at ?? replay.from);
+	/** The world made again for a moment behind it, while it is made */
+	let going;
+	const watcher = options.player ?? replay.player;
+	/** A host for a world, with the watcher's end of a connection to it: the welcome goes out at once */
+	const serve = (world) => {
+		const [served, watching] = pair();
+		const serving = new SessionHost(world, { sendRate: 10 });
+		serving.connect(watcher, served, {
+			readOnly: true,
+			observer: true
+		});
+		return {
+			serving,
+			watching
+		};
+	};
+	const made = replayRun(replay, options.game, due, options.components).then((first) => {
+		run = first;
+		const { serving, watching } = serve(first.world);
+		host = serving;
+		return connect(watching, { game: options.game });
+	});
+	/** Back to a moment before the world: made again from the last checkpoint before it, and the session taken there */
+	const rewind = (session, to) => {
+		going = replayRun(replay, options.game, to, options.components).then((again) => {
+			if (stopped) return again.world.dispose();
+			const { serving, watching } = serve(again.world);
+			const resumed = session.resume(watching);
+			host?.dispose();
+			run?.world.dispose();
+			run = again;
+			host = serving;
+			return resumed;
+		}).catch((error) => run?.world.log.warn("replay", "The replay could not go back", { error: String(error) })).finally(() => going = void 0);
+	};
+	const player = {
+		session: made.then((session) => {
+			if (stopped) return session;
+			let last = performance.now();
+			timer = setInterval(() => {
+				const now = performance.now();
+				const seconds = (now - last) / 1e3;
+				last = now;
+				if (going || !run) return;
+				if (Math.floor(due) < run.world.tick) return rewind(session, Math.floor(due));
+				if (run.world.tick >= Math.floor(due)) due = Math.min(due + seconds * replay.tickRate * player.speed, replay.to);
+				run.stepTo(Math.floor(due), now + 12);
+				host.publish(seconds);
+			}, 1e3 / LOOKS$1);
+			return session;
+		}),
+		get tick() {
+			return run?.world.tick ?? replay.from;
+		},
+		speed: 1,
+		skipTo(tick) {
+			due = within(tick);
+		},
+		get behind() {
+			if (going) return Math.max(Math.floor(due) - replay.from, 1);
+			return Math.max(Math.floor(due) - (run?.world.tick ?? replay.from), 0);
+		},
+		get ended() {
+			return (run?.world.tick ?? replay.from) >= replay.to;
+		},
+		get apart() {
+			return run?.apart ?? null;
+		},
+		get difference() {
+			return run?.difference ?? null;
+		},
+		stop() {
+			stopped = true;
+			clearInterval(timer);
+			host?.dispose();
+			run?.world.dispose();
+		}
+	};
+	return player;
+}
+//#endregion
+//#region src/session/replay.ts
+/** How often the recorder looks whether the world went on, a second: it keeps what changed at its own rate */
+var LOOKS = 30;
+/**
+* The tick a message says it brings, to answer that it got there: of a delta, from the head of its text where it comes
+* first; of the welcome, of the first 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;
+};
+/**
+* Records a game played in the page (`RecordOptions`): as its start and its players' commands (`kind: 'commands'`,
+* the default: `recordCommands`), or as an observer from `player`'s side sees it, what changed `sendRate` times a
+* second (`kind: 'frames'`). Frames are answered at once, as by a watcher who missed nothing, so what is kept is what
+* changed and not the whole world again
+*
+* @beta
+*/
+function recordGame(world, options) {
+	if ((options.kind ?? "commands") === "commands") return recordCommands(world, options);
+	const host = new SessionHost(world, { sendRate: options.sendRate ?? 10 });
+	const frames = [];
+	const from = world.tick;
+	let answer = () => {};
+	host.connect(options.player, {
+		send(message) {
+			frames.push([world.tick, message]);
+			const tick = tickOf(message);
+			if (tick !== void 0) answer(JSON.stringify({
+				type: "ack",
+				tick
+			}));
+		},
+		onMessage: (handler) => answer = handler,
+		onClose: () => {},
+		close: () => {}
+	}, {
+		readOnly: true,
+		observer: true
+	});
+	let last = performance.now();
+	const timer = setInterval(() => {
+		const now = performance.now();
+		host.publish((now - last) / 1e3);
+		last = now;
+	}, 1e3 / LOOKS);
+	let replay;
+	return {
+		get ticks() {
+			return world.tick - from;
+		},
+		stop() {
+			if (replay) return replay;
+			clearInterval(timer);
+			host.dispose();
+			replay = {
+				format: 1,
+				game: world.registry.game,
+				player: options.player,
+				tickRate: world.tickRate,
+				from,
+				to: world.tick,
+				frames
+			};
+			return replay;
+		}
+	};
+}
+/**
+* Plays a replay back, as a watcher's session (`connect`): a replay of commands run again (`playCommands`), or what the
+* host sent coming in as it came, by the replay's ticks; `speed` times as fast. `game` is the game module it is of, or
+* the modules the page has, by id
+*
+* @beta
+*/
+function playReplay(replay, options) {
+	if (replay.format === 2) {
+		const games = options.game;
+		const game = "units" in games && typeof games.id === "string" ? games : games[replay.game];
+		if (!game) throw new Error(`This page does not have the game the replay is of (${replay.game})`);
+		return playCommands(replay, {
+			game,
+			at: options.at,
+			components: options.components
+		});
+	}
+	let deliver = () => {};
+	const watching = () => ({
+		send: () => {},
+		onMessage: (handler) => void (deliver = handler),
+		onClose: () => {},
+		close: () => {}
+	});
+	const within = (tick) => Math.min(Math.max(tick, replay.from), replay.to);
+	let next = 0;
+	/** The moment it is asked to be at: the clock, or where a seek goes */
+	let due = within(options.at ?? replay.from);
+	let last = performance.now();
+	/** The tick of the last frame handed to the session */
+	const shown = () => next > 0 ? replay.frames[next - 1][0] : replay.from;
+	/** Whether frames are still to be handed over to come to the moment asked */
+	const pending = () => next < replay.frames.length && replay.frames[next][0] <= due;
+	let session;
+	const player = {
+		session: connect(watching(), { game: options.game }),
+		get tick() {
+			return pending() ? shown() : due;
+		},
+		speed: 1,
+		skipTo(target) {
+			due = within(target);
+			if (session && due < shown()) {
+				next = 0;
+				session.resume(watching()).catch(() => void 0);
+				deliver(replay.frames[next++]?.[1] ?? "");
+			}
+		},
+		get behind() {
+			return pending() ? Math.max(Math.floor(due) - shown(), 1) : 0;
+		},
+		get ended() {
+			return next >= replay.frames.length;
+		},
+		stop() {
+			stopped = true;
+			clearInterval(timer);
+		}
+	};
+	/** Hands the session the frames up to the moment asked, until `deadline` is past */
+	const flush = (deadline) => {
+		let handed = 0;
+		while (pending()) {
+			deliver(replay.frames[next++][1]);
+			if (++handed % 16 === 0 && performance.now() > deadline) return;
+		}
+	};
+	let timer;
+	let stopped = false;
+	deliver(replay.frames[next++]?.[1] ?? "");
+	player.session.then((made) => {
+		if (stopped) return;
+		session = made;
+		last = performance.now();
+		timer = setInterval(() => {
+			const now = performance.now();
+			if (!pending()) due = Math.min(due + (now - last) / 1e3 * replay.tickRate * player.speed, replay.to);
+			last = now;
+			flush(now + 12);
+		}, 1e3 / LOOKS);
+	}, () => void 0);
+	return player;
+}
+//#endregion
+export { ARRIVE_RANGE, ATTACK_STATS, ATTRIBUTES, ATTRIBUTE_KEYS, AURA_LINGER, AVOIDANCE_LEVELS, Areas, BLOCKS_BUILD, BLOCKS_WALK, BOARD_REACH, BRIDGE, BUILD_REACH, BuildGrid, CAMPAIGN_FORMAT, CAPTURE_FIELDS, CAPTURE_KIND, CHAT_LENGTH, CLASSIC_ATTRIBUTES, COPY_OF, CORE_STAT_KEYS, DATA_KINDS, DEFAULT_AVOIDANCE, DEFAULT_HEIGHTS, DEFAULT_MAX_PLAYERS, DEFAULT_STANCE, DESTRUCTIBLES, DIRECTOR, DIRECTOR_ACTIONS, DIRECTOR_ORDERS, Dialog, ENTITY_DERIVED, ENTITY_SAVE, EXPOSED_FOR, Entity, FAIR_MARGIN, FOG_EXPLORED, FOG_UNEXPLORED, FOG_VISIBLE, FORMATION_GAP, FRIENDLY_FIRE, FogOfWar, HEROES, Invalid, LANE_END_REACH, LANE_SPAWNERS, LANE_SPAWNER_FIELDS, LANE_SPAWNER_KIND, LEGACY_TILESET, LINE_SECONDS, LOG_LEVELS, LocalSession, Logger, MANA_BURN, MAP_CREEPS, MAP_FORMAT, MAP_NEUTRAL, MAP_OBJECTIVES, MAP_OBJECTIVES_KEY, MAP_RULES, MAP_RULES_KEY, MAX_FOG_TEAMS, MAX_LEVEL, MAX_MAP_PLAYERS, MAX_MAP_SIZE, MAX_TILES, MIN_MAP_SIZE, MISSION_RULES, MOBA_STATS, MissingGround, ModError, NEW_DEFINITION, Objectives, PHASES, PING_KINDS, PLAYER_COLORS, PORTALS, PROFILE_SMOOTH, PROTOCOL_VERSION, PackError, Path, Player, RAMP_REACH, RANDOM_RACE, REACH, REPATH_SPREAD, REPLAY_SLICE, REQUIRED_FIELDS, RUNES, Registry, RemoteSession, Rng, SAVE_FORMAT, SCENARIO_FORMAT, SHOP_RANGE, SHUN_TIME, STANCES, STAT_WORDS, SaveError, Scheduler, Score, Sequences, SessionHost, SessionRefused, SessionView, SidePaths, SizedNavigation, TAU, TOMES, Terrain, Timers, UNLOAD_REACH, UPHILL_MISS, UnlistedError, VETERANCY_RANKS, WATER_DEEP, WATER_NONE, WATER_SHALLOW, WorkerSession, World, WorldMap, abilityCast, abilityImpact, abilityReach, abilityRefusal, abilityText, abilityValues, adoptTileset, aimOf, allowed, angleDiff, angleTo, anyEffect, applyBuff, apply as applyDelta, applyHeroRecord, applyTerrainPatch, areaShapeOf, askPause, assembleGame, at, atShop, attackCommand, attackPathOrder, attackReaches, attackStarted, attackStat, attackTiming, attackersOf, attributesOf, autocastCommand, availableTo, availableToPlayer, avoids, bandOf, baseStats, basinShape, blankDefinition, blockByDoodads, board, boardOrder, boarded, bool, bounty, buffApplied, buffEnded, buffRemoved, buildLineCommand, buildNavigationData, builtSoFar, burnMana, buy, buyCommand, campCleared, campFields, campHooks, campLayout, campMember, campNamed, campRespawnSystem, campReturned, camps, campsOf, canAttack, canBoard, canHarvest, canLearn, canPlaceStructure, canRepair, cancelConstructionCommand, cancelTrainCommand, captureAreaOf, captureOf, capturePoint, captured, captures, capturesOf, capturing, cargo, carryIn, carryOut, carryResearch, carryResources, carryUnits, castCommand, castRange, castStarted, castTimeOf, casterFacts, cellLayerValues, cellsChanged, cellsIn, cellsSeen, changedStats, channelEnded, channelStarted, chargesLeft, chat, chatted, checkDamageTable, checkLanes, checkMap, checkMapObjectives, checkMissionRules, checkPack, checkPackSchema, checkRaces, checkRules, checkpoint, chopped, cinematic, cinematicChoice, cinematicChoiceCommand, cinematicCommand, cinematicCue, cinematicCued, cinematicEnded, cinematicPlayingCommand, circleFormation, clamp, clearGround, cloneMap, cloneTerrain, closestPointOnRect, commandHandled, commandRejected, composeGame, compositionOf, connect, consoleSink, constructionCancelled, constructionFinished, constructionOf, constructionSite, constructionStarted, cooldownOf, copyDefinition, coreCommands, coreFormations, coreHooks, coreSystems, coreVictory, corpseSystem, corpses, costRefusal, createItem, createLogRing, createMap, createRegistry, createWorld, createWorldFromMap, cueCinematic, currencyOf, damageMultiplier, damaged, dashing, dataRulesProblem, declaredRefusal, decodeSave, defaultEngageLayer, defaultEngageRoom, defaultHeroRules, defaultPickAttack, defaultRules, defaultWave, defineArea, defineCellLayer, defineCommand, defineComponent, defineEffect, defineEvent, defineGameFile, defineHook, defineHookType, defineIds, defineListener, defineMapField, defineMod, defineObjective, definePrefab, defineRace, defineSequence, defineStat, defineTile, defineTimer, defineTunable, definitionChanged, definitionIn, definitionsIn, delayed, denying, deposit, describeAbility, detection, diff as diffFrames, directing, directorCommand, directorInvulnerable, dispelBuffs, dispelEffects, dist, distSq, distToRect, distanceToEdge, drawFromGroup, drawFromTable, dropOnGround, earn, edgeDistance, editDistance, editableFields, editableValues, effectFields, effectStarted, effectStopped, effectTargets, effectTypesOf, encodeSave, engageLayer, engageWith, engagedLike, engagedWith, engineMessage, engineStats, enteredArea, entityDied, entityMorphed, entityRemoved, entitySpawned, environmentChanged, errorFields, eventById, exactMath, exchange, exchanged, expose, exposure, faceTowards, farthestAcquisition, farthestReach, fieldOptions, fighting, findGround, findItem, fireOnTheMove, fitToPlaces, fitValue, followPathOrder, footprintCell, footprintOf, formatNumber, formationContext, formationPoints, freeSlot, fromRuns, gainStats, gainedStats, gameHash, gameOver, gameReloaded, garrisonHooks, gateChanged, gateStates, gathering, gathers, generateMap, generateTerrain, give, giveBack, giveItem, giveMapObjective, giveResearch, giveResources, grantVeterancy, grantXp, groundAttack, groundBase, groundDifference, groundHash, groundOf, groundReshaped, groundSpeedAt, groundSpeedOfCell, groupChoices, halt, harvesterOf, hasBuff, hasPack, hashInts, healed, heightsFromPixels, heightsToPixels, heroCommands, heroFromRecord, heroLevelUp, heroOf, heroOfState, heroRecord, heroRevived, heroState, heroStrike, heroesOf, hire, hireCommand, hireRefusal, hirerAt, homeOf, hotMod, hotRules, hourOf, id, ids, illusion, impact, inShape, index, innerEffects, invalidateStats, inventoryChanged, inventorySlots, isAvailable, isBlocked, isCommand, isCrowded, isFiniteNumber, isGateOpen, isGroundChanges, isMadeOf, isMovingTo, isNight, isObject, isRooted, isScenery, isServerMessage, isShunned, isSilenced, isSpell, isSpellImmune, isStunned, itemDropped, itemPicked, laneMinion, lanesOf, lastHitsOf, lastTeamStanding, layerOf, layeredNoise, learn, learnCommand, leftArea, lerp, lerpAngle, levelNeeded, lineEnded, lineSaid, list, loadOrder, loadTerrain, loadWorld, logLine, lookAhead, loopback, makeHero, makeWay, manaChanged, mapCampData, mapCell, mapCells, mapDrops, mapFields, mapFileStem, mapGeneratorWorker, mapLanes, mapNamesSource, mapObjectData, mapObjectivePlayers, mapObjectives, mapObjectivesOf, mapPlayerData, mapRegionData, mapTerrain, mapText, mapThings, mapTileIds, mapsFrom, maxLevelOf, maxPlayersOf, mayDeny, measureMap, meets, memoryNavigationCache, mergeMaps, mergeValues, messageSent, migrateMap, missed, missileHit, missileRemoved, missileSpawned, missing, missingTech, missionRuleState, missionRulesOf, missionWon, mitigation, morph, morphCancelled, morphStarted, moveTo, moveToEntity, moving, navigationKey, navigationWorker, nearestDryGround, nested, nestedPartId, newCampaignProgress, noStats, noneFormation, notReady, number, object, objectFields, objectiveChanged, objectiveVictory, onNewGameVersion, onNewModVersion, oneOf, openSocket, optional, orderCommand, orderSays, packFromJson, packsOf, parseMap, passiveEffects, patchAt, patrolPathOrder, pauseAsked, pauseCommand, pausesLeft, pay, penetratingMitigation, pickAttack, pickUp, pileOf, pileTaken, pileType, ping, pingKinds, pinged, placeUnits, placementCells, placementProblem, plain as plainData, playCinematic, playCommands, playEffect, playReplay, playTileset, playerDefeated, playerFacts, playerFields, playerSlot, playerSurrendered, point, portal, portalUsed, prefabsFrom, presetBlight, presetFountain, presetGenerator, presetMarket, presetScore, presetTiles, priceOf, primaryAttribute, productionOf, productionQueue, profileReach, projectileRemoved, projectileSpawned, protocolMismatch, quantize, queueOf, raceOf, rallyCommand, randomSeed, rangeAgainst, rankOf, rankedUp, reachedByDefault, reaches, readCampaignProgress, readHeroRecord, readHostMessage, readMessage, readPlayerMessage, readScenario, recallAbility, recompose, recordCommands, recordGame, redefineIn, redefinitions, refreshVitals, refund, regionCinematic, regionFields, release, reloadGame, removeBuff, removeDefinition, replaceIn, replicateEvent, replicatedEvents, requirementRefusal, researchCommand, researchFinished, resisted, resizeMap, resolveRules, resourceChanged, resourcesDeposited, resourcesPass, resourcesSpent, respawnCamp, respawnIn, respawning, restoreCharges, reviveCommand, reviveCost, reviveHero, rgb, roadsPass, roomFor, roomIn, rootConsole, rootLogger, rotateTowards, rowsFormation, rubbleType, ruleFired, runReplay, rustled, satisfies, saveDifference, saveHeader, saveProblem, saveTerrain, saveWorld, savedGround, scaled, scaledParts, scatterPass, scenarioOfMap, scenarioOfWorld, scenarioWorld, scoreData, scoreOn, seconds, sell, sellCommand, sellValue, sendWave, serializeMap, serveMapGenerator, serveNavigationBuilds, serveWorld, setAnchored, setGate, setGhost, setHeroLevel, setRace, setWallGate, setWaygate, shapeArea, shapeAsBox, shapeAt, shapeBounds, shapeReach, shareGame, shareWith, shieldOf, shootsUphill, shopNear, shopStock, shoreNear, shortOf, shun, sideKnowledge, silences, siteKey, siteOf, siteWords, slotsOf, smartCommand, smoothstep, snapshotOf, snapshotPart, spawnCamp, spawnPrefab, spawnStart, spend, spendCharge, spotFor, squareFormation, stance, stanceCommand, stanceOf, standsInWay, startDash, startedOn, startingBase, startingTerrain, startsPass, statsOf, stepAside, stopCommand, stopEffect, string, summonEffects, summonHooks, summoned, surrender, surrenderCommand, swingTiming, symmetricPlaces, tableItems, takeCorpses, takeItem, talk, targetFacts, targetRefusal, teamChanged, teamMemory, techOf, techTree, tellRules, terrainPass, terrainPatch, terrainPatchProblem, text, tileRemap, tilesFor, tilesPass, tilingNoise, toMessage, toRuns, tooNear, townPortal, traded, trainCommand, trainRefusal, tunableChanged, tuneCommand, tunings, underConstruction, unitHired, unitTrained, unload, unloadOrder, unloaded, unlockRefusal, unlocked, updateMapTerrain, updateSave, upgradeBuildingCommand, upgradeLevel, upgradeOf, upgradesOf, upkeepOf, usePowerUp, validTarget, valueAt, valueText, vec2, veterancy, viewLevel, wait, waitFor, waitUntil, walkBetween, walkingTime, wallGate, wallGateChanged, wallGateCommand, wallJoined, wallLine, wallShapeOf, wavesSent, waygate, waygateTarget, withAttributes, withCapture, withChanges, withConcealment, withData, withDestructibles, withDirector, withFriendlyFire, withHeroes, withLanes, withLastHits, withManaBurn, withMobaStats, withPortals, withRemains, withRespawn, withRunes, withStances, withTomes, withTuning, withValues, withVeterancy, withWalls, withoutEditor, worked, workerSession, worldFailed, worthless, xpGained, xpWorth };
+
+//# sourceMappingURL=index.js.map