@v12-engine/engine 0.1.1 → 0.4.0

package/dist/world.d.ts

@@ -5,9 +5,9 @@ import { Clock } from './clock';
 import { Spawning } from './spawning';
 import { type IssuedCommand } from './commands';
 import type { Camp } from './camps';
-import type { ChatAudience, PingKind } from './talk';
+import type { ChatAudience, PingId } from './talk';
 import { type DebugChecks } from './debug';
-import { type AbilityDef, type AttackDef, type Cost, type DamageType, type EffectDef, type EffectOf, type ResourceKind } from './defs';
+import { type AbilityDef, type AttackDef, type Cost, type DamageType, type EffectDef, type EffectOf, type MorphBack, type ResourceId } from './defs';
 import { Entity, type EntityId, type ItemInstance, type PlayerId } from './entity';
 import { EntityIndex } from './entityIndex';
 import { type ErrorPolicy, type ErrorSite, type RejectedKind, type WorldFailure } from './errors';
@@ -21,7 +21,7 @@ import type { SidePaths } from './navigation/sidePaths';
 import type { Navigation } from './navigation/navigation';
 import { Player, type PlayerInit, type SpentOn } from './player';
 import type { Registry, System } from './registry';
-import type { GameRules } from './rules';
+import type { RuleSettings } from './rules';
 import { Scheduler } from './scheduler';
 import { Score } from './score';
 import { Computers } from './computers';
@@ -34,14 +34,17 @@ import { type GroundItem } from './items';
 import type { Terrain } from './terrain';
 import { type GroundBase, type TerrainPatch } from './ground';
 import { type AreaDef, type AreaShape, Areas } from './areas';
+import { type WorldQuery } from './query';
 import { Dialog, type SaidLine } from './dialog';
 import { Objectives, type ObjectiveState, type ObjectiveStatus } from './objectives';
 import { type SequenceDef, Sequences } from './sequences';
 import { type TimerDef, Timers } from './timers';
 import type { ListenerDef } from './events';
 import type { Trace } from './inspect';
+import type { CameraOrder } from './cameraOrders';
+import type { WindGust } from './foliage';
 import type { CinematicChoice, CinematicCue, CinematicCueSent, CinematicEnded } from './cinematics';
-import { type EffectCue, type EffectOptions } from './effects';
+import { type FxCue, type FxOptions } from './effects';
 import { WorldMap } from './names';
 import type { MapEnvironment } from './map';
 import { type PrefabDef, type SpawnedPrefab, type SpawnPrefabOptions } from './prefabs';
@@ -51,27 +54,45 @@ import { type PrefabDef, type SpawnedPrefab, type SpawnPrefabOptions } from './p
  * @beta
  */
 export type PlayerRelation = 'ally' | 'enemy' | 'neutral';
-/** @beta */
+/**
+ * A shot in flight to a target or a point; it deals its damage when it lands (`world.projectiles`)
+ *
+ * @beta
+ */
 export interface Projectile {
+    /** The projectile's id, from `world.newId` */
     id: number;
+    /** The entity that fired it */
     source: EntityId;
+    /** The player whose unit fired it, who is credited with what it does */
     owner: PlayerId;
+    /** The entity it is after; 0 or gone for a shot that hits an area */
     target: EntityId;
+    /** Where it is now, east-west, in world units */
     x: number;
+    /** Where it is now, north-south, in world units */
     z: number;
+    /** Where it was at the last tick, east-west, for the screen to blend by */
     prevX: number;
+    /** Where it was at the last tick, north-south, for the screen to blend by */
     prevZ: number;
     /** Where it is heading. Follows the target while it lives */
     tx: number;
+    /** The north-south coordinate it is heading for */
     tz: number;
+    /** World units it flies per second */
     speed: number;
+    /** The damage it deals on landing */
     damage: number;
+    /** The type of damage it deals */
     type: DamageType;
+    /** Whether the hit is a critical one */
     crit: boolean;
     /** Fired uphill and going to miss: it flies all the way and does nothing when it comes down */
     miss: boolean;
     /** Where it was fired from */
     sx: number;
+    /** North-south coordinate it was fired from */
     sz: number;
     /** Set for shots that hit an area instead of a target */
     splash?: {
@@ -96,25 +117,39 @@ export interface Projectile {
  * @beta
  */
 export interface Missile {
+    /** The missile's id, from `world.newId` */
     id: number;
+    /** The player whose unit sent it */
     owner: PlayerId;
+    /** The caster entity that sent it */
     source: EntityId;
+    /** The id of the ability it was sent by */
     ability: string;
+    /** The ability's level when it was sent */
     level: number;
+    /** Where it is now, east-west, in world units */
     x: number;
+    /** Where it is now, north-south, in world units */
     z: number;
+    /** Where it was at the last tick, east-west */
     prevX: number;
+    /** Where it was at the last tick, north-south */
     prevZ: number;
     /** Direction, of length 1 */
     dx: number;
+    /** North-south part of its direction */
     dz: number;
+    /** World units it travels per second */
     speed: number;
     /** How far it still goes */
     left: number;
     /** Seconds until it sets off, and how long that took in all */
     delay: number;
+    /** Seconds it takes to take shape before it sets off: `delay` starts from it and counts down */
     forms: number;
+    /** How far from its path it hits things, in world units */
     radius: number;
+    /** The missile effect of the ability that made it, which says what it does to what it hits */
     effect: EffectOf<'missile'>;
     /** Whom it has passed through already. Missiles sent together share it: what one of them hit the others pass by */
     hit: Set<EntityId>;
@@ -130,6 +165,18 @@ export interface Missile {
     bounces: number;
     /** Something got in its way: what happens where it ends does not */
     stopped: boolean;
+    /** On its way back to the caster (`EffectFields.returns`): it touches nobody (unless it `hitsOnReturn`), and ends where the caster is */
+    returning?: boolean;
+    /** How many it went through, for one that goes through so many (`pierce`) or less on each (`falloff`) */
+    struck?: number;
+    /** The last one it hit, for what happens where it meets a wall (`onWall`) */
+    last?: EntityId;
+    /** The level of the ground it set off from, for one that stops at a wall (`onWall`): a cliff above it is a wall */
+    floor?: number;
+    /** Where its owner steers it (`steer`, `steerMissile`) */
+    steerTo?: Vec2;
+    /** How full the ability that sent it was held (`EffectContext.held`), for one held and let go */
+    held?: number;
 }
 /**
  * Something an ability does a while after it was cast
@@ -137,14 +184,24 @@ export interface Missile {
  * @beta
  */
 export interface Delayed {
+    /** Seconds until its effects happen */
     left: number;
+    /** The unit that cast the ability */
     caster: Entity;
+    /** The ability whose effects are waiting */
     ability: AbilityDef;
+    /** The ability's level when it was cast */
     level: number;
+    /** Where the effects happen */
     point: Vec2;
+    /** The effects to run when the time is up */
     effects: EffectDef[];
     /** What its arrival goes by, when not the ability */
     impact?: string;
+    /** Where the effects went off from and the way they faced as it was cast, for those with a shape (`EffectCommon.shape`) */
+    from?: Vec2;
+    /** The way the effects faced as it was cast, in radians as a unit's `facing` (0 along +z), for those with a shape */
+    heading?: number;
 }
 /**
  * Ground an ability goes on working on for a while
@@ -152,22 +209,51 @@ export interface Delayed {
  * @beta
  */
 export interface Zone {
+    /** The zone's id, from `world.newId` */
     id: number;
+    /** The unit that cast the ability */
     caster: Entity;
+    /** The ability that made the zone */
     ability: AbilityDef;
+    /** The ability's level when it was cast */
     level: number;
+    /** Centre of the zone, east-west */
     x: number;
+    /** Centre of the zone, north-south */
     z: number;
+    /** Seconds the zone goes on */
     left: number;
     /** Seconds until what is inside is next seen to */
     next: number;
+    /** The zone effect that says what it does to what is inside */
     effect: EffectOf<'zone'>;
+    /**
+     * Where the effects went off from and the way they faced as it was cast, kept for what it holds with a shape
+     * (`EffectCommon.shape`): a cone of it goes off from there, the way it faced. Left out for one with no shape
+     */
+    from?: Vec2;
+    /** The way it faced as it was cast, in radians as a unit's `facing` (0 along +z); left out for one with no shape */
+    heading?: number;
+    /** The unit it goes with (`follow`) */
+    follows?: EntityId;
+    /** Who is in it now, by id from the lowest, for one that sees to who comes and goes (`onEnter`, `onLeave`, `edge`) */
+    inside?: EntityId[];
 }
-/** @beta */
+/**
+ * How a message to a player is shown: an error, information or a hint
+ *
+ * @beta
+ */
 export type MessageKind = 'error' | 'info' | 'hint';
-/** @beta */
+/**
+ * The events a world emits (`world.events`), by name, each with its payload; what hooks do not cover and listeners and sessions hear
+ *
+ * @beta
+ */
 export interface WorldEvents {
+    /** An entity was added to the world */
     entitySpawned: Entity;
+    /** An entity left the world, dead or taken away */
     entityRemoved: Entity;
     /**
      * `cause`: the blow, for what died of damage. `how`: what the rules made of the death in the `death` hook, for the
@@ -196,6 +282,7 @@ export interface WorldEvents {
         buff: string;
         expired: boolean;
     };
+    /** Damage was dealt to a target: how much, of which type, by whom and by what ability or attack */
     damaged: {
         target: Entity;
         source?: Entity;
@@ -213,6 +300,7 @@ export interface WorldEvents {
         source?: Entity;
         target?: Entity;
     };
+    /** A target was healed by an amount, by a source when it has one */
     healed: {
         target: Entity;
         source?: Entity;
@@ -224,7 +312,18 @@ export interface WorldEvents {
         target?: Entity;
         weapon: number;
     };
+    /**
+     * A swing called off before its blow (`cancelSwing`): the unit was told something else, its target went, it was
+     * stunned. What it was swinging at, where it was at something, and with which of its attacks
+     */
+    swingCancelled: {
+        attacker: Entity;
+        target?: Entity;
+        weapon: number;
+    };
+    /** A projectile was fired */
     projectileSpawned: Projectile;
+    /** A projectile landed or was taken away */
     projectileRemoved: Projectile;
     /** An attack that hits an area came down */
     impact: {
@@ -233,7 +332,9 @@ export interface WorldEvents {
         radius: number;
         owner: PlayerId;
     };
+    /** A building's construction began, its site placed */
     constructionStarted: Entity;
+    /** A building was completed */
     constructionFinished: Entity;
     /** A construction was called off by its owner: it dies next, with the reason `cancelled` */
     constructionCancelled: Entity;
@@ -248,6 +349,7 @@ export interface WorldEvents {
         entity: Entity;
         into: string;
     };
+    /** A building finished training a unit */
     unitTrained: {
         building: Entity;
         unit: Entity;
@@ -257,6 +359,13 @@ export interface WorldEvents {
         entity: Entity;
         from: string;
     };
+    /** A hero in a form turned back into what it was (`leaveForm`): `form`, the type it was in; `why`, what turned it back */
+    morphedBack: {
+        entity: Entity;
+        form: string;
+        why?: MorphBack | (string & {});
+    };
+    /** A player was defeated, out of the game */
     playerDefeated: Player;
     /** A player gave up (see `surrender`): `playerDefeated` follows */
     playerSurrendered: {
@@ -268,6 +377,7 @@ export interface WorldEvents {
         seconds: number;
         left: number;
     };
+    /** The game ended; `winner` is the winning team */
     gameOver: {
         winner: number;
     };
@@ -284,10 +394,12 @@ export interface WorldEvents {
         unit: Entity;
         player: PlayerId;
     };
+    /** A unit got out of a transport */
     unloaded: {
         passenger: Entity;
         transport: Entity;
     };
+    /** A hero reached a new level */
     heroLevelUp: {
         hero: Entity;
         level: number;
@@ -319,6 +431,7 @@ export interface WorldEvents {
         amount: number;
         reason?: string;
     };
+    /** A fallen hero was brought back */
     heroRevived: Entity;
     /** `duration`: seconds of the wind-up */
     castStarted: {
@@ -327,23 +440,36 @@ export interface WorldEvents {
         point?: Vec2;
         duration: number;
     };
+    /**
+     * A wind-up called off before it went off: the caster stunned, killed, or ordered elsewhere. `ability`: the one wound up,
+     * where it is still known (an item's, gone with the item, is not)
+     */
+    castCancelled: {
+        caster: Entity;
+        ability?: AbilityDef;
+    };
     /** A channelled ability started to be kept up, or ended: done, or `interrupted` */
     channelStarted: {
         caster: Entity;
         ability: AbilityDef;
         duration: number;
     };
+    /** A channelled ability stopped being kept up; `interrupted` when it was broken off */
     channelEnded: {
         caster: Entity;
         ability: AbilityDef;
         interrupted: boolean;
     };
+    /** A missile was sent on its way */
     missileSpawned: Missile;
+    /** A missile passed through a target */
     missileHit: {
         missile: Missile;
         target: Entity;
     };
+    /** A missile ended or was taken away */
     missileRemoved: Missile;
+    /** An ability was cast: by whom, at what level, at which target or point, and whether it used a charge */
     abilityCast: {
         caster: Entity;
         ability: AbilityDef;
@@ -352,7 +478,11 @@ export interface WorldEvents {
         point: Vec2;
         charged?: boolean;
     };
-    /** What an ability set off arrived: a missile hit, a rush ended, the time was up */
+    /**
+     * What an ability set off arrived: a missile hit, a rush ended, the time was up. `from`: where it went off from,
+     * when not the caster (`EffectContext.origin`). `effect`: the effect of the ability whose arrival it is (a missile, a
+     * delay, a zone at its end), where the list that landed is one of the ability's
+     */
     abilityImpact: {
         caster: Entity;
         ability: AbilityDef;
@@ -361,17 +491,28 @@ export interface WorldEvents {
         point: Vec2;
         radius: number;
         impact?: string;
+        from?: Vec2;
+        effect?: EffectDef;
     };
+    /** A building finished researching an upgrade, to this level */
     researchFinished: {
         building: Entity;
         upgrade: string;
         level: number;
     };
+    /** An item came to lie on the ground */
     itemDropped: GroundItem;
+    /** An entity picked an item up from the ground */
     itemPicked: {
         entity: Entity;
         item: ItemInstance;
     };
+    /** A hero took a purchase back at a shop (`undoBuy`): what it cost came back, the parts it used up came back */
+    itemUndone: {
+        entity: Entity;
+        item: string;
+        shop: number;
+    };
     /** Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`) */
     campCleared: {
         camp: Camp;
@@ -384,7 +525,7 @@ export interface WorldEvents {
     pinged: {
         player: PlayerId;
         point: Vec2;
-        kind: PingKind;
+        kind: PingId;
         to: ChatAudience;
         by?: string;
     };
@@ -415,6 +556,7 @@ export interface WorldEvents {
     inventoryChanged: {
         entity: Entity;
     };
+    /** A player was paid a bounty of this amount for an entity's death */
     bounty: {
         entity: Entity;
         player: PlayerId;
@@ -434,7 +576,7 @@ export interface WorldEvents {
     resourcesDeposited: {
         entity: Entity;
         player: PlayerId;
-        kind: ResourceKind;
+        kind: ResourceId;
         amount: number;
         upkeep?: number;
     };
@@ -478,7 +620,7 @@ export interface WorldEvents {
         kind: MessageKind;
         seconds?: number;
     };
-    /** A unit walked into an area of the game (`GameModule.areas`) */
+    /** A unit walked into an area of the game (`Rules.areas`) */
     enteredArea: {
         area: string;
         entity: Entity;
@@ -515,14 +657,18 @@ export interface WorldEvents {
     cinematicCue: CinematicCue;
     /** The rules cue the cinematic playing on some screens, or everyone's (see `cueCinematic`) */
     cinematicCued: CinematicCueSent;
+    /** The rules pan or shake one player's camera (see `cameraFor`) */
+    cameraOrdered: {
+        player: PlayerId;
+    } & Pick<CameraOrder, 'pan' | 'shake'>;
     /** A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`) */
     cinematicEnded: CinematicEnded;
     /** A player picked an answer of a cinematic's choice, as their screen said (see `cinematicChose`) */
     cinematicChoice: CinematicChoice;
-    /** The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.effect`) */
-    effectStarted: EffectCue;
-    /** The rules stop an effect they played (see `world.stopEffect`) */
-    effectStopped: {
+    /** The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.fx`) */
+    fxStarted: FxCue;
+    /** The rules stop an effect they played (see `world.stopFx`) */
+    fxStopped: {
         id: number;
         fade?: number;
     };
@@ -539,14 +685,25 @@ export interface WorldEvents {
         entered: boolean;
         teams?: number[];
     };
+    /**
+     * A gust of wind blew at a place (`gust`, `WindGust`): where, and the gust. Told to the players who see the place,
+     * for their screens to bend the grass and bushes there
+     */
+    gusted: {
+        x: number;
+        z: number;
+        gust: WindGust;
+    };
     /**
      * Cells of a layer (`Terrain.cells`) were set to a value (`setCells`): told to the players who see them, the others
-     * as they come into sight (`cellsSeen`)
+     * as they come into sight (`cellsSeen`). `over`: the seconds the screens ease into it over, where the rules said
+     * (grass growing back)
      */
     cellsChanged: {
         layer: string;
         cells: number[];
         value: number;
+        over?: number;
     };
     /**
      * Cells of a layer that changed out of a team's sight came into it (`TeamMemory.cells`): told to that team's players,
@@ -586,13 +743,17 @@ export interface WorldChecks {
  * @beta
  */
 export interface WorldOptions extends WorldChecks {
+    /** The ground the world stands on */
     terrain: Terrain;
+    /** The navigation units on the ground walk by */
     navigation: Navigation;
     /** Where boats go (`UnitTypeDef.naval`): the deep water. None for a map without, and boats go on the ground */
     waterNavigation?: Navigation;
-    /** The navigations the sides plan their routes on, of what each knows (`GameModule.paths: 'seen'`). None when left out */
+    /** The navigations the sides plan their routes on, of what each knows (`Rules.paths: 'seen'`). None when left out */
     sidePaths?: SidePaths;
+    /** The game's definitions: unit types, abilities, orders and the rest */
     registry: Registry;
+    /** The players of the world, in order, from which its `Player`s are made */
     players: PlayerInit[];
     /** The races one is drawn from for a player given `random`: all of the game's when left out */
     randomRaces?: readonly string[];
@@ -608,17 +769,22 @@ export interface WorldOptions extends WorldChecks {
     timers?: TimerDef[];
     /** Scripts of steps the game can start, by id */
     sequences?: SequenceDef[];
+    /** Seed for the world's random generator; 1 when left out */
     seed?: number;
     /** Simulation steps per second */
     tickRate?: number;
     /** The logger the world's own is made under (`world.log`): the root one when left out */
     log?: Logger;
-    /** The least an entry of the world's log must matter to be said (`GameModule.log`) */
+    /** The least an entry of the world's log must matter to be said (`Rules.log`) */
     logLevel?: LogLevel;
-    /** What becomes of a part of the game that throws (`GameModule.onError`): it throws on, when left out */
+    /** What becomes of a part of the game that throws (`Rules.onError`): it throws on, when left out */
     onError?: ErrorPolicy;
 }
-/** @beta */
+/**
+ * How a blow is described to `world.damage`: its type, whether it is an attack or crit, its ability, tags and how it kills
+ *
+ * @beta
+ */
 export interface DamageOptions {
     /** Physical when left out */
     damageType?: DamageType;
@@ -632,8 +798,6 @@ export interface DamageOptions {
     tags?: string[];
     /** How what this blow kills dies, for the screen (`'burnt'`): the death's `how` (`AttackDef.how`, `AbilityDef.how`) */
     how?: string;
-    /** The attack's type by the game's damage table (`GameRules.combat.damageTable`): an ability's say, where a basic attack has its `AttackDef.attackType` */
-    attackType?: string;
 }
 /**
  * What killed something that died of damage: the blow that did it
@@ -641,13 +805,17 @@ export interface DamageOptions {
  * @beta
  */
 export interface DeathCause {
+    /** The type of damage that killed */
     type: DamageType;
     /** What the blow took off */
     amount: number;
     /** How much more it was than there was health left */
     overkill: number;
+    /** Whether the killing blow was a critical hit */
     crit: boolean;
+    /** The id of the ability that dealt the blow, when it was one */
     ability?: string;
+    /** Words of the game's own about the blow (`DamageOptions.tags`) */
     tags?: string[];
     /** How the blow says what it kills dies (`DamageOptions.how`) */
     how?: string;
@@ -667,23 +835,43 @@ export type DeathReason = 'damage' | 'killed' | 'cancelled' | 'expired' | 'deple
  * @beta
  */
 export interface Reveal {
+    /** The reveal's id, from `world.newId` */
     id: number;
+    /** The team that sees the spot */
     team: number;
+    /** Centre of the revealed spot, east-west */
     x: number;
+    /** Centre of the revealed spot, north-south */
     z: number;
+    /** How far from the centre it reveals, in world units */
     radius: number;
     /** Seconds it goes on */
     left: number;
     /** Shown, and nothing drawn for it: what the rules show a player, as a cinematic looks at it. A spell's, when left out */
     quiet?: boolean;
 }
-/** @beta */
+/**
+ * What `world.spawn` is told besides type, owner and position: facing, size, look and the rest
+ *
+ * @beta
+ */
 export interface SpawnOptions {
+    /** The way it faces, in radians; the engine's default facing when left out */
     facing?: number;
     /** How big it is drawn */
     scale?: number;
     /** Which of the models of its type it is drawn with, for things that come in kinds like trees */
     look?: string;
+    /**
+     * Drawn as this entity is: its type's model, its owner's colour, its size and its look, while the new one stays what
+     * its own type and owner say it is (a soul in the fallen's shape). `scale` and `look` here win over the entity's
+     */
+    looksLike?: Entity;
+    /**
+     * Components it starts with, by id, as `Component.default` would not give them: `{ 'warden.soul': { hero: 4 } }`.
+     * They are on it before the hooks of its making run. An id the game does not have throws
+     */
+    data?: Record<string, unknown>;
     /** A name of its own, for the rules to find it by: `world.named('gate')` */
     name?: string;
     /** Seconds it lasts, when that is not what its type says */
@@ -694,6 +882,17 @@ export interface SpawnOptions {
         paid?: Cost;
     };
 }
+/**
+ * Where a new entity goes and whose it is, with what else it starts with (`World.spawn(type, { at, owner })`)
+ *
+ * @public
+ */
+export interface SpawnAt extends SpawnOptions {
+    /** Where it stands, in cells; a building is centred on the cells nearest it */
+    at: Vec2;
+    /** The player it belongs to */
+    owner: PlayerId;
+}
 /** See `World.internals` */
 export interface WorldInternals {
     nextEntityId: number;
@@ -719,17 +918,38 @@ export interface WorldWatcher {
     /** A tick ran */
     stepped?(): void;
 }
-/** @beta */
+/**
+ * The simulation: the ground, entities, players, systems and rules of one game, stepped a tick at a time with `step`
+ *
+ * @public
+ */
 export declare class World {
-    /** Obstacles the navigation had no room for (`RecastNavigationOptions.maxObstacles`): what is put down past it does not block the way */
+    /**
+     * Obstacles the navigation had no room for (`RecastNavigationOptions.maxObstacles`): what is put down past it does not block the way
+     *
+     * @beta
+     */
     obstaclesRefused: number;
+    /**
+     * The ground the world stands on
+     *
+     * @beta
+     */
     readonly terrain: Terrain;
-    /** The ground it started on, where it was made from a map (S36): what a save keeps only the changes of */
+    /**
+     * The ground it started on, where it was made from a map (S36): what a save keeps only the changes of
+     *
+     * @beta
+     */
     ground?: GroundBase;
-    /** The ground and the air. Agents find their own layer, everything else is about the ground */
+    /**
+     * The ground and the air. Agents find their own layer, everything else is about the ground
+     *
+     * @beta
+     */
     readonly nav: Navigation;
     /**
-     * The navigations the sides plan their routes on, of the buildings each knows (`GameModule.paths: 'seen'`): routes
+     * The navigations the sides plan their routes on, of the buildings each knows (`Rules.paths: 'seen'`): routes
      * of ground units are planned on their side's, and walked on `nav`. None where routes know everything
      *
      * @beta
@@ -737,12 +957,42 @@ export declare class World {
     readonly sidePaths?: SidePaths;
     /** The ground, the air and the water, to find where a kind of unit can be */
     private readonly layers;
+    /**
+     * The navigation an entity walks by: the air, the water or the ground, by its layer
+     *
+     * @beta
+     */
     navFor(entity: Entity): Navigation;
-    /** The air alone */
+    /**
+     * The air alone
+     *
+     * @beta
+     */
     readonly air: Navigation;
+    /** The game's definitions: unit types, abilities, orders and the rest */
     readonly registry: Registry;
+    /**
+     * Which cells are taken by buildings and what can be built where
+     *
+     * @beta
+     */
     readonly grid: BuildGrid;
+    /**
+     * What each team has seen and sees, per cell
+     *
+     * @beta
+     */
     readonly fog: FogOfWar;
+    /**
+     * Index of entities by position, for asking what is near a point.
+     *
+     * Units are filed once a tick, where they stand as it starts (after the commands, before the systems: `step`).
+     * A unit that moves during the tick (the `move` phase) is still filed where it was until the next, so a query in
+     * `resolve` searches by where units started and checks distance against where they are now: a unit that walked
+     * into range this tick may be found only the next. Structures are filed where they stand, as they are made
+     *
+     * @beta
+     */
     readonly spatial: SpatialIndex;
     /** What happened, for whoever watches: sessions, tests. Sent out at the end of each tick. Rules use `hooks` */
     readonly events: Emitter;
@@ -755,11 +1005,21 @@ export declare class World {
     /**
      * The engine's checks on itself this world runs (`DebugChecks`): what it was made with (`CreateWorldOptions.checks`),
      * the process's (`setDebugChecks`) when it says nothing. Slow: tests and development
+     *
+     * @beta
      */
     checks: DebugChecks;
-    /** Moved on by `invalidateStats` without an entity: every entity's stats are added up again when next asked for */
+    /**
+     * Moved on by `invalidateStats` without an entity: every entity's stats are added up again when next asked for
+     *
+     * @beta
+     */
     statsVersion: number;
-    /** What the debug tools follow of the rules as they run: hooks and listeners. Null when nobody asks, see `EventLog` */
+    /**
+     * What the debug tools follow of the rules as they run: hooks and listeners. Null when nobody asks, see `EventLog`
+     *
+     * @beta
+     */
     trace: Trace | null;
     /** Where game modules and mods take part in damage, deaths, orders and the like, see `HookEvents` */
     readonly hooks: Hooks;
@@ -772,7 +1032,7 @@ export declare class World {
     /** What each player is set to do, in a mission */
     readonly objectives: Objectives;
     /**
-     * What the game counts of its players (`GameRules.score`): `world.score.add(player, 'towersLost')`, `get`, `team`.
+     * What the game counts of its players (`RuleSettings.score`): `world.score.add(player, 'towersLost')`, `get`, `team`.
      * Counts nothing in a game that does not ask
      *
      * @beta
@@ -780,27 +1040,68 @@ export declare class World {
     readonly score: Score;
     /** What is said, by whom, to whom: `world.dialog.say(player, line)`, or `talk` in a sequence */
     readonly dialog: Dialog;
+    /** The world's seeded random generator; the only source of randomness the simulation uses */
     readonly rng: Rng;
+    /** Every player of the world, by id */
     readonly players: Map<number, Player>;
-    /** Everything in the world, by id. Fallen heroes stay in here while they wait to be brought back */
+    /**
+     * Everything in the world, by id. Fallen heroes stay in here while they wait to be brought back
+     *
+     * @beta
+     */
     readonly entities: Map<number, Entity>;
     /**
-     * The entities that are not scenery: the ones that move, act or change by themselves. Systems that run
-     * every tick go through these instead of `entities`, which on a big map is mostly trees.
+     * The entities that act: the ones that move, fight, build or change by themselves, which is everything but scenery.
+     * Systems that run every tick go through these instead of `entities`, which on a big map is mostly trees.
+     *
+     * In the order each became a unit, which is the order of ids except for scenery woken later (`Spawning.wake`: a
+     * tree given a buff), which comes last, after units made before it. A save keeps this order, so a loaded world
+     * walks it the same. A component's index (`EntityIndex`, `SystemDef.over`) walks in id order instead, so code that
+     * picks the first of equals breaks the tie by id, not by which it met first, to stay the same either way
      */
-    readonly actors: Map<number, Entity>;
+    readonly units: Map<number, Entity>;
     /**
      * The scenery each team sees right now, by team. Kept by the fog system whenever it works out what everyone sees:
      * scenery never moves, so this only changes then. Lets a session describe what is in sight without testing every tree
+     *
+     * @beta
      */
     readonly sceneryInSight: Map<number, Set<Entity>>;
-    /** Entities by owner, heroes by owner, shops. For questions that would otherwise go through every entity */
+    /**
+     * Entities by owner, heroes by owner, shops. For questions that would otherwise go through every entity
+     *
+     * @beta
+     */
     readonly index: EntityIndex;
+    /**
+     * The shots in flight
+     *
+     * @beta
+     */
     readonly projectiles: Projectile[];
+    /**
+     * The missiles in flight
+     *
+     * @beta
+     */
     readonly missiles: Missile[];
+    /**
+     * Effects waiting for their time to come
+     *
+     * @beta
+     */
     readonly delayed: Delayed[];
+    /**
+     * The zones that are working on the ground now
+     *
+     * @beta
+     */
     readonly zones: Zone[];
-    /** Switches for trying things out. A game that is played for real leaves them off */
+    /**
+     * Switches for trying things out. A game that is played for real leaves them off
+     *
+     * @beta
+     */
     readonly cheats: {
         /** Abilities and what is carried can be used again at once */
         noCooldowns: boolean;
@@ -814,51 +1115,111 @@ export declare class World {
     /**
      * Players who may use the debug commands (`debug.*`, see `debugCommands.ts`): who a session lets, a seat in the page
      * that asked, a server started to. Not in a save: whoever loads it says again
+     *
+     * @beta
      */
     readonly debugPlayers: Set<number>;
     /**
      * The entity each object of the map became, by the object's id (`MapObject.id`): what the map put down as the world
      * was made of it (`createWorldFromMap`), and what the editor's Play here put down since (`debug.mapObject`), for the
      * editor to find again what it moves and takes away (EQ10). Kept in a save
+     *
+     * @beta
+     */
+    readonly fromMap: Map<number, number>;
+    /**
+     * Spots a team sees for a while without anything there to see them
+     *
+     * @beta
      */
-    readonly mapEntities: Map<number, number>;
-    /** Spots a team sees for a while without anything there to see them */
     readonly reveals: Reveal[];
-    /** State of game modules and mods for the whole game, see `state` */
+    /**
+     * State of game modules and mods for the whole game, see `state`
+     *
+     * @beta
+     */
     readonly states: StateStore;
-    /** Items lying on the ground */
+    /**
+     * Items lying on the ground
+     *
+     * @beta
+     */
     readonly items: GroundItem[];
-    /** Runs the systems, in order, each as often as it asks */
+    /**
+     * Runs the systems, in order, each as often as it asks
+     *
+     * @beta
+     */
     readonly scheduler: Scheduler;
     /** The computer players: who is seated, kept in a save and seated again by a load (`world.computers.seat`) */
     readonly computers: Computers;
-    /** What the world's numbers started from (`rng`): 1 when none was given. A computer player's own numbers start from it and its player */
+    /**
+     * What the world's numbers started from (`rng`): 1 when none was given. A computer player's own numbers start from it and its player
+     *
+     * @beta
+     */
     readonly seed: number;
+    /** Simulation ticks per second */
     readonly tickRate: number;
-    /** Seconds per tick */
+    /**
+     * Seconds per tick
+     *
+     * @beta
+     */
     readonly dt: number;
+    /** The tick number the world is at, from 0; it goes up by one for each `step` */
     tick: number;
-    /** How things are hurt, healed and die (`Life`) */
+    /**
+     * How things are hurt, healed and die (`Life`)
+     *
+     * @beta
+     */
     readonly life: Life;
-    /** What each team sees of the entities (`Sight`): the fog, what is invisible, the game's say */
+    /**
+     * What each team sees of the entities (`Sight`): the fog, what is invisible, the game's say
+     *
+     * @beta
+     */
     readonly sight: Sight;
-    /** Who is on whose side (`Sides`): teams, relations, shared vision and control */
+    /**
+     * Who is on whose side (`Sides`): teams, relations, shared vision and control
+     *
+     * @beta
+     */
     readonly sides: Sides;
-    /** How entities come into the world and are moved about in it (`Spawning`) */
+    /**
+     * How entities come into the world and are moved about in it (`Spawning`)
+     *
+     * @beta
+     */
     readonly spawning: Spawning;
-    /** The time of day (`Clock`): the hour, night, turned forward or stopped */
+    /**
+     * The time of day (`Clock`): the hour, night, turned forward or stopped
+     *
+     * @beta
+     */
     readonly clock: Clock;
     /** Team that won, once the game is decided */
     winner: number | null;
     /**
      * What becomes of a part of the game that throws: a hook's handler, a listener, a system, a timer, an order, a
-     * command (`ErrorPolicy`). The game's own (`GameModule.onError`), or whoever runs the world's; with neither it
+     * command (`ErrorPolicy`). The game's own (`Rules.onError`), or whoever runs the world's; with neither it
      * throws, as it always did. A server and a launched game end the game where nothing is said (`??= 'end'`)
+     *
+     * @beta
      */
     errorPolicy?: ErrorPolicy;
-    /** Why the game ended on an error, once it has (`end`): the world is not stepped again */
+    /**
+     * Why the game ended on an error, once it has (`end`): the world is not stepped again
+     *
+     * @beta
+     */
     failure: WorldFailure | null;
-    /** The parts switched off for having thrown (`disable`), by name (`siteKey`): kept in a save, and off again when it is loaded */
+    /**
+     * The parts switched off for having thrown (`disable`), by name (`siteKey`): kept in a save, and off again when it is loaded
+     *
+     * @beta
+     */
     readonly disabled: Map<string, ErrorSite>;
     /** True through a tick: an error then can end the game; outside one it is whoever called's */
     private stepping;
@@ -884,42 +1245,95 @@ export declare class World {
      * @beta
      */
     commandLimit: number;
+    /**
+     * Makes an empty world of the options' terrain, rules and players; a game makes one with `createWorld` or
+     * `createWorldFromMap`, which also place the map's things and start the rules
+     *
+     * @beta
+     */
     constructor(options: WorldOptions);
-    /** The systems, in the order they run */
+    /**
+     * The systems, in the order they run
+     *
+     * @beta
+     */
     get systems(): readonly System[];
-    /** Adds a system to the running world, like a computer player. It takes its place by its phase, `before` and `after` */
+    /**
+     * Adds a system to the running world, like a computer player. It takes its place by its phase, `before` and `after`
+     *
+     * @beta
+     */
     addSystem(system: System): void;
     /** What systems kept in themselves when the game was saved, for those not added yet */
     private readonly savedSystems;
-    /** Gives the systems what they kept in a save (see `System.save`): those there now, and those added later */
+    /**
+     * Gives the systems what they kept in a save (see `System.save`): those there now, and those added later
+     *
+     * @beta
+     */
     restoreSystems(saved: Record<string, unknown>): void;
-    /** Takes a system out by name. False when there is none of that name */
+    /**
+     * Takes a system out by name. False when there is none of that name
+     *
+     * @beta
+     */
     removeSystem(name: string): boolean;
+    /** Seconds of game time that have passed: `tick` times `dt` */
     get time(): number;
-    /** A number of the rules as it is tuned now (`TunableDef`): what it was set to while playing, or its default */
+    /**
+     * A number of the rules as it is tuned now (`TunableDef`): what it was set to while playing, or its default
+     *
+     * @beta
+     */
     tunable(id: string): number;
-    /** Tunes a number of the rules, within its bounds, and says so (`tunableChanged`) */
+    /**
+     * Tunes a number of the rules, within its bounds, and says so (`tunableChanged`)
+     *
+     * @beta
+     */
     setTunable(id: string, value: number): void;
     /**
      * Changes a definition while the game runs (S61): a unit type's health, an ability's cooldown, as the editor's Data
      * panel tries them. What is made of it from then on is made of the new one; a unit type's units already in the world
      * take it at once, with as much of their health lost as before. Kept with the world and in its save, and said
-     * (`definitionChanged`). False for a definition the game does not have
+     * (`definitionChanged`). False for a definition the game does not have. Not held to what the game lets be changed
+     * (`Rules.editable`), as `layData` and a map's definitions are: any field is taken. The check is the command's that
+     * the Data panel sends (`redefineCommand`); code that calls this says what it allows itself
+     *
+     * @beta
      */
     redefine(kind: DataKind, id: string, values: DataValues): boolean;
     /** State of a game module or a mod for the whole game: made from the component's default when first asked for */
     state<T>(key: Component<T, unknown>): T;
+    /** Sets the whole game's state for a component, replacing what `state` gives for it */
     setState<T>(key: Component<T, unknown>, value: T): void;
-    /** The game's numbers that are not about any one unit, like the supply cap (`GameModule.rules`) */
-    get rules(): Readonly<GameRules>;
-    /** Hour of the day, 0..24. Noon in a game without days (`clock.hour`) */
+    /** The game's numbers that are not about any one unit, like the supply cap (`Rules.settings`) */
+    get settings(): Readonly<RuleSettings>;
+    /**
+     * Hour of the day, 0..24. Noon in a game without days (`clock.hour`)
+     *
+     * @beta
+     */
     get hour(): number;
-    /** Whether the sun is down (`clock.night`): asked for every unit's sight and stats, many times a tick */
+    /**
+     * Whether the sun is down (`clock.night`): asked for every unit's sight and stats, many times a tick
+     *
+     * @beta
+     */
     get night(): boolean;
-    /** Unique id for orders, order groups and projectiles */
+    /**
+     * Unique id for orders, order groups and projectiles
+     *
+     * @beta
+     */
     newId(): number;
+    /** The player of this id; throws when there is none */
     player(id: PlayerId): Player;
-    /** Whether an entity of this id was ever made here: one that died was, one of a number not yet given out never was */
+    /**
+     * Whether an entity of this id was ever made here: one that died was, one of a number not yet given out never was
+     *
+     * @beta
+     */
     made(id: EntityId): boolean;
     /** Living entity with this id */
     get(id: EntityId | undefined): Entity | undefined;
@@ -928,11 +1342,17 @@ export declare class World {
      * dead, or when there never was one. A game can say which names there are: `world.named<RoadNames>('gate')`
      */
     named<Name extends string = string>(name: Name): Entity | undefined;
-    /** The name an entity was given, if any */
+    /**
+     * The name an entity was given, if any
+     *
+     * @beta
+     */
     nameOf(entity: Entity): string | undefined;
     /**
      * Names an entity, for the rules to find it by (`named`), or takes its name away with none. It has one name, and a
      * name is one entity's: taking that of another that still lives throws. The name of the dead is free
+     *
+     * @beta
      */
     setName(entity: Entity, name: string | undefined): void;
     /**
@@ -944,9 +1364,17 @@ export declare class World {
     areEnemies(a: PlayerId, b: PlayerId): boolean;
     /** Whether two players are on one side (`sides.allies`) */
     areAllies(a: PlayerId, b: PlayerId): boolean;
-    /** Whether a player may command an entity (`sides.mayCommand`): what every command is checked against */
+    /**
+     * Whether a player may command an entity (`sides.mayCommand`): what every command is checked against
+     *
+     * @beta
+     */
     mayCommand(player: PlayerId, entity: Entity): boolean;
-    /** Whether a team currently sees the entity (`sight.sees`): asked of every entity, team and snapshot */
+    /**
+     * Whether a team currently sees the entity (`sight.sees`): asked of every entity, team and snapshot
+     *
+     * @beta
+     */
     isVisibleTo(entity: Entity, team: number): boolean;
     /**
      * Creates an entity. Structures are centered on the grid cells closest to `position`;
@@ -959,10 +1387,26 @@ export declare class World {
      * @beta
      */
     spawnPrefab(prefab: PrefabDef | string, options: SpawnPrefabOptions): SpawnedPrefab;
+    /**
+     * The neutral player, who owns what belongs to nobody (a soul, a mine, a tree): the first of them, the game's
+     * `MAP_NEUTRAL`. Throws for a game that has none
+     *
+     * @beta
+     */
+    get neutral(): PlayerId;
+    /**
+     * Puts a new entity of the unit type `typeId` into the world for `owner` at `at`, and returns it:
+     * `world.spawn('footman', { at: { x: 10, z: 12 }, owner: 1 })`, with the rest of what it may start with
+     * (`SpawnOptions`: `facing`, `name`, `lifetime`, `data`…) beside them
+     */
+    spawn(typeId: string, options: SpawnAt): Entity;
+    /** Puts a new entity of the unit type `typeId` into the world for `owner` at `position`, and returns it */
     spawn(typeId: string, owner: PlayerId, position: Vec2, options?: SpawnOptions): Entity;
     /**
      * Turns scenery into an actor, for good: something gave it a reason to be looked at every tick, like a buff
      * that has to run out. Whatever does that to an entity calls this; the debug checks catch what forgets to.
+     *
+     * @beta
      */
     wake(entity: Entity): void;
     /**
@@ -982,35 +1426,49 @@ export declare class World {
         over?: number;
     }): void;
     /**
-     * Plays one of the view's effects (`GameView.fx.defs`) on the screens of the players who see where it is, or those it is
+     * Plays one of the view's fx (`GameView.fx.defs`) on the screens of the players who see where it is, or those it is
      * for (`to`): at a place (`at`), or on an entity (`on`, at a `point` of its model), with knobs (`params`). Its random
      * parts go by a seed, the same on every screen. Nothing it does decides anything: it is not in the world's state, a
-     * save, or what a player who joins later is told. What it gives back stops it (`stopEffect`)
+     * save, or what a player who joins later is told. What it gives back stops it (`stopFx`)
      *
      * @beta
      */
-    effect(effect: string, options?: EffectOptions): number;
+    fx(fx: string, options?: FxOptions): number;
     /**
-     * Stops an effect the rules played (`effect`) on every screen, as its own `stop` says, over `fade` seconds
+     * Stops an fx the rules played (`fx`) on every screen, as its own `stop` says, over `fade` seconds
      *
      * @beta
      */
-    stopEffect(id: number, options?: {
+    stopFx(id: number, options?: {
         fade?: number;
     }): void;
-    setCells(layer: string, cells: readonly number[] | AreaShape, value: number): number[];
+    /**
+     * Sets the cells of a cell layer, given as indices or an area, to a value 0..255, and returns the cells that changed.
+     * `over`: the seconds the screens that see them ease into the value over (grass growing back), told with the cells;
+     * a screen told of them later, as they come into its sight, eases in as it can
+     *
+     * @beta
+     */
+    setCells(layer: string, cells: readonly number[] | AreaShape, value: number, options?: {
+        over?: number;
+    }): number[];
     /**
      * Reshapes a part of the ground as the game goes (`TerrainPatch`): its heights, cliffs, water, paint, what is kept
      * off it and the game's layers of cells, all at once, as the editor's Play here pushes the map's ground into the game
      * played (`debug.ground`, EQ10). What the rules go by follows: who sees whom from the levels, where can be built, and
-     * the ways, cut again of the ground as it is now (`Navigation.reshape`: on this thread, every machine the same, and
-     * not for nothing on a big map). What stands on it stays where it is. Every player is told (a `ground` event), and
-     * saves keep it. Throws where the patch does not fit the ground (`terrainPatchProblem`)
+     * the ways, cut again of the ground as it is now (`Navigation.reshape`: on this thread, every machine the same; only
+     * the tiles of the ways the patch reaches, a few milliseconds for a field, where the ground is still cut on the same
+     * grid, else all of them, which is not for nothing on a big map). What stands on it stays where it is. Every player
+     * is told (a `ground` event), and saves keep it. Throws where the patch does not fit the ground (`terrainPatchProblem`)
      *
      * @beta
      */
     reshapeGround(patch: TerrainPatch): void;
-    /** Lets a team see a spot for a while, with nothing standing there */
+    /**
+     * Lets a team see a spot for a while, with nothing standing there
+     *
+     * @beta
+     */
     reveal(team: number, point: Vec2, radius: number, seconds: number, options?: {
         quiet?: boolean;
     }): Reveal;
@@ -1025,9 +1483,15 @@ export declare class World {
      * Takes a unit out of the world for a while, or puts it back: a worker inside a gold mine, a unit carried in
      * something. While hidden it is not found, not seen and in nobody's way, and its orders wait. It comes back at
      * `at`, or where it went in, on the nearest ground it can stand on. Structures cannot hide
+     *
+     * @beta
      */
     setHidden(entity: Entity, hidden: boolean, at?: Vec2): void;
-    /** Gives an entity a time after which it is gone by itself, like a ward, or takes it away with `null` */
+    /**
+     * Gives an entity a time after which it is gone by itself, like a ward, or takes it away with `null`
+     *
+     * @beta
+     */
     setLifetime(entity: Entity, seconds: number | null): void;
     /** Deals damage (`life.damage`): the hooks, armor and shields, health, death */
     damage(target: Entity, amount: number, source?: Entity, options?: DamageOptions): void;
@@ -1043,11 +1507,17 @@ export declare class World {
     /**
      * Gives a player a hint (campaign plan CP5): a message of the kind `hint`, shown for `seconds` (the screen's own
      * time when left out), which a player who turned hints off in the settings does not see
+     *
+     * @beta
      */
     hint(player: PlayerId, message: MessageRef, options?: {
         seconds?: number;
     }): void;
-    /** The command being carried out, to find out whether it was refused: see `executeCommand` */
+    /**
+     * The command being carried out, to find out whether it was refused: see `executeCommand`
+     *
+     * @beta
+     */
     handling?: {
         player: PlayerId;
         refusal: Message | undefined;
@@ -1055,11 +1525,21 @@ export declare class World {
     /**
      * What a save needs that is the world's own business: id counters, the clock and the commands waiting for
      * the next tick. For `saveWorld` and `loadWorld` only
+     *
+     * @beta
      */
     internals(): WorldInternals;
-    /** Puts back what `internals` gave, for `loadWorld` only */
+    /**
+     * Puts back what `internals` gave, for `loadWorld` only
+     *
+     * @beta
+     */
     restoreInternals(internals: WorldInternals): void;
-    /** Puts back who died and waits to be taken out (`WorldInternals.dead`), once the entities are back. For `loadWorld` only */
+    /**
+     * Puts back who died and waits to be taken out (`WorldInternals.dead`), once the entities are back. For `loadWorld` only
+     *
+     * @beta
+     */
     restoreDead(ids: readonly EntityId[]): void;
     /**
      * Queues a player command. It is applied at the start of the next tick; talk (a command whose def says
@@ -1075,12 +1555,16 @@ export declare class World {
      * @beta
      */
     watch(watcher: WorldWatcher): () => void;
-    /** A save of the world was taken, which put its crowd back (`saveWorld`): told to what watches it. The engine's */
+    /**
+     * A save of the world was taken, which put its crowd back (`saveWorld`): told to what watches it. The engine's
+     *
+     * @beta
+     */
     saved(): void;
     /** Advances the simulation by one fixed tick */
     /**
      * The entities that are all of what is asked, for scripts: whose they are, of which type, in which area. Only the
-     * living, unless asked. A new list: for what runs every tick, go through `index` or `areas` instead
+     * living, unless asked. A new list: for what runs every tick, go through `index` or `areas` instead; by place and condition, `query`
      */
     find(filter?: {
         owner?: PlayerId;
@@ -1088,24 +1572,58 @@ export declare class World {
         area?: string;
         dead?: boolean;
     }): Entity[];
+    /**
+     * What in the world is all a query asks (`WorldQuery`): around a point or a unit (`near`, `radius`), in an area, of
+     * whom, of which type, kind and layer, what it carries and how hurt it is (`UnitCondition`), what a player sees, or
+     * code (`where`); in an order (`sort`: `nearest`, `lowestHealthShare`, `random`…), as many as `limit` says. A new list:
+     * `world.query({ near: hero, radius: 8, is: 'enemy', healthBelow: 0.3, sort: 'nearest', limit: 3 })`
+     *
+     * @beta
+     */
+    query(query?: WorldQuery): Entity[];
     /**
      * Marks a moment to start again from, like the start of a wave, with what the player is told it is ("Wave 6").
      * A session keeps a save of the world as it is at the end of this tick, for "Retry from wave 6"
      */
     checkpoint(label: MessageRef): void;
+    /**
+     * Steps the world one tick; does nothing once the game failed. In this order:
+     *
+     * 1. The commands sent since the last tick are carried out.
+     * 2. Units are filed by where they stand (`spatial`).
+     * 3. The systems run, phase by phase (`commands`, `decide`, `move`, `resolve`, `cleanup`).
+     * 4. The dead are taken out of the world (`remove` hook, `entityRemoved`).
+     * 5. `tick` goes up by one.
+     * 6. The tick's events go out to listeners (`world.events.on`), held until now.
+     *
+     * So a listener runs after the tick is over: `world.tick` is already the next one, and an entity that died this
+     * tick is no longer in `world.entities` (the event still carries it; a fallen hero waiting to be brought back
+     * stays). Hooks run at once, inside the tick, where
+     * what they are asked about happens
+     */
     step(): void;
     /**
      * What a part of the game that threw comes to, by what the world says of errors (`errorPolicy`). It returns when
      * the part is to be switched off or let go (`disable`): the caller does that, and goes on. It throws otherwise: the
      * error itself (`throw`), or what leaves the tick of a game that ends there (`end`)
+     *
+     * @beta
      */
     caught(error: unknown, where: ErrorSite): void;
-    /** Switches off the parts a save says were (`world.disabled`): the same game goes on as the one that was saved */
+    /**
+     * Switches off the parts a save says were (`world.disabled`): the same game goes on as the one that was saved
+     *
+     * @beta
+     */
     disable(sites: Iterable<ErrorSite>): void;
     private advance;
-    /** Throws when scenery has something that only actors get looked after for. See `debugChecks` */
+    /** Throws when scenery has something that only units get looked after for. See `debugChecks` */
     private checkScenery;
-    /** Whether it was disposed: its navigation is freed, and it is not to be stepped again */
+    /**
+     * Whether it was disposed: its navigation is freed, and it is not to be stepped again
+     *
+     * @beta
+     */
     get disposed(): boolean;
     private wasDisposed;
     /**