@v12-engine/engine 0.1.1 → 0.4.0

package/dist/defs.d.ts

@@ -1,32 +1,64 @@
 import type { AbilityAiView } from './ai/micro';
 import type { AiHints } from './ai/roles';
-import type { AbilityTextContext, AbilityValueDef, TextSegment } from './abilities/text';
+import type { AbilityTextContext, AbilityValueDef, CasterFacts, TextSegment } from './abilities/text';
+import type { EffectContext } from './abilities/effects';
 import type { EntityState } from './session/protocol';
 /**
  * Static game data. Everything a game module (melee, custom map, mod) defines about
  * its units lives in plain objects like these, the engine never hardcodes a unit.
  */
-import type { GameRules } from './rules';
+import type { RuleSettings } from './rules';
 import type { AbilityState, BuffInstance, Entity } from './entity';
 import type { Vec2 } from './math';
 import type { World } from './world';
+import type { BurnsDef } from './burning';
 /**
  * A value that can grow with the level of an ability: one number, or one per level
  *
  * @beta
  */
 export type Scaled = number | number[];
+/**
+ * What an amount in code is asked with (`EffectValue`): the ability's level and what the caster brings now, and the effect
+ * as it lands, where it is landing. The tooltip asks it too (`abilityValues`), with no `effect` and no target
+ *
+ * @beta
+ */
+export interface EffectValueContext {
+    /** The level of the ability */
+    level: number;
+    /** What the caster brings to the numbers now: its stats, its level as a hero (`casterFacts`) */
+    caster: CasterFacts;
+    /** The effect as it lands: the world, the caster, where, how far a missile came. Not there for the tooltip */
+    effect?: EffectContext;
+}
+/**
+ * An amount, a time or a size of an effect: a number, one per level (`Scaled`), or worked out in code for each target as
+ * it lands (`(context, target) => number`: a share of what the target lacks, more for each mark on it, by how far it
+ * flew). Code is asked with no target where the effect is not for one (a zone's time, an area's size) and by the
+ * tooltip; what the screen draws before a cast (the aim) has no caster to ask, and takes `AbilityDef.aim`
+ *
+ * @beta
+ */
+export type EffectValue = Scaled | ((context: EffectValueContext, target?: Entity) => number);
 /**
  * The value at a level. Levels past the end of the list get the last one
  *
  * @beta
  */
 export declare function at(value: Scaled | undefined, level: number, fallback?: number): number;
+/**
+ * The value of an amount where there is no caster to ask its code (`EffectValue`): at the level, or `fallback` for code.
+ * What the aim the screen draws and a computer player's guesses go by
+ *
+ * @beta
+ */
+export declare function declaredAt(value: EffectValue | undefined, level: number, fallback?: number): number;
 /**
  * The stats the engine reads: what a unit has of health, mana and their regeneration, how it moves, sees and attacks,
  * and its armor and magic resist (the two kinds of damage there are besides true). Levels, items, buffs and research
- * change them. A game adds stats of its own with `GameModule.stats`, a pack its own (`GamePack.stats`: the MOBA
- * stats of `withMobaStats`).
+ * change them. A game adds stats of its own with `Rules.stats`, a pack its own (`GamePack.stats`: the MOBA
+ * stats of `mobaStatsPack`).
  *
  * @beta
  */
@@ -37,13 +69,33 @@ export interface CoreStats {
     attackSpeed: number;
     /** Measured between the edges of attacker and target */
     attackRange: number;
+    /** The most health a unit has; the entity's `maxHealth` follows it */
     health: number;
     /** Against physical damage: 100 of it halve what arrives */
     armor: number;
     /** The same against magic damage */
     magicResist: number;
+    /**
+     * Part by which the damage it takes is more or less, after armor or magic resist and before shields: -0.3 takes 30%
+     * less, 0.2 a fifth more. Added up with the part of the damage's own type (below), and never below none
+     */
+    incomingDamage: number;
+    /** The same, of physical damage only, on top of `incomingDamage` */
+    incomingPhysicalDamage: number;
+    /** The same, of magic damage only, on top of `incomingDamage` */
+    incomingMagicDamage: number;
+    /** The same, of true damage only, on top of `incomingDamage` */
+    incomingTrueDamage: number;
+    /**
+     * Part by which all the damage it deals, of attacks and abilities, is more or less: -0.35 deals 35% less. Never below
+     * none
+     */
+    outgoingDamage: number;
+    /** Part by which the healing it gets is more or less: -0.4 heals 40% less (an anti-heal). Never below none */
+    incomingHealing: number;
     /** Per second */
     healthRegen: number;
+    /** The most mana a unit has */
     mana: number;
     /** Per second */
     manaRegen: number;
@@ -70,7 +122,9 @@ export type StatKey = string;
  * @beta
  */
 export interface StatDef {
+    /** The stat's id, which units, changes and abilities name it by */
     id: string;
+    /** What the player sees the stat called */
     name: string;
     /** Shown when the pointer is over it */
     description?: string;
@@ -78,11 +132,16 @@ export interface StatDef {
     default?: number;
     /** It never goes below or above these, whatever changes it */
     min?: number;
+    /** The highest the stat goes, whatever changes it; no upper bound when left out */
     max?: number;
     /** How it is shown: a whole number, a decimal, or a part of one as a percentage. A whole number when left out */
     format?: 'number' | 'decimal' | 'percent';
 }
-/** @beta */
+/**
+ * Gives a `CoreStats` with every stat at 0
+ *
+ * @beta
+ */
 export declare const noStats: () => CoreStats;
 /**
  * How the days go by. Hours run from 0 to 24
@@ -105,7 +164,11 @@ export interface DayCycle {
  * @beta
  */
 export declare function hourOf(day: DayCycle | null, seconds: number): number;
-/** @beta */
+/**
+ * Whether the hour (0..24) is night under the day cycle, before its dawn or from its dusk; never night without a day cycle
+ *
+ * @beta
+ */
 export declare const isNight: (day: DayCycle | null, hour: number) => boolean;
 /**
  * Something that changes stats: `stats` is added, `percent` makes them bigger or smaller by a part of what
@@ -114,7 +177,9 @@ export declare const isNight: (day: DayCycle | null, hour: number) => boolean;
  * @beta
  */
 export interface StatChange {
+    /** Amounts added to stats, by stat */
     stats?: Partial<Stats>;
+    /** Parts stats grow or shrink by, by stat: 0.1 is 10% more, and the parts add up before they are applied */
     percent?: Partial<Stats>;
 }
 /**
@@ -123,7 +188,9 @@ export interface StatChange {
  * @beta
  */
 export interface ScaledStatChange {
+    /** Amounts added to stats, by stat, each growing with the ability's level */
     stats?: Partial<Record<StatKey, Scaled>>;
+    /** Parts stats grow or shrink by, by stat, each growing with the ability's level */
     percent?: Partial<Record<StatKey, Scaled>>;
 }
 /**
@@ -144,17 +211,112 @@ export interface HeroDef {
     learns: string[];
     /** Abilities it has from the start and does not learn: the two spells every hero brings along. No mana, and nothing shortens their cooldown */
     spells?: string[];
+    /**
+     * Its innate: an ability it has from level 1, for no point, that grows with it: its level is the hero's (up to the
+     * ability's own `maxLevel` where it says one), or goes up at the hero levels of `innateLevels`. A passive most often
+     * (its buffs, its triggers), or one it casts
+     *
+     * @beta
+     */
+    innate?: string;
+    /**
+     * The hero levels its innate goes up a level at, from its first: `[1, 6, 11, 16]` has it at level 2 from the hero's
+     * sixth. The hero's own level, when left out
+     *
+     * @beta
+     */
+    innateLevels?: number[];
+    /**
+     * What it is good at, by calling (`CallingDef`, the game's: `heroesPack({ callings })`), each with a strength from 1
+     * to 3: `{ stalker: 3, roamer: 2 }`. They lock nothing: the shop's suggestions and filters, the tooltips and the
+     * computer players go by them
+     *
+     * @beta
+     */
+    callings?: Record<string, 1 | 2 | 3>;
     /** The level it stops at. 10 when left out */
     maxLevel?: number;
     /** A buff whose stacks are shown next to its health and mana, as so many points out of as many as it can have */
     meter?: string;
     /**
-     * Its primary attribute, in a game with the attributes pack (`withAttributes`): each point of it adds to its attack
-     * as well. `AttributesOptions.primaryOf` says it in code
+     * The forms it takes (a `morph` effect's `into`), by unit type: what it learns in each (`HeroForm`). A form is a
+     * hero's type of its own (its stats, its growth, its look); this says what of the hero's it takes along
+     *
+     * @beta
+     */
+    forms?: Record<string, HeroForm>;
+}
+/**
+ * What becomes of a hero's cooldowns going in and out of a form (`HeroForm.cooldowns`)
+ *
+ * @beta
+ */
+export type FormCooldowns = 'keep' | 'reset' | 'shared';
+/**
+ * What a hero is in one of its forms (`HeroDef.forms`): the abilities it learns there by id (`learns`), the level each
+ * starts at (`levels`: that of one of the hero's own, or a number), and what of its own the form leaves in place
+ * (`keeps`). Everything else of its own is put away until it turns back
+ *
+ * ```ts
+ * // Nidalee's cougar: Takedown at Rocket Grab's level and Pounce at Void Swarm's, Swipe learned in the form; the
+ * // aspect (it made the form) and the ultimate stay as they are
+ * forms: { cougar: { learns: ['takedown', 'pounce', 'swipe'], levels: { takedown: 'rocketGrab', pounce: 'voidSwarm' }, keeps: ['heartbreaker'] } }
+ * ```
+ *
+ * The shorter shape, a list alone with neither `levels` nor `keeps`, is read by slot: the first at the level of the
+ * first the hero learns as itself, the second of the second, and so on (Q is Q), a point put into one in the form going
+ * to the hero's own at that slot too
+ *
+ * @beta
+ */
+export interface HeroForm {
+    /**
+     * The abilities it learns in the form, by id: what the HUD's card and hero panel show there, and what its points go
+     * into, in this order (the hero's own it keeps after them). One of the hero's own named here is kept as it is. What
+     * the form's type learns (its `hero.learns`) when left out
+     */
+    learns?: string[];
+    /**
+     * The level each of `learns` starts at in the form, by id: the id of one of the hero's own abilities, whose level it
+     * has (a point put into it in the form goes to that one too), or a number. 0 for what is not said: learned in the form
+     */
+    levels?: Record<string, string | number>;
+    /**
+     * The hero's own abilities the form leaves in place, by id: castable in the form as they are, level and cooldown (an
+     * ultimate, a passive); learned there, those it learns as itself. The ability that made the form and the spells it
+     * brought along (`HeroDef.spells`) are kept unsaid
+     */
+    keeps?: string[];
+    /**
+     * What becomes of the cooldowns of what the form puts away and of what it brings, when the hero goes in and out of it
+     * within the time of a cooldown:
+     *
+     * - left out: what the hero puts away runs down by the time it is away, and comes back with what is left; what the
+     *   form brings starts ready each time. The default
+     * - `'keep'`: what is put away comes back exactly as it was left, the time away not counted: a form is not a way to
+     *   wait out a cooldown
+     * - `'reset'`: what is put away comes back ready, its cooldown 0: a form is a way to get them back
+     * - `'shared'`: an ability of the form whose level is one of the hero's own (`levels` by id, or by slot in the shorter
+     *   shape) has one cooldown with it: it starts with the cooldown of the one it takes the place of, and gives its
+     *   own, what it has by then (cast in the form or run down), back as the hero turns back. The rest as when left out
+     *
+     * What the form keeps in place (`keeps`, the ability that made it, the spells) is one ability in both and is never
+     * touched by any of them
      */
-    primary?: 'strength' | 'agility' | 'intelligence';
+    cooldowns?: FormCooldowns;
 }
-/** @beta */
+/**
+ * What turns a form back into the hero it was (`EffectFields.back`): the ability that made it cast again (`ability`),
+ * its time up (`time`), or its death (`death`: it falls as itself, and is brought back as itself)
+ *
+ * @beta
+ */
+export type MorphBack = 'ability' | 'time' | 'death';
+/**
+ * What an entity is: a unit, a building or a resource
+ *
+ * @beta
+ */
 export type EntityKind = 'unit' | 'building' | 'resource';
 /**
  * Where something is: on the ground, or above it
@@ -185,7 +347,7 @@ export interface AttackStats {
  */
 export interface AttackDef {
     /**
-     * The stats its numbers are, by id: a stat of the game's (`GameModule.stats`) for a weapon whose damage, speed or
+     * The stats its numbers are, by id: a stat of the game's (`Rules.stats`) for a weapon whose damage, speed or
      * range is not the unit's first's. What changes those stats (research, items, buffs) changes this attack alone
      */
     stats?: AttackStats;
@@ -193,11 +355,18 @@ export interface AttackDef {
     damageType?: DamageType;
     /** Seconds from the start of the swing until damage lands (or the projectile leaves), at the attack speed the unit starts with */
     damagePoint: number;
+    /**
+     * Seconds after the blow during which the unit is held: an order it is given (a move, another attack) waits until
+     * they are over, unless the rules let it cut them (`RuleSettings.combat.recoveryCancels`). At the attack speed the unit
+     * starts with, shorter as it attacks faster, and never past its next swing. None when left out: it may walk away
+     * the moment the blow lands (kiting), as in LoL
+     */
+    recovery?: number;
     /** Enemies closer than this are attacked automatically */
     acquisitionRange: number;
     /**
      * How near is too near, edge to edge: what is closer than this the attack does not hit (a siege weapon's dead zone).
-     * Another of the unit's attacks takes over there where one reaches (`GameRules.combat.pickAttack`); with none, a unit
+     * Another of the unit's attacks takes over there where one reaches (`RuleSettings.combat.pickAttack`); with none, a unit
      * told to attack steps back out of it first, and one left to itself does not pick what is that near. None when left out
      */
     minRange?: number;
@@ -223,6 +392,13 @@ export interface AttackDef {
     ground?: boolean;
     /** Brings down what is `fellable` in the area it hits */
     fells?: boolean;
+    /**
+     * A blow from up close (no missile) also strikes the target's other enemies near it, a part of its damage each:
+     * a cleave. With a buff's (`BuffDef.cleave`), the one of the larger part counts
+     *
+     * @beta
+     */
+    cleave?: Cleave;
     /**
      * How what this attack kills dies, for the screen (`'shot'`, `'crushed'`, `'burnt'`): the death's `how`, which the
      * view shows its way (`UnitLook.death`). A word, or one decided for each blow. The `death` hook has the last say
@@ -235,25 +411,38 @@ export interface AttackDef {
         crit: boolean;
         tags?: readonly string[];
     }) => string | undefined);
-    /**
-     * The attack's type against the target's armour type, by the game's damage table (`GameRules.combat.damageTable`): `pierce`,
-     * `siege`… Left out, the attack is multiplied by nothing
-     */
-    attackType?: string;
+}
+/**
+ * What a blow from up close does to the enemies around its target (`AttackDef.cleave`, `BuffDef.cleave`): a part of
+ * its damage, before their armor, for each of them within `radius` of the target and, where `angle` says, within a
+ * cone of that angle that opens from the attacker through the target (so ahead of the attacker, round and behind the
+ * target). Not the target itself, nor anyone the attack could not hit
+ *
+ * @beta
+ */
+export interface Cleave {
+    /** The part of the blow's damage each other enemy takes, by level for a buff's: 0.5 is half */
+    part: Scaled;
+    /** How far from the target's edge the enemies it reaches stand */
+    radius: number;
+    /** How wide the cone is, in radians (1.57: a quarter turn). All the way round the target when left out */
+    angle?: number;
 }
 /**
  * The id of a resource, as its game module defines it (`ResourceDef`)
  *
  * @beta
  */
-export type ResourceKind = string;
+export type ResourceId = string;
 /**
  * Something players have amounts of and pay with, like gold, lumber or crystals. A game module lists its own
  *
  * @beta
  */
 export interface ResourceDef {
-    id: ResourceKind;
+    /** The resource's id, which prices, players' amounts and gatherers name it by */
+    id: ResourceId;
+    /** What the player sees the resource called */
     name: string;
     /** What every player starts a game with. Nothing when left out */
     start?: number;
@@ -265,17 +454,31 @@ export interface ResourceDef {
  *
  * @beta
  */
-export type Cost = Record<ResourceKind, number>;
-/** @beta */
+export type Cost = Record<ResourceId, number>;
+/**
+ * The definition of a unit type: a unit, building or resource, with its stats, abilities, costs and what it does
+ *
+ * @public
+ */
 export interface UnitTypeDef {
+    /** The type's id, shared by every game: give it a prefix of the game's */
     id: string;
+    /** What the player sees the type called */
     name: string;
     /**
      * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):
      * what it is drawn, heard and pictured as where the game gives it no look of its own
      */
     basedOn?: string;
+    /** Whether the type is a unit, a building or a resource */
     kind: EntityKind;
+    /**
+     * Words of the game's for what it is (`undead`, `mechanical`, `ward`): what an effect's `tags`, an ability's
+     * `targets.tags` and an `if`'s condition (`UnitCondition.tags`) go by
+     *
+     * @beta
+     */
+    tags?: string[];
     /** Collision radius */
     radius: number;
     /** Size in grid cells. Required for buildings and resources */
@@ -301,12 +504,12 @@ export interface UnitTypeDef {
      */
     naval?: boolean;
     /**
-     * A waygate, in a game with the portals pack (`withPortals`): a unit told to it walks in and is at once where it
+     * A waygate, in a game with the portals pack (`portalsPack`): a unit told to it walks in and is at once where it
      * leads (its `waygate` field, a point of the map; `setWaygate` in code)
      */
     waygate?: boolean;
     /**
-     * Rocks, a barricade, a gate to break down, in a game with the destructibles pack (`withDestructibles`): it stands in
+     * Rocks, a barricade, a gate to break down, in a game with the destructibles pack (`destructiblesPack`): it stands in
      * the way as any building does until it is brought down, and any unit whose attack reaches it attacks it when told
      * to, never of its own accord
      */
@@ -327,14 +530,15 @@ export interface UnitTypeDef {
         /** Attack damage each one inside adds; or in code, all of what they add, by who is inside (none for nobody) */
         armed?: number | ((world: World, building: Entity, inside: Entity[]) => number);
     };
-    /** Radians per second */
+    /** How fast it turns, in radians a second: the game's for every unit (`RuleSettings.movement.turnRate`, 12) when left out */
     turnRate?: number;
     /**
      * How it attacks, as the classic RTS two weapons: against each target the first that reaches it (its `targets`), or
-     * the one the game picks (`GameRules.combat.pickAttack`). It swings one at a time: a hit's cooldown is that attack's,
+     * the one the game picks (`RuleSettings.combat.pickAttack`). It swings one at a time: a hit's cooldown is that attack's,
      * whichever swings next. None for what does not attack
      */
     attacks?: AttackDef[];
+    /** Makes the type a hero, with its levels and the rest of `HeroDef`; none for a unit that is not one */
     hero?: HeroDef;
     /** How dangerous it is, for creeps. Shown to the player, and added up per camp */
     level?: number;
@@ -356,7 +560,7 @@ export interface UnitTypeDef {
     /** Building types the player has to have before this can be built or trained */
     requires?: string[];
     /**
-     * The race it is of (`GameModule.races`): only its players may build or train it. Everyone's when left out: creeps,
+     * The race it is of (`Rules.races`): only its players may build or train it. Everyone's when left out: creeps,
      * what is shared. What a player may have is the game's to change (the `available` hook)
      */
     race?: string;
@@ -388,16 +592,19 @@ export interface UnitTypeDef {
     revives?: boolean;
     /** Ids of the abilities the unit has */
     abilities?: string[];
+    /** What it costs to build or train, in resources */
     cost?: Cost;
-    /** Supply (food) it takes up for as long as it lives, and while it is being trained */
-    supply?: number;
-    /** What it takes of the game's other pools of supply, by name (`GameRules.supply.pools`): `{ command: 1 }` */
-    supplies?: Record<string, number>;
+    /**
+     * Supply (food) it takes up for as long as it lives, and while it is being trained: of the one pool there always is, or by
+     * pool (`{ supply: 2, command: 1 }`: `supply` that one, the rest the game's own, `RuleSettings.supply.pools`). Read with
+     * `supplyOf` and `supplyPoolsOf`
+     */
+    supply?: number | Record<string, number>;
     /** Seconds to build or train */
     buildTime?: number;
-    supplyProvided?: number;
-    /** What it provides of the game's other pools of supply, by name (`GameRules.supply.pools`), once it stands finished */
-    suppliesProvided?: Record<string, number>;
+    /** What it provides once it stands finished: of the one pool, or by pool, as `supply` is said. Read with `supplyGivenOf` and `supplyPoolsGivenOf` */
+    supplyGiven?: number | Record<string, number>;
+    /** Makes it a worker that gathers: how much it carries, seconds a load takes, and which resources it gathers */
     harvester?: {
         capacity: number;
         gatherTime: number;
@@ -405,7 +612,7 @@ export interface UnitTypeDef {
          * The kinds of resource it gathers: all of them when left out. The undead's acolytes gold and nothing else, ghouls
          * lumber. The `canHarvest` hook has the last word (`canHarvest`)
          */
-        kinds?: ResourceKind[];
+        ids?: ResourceId[];
     };
     /** Building types this unit can construct */
     builds?: string[];
@@ -414,19 +621,19 @@ export interface UnitTypeDef {
     /** Upgrades that can be researched here */
     researches?: string[];
     /** Accepts harvested resources: all of them, or only the ones listed */
-    dropOff?: boolean | ResourceKind[];
+    dropOff?: boolean | ResourceId[];
     /**
      * Goes up on a resource of this kind, over it, of the same footprint: the undead's cursed gold mine. The resource is
      * its owner's alone from then on (`canHarvest`); one that takes what is gathered there (`dropOff`) has its owner's
      * workers gather at it from around it, handing in where they stand, as many at once as `gatherers` says. It goes
      * down with the resource, which stands again where it is destroyed
      */
-    builtOn?: ResourceKind;
+    builtOn?: ResourceId;
     /** Workers that gather at once at it, when it stands on a resource (`builtOn`): 5 when left out */
     gatherers?: number;
     /**
      * Goes up on its own once it is put down, as the undead summon theirs: the builder is free at once, and nobody
-     * helps (`GameRules.production.buildRate` of one builder, all the way). The same as `construction: 'self'`
+     * helps (`RuleSettings.production.buildRate` of one builder, all the way). The same as `construction: 'self'`
      */
     buildsItself?: boolean;
     /**
@@ -438,14 +645,15 @@ export interface UnitTypeDef {
      */
     construction?: 'builder' | 'self' | 'instant';
     /**
-     * How fast it goes up with so many builders at it, 1 being one builder's: the game's rule (`GameRules.production.buildRate`) for
+     * How fast it goes up with so many builders at it, 1 being one builder's: the game's rule (`RuleSettings.production.buildRate`) for
      * every type when left out
      *
      * @beta
      */
     buildRate?: (builders: number, world: World, structure: Entity) => number;
+    /** Makes it a deposit that can be gathered from: which resource, how much, how many workers fit and how they gather */
     resource?: {
-        kind: ResourceKind;
+        id: ResourceId;
         amount: number;
         /** Workers that fit inside at once, for resources that are entered */
         slots: number;
@@ -458,7 +666,14 @@ export interface UnitTypeDef {
     hotkey?: string;
     /** Higher values are picked first when acquiring targets */
     threat?: number;
+    /** Whether it cannot be hurt */
     invulnerable?: boolean;
+    /**
+     * Ids of the abilities that alone may target it (a soul that only `possess` takes). Nothing else may: not an ability
+     * clicked on it or used on it by the AI, nor an attack, nor the area of one, nor a heal; the ones named get through
+     * the target rules as they say (`targets`). It is untouched as `invulnerable` is, but for them
+     */
+    targetableBy?: string[];
     /** Takes damage like anything else but never dies of it: it is left with a little health, like something to practise on */
     undying?: boolean;
     /** Seconds after it was last hurt that it is whole again, all at once */
@@ -468,7 +683,15 @@ export interface UnitTypeDef {
     /** Destroyed by attacks that fell, like a tree by a catapult, whatever else it withstands */
     fellable?: boolean;
     /**
-     * A piece of wall (`withWalls`): it joins with the pieces of its family beside it, and its shape (`single`, `end`,
+     * Whether it burns, in a game with the burning pack (`burningPack`), and how (`BurnsDef`: for how long, what it
+     * leaves, whether its wood is kept, what kind of burning it is): `true` as the pack says, `false` never. What can be
+     * felled (`fellable`: trees) burns when left out; anything else does not
+     *
+     * @beta
+     */
+    burns?: boolean | BurnsDef;
+    /**
+     * A piece of wall (`wallsPack`): it joins with the pieces of its family beside it, and its shape (`single`, `end`,
      * `straight`, `corner`, `tee`, `cross`) is its look. A gate (`gate`) joins as a piece does, turned along its line,
      * and its owner opens and shuts it for everyone (`wallGateCommand`): its look `open` or `shut`. Pieces join by their
      * footprints, so a gate wider than a cell sits in a line of pieces of one: one of a cell lets nobody through, the
@@ -484,23 +707,124 @@ export interface UnitTypeDef {
     invisible?: {
         after?: number;
     };
-    /** Goes down after this many attacks and spells, whatever they deal: its health counts hits */
-    hits?: number;
+    /**
+     * Finds what of its enemies is invisible or camouflaged within this far of it, for its team, for as long as it stays
+     * that near, in a game with the vision pack (`visionPack`): a Sentry Ward's true sight, a Control Ward
+     *
+     * @beta
+     */
+    trueSight?: number;
+    /**
+     * Goes down after this many attacks and spells, whatever they deal: its health counts hits, and its most health is
+     * this whatever its `stats.health` or what changes its stats say
+     */
+    uses?: number;
+    /**
+     * A trap, a mine, a pickup, in a game with the ground objects pack (`groundObjectsPack`): an ability of the game's that
+     * goes off as one of those it is for comes within its `radius` (`GroundTrigger`)
+     *
+     * @beta
+     */
+    trigger?: GroundTrigger;
+    /**
+     * Something others click on, in a game with the ground objects pack (`groundObjectsPack`): a unit of those it is for
+     * told to it (right-clicked) walks up to it and uses it, an ability of the game's going off (`GroundUse`): Thresh's
+     * lantern, Bard's portals
+     *
+     * @beta
+     */
+    use?: GroundUse;
+    /**
+     * Stops the missiles of abilities that come at it, in a game with the ground objects pack (`groundObjectsPack`):
+     * those of its enemies (`enemies`), or of everyone (`all`); they are gone where they meet it, with nothing happening
+     * (Yasuo's Wind Wall, a line of them: `EffectFields.line`). A missile thrown (`arc`) flies over it
+     *
+     * @beta
+     */
+    blocksMissiles?: 'enemies' | 'all';
+    /**
+     * What happens where it dies, in a game with the ground objects pack (`groundObjectsPack`): an ability of the game's
+     * goes off there in its maker's name (`ability`), and those of its type and owner within `chain` of it die too and
+     * go off in turn: Gangplank's barrels (`uses: 3` counts the hits that bring one down)
+     *
+     * @beta
+     */
+    burst?: {
+        ability: string;
+        chain?: number;
+    };
+    /**
+     * Resources of its own beside mana, in a game with the resources pack (`resourcesPack`), by id: energy, fury, heat,
+     * flow, ammo (`PoolDef`: how much at most, at the start, back each second, lost each second when nothing used it,
+     * gained by walking, refilled when empty, and buffs at thresholds). What its abilities cost of them (`AbilityDef.cost`)
+     * and give (`gain`), what its attacks cost (`attackCost`), the `gain` effect
+     *
+     * @beta
+     */
+    pools?: Record<string, PoolDef>;
+    /**
+     * What each of its attacks costs of its pools (`pools`), in a game with the resources pack: with less than that it
+     * does not attack (Jhin's four shots, then the reload)
+     *
+     * @beta
+     */
+    attackCost?: Record<string, number>;
     /**
      * What the computer player takes it for (`AiHints`): its roles (`worker`, `hall`, `soldier`...), the game's words
      * about it, what it answers. Declared where what the kit infers from the rest of the definition is wrong or cannot
      * be known; inferred otherwise (`inferRoles` in `@v12-engine/engine/ai`)
      */
     ai?: AiHints;
-    /** Its armour type, the column of the game's damage table (`GameRules.combat.damageTable`): `light`, `heavy`, `fortified`… */
-    armourType?: string;
 }
 /**
- * How an ability is aimed
+ * The names of a game's own ways of aiming an ability (`defineTargeting`), by declaration merging:
+ * `declare module '@v12-engine/engine' { interface AbilityTargetings { wall: true } }` makes `target: 'wall'` an
+ * ability's way of aiming
+ *
+ * @beta
+ */
+export interface AbilityTargetings {
+}
+/**
+ * How an ability is aimed: the engine's ways (`AimKind`: `none`, `unit`, `point`, `direction`, `vector`, `passive`), or a
+ * game's own (`AbilityTargetings`, `defineTargeting`)
+ *
+ * @beta
+ */
+export type AbilityTarget = 'none' | 'unit' | 'point' | 'direction' | 'vector' | 'passive' | keyof AbilityTargetings;
+/**
+ * How an ability is cast again after it is cast (`AbilityDef.recast`): for `window` seconds the same button casts the
+ * recast, `count` times, each doing its `effects` (no wind-up, no channel, `manaCost` its own: none when left out); the
+ * cooldown waits for the last recast or the window's end (`after`) or starts at the first cast (`first`). The window
+ * and its recasts are the ability's state (`AbilityState.recast`), saved and told to its owner's button
+ * (`AbilityInfo.recast`)
  *
  * @beta
  */
-export type AbilityTarget = 'none' | 'unit' | 'point' | 'direction' | 'passive';
+export interface AbilityRecast {
+    /** Seconds it may be cast again for, from the cast */
+    window: Scaled;
+    /** How many times it may be cast again in the window: once when left out */
+    count?: number;
+    /** What a recast does: the ability's own `effects` when left out */
+    effects?: EffectDef[];
+    /** How a recast is aimed: as the ability is when left out; with a `mark`, at the marked unit, with no aim of its own */
+    target?: AbilityTarget;
+    /** How far away a recast's target may be: the ability's `range` when left out */
+    range?: Scaled;
+    /**
+     * A buff the cast leaves on a unit (Sonic Wave's mark): a recast goes to the unit that carries it from the caster
+     * (the nearest, where there are more), its target and its point, and is refused while none does (`noMark`)
+     */
+    mark?: string;
+    /**
+     * When the cooldown starts: `after` the last recast, or the window's end (when left out), with what it was as the
+     * ability was cast; or at the `first` cast, as usual, the recasts not waiting for it
+     */
+    cooldown?: 'after' | 'first';
+    /** Mana a recast costs: none when left out */
+    manaCost?: Scaled;
+}
 /**
  * What every effect may say, whatever its type: who of what it reaches it applies to (`effectTargets`)
  *
@@ -509,89 +833,663 @@ export type AbilityTarget = 'none' | 'unit' | 'point' | 'direction' | 'passive';
 export interface EffectCommon {
     /** Only hits what carries this buff */
     ifBuff?: string;
+    /**
+     * Which look of its ability the screen draws it with (`AbilityLook.effects` in the client: by this name, else by its
+     * place in the ability or its type). Nothing to the rules: the same game with another look
+     *
+     * @beta
+     */
+    look?: string;
     /** Only hits heroes */
     only?: 'heroes';
+    /**
+     * Only hits what has one of these tags of its type (`UnitTypeDef.tags`): `['undead']`. Everything when left out
+     *
+     * @beta
+     */
+    tags?: string[];
+    /**
+     * It happens by chance: this share of the times it would (0.25 one in four), drawn from the world's numbers
+     * (`world.rng`), so the same every run. Once each time its list runs, for all it reaches; for a trigger (`onHit`,
+     * `onDamaged`…), each time it would go off (Bash), its cooldown starting only when it does; for an `if`, a
+     * condition like its others, drawn for each it asks of (and `otherwise` when the draw fails). A number, one per
+     * level, or code (`EffectValue`) asked with the target
+     *
+     * @beta
+     */
+    chance?: EffectValue;
     /** Only hits these kinds of things. Everything but resources when left out */
     kinds?: EntityKind[];
     /** Where what it hits has to be: on the ground, in the air. Both when left out */
     layers?: Layer[];
-    /** Makes the effect hit everything around the point of impact. Required for auras, and the size of a missile */
-    radius?: Scaled;
+    /**
+     * Makes the effect hit everything around the point of impact. Required for auras, and the size of a missile. In code
+     * (`EffectValue`), asked as it lands with no target
+     */
+    radius?: EffectValue;
+    /**
+     * What ground it covers (`EffectShape`), turned the way the ability was aimed: `circle` (its `radius`, what an effect
+     * with a radius alone covers), `cone` (`length`, `angle`), `line` (`length`, `width`), `rect` (`length`, `width`),
+     * `ring` (`radius`, `width`), `arc` (`radius`, `angle`, `width`), `cross` (`length`, `width`). A circle, a ring, a
+     * rectangle and a cross lie around where it landed; a cone, a line and an arc go off from the caster (or the
+     * context's `origin`) the way of where it landed. Everything in it, as `affects` says, is hit (`effectArea`,
+     * `inArea`). Of a zone: what is inside it, for `onEnter`, `onLeave` and `edge`
+     *
+     * @beta
+     */
+    shape?: EffectShape;
+    /** Of a `cone`, a `line`, a `rect` and a `cross`: how long it is, end to end. In code (`EffectValue`), asked as it lands @beta */
+    length?: EffectValue;
+    /**
+     * Of a `line`, a `rect` and a `cross`: how far it covers on either side of its middle; of a `ring` and an `arc`, how
+     * thick it is, inwards from its `radius`. 1 when left out
+     *
+     * @beta
+     */
+    width?: EffectValue;
+    /** Of a `cone` and an `arc`: how wide it opens, in radians @beta */
+    angle?: EffectValue;
     /** Who an effect with a radius applies to. Follows from the kind of effect when left out */
     affects?: 'enemies' | 'allies' | 'all';
+    /**
+     * Only hits what this says of it (`UnitCondition`: a buff or none, health under or over a share, a hero, tags, enemy
+     * or ally of the caster), or code (`UnitConditionCheck`, asked with the target): `{ healthBelow: 0.5, notTags:
+     * ['mechanical'] }`. Of an effect with an area, asked of each in it; of one without, of its target
+     *
+     * @beta
+     */
+    where?: UnitCondition | UnitConditionCheck;
+    /**
+     * Of what its area reaches, the order it goes to them in (`TargetOrder`), or a comparison: the first `limit` of it are
+     * hit. The nearest to the middle of its area (where it landed, or the caster for a cone, a line and an arc) when left
+     * out with a `limit`
+     *
+     * @beta
+     */
+    sort?: TargetOrder | ((a: Entity, b: Entity) => number);
+    /**
+     * Of what its area reaches, at most this many, the first by `sort`: a number, or one per level. `{ sort:
+     * 'lowestHealthShare', limit: 3 }` heals the three most hurt; `{ sort: 'random', limit: 1 }` strikes one of them.
+     * Chosen before the game has its say (`beforeEffect`): a spell shield on one chosen takes the blow
+     *
+     * @beta
+     */
+    limit?: Scaled;
     /** Applies to the caster, wherever the ability was aimed */
     on?: 'caster';
+    /**
+     * When it happens, in a chain (`EffectMoment`): not now, but as the nearest effect before it in its list that
+     * comes to that moment gets there: `hit` a missile's every hit, `arrived` a pull's target arriving, `landed` a
+     * dash's end, `end` a missile's or zone's end. `[missile, { type: 'damage', when: 'hit' }]` is `[{ ...missile, effects: [damage] }]`:
+     * what waits goes into what it waits on (`lowerChain`), so one waiting on what waits itself happens later still.
+     * One with nothing before it to wait on never happens (`checkRules` says so)
+     *
+     * @beta
+     */
+    when?: EffectMoment;
+    /**
+     * Goes off from units of the caster's of a type (`ProxyOrigin`), not from the caster: once from each it picks, that one
+     * the context's `origin` (a missile starts there, an area never takes it in, the strike says it came from there), the
+     * caster still who does it (whose the damage, the kills and the scaling are). Zed's shadows, Orianna's ball, Syndra's
+     * spheres, Azir's soldiers. Nothing where none is picked, unless `caster` says otherwise
+     *
+     * @beta
+     */
+    origin?: ProxyOrigin;
 }
 /**
- * The fields the engine's effects read, by name: each type of effect has those of them it reads (`EffectTypes`, a
- * `Pick` of these), and a game's own type picks of them or says its own
+ * Units of the caster's an effect goes off from (`EffectCommon.origin`): proxies, a shadow, a ball, a sphere, a soldier.
+ * The caster's are those it put down (`madeBy`, a `spawn` of the ground objects pack), or, of one nobody says put down,
+ * those of its owner. In code, a game's effect runs its effects from a unit of its own choice (`EffectContext.origin`,
+ * `runEffects`), or asks which a proxy origin picks (`proxiesOf`)
  *
  * @beta
  */
-export interface EffectFields {
-    /** For `teleport`: where to, however far: the caster's side's home (`homeOf`), where it was aimed, or by its target */
-    to?: 'home' | 'point' | 'target';
-    amount?: Scaled;
-    /** Id of the buff to put on the targets */
-    buff?: string;
-    /** Unit type, for effects that bring one into the world */
-    unit?: string;
-    /** For `onHit`: only while the attacker carries this buff */
-    whileBuff?: string;
-    /** For `charged`: what happens when the ability is not charged */
-    otherwise?: EffectDef[];
-    /** For missiles: buildings and trees in its way stop it, without anything happening to them */
-    blocked?: boolean;
-    /** For `onKill`: only when it was an attack of the carrier that killed */
-    attack?: boolean;
-    /** For `refresh`: the ability that is ready again, when it is not the one the effect belongs to */
-    ability?: string;
-    /** For `dash`: how high the caster rises on the way, which makes it a leap. For whoever draws it */
-    leap?: number;
+export interface ProxyOrigin {
+    /** The unit type of the caster's it goes off from */
+    proxy: string;
     /**
-     * For a leap: how much higher than where it takes off the ground on its way may stand. What stands higher
-     * is a wall to it: it comes down in front of it. Over anything when left out
+     * Which of them: the one `nearest` to where it was aimed (when left out), `all` of them (each in the order they came
+     * into the world), the `newest` or the `oldest`
      */
-    climb?: number;
-    /** Seconds the buff lasts, when that is different from its usual duration */
-    duration?: Scaled;
+    pick?: 'nearest' | 'all' | 'newest' | 'oldest';
     /**
-     * What the stats of the caster add to the amount: `{ abilityPower: 0.6 }` adds 60% of its ability power.
-     * `level` is for every level of the hero past the first
+     * From the caster as well (`true`: Zed and his shadows, each a Razor Shuriken), or from the caster where none is
+     * picked (`otherwise`: Orianna's ball, with her when it is nowhere). From the picked alone when left out
      */
-    scaling?: Scaling;
-    /** For damage. Magic when left out */
-    damageType?: DamageType;
-    /** For damage: how what it kills dies, for the screen, over the ability's own `how` */
-    how?: string;
-    /** For missiles: seconds they take shape where they were cast before they set off. The caster is free to go */
-    delay?: Scaled;
-    /** For missiles: how fast they travel, in units per second, and how far */
-    speed?: number;
-    distance?: Scaled;
-    /** For missiles: how many are sent, spread over an angle in radians. What one of them hit the others pass by */
-    count?: Scaled;
-    spread?: number;
-    /** For missiles: flies after the unit the ability was cast on, and only hits that one */
-    homing?: boolean;
-    /** For missiles: flies to the spot the ability was aimed at and stops there, `distance` away at the most */
-    toPoint?: boolean;
-    /** For missiles: how far the team of the caster sees around it */
-    sight?: number;
+    caster?: boolean | 'otherwise';
+    /** Only those within this far of the caster: Azir's soldiers within his reach. Any distance when left out */
+    range?: number;
+    /** Only those within this far of where it was aimed: the soldiers near what Azir attacks. Any distance when left out */
+    near?: number;
     /**
-     * What happens to what is hit. For missiles: everything they pass through. For `onHit`: the target of an attack.
-     * For `dash`: what is around where it ends. For `after`: what is there when the time is up. For `zone`: what is inside, over and over
+     * Where it lands: where it was aimed (`aim`, when left out), or where each it goes off from stands (`proxy`: Orianna's
+     * Dissonance around the ball, Zed's Shadow Slash around each shadow)
      */
-    effects?: EffectDef[];
-    /** For missiles that were not stopped, and for zones: what happens where and when they end */
-    onEnd?: EffectDef[];
+    at?: 'aim' | 'proxy';
+    /** The one it goes off from is its target too: a swap with it (Zed's Living Shadow cast again), a dash to it */
+    target?: boolean;
+}
+/**
+ * The shapes of ground an effect may cover (`EffectCommon.shape`)
+ *
+ * @beta
+ */
+export type EffectShape = 'circle' | 'cone' | 'line' | 'rect' | 'ring' | 'arc' | 'cross';
+/**
+ * A resource of a unit's own beside mana (`UnitTypeDef.pools`), in a game with the resources pack (`resourcesPack`):
+ * Akali's energy (`regen`), Tryndamere's fury (gained by attacks, `decay` after `idle`), Rumble's heat (gained by casts,
+ * overheating at a threshold), Yasuo's flow (`moving`), Jhin's ammo (`reload`)
+ *
+ * @beta
+ */
+export interface PoolDef {
+    /** What it is called on the screen: its id when left out */
+    name?: string;
+    /** The colour of its bar, a CSS colour: the client's own when left out */
+    color?: string;
+    /** How much it holds at most */
+    max: number;
+    /** How much it holds as the unit comes into the world: full when left out */
+    start?: number;
+    /** How much comes back each second, always (energy) */
+    regen?: number;
+    /** How much goes each second once nothing has spent or given any for `idle` seconds (fury, heat) */
+    decay?: number;
+    /** Seconds without its being spent or given before it decays: at once when left out */
+    idle?: number;
+    /** How much comes for each cell the unit walks (Yasuo's flow) */
+    moving?: number;
+    /** Seconds after it runs out until it is full again (a reload) */
+    reload?: number;
+    /** Buffs its carrier gets as it fills (`PoolThreshold`): overheated, in the danger zone */
+    thresholds?: PoolThreshold[];
+}
+/**
+ * A buff a unit gets as one of its pools reaches `at` (`PoolDef.thresholds`): kept on while it holds that much or more
+ * (`kept`: Rumble's danger zone), or put on once as it gets there; one that `empties` holds the pool still while it
+ * lasts, and empties it as it ends (Rumble's overheat)
+ *
+ * @beta
+ */
+export interface PoolThreshold {
+    /** How much the pool holds for it */
+    at: number;
+    /** The buff, in the carrier's own name */
+    buff: string;
+    /** On while the pool holds `at` or more, off below: put on once as it gets there when left out */
+    kept?: boolean;
+    /** The pool stays as it is while the buff lasts, and is empty as it ends (not with `kept`) */
+    empties?: boolean;
+}
+/**
+ * What an `if` asks of a unit, its caster or its target (`EffectFields.caster`, `EffectFields.target`): each part it
+ * says must hold. Or code (`UnitConditionCheck`)
+ *
+ * @beta
+ */
+export interface UnitCondition {
+    /** It carries this buff */
+    buff?: string;
+    /** It does not carry this buff */
+    noBuff?: string;
+    /** Its health is under this share of its max (0.2: below 20%: an execute) */
+    healthBelow?: number;
+    /** Its health is at or over this share of its max (1: unhurt) */
+    healthAbove?: number;
+    /** It is a hero (true) or not (false) */
+    hero?: boolean;
     /**
-     * For `after`: the name its arrival goes by for whoever draws it and plays its sound, where one ability sets off
-     * several that do not look alike: the last of a barrage. The ability's own when left out
+     * It is a structure, a building (true), or not (false). `{ hero: false, structure: false }` is a creep: any unit
+     * that is neither, a camp's, a lane's, a summon. What a passive that works in every kind of game names
+     *
+     * @beta
+     */
+    structure?: boolean;
+    /** Its type has one of these tags (`UnitTypeDef.tags`) */
+    tags?: string[];
+    /** Its type has none of these tags: `['undead']` for the living */
+    notTags?: string[];
+    /** What it is to the caster: an `enemy` or an `ally` (the caster itself is one) */
+    is?: 'enemy' | 'ally';
+}
+/**
+ * The orders a query and an effect sort what they found in (`WorldQuery.sort`, `EffectCommon.sort`): `nearest` and
+ * `farthest` to its point (by the edge of each), the least or most `health`, the least or most of it as a share of its
+ * max (`lowestHealthShare`: the most hurt), or `random`, drawn from the world's numbers (`world.rng`), so the same every
+ * run. Ties go by who came into the world first
+ *
+ * @beta
+ */
+export type TargetOrder = 'nearest' | 'farthest' | 'lowestHealth' | 'highestHealth' | 'lowestHealthShare' | 'highestHealthShare' | 'random';
+/**
+ * An `if`'s condition in code: whether it holds of the unit (the caster or the target), as the effect lands
+ *
+ * @beta
+ */
+export type UnitConditionCheck = (context: EffectValueContext, unit: Entity) => boolean;
+/**
+ * A ground object's trap, mine or pickup (`UnitTypeDef.trigger`), in a game with the ground objects pack
+ *
+ * @beta
+ */
+export interface GroundTrigger {
+    /**
+     * The ability whose `effects` go off: in the name of whoever put it down (its maker, a `spawn` of the pack's: the
+     * object's own where there is none or it is gone), the one who came its target, the object where they go off from
+     * (`EffectContext.origin`), at the level it was put down at
+     */
+    ability: string;
+    /** How near its edge one comes for it to go off: 1 when left out */
+    radius?: number;
+    /** Who sets it off: `enemies` of its owner (when left out), `allies`, `all`, or its `maker` alone (a soul, a chime) */
+    by?: 'enemies' | 'allies' | 'all' | 'maker';
+    /** Seconds after it is put down before it works (a mine arming): at once when left out */
+    arm?: number;
+    /** Times it goes off before it is gone: once when left out, for ever with 0 */
+    times?: number;
+}
+/**
+ * Something on the ground others use (`UnitTypeDef.use`), in a game with the ground objects pack
+ *
+ * @beta
+ */
+export interface GroundUse {
+    /**
+     * The ability whose `effects` go off as one uses it: in its maker's name (its own where there is none), the one who
+     * uses it the target, the object the `origin`, and the point the next of those put down with it (the other end of a
+     * portal) or the object itself
+     */
+    ability: string;
+    /** Who may use it: `allies` of its owner (when left out), `enemies` or `all` */
+    by?: 'allies' | 'enemies' | 'all';
+    /** How near its edge one comes to use it: 1 when left out */
+    range?: number;
+    /** Times it is used before it is gone: for ever when left out */
+    times?: number;
+}
+/**
+ * The spots a `spawn` of the ground objects pack lays its units on (`EffectFields.line`): `count` of them, ends
+ * included, along the way it was aimed, `length` long around where it landed (or from where it went off from to there,
+ * when left out), or `across` it, a quarter turn round (a wall in front of the caster)
+ *
+ * @beta
+ */
+export interface SpawnLine {
+    /** How many, ends included */
+    count: number;
+    /** How long it is, around where it landed: from where it went off from to there when left out */
+    length?: number;
+    /** It lies across the way it was aimed, a quarter turn round: a wall in front */
+    across?: boolean;
+}
+/**
+ * Which way a `knockback` throws, in a game with the moves pack (`EffectFields.direction`)
+ *
+ * @beta
+ */
+export type KnockbackDirection = 'away' | 'aim' | 'over' | 'towards';
+/**
+ * The moment an effect of a chain waits for (`EffectCommon.when`): a missile's hit (`hit`), a pull's arrival
+ * (`arrived`), a dash's landing (`landed`), a missile's or a zone's end (`end`)
+ *
+ * @beta
+ */
+export type EffectMoment = 'hit' | 'arrived' | 'landed' | 'end';
+/**
+ * What an effect waiting for a moment waits on (`EffectCommon.when`): the types that come to it, and the list of
+ * theirs it goes into
+ *
+ * @beta
+ */
+export declare const EFFECT_MOMENTS: Readonly<Record<EffectMoment, {
+    readonly types: readonly string[];
+    readonly into: 'effects' | 'onEnd';
+}>>;
+/**
+ * The fields the engine's effects read, by name: each type of effect has those of them it reads (`EffectTypes`, a
+ * `Pick` of these), and a game's own type picks of them or says its own
+ *
+ * @beta
+ */
+export interface EffectFields {
+    /**
+     * For `teleport`: where to, however far: the caster's side's home (`homeOf`), where it was aimed, or by its target.
+     * For `dash`, in a game with the moves pack (`movesPack`): `target` rushes to the unit it was cast on, after it as it
+     * moves, to its edge (or `through` it); its `effects` happen to it there
+     */
+    to?: 'home' | 'point' | 'target';
+    /**
+     * For a `dash` to a unit (`to: 'target'`), in a game with the moves pack: it goes on through the unit, this far past
+     * its middle, along the way from where the caster set off (Yasuo's Sweeping Blade); the place is fixed as it sets off
+     *
+     * @beta
+     */
+    through?: number;
+    /**
+     * For `dash` and `knockback`, in a game with the moves pack (`movesPack`): what happens to each enemy of the caster
+     * the one moved meets on its way, once each, in the caster's name, the one met its target and the one moved where they
+     * go off from (`EffectContext.origin`): Lee Sin's Dragon's Rage (who the kicked one flies into is hurt and thrown up),
+     * Rammus's Powerball
+     *
+     * @beta
+     */
+    collide?: EffectDef[];
+    /** For `dash` and `knockback` with `collide`: the one moved stops at the first one it meets @beta */
+    stops?: boolean;
+    /**
+     * For `knockback`, in a game with the moves pack (`movesPack`): which way it throws (`KnockbackDirection`): `away` from
+     * where the effects go off from (the caster, or the context's `origin`: what it always did), `aim` the way the ability
+     * was aimed (Thresh's Flay, Vayne's Condemn, Poppy's charge), `over` the caster to land `distance` beyond it on its
+     * other side (Singed's Fling: give it a `leap`), or `towards` it, to its edge at the most (a yank)
+     *
+     * @beta
+     */
+    direction?: KnockbackDirection;
+    /**
+     * For `attach`, in a game with the moves pack: who is put on whom: the `caster` on the unit it was cast on (Yuumi's
+     * You and Me!, when left out) or that unit on the caster (Kalista's Fate's Call)
+     *
+     * @beta
+     */
+    rider?: 'caster' | 'target';
+    /** For `raiseDead`: the corpses rise as what they were, the caster's (Animate Dead), rather than as its `unit` @beta */
+    as?: 'themselves';
+    /** For `onFatal`: the share of its max health the carrier is left with, rather than dying: all of it when left out @beta */
+    health?: number;
+    /**
+     * For `if`: what must hold of the caster (`UnitCondition`, or code), for `effects` to happen rather than `otherwise`
+     *
+     * @beta
+     */
+    caster?: UnitCondition | UnitConditionCheck;
+    /**
+     * For `if`: what must hold of the target (`UnitCondition`, or code): the unit it was cast on, or each one within its
+     * `radius` or `shape`, where it has one. With no target there, it does not hold
+     *
+     * @beta
+     */
+    target?: UnitCondition | UnitConditionCheck;
+    /**
+     * How much: of damage, healing, mana, a shield (`buff`). A number, one per level, or code asked for each target
+     * (`EffectValue`); with what the caster's stats add (`scaling`) and the formulas of `damage`, `heal` and `buff`
+     * (`byMaxHealth`, `byCurrentHealth`, `byMissingHealth`, `byStacks`, `byDistance`, `targetScaling`) on top
+     */
+    amount?: EffectValue;
+    /** Id of the buff to put on the targets */
+    buff?: string;
+    /** Unit type, for effects that bring one into the world */
+    unit?: string;
+    /** For `spawn`: whose it is: the caster's when left out, or the neutral player's (a soul nobody owns) */
+    owner?: 'neutral';
+    /** For `spawn`: drawn as the target or the caster is (its model, its owner's colour, its size), while it stays what its own type is */
+    looksLike?: 'target' | 'caster';
+    /** For `spawn`: components it starts with, by id, in the form a save keeps them in */
+    data?: Record<string, unknown>;
+    /**
+     * For `spawn`, in a game with the ground objects pack (`groundObjectsPack`): so many along a line (`SpawnLine`),
+     * buildings one to a cell: Anivia's Crystallize (`across`), Taliyah's Weaver's Wall, Yasuo's Wind Wall, Bard's portals
+     * (two: one where he stands, one where he aimed)
+     *
+     * @beta
+     */
+    line?: SpawnLine;
+    /**
+     * For `spawn`, in a game with the ground objects pack: `count` round a circle of `radius` about where it landed, the
+     * first the way it was aimed: Jarvan's Cataclysm
+     *
+     * @beta
+     */
+    ring?: {
+        count: number;
+        radius: number;
+    };
+    /**
+     * For `gain`, in a game with the resources pack (`resourcesPack`): which of the pools (`UnitTypeDef.pools`) of what it
+     * reaches it fills (or empties, with an `amount` under 0)
+     *
+     * @beta
+     */
+    pool?: string;
+    /** For `onHit` and `onKill`: only while the carrier carries this buff */
+    whileBuff?: string;
+    /**
+     * For `onHit`: only every so many of the carrier's attacks that land (while it carries `whileBuff`, where it says),
+     * counted on the carrier and saved with it: Jhin's fourth shot, a third strike. Every attack when left out
+     *
+     * @beta
+     */
+    every?: number;
+    /**
+     * For `onHit`: the attack that sets it off uses up one of `whileBuff`'s stacks, the buff for its last (or one that does
+     * not count them): "the next attack" of Power Fist, Siphoning Strike, Nether Blade, Flurry's two. Used up by the
+     * attack that kills too, after what the kill sets off (`onKill` still sees it)
+     *
+     * @beta
+     */
+    consumes?: boolean;
+    /**
+     * For `onHit`: the slot it takes among what the carrier's attacks set off (its attack modifiers: an orb, a poison, a
+     * frost), from its abilities, items and buffs alike. Of those that share a slot only one goes off, the one of the
+     * highest `priority`; those of different slots, and those of none, all add up (`RuleSettings.combat.attackModifiers`)
+     *
+     * @beta
+     */
+    slot?: string;
+    /**
+     * For `onHit` with a `slot`: which of those sharing it goes off, the highest first (0 when left out); the first of
+     * the carrier's abilities, then items, then buffs among equals
+     *
+     * @beta
+     */
+    priority?: number;
+    /**
+     * For the triggers of a passive (`onHit`, `onKill`, `onCast`, `onDamaged`, `onAbilityHit`, `onLowHealth`): seconds
+     * before it can go off again once it did, kept on the ability's own cooldown (`AbilityState.cooldown`, shown on its
+     * button) for an ability, on the carrier for an item's or a buff's. Every time when left out
+     *
+     * @beta
+     */
+    cooldown?: Scaled;
+    /**
+     * For `onLowHealth`: the part of its max health (0.3: 30%) the carrier's health falls below for it to go off: once
+     * as it falls past it, not again until it is back above
+     *
+     * @beta
+     */
+    below?: number;
+    /**
+     * For `onDamaged`: only for an attack that hits from up close (one with no missile: `AttackDef.projectileSpeed`
+     * left out): Thorns Aura, Spiked Carapace
+     *
+     * @beta
+     */
+    melee?: boolean;
+    /**
+     * For `removeBuff`: how many stacks of `buff` come off: all of it when left out, the buff itself once none is left
+     *
+     * @beta
+     */
+    stacks?: Scaled;
+    /** For `charged`: what happens when the ability is not charged. For `if`: what happens when its conditions do not hold */
+    otherwise?: EffectDef[];
+    /** For missiles: buildings and trees in its way stop it, without anything happening to them */
+    blocked?: boolean;
+    /** For `onKill`: only when it was an attack of the carrier that killed. For `onDamaged`: only when an attack hurt it */
+    attack?: boolean;
+    /**
+     * For `refresh`: the ability that is ready again, when it is not the one the effect belongs to. For `grantAbility`
+     * and `swapAbility`, in a game with the ability changes pack (`abilityChangesPack`): the ability given
+     */
+    ability?: string;
+    /**
+     * For `swapAbility`, in a game with the ability changes pack: the caster's ability that gives way, the one the effect
+     * belongs to when left out
+     *
+     * @beta
+     */
+    from?: string;
+    /**
+     * For `grantAbility`, `swapAbility` and `stealAbility`, in a game with the ability changes pack: casts of it before it
+     * is gone (and what it took the place of is back): one for a stolen one when left out, for ever otherwise
+     *
+     * @beta
+     */
+    uses?: number;
+    /**
+     * For `grantAbility` and `swapAbility`, in a game with the ability changes pack: the level it is given at: the level of
+     * what it takes the place of, or the effect's own, when left out
+     *
+     * @beta
+     */
+    atLevel?: number;
+    /**
+     * For `stealAbility`, in a game with the ability changes pack: which of the target's abilities it takes: its
+     * `ultimate` (when left out), its `first`, or one at `random` (`world.rng`)
+     *
+     * @beta
+     */
+    pick?: 'ultimate' | 'first' | 'random';
+    /** For `dash`: how high the caster rises on the way, which makes it a leap. For whoever draws it */
+    leap?: number;
+    /**
+     * For a leap: how much higher than where it takes off the ground on its way may stand. What stands higher
+     * is a wall to it: it comes down in front of it. Over anything when left out
+     */
+    climb?: number;
+    /** Seconds the buff lasts, when that is different from its usual duration. In code (`EffectValue`), asked for each target */
+    duration?: EffectValue;
+    /**
+     * What the stats of the caster add to the amount: `{ abilityPower: 0.6 }` adds 60% of its ability power.
+     * `level` is for every level of the hero past the first
+     */
+    scaling?: Scaling;
+    /** For damage. Magic when left out */
+    damageType?: DamageType;
+    /** For damage: how what it kills dies, for the screen, over the ability's own `how` */
+    how?: string;
+    /** For missiles: seconds they take shape where they were cast before they set off. The caster is free to go */
+    delay?: Scaled;
+    /** For missiles: how fast they travel, in units per second, and how far */
+    speed?: number;
+    /** For missiles: how far they fly, in cells */
+    distance?: Scaled;
+    /** For missiles: how many are sent, spread over an angle in radians. What one of them hit the others pass by */
+    count?: Scaled;
+    /** For missiles: the angle, in radians, the missiles are spread over */
+    spread?: number;
+    /** For missiles: flies after the unit the ability was cast on, and only hits that one */
+    homing?: boolean;
+    /**
+     * For missiles: flies to the spot the ability was aimed at and stops there, `distance` away at the most. For `pull`:
+     * drags to where the effect landed (a zone's middle, the spot of an `after`) rather than to the caster
+     */
+    toPoint?: boolean;
+    /** For missiles: how far the team of the caster sees around it */
+    sight?: number;
+    /**
+     * What happens to what is hit. For missiles: everything they pass through. For `onHit`: the target of an attack.
+     * For `dash`: what is around where it ends. For `pull`: what was pulled, as it arrives. For `after`: what is there when the time is up. For `zone`: what is inside, over and over
+     */
+    effects?: EffectDef[];
+    /** For missiles that were not stopped, and for zones: what happens where and when they end */
+    onEnd?: EffectDef[];
+    /**
+     * For `after`: the name its arrival goes by for whoever draws it and plays its sound, where one ability sets off
+     * several that do not look alike: the last of a barrage. The ability's own when left out
      */
     impact?: string;
-    /** For missiles: goes on after it hit something. False for the ones that are used up by the first thing in their way */
-    pierce?: boolean;
+    /**
+     * For missiles: goes on after it hit something. False for the ones that are used up by the first thing in their way;
+     * a number for those that go through so many and are used up by the next (1: Lux's Light Binding, two at the most)
+     */
+    pierce?: boolean | number;
+    /**
+     * For missiles that go through what they hit (`pierce`): what part of the amounts each one it went through takes off
+     * the next (0.3: a third less on the second, less again on the third). Read by `damage`, `heal` and `mana` (`share`)
+     *
+     * @beta
+     */
+    falloff?: number;
+    /**
+     * For missiles that come back (`returns`): on the way back they hit what they pass through again, each once more
+     * (Ahri's Orb of Deception); the caster's place is still where it ends
+     *
+     * @beta
+     */
+    hitsOnReturn?: boolean;
+    /**
+     * For missiles: they find their own targets: while one flies with nobody to go after, it turns after the nearest it may
+     * hit within this far of it and flies after that one (Fox-Fire, Dance of Arrows); another, if that one is gone first
+     *
+     * @beta
+     */
+    seek?: number;
+    /**
+     * For missiles: what happens where it meets a wall (ground it cannot cross, a cliff above where it set off, the edge of
+     * the play area, a building or a tree): it stops there, and these go off there, to the last one it hit where there is
+     * one (Bard's Cosmic Binding). For `dash` and `knockback`, in a game with the moves pack (`movesPack`): the one moved
+     * stops at such a wall (what flies meets none), and these go off there in the caster's name, to the one moved
+     * (Vayne's Condemn, Poppy's Heroic Charge)
+     *
+     * @beta
+     */
+    onWall?: EffectDef[];
+    /**
+     * For missiles: what goes off from where it is, the way it flew, once it is done (it hit what used it up, reached
+     * whom it flew after, or came to the end of its way) or is split by the game (`splitMissile`): missiles in it fly on
+     * from there at their own `spread` (Vel'Koz's Plasma Fission: two at a half turn's spread, a quarter either side)
+     *
+     * @beta
+     */
+    split?: EffectDef[];
+    /**
+     * For missiles: turned by their owner as they fly, towards the point the `steer` command gives (`steerMissile`), at most
+     * `rate` radians a second (π when left out): Yuumi's Prowling Projectile, Viktor's storm
+     *
+     * @beta
+     */
+    steer?: {
+        rate?: number;
+    };
+    /**
+     * For `zone`: goes with a unit, the `caster` or the `target`, and faces the way it does; it ends (with its `onEnd`) when
+     * that one dies or leaves the world
+     *
+     * @beta
+     */
+    follow?: 'caster' | 'target';
+    /**
+     * For `zone`: what happens to each who comes into it (its own `radius` or `shape`, as `affects` says), those inside as
+     * it is laid included. Each in it is seen to every round of the world, not four times a second
+     *
+     * @beta
+     */
+    onEnter?: EffectDef[];
+    /** For `zone`: what happens to each who goes out of it, alive @beta */
+    onLeave?: EffectDef[];
+    /**
+     * For `zone`: what happens to each who crosses its edge, in or out, once it is laid (Veigar's Event Horizon, Thresh's
+     * Box): those inside as it is laid have not crossed it
+     *
+     * @beta
+     */
+    edge?: EffectDef[];
+    /**
+     * For missiles: once done (it hit what used it up or what it flew after, came to the end of its way, or came down)
+     * it flies back to the caster, after it wherever it goes, and touches nobody on the way; its `onEnd` happens where
+     * the caster is when it gets there, not where it turned. Gone, with nothing more, if the caster is
+     *
+     * @beta
+     */
+    returns?: boolean;
+    /**
+     * For `pull`: how long the drag takes, from where the target is to where it ends. Its speed is set by it as it
+     * starts: a caster that walks off makes it take longer
+     *
+     * @beta
+     */
+    seconds?: Scaled;
     /**
      * For missiles: thrown, not shot. It goes `height` up in the middle of its way and comes down at its end, `time`
      * seconds after it set off however far that is (`speed` otherwise). It flies over everything, and what is within
@@ -620,7 +1518,91 @@ export interface EffectFields {
     buy?: string;
     /** For `exchange`: how much of `buy` comes for each one of `sell` (0.5: 100 lumber for 50 gold) */
     rate?: number;
+    /**
+     * For `damage`: a part of what the target has lost of its health, added to the amount for each it hits (0.1: a tenth
+     * of its missing health), worked out as it lands
+     *
+     * @beta
+     */
+    byMissingHealth?: Scaled;
+    /**
+     * For `damage`, `heal` and a shield (`buff`): a part of the target's maximum health, added for each it reaches (0.08:
+     * 8% of its max health). Death and Decay, a % health nuke
+     *
+     * @beta
+     */
+    byMaxHealth?: Scaled;
+    /**
+     * For `damage`, `heal` and a shield (`buff`): a part of the health the target has now, added for each it reaches
+     *
+     * @beta
+     */
+    byCurrentHealth?: Scaled;
+    /**
+     * For `damage`, `heal` and a shield (`buff`): `amount` more for each stack of `buff` on the target (`of: 'target'`,
+     * when left out) or the caster: Rend's spears, a passive's marks
+     *
+     * @beta
+     */
+    byStacks?: {
+        buff: string;
+        of?: 'target' | 'caster';
+        amount: Scaled;
+    };
+    /**
+     * For `damage`, `heal` and a shield (`buff`): the whole of it times 1 and `per` for every unit of distance from where
+     * it went off to the target (a missile's way, or from the caster or the `origin`), `most` times at the most: a
+     * javelin that hurts more the farther it flew
+     *
+     * @beta
+     */
+    byDistance?: {
+        per: number;
+        most?: number;
+    };
+    /**
+     * For `damage`, `heal` and a shield (`buff`): parts of the target's stats added (`{ armor: 1 }`: as much as its armor;
+     * `{ health: 0.05 }`: 5% of its max health), as `scaling` adds the caster's
+     *
+     * @beta
+     */
+    targetScaling?: Partial<Record<StatKey, Scaled>>;
+    /**
+     * For `damage`, `heal` and a shield (`buff`) a trigger sets off: a part of the damage that set it off
+     * (`EffectContext.damage`), added (0.2: a fifth of it): Spiked Carapace's returned damage, a heal by what was taken
+     *
+     * @beta
+     */
+    byDamage?: Scaled;
+    /**
+     * For `morph`: the unit type the caster turns into where it stands, a hero's form (`HeroDef.forms`)
+     *
+     * @beta
+     */
+    into?: string;
+    /**
+     * For `morph`: the form lasts until the ability is cast again in it, which turns it back (a toggle); with a
+     * `duration` too, until whichever comes first
+     *
+     * @beta
+     */
+    toggle?: boolean;
+    /**
+     * For `morph`: what turns the form back (`MorphBack`): the ability cast again, its `duration` up, its death. All
+     * three when left out (the ability only with `toggle`); without `ability`, the ability cast again in the form starts
+     * its time over
+     *
+     * @beta
+     */
+    back?: MorphBack[];
 }
+/**
+ * The fields of the formulas an amount of `damage`, `heal` and a shield (`buff`) may add to it, for each target as it
+ * lands (`effectAmount`)
+ *
+ * @beta
+ */
+export type AmountFormula = 'byMissingHealth' | 'byMaxHealth' | 'byCurrentHealth' | 'byStacks' | 'byDistance' | 'targetScaling' | 'byDamage';
 /**
  * The types of effect there are, each with the fields it reads: the engine's, and a game's own, added by declaration
  * merging as it defines them (`declare module '@v12-engine/engine' { interface EffectTypes { arrowStun: { ... } } }`,
@@ -630,107 +1612,399 @@ export interface EffectFields {
  */
 export interface EffectTypes {
     /** Hurts what it reaches: `amount`, with what of the caster's stats adds to it (`scaling`), of a type (magic when left out) */
-    damage: Pick<EffectFields, 'amount' | 'scaling' | 'damageType' | 'how'>;
+    damage: Pick<EffectFields, 'amount' | 'scaling' | 'damageType' | 'how' | AmountFormula>;
     /** Heals what it reaches, more for the caster's heal and shield power */
-    heal: Pick<EffectFields, 'amount' | 'scaling'>;
+    heal: Pick<EffectFields, 'amount' | 'scaling' | AmountFormula>;
     /** Gives mana to what it reaches */
     mana: Pick<EffectFields, 'amount' | 'scaling'>;
-    /** Puts a buff on what it reaches: for its own time or `duration`, one more of it with `stack` */
+    /**
+     * Fills a pool of what it reaches (`pool`, one of `UnitTypeDef.pools`) by `amount` (empties it, under 0), in a game
+     * with the resources pack (`resourcesPack`): allies when it says nothing, the caster with `on: 'caster'` (Tryndamere's
+     * fury from an `onHit`)
+     *
+     * @beta
+     */
+    gain: {
+        pool: string;
+    } & Pick<EffectFields, 'amount' | 'scaling'>;
+    /**
+     * Does something to the grass and bushes where it lands, in a game with the foliage pack (`foliagePack`): sets it
+     * alight (`ignite`, by the caster), puts it out (`extinguish`), ruins it (`ruin`, as `how` says: `cut` when left
+     * out), has it grow back (`regrow`, over `over` seconds) or takes it away (`clear`). Over its `radius` or `shape`,
+     * the cell it landed on when it has neither; on `layer`, every layer of the pack when left out. It acts on cells, not
+     * on what stands there: the fields of whom (`affects`, `kinds`, `tags`, `where`, `limit`...) say nothing to it. A
+     * fire arrow, a mower, a rain spell
+     *
+     * @beta
+     */
+    foliage: {
+        act: 'ignite' | 'extinguish' | 'ruin' | 'regrow' | 'clear';
+        layer?: string;
+        how?: 'cut' | 'crush' | 'scorch';
+        over?: number;
+    };
+    /**
+     * Sets alight what burns where it lands, by the caster (`light`), or puts it out (`putOut`), in a game with the
+     * burning pack (`burningPack`): over its `radius` or `shape`, else the unit it was cast on, else what stands where it
+     * landed. `how`: the kind of burning it sets off (a blight, frost: the look's `burning.how` and the death's), the
+     * thing's own when left out; `seconds`: how long it burns. Of what it finds, what its fields of whom say (`affects`:
+     * `enemies` lights the caster's enemies' alone; `kinds`, `tags`, `layers`, `where`, `sort`, `limit`), everything
+     * that burns, trees among it, when it says none. A fire arrow, a torch, a rain spell
+     *
+     * @beta
+     */
+    burn: {
+        act: 'light' | 'putOut';
+        how?: string;
+        seconds?: number;
+    };
+    /**
+     * Puts a buff on what it reaches: for its own time or `duration`, one more of it with `stack`. With an `amount` (and
+     * `scaling`, the formulas), its shield holds that rather than the buff's own `shield`
+     */
     buff: {
         buff: string;
-    } & Pick<EffectFields, 'duration' | 'stack'>;
+    } & Pick<EffectFields, 'duration' | 'stack' | 'amount' | 'scaling' | AmountFormula>;
     /** Sends a missile: how fast, how far, how many, and what it does to what it passes through and where it ends */
-    missile: Pick<EffectFields, 'speed' | 'distance' | 'count' | 'spread' | 'homing' | 'toPoint' | 'delay' | 'sight' | 'blocked' | 'pierce' | 'arc' | 'bounce' | 'effects' | 'onEnd'>;
+    missile: Pick<EffectFields, 'speed' | 'distance' | 'count' | 'spread' | 'homing' | 'toPoint' | 'delay' | 'sight' | 'blocked' | 'pierce' | 'arc' | 'bounce' | 'effects' | 'onEnd' | 'returns' | 'falloff' | 'hitsOnReturn' | 'seek' | 'onWall' | 'split' | 'steer'>;
     /** A passive's buff on what is around the carrier, kept up by the ability system */
     aura: {
         buff: string;
     };
-    /** Brings a unit of the caster's into the world where it landed, for `duration` seconds or for good */
+    /**
+     * Brings a unit into the world where it landed, the caster's (the neutral player's with `owner`), for `duration` seconds
+     * or for good, with `data` and the looks of the target or the caster. In a game with the ground objects pack
+     * (`groundObjectsPack`): so many along a `line` or round a `ring`, each knowing who put it down (`madeBy`)
+     */
     spawn: {
         unit: string;
-    } & Pick<EffectFields, 'duration'>;
+    } & Pick<EffectFields, 'duration' | 'owner' | 'looksLike' | 'data' | 'line' | 'ring'>;
     /** Puts a buff on the caster for as long as it likes, or takes it off */
     toggle: {
         buff: string;
     };
     /** The caster's team sees the spot for a while */
     reveal: Pick<EffectFields, 'duration'>;
-    /** A passive's: `effects` happen to the target of every attack of the carrier, while it carries `whileBuff` */
-    onHit: Pick<EffectFields, 'whileBuff' | 'effects'>;
+    /**
+     * A passive's (an ability's, an item's or a buff's: `BuffDef.passive`): `effects` happen to the target of every attack
+     * of the carrier that lands, while it carries `whileBuff`; of every `every`th, using up a stack of `whileBuff` with
+     * `consumes`, once in `cooldown` seconds
+     */
+    onHit: Pick<EffectFields, 'whileBuff' | 'effects' | 'every' | 'consumes' | 'cooldown' | 'slot' | 'priority'>;
     /** The caster is ready to strike again at once */
     resetAttack: object;
     /** The caster is elsewhere at once, `distance` away at the most */
     blink: Pick<EffectFields, 'distance'>;
     /** The caster is elsewhere at once, however far (`to`) */
     teleport: Pick<EffectFields, 'to'>;
-    /** The caster rushes to the spot (a leap with `leap`), and `effects` happen around where it ends */
-    dash: Pick<EffectFields, 'distance' | 'leap' | 'climb' | 'speed' | 'effects' | 'buff'>;
-    /** Throws what it reaches `distance` away from the caster */
-    knockback: Pick<EffectFields, 'distance' | 'speed' | 'leap'>;
+    /**
+     * The caster rushes to the spot (a leap with `leap`), and `effects` happen around where it ends. In a game with the
+     * moves pack (`movesPack`): to a unit (`to: 'target'`, after it as it moves, or `through` it), with what happens to who
+     * it meets (`collide`, `stops`) and at a wall (`onWall`)
+     */
+    dash: Pick<EffectFields, 'distance' | 'leap' | 'climb' | 'speed' | 'effects' | 'buff' | 'to' | 'through' | 'collide' | 'stops' | 'onWall'>;
+    /**
+     * Throws what it reaches `distance` away from the caster. In a game with the moves pack (`movesPack`): which way
+     * (`direction`), with what happens to who the thrown one meets (`collide`, `stops`) and at a wall (`onWall`)
+     */
+    knockback: Pick<EffectFields, 'distance' | 'speed' | 'leap' | 'direction' | 'collide' | 'stops' | 'onWall'>;
+    /**
+     * The caster and the unit it was cast on trade places, at once, in a game with the moves pack (`movesPack`). Nothing
+     * where either is a structure, rushing or dragged, or the target cannot be moved (`BuffDef.unstoppable`)
+     *
+     * @beta
+     */
+    swap: object;
+    /**
+     * Sends the unit the effect goes off from (a proxy of the caster's: `EffectCommon.origin`) to where it was aimed, at
+     * `speed` (at once when left out), and its `effects` happen where it arrives, in the caster's name, from it: Orianna's
+     * ball flown to where she aims, Azir's soldiers sent. Nothing where it goes off from the caster
+     *
+     * @beta
+     */
+    sendProxy: Pick<EffectFields, 'speed' | 'effects'>;
+    /**
+     * The caster's team sees each unit it reaches for `duration` seconds (4 when left out), wherever it goes: in the fog,
+     * in a bush, invisible or camouflaged, in a game with the vision pack (`visionPack`). A unit, not a spot (`reveal`):
+     * Rengar's Thrill of the Hunt on the champions about him, Pyke's Death from Below, a Dust of Appearance
+     *
+     * @beta
+     */
+    revealUnit: Pick<EffectFields, 'duration'>;
+    /**
+     * One unit rides another, in a game with the moves pack (`movesPack`): the `rider` (the caster, or the unit it was
+     * cast on) is out of the world (`World.setHidden`: not found, not hit, in nobody's way) and goes where its host goes,
+     * until the host dies or leaves the world, `duration` seconds are up, or whoever cast it casts the ability again (on the
+     * host, or with a point: the ability's cooldown starts then). Then it is back where its host is, and `onEnd` happens in
+     * the rider's name, at the point the recast gave (where it is otherwise), the host its target: Yuumi's You and Me!,
+     * Kalista's Fate's Call (the ally thrown where she aims)
+     *
+     * @beta
+     */
+    attach: Pick<EffectFields, 'rider' | 'duration' | 'onEnd'>;
+    /**
+     * Drags what it reaches to the caster's edge (or to where it landed, `toPoint`) over `seconds`, after the caster as it
+     * moves; `effects` happen to it as it arrives, in the caster's name. While dragged it does nothing of its own (its
+     * orders wait, it casts nothing, uses nothing) and nothing else moves it (a knockback, a dash). Who is rushing
+     * somewhere already, and structures, are not pulled
+     *
+     * @beta
+     */
+    pull: Pick<EffectFields, 'seconds' | 'toPoint' | 'effects'>;
     /** An ability of the caster is ready again: `ability`, or the one the effect belongs to */
     refresh: Pick<EffectFields, 'ability'>;
-    /** A passive's: `effects` happen around whoever the carrier kills (by an attack, with `attack`) */
-    onKill: Pick<EffectFields, 'attack' | 'effects'>;
+    /** A passive's: `effects` happen around whoever the carrier kills (by an attack, with `attack`; while it carries `whileBuff`) */
+    onKill: Pick<EffectFields, 'attack' | 'whileBuff' | 'effects' | 'cooldown'>;
     /** A passive's: `effects` happen to the carrier whenever it casts */
-    onCast: Pick<EffectFields, 'effects'>;
+    onCast: Pick<EffectFields, 'effects' | 'cooldown'>;
+    /**
+     * Gives what it reaches an ability (`ability`) at `atLevel` (the effect's level), for `duration` seconds or `uses`
+     * casts, or for good, in a game with the ability changes pack (`abilityChangesPack`): allies when it says nothing
+     *
+     * @beta
+     */
+    grantAbility: {
+        ability: string;
+    } & Pick<EffectFields, 'atLevel' | 'duration' | 'uses'>;
+    /**
+     * The caster's ability `from` (the one the effect belongs to) gives way to `ability` in its place on the card, at its
+     * level (or `atLevel`), for `duration` seconds or `uses` casts, then back; for good with neither. In a game with the
+     * ability changes pack: a stance, an awakened ability, a weapon of a set
+     *
+     * @beta
+     */
+    swapAbility: {
+        ability: string;
+    } & Pick<EffectFields, 'from' | 'atLevel' | 'duration' | 'uses'>;
+    /**
+     * Takes one of the abilities of the unit it was cast on (`pick`: its ultimate when left out) and puts it in the place
+     * of the one the effect belongs to, at that one's level, for `uses` casts (one when left out) or `duration` seconds,
+     * then back: Sylas's Hijack. In a game with the ability changes pack
+     *
+     * @beta
+     */
+    stealAbility: Pick<EffectFields, 'pick' | 'duration' | 'uses'>;
+    /**
+     * What it reaches becomes the caster's owner's (`World.setOwner`), for `duration` seconds or for good: Charm,
+     * Dominate. Heroes and structures are left as they are. In a game with the ability changes pack
+     *
+     * @beta
+     */
+    convert: Pick<EffectFields, 'duration'>;
+    /**
+     * A passive's: `effects` happen to whoever hurt the carrier (by an attack with `attack`, from up close with `melee`),
+     * in the carrier's name, the damage it took in `EffectContext.damage` (`byDamage`): Thorns Aura, Frost Armor, Spiked
+     * Carapace, Defensive Ball Curl. Not for damage a trigger's effects did: two of them never echo
+     *
+     * @beta
+     */
+    onDamaged: Pick<EffectFields, 'attack' | 'melee' | 'effects' | 'cooldown'>;
+    /**
+     * A passive's: `effects` happen to an enemy an ability of the carrier hurt, each time one does (not its attacks, not
+     * a trigger's effects), the damage in `EffectContext.damage`: Essence Theft, Phenomenal Evil
+     *
+     * @beta
+     */
+    onAbilityHit: Pick<EffectFields, 'effects' | 'cooldown'>;
+    /**
+     * A passive's: `effects` happen to the carrier once its health falls below `below` of its max (as it falls past it),
+     * once in `cooldown` seconds: Mana Barrier
+     *
+     * @beta
+     */
+    onLowHealth: Pick<EffectFields, 'below' | 'effects' | 'cooldown'>;
+    /**
+     * A passive's: instead of dying of a blow or a kill, the carrier is left with `health` of its max (all of it when
+     * left out) and `effects` happen to it, in its name, once in `cooldown` seconds: Reincarnation, Guardian Angel (an
+     * item's), Anivia's Rebirth (a `morph` into the egg), Zilean's Chronoshift (a buff's)
+     *
+     * @beta
+     */
+    onFatal: Pick<EffectFields, 'health' | 'effects' | 'cooldown'>;
+    /**
+     * Takes `buff` off what it reaches: `stacks` of it, or all of it (every one of it there is) when left out. A mark
+     * popped, stacks spent
+     *
+     * @beta
+     */
+    removeBuff: {
+        buff: string;
+    } & Pick<EffectFields, 'stacks'>;
+    /**
+     * Takes off what holds them up from what it reaches (allies when it says nothing): harmful stuns, roots, silences,
+     * disarms, controls, grounds and slows, not a suppression nor being thrown up (`isCleansable`): Remove Scurvy
+     *
+     * @beta
+     */
+    cleanse: object;
     /** `effects` when the ability went off charged, `otherwise` when it did not */
     charged: Pick<EffectFields, 'effects' | 'otherwise'>;
+    /**
+     * `effects` when what it asks holds, `otherwise` when it does not: of the `caster` and of the `target`
+     * (`UnitCondition`: a buff, health below a share, a hero, tags, enemy or ally; or code) and by `chance`. On the unit it
+     * was cast on, or, with a `radius` or `shape`, on each within it (as `affects` says, enemies when it says nothing),
+     * each then the target of what it does. Execute below 20%, Holy Light on the undead, Bash's chance (`conditionHolds`)
+     *
+     * @beta
+     */
+    if: Pick<EffectFields, 'caster' | 'target' | 'effects' | 'otherwise'>;
     /** `effects` happen at the spot, `delay` seconds from now */
     after: Pick<EffectFields, 'delay' | 'effects' | 'impact'>;
     /** For `duration` seconds `effects` happen to what is at the spot, over and over, and `onEnd` at the end */
-    zone: Pick<EffectFields, 'duration' | 'effects' | 'onEnd'>;
+    zone: Pick<EffectFields, 'duration' | 'effects' | 'onEnd' | 'follow' | 'onEnter' | 'onLeave' | 'edge'>;
     /** Finds what is invisible around the spot: the caster's team sees it for `duration` seconds */
     detect: Pick<EffectFields, 'duration'>;
     /** Raises `count` of the corpses around the spot as units of `unit`, for `duration` seconds or for good */
     raiseDead: {
-        unit: string;
-    } & Pick<EffectFields, 'duration' | 'count'>;
+        unit?: string;
+    } & Pick<EffectFields, 'duration' | 'count' | 'as'>;
+    /**
+     * Brings back the corpses of the caster's side around the spot (within `radius`, 6) as what they were, their owners'
+     * again and whole, `count` of them at most (all when left out): Resurrection
+     *
+     * @beta
+     */
+    revive: Pick<EffectFields, 'count'>;
     /**
      * Makes `count` copies of the target, for `duration` seconds: they deal `dealt` of its damage (a third when left out)
      * and take `taken` times what they are dealt (twice when left out)
      */
-    illusion: Pick<EffectFields, 'count' | 'duration'> & {
-        dealt?: number;
-        taken?: number;
+    illusion: Pick<EffectFields, 'count' | 'duration'> & {
+        dealt?: number;
+        taken?: number;
+    };
+    /**
+     * Brings `count` (1) units of `unit` around where it landed, `spread` cells from it (1.5), for `lifetime` seconds (for
+     * good when left out): the caster's summons (`summoned`). With nothing to attack they walk with the caster (`follow`,
+     * true); `aggro` says whom they go for (`mastersAttacker` when left out: whoever hits the caster, then the nearest);
+     * they die with the caster unless `diesWithMaster` is false
+     *
+     * @beta
+     */
+    summon: {
+        unit: string;
+    } & Pick<EffectFields, 'count'> & {
+        lifetime?: Scaled;
+        spread?: number;
+        follow?: boolean;
+        aggro?: 'nearest' | 'mastersAttacker' | 'none';
+        diesWithMaster?: boolean;
+    };
+    /** Takes the buffs off what it reaches, and hurts what is summoned by `amount` */
+    dispel: Pick<EffectFields, 'amount'>;
+    /**
+     * Turns the caster into another unit type where it stands (`into`), a form (`takeForm`): its level, experience,
+     * items, buffs and the share of its health and mana kept, what it was told going on, and the form's abilities
+     * learned at the levels its form says (`HeroDef.forms`). For `duration` seconds, or until cast again (`toggle`), or
+     * both; `back` says what turns it back
+     *
+     * @beta
+     */
+    morph: {
+        into: string;
+    } & Pick<EffectFields, 'duration' | 'toggle' | 'back'>;
+    /**
+     * Trades `amount` of a resource of the caster's owner (`sell`) for another (`buy`), `rate` of it for each one sold:
+     * a marketplace's (`presetMarket`, `exchange` in code). Nothing of it with less than `amount` to sell
+     */
+    exchange: {
+        sell: string;
+        buy: string;
+        rate: number;
+        amount: Scaled;
+    };
+    /**
+     * A tome's, in a game with the tomes pack (`tomesPack`): what it reaches gains `gain` for good (a point of strength),
+     * a hero `xp` experience and `levels` levels
+     */
+    tome: {
+        gain?: StatChange;
+        xp?: number;
+        levels?: number;
+    };
+    /**
+     * Mana burn, in a game with its pack (`manaBurnPack`): takes `amount` of the mana of what it reaches, and hurts it by
+     * as much as it took, times `ratio` (1 when left out), magic damage unless `damageType` says
+     */
+    manaBurn: Pick<EffectFields, 'amount' | 'scaling' | 'damageType'> & {
+        ratio?: number;
+    };
+    /**
+     * A town portal, in a game with the portals pack (`portalsPack`): the caster and as many as `count` (12 when left out)
+     * of its own units within `radius` (7) of it are at once at its side's home nearest where it was aimed (`homeOf`)
+     */
+    townPortal: Pick<EffectFields, 'count'>;
+    /**
+     * A passive's, in a game with the default items (`defaultItemsPack`): keeps `buff` on the allies within `radius` of
+     * the carrier (itself too) while the carrier does not carry `spent`: Dawnmender's ward, whose `onFatal` spends it
+     * (`wardSpent`)
+     *
+     * @beta
+     */
+    allyWard: {
+        buff: string;
+        spent: string;
+    };
+    /**
+     * Of a ward's trigger (`allyWard`), on the ally it saved: puts `spent` on whoever gave the ward for `duration`
+     * seconds and takes the ward (`buff`) off everyone it gave it to: one save a while, for all of them
+     *
+     * @beta
+     */
+    wardSpent: {
+        buff: string;
+        spent: string;
+    } & Pick<EffectFields, 'duration'>;
+    /**
+     * The caster's abilities are ready again: the ones it learns (`HeroDef.learns`), not its ultimate unless `ultimate`,
+     * not what its items do. Nightfang's kill. In a game with the default items
+     *
+     * @beta
+     */
+    refreshAbilities: {
+        ultimate?: boolean;
     };
-    /** Takes the buffs off what it reaches, and hurts what is summoned by `amount` */
-    dispel: Pick<EffectFields, 'amount'>;
     /**
-     * Trades `amount` of a resource of the caster's owner (`sell`) for another (`buy`), `rate` of it for each one sold:
-     * a marketplace's (`presetMarket`, `exchange` in code). Nothing of it with less than `amount` to sell
+     * A passive's: the caster's ability `spell` (by id, a hero spell's: `reap`) cools down `part` faster (0.5: half
+     * again). Nothing for a caster without it. In a game with the default items
+     *
+     * @beta
      */
-    exchange: {
-        sell: string;
-        buy: string;
-        rate: number;
-        amount: Scaled;
+    quicken: {
+        spell: string;
+        part: number;
     };
     /**
-     * A tome's, in a game with the tomes pack (`withTomes`): what it reaches gains `gain` for good (a point of strength),
-     * a hero `xp` experience and `levels` levels
+     * A passive's: `buff` on the carrier while it is out of fights, neither hurt nor attacking for `after` seconds (5
+     * when left out): Shadow Cowl's, Wanderer's Boots' speed. In a game with the default items
+     *
+     * @beta
      */
-    tome: {
-        gain?: StatChange;
-        xp?: number;
-        levels?: number;
+    outOfFights: {
+        buff: string;
+        after?: number;
     };
     /**
-     * Mana burn, in a game with its pack (`withManaBurn`): takes `amount` of the mana of what it reaches, and hurts it by
-     * as much as it took, times `ratio` (1 when left out), magic damage unless `damageType` says
+     * Gives the caster's owner `amount` of the game's currency: a kill near the Ring of the Old King. In a game with the
+     * default items
+     *
+     * @beta
      */
-    manaBurn: Pick<EffectFields, 'amount' | 'scaling' | 'damageType'> & {
-        ratio?: number;
-    };
+    reward: Pick<EffectFields, 'amount'>;
     /**
-     * A town portal, in a game with the portals pack (`withPortals`): the caster and as many as `count` (12 when left out)
-     * of its own units within `radius` (7) of it are at once at its side's home nearest where it was aimed (`homeOf`)
+     * A passive's: a `unit` of the carrier's at its side at night, its summon (`summoned`), gone by day: Wolfhide Charm.
+     * In a game with the default items
+     *
+     * @beta
      */
-    townPortal: Pick<EffectFields, 'count'>;
+    nightCompanion: {
+        unit: string;
+    };
 }
 /**
  * One thing an ability does: its `type`, which picks the handler and says which fields it has (`EffectTypes`)
  *
- * @beta
+ * @public
  */
 export type EffectDef = {
     [K in keyof EffectTypes]: {
@@ -753,6 +2027,16 @@ export type AnyEffect = {
  * @beta
  */
 export declare const anyEffect: (effect: EffectDef) => AnyEffect;
+/**
+ * A list of effects as it runs (`EffectCommon.when`): every effect that waits for a moment taken out of the list and
+ * put at the end of the list of the nearest one before it that comes to that moment (a missile's `effects` for `hit`,
+ * its `onEnd` for `end`), copied; what waits on what waits itself goes in there. The list itself when nothing in it
+ * waits, so the nested shape (`{ type: 'missile', effects: [...] }`) and a chain are one thing by the time they run.
+ * One with nothing to wait on is dropped, and `orphan` told of it by its index in the list
+ *
+ * @beta
+ */
+export declare function lowerChain(effects: readonly EffectDef[], orphan?: (index: number, effect: EffectDef) => void): EffectDef[];
 /**
  * An effect of one type
  *
@@ -779,10 +2063,41 @@ export type AimShape = {
     shape: 'cone';
     length: number;
     angle: number;
+}
+/** A ring at the spot: what is `radius` away and up to `width` closer, not what is in the middle */
+ | {
+    shape: 'ring';
+    radius: number;
+    width: number;
+}
+/** A stretch of a ring around the caster, `radius` away, `angle` wide (radians) and `width` thick, its middle the way it is aimed */
+ | {
+    shape: 'arc';
+    radius: number;
+    angle: number;
+    width: number;
+}
+/** A rectangle around the spot, `length` long the way it is aimed and `width` out on either side */
+ | {
+    shape: 'rect';
+    length: number;
+    width: number;
+}
+/** An X at the spot: two bars `length` long and `width` out on either side, crossing square, each turned an eighth from the way it is aimed */
+ | {
+    shape: 'cross';
+    length: number;
+    width: number;
 };
-/** @beta */
+/**
+ * The definition of an ability: how it is aimed, what it costs and the effects it has
+ *
+ * @public
+ */
 export interface AbilityDef {
+    /** The ability's id, shared by every game: give it a prefix of the game's */
     id: string;
+    /** What the player sees the ability called */
     name: string;
     /**
      * How what its damage kills dies, for the screen (`'burnt'`, `'frozen'`, `'blasted'`): the death's `how`, which the
@@ -803,7 +2118,7 @@ export interface AbilityDef {
     /**
      * What it does, in words: a template with values in braces, worked out for the caster as it is now ("Deals {damage}
      * magic damage" shows "Deals 80 (50 + 60% ability power) magic damage"). The values are its own (`values`), or found
-     * in its effects: `damage`, `heal`, `shield`, `amount`, `duration`, `radius`, `range`, `cooldown`, `charges`, `refill`,
+     * in its effects: `damage`, `heal`, `shield`, `amount`, `duration`, `radius`, `chance` (in percent), `range`, `cooldown`, `charges`, `refill`,
      * `mana`, `count`, `distance` (see `abilityValues`)
      */
     description?: string;
@@ -811,10 +2126,13 @@ export interface AbilityDef {
     values?: Record<string, AbilityValueDef>;
     /** What it does, said in code instead of `description`: words with `{values}` in them, or words and values already put together */
     describe?: (context: AbilityTextContext) => string | TextSegment[];
+    /** The key that casts it from the command card */
     hotkey?: string;
     /**
      * none: happens at once. unit, point: needs a target, and the caster walks into range of it.
-     * direction: goes off from where the caster stands, towards where it was aimed. passive: always on, cannot be cast
+     * direction: goes off from where the caster stands, towards where it was aimed. vector: two points, where it starts
+     * (walked into range of, its effects' `origin`) and the way it goes from there (their `point`): Death Ray, Seismic
+     * Shove. passive: always on, cannot be cast. Or a game's own (`defineTargeting`, `Rules.targetings`)
      */
     target: AbilityTarget;
     /** What may be targeted, for abilities cast on a unit */
@@ -824,11 +2142,39 @@ export interface AbilityDef {
         self?: boolean;
         kinds?: EntityKind[];
         layers?: Layer[];
+        /** True: heroes alone; false: anything but a hero (a creep, a minion, a building: Reap). Heroes or not when left out */
         heroes?: boolean;
+        /** Only what has one of these tags of its type (`UnitTypeDef.tags`): Death Coil on the undead @beta */
+        tags?: string[];
     };
+    /** Mana it costs per cast, by level */
     manaCost?: Scaled;
     /** Health it costs, as a part of all the caster can have. It cannot be cast with less than that left */
     healthCost?: Scaled;
+    /**
+     * What it costs of the caster's pools (`UnitTypeDef.pools`), by pool, in a game with the resources pack
+     * (`resourcesPack`): it is not ready with less, and pays as it goes off (Akali's energy, a shot of ammo)
+     *
+     * @beta
+     */
+    cost?: Record<string, Scaled>;
+    /**
+     * What it gives the caster's pools as it goes off, by pool, in a game with the resources pack: Rumble's heat, a
+     * fury's spender's opposite
+     *
+     * @beta
+     */
+    gain?: Record<string, Scaled>;
+    /**
+     * Its costs (its mana and `cost`) grow with the stacks of a buff of the caster's, in a game with the resources pack:
+     * times one and `per` for each stack (Kassadin's Riftwalk: `per: 1`, twice with one stack, three times with two)
+     *
+     * @beta
+     */
+    costGrowth?: {
+        buff: string;
+        per: number;
+    };
     /** Seconds before it can be used again */
     cooldown?: Scaled;
     /**
@@ -840,6 +2186,13 @@ export interface AbilityDef {
         count: Scaled;
         refill: Scaled;
     };
+    /**
+     * It may be cast again for a while after it is cast (`AbilityRecast`): Ahri's Spirit Rush thrice, Lee Sin's second
+     * Sonic Wave to the one the first marked, Lux's Lucent Singularity set off
+     *
+     * @beta
+     */
+    recast?: AbilityRecast;
     /** How far away the target may be */
     range?: Scaled;
     /** The target may be as far away as the caster's attacks reach, and `range` farther */
@@ -851,8 +2204,14 @@ export interface AbilityDef {
     tags?: string[];
     /** Levels a hero can put into it. 3 when left out */
     maxLevel?: number;
-    /** Hero level needed for the first level of the ability. Ultimates ask for 6 */
+    /** Hero level needed for the first level of the ability. 1 when left out, 6 for an `ultimate` */
     requiresLevel?: number;
+    /**
+     * A hero's ultimate: first learned at level 6 (unless `requiresLevel` says otherwise), what the AI uses on a crowd
+     * only (as it does what asks for a level), and what a game's own code can tell apart (what a possession of another
+     * hero leaves the hero's own: `keeps`)
+     */
+    ultimate?: boolean;
     /** Hero levels between two levels of the ability. 2 when left out */
     levelStep?: number;
     /**
@@ -874,6 +2233,23 @@ export interface AbilityDef {
         shape: 'cone';
         length: Scaled;
         angle: number;
+    } | {
+        shape: 'ring';
+        radius: Scaled;
+        width: Scaled;
+    } | {
+        shape: 'arc';
+        radius: Scaled;
+        angle: number;
+        width: Scaled;
+    } | {
+        shape: 'rect';
+        length: Scaled;
+        width: Scaled;
+    } | {
+        shape: 'cross';
+        length: Scaled;
+        width: Scaled;
     };
     /** Units use it on their own when they have nothing else to do. The player can switch this off */
     autocast?: boolean;
@@ -882,6 +2258,7 @@ export interface AbilityDef {
      * `charged` effects do their other thing, and casting it takes the buff away
      */
     charge?: string;
+    /** What it does, one effect after the other, when it is cast */
     effects: EffectDef[];
     /** What an ability that is cast does all the time besides, once it is learned: buffs, auras, `onHit` */
     passive?: EffectDef[];
@@ -901,6 +2278,7 @@ export interface AbilityDef {
     ai?: (view: AbilityAiView, caster: EntityState, level: number) => {
         point: Vec2;
         target?: number;
+        to?: Vec2;
     } | null | undefined;
     /** How far away the target may be, in code: the range on high ground, say. `range` is what the screen shows */
     rangeOf?: (world: World, caster: Entity, level: number) => number;
@@ -920,7 +2298,70 @@ export interface AbilityDef {
         finished?: EffectDef[];
         /** Broken off when the caster is hurt, as a recall is: any damage, from anyone */
         breaksOnDamage?: boolean;
+        /**
+         * A tether: broken off (`interrupted`) as the unit it was cast on gets farther than this from the caster's edge,
+         * dies or hides: Siphon Mana, Life Drain, Morgana's Soul Shackles
+         *
+         * @beta
+         */
+        leash?: number;
+        /**
+         * Aimed as it goes: where it goes off at (`point`) follows the player's `aim` commands, in a game with the holds
+         * pack (`holdsPack`): Vel'Koz's ray, Jhin's Curtain Call, Starfall's sweep. The caster turns to it
+         *
+         * @beta
+         */
+        aimed?: boolean;
+        /**
+         * Kept up as the caster walks, in a game with the holds pack (`holdsPack`): not an order the caster stands in, so
+         * it may be told to go elsewhere while it lasts; broken off by a stun, a silence, its death
+         *
+         * @beta
+         */
+        walks?: boolean;
+    };
+    /**
+     * What it may be made into for good, chosen once (`upgradeAbility`, the `upgradeAbility` command), in a game with the
+     * ability changes pack (`abilityChangesPack`): Viktor's augments, Engineering Upgrade's better abilities. The new one
+     * takes its place at its level and cooldown
+     *
+     * @beta
+     */
+    upgrades?: string[];
+    /**
+     * Held to charge and let go, in a game with the holds pack (`holdsPack`): the cast starts the hold where the caster
+     * stands, going on with what it was doing, and the `release` command (the key let go, or a click) sets it off, as
+     * full as it was held (`HoldDef`): farther, harder, or a tap's other effects. Paid as it is let go
+     *
+     * @beta
+     */
+    hold?: HoldDef;
+}
+/**
+ * How an ability is held to charge and let go (`AbilityDef.hold`), in a game with the holds pack: Varus's Piercing Arrow,
+ * Xerath's Arcanopulse, Pyke's Bone Skewer, Viego's Spectral Maw
+ *
+ * @beta
+ */
+export interface HoldDef {
+    /** Seconds held for it to be full */
+    max: number;
+    /** Seconds held after which it goes off by itself, where it was last aimed: as it is full when left out */
+    upTo?: number;
+    /** How far it reaches let go at once (`from`) and full (`to`): where it is let go at is brought that near */
+    range?: {
+        from: number;
+        to: number;
     };
+    /** What its amounts come to full, times what they are let go at once (1.5: half again); what comes between is between */
+    scale?: number;
+    /** Let go before `under` seconds: these effects in place of its own (Pyke's stab, not his hook) */
+    tap?: {
+        under: number;
+        effects: EffectDef[];
+    };
+    /** A buff on the caster while it holds: a slow */
+    buff?: string;
 }
 /**
  * What the stats of the caster add to an amount. `level` is for every level of a hero past the first,
@@ -932,21 +2373,31 @@ export type Scaling = Partial<Record<StatKey | 'level' | 'bonusAttackDamage', Sc
 /**
  * Something lasting on a unit that changes what it can do
  *
- * @beta
+ * @public
  */
 export interface BuffDef extends ScaledStatChange {
+    /** The buff's id, shared by every game: give it a prefix of the game's */
     id: string;
+    /** What the player sees the buff called */
     name: string;
     /**
      * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):
      * what it is drawn, heard and pictured as where the game gives it no look of its own
      */
     basedOn?: string;
+    /** What the buff does, in words, shown when the pointer is over it */
     description?: string;
     /** Seconds. Lasts until removed when left out */
     duration?: number;
     /** A debuff: by default it goes on enemies */
     harmful?: boolean;
+    /**
+     * Free words to find it by and to sort it with (`fire`, `slow`, `anti-heal`), as abilities and units have: what a
+     * search matches, what a game's code asks (`buffsTagged`)
+     *
+     * @beta
+     */
+    tags?: string[];
     /** The unit cannot do anything. A function says so for one carrier, one moment */
     stun?: boolean | BuffCheck;
     /** Thrown into the air for as long as it lasts. Comes with a stun, the rest is for the eye */
@@ -979,6 +2430,29 @@ export interface BuffDef extends ScaledStatChange {
     disarm?: boolean | BuffCheck;
     /** Who carries it is immune to spells while it lasts, as an avatar is (see `UnitTypeDef.spellImmune`). Or while its function says */
     spellImmune?: boolean | BuffCheck;
+    /**
+     * Who carries it takes no damage while it lasts, and no enemy's ability may be cast on it (Divine Shield, Kayle's
+     * Intervention, Zhonya's stasis with a `stun`). Effects other than damage still reach it. Or while its function says
+     *
+     * @beta
+     */
+    invulnerable?: boolean | BuffCheck;
+    /**
+     * Who carries it is out of reach while it lasts (Fizz's Playful, Zed's Death Mark dash, Vlad's pool): no ability may be
+     * cast on it but by itself, no attack is aimed at it nor lands, and no effect of anyone else's reaches it (an area,
+     * a missile, a chain), allies' too; it is still seen and still in the way. Or while its function says
+     *
+     * @beta
+     */
+    untargetable?: boolean | BuffCheck;
+    /**
+     * The least health damage leaves its carrier with while it lasts (Tryndamere's Undying Rage at 1, Kindred's Lamb's
+     * Respite at a tenth of its max): a number, one per level, or code with the carrier. It is hurt down to it, never past
+     * it. The highest of what it carries counts
+     *
+     * @beta
+     */
+    minHealth?: Scaled | ((world: World, carrier: Entity, instance: BuffInstance) => number);
     /**
      * Whether a dispel takes it off (see the effect `dispel`). Yes when left out: no for what nothing should end early.
      * Decided in code for each dispel: by who dispels it (`by`), its level
@@ -1013,7 +2487,153 @@ export interface BuffDef extends ScaledStatChange {
     };
     /** Code run when it comes off, run out (`expired`) or taken off. Not for the buffs of something that dies */
     onRemove?: (world: World, carrier: Entity, instance: BuffInstance, expired: boolean) => void;
+    /**
+     * It takes its carrier's orders while it lasts: what it was told waits (a channel is broken off), the player's and
+     * anyone's new orders are refused, and it goes on with what it was told after, as from a stun. `fear`: it walks away
+     * from who put it on; `charm`: it walks to them; `taunt`: it attacks them (walks to them where it cannot). Code
+     * (`BuffControl`) steers it itself every tick. The last of them it carries is the one it does
+     *
+     * @beta
+     */
+    control?: ControlKind | BuffControl;
+    /**
+     * Held like a stun, and more: tenacity does not cut it short and a `cleanse` does not take it off (Malzahar's
+     * Nether Grasp, Skarner's Impale)
+     *
+     * @beta
+     */
+    suppress?: boolean;
+    /**
+     * Its carrier cannot rush or jump anywhere of its own: an ability of its with a `dash` or a `blink` is refused
+     * ("Grounded"), and such an effect of its does nothing (Singed's Mega Adhesive). Not `grounds`, which brings a flyer down
+     *
+     * @beta
+     */
+    grounded?: boolean;
+    /**
+     * What it takes of its carrier each second while it lasts, by pool (`UnitTypeDef.pools`) or `mana`, in a game with
+     * the resources pack (`resourcesPack`): taken off when there is not enough for the next second's (Immolation, a
+     * Glacial Storm kept up)
+     *
+     * @beta
+     */
+    drain?: Record<string, number>;
+    /**
+     * Nothing that holds a unit up does anything to its carrier while it lasts: harmful stuns, roots, silences, disarms,
+     * controls, suppressions and grounds on it hold nothing, new ones do not take, and it is neither thrown nor pulled
+     * (Olaf's Ragnarok, Malphite's Unstoppable Force). Slows still slow
+     *
+     * @beta
+     */
+    unstoppable?: boolean;
+    /**
+     * Its carrier is seen by the team of whoever put it on while it lasts, wherever it stands: in the fog, in a bush,
+     * invisible or camouflaged (the fog lit where it stands, as for what a `detect` found), in a game with the vision
+     * pack (`visionPack`): Kindred's mark, a hunter's quarry
+     *
+     * @beta
+     */
+    revealed?: boolean;
+    /**
+     * Its carrier is camouflaged while it lasts, in a game with the vision pack (`visionPack`): its enemies see it only
+     * from within this far of it (a unit of theirs that near), unless something finds it (`trueSight`, `detect`,
+     * `revealUnit`) or it attacked them a moment ago: Pyke's Ghostwater Dive, Rengar's Thrill of the Hunt, Viego's mist.
+     * A function says how far for one carrier, one moment
+     *
+     * @beta
+     */
+    camouflage?: number | ((world: World, carrier: Entity, instance: BuffInstance) => number);
+    /**
+     * Its carrier finds what of its enemies is invisible or camouflaged within this far of it, for its team, while it
+     * lasts, in a game with the vision pack (`visionPack`): an Oracle Lens, a Magic Sentry on a tower
+     *
+     * @beta
+     */
+    trueSight?: number;
+    /**
+     * Its carrier walks through other units, and they through it, while it lasts: neither steers round nor pushes the
+     * other (a Ghost, a Phantom Stride). Walls, cliffs, buildings and trees still stop it. A function says so for one
+     * carrier, one moment
+     *
+     * @beta
+     */
+    phasing?: boolean | BuffCheck;
+    /**
+     * Its carrier's blows from up close strike the enemies around their target too, a part of their damage each, as an
+     * attack's own cleave (`AttackDef.cleave`): the larger part counts
+     *
+     * @beta
+     */
+    cleave?: Cleave;
+    /**
+     * The healing past full health that its carrier gives (`given`, when left out) or gets (`taken`) becomes a shield on
+     * whoever was healed: the buff `buff` (its own time, and a shield of its own where it says), holding `part` of what
+     * spilled over (all of it when left out), up to `most` of the healed one's max health (a third when left out)
+     *
+     * @beta
+     */
+    overheal?: {
+        buff: string;
+        part?: Scaled;
+        most?: number;
+        of?: 'given' | 'taken';
+    };
+    /**
+     * Its carrier pays for its abilities with health, not mana, while it carries it: this much health for each point of
+     * mana they cost (1 for `true`). It cannot cast with no more health than that; items still cost nothing
+     *
+     * @beta
+     */
+    paysWithHealth?: boolean | number;
+    /**
+     * What its carrier's attacks, hurts, casts and kills set off while it carries it, as an ability's passive does
+     * (`onHit`, `onKill`, `onCast`, `onDamaged`, `onAbilityHit`, `onLowHealth`), in the carrier's name: Frost Armor's
+     * slow on who strikes it, a Thorns Aura's buff, the empowered next attack of a buff a cast put on
+     *
+     * @beta
+     */
+    passive?: EffectDef[];
+    /**
+     * What takes it off before its time: `damage` (its carrier hurt: Sleep), `attack` (an attack of its carrier lands,
+     * after what the attack sets off: Wind Walk), `cast` (its carrier casts an ability other than the one that put it on)
+     *
+     * @beta
+     */
+    breaksOn?: BuffBreak[];
+    /**
+     * What happens where its carrier dies carrying it, in the name of who put it on (while they live): Doom's demon, Black
+     * Arrow's skeleton, a mark that spreads
+     *
+     * @beta
+     */
+    onCarrierDeath?: EffectDef[];
+    /**
+     * What happens to its carrier as an effect (`stack`) brings it to `maxStacks`, in the name of who put it on: Gravity
+     * Field's stun on the third, Hemorrhage's might on the fifth. A `removeBuff` among them spends the stacks
+     *
+     * @beta
+     */
+    onMaxStacks?: EffectDef[];
 }
+/**
+ * The orders a buff gives its carrier (`BuffDef.control`): away from who put it on, to them, or at them
+ *
+ * @beta
+ */
+export type ControlKind = 'fear' | 'charm' | 'taunt';
+/**
+ * A buff's own control (`BuffDef.control` in code): run every tick it holds its carrier, in place of the orders it
+ * waits on, to steer it as it likes (with `moveTo`, `engage` and the like). `source` is who put it on, while it is there
+ *
+ * @beta
+ */
+export type BuffControl = (world: World, carrier: Entity, instance: BuffInstance, dt: number, source: Entity | undefined) => void;
+/**
+ * What takes a buff off before its time (`BuffDef.breaksOn`): its carrier hurt, an attack of its landing, a cast of its
+ *
+ * @beta
+ */
+export type BuffBreak = 'damage' | 'attack' | 'cast';
 /** Whether a buff does what it says (stuns, roots) to one carrier, at this moment */
 export type BuffCheck = (world: World, carrier: Entity, instance: BuffInstance) => boolean;
 /** Code a buff runs on its carrier: as it is put on, or every so often */
@@ -1027,14 +2647,55 @@ export interface IncomingBuff {
     source: number;
 }
 /**
- * Where an item is in a shop. The client's tiers, or a game's own (`GameView.shopTiers`)
+ * Where an item is in a shop, and in its build tree: what is used up (`consumable`), what a hero starts with
+ * (`starter`), the parts (`basic`), what they build (`intermediate`), what it all leads to (`legendary`), and what is
+ * found, never sold (`relic`: loot of camps, bosses and quests). The client's tiers, or a game's own
+ * (`GameView.hud.shopTiers`). `epic` is the old word for `intermediate`, still read as it (`itemTier`)
+ *
+ * @beta
+ */
+export type ItemTier = 'consumable' | 'starter' | 'basic' | 'intermediate' | 'legendary' | 'relic' | 'epic' | (string & {});
+/**
+ * How an item's charges come back (`ItemDef.refill`): all of them at a shop of the carrier's side or an ally's
+ * (`shop`), and one every `every` seconds. An item that refills is kept at no charges, waiting for them
+ *
+ * @beta
+ */
+export interface ItemRefill {
+    /** Every charge back while its carrier stands at a shop it may trade with */
+    shop?: boolean;
+    /** Seconds for one charge to come back, wherever it is carried. None when left out */
+    every?: number;
+}
+/**
+ * A tag of items (`ItemDef.tags`), named and given a look: what a shop shows of it and whether it is one of the shop's
+ * filters. A tag no `TagDef` names still works, shown as its own word (`Rules.tags`)
  *
  * @beta
  */
-export type ItemTier = 'consumable' | 'starter' | 'basic' | 'epic' | 'legendary' | (string & {});
-/** @beta */
+export interface TagDef {
+    /** The tag as items say it: `attack`, `lifesteal`, `anti-heal` */
+    id: string;
+    /** What the player sees it called: its id when left out */
+    name?: string;
+    /** A line about it, shown when the pointer is over it */
+    description?: string;
+    /** An icon of its own, by path or by a name of the game's icons */
+    icon?: string;
+    /** The colour it is shown in, as CSS has it (`#e0a030`) */
+    color?: string;
+    /** One of the shop's filters, a chip to pick: not when left out */
+    filter?: boolean;
+}
+/**
+ * The definition of an item: what it costs, what it gives its carrier and how it is used
+ *
+ * @public
+ */
 export interface ItemDef {
+    /** The item's id, shared by every game: give it a prefix of the game's */
     id: string;
+    /** What the player sees the item called */
     name: string;
     /** How good it is, 1 and up (campaign plan GP3): what an item table draws by (`{ level: 3 }`) */
     level?: number;
@@ -1045,7 +2706,9 @@ export interface ItemDef {
      * what it is drawn, heard and pictured as where the game gives it no look of its own
      */
     basedOn?: string;
+    /** What the item does, in words, shown when the pointer is over it */
     description?: string;
+    /** What it costs in a shop, in resources */
     cost: Cost;
     /** Uses before it is gone. Items without charges stay */
     charges?: number;
@@ -1055,8 +2718,52 @@ export interface ItemDef {
     passive?: string;
     /** Items it is made of. Those the buyer carries are used up and taken off the price, which is for all of it */
     from?: string[];
-    /** Where it goes in a shop: consumable, starter, basic, epic, legendary */
+    /**
+     * Where it goes in a shop: consumable, starter, basic, intermediate, legendary, relic (`ItemTier`). `epic`, the old
+     * word, is read as intermediate
+     */
     tier?: ItemTier;
+    /**
+     * The name of its passive (or the passive of items that share it): two carried, of it or of items sharing the name,
+     * work once (the first carried). Its stats (`bonus`) always count. Every passive works when left out
+     *
+     * @beta
+     */
+    unique?: string;
+    /**
+     * A group of items a hero carries only so many of (`boots`): `groupLimit`, or the game's limit of the group
+     * (`ItemSettings.groups`), 1 when neither says. Buying, picking up or being handed one more is refused, saying why
+     *
+     * @beta
+     */
+    group?: string;
+    /** How many of its `group` one carrier may have: the game's limit of the group, or 1, when left out @beta */
+    groupLimit?: number;
+    /**
+     * How many of it go in one slot: another bought, picked up or handed over goes into the slot of one carried, its
+     * charges added, up to so many of it (a stack of potions). One a slot when left out
+     *
+     * @beta
+     */
+    stack?: number;
+    /** How its charges come back (`ItemRefill`): at a shop, over time. Used up for good when left out @beta */
+    refill?: ItemRefill;
+    /** The part of its price a shop gives back for it, over the game's (`EconomySettings.sellPrice`) @beta */
+    sellRate?: number;
+    /**
+     * Free words of the game's for what it is (`attack`, `lifesteal`, `anti-heal`, `early`): its categories, what a
+     * search finds it by (`#lifesteal`), what a shop filters by. A `TagDef` gives one a name and a look (`Rules.tags`)
+     *
+     * @beta
+     */
+    tags?: string[];
+    /**
+     * The callings of heroes it is meant for (`vanguard`, `ranger`…): what a shop suggests and filters by. Never a lock:
+     * any hero may buy it
+     *
+     * @beta
+     */
+    suits?: string[];
     /** Applies for as long as the item is carried */
     bonus?: StatChange;
     /** How many a shop has at most, and the seconds it takes to get one back. As many as anyone wants when left out */
@@ -1064,10 +2771,11 @@ export interface ItemDef {
         max: number;
         restock: number;
     };
+    /** The key that uses it from the command card */
     hotkey?: string;
     /**
      * Used as it is picked up, by walking over it or by the order, and never carried: a rune, a tome. Its ability is cast by
-     * whoever picked it. In a game with the runes pack (`withRunes`, whose `powerUp` says it in code)
+     * whoever picked it. In a game with the runes pack (`runesPack`, whose `powerUp` says it in code)
      */
     powerUp?: boolean;
 }
@@ -1079,6 +2787,7 @@ export interface ItemDef {
 export interface UpkeepTier {
     /** Applies when the player uses more supply than this */
     above: number;
+    /** What the player sees the tier called */
     name: string;
     /** Part of what is gathered that still arrives, 0..1 */
     income: number;
@@ -1095,27 +2804,33 @@ export interface UpgradeEffect extends StatChange {
 /**
  * Research that improves a player's units for the rest of the game
  *
- * @beta
+ * @public
  */
 export interface UpgradeDef {
+    /** The upgrade's id, shared by every game: give it a prefix of the game's */
     id: string;
+    /** What the player sees the upgrade called */
     name: string;
     /**
      * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):
      * what it is drawn, heard and pictured as where the game gives it no look of its own
      */
     basedOn?: string;
+    /** What the upgrade does, in words, shown when the pointer is over it */
     description?: string;
     /** Paid for every level */
     cost: Cost;
     /** Seconds per level */
     researchTime: number;
+    /** The highest level that can be researched; 1 when left out */
     maxLevel?: number;
     /** Building types needed, one list per level. Levels past the end of the list need nothing */
     requires?: string[][];
-    /** The race it is of (`GameModule.races`): only its players may research it. Everyone's when left out */
+    /** The race it is of (`Rules.races`): only its players may research it. Everyone's when left out */
     race?: string;
+    /** The key that researches it from the command card */
     hotkey?: string;
+    /** What each level changes in the stats of the units it applies to */
     effects: UpgradeEffect[];
     /**
      * What it does besides stats, in code, to each unit of the player's: as a level is researched (to the units there
@@ -1131,18 +2846,33 @@ export interface UpgradeDef {
  * @beta
  */
 export declare const upgradesOf: (def: Pick<UnitTypeDef, 'upgradesTo'>) => readonly string[];
-/** @beta */
+/**
+ * Gives the footprint of a unit type: its own, or a square the width of its collision diameter, rounded up
+ *
+ * @beta
+ */
 export declare const footprintOf: (def: UnitTypeDef) => {
     w: number;
     d: number;
 };
+/** The one pool of supply there always is, in a supply said by pool (`UnitTypeDef.supply`) @beta */
+export declare const MAIN_SUPPLY = "supply";
+/** What a type takes of the one pool of supply there always is (`UnitTypeDef.supply`, a number or its `supply`) @beta */
+export declare function supplyOf(def: Pick<UnitTypeDef, 'supply'>): number;
+/** What a type takes of the game's own pools of supply, by name (`UnitTypeDef.supply` said by pool, the one pool left out) @beta */
+export declare function supplyPoolsOf(def: Pick<UnitTypeDef, 'supply'>): Record<string, number>;
+/** What a finished building of a type provides of the one pool of supply (`UnitTypeDef.supplyGiven`) @beta */
+export declare function supplyGivenOf(def: Pick<UnitTypeDef, 'supplyGiven'>): number;
+/** What a finished building of a type provides of the game's own pools, by name (`UnitTypeDef.supplyGiven` said by pool) @beta */
+export declare function supplyPoolsGivenOf(def: Pick<UnitTypeDef, 'supplyGiven'>): Record<string, number>;
 /**
  * What base stats are worked out under: the rules of a game, and what its own stats start at. A `Registry` is one
  *
  * @beta
  */
 export interface StatSource {
-    readonly rules: Readonly<GameRules>;
+    /** The rules of the game the stats are worked out under, as `RuleSettings` */
+    readonly settings: Readonly<RuleSettings>;
     /** Every stat of the game at 0, its own at their default */
     readonly statDefaults: Readonly<Stats>;
 }