@kingdomsconnected/types 1.6.0 → 1.6.2

package/generated/server-api.d.ts

@@ -18,18 +18,35 @@ declare global {
     /**
      * Dispatched once per accepted death report. Call player.revive() to request revival; there is no automatic respawn.
      * 
-     * `killer` is the player whose blow took the last of the health, as the dying player's own client saw it -- null for a fall, a bleed-out, or anything that was not a player. `reason` is the game's own for that last write: `combat` for a blade or a bow, `fall`, `bleeding`, `poison` and so on.
+     * `killer` is the player or server NPC whose blow took the last of the health, as the dying player's own client saw it -- null for a fall, a bleed-out, or anything without an identified attacker. `reason` is the game's own for that last write: `combat` for a blade or a bow, `fall`, `bleeding`, `poison` and so on.
      */
-    playerDied: [player: Player, killer: Player | null, reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm"];
+    playerDied: [player: Player, killer: Player | Npc | null, reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm"];
 
     /**
-     * Dispatched when something takes health off a player: a weapon, an arrow, a fall, a collision, a scripted hit. The hit player's own client reports it, because only it resolved the blow against its armour and its skills, so `amount` is what was really taken. It arrives ahead of the `playerDied` a killing blow causes.
+     * Dispatched when something takes health off a player: a weapon, an arrow, a fall, a collision, a scripted hit. Player combat and server NPC melee are raised by the server as it rules on them, after `playerHit` had its say, so `amount` is what the ruling takes; anything else is reported by the hit player's own client, which resolved it against its armour and its skills. It arrives ahead of the `playerDied` a killing blow causes.
      * 
-     * `attacker` is the player who dealt it, or null. `bodyPart` is where it landed, or null for damage that lands nowhere in particular. The weapon is the attacker's own `rightHandItem` or `leftHandItem`.
+     * `attacker` is the player or server NPC who dealt it, or null. `bodyPart` is where it landed, or null for damage that lands nowhere in particular. A player attacker's weapon is available through `rightHandItem` or `leftHandItem`; an NPC's equipped items are in `wearing`.
      * 
      * Bleeding, poison and hunger wear health down a tick at a time without raising this -- `bleeding`, `poisoning` and `hunger` are live numbers already. The tick that kills does arrive, with its own reason, just before the `playerDied` it causes.
      */
-    playerDamage: [player: Player, attacker: Player | null, amount: number, bodyPart: "head" | "torso" | "leftArm" | "rightArm" | "leftLeg" | "rightLeg" | null, reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm"];
+    playerDamage: [player: Player, attacker: Player | Npc | null, amount: number, bodyPart: "head" | "torso" | "leftArm" | "rightArm" | "leftLeg" | "rightLeg" | null, reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm"];
+
+    /**
+     * A melee swing aimed at another player was admitted by the server, including a miss. Raised once per attack generation, after presentation admission. Use it to track combat inactivity in your resource.
+     */
+    playerAttack: [player: Player, opponent: Player];
+
+    /**
+     * A resource called cancelCombat for this pair. Raised after the cancellation was sent to both players and their observers.
+     */
+    playerCombatCancelled: [first: Player, second: Player];
+
+    /**
+     * Dispatched when another player's blade or arrow, or a server NPC's melee attack, lands on a player, before anything is taken -- the place for teams, safe zones, friendly fire and damage rules. The game resolved the blow against the guard the victim really held -- whether it was blocked, perfectly or not, and where it landed -- and the server works out what a swing takes from there; it has checked that the swing was one it relayed and could still land, or that the arrow was one whose impact it accepted, and that the two stood within reach. Only what is ruled here comes off the victim's health, on every client at once.
+     * 
+     * Return `false` from a handler to refuse the blow: no health is taken and no `playerDamage` follows. NPC melee uses the victim client's native damage with `priced: false`; set `hit.damage` to change it. For priced player swings, scale `hit.modifiers` to change how a swing is worked out -- a stronger attack, weaker armour -- or set `hit.damage` to say outright what it takes: `0` for a blow that lands harmlessly, more for a heavier one. Either way the blow is still seen and heard: the blades met. Handlers run synchronously, so the decision cannot wait on anything awaited.
+     */
+    playerHit: [player: Player, attacker: Player | Npc, hit: PlayerHit];
 
     /**
      * Dispatched when a limb becomes injured -- usually a blow landing there, sometimes a fall on both legs. `player.injuries` already says so. A limb hit again while injured stays injured and raises nothing new.
@@ -120,6 +137,11 @@ declare global {
      */
     playerInventoryReady: [player: Player];
 
+    /**
+     * A move or patrol leg reached its destination, was blocked, or failed. Intermediate path corners do not emit this event.
+     */
+    horseIntentDone: [horse: Horse, status: string];
+
     /**
      * Dispatched immediately after a horse is created and replicated, whether by `Horse.spawn`, the `/horse` command, or anything else.
      */
@@ -350,14 +372,14 @@ declare global {
     npcIntentDone: [npc: Npc, status: string];
 
     /**
-     * Dispatched after health came off the ledger. The attacker's own client resolved the hit and the server agreed to it, so `amount` is what was actually taken, not what was claimed.
+     * Dispatched after health came off the ledger. For melee, the victim's simulator resolves the native hit and the server checks the accepted swing before changing health. `amount` is what was actually taken.
      */
-    npcDamage: [npc: Npc, attacker: Player | null, amount: number];
+    npcDamage: [npc: Npc, attacker: Player | Npc | null, amount: number];
 
     /**
      * Dispatched when the last of an NPC's health goes. The body stays as a corpse and the handle keeps resolving.
      */
-    npcDeath: [npc: Npc, attacker: Player | null];
+    npcDeath: [npc: Npc, attacker: Player | Npc | null];
 
     /**
      * Dispatched when a dead NPC is brought back. Every client makes a new body for it.
@@ -379,6 +401,16 @@ declare global {
      */
     npcSimulatorChange: [npc: Npc, player: Player | null];
 
+    /**
+     * One accepted waypoint outcome; intermediate path corners do not emit it.
+     */
+    patrolWaypoint: [actor: Npc, info: PatrolState & { status: 'reached' | 'blocked' | 'failed' }];
+
+    /**
+     * A patrol ended, failed, or was replaced. Edits to its definition do not replace its snapshot.
+     */
+    patrolFinished: [actor: Npc, info: PatrolState & { status: 'completed' | 'failed' | 'cancelled' }];
+
     /**
      * Dispatched when a player starts or stops following a quest in the game's journal, whichever way it happened: the track button, the game auto-tracking a quest that turns active, or the untrack that follows finishing or failing one. The client reports it -- following a quest is decided there and cannot be refused here -- so a handler reacts rather than vetoes. It fires only on an actual change, and only for a quest that player was given.
      */
@@ -432,9 +464,9 @@ declare global {
     siegeEngineReady: [engine: SiegeEngine];
 
     /**
-     * Dispatched when a player presses a `usable` engine's native prompt, standing at it, on the step the prompt was offered for. Return false to refuse; otherwise the engine loads, or fires along the player's facing at `range` with the player as the attacker. A handler that works the engine itself should refuse, so it is not worked twice.
+     * Dispatched when a player asks something of a `usable` engine, standing at it: to take its place (`operate`) or a free winch (`winch`) from the game's own prompt, or -- in its place -- to `load` it or `fire` it where they laid it, with the player as the attacker. Return false to refuse. `leave` reports a player stepping away from either and cannot be refused. A handler that works the engine itself should refuse, so it is not worked twice.
      */
-    siegeEngineUse: [player: Player, engine: SiegeEngine, action: "load" | "fire"];
+    siegeEngineUse: [player: Player, engine: SiegeEngine, action: "operate" | "winch" | "leave" | "load" | "fire"];
 
     /**
      * Dispatched the moment an engine lets its projectile go, partway through the shot `fire` started.
@@ -442,7 +474,7 @@ declare global {
     siegeFire: [engine: SiegeEngine, attacker: Player | null, target: Vector3];
 
     /**
-     * Dispatched where a projectile came down: what the player nearest the target saw it hit, checked against the arc it was thrown on, or the target itself when nobody could see it. Players within `damageRadius` have already been told to take their share, and NPCs have taken theirs. `engine` is null when it was destroyed while the stone was in the air.
+     * Dispatched where a projectile came down: what the reporting player -- the attacker when near enough, else whoever is nearest the target -- saw it hit, checked against the arc it was thrown on, or the target itself when nobody could see it. Players within `damageRadius` have already been told to take their share, and NPCs have taken theirs. `engine` is null when it was destroyed while the stone was in the air.
      */
     siegeImpact: [engine: SiegeEngine | null, position: Vector3, attacker: Player | null];
 
@@ -456,6 +488,11 @@ declare global {
      */
     areaExit: [area: Area, entity: Player | Horse | Cart | Npc, matchingVirtualWorld: boolean];
 
+    /**
+     * Raised once after every configured world export has loaded successfully, including an empty list. WorldResource.ready is true inside the handler. A script starting later must check WorldResource.ready first; the event is not replayed. Do not await this event inside resourceStart: exports load after script startup. Handler promises are not awaited.
+     */
+    worldResourcesReady: [];
+
     /**
      * A container now exists: a scripted chest, a virtual stash, or one the level places, built in a virtual world the first time anything there asked for it. Every container starts empty; restore saved contents here with `setInventory`. The level's containers in the global world are built before any resource runs, so restore those from `resourceStart` by walking `Stash.all()`.
      */
@@ -582,11 +619,221 @@ declare global {
      * Dispatched when a player asks to join, before the connection exists: they hold no player slot, are not counted as online, and are sent nothing -- no resource list, no download, no body. The request waits until every handler has returned and every Promise a handler returned has settled, then it is let in if a player slot is free (otherwise it is refused as full). `connection.reject()` turns it away instead, and so does a handler that throws or rejects, or handlers that have not settled within the server's admission timeout (30 seconds by default, restarted by every `connection.update()`). With no handler at all, every request is let in at once.
      */
     playerConnecting: [connection: PendingConnection];
+
+    /**
+     * Dispatched when a blast takes `amount` off an engine with a `maxHealth`, before it is wrecked by it. `health` already reads what is left.
+     */
+    siegeEngineDamage: [engine: SiegeEngine, amount: number, attacker: Player | null];
+
+    /**
+     * Dispatched when an engine's health runs out. Its operator and crew have been let go, and a stone still in its sling went down with it.
+     */
+    siegeEngineWreck: [engine: SiegeEngine, attacker: Player | null];
+
+    /**
+     * Dispatched immediately after a siege ladder is placed.
+     */
+    siegeLadderSpawn: [ladder: SiegeLadder];
+
+    /**
+     * Dispatched while a siege ladder is being removed. The handle still resolves.
+     */
+    siegeLadderDestroy: [ladder: SiegeLadder];
+
+    /**
+     * Dispatched when a player asks to push a `usable` ladder from the walk at its top, or to raise a fallen one from beside its foot. Return false to refuse.
+     */
+    siegeLadderUse: [player: Player, ladder: SiegeLadder, action: "push" | "raise"];
+
+    /**
+     * Dispatched when a pushed ladder hits the ground. Anyone who was on it was thrown off as it began to fall, and took the game's own fall.
+     */
+    siegeLadderFall: [ladder: SiegeLadder, pusher: Player | null];
+
+    /**
+     * Dispatched when a raised ladder leans on its wall again and can be climbed.
+     */
+    siegeLadderRaise: [ladder: SiegeLadder];
+
+    /**
+     * Dispatched immediately after a stone pile is placed.
+     */
+    stonePileSpawn: [pile: StonePile];
+
+    /**
+     * Dispatched while a stone pile is being removed. The handle still resolves.
+     */
+    stonePileDestroy: [pile: StonePile];
+
+    /**
+     * Dispatched when a player takes a stone off a pile. The game's own stone throwing has already lifted it and heaves it over the wall at once, so it cannot be refused; make the pile not `usable` to stop the next one.
+     */
+    stonePileThrow: [player: Player, pile: StonePile];
+
+    /**
+     * Dispatched where a thrown stone first met something, as its thrower saw it, checked to lie within 30 m of its pile. Players within the pile's `damageRadius` have been told to take their share, and NPCs have taken theirs.
+     */
+    stoneImpact: [pile: StonePile | null, position: Vector3, attacker: Player];
   }
 
   /** Names of native events available in this scripting environment. */
   type EventName = keyof EventMap;
 
+  /**
+   * Writable player stats, in native units. Use getStat and the server's setStat.
+   */
+  const PlayerStat: {
+    /**
+     * Current health, in native units. Zero can kill.
+     */
+    readonly Health: "health";
+
+    /**
+     * Current stamina; the game continues spending and regenerating it.
+     */
+    readonly Stamina: "stamina";
+
+    /**
+     * Current energy reserve; higher means better rested.
+     */
+    readonly Exhaust: "exhaust";
+
+    /**
+     * Current nourishment; higher means better fed.
+     */
+    readonly Hunger: "hunger";
+  };
+
+  /**
+   * Read-only computed player stats. Use getDerivedStat; these values cannot be passed to setStat.
+   */
+  const DerivedPlayerStat: {
+    /**
+     * Total bleeding strength.
+     */
+    readonly Bleeding: "bleeding";
+
+    /**
+     * Sleepiness; above zero means asleep.
+     */
+    readonly Sleeping: "sleeping";
+
+    /**
+     * Consciousness; zero means knocked out.
+     */
+    readonly Consciousness: "consciousness";
+
+    /**
+     * Native drunkenness value.
+     */
+    readonly Drunkenness: "drunkenness";
+
+    /**
+     * Native poisoning value; not every named poison changes this value.
+     */
+    readonly Poisoning: "poisoning";
+
+    /**
+     * Effective charisma.
+     */
+    readonly Charisma: "charisma";
+
+    /**
+     * Effective visibility.
+     */
+    readonly Visibility: "visibility";
+
+    /**
+     * Effective conspicuousness.
+     */
+    readonly Conspicuousness: "conspicuousness";
+
+    /**
+     * Effective noise.
+     */
+    readonly Noise: "noise";
+
+    /**
+     * Native dirtiness reading; reading it does not clean the body or equipment.
+     */
+    readonly Dirtiness: "dirtiness";
+
+    /**
+     * Native bloodiness reading.
+     */
+    readonly Bloodiness: "bloodiness";
+
+    /**
+     * Native smell reading.
+     */
+    readonly Smell: "smell";
+
+    /**
+     * Native smell intensity.
+     */
+    readonly SmellIntensity: "smellIntensity";
+
+    /**
+     * Native fragrance reading.
+     */
+    readonly Fragrance: "fragrance";
+
+    /**
+     * Carried weight in the same units as InventoryCapacity.
+     */
+    readonly CarriedWeight: "carriedWeight";
+
+    /**
+     * Native carrying capacity, including applicable equipment effects.
+     */
+    readonly InventoryCapacity: "inventoryCapacity";
+
+    /**
+     * Native encumbrance reading.
+     */
+    readonly Encumbrance: "encumbrance";
+
+    /**
+     * Native hangover reading.
+     */
+    readonly Hangover: "hangover";
+
+    /**
+     * Computed alcoholism reading, not the persistent soul resource.
+     */
+    readonly Alcoholism: "alcoholism";
+
+    /**
+     * Effective armor rating.
+     */
+    readonly ArmorRating: "armorRating";
+
+    /**
+     * Overall armor defense.
+     */
+    readonly OverallArmorDefense: "overallArmorDefense";
+
+    /**
+     * Overall weapon attack.
+     */
+    readonly OverallWeaponAttack: "overallWeaponAttack";
+
+    /**
+     * Normalized run speed; not world-space velocity.
+     */
+    readonly NormalizedRunSpeed: "normalizedRunSpeed";
+
+    /**
+     * Native base run speed.
+     */
+    readonly RunSpeedBase: "runSpeedBase";
+
+    /**
+     * Native morale reading.
+     */
+    readonly Morale: "morale";
+  };
+
   /**
    * How a player's body looks: four of the game's own character-component names, and the gender whose catalog they come from.
    * 
@@ -956,6 +1203,136 @@ declare global {
     walkEnforced: boolean;
   }
 
+  /**
+   * One number per damage type a blow is worked out in. A blade's stab, slash and smash are priced separately and added; a blow runs only the passes its attack and weapon call for.
+   */
+  interface DamagePasses {
+    /**
+     * The stab pass.
+     */
+    stab: number;
+
+    /**
+     * The slash pass.
+     */
+    slash: number;
+
+    /**
+     * The smash pass.
+     */
+    smash: number;
+  }
+
+  /**
+   * Scales a `playerHit` handler puts on the server's price of a melee blow, each 1 until a handler changes it. The server works the blow out again with them, step by step as the game does: a heavier attack has to get through the same armour and the same block, so doubling `attack` does not simply double the damage. Never negative.
+   */
+  interface PlayerHitModifiers {
+    /**
+     * Scales the attacker's attack in every pass, after their weapon, strength, skill and the swing itself.
+     */
+    attack: number;
+
+    /**
+     * Scales the victim's armour where the blow landed.
+     */
+    defense: number;
+
+    /**
+     * Scales what the victim's block put up. Nothing for a blow that was not blocked.
+     */
+    block: number;
+
+    /**
+     * Scales the health the blow takes, once everything else is worked out. The game's own cap of 200 a blow is applied before it, so this can go past it.
+     */
+    health: number;
+  }
+
+  /**
+   * A player or NPC blow, as `playerHit` shows it before the referee rules. `damage` is what the blow will take and `modifiers` scale how the server works it out; a handler may change either. Every other field describes what happened and is read-only in effect.
+   */
+  interface PlayerHit {
+    /**
+     * Health the blow takes. For melee between players the server works it out itself, the way the game does, from the attacker's weapon and its wear, both players' strength and skills, the armour the victim wears where it landed, the block and the perks and buffs it can vouch for; for NPC melee or an arrow it is what the victim's own game worked out. Set it and it stands as set: `modifiers` are then ignored. Never negative.
+     */
+    damage: number;
+
+    /**
+     * Health the game itself took for the blow on the machine that saw it land. Matches `damage` unless a perk that depends on the moment -- a heavy weapon's, a first strike's -- was in play, which the server leaves out.
+     */
+    engineDamage: number;
+
+    /**
+     * Whether the server worked `damage` out itself: true for a swing, false for an arrow.
+     */
+    priced: boolean;
+
+    /**
+     * The attacker's weapon as 32 hex digits, or null for a bare hand.
+     */
+    weapon: string | null;
+
+    /**
+     * The attacker's attack in each pass, after the swing's own strength and before `modifiers`.
+     */
+    attack: DamagePasses;
+
+    /**
+     * The victim's armour in each pass where the blow landed, before `modifiers`.
+     */
+    armor: DamagePasses;
+
+    /**
+     * What the victim's block put up, or 0 when nothing blocked it.
+     */
+    blockDefense: number;
+
+    /**
+     * How much the place it landed multiplies the damage by: 1.5 for the head, 1 for the torso, 0.7 for a limb.
+     */
+    bodyPartCoefficient: number;
+
+    /**
+     * Scales on the server's price; see `PlayerHitModifiers`. Ignored for an arrow.
+     */
+    modifiers: PlayerHitModifiers;
+
+    /**
+     * Stamina the blow cost the victim. Already spent: stamina decides their next block, which cannot wait for a ruling.
+     */
+    stamina: number;
+
+    /**
+     * The limb it landed on, or null for none in particular.
+     */
+    bodyPart: "head" | "torso" | "leftArm" | "rightArm" | "leftLeg" | "rightLeg" | null;
+
+    /**
+     * The game's own reason for the damage: `combat` for a blade or a bow.
+     */
+    reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm";
+
+    /**
+     * Whether it was a swing or an arrow.
+     */
+    source: "melee" | "missile";
+
+    /**
+     * The victim's block caught it.
+     */
+    blocked: boolean;
+
+    /**
+     * The victim's perfect block caught it. The game takes nothing for one.
+     */
+    perfectBlock: boolean;
+
+    /**
+     * The victim's block gave way under it.
+     */
+    blockBroken: boolean;
+  }
+
   /**
    * Which of a player's limbs carry an injury, one flag per limb. An injury is the game's own: it lowers the stamina ceiling (`healthyStamina`), can bleed, and heals slowly by itself or at once with a bandage or `player.heal`.
    */
@@ -1069,12 +1446,12 @@ declare global {
     readonly healthyStamina: number;
 
     /**
-     * Current tiredness, in the game's own units.
+     * Current energy reserve, in the game's own units. Higher means better rested.
      */
     readonly exhaust: number;
 
     /**
-     * Tiredness capacity, in the game's own units.
+     * Maximum energy reserve, in the game's own units.
      */
     readonly maxExhaust: number;
 
@@ -1144,7 +1521,7 @@ declare global {
     readonly relativeSkills: SoulSkills;
 
     /**
-     * The velocity the body's own animation was driven by this frame, not the one its physics settled on.
+     * On the owning machine, the velocity the body's own animation was driven by this frame, not the one its physics settled on. Everywhere else, measured from successive replicated positions.
      */
     readonly velocity: Vector3;
 
@@ -1158,21 +1535,6 @@ declare global {
      */
     readonly inAir: boolean;
 
-    /**
-     * The engine's own locomotion pace tag -- walk, jog, sprint -- as its animation system picked it. Raw Mannequin tag ids; 255 means nothing is set.
-     */
-    readonly moveSpeedTag: number;
-
-    /**
-     * The engine's own movement direction tag. Raw Mannequin tag ids; 255 means nothing is set.
-     */
-    readonly moveDirTag: number;
-
-    /**
-     * The engine's own stance tag -- upright, sneaking, sitting, lying. Raw Mannequin tag ids; 255 means nothing is set.
-     */
-    readonly stanceTag: number;
-
     /**
      * Whether this player is crouched, as their own game's crouch action reports it. False once their body is gone.
      */
@@ -1285,6 +1647,18 @@ declare global {
      */
     toString(): string;
 
+    /**
+     * Reads the latest reported stat in native units. Returns zero when no valid body snapshot exists; check player.ready to distinguish that from a real zero. Throws for an unknown stat or invalid arguments.
+     * @param stat A PlayerStat value.
+     */
+    getStat(stat: "health" | "stamina" | "exhaust" | "hunger"): number;
+
+    /**
+     * Reads a computed stat from the latest body snapshot. Bleeding, Sleeping, Consciousness, Drunkenness and Poisoning follow the body as it changes; the others are sampled about every 250 ms to a hundredth of a native unit, then replicated. Values use native units and can be negative; they are not universally percentages. Returns zero without a valid snapshot. Throws for an unknown stat or invalid arguments. These readings do not override another player's native calculations.
+     * @param stat A DerivedPlayerStat value.
+     */
+    getDerivedStat(stat: "bleeding" | "sleeping" | "consciousness" | "drunkenness" | "poisoning" | "charisma" | "visibility" | "conspicuousness" | "noise" | "dirtiness" | "bloodiness" | "smell" | "smellIntensity" | "fragrance" | "carriedWeight" | "inventoryCapacity" | "encumbrance" | "hangover" | "alcoholism" | "armorRating" | "overallArmorDefense" | "overallWeaponAttack" | "normalizedRunSpeed" | "runSpeedBase" | "morale"): number;
+
     /**
      * Where this player stands on one track: level, XP towards the next one, and unspent perk points.
      * @param track A track name, from `Progression.tracks()`.
@@ -1356,6 +1730,13 @@ declare global {
      */
     revive(): boolean;
 
+    /**
+     * Ends melee combat between these two players and retires their pending blows against each other. Other opponents are left alone. A later attack can start combat again. Consent and timeout rules belong to your resource.
+     * @param opponent The other player. Both sides are cancelled.
+     * @returns True when sent; false for disconnected players, the same player, or different virtual worlds.
+     */
+    cancelCombat(opponent: Player): boolean;
+
     /**
      * Puts this player somewhere, as a spawn rather than as a teleport: their client holds the body still until there is real ground under it, so it cannot fall through a world that has not streamed in yet.
      * 
@@ -1434,6 +1815,13 @@ declare global {
      */
     setAppearance(appearance: Partial<Appearance>): boolean;
 
+    /**
+     * Grants or revokes World Builder access for this player. Multiplayer connections start without access. Enabling allows F7 and the client MapEditor.open API; disabling also closes an open editor. The permission lasts until changed or disconnected and does not affect other players. Offline editing is always allowed.
+     * @param enabled Whether this player may open World Builder.
+     * @returns True when the permission was sent; false for a player with no connection. Throws unless enabled is a boolean.
+     */
+    setWorldBuilderEnabled(enabled: boolean): boolean;
+
     /**
      * Puts a pace rule on this player. `walkByDefault` makes walking the pace they keep coming back to and leaves their own key working; `walkEnforced` forbids running and sprinting outright, and their key stops mattering.
      * 
@@ -1448,7 +1836,7 @@ declare global {
     setMovementMode(mode: Partial<MovementMode>): boolean;
 
     /**
-     * Grants items into this player's inventory, which the server holds; their game shows them on the next tick. `Inventory.add` does the same and can also set the items' properties.
+     * Grants items into this player's inventory, which the server holds; their game shows them on the next tick and announces them with its own "You received" toast. `Inventory.add` does the same, can set the items' properties, and can leave out the toast.
      * @param item Item class GUID, or the exact name the game's own item tables use.
      * @param amount How many to grant; defaults to 1, and at most 10000.
      * @returns True when the items were added; false for an unknown item, an amount outside 1..10000, or a player with no inventory.
@@ -1456,7 +1844,7 @@ declare global {
     giveItem(item: string, amount?: number): boolean;
 
     /**
-     * Takes items of a class out of this player's inventory, across its rows, all of them or none. The server holds the inventory, so the promise is already settled when it is returned; it stays a promise so existing scripts keep working. To move items between players use `Inventory.transfer`, which cannot lose them half way.
+     * Takes items of a class out of this player's inventory, across its rows, all of them or none. The server holds the inventory, so the promise is already settled when it is returned; it stays a promise so existing scripts keep working. Their game announces the loss with its own toast; `Inventory.remove` can leave it out. To move items between players use `Inventory.transfer`, which cannot lose them half way.
      * @param item Item class GUID, or the exact name the game's own item tables use. The same spelling `giveItem` takes.
      * @param amount How many units to take; defaults to 1, and at most 10000. Zero is refused rather than read as "all of them".
      * @returns An object carrying `removed` (the amount when it happened, otherwise 0), `requested`, `ok`, and `reason` (empty on success, otherwise the inventory code, such as `insufficientItems`).
@@ -1470,6 +1858,13 @@ declare global {
      */
     dropInventory(options?: { keepEquipped?: boolean }): Stash | null;
 
+    /**
+     * Dresses this player in one of the game's own outfits. Every piece of clothing they wear comes off and stays in their inventory, and a new set of the outfit's clothes is added and worn; weapons and everything else are left as they are. Their game dresses them a moment later, as it does after `Inventory.set`.
+     * @param preset One of the game's own outfits for this player's gender, by a name from `Player.outfitPresets(player.appearance.gender)` or its GUID.
+     * @returns True when the inventory was changed; false for a preset that is not in the catalog or is the other gender's, a player with no inventory, or an inventory with no room.
+     */
+    setOutfit(preset: string): boolean;
+
     /**
      * Reads this player's inventory; the same as `Inventory.get(player)`.
      * @returns A copy of it, or null for a player who is not connected.
@@ -1506,6 +1901,28 @@ declare global {
      */
     hasBuff(buff: string): boolean;
 
+    /**
+     * Sets health, stamina, energy or nourishment on the living body. Call once player.ready is true. Lowering health raises playerDamage with a null attacker; a fatal change also raises playerDied with a null killer. Zero health can kill. Does not clear buffs or revive; normal regeneration and consumption continue.
+     * @param stat Writable PlayerStat; derived stats are rejected.
+     * @param value Finite native value from 0 to 1000000, clamped to the native maximum. Positive health must exceed 0.00001; positive values must not underflow to zero.
+     * @returns True when sent, not confirmation of application; false for a missing, unready or dead body. Throws for invalid arguments or a read-only stat. Requests for a previous life are discarded. Read getStat after the client's next report to observe the result.
+     */
+    setStat(stat: "health" | "stamina" | "exhaust" | "hunger", value: number): boolean;
+
+    /**
+     * Sets this living player's health, raising or lowering it. Lowering raises playerDamage with a null attacker and the amount removed; a fatal change also raises playerDied with a null killer. This includes restoring a lower saved value. Zero can kill; this never revives a dead player. Leaves injuries, poison and bleeding in place. Call after playerSpawned or playerReady when restoring a saved value. The client applies the request asynchronously; health continues to show its last report until a new one arrives.
+     * @param value Health in the same units as player.health. Clamped to maxHealth on the player's client.
+     * @returns True when sent; false when the body is missing, not ready or dead. Throws unless value is a finite number from 0 to 1000000, with positive health greater than 0.00001 after conversion to native float units. A request for a life that has since ended is ignored.
+     */
+    setHealth(value: number): boolean;
+
+    /**
+     * Sets this living player's nourishment, raising or lowering it. Call after playerSpawned or playerReady when restoring a saved value. The client applies the request asynchronously; hunger continues to show its last report until a new one arrives.
+     * @param value Nourishment in the same units as player.hunger. Higher means better fed. Clamped to maxHunger on the player's client.
+     * @returns True when sent; false when the body is missing, not ready or dead. Throws unless value is a finite number from 0 to 1000000 that does not round from positive to zero in native float units. A request for a life that has since ended is ignored.
+     */
+    setHunger(value: number): boolean;
+
     /**
      * Nurses this player back, on their own client and with the game's own recipe -- the one its quests use for a full heal: the `remove_injuries` and `remove_all_posions` cures, which each wipe their whole kind of effect as they land, then health raised through the soul's own setter, the way a potion raises it. What comes off raises `playerInjuryHealed` and `playerBuffRemoved` as usual.
      * 
@@ -1559,11 +1976,19 @@ declare global {
     putDownItem(options?: { immediate?: boolean }): boolean;
 
     /**
-     * Puts this player in a horse's saddle, the way the game's own forced mount does -- their client plays the climb. It is an instruction to their client, so the seat is reported back like any other mount: `horseMounting` can still refuse it, and `horseMount` and `player.horse` follow once it lands. The player has to be standing near the horse; teleport them beside it first.
-     * @param horse The horse to climb onto.
+     * Puts this player in a horse's saddle. Everyone near enough to watch sees it the way it was asked for -- the get-on, or the instant seat -- while a client that only streams the rider in later finds them already seated. It is an instruction to their client, so the seat is reported back like any other mount: `horseMounting` can still refuse it, and `horseMount` and `player.horse` follow once it lands. The player has to be standing near the horse; teleport them beside it first.
+     * @param horse The horse to get on.
+     * @param options `instant` puts them straight into the seat, as the game's own forced mount does; by default they play the get-on a player plays at a horse.
      * @returns True when the order went out; false when the horse is dead or somebody else is riding it, or the player has no connection.
      */
-    mount(horse: Horse): boolean;
+    mount(horse: Horse, options?: { instant?: boolean }): boolean;
+
+    /**
+     * The game's own outfits, from its clothing presets: what `player.setOutfit` and `Npc.setOutfit` dress a body in. Many belong to one named character.
+     * @param gender Only the outfits authored for this gender. The game will not put a man's clothes on a woman or the reverse, so `player.setOutfit` takes only the presets of the player's own `appearance.gender`.
+     * @returns Preset names, men's first, each gender's in name order.
+     */
+    static outfitPresets(gender?: "male" | "female"): string[];
 
     /**
      * Lists every player currently connected, including those whose body has no pose yet.
@@ -1676,7 +2101,7 @@ declare global {
     revision: number;
 
     /**
-     * `add`, `remove`, `properties`, `set`, `transfer`, `wear` when the player's game wore an item down in use, `use` for food, potions and ointments, `shot` for a fired round, `pickpocket`, `trade` for a vendor deal, `drop` for `player.dropInventory`, or the ground, stash and gathering reasons.
+     * `add`, `remove`, `properties`, `set`, `transfer`, `wear` when the player's game wore an item down in use, `use` for food, potions and ointments, `shot` for a fired round, `pickpocket`, `trade` for a vendor deal, `repair` for a repair kit, `drop` for `player.dropInventory`, or the ground, stash and gathering reasons.
      */
     reason: string;
 
@@ -1696,7 +2121,7 @@ declare global {
     ok: boolean;
 
     /**
-     * Empty on success, otherwise why not: `inventoryUnavailable`, `invalidRequest`, `staleRevision`, `invalidItem`, `invalidItems`, `invalidAmount`, `unknownItem`, `insufficientItems`, `inventoryCapacity`, `sameInventory`, or a property policy code (`invalidMetadata`, `unknownItemClass`, `questItem`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
+     * Empty on success, otherwise why not: `inventoryUnavailable`, `invalidRequest`, `staleRevision`, `invalidItem`, `invalidItems`, `invalidAmount`, `unknownItem`, `insufficientItems`, `inventoryCapacity`, `sameInventory`, `invalidEquipment`, or a property policy code (`invalidMetadata`, `unknownItemClass`, `questItem`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
      */
     code: string;
 
@@ -1722,14 +2147,14 @@ declare global {
     get(player: Player): InventoryState | null;
 
     /**
-     * Gives a player items of a class, 1 to 10000 at a time. `item` is the class GUID or the exact name the game's own item tables use, the same spelling `giveItem` takes. Left-out properties mean quality 1 at full condition; `metadata.quality` asks for a higher tier, up to what the class is made in, and `invalidQuality` refuses one past it. The units join the row that already holds this class with these properties, if there is one.
+     * Gives a player items of a class, 1 to 10000 at a time. `item` is the class GUID or the exact name the game's own item tables use, the same spelling `giveItem` takes. Left-out properties mean quality 1 at full condition; `metadata.quality` asks for a higher tier, up to what the class is made in, and `invalidQuality` refuses one past it. The units join the row that already holds this class with these properties, if there is one. The player's game announces them with its own "You received" toast unless `notify` is false.
      */
-    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number }): InventoryResult;
+    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number; notify?: boolean }): InventoryResult;
 
     /**
-     * Takes exact units from named rows, every one of them or none.
+     * Takes exact units from named rows, every one of them or none. The player's game announces the loss with its own toast unless `notify` is false.
      */
-    remove(player: Player, request: { units: InventoryUnit[]; revision?: number }): InventoryResult;
+    remove(player: Player, request: { units: InventoryUnit[]; revision?: number; notify?: boolean }): InventoryResult;
 
     /**
      * Replaces a row's properties. The row keeps its identity and amount. It replaces rather than merges: carry over anything you want to keep, and give `health` or `condition`, not two that disagree.
@@ -1737,14 +2162,14 @@ declare global {
     setProperties(player: Player, request: { id: string; metadata: Record<string, unknown>; revision?: number }): InventoryResult;
 
     /**
-     * Replaces a player's whole inventory, which is how a saved one comes back. Rows keep the ids they are given (letters, digits and `-_:.`, up to 64) and get new ones when they have none. `equipped` is how many units of a gear row the body wears, up to 48 in all; their game dresses in them. An empty list clears the inventory.
+     * Replaces a player's whole inventory, which is how a saved one comes back. It is never announced in the player's game. Rows keep the ids they are given (letters, digits and `-_:.`, up to 64) and get new ones when they have none. `equipped` is how many units of a gear row the body wears, up to 48 in all; their game dresses in them. An empty list clears the inventory.
      */
     set(player: Player, request: { items: { id?: string; item: string; amount: number; metadata?: Record<string, unknown>; equipped?: number }[]; revision?: number }): InventoryResult;
 
     /**
-     * Moves exact units from one player to another with their properties, all or nothing. They join matching rows in the target, so the target's row ids are the ones in the result's `items`. Whether the two may trade -- distance, consent, price -- is for the script to decide.
+     * Moves exact units from one player to another with their properties, all or nothing. They join matching rows in the target, so the target's row ids are the ones in the result's `items`. Whether the two may trade -- distance, consent, price -- is for the script to decide. Both players' games announce what they lost and gained unless `notify` is false.
      */
-    transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number }): InventoryResult;
+    transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number; notify?: boolean }): InventoryResult;
 
     /**
      * What the game prices one unit of an item at, in money units, worked out the way the game does it. `pristine` is the price at the best health its quality allows, `current` at its own health. Quality changes the price only through that health. The metadata reads as `Inventory.add` reads it -- left out, quality 1 at full condition -- so `Inventory.getItemPrice(row.item, row.metadata)` prices a row. This is the item's own worth: what the game's shopkeepers would ask depends on their terms and the haggling, and a `Vendor` charges whatever its script says.
@@ -1772,6 +2197,11 @@ declare global {
      */
     constructor(id: number);
 
+    /**
+     * The current route's status: idle, running, reached, blocked, or failed.
+     */
+    readonly navigationStatus: string;
+
     /**
      * What this horse wears, by slot: `saddle` (the saddlebags are part of it, and so is the carrying capacity they add), `head` (a bridle or chanfron), `torso` (a caparison), `shoe`. Item class names, null for an empty slot. A spawned horse wears the game's own tack for it unless `Horse.spawn` said otherwise. The gear changes the horse's stats as well as its look.
      */
@@ -1863,6 +2293,25 @@ declare global {
      */
     destroy(): void;
 
+    /**
+     * Routes an unridden horse over the server navigation mesh. Mounting cancels the order. Returns false without a mesh, for a dead or mounted horse, or invalid input.
+     * @param position Destination in world coordinates.
+     * @param options Defaults to walking and a 1.5 metre arrival radius.
+     */
+    moveTo(position: Vector3, options?: { speed?: 'walk' | 'jog' | 'run'; radius?: number }): boolean;
+
+    /**
+     * Patrols using the NPC route state machine. Requires a loaded mesh and an alive, unridden horse. Mounting cancels the patrol.
+     * @param points One to 256 waypoints.
+     * @param options Defaults to walking, looping, and no wait.
+     */
+    patrol(points: Vector3[], options?: { speed?: 'walk' | 'jog' | 'run'; loop?: boolean; waitSeconds?: number }): boolean;
+
+    /**
+     * Cancels navigation and holds an unridden horse where it stands. Does not take control from a rider.
+     */
+    hold(): void;
+
     /**
      * Makes this horse another player's. Every client makes it that player's horse in the game's own terms -- theirs is never a stolen horse -- and `horseOwnerChanged` follows. Ownership decides nothing about who may ride it: that is `horseMounting`'s to refuse. Throws when `player` is not a connected player.
      * @param player The horse's new owner, or null to leave it ownerless.
@@ -3009,12 +3458,12 @@ declare global {
      * @param model Mesh to build, as either a full catalog path (`objects/manmade/barrels/barrel_a.cgf`) or its file stem (`barrel_a`). A stem several meshes share resolves to the first of them, so pass the path when it matters which. A mesh this server streams -- a `.cgf` in a resource's `stream/objects/kcdc/<resource>/` folder -- is named by its full path, `objects/kcdc/<resource>/chair.cgf`; a player whose game does not have it yet sees the prop as soon as it does.
      * @param position Optional world-space spawn position; omitted components default to zero.
      * @param rotation Optional initial orientation: a Quaternion, or a Vector3 of Euler angles in degrees.
-     * @param scale Optional uniform scale from 0.01 to 100; omitted spawns the mesh at its own size.
+     * @param scale Uniform size or separate X/Y/Z sizes, each from 0.01 to 100. Omitted uses the mesh size. Nonuniform collision follows the native engine limitations.
      * @param physics Optional collision: `static` (the default), `rigid` or `none`.
      * @param virtualWorld Optional virtual world the prop belongs to; omitted puts it in the global one.
      * @returns The newly spawned prop handle.
      */
-    static spawn(model: string, position?: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, scale?: number, physics?: string, virtualWorld?: number): Prop;
+    static spawn(model: string, position?: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, scale?: number | Vector3, physics?: string, virtualWorld?: number): Prop;
 
     /**
      * Lists every prop the server currently has.
@@ -3536,7 +3985,7 @@ declare global {
    */
   class LevelEdit {
     /**
-     * Wraps an edit the server already holds; use LevelEdit.apply or LevelEdit.applyMap to make one.
+     * Wraps an edit the server already holds; use LevelEdit.apply to make one, or WorldResource for a whole export.
      * @param id Network entity identifier.
      */
     constructor(id: number);
@@ -3620,14 +4069,6 @@ declare global {
      */
     static apply(definition: LevelEditDefinition, virtualWorld?: number): LevelEdit;
 
-    /**
-     * Applies every entry of a map's `world` array, which is how edits made in the World Builder reach every player instead of being loaded by hand on each.
-     * @param map A World Builder map saved from the editor, as its JSON text or the parsed object. Only its `world` array is read: its placed objects are `Prop.spawn`'s, its areas `Area.create`'s.
-     * @param virtualWorld Optional virtual world whose players see the edits; the global one when omitted.
-     * @returns One edit per entry, in the map's order. Throws, naming the entry, for one no client could find the object by.
-     */
-    static applyMap(map: string | Record<string, unknown>, virtualWorld?: number): LevelEdit[];
-
     /**
      * Lists every edit the server currently has.
      * @param virtualWorld Optional virtual world to list; omitted lists every one of them.
@@ -3666,7 +4107,7 @@ declare global {
     readonly soul: string;
 
     /**
-     * Entity class the body is spawned as -- `NPC` or `NPC_Female`.
+     * Native entity class, including `NPC`, `NPC_Female`, or the matching animal class from `Npc.animals()`.
      */
     readonly actorClass: string;
 
@@ -3686,7 +4127,7 @@ declare global {
     faction: number;
 
     /**
-     * The server's ledger of this body's health, clamped to `maxHealth`. Damage from players arrives here after the server has agreed to it.
+     * The server's ledger of this body's health, clamped to `maxHealth`. Combat damage arrives here after the server has agreed to it.
      */
     health: number;
 
@@ -3731,10 +4172,15 @@ declare global {
     locomotion: string;
 
     /**
-     * What the NPC has been told to do: `hold`, `moveTo`, `follow`, `flee`, `lookAt`, `playAnim` or `talk`.
+     * What the NPC has been told to do: `hold`, `moveTo`, `follow`, `flee`, `lookAt`, `playAnim`, `talk` or `attack`.
      */
     readonly intent: string;
 
+    /**
+     * Current patrol snapshot and progress, or null when not patrolling. Updating a route does not change a running patrol.
+     */
+    readonly patrolState: PatrolState | null;
+
     /**
      * What has become of the current order: `idle`, `running`, `reached`, `blocked` or `failed`. A move reads `running` from the moment it is given -- while its route is planned and while it walks the route's corners -- until it ends, and then the outcome `npcIntentDone` announced, which stays until the next order. A follow reads `reached` while it is within its radius. Dormant moves in `auto` or `server` mode are carried out and decided by the server; dormant `game` moves wait for a client simulator.
      */
@@ -3837,11 +4283,19 @@ declare global {
      * Walks the waypoints in order. The server stores the route and replicates the current target. `npcIntentDone` fires once per leg, after its final mesh corner or a movement failure.
      * 
      * A leg that ends `blocked` or `failed` is skipped after at least 2 seconds. When every leg of a lap has failed in a row, the patrol is abandoned and that last leg reports `failed` instead.
-     * @param points The waypoints, in order.
-     * @param options `loop` defaults to true; `waitSeconds` is the wait at each waypoint, 0 to 3600 (default 0); `speed` defaults to `walk`. `pathfinding` uses the modes documented for `moveTo` and applies to every leg.
+     * @param points Waypoints, a named route handle, or its stable id. Named routes are copied at start.
+     * @param options Point arrays retain their defaults: loop, walk, zero wait. Named routes use their authored defaults. Call options override route defaults; waypoint overrides take priority. Use mode for once, loop or pingPong; do not combine mode and loop. radius is the arrival distance. pathfinding uses the moveTo modes for every leg.
      * @returns True when the route was accepted; false for an empty route, more than 256 waypoints, a waypoint that is not finite or lies outside the world, or a `waitSeconds` that is not a number. Throws if server mode has no loaded mesh, leaving the previous order intact.
      */
-    patrol(points: (Vector3 | Partial<Vector3>)[], options?: { speed?: 'walk' | 'jog' | 'run'; loop?: boolean; waitSeconds?: number; pathfinding?: 'auto' | 'game' | 'server' }): boolean;
+    patrol(points: (Vector3 | Partial<Vector3>)[] | PatrolRoute | string, options?: { speed?: 'walk' | 'jog' | 'run'; loop?: boolean; mode?: 'once' | 'loop' | 'pingPong'; radius?: number; waitSeconds?: number; pathfinding?: 'auto' | 'game' | 'server' }): boolean;
+
+    /**
+     * Orders native combat against a live player or NPC in the same visible world within 128 metres. Another order stops it. The order fails when its target dies, disappears or leaves that range. It waits while dormant; no offline damage is simulated. Bow attacks stop within 18 metres and use native projectiles. Equipped NPC arrows are replenished while shooting.
+     * @param target The combatant to pursue and attack.
+     * @param options Defaults to melee. Bow requires an equipped bow and compatible arrows.
+     * @returns True when accepted. Invalid targets leave the previous order unchanged.
+     */
+    attack(target: Player | Npc | number, options?: { weapon?: "melee" | "bow" }): boolean;
 
     /**
      * Keeps the NPC near somebody as they move, steering straight at them. `npcIntentDone` reports `reached` the first time it catches up, and the follow carries on. If the body reports `blocked`, a loaded mesh lets the server route to the target's current position before reporting it. After recovery it resumes following the moving target.
@@ -3967,7 +4421,7 @@ declare global {
      * Spawns an NPC and replicates it. It exists on the server from this moment: every client near enough makes a body for it, one of them is elected to run it, and the rest draw what that one reports.
      * 
      * The body is not simulated until somebody is close enough to run it, which is not a failure -- a guard on the other side of the map has nothing to do that anybody can see. Read `simulator` to tell.
-     * @param options `soul` is a role name from `Npc.roles()` or a soul GUID; `position` is where to put it. Everything else has a default.
+     * @param options `soul` is a role from `Npc.roles()`, an animal name from `Npc.animals()`, or a soul GUID; `position` is where to put it. Everything else has a default.
      * @returns The new NPC's handle.
      */
     static create(options: { soul?: string; class?: string; name?: string; outfit?: string; wearing?: string[]; appearance?: Partial<Appearance>; position?: Vector3 | Partial<Vector3>; rotation?: Quaternion | Vector3 | Partial<Vector3>; faction?: number; health?: number; maxHealth?: number; locomotion?: 'kinematic' | 'native'; invulnerable?: boolean; frozen?: boolean; interactable?: boolean; nametag?: boolean; lootable?: boolean; virtualWorld?: number }): Npc;
@@ -4002,14 +4456,175 @@ declare global {
     static removeAll(virtualWorld?: number): number;
 
     /**
-     * The named kinds of NPC this build ships -- `guard`, `bandit`, `townswoman` and the rest. Each is a real soul out of the game's own tables, so a role spawns a body that already looks the part. Anything not in this list is taken as a soul GUID.
+     * The named kinds of NPC this build ships -- `guard`, `bandit`, `townswoman` and the rest. Each is a real soul out of the game's own tables, so a role spawns a body that already looks the part. Animal names are listed separately by `Npc.animals()`. Other values are taken as soul GUIDs.
      * @returns The role names.
      */
     static roles(): string[];
+
+    /**
+     * Animal souls with matching native classes. Pass a name or soul to Npc.create. Chickens use flock entities and are excluded.
+     */
+    static animals(): { name: string; soul: string; actorClass: string }[];
+
+    /**
+     * Level-authored animal spawners. Positions are markers and must be projected onto navigation. GUIDs are hex strings. Counts and respawn days describe the original game; scripts decide their population and respawn policy.
+     * @param level Defaults to the running server's level. Pass * for all levels.
+     */
+    static animalSpawnpoints(level?: string): { level: string; guid: string; name: string; layer: string; soul: string; actorClass: string; position: Vector3; count: number; respawnDays: number; spawnInFlock: boolean; spawnAreaGuid: string }[];
   }
 
   interface Npc extends Entity {}
 
+  /**
+   * One authored stop, independent of actor type.
+   */
+  interface PatrolPoint {
+    /**
+     * World-space waypoint.
+     */
+    position: Vector3;
+
+    /**
+     * Overrides the route and call speed for this leg.
+     */
+    speed?: 'walk' | 'jog' | 'run' | undefined;
+
+    /**
+     * Wait after arrival, 0 to 3600 seconds.
+     */
+    waitSeconds?: number | undefined;
+
+    /**
+     * Arrival radius in metres.
+     */
+    radius?: number | undefined;
+  }
+
+  /**
+   * The format saved by World Builder and accepted by PatrolRoute.create.
+   */
+  interface PatrolRouteDefinition {
+    /**
+     * Stable globally unique id, up to 128 bytes. Use a namespace such as town.guard-loop.
+     */
+    id: string;
+
+    /**
+     * Display name, up to 256 bytes.
+     */
+    name?: string | undefined;
+
+    /**
+     * 1 to 256 ordered waypoints.
+     */
+    points: PatrolPoint[];
+
+    /**
+     * Defaults to loop. Ping-pong visits each endpoint once per turn.
+     */
+    mode?: 'once' | 'loop' | 'pingPong' | undefined;
+
+    /**
+     * Default leg speed; walk when omitted.
+     */
+    speed?: 'walk' | 'jog' | 'run' | undefined;
+
+    /**
+     * Default arrival wait, 0 to 3600; defaults to zero.
+     */
+    waitSeconds?: number | undefined;
+
+    /**
+     * Default arrival radius; 1.5 metres when omitted.
+     */
+    radius?: number | undefined;
+  }
+
+  /**
+   * A running patrol's snapshot. Indices and laps start at zero.
+   */
+  interface PatrolState {
+    /**
+     * Stable route id; null for an anonymous point-array patrol.
+     */
+    routeId: string | null;
+
+    /**
+     * Target waypoint index.
+     */
+    waypointIndex: number;
+
+    /**
+     * Completed loops or round trips.
+     */
+    lap: number;
+
+    /**
+     * 1 forward, -1 backward.
+     */
+    direction: number;
+
+    /**
+     * Whether the actor is approaching or waiting at the waypoint.
+     */
+    phase: 'moving' | 'waiting';
+  }
+
+  /**
+   * Named patrol definition. Actors snapshot it when ordered; update or destroy affects future starts.
+   */
+  class PatrolRoute {
+    private constructor();
+
+    /**
+     * False after destruction.
+     */
+    readonly exists: boolean;
+
+    /**
+     * Stable id; empty after destruction.
+     */
+    readonly id: string;
+
+    /**
+     * Display name.
+     */
+    readonly name: string;
+
+    /**
+     * Returns an independent definition, or null after destruction.
+     */
+    toJSON(): PatrolRouteDefinition | null;
+
+    /**
+     * Removes the definition. Active patrols keep their snapshots.
+     */
+    destroy(): boolean;
+
+    /**
+     * Updates defaults or waypoints atomically. Invalid input throws; a destroyed handle returns false.
+     * @param changes Fields to replace; id cannot change.
+     */
+    update(changes: Partial<PatrolRouteDefinition>): boolean;
+
+    /**
+     * Registers a route. Invalid data or a duplicate id throws.
+     * @param definition The route to register.
+     */
+    static create(definition: PatrolRouteDefinition): PatrolRoute;
+
+    /**
+     * Looks up a registered route.
+     * @param id Exact route id.
+     */
+    static getById(id: string): PatrolRoute | null;
+
+    /**
+     * Lists registered routes in creation order.
+     */
+    static all(): PatrolRoute[];
+  }
+
   /**
    * Replicated journal quest handle.
    */
@@ -4311,65 +4926,147 @@ declare global {
    */
   interface GatheringProposal {
     /**
-     * Item class GUID of the herb.
+     * Item class GUID of the herb.
+     */
+    item: string;
+
+    /**
+     * How many, as the game computes it from the player's survival level and the plants harvested together.
+     */
+    amount: number;
+
+    /**
+     * The game's pickable area id for the plant.
+     */
+    kind: number;
+
+    /**
+     * Where the plant grows, as the player's game reported it.
+     */
+    position: number[];
+
+    /**
+     * The player's virtual world.
+     */
+    virtualWorld: number;
+  }
+
+  /**
+   * A plant a player picked, and what they were given.
+   */
+  interface GatheringHarvestedEvent {
+    /**
+     * Item class GUID of the herb.
+     */
+    item: string;
+
+    /**
+     * How many.
+     */
+    amount: number;
+
+    /**
+     * The game's pickable area id for the plant.
+     */
+    kind: number;
+
+    /**
+     * Where the plant grows.
+     */
+    position: number[];
+
+    /**
+     * The player's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * The inventory rows that received the herb.
+     */
+    items: InventoryUnit[];
+  }
+
+  /**
+   * A frozen snapshot of one stew pot in one virtual world.
+   */
+  interface CookPotSnapshot {
+    /**
+     * The fireplace's level GUID.
+     */
+    guid: string;
+
+    /**
+     * Position of the eating trigger.
+     */
+    position: { readonly x: number; readonly y: number; readonly z: number };
+
+    /**
+     * Unreserved meals remaining.
      */
-    item: string;
+    portions: number;
 
     /**
-     * How many, as the game computes it from the player's survival level and the plants harvested together.
+     * Portions in the most recent refill; sets the halfway point.
      */
-    amount: number;
+    capacity: number;
 
     /**
-     * The game's pickable area id for the plant.
+     * Whether eating is allowed. Disabling preserves the contents.
      */
-    kind: number;
+    enabled: boolean;
 
     /**
-     * Where the plant grows, as the player's game reported it.
+     * Visible food level, derived from remaining portions.
      */
-    position: number[];
+    state: "empty" | "half" | "full";
 
     /**
-     * The player's virtual world.
+     * Virtual world that owns this stock.
      */
     virtualWorld: number;
   }
 
   /**
-   * A plant a player picked, and what they were given.
+   * Server-owned stew pots. Stocked pots begin with four shared meals, with no automatic refill. State lasts until the server stops.
    */
-  interface GatheringHarvestedEvent {
-    /**
-     * Item class GUID of the herb.
-     */
-    item: string;
-
+  const CookPot: {
     /**
-     * How many.
+     * Lists every catalogued pot on the server's level in one virtual world; empty for a world no player or write has used yet.
+     * @param virtualWorld Virtual world id; defaults to 0. The global visibility sentinel is not a stock world.
      */
-    amount: number;
+    all(virtualWorld?: number): CookPotSnapshot[];
 
     /**
-     * The game's pickable area id for the plant.
+     * Returns a snapshot, or null for an unknown pot.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param virtualWorld Virtual world id; defaults to 0. The global visibility sentinel is not a stock world.
      */
-    kind: number;
+    get(guid: string, virtualWorld?: number): CookPotSnapshot | null;
 
     /**
-     * Where the plant grows.
+     * Replaces remaining stock and capacity, preserving enabled. Returns false for an unknown pot.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param portions Integer from 0 to 1000; defaults to four.
+     * @param virtualWorld Virtual world id; defaults to 0. The global visibility sentinel is not a stock world.
      */
-    position: number[];
+    refill(guid: string, portions?: number, virtualWorld?: number): boolean;
 
     /**
-     * The player's virtual world.
+     * Allows or blocks eating. Returns false for an unknown pot.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param enabled False blocks eating without changing stock or its appearance.
+     * @param virtualWorld Virtual world id; defaults to 0. The global visibility sentinel is not a stock world.
      */
-    virtualWorld: number;
+    setEnabled(guid: string, enabled: boolean, virtualWorld?: number): boolean;
 
     /**
-     * The inventory rows that received the herb.
+     * Changes food level and stock together, preserving enabled. Returns false for an unknown pot.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param state Empty, two portions, or four portions; resets capacity to four.
+     * @param virtualWorld Virtual world id; defaults to 0. The global visibility sentinel is not a stock world.
      */
-    items: InventoryUnit[];
-  }
+    setState(guid: string, state: "empty" | "half" | "full", virtualWorld?: number): boolean;
+  };
 
   /** */
   interface NearestDoor {
@@ -4557,7 +5254,7 @@ declare global {
   }
 
   /**
-   * Replicated handle for one of the level's animated gates.
+   * Replicated handle for one of the level's castle gates.
    */
   class Gate {
     /**
@@ -4567,12 +5264,12 @@ declare global {
     constructor(id: number);
 
     /**
-     * The level's own EntityGuid, as sixteen lowercase hex digits. The same on every machine, so it is the identity to store a gate under; `Gate.find` takes it back.
+     * The level's own EntityGuid, as sixteen lowercase hex digits. The same on every machine, so it is the identity to store a gate under; `Gate.find` takes it back. A `gate` has no entity of its own, so its key is the GUID of the layer that draws it shut.
      */
     readonly guid: string;
 
     /**
-     * What piece of architecture this is: `drawbridge` or `portcullis`. The shipped game has two in total.
+     * What piece of architecture this is: `drawbridge` or `portcullis`, which animate, or `gate`, a pair of leaves the level swaps between drawn open and drawn shut -- the Ratborsch and Nebakov fortress gates and the Ruthard palace gate. A `gate` opens and closes at once.
      */
     readonly kind: string;
 
@@ -4592,7 +5289,7 @@ declare global {
     readonly moving: boolean;
 
     /**
-     * How long opening takes, in seconds, from the key range the asset's animation database stores. A gate with no opening clip runs its closing one backwards, so this is that clip's length.
+     * How long opening takes, in seconds, from the key range the asset's animation database stores. A gate with no opening clip runs its closing one backwards, so this is that clip's length. 0 for a `gate`.
      */
     readonly openDuration: number;
 
@@ -4706,12 +5403,12 @@ declare global {
     damageRadius: number;
 
     /**
-     * Whether players within 12 m of the engine get the game's own action hint for it on the use key: Load while it is idle, Fire while it is loaded. A press raises `siegeEngineUse`, and unless a handler refuses it the engine loads, or fires along the player's facing at `range`. Off by default.
+     * Whether players may work the engine. A player within 2 m of an empty one gets the game's own action hint on the use key to take its place, and becomes its `operator`; near a trebuchet with a `crewRequired`, a free winch is offered too. Each ask raises `siegeEngineUse` first, which may refuse it. Off by default.
      */
     usable: boolean;
 
     /**
-     * How far a shot fired from the native prompt goes along the player's facing, in metres; kept between `minRange` and `maxRange`. 150 for a trebuchet and 120 for a cannon to start with.
+     * How far a shot goes along the operator's facing when they fire before laying the engine anywhere, in metres; kept between `minRange` and `maxRange`. 150 for a trebuchet and 120 for a cannon to start with.
      */
     range: number;
 
@@ -4730,6 +5427,46 @@ declare global {
      */
     readonly loadDuration: number;
 
+    /**
+     * What the engine can take before it is wrecked; 0, the default, means nothing harms it. Setting it heals the engine to the new maximum and repairs a wreck. A blast within `damageRadius` of an engine -- any engine's, its own included -- takes its share of that shot's `damage` off it, raising `siegeEngineDamage`.
+     */
+    maxHealth: number;
+
+    /**
+     * What is left of `maxHealth`. Setting it to 0 wrecks the engine and raising it from 0 repairs one; ignored while `maxHealth` is 0.
+     */
+    health: number;
+
+    /**
+     * Whether the engine's health ran out. A wrecked cannon shows the game's broken gun and a wrecked trebuchet leans and settles; nothing loads, aims or fires it, and its operator and crew are let go, until `repair` or a new `maxHealth`.
+     */
+    readonly wrecked: boolean;
+
+    /**
+     * Shots left to load; each `load` takes one, and an engine with none refuses to load. -1, the default, never runs out; any negative value means the same.
+     */
+    ammo: number;
+
+    /**
+     * How many of the engine's winches must be manned for its arm to be winched down; 0, the default, winds it by itself. With fewer hands than this the winding holds where it is, and goes on when they come back. Players near a usable engine that needs them are offered its winches, and each one there plays the game's own pull. Kept to `crewPlaces`.
+     */
+    crewRequired: number;
+
+    /**
+     * How many winches the engine has: 2 on a trebuchet, 0 on a cannon.
+     */
+    readonly crewPlaces: number;
+
+    /**
+     * The player in the engine's place, or null. They lay it where they look while they hold the block key, load it with the torch key, fire it with the attack key and step away with the use key; walking off lets go of it too. `setOperator` puts somebody there.
+     */
+    readonly operator: Player | null;
+
+    /**
+     * Who mans each winch, in place order, with null for an empty one.
+     */
+    readonly crew: (Player | null)[];
+
     /**
      * Formats this engine handle for logging and debugging.
      * @returns The engine ID, its kind and where it is in its cycle.
@@ -4743,7 +5480,7 @@ declare global {
     load(): SiegeResult;
 
     /**
-     * Turns a loaded engine to face the target and shoots at it. A trebuchet's arm lets the stone go at one angle, so its speed is solved for the distance; a cannon fires at one speed, so its elevation is. The stone is let go partway through the shot (`seconds`), then every client nearby draws it along the same arc. It comes down where the world stops it, which the player nearest the target is asked to report, or on the target when nobody can.
+     * Turns a loaded engine to face the target and shoots at it. A trebuchet's arm lets the stone go at one angle, so its speed is solved for the distance; a cannon fires at one speed, so its elevation is. The stone is let go partway through the shot (`seconds`), then every client nearby draws it along the same arc. It comes down where the world stops it, which the attacker is asked to report when near enough, else the player nearest the target, or on the target when nobody can.
      * @param target Where the projectile should come down.
      * @param attacker The player credited with whatever it hits, in `playerDamage`, `npcDamage` and `siegeImpact`.
      * @returns What happened, and the phrase to explain it with when nothing did.
@@ -4764,6 +5501,30 @@ declare global {
      */
     canHit(target: Vector3 | Partial<Vector3>): string;
 
+    /**
+     * Shows or hides the operator's aim guide: a translucent red beam along the shot's path -- out of a trebuchet's sling and along its arc, or straight from a cannon's muzzle -- to where it would come down, with a ball there. Off by default, which leaves laying the engine to the eye; the Fire hint says how far the shot goes either way.
+     * @param enabled Whether the operator sees the beam.
+     */
+    setAimGuide(enabled: boolean): void;
+
+    /**
+     * Whether the operator sees the aim guide; see `setAimGuide`.
+     * @returns True when the beam is shown.
+     */
+    getAimGuide(): boolean;
+
+    /**
+     * Makes the engine whole again: `health` back to `maxHealth`, and a wreck idle and unloaded.
+     */
+    repair(): void;
+
+    /**
+     * Puts a player in the engine's place without asking them, or takes whoever is there out of it. A player holds one place at a time, so they leave any other engine or winch first. Raises no `siegeEngineUse`.
+     * @param player Who takes the engine's place, or null to empty it.
+     * @returns False for a player who is no longer connected.
+     */
+    setOperator(player: Player | null): boolean;
+
     /**
      * Removes the engine on every client after emitting `siegeEngineDestroy`. A projectile already in the air still lands.
      */
@@ -5091,6 +5852,76 @@ declare global {
     static all(kind?: 'level' | 'script'): Area[];
   }
 
+  /**
+   * A named world export loaded from mod.world_resources. Server-owned, with live access to its surviving props, effects, level edits, areas and patrol routes. Obtain handles through all or find; runtime loading, reloading and unloading are not exposed.
+   */
+  class WorldResource {
+    private constructor();
+
+    /**
+     * Unique case-sensitive resource name: the filename without .world.json, or the explicit config name. Empty after shutdown.
+     */
+    readonly name: string;
+
+    /**
+     * Resolved absolute source file path, in UTF-8. Empty after shutdown.
+     */
+    readonly path: string;
+
+    /**
+     * The exported game level, checked against the server level at startup. Empty after shutdown.
+     */
+    readonly level: string;
+
+    /**
+     * Whether this export is registered. Remains true even if scripts destroy all of its contents.
+     */
+    readonly loaded: boolean;
+
+    /**
+     * A fresh array of surviving props in export order. Changing the array does not change membership; the handles support normal Prop operations.
+     */
+    readonly props: Prop[];
+
+    /**
+     * A fresh array of surviving effects in export order, excluding destroyed effects.
+     */
+    readonly effects: Vfx[];
+
+    /**
+     * A fresh array of surviving level edits in export order, excluding restored edits.
+     */
+    readonly levelEdits: LevelEdit[];
+
+    /**
+     * A fresh array of surviving exported areas in export order, excluding destroyed areas.
+     */
+    readonly areas: Area[];
+
+    /**
+     * Surviving exported patrol definitions, in export order.
+     */
+    readonly patrolRoutes: PatrolRoute[];
+
+    /**
+     * True after every configured export has loaded successfully, even when the config list is empty. Check this before subscribing to worldResourcesReady when a script may start later.
+     */
+    static readonly ready: boolean;
+
+    /**
+     * Lists config-loaded world exports in configuration order. Empty before successful startup and after shutdown.
+     * @returns A fresh array of resource handles.
+     */
+    static all(): WorldResource[];
+
+    /**
+     * Finds a config-loaded export by name. Throws for a non-string argument.
+     * @param name Exact, case-sensitive resource name.
+     * @returns The resource, or null when absent or startup has not completed.
+     */
+    static find(name: string): WorldResource | null;
+  }
+
   /**
    * Container handle for a spawned chest, a level chest, or virtual stock without a world entity.
    */
@@ -5624,7 +6455,7 @@ declare global {
   /**
    * Queries the level's navigation mesh on the server. The mesh includes walkable floors, bridges and stairs.
    * 
-   * Copy the game's `Data/Levels/<level>/recast.pak` to the server's `files/<level>/` directory. The server searches `files/` recursively at startup. An optional `mod.navmesh` in `server.json` takes priority and can name a game install, level folder or pak file. The game data must be supplied separately. Without a mesh, `ready` is false and geometry queries return null or false. Points are world-space metres, Z up. Every query takes an optional options object. `searchRadius` and `searchHeight` limit how far a point may be from the mesh, across the ground and up or down: 2 metres by default, up to 64, and 4 by default, up to 128. Keep `searchHeight` under a storey's height, or a point on one floor snaps to the floor above. `doors` picks which doors a query walks through: `unlocked`, the default, is how an NPC treats a door -- open or shut, it goes through unless the door is locked; `open` only through doors that stand open; `any` ignores locks; `none` treats every doorway as a wall. A door's state is read off the door in the global world. A field given with the wrong type or out of range throws.
+   * Copy the game's `Data/Levels/<level>/recast.pak` to the server's `files/<level>/` directory. The server searches `files/` recursively at startup. An optional `mod.navmesh` in `server.json` takes priority and can name a game install, level folder or pak file. The game data must be supplied separately. Without a mesh, `ready` is false and geometry queries return null or false. Points are world-space metres, Z up. Every query takes an optional options object. `searchRadius` and `searchHeight` limit how far a point may be from the mesh, across the ground and up or down: 2 metres by default, up to 64, and 4 by default, up to 128. Keep `searchHeight` under a storey's height, or a point on one floor snaps to the floor above. `doors` picks which doors a query walks through: `unlocked`, the default, is how an NPC treats a door -- open or shut, it goes through unless the door is locked; `open` only through doors that stand open; `any` ignores locks; `none` treats every doorway as a wall. Door states are read in the global world, except validatePatrol with an actor, which uses that actor's world. A field given with the wrong type or out of range throws.
    */
   const Navigation: {
     /**
@@ -5642,6 +6473,13 @@ declare global {
      */
     readonly activeOverlays: string[];
 
+    /**
+     * Checks all legs, including the closing leg of a loop and reverse legs of ping-pong. Uses the patrol runner's search budget. A single waypoint is checked against itself. Missing mesh reports available false; partial paths are incomplete. This does not start or change an actor's order.
+     * @param route A registered route or its id.
+     * @param options Optional actor chooses door policy in its virtual world: unlocked doors for humanoids, no doorways for horses and animals.
+     */
+    validatePatrol(route: PatrolRoute | string, options?: { actor?: Npc | Horse }): { available: boolean; complete: boolean; legs: { fromIndex: number; toIndex: number; complete: boolean; path: NavigationPath | null }[] };
+
     /**
      * Snaps a point to the nearest walkable surface.
      * @param point The point to snap; omitted components default to zero.
@@ -7027,6 +7865,16 @@ declare global {
      * True in the authoritative server scripting runtime.
      */
     readonly isServer: boolean;
+
+    /**
+     * Local Framework release version.
+     */
+    readonly frameworkVersion: string;
+
+    /**
+     * Local mod version from InstanceOptions.modVersion; empty when unset.
+     */
+    readonly modVersion: string;
   };
 
   /**
@@ -7289,6 +8137,8 @@ declare global {
    * Arbitrary key/value state attached to one replicated entity, reached as `entity.state`. Keys set on the server replicate to every client that can currently see the entity.
    */
   class StateBag {
+    private constructor();
+
     /**
      * Reads one key from this entity's state.
      * @param key Key to read.
@@ -7438,7 +8288,7 @@ declare global {
 
     /**
      * Overrides the text drawn on this player's nametag.
-     * @param text Text to show instead of the player's name; empty or omitted restores the name.
+     * @param text Text to show instead of the player's name, cut to 64 bytes; empty or omitted restores the name.
      */
     setNametagText(text?: string): void;
 
@@ -7451,6 +8301,219 @@ declare global {
 
   interface BasePlayer extends Entity {}
 
+  /** */
+  interface SiegeLadderKind {
+    /**
+     * Its name: `siege`, `tall`, `short` or `low`.
+     */
+    kind: string;
+
+    /**
+     * The mesh it stands as, a path from the shared prop catalog.
+     */
+    model: string;
+
+    /**
+     * How far up its rungs go, in metres.
+     */
+    height: number;
+
+    /**
+     * How far it leans towards the wall standing, in degrees about its own X; it leans towards its forward.
+     */
+    lean: number;
+  }
+
+  /**
+   * Replicated handle for a siege ladder leaning on a wall.
+   */
+  class SiegeLadder {
+    /**
+     * Creates a script wrapper for an existing siege ladder with this ID; use SiegeLadder.spawn() to place one.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * Which of the game's ladders it is: `siege` (the Suchdol siege ladder, 9.75 m), `tall` (5.5 m), `short` (3.25 m) or `low` (2 m).
+     */
+    readonly kind: string;
+
+    /**
+     * `standing` against its wall, `pushed` (a defender's swing, then its fall), `down`, `raising` or `broken`. Named `pose` because every entity already has a `state`, which is its state bag.
+     */
+    readonly pose: string;
+
+    /**
+     * How far up its rungs go, in metres: its top rests this high above its foot on the wall's top. Pick the kind whose height meets the walk.
+     */
+    readonly height: number;
+
+    /**
+     * Whether the game's own climb is offered on it: while it stands and nobody has started to push it.
+     */
+    readonly climbable: boolean;
+
+    /**
+     * Whether players are offered the push at its top and the raise at the foot of a fallen one, each raising `siegeLadderUse` first. On by default. The climb is the game's and is offered whenever the ladder stands.
+     */
+    usable: boolean;
+
+    /**
+     * Who last pushed it, or null.
+     */
+    readonly pusher: Player | null;
+
+    /**
+     * Formats this ladder handle for logging and debugging.
+     * @returns The ladder ID, its kind and its pose.
+     */
+    toString(): string;
+
+    /**
+     * Pushes a standing ladder off its wall. It stands through the swing, falls away from the wall as the blade meets it -- throwing off anyone climbing it -- and lies where it lands, about 4.5 seconds later.
+     * @param player Who pushes it: they play the game's own halberd push, and are credited with it in `siegeLadderFall`.
+     * @returns What happened, and the phrase to explain it with when nothing did.
+     */
+    push(player?: Player | number | null): SiegeResult;
+
+    /**
+     * Lays a fallen ladder back against its wall, over the lift's 5.7 seconds.
+     * @param player Who raises it: they play the game's own ladder lift.
+     * @returns What happened, and the phrase to explain it with when nothing did.
+     */
+    raise(player?: Player | number | null): SiegeResult;
+
+    /**
+     * Breaks the ladder: it lies in pieces where it stands, anyone on it falls, and nothing raises it until `repair`.
+     */
+    break(): void;
+
+    /**
+     * Puts a fallen or broken ladder back against its wall at once.
+     */
+    repair(): void;
+
+    /**
+     * Removes the ladder on every client after emitting `siegeLadderDestroy`.
+     */
+    destroy(): void;
+
+    /**
+     * Places one of the game's own ladders leaning on a wall, the way the Suchdol and Nebakov sieges stand theirs: the game's climb, and the game's step off over the palisade at its top, which wants the top a little over the walk.
+     * @param kind `siege`, `tall`, `short` or `low`.
+     * @param position Where its foot stands, on the ground below the wall.
+     * @param rotation Its facing: forward is the way to the wall it leans on. A Quaternion, or a Vector3 of Euler angles in degrees.
+     * @param virtualWorld Optional virtual world the ladder belongs to; omitted puts it in the global one.
+     * @returns The new ladder's handle.
+     */
+    static spawn(kind: string, position: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, virtualWorld?: number): SiegeLadder;
+
+    /**
+     * What one kind of ladder is: its mesh, its climb and its lean -- what a placement preview needs to show it as it will stand.
+     * @param kind `siege`, `tall`, `short` or `low`.
+     * @returns The kind, or null for a name that is not one.
+     */
+    static describe(kind: string): SiegeLadderKind | null;
+
+    /**
+     * Lists the siege ladders the server has.
+     * @param virtualWorld Optional virtual world to list; omitted lists every one.
+     * @returns One handle per ladder, in no particular order.
+     */
+    static all(virtualWorld?: number): SiegeLadder[];
+
+    /**
+     * Looks a ladder up by its network entity ID.
+     * @param id Network entity identifier.
+     * @returns The ladder's handle, or null when no live ladder has that ID.
+     */
+    static getById(id: number): SiegeLadder | null;
+
+    /**
+     * Removes siege ladders, emitting `siegeLadderDestroy` for each one.
+     * @param virtualWorld Optional virtual world to clear; omitted clears every one.
+     * @returns How many were removed.
+     */
+    static destroyAll(virtualWorld?: number): number;
+  }
+
+  interface SiegeLadder extends Entity {}
+
+  /**
+   * Replicated handle for a pile of hurling stones on a battlement.
+   */
+  class StonePile {
+    /**
+     * Creates a script wrapper for an existing stone pile with this ID; use StonePile.spawn() to place one.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * Stones left to throw; each throw takes one, and a pile with none offers nothing. Players see at most nine in the heap. -1, the default, never runs out; any negative value means the same.
+     */
+    stones: number;
+
+    /**
+     * Whether players are offered the game's own prompt at the pile. On by default.
+     */
+    usable: boolean;
+
+    /**
+     * Health taken from anyone at the point a stone comes down, up to 1000; a quarter of it reaches the edge of `damageRadius`. 60 to start with; a player has 100.
+     */
+    damage: number;
+
+    /**
+     * How far from where a stone comes down anyone is hurt, in metres, up to 10. 1.5 to start with.
+     */
+    damageRadius: number;
+
+    /**
+     * Formats this pile handle for logging and debugging.
+     * @returns The pile ID and the stones it has left.
+     */
+    toString(): string;
+
+    /**
+     * Removes the pile on every client after emitting `stonePileDestroy`. A stone already thrown still lands.
+     */
+    destroy(): void;
+
+    /**
+     * Places the game's own battlement pile of hurling stones, the Nebakov and Suchdol defenders' heap. Its prompt, the lift and the heave over the wall are the game's stone throwing; each stone is a real rigid body that falls where it falls.
+     * @param position Where the thrower stands on the walk, behind the parapet.
+     * @param rotation Its facing: forward is the way the stones go, over the wall. A Quaternion, or a Vector3 of Euler angles in degrees.
+     * @param virtualWorld Optional virtual world the pile belongs to; omitted puts it in the global one.
+     * @returns The new pile's handle.
+     */
+    static spawn(position: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, virtualWorld?: number): StonePile;
+
+    /**
+     * Lists the stone piles the server has.
+     * @param virtualWorld Optional virtual world to list; omitted lists every one.
+     * @returns One handle per pile, in no particular order.
+     */
+    static all(virtualWorld?: number): StonePile[];
+
+    /**
+     * Looks a pile up by its network entity ID.
+     * @param id Network entity identifier.
+     * @returns The pile's handle, or null when no live pile has that ID.
+     */
+    static getById(id: number): StonePile | null;
+
+    /**
+     * Removes stone piles, emitting `stonePileDestroy` for each one.
+     * @param virtualWorld Optional virtual world to clear; omitted clears every one.
+     * @returns How many were removed.
+     */
+    static destroyAll(virtualWorld?: number): number;
+  }
+
+  interface StonePile extends Entity {}
+
   /**
    * Calls a function once after a delay.
    * @param handler Function to call.