@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/hotReload.d.ts

@@ -0,0 +1,76 @@
+import { type GameModule } from './game';
+import type { ModDef } from './mods';
+import type { World } from './world';
+/**
+ * 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
+ */
+export declare const gameReloaded: import("./events").EventKey<{
+    game: string;
+}>;
+/**
+ * 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
+ */
+export declare function reloadGame(world: World, game: GameModule): void;
+/**
+ * What a module's `import.meta.hot` gives for hot reload, as Vite has it: what loads the page again
+ *
+ * @beta
+ */
+export interface HotContext {
+    invalidate(message?: string): void;
+}
+/**
+ * Hears of every new version of a game's rules taken in the page (`hotRules`). Returns what stops it
+ *
+ * @beta
+ */
+export declare function onNewGameVersion(listener: (game: GameModule) => void): () => void;
+/**
+ * Hears of every new version of a mod taken in the page (`hotMod`). Returns what stops it
+ *
+ * @beta
+ */
+export declare function onNewModVersion(listener: (mod: ModDef) => void): () => void;
+/**
+ * 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
+ */
+export declare function hotMod(hot: HotContext | undefined, current: ModDef, next: unknown): void;
+/**
+ * Puts what `next` has into `current`, in its place: everything that holds `current` has the new version
+ *
+ * @beta
+ */
+export declare function replaceIn(current: object, next: object): void;
+/**
+ * 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
+ */
+export declare function hotRules(hot: HotContext | undefined, current: GameModule, next: unknown): void;

package/dist/ids.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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
+ */
+export declare function defineIds<const T extends string>(...names: T[]): {
+    readonly [K in T]: K;
+};
+/**
+ * The ids of a list made with `defineIds`, as a type: `IdOf<typeof UNIT>`
+ *
+ * @beta
+ */
+export type IdOf<T extends Readonly<Record<string, string>>> = keyof T & string;

package/dist/index.d.ts

@@ -0,0 +1,227 @@
+/**
+ * The public API of the engine: everything a game module, a mod, a client or a server may use.
+ * Imported as `@v12-engine/engine`.
+ *
+ * What is not listed here is the engine's own business and can change at any time. Tests may reach
+ * further in; nothing else should, and the architecture tests check that.
+ */
+export type { CreateWorldOptions, GameModule, GameResult, LobbySetting, MapWorldOptions, ServerHooks, ServerSeat } from './game';
+export { spawnStart, type StartCode, type StartData, type StartDef, startingBase } from './start';
+export type { LoadWorldOptions } from './game';
+export type { Collection, GameBuilder, ModDef } from './mods';
+export { composeGame, defineMod, isMadeOf, ModError, recompose, satisfies } from './mods';
+export { type AssembledGame, assembleGame, coreSystems, createRegistry, createWorld, createWorldFromMap, loadWorld, maxPlayersOf } from './game';
+export type { EntitySave, SaveHeader, SaveMigration, SaveMissing, SaveRefusal, SaveRules, WorldSave } from './save';
+export { type TerrainSave } from './terrainSave';
+export { decodeSave, encodeSave, SAVE_FORMAT, SaveError, saveHeader, saveProblem, saveWorld, type SaveWorldOptions, updateSave } from './save';
+export { applyTerrainPatch, type GroundBase, type GroundChanges, type GroundLayer, groundDifference, groundHash, isGroundChanges, type SavedGround, terrainPatch, type TerrainPatch, terrainPatchProblem } from './ground';
+export type { CampRules, FogRules, GameRules, HudShareRule, HudSharing, QueuedUnit, RulesInit } from './rules';
+export { defaultRules } from './rules';
+export type { EngineMessages, Message, MessageParams, MessageRef } from './messages';
+export { engineMessage, toMessage } from './messages';
+export type { OrderBehavior, OrderFact, OrderInit, OrderStatus, System, SystemDef, SystemOver, SystemPhase } from './registry';
+export type { NoState, OrderInitOf, OrderInits, OrderParams, OrderStateOf, OrderStates } from './registry';
+export type { AdvanceState, AlongPath, AttackGroundState, AttackState, FollowState, HoldState, PatrolState } from './orders/basic';
+export type { BuildState, RepairState, WorkState } from './orders/build';
+export type { CastChannel, CastState } from './orders/cast';
+export type { HarvestGathering, HarvestKept, HarvestState, HarvestToDropOff, HarvestToResource } from './orders/harvest';
+export type { ItemOrderState } from './orders/items';
+export type { BoardState, LoadState, UnloadState } from './transport';
+export type { SystemTiming } from './scheduler';
+export { PHASES, Scheduler } from './scheduler';
+export type { Available, CanHarvest, AfterCast, AfterDamage, BeforeBuff, BeforeCast, BeforeDamage, BeforeDeath, BeforeHeal, BeforeOrder, BeforePause, BeforeSurrender, SupplyCap, BeforeProduce, BuffEnd, CanPlace, Death, FromMap, FromMapCamp, FromMapObject, FallenHero, FromMapRegion, Morphed, AnyHook, HookDef, HookEvents, HookHandler, HookKey, HookName, Idle, Hooks, ProductionKind, TargetScore, MakeWay, Detour, Formation } from './hooks';
+export { defineHook, defineHookType } from './hooks';
+export type { EventAudience, EventKey, ListenerDef } from './events';
+export { type ReplicatedEvent, replicateEvent, type SessionEventOf, SessionView, type SnapshotPart } from './replication';
+export { defineEvent, defineListener } from './events';
+/** The engine's events, a key each (design review E7) */
+export * from './engineEvents';
+export type { PrefabArea, PrefabCamp, PrefabContents, PrefabDef, PrefabInside, PrefabObject, SpawnedPrefab, SpawnPrefabOptions } from './prefabs';
+export { definePrefab, nestedPartId, prefabsFrom, spawnPrefab } from './prefabs';
+export type { AreaDef, AreaRef, AreaShape } from './areas';
+export { Areas, areaShapeOf, defineArea, inShape, shapeArea, shapeAsBox, shapeAt, shapeBounds, shapeReach } from './areas';
+export type { EveryOptions, ShownTimer, TimerDef, TimerInfo } from './timers';
+export { defineTimer, Timers } from './timers';
+export type { SequenceDef, Step } from './sequences';
+export { defineSequence, Sequences, wait, waitFor, waitUntil } from './sequences';
+export type { ObjectiveDef, ObjectiveState, ObjectiveStatus } from './objectives';
+export { defineObjective, objectiveVictory, Objectives } from './objectives';
+export type { MapObjective } from './mapObjectives';
+export { checkMapObjectives, giveMapObjective, MAP_OBJECTIVES, MAP_OBJECTIVES_KEY, mapObjectivePlayers, mapObjectives, mapObjectivesOf } from './mapObjectives';
+export type { MissionActionData, MissionRule, MissionRuleState } from './missionRules';
+export { checkMissionRules, MAP_RULES_KEY, MISSION_RULES, missionRulesOf, missionRuleState, ruleFired, tellRules } from './missionRules';
+export type { Audience as LineAudience, LineDef, SaidLine } from './dialog';
+export { Dialog, talk } from './dialog';
+export type { CinematicChoice, CinematicCue, CinematicCueSent, CinematicEnded, CinematicOptions, CinematicOutcome, CinematicWait } from './cinematics';
+export type { DeathCause, DeathReason, PlayerRelation } from './world';
+export { cinematic, cinematicCue, cueCinematic, playCinematic, regionCinematic } from './cinematics';
+export type { EffectCue, EffectOptions } from './effects';
+export { playEffect, stopEffect } from './effects';
+export { coreHooks } from './features';
+export { Registry, UnlistedError } from './registry';
+export type { DamageOptions, Delayed, MessageKind, Missile, Projectile, Reveal, SpawnOptions, WorldEvents, WorldChecks, WorldOptions, WorldWatcher, Zone } from './world';
+export { World } from './world';
+export type { Camp, CampMember } from './camps';
+export { campLayout, campMember, campNamed, camps, respawnCamp, spawnCamp } from './camps';
+export type { MapInfo, MapPlayerInfo } from './names';
+export { WorldMap } from './names';
+export type { Spot } from './paths';
+export { Path } from './paths';
+export { mapFileStem, mapNamesSource, mapText } from './mapFile';
+export { type MapMerge, mergeMaps } from './mapMerge';
+export type { MapEditorDef, MapEraseKind, MapFieldDef, MapFieldKind, MapFieldOption, MapPaletteGroup, MapProblem, MapRef, MapRefTarget, MapRefUse, MapTarget, MapThing } from './mapFields';
+export type { TileDef } from './tiles';
+export { defineTile, MAX_TILES } from './tiles';
+export { type CellLayerDef, cellLayerValues, cellsIn, defineCellLayer } from './cellLayers';
+export { presetBlight, presetTiles } from './presetGround';
+export { type MarketRate, presetFountain, presetMarket, type PresetMarketOptions } from './presetBuildings';
+export { type ConcealmentOptions, patchAt, withConcealment } from './concealment';
+export { homeOf } from './home';
+export { recallAbility, type RespawnOptions, withRespawn } from './packs/heroes/respawn';
+export { DEFAULT_STANCE, stance, stanceCommand, type StanceDef, stanceOf, STANCES, type StancesOptions, withStances } from './stances';
+export { CAPTURE_FIELDS, CAPTURE_KIND, captured, captureOf, type CaptureOptions, capturePoint, type CapturePoint, captures, capturesOf, type CaptureState, capturing, type Contested, withCapture } from './capture';
+export { FRIENDLY_FIRE, type FriendlyFireOptions, withFriendlyFire } from './friendlyFire';
+export { denying, type DenyOptions, type LastHitOptions, lastHitsOf, mayDeny, withLastHits } from './denying';
+export { checkLanes, coreVictory, defaultWave, heroStrike, type LaneWave, laneMinion, type LanesOptions, sendWave, wavesSent, withLanes, LANE_SPAWNER_KIND, LANE_SPAWNERS, type Lane, type LaneEnd, lanesOf, mapLanes } from './lanes';
+export { campFields, DEFAULT_HEIGHTS, defineMapField, fieldOptions, mapFields, mapThings, objectFields, playerFields, regionFields } from './mapFields';
+export type { IdOf } from './ids';
+export { defineIds } from './ids';
+export type { Audience, Component, ComponentFieldDef, ComponentOptions, SavedRefs, SnapshotView } from './components';
+export { defineComponent, snapshotOf } from './components';
+export type { AbilityState, BuffInstance, CombatState, ConstructionState, Dash, EntityId, HarvesterState, ItemInstance, MovementState, MoveStatus, Order, Placed, PlayerId, ProductionItem, ProductionState, RallyPoint, ResourceState, StockState } from './entity';
+export { deposit, detection, distanceToEdge, edgeDistance, Entity, exposure, fighting, moving } from './entity';
+export { dashing } from './dashing';
+export { orderSays } from './orders/facts';
+export { type DebugAsk, type GameHostMessage, type HostToPlayer, type LobbyServerMessage, type ServerToPlayer } from './session/wire';
+export { defineGameFile, type GameFileDef } from './gameFiles';
+export type { PlayerInit } from './player';
+export type { Purse } from './player';
+export { currencyOf, earn, giveBack, pay, Player, refund, shortOf, spend, type SpentOn } from './player';
+export { defineStat, engineStats, presetScore, type PresetScoreOptions, Score, type ScoreAudience, type ScoreCount, type ScoreCounted, scoreData, type ScoreData, type ScoreFormat, type ScoreKind, type ScoreLineState, scoreOn, type ScoreRules, type ScoreSource, type ScoreState, type ScoreStatDef, type ResolvedScore } from './score';
+export type { Command, CommandDef, Commands, DefinedCommand, IssuedCommand, ModCommand } from './commands';
+export { coreCommands, defineCommand, stopCommand } from './commands';
+export type { Check, Checked, Fields } from './fields';
+export { bool, id, ids, index, Invalid, isObject, list, number, object, oneOf, optional, point, rgb, seconds, string, text } from './fields';
+export type { AbilityDef, AbilityTarget, AimShape, AttackDef, AttackStats, BuffDef, Cost, DamageType, DayCycle, AnyEffect, EffectCommon, EffectDef, EffectFields, EffectOf, EffectTypes, EntityKind, HeroDef, ItemDef, ItemTier, Layer, ResourceDef, ResourceKind, Scaled, ScaledStatChange, Scaling, StatChange, StatDef, StatKey, Stats, CoreStats, StatSource, UnitTypeDef, UpgradeDef, UpgradeEffect, UpkeepTier } from './defs';
+export { aimOf, at, baseStats, footprintOf, upgradesOf, hourOf, isNight, noStats, anyEffect } from './defs';
+export { attackTiming, cooldownOf, mitigation, refreshVitals, type StatPart, type StatSum, statsOf, swingTiming } from './stats';
+export { casterFacts, scaled } from './abilities/scaled';
+export { AURA_LINGER, applyBuff, avoids, hasBuff, isRooted, isSilenced, isSpellImmune, isStunned, layerOf, removeBuff, shieldOf, silences } from './abilities/buffs';
+export type { EffectContext, EffectHandler, EffectKind } from './abilities/effects';
+export { defineEffect, type EffectKindOptions, effectTargets, startDash } from './abilities/effects';
+export { buffEnded } from './abilities/land';
+export { restoreCharges } from './abilities/charges';
+export { castRange, castTimeOf, isSpell, notReady, validTarget } from './orders/cast';
+export { attackReaches, canAttack, fireOnTheMove, shootsUphill } from './systems/combat';
+export { attackStat, defaultPickAttack, farthestAcquisition, farthestReach, groundAttack, pickAttack, rangeAgainst, reaches, tooNear } from './attacks';
+export type { EngageLayer } from './engagement';
+export { attackersOf, bandOf, defaultEngageLayer, defaultEngageRoom, engagedLike, engagedWith, engageLayer, engageWith, isBlocked, isCrowded, isShunned, release, roomFor, SHUN_TIME, shun, spotFor } from './engagement';
+export type { MoveOptions } from './systems/movement';
+export { faceTowards, halt, lookAhead, makeWay, moveTo, moveToEntity, REPATH_SPREAD, setAnchored, setGhost, standsInWay, stepAside } from './systems/movement';
+export type { FormationContext, FormationDef } from './formation';
+export { circleFormation, coreFormations, fitToPlaces, FORMATION_GAP, formationPoints, noneFormation, rowsFormation, squareFormation } from './formation';
+export { expose } from './systems/fog';
+export { lastTeamStanding } from './systems/victory';
+export { canPlaceStructure, canRepair, placementCells, placementProblem, siteOf } from './orders/build';
+export { BuildGrid, footprintCell } from './grid';
+export { playerFacts, upgradeLevel } from './systems/production';
+export { productionOf, productionQueue, queueOf, upgradeOf } from './systems/productionQueue';
+export { builtSoFar, constructionSite, underConstruction } from './systems/construction';
+export type { PlayerFacts, ReadyFacts, Relation, TargetFacts } from './shared';
+export { abilityReach, abilityRefusal, chargesLeft, costRefusal, availableTo, availableToPlayer, gathers, requirementRefusal, sellValue, targetRefusal, trainRefusal } from './shared';
+export { targetFacts } from './orders/cast';
+export { canLearn, grantXp, HEROES, heroesOf, heroOf, heroOfState, heroState, learn, levelNeeded, maxLevelOf, respawnIn, reviveCost, reviveHero, setHeroLevel, xpWorth } from './hero';
+export type { HeroesPack, HeroRules, HeroSent, HeroState } from './hero';
+export { hasPack, type GamePack } from './packs/pack';
+export { withHeroes } from './packs/heroes';
+export { cinematicPlayingCommand, DIRECTOR, DIRECTOR_ACTIONS, DIRECTOR_ORDERS, type DirectorAction, directorCommand, directorInvulnerable, type DirectorOptions, directing, withDirector } from './packs/director';
+export { MOBA_STATS, type MobaStatsOptions, penetratingMitigation, withMobaStats } from './packs/moba';
+export { makeHero } from './packs/heroes/making';
+export type { GroundItem } from './items';
+export { freeSlot, inventorySlots, slotsOf } from './inventory';
+export { atShop, buy, createItem, dropOnGround, findItem, giveItem, pickUp, priceOf, sell, shopNear, spendCharge, takeItem, shopStock } from './items';
+export { meets, missing, morph, techOf, unlocked, unlockRefusal } from './tech';
+export { type TechEdge, type TechNode, techTree } from './techTree';
+export { canHarvest, gathering, harvesterOf } from './orders/harvest';
+export { checkRaces, defineRace, isAvailable, RANDOM_RACE, type RaceDef, type RaceHookDef, raceOf, setRace } from './races';
+export type { Upkeep } from './upkeep';
+export { upkeepOf } from './upkeep';
+export { plain as plainData } from './plain';
+export type { CellRect, GameMap, MapResize, MapResizer, MapSides, MapCamp, MapFile, MapMigration, MapCamera, MapDay, MapForce, MapItemTable, MapItemTableEntry, MapRandomGroup, MapDoodad, MapDetail, MapDetailLevel, MapDoodadDetail, MapEnvironment, MapObject, MapObjectOrder, MapPath, PathProfile, MapPlayer, MapPoint, MapRegion, MapRegionCinematic, MapDoodadLight, NewMapOptions } from './map';
+export { cloneMap, createMap, withoutEditor, MAP_CREEPS, MAP_NEUTRAL, mapTerrain, blockByDoodads, BLOCKS_BUILD, BLOCKS_WALK, type MapTile, mapTileIds, playTileset, heightsFromPixels, heightsToPixels, MAX_MAP_SIZE, resizeMap, MAX_LEVEL, MAX_MAP_PLAYERS, adoptTileset, mapsFrom, migrateMap, parseMap, PLAYER_COLORS, PROFILE_SMOOTH, profileReach, playerSlot, serializeMap, updateMapTerrain } from './map';
+export type { PlateauSpec, RampSpec, TerrainGenOptions, TerrainMesh, TerrainSurface } from './terrain';
+export { generateTerrain, Terrain, WATER_DEEP, WATER_NONE, WATER_SHALLOW } from './terrain';
+export { FogOfWar } from './fog';
+export type { AgentSave, NavDebugGeometry, Navigation } from './navigation/navigation';
+export type { AvoidanceLevel, AvoidanceParams, RecastNavigationOptions } from './navigation/recast';
+export { AVOIDANCE_LEVELS } from './navigation/recast';
+export type { AbilityInfo, SharedAbility, CampInfo, GameKindListing, GameListing, MineInfo, CarriedItem, GatheringInfo, ProductionInfo, InventoryInfo, EntityState, FogState, GameSession, CorpseState, GroundItemState, XpInfo, HeroSummary, LearnableInfo, MissileState, Outcome, OwnEntityState, PlayerCommand, PlayerState, ProjectileState, QueueItemState, RevealState, SessionEvent, SessionEvents, SessionCan, SessionDebug, SessionPace, SessionSaves, SessionTiming, SessionComputer, Snapshot, StockInfo } from './session/protocol';
+export { isCommand, PROTOCOL_VERSION } from './session/protocol';
+export { LocalSession } from './session/local';
+export { type TeamMemory } from './session/memory';
+export type { ConnectOptions, HostTiming, LoopbackEnd, LoopbackOptions, SessionHostOptions, Transport } from './session/remote';
+export { connect, loopback, RemoteSession, SessionHost, SessionRefused } from './session/remote';
+export { delayed } from './session/delay';
+export { type ServeWorldOptions, serveWorld, type WorkerGame, WorkerSession, workerSession, type WorkerSessionOptions, type WorldPort, type WorldWorkerLike } from './session/worker';
+export { openSocket } from './session/socket';
+export { type RelayNotice, type SharedGame, shareGame, type ShareOptions } from './session/share';
+export type { Delta, EntityChange, FogMessage, Frame, WirePatch } from './session/delta';
+export { quantize } from './session/delta';
+export type { AbilityAiView } from './ai/micro';
+export type { AiHints, AiRole } from './ai/roles';
+export type { Computers } from './computers';
+export type { ComputerPlayer, ComputerSystem } from './ai/computer';
+export type { BrainDef } from './ai/brain';
+export type { Rect, Vec2 } from './math';
+export { clamp, dist, distSq, hashInts, lerp, lerpAngle, smoothstep, vec2 } from './math';
+export { exactMath } from './exactMath';
+export { type KnownBuilding, SidePaths } from './navigation/sidePaths';
+export { Rng } from './rng';
+export { randomSeed } from './session/seed';
+export { layeredNoise, type Noise2 } from './noise';
+export { type GeneratedMap, type MapGenerating, mapGeneratorWorker, serveMapGenerator } from './generateWorker';
+export { generateMap, type GeneratedWith, type GeneratorContext, type GeneratorOptions, type GeneratorParamDef, type GeneratorPass, type MapGenerator, type MapSymmetry, type GeneratorMark, presetGenerator, type PresetGeneratorOptions, resourcesPass, type ResourcesPassOptions, roadsPass, type RoadsPassOptions, scatterPass, type ScatterPassOptions, startsPass, type StartsPassOptions, symmetricPlaces, terrainPass, type TerrainPassOptions, tilesPass, type TilesPassOptions, basinShape, type BasinShapeOptions, clearGround, nearestDryGround } from './generate';
+export { invalidateStats } from './stats';
+export type { EntityRow, InspectedSection, Inspection, InspectTarget, LoggedEvent, PlayerRow, Trace, WorldListing } from './inspect';
+export type { WaitingTimer } from './timers';
+export { checkMap, MAP_RULES, type MapCheckContext, mapCells, type MapRule } from './mapCheck';
+export { checkRules, editDistance, type RulesProblem } from './rulesCheck';
+export { grantVeterancy, rankedUp, rankOf, veterancy, VETERANCY_RANKS, type VeterancyOptions, type VeterancyRank, type VeterancyState, withVeterancy } from './veterancy';
+export { ATTRIBUTE_KEYS, type Attribute, ATTRIBUTES, attributesOf, type AttributesOptions, primaryAttribute, CLASSIC_ATTRIBUTES, withAttributes } from './attributes';
+export { burnMana, type BurnOptions, MANA_BURN, withManaBurn } from './manaBurn';
+export { DESTRUCTIBLES, type DestructiblesOptions, withDestructibles } from './destructibles';
+export { portal, PORTALS, portalUsed, setWaygate, townPortal, waygate, waygateTarget, withPortals } from './portals';
+export { RUNES, type RunesOptions, usePowerUp, withRunes } from './runes';
+export { gainedStats, gainStats, type GainedStats, TOMES, withTomes } from './tomes';
+export { pileOf, pileTaken, pileType, type RemainsOptions, type RemainsSpec, rubbleType, withRemains } from './remains';
+export { buildLineCommand, setWallGate, wallGate, wallGateChanged, wallGateCommand, wallJoined, wallLine, type WallShape, withWalls } from './walls';
+export { BUILD_REACH, type GameMeasure, type MapReport, measureMap, type StartMeasure, walkBetween, type Walk, walkingTime } from './mapMeasure';
+export { defineTunable, type TunableDef, tunableChanged, tuneCommand, withTuning } from './tunables';
+export { buildNavigationData, memoryNavigationCache, type NavigationBuild, type NavigationBuildConfig, type NavigationBuilder, type NavigationBuilds, type NavigationSpeeds, type NavigationCache, type NavigationPort, navigationWorker, type NavigationWorkerLike, serveNavigationBuilds } from './navigation/builds';
+export { DATA_KINDS, type DataDefs, type DataField, type DataKind, type DataValue, type DataValues, COPY_OF, copyDefinition, type FieldValue, definitionChanged, definitionIn, definitionsIn, type EditableData, type EditableField, type EditableFields, editableFields, blankDefinition, effectFields, effectTypesOf, editableValues, fitValue, type GameData, mergeValues, nested, NEW_DEFINITION, redefineIn, redefinitions, removeDefinition, REQUIRED_FIELDS, valueAt, withData, withValues } from './gameData';
+export { checkPack, checkPackSchema, PackError, packFromJson, packsOf } from './packs';
+export type { DataRules } from './gameData';
+export { dataRulesProblem } from './gameData';
+export type { PackFile, PackMod } from './packs';
+export { readScenario, SCENARIO_FORMAT, type ScenarioFile, scenarioOfMap, scenarioOfWorld, scenarioWorld } from './scenario';
+export { gateChanged, isGateOpen, setGate } from './gates';
+export { gameReloaded, type HotContext, hotMod, hotRules, onNewGameVersion, onNewModVersion, reloadGame, replaceIn } from './hotReload';
+export { applyHeroRecord, heroFromRecord, type HeroItem, heroRecord, type HeroRecord, readHeroRecord } from './packs/heroes/carry';
+export { type CampaignProgress, carryIn, carryOut, carryResearch, carryResources, carryUnits, giveResearch, giveResources, type MissionResult, missionWon, newCampaignProgress, placeUnits, readCampaignProgress, type UnitRecord } from './packs/heroes/campaign';
+export { board, canBoard, type Cargo, cargo, roomIn, unload } from './transport';
+export { hire } from './packs/heroes/hire';
+export { allowed, chat, type ChatAudience, ping, PING_KINDS, pingKinds, type PingKind as PlayerPingKind } from './talk';
+export { type Corpse, corpses, illusion, summoned, takeCorpses, worthless } from './summons';
+export { dispelBuffs } from './abilities/dispel';
+export { exchange, give, shareWith } from './trade';
+export { pausesLeft, surrender } from './endings';
+export { type FramesReplay, type RecordOptions, type Replay, type ReplayPlayer, type ReplayRecorder, playReplay, recordGame } from './session/replay';
+export { type CommandRecorder, type CommandReplay, recordCommands, REPLAY_SLICE, runReplay } from './session/commandReplay';
+export { type Apart, type Difference, saveDifference } from './determinism';
+export type { AbilityTextContext, AbilityValue, AbilityValueDef, CasterFacts, TextSegment, ValuePart } from './abilities/text';
+export { abilityText, abilityValues, describeAbility, formatNumber, STAT_WORDS, valueText } from './abilities/text';
+export { consoleSink, createLogRing, errorFields, LOG_LEVELS, type LogContext, type LogEntry, Logger, type LoggerOptions, type LogLevel, logLine, type LogRing, type LogSink, rootConsole, rootLogger } from './log';
+export { type ErrorAnswer, type ErrorPolicy, type ErrorSite, type RejectedKind, siteWords, type WorldFailure } from './errors';
+/** The engine's orders that go along a path of the map, for a game's own to be made of (`followRoad` of the tower defense) */
+export { checkDamageTable, type DamageTable, damageMultiplier } from './rules';
+export { groundSpeedAt, groundSpeedOfCell } from './groundSpeed';