@kingdomsconnected/types 1.6.4 → 1.6.6

package/generated/server-api.d.ts

@@ -120,6 +120,36 @@ declare global {
      */
     playerReady: [player: Player];
 
+    /**
+     * After the server receives changed player stats, including poison strength, drunkenness, health loss and potion-related readings. Changes are snapshots batched per server tick. The first valid report and each new body establish a baseline. These are observations, not cancellable requests; the client can coalesce intermediate values. No cause is inferred. Use consumption vetoes and custom server effects to decide gameplay before it happens.
+     */
+    playerStatsChanged: [player: Player, changes: { stat: "health" | "stamina" | "exhaust" | "hunger" | "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"; previous: number; current: number }[]];
+
+    /**
+     * Before reserving a food or potion unit or pot serving. Return false synchronously to refuse without spending stock or applying effects. Async handlers cannot veto. Do not apply replacement effects here: native use can still fail.
+     */
+    playerConsuming: [player: Player, consumption: Consumption];
+
+    /**
+     * After playerConsuming accepts, before reservation. Return false synchronously to consume without native nutrition, energy, alcohol, potion, spoilage or added pot poison effects. Apply custom effects in playerConsumed using player.setStat, addBuff and clearBuffs.
+     */
+    playerConsumptionEffects: [player: Player, consumption: Consumption];
+
+    /**
+     * Before applying a reserved pot meal's additional poison on its eating receipt. Return false synchronously to suppress it. Runs only when nativeEffects is true. Native food spoilage and item buffs can be replaced through playerConsumptionEffects and Buffs.claim.
+     */
+    playerPoisonAbsorbing: [player: Player, consumption: Consumption, buff: string];
+
+    /**
+     * Once after the owning client confirms successful use. Use for custom stat changes and buffs after suppressing native effects. Missing receipts and expired or replaced bodies never raise it. Inventory uses also raise playerItemUsed.
+     */
+    playerConsumed: [player: Player, consumption: Consumption];
+
+    /**
+     * A validated custom-item action. The frozen row includes server-only data. Scripts decide what happens and explicitly consume items.
+     */
+    playerCustomItemUse: [player: Player, item: InventoryRow, revision: number];
+
     /**
      * An inventory changed. Raised on the next server tick in the order the changes happened, once per inventory an operation touched: a transfer raises it for both players. A handler may change inventories; those changes arrive on a later tick. Every change of a player who disconnects is raised before `playerDisconnect`. Save from here to keep inventories across sessions -- the server keeps nothing itself.
      */
@@ -231,6 +261,26 @@ declare global {
      */
     playerPickpocketCaught: [thief: Player, victim: Player];
 
+    /**
+     * A new turn begins, including turns after automatic busts.
+     */
+    diceTurnStart: [event: DiceProgressEvent];
+
+    /**
+     * The server dealt a roll. Includes all six face values and the mask rolled this time.
+     */
+    diceRoll: [event: DiceProgressEvent];
+
+    /**
+     * The server accepted Continue or Pass. Invalid or repeated requests emit nothing.
+     */
+    diceMove: [event: DiceProgressEvent];
+
+    /**
+     * A turn ended by banking, busting, winning, or a match ending. A round means one player's turn.
+     */
+    diceTurnEnd: [event: DiceProgressEvent];
+
     /**
      * Dispatched once a match has started and both players have been sent to the table. Which of them throws first is drawn at random.
      */
@@ -361,6 +411,21 @@ declare global {
      */
     npcSpawn: [npc: Npc];
 
+    /**
+     * Its initial inventory has been established. The default stock is censused once by its elected simulator; Inventory.set establishes authored stock immediately.
+     */
+    npcInventoryReady: [npc: Npc];
+
+    /**
+     * An accepted butchering completion. The prepopulated stock is now accessible and every client applies the butchered appearance. Emitted once per life; save Inventory.get(npc) here too to persist the harvested flag.
+     */
+    npcHarvested: [npc: Npc, player: Player];
+
+    /**
+     * Committed stock changes, including loot transfers. Save this stock and restore it with Inventory.set. Harvest completion is reported by npcHarvested.
+     */
+    npcInventoryChanged: [npc: Npc, change: InventoryChange];
+
     /**
      * Dispatched while an NPC is being despawned. The handle still resolves, so what it was and where it stood can be read one last time.
      */
@@ -468,6 +533,16 @@ declare global {
      */
     siegeEngineUse: [player: Player, engine: SiegeEngine, action: "operate" | "winch" | "leave" | "load" | "fire"];
 
+    /**
+     * 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 the moment an engine lets its projectile go, partway through the shot `fire` started.
      */
@@ -478,6 +553,51 @@ declare global {
      */
     siegeImpact: [engine: SiegeEngine | null, position: Vector3, 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];
+
     /**
      * Dispatched when a body comes to be inside an enabled area: it walked or rode in, or the area was created, moved, reshaped or enabled around it. The server decides this itself from the pose it already replicates, by the game's own rule for that kind of area, so a client cannot claim it. `matchingVirtualWorld` is false when a script area bound to one world is crossed by a body in another; a level area is in every world.
      */
@@ -619,61 +739,6 @@ 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. */
@@ -1400,6 +1465,11 @@ declare global {
      */
     readonly disguise: string | null;
 
+    /**
+     * Whether this player's body is drawn at all -- itself, what it wears and what it carries. True for everybody until something hides them. Published by their own client, so it follows `setVisible` once they have actually stopped drawing. A hidden player is only invisible: they still stand where they stand, still collide, can still be hit, and NPCs still see them.
+     */
+    readonly visible: boolean;
+
     /**
      * Whether this player's body has both a pose and a soul, which is what everyone else waits for before spawning a puppet for them. False for the first moments of a connection.
      */
@@ -1945,6 +2015,17 @@ declare global {
      */
     setDisguise(model: string | null): boolean;
 
+    /**
+     * Stops drawing this player's body, or draws it again -- on their own screen and on everybody else's. The body goes with everything on it: what it wears, the weapons on its back and belt, and whatever it is holding. It is state, like a disguise: somebody who streams in or joins sees nothing of a hidden player either, and it lasts until the next call or until they leave.
+     * 
+     * Nothing but the drawing changes. They stand where they stood, keep their collider, their soul and their weapons, so a hidden player still blocks a doorway, can still be hit and traced against, still fights and still dies -- and the NPCs around them never stopped seeing a person. Nametags are separate; `setNametagVisible` is the call for that.
+     * 
+     * Their own camera sits in their head, so a hidden player simply sees no arms in first person. The owning client is authoritative for its body, so this is a request that lands on their next frame; `player.visible` reads what they actually have.
+     * @param visible False to stop drawing this player's body, true to draw it again.
+     * @returns True when the request went out; false for a player with no connection to ask. Throws unless `visible` is a boolean.
+     */
+    setVisible(visible: boolean): boolean;
+
     /**
      * Takes this player out of whatever saddle they are in: their own client gets them off, and `horseDismount` is raised.
      * @returns The horse they were taken off, or null when they were not riding one.
@@ -2006,6 +2087,91 @@ declare global {
 
   interface Player extends BasePlayer {}
 
+  /**
+   * A server-validated serving. Item properties and pot poison come from server state; changing the snapshot does not change the decision.
+   */
+  interface Consumption {
+    /**
+     * Where the serving comes from.
+     */
+    source: "inventory" | "cookPot";
+
+    /**
+     * Native food or potion item class GUID.
+     */
+    item: string;
+
+    /**
+     * Native food type; potions use the game's food type 1.
+     */
+    kind: "food" | "potion";
+
+    /**
+     * Native table inputs before item condition, spoilage, perks or soul modifiers. Health effects may run over time. These are not promised final stat deltas. Null when the catalog has no row.
+     */
+    baseEffects: { buff: string | null; health: number; energy: number; nourishment: number; alcohol: number } | null;
+
+    /**
+     * Inventory row, or null for a pot meal.
+     */
+    rowId: string | null;
+
+    /**
+     * Cooking pot GUID, or null for an inventory item.
+     */
+    potGuid: string | null;
+
+    /**
+     * Server item properties, including condition. Empty for a pot meal.
+     */
+    metadata: Record<string, unknown>;
+
+    /**
+     * Additional cooking pot poison buff GUID, or null. Spoilage and the item's own effects are part of nativeEffects.
+     */
+    poison: string | null;
+
+    /**
+     * Whether native nutrition, energy, alcohol, potion and spoilage effects are allowed. Final in playerConsumed.
+     */
+    nativeEffects: boolean;
+  }
+
+  /**
+   * One candidate from the game's animal loot preset; probability and inventory population belong to the gamemode.
+   */
+  interface AnimalLootItem {
+    /**
+     * Item class GUID.
+     */
+    item: string;
+
+    /**
+     * Maximum authored unit count.
+     */
+    amount: number;
+
+    /**
+     * Authored quantity fraction, not a drop probability.
+     */
+    fraction: number;
+
+    /**
+     * Uniform variation around the quantity fraction.
+     */
+    variation: number;
+
+    /**
+     * The item is food.
+     */
+    food: boolean;
+
+    /**
+     * Tagged as a special Harvester part in the game data. This is metadata; the gamemode decides eligibility.
+     */
+    harvester: boolean;
+  }
+
   /**
    * A count of units from one row.
    */
@@ -2022,11 +2188,11 @@ declare global {
   }
 
   /**
-   * A stack of one item class with one set of properties. Two rows never hold the same class with equal properties unless a restore put them there.
+   * A stack of one item class with one set of properties. Two rows never hold the same class with equal properties unless a restore put them there. Stackable custom rows merge only with matching properties. Nonstackable custom rows each contain one unit.
    */
   interface InventoryRow {
     /**
-     * The row's identity within this player's inventory. Stable while the row exists; save it with the row and pass it back to `Inventory.set`.
+     * The row's identity within its owner's inventory. Stable while the row exists; save it with the row and pass it back to `Inventory.set`.
      */
     id: string;
 
@@ -2036,7 +2202,7 @@ declare global {
     item: string;
 
     /**
-     * The item's name in the game's own tables; not localized text.
+     * Internal table name, or Items.register id for a custom type. Display overrides are in metadata.custom.name.
      */
     name: string;
 
@@ -2061,22 +2227,22 @@ declare global {
     condition: number;
 
     /**
-     * Units of the row the player's body wears or holds, as their game last reported it. Only in `Inventory.get` and `player.getInventory()`; give it back to `Inventory.set` to dress a restored body.
+     * Units the body wears or holds: reported by a player, authored stock for an NPC. Reads include them; pass them to `Inventory.set` to dress a restored body.
      */
     equipped: number;
 
     /**
-     * Every property the server keeps: `quality`, `health`, `condition`, and on missiles `poison` (a buff GUID) and `poisonCharges`, and `onEquipBuffs` (buff GUIDs). A default is left out. Pass it back as it is to keep an item exactly.
+     * Every property the server keeps: `quality`, `health`, `condition`, and on missiles `poison` (a buff GUID) and `poisonCharges`, and `onEquipBuffs` (buff GUIDs). Custom items also carry `custom: { name?, description?, data? }`. Data stays server-side. A default is left out. Pass it back as it is to keep an item exactly.
      */
     metadata: Record<string, unknown>;
   }
 
   /**
-   * One player's inventory as the server holds it.
+   * One player's or NPC's inventory as the server holds it.
    */
   interface InventoryState {
     /**
-     * The player's game shows this revision. False for a moment after every change, and until `playerInventoryReady`.
+     * For a player, their game shows this revision. For an NPC, its initial stock has been established. Wait for `playerInventoryReady` or `npcInventoryReady` respectively.
      */
     ready: boolean;
 
@@ -2089,10 +2255,45 @@ declare global {
      * Every row.
      */
     items: InventoryRow[];
+
+    /**
+     * NPC stock only: the carcass has already been harvested. Pass it to Inventory.set when restoring a corpse; absent preserves its existing state.
+     */
+    harvested: boolean | undefined;
+
+    /**
+     * The current native outfit's quick-access assignments and selections, using row IDs. Null until reported or restored. Save with items and pass both to Inventory.set.
+     */
+    quickslots: InventoryQuickslots | null;
+  }
+
+  /**
+   * The current outfit's weapon and item quickslots. Indices are zero-based; each array has four entries. Empty references are null.
+   */
+  interface InventoryQuickslots {
+    /**
+     * Four weapon slots, each with primary and secondary row IDs. A row may appear in several slots.
+     */
+    weapons: { primary: string | null; secondary: string | null }[];
+
+    /**
+     * Four item slots, containing row IDs or null. Save equipped belts and pouches with the inventory rows to retain slot capacity.
+     */
+    items: (string | null)[];
+
+    /**
+     * Selected weapon slot, 0 through 3.
+     */
+    activeWeapon: number;
+
+    /**
+     * Selected item slot, 0 through 3.
+     */
+    activeItem: number;
   }
 
   /**
-   * What one operation did to one player's inventory.
+   * What one operation did to one inventory.
    */
   interface InventoryChange {
     /**
@@ -2101,7 +2302,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, `repair` for a repair kit, `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, `sharpen` for a grindstone, `drop` for `player.dropInventory`, `loot`, `npcDeposit`, `harvest`, `outfit`, or the ground, stash and gathering reasons. `equipment` reports an equipment or quickslot change: items is empty, the item revision does not advance, and Inventory.get returns the new snapshot.
      */
     reason: string;
 
@@ -2137,39 +2338,49 @@ declare global {
   }
 
   /**
-   * Player inventories. The server holds each connected player's items and their game shows them; nothing a player's game does adds an item. Every operation happens at once and in full, or not at all. `revision` is optional everywhere: give the one you read to refuse the operation when the inventory changed since.
+   * Player and NPC inventories. The server holds the stock and clients project it. Native NPC default stock is censused once by its elected simulator; `Inventory.set` establishes scripted stock immediately. Other NPC writes require ready stock. Every operation happens at once and in full, or not at all. `revision` is optional everywhere: give the one you read to refuse the operation when the inventory changed since.
    */
   const Inventory: {
     /**
-     * Reads a player's inventory.
-     * @returns A copy of it, or null for a player who is not connected.
+     * Lists every equippable item in the compiled game catalog. Names are table identifiers; nameKey is the native localization key. Maximum quality is the same bound Inventory.add enforces.
+     */
+    classes(): { id: string; name: string; nameKey: string; category: string; maximumQuality: number; quest: boolean }[];
+
+    /**
+     * Reads a player's or NPC's inventory.
+     * @returns A copy, or null for an owner that no longer exists.
+     */
+    get(owner: Player | Npc): InventoryState | null;
+
+    /**
+     * Gives an owner 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. A player's game announces them with its own "You received" toast unless `notify` is false.
      */
-    get(player: Player): InventoryState | null;
+    add(owner: Player | Npc, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number; notify?: boolean }): InventoryResult;
 
     /**
-     * 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.
+     * Takes exact units from named rows, every one of them or none. A player's game announces the loss with its own toast unless `notify` is false.
      */
-    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number; notify?: boolean }): InventoryResult;
+    remove(owner: Player | Npc, request: { units: InventoryUnit[]; revision?: number; notify?: boolean }): InventoryResult;
 
     /**
-     * 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.
+     * Updates only named custom fields. Null resets a display override or clears data. Supplied data replaces the old object. The whole row keeps its identity, amount and native properties.
      */
-    remove(player: Player, request: { units: InventoryUnit[]; revision?: number; notify?: boolean }): InventoryResult;
+    updateCustom(player: Player, request: { id: string; name?: string | null; description?: string | null; data?: Record<string, unknown> | null; revision?: number }): 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.
      */
-    setProperties(player: Player, request: { id: string; metadata: Record<string, unknown>; revision?: number }): InventoryResult;
+    setProperties(owner: Player | Npc, request: { id: string; metadata: Record<string, unknown>; revision?: number }): InventoryResult;
 
     /**
-     * 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.
+     * Replaces an owner'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. Optional quickslots restores assignments and selected slots in the current native outfit; every referenced ID must occur in items. Invalid shape or missing references returns invalidQuickslots before changing anything. Omitted or null quickslots leaves assignment to the game's normal equipment handling. Native item eligibility and slot capacity still apply. 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;
+    set(owner: Player | Npc, request: { items: { id?: string; item: string; amount: number; metadata?: Record<string, unknown>; equipped?: number }[]; quickslots?: InventoryQuickslots | null; revision?: number; harvested?: boolean }): 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. Both players' games announce what they lost and gained unless `notify` is false.
+     * Moves exact units between players or NPCs 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`. The script decides access, distance and consent. Players' games announce what they lost and gained unless `notify` is false.
      */
-    transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number; notify?: boolean }): InventoryResult;
+    transfer(source: Player | Npc, target: Player | Npc, 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.
@@ -2187,6 +2398,16 @@ declare global {
     setItemName(item: string, name: string | null): string[];
   };
 
+  /**
+   * Server-defined resource items using existing game appearances. Register types before restoring their instances.
+   */
+  const Items: {
+    /**
+     * Registers an immutable type and returns its stable GUID. Identical repeats succeed; conflicts throw. Defaults: empty description, price 0, stackable true, usable false, useLabel Use. visual names a miscellaneous item, crafting material or document appearance.
+     */
+    register(id: string, definition: { name: string; description?: string; visual: string; weight: number; price?: number; stackable?: boolean; usable?: boolean; useLabel?: string }): string;
+  };
+
   /**
    * Replicated KCD2 horse handle.
    */
@@ -2531,6 +2752,11 @@ declare global {
      * What one costs, in money units -- the amount of the game's `money` item, which is also what `player.giveItem('money', n)` hands out.
      */
     price: number;
+
+    /**
+     * Item properties, including custom display overrides and private data. Preserved when bought.
+     */
+    metadata?: Record<string, unknown> | undefined;
   }
 
   /**
@@ -2552,6 +2778,11 @@ declare global {
    * One settled line of a deal.
    */
   interface VendorTradeLine {
+    /**
+     * Exact item properties, including private custom data. Sold variants appear as separate lines.
+     */
+    metadata: Record<string, unknown>;
+
     /**
      * The item class GUID.
      */
@@ -2705,7 +2936,87 @@ declare global {
      * The score that wins, banked at the end of a turn. 2000 when omitted, at most 100000.
      */
     targetScore?: number | undefined;
-  }
+
+    /**
+     * First seat's scoreboard label, up to 64 UTF-8 bytes without control characters. Empty or omitted uses the native label.
+     */
+    firstName?: string | undefined;
+
+    /**
+     * Second seat's scoreboard label. Each client maps the seat to its local or opponent column.
+     */
+    secondName?: string | undefined;
+  }
+
+  /**
+   * An accepted server dice action. Notifications describe server decisions, which can precede the native animation. Seats and die-mask bits start at zero; turns and rolls start at one.
+   */
+  interface DiceProgressEvent {
+    /**
+     * Match ID.
+     */
+    match: number;
+
+    /**
+     * Network ID of the acting player.
+     */
+    player: number;
+
+    /**
+     * Acting seat: 0 for first, 1 for second.
+     */
+    seat: number;
+
+    /**
+     * Turn number across both seats, starting at 1.
+     */
+    turn: number;
+
+    /**
+     * Roll within the turn; 0 before its first roll.
+     */
+    roll: number;
+
+    /**
+     * Number of accepted moves so far.
+     */
+    moveIndex: number;
+
+    /**
+     * Unbanked points in this turn, before they are lost on a bust or banked on a pass.
+     */
+    turnScore: number;
+
+    /**
+     * This seat's banked score.
+     */
+    totalScore: number;
+
+    /**
+     * Six pip values (1 through 6) in die-index order on diceRoll; empty on other events. rolledMask identifies the dice rolled this time.
+     */
+    faces: number[];
+
+    /**
+     * Bit mask of dice rolled, on diceRoll; zero otherwise.
+     */
+    rolledMask: number;
+
+    /**
+     * Bit mask of dice selected in the accepted move; zero otherwise.
+     */
+    heldMask: number;
+
+    /**
+     * Points added by diceMove or banked by a passed diceTurnEnd; zero otherwise.
+     */
+    points: number;
+
+    /**
+     * continue or pass on diceMove; bust or rolled on diceRoll; pass, bust, won, gaveUp, left, timedOut, failed, or stopped on diceTurnEnd; empty on diceTurnStart.
+     */
+    reason: string;
+  }
 
   /**
    * Dice matches between two players on the game's own dice table.
@@ -2728,6 +3039,15 @@ declare global {
      */
     start(first: number, second: number, options?: DiceMatchOptions): number;
 
+    /**
+     * Changes both scoreboard labels on the next native scoreboard refresh. Empty restores a native label. Names allow at most 64 UTF-8 bytes and no control characters.
+     * @param match Match ID.
+     * @param first First seat label.
+     * @param second Second seat label.
+     * @returns False if the match has ended.
+     */
+    setNames(match: number, first: string, second: string): boolean;
+
     /**
      * Ends a match with nobody winning; both tables close.
      * @param match The match to end.
@@ -3742,6 +4062,29 @@ declare global {
 
   interface Vfx extends Entity {}
 
+  /**
+   * One player's view, directed from the server. A shot is sent and forgotten: the server keeps no record of it, so a player who reconnects or changes level has their own view until they are sent another.
+   */
+  const Camera: {
+    /**
+     * Films one player's view from a fixed point: what a cutscene, an intro or a kill cam is made of. It holds until `clearShot`, or glides on to the next `setShot`.
+     * 
+     * This is the client's `Camera.setShot`, sent to that player; whichever of the two comes last wins. Nothing about the player's controls changes, and nothing about where their body is: their character stays where it stood, drawn head and all for as long as the camera is looking at it from outside its eyes. A player flying with `NoClip` refuses the shot.
+     * @param player Whose view to film.
+     * @param options `position` is where the camera stands and `lookAt` the point it faces, both in world space. `duration` is how long it takes to get there from wherever the player's view is, in milliseconds: 0, the default, is a cut, and the most is 60000. `fov` is the vertical field of view in degrees, 20 to 120; leave it out to keep the player's own.
+     * @returns True when the shot was sent, false when `position` and `lookAt` are the same point.
+     */
+    setShot(player: Player, options: { position: Vector3; lookAt: Vector3; duration?: number; fov?: number }): boolean;
+
+    /**
+     * Gives a player their own view back. Harmless for a player without a shot.
+     * @param player Whose view to give back.
+     * @param duration How long the glide back into the player's eyes takes, in milliseconds: 0, the default, is a cut, and the most is 60000.
+     * @returns True when it was sent.
+     */
+    clearShot(player: Player, duration?: number): boolean;
+  };
+
   /**
    * Replicated ground marker handle.
    */
@@ -4167,9 +4510,9 @@ declare global {
     lootable: boolean;
 
     /**
-     * How the client simulator moves the body. `native` (default) uses the game's movement controller and walk animations. `kinematic` moves the body directly without walk animation. Neither finds a way around anything: the game's movement controller steers straight at the point it is given. Routes come from server pathfinding, which hands either mode mesh corners -- see `moveTo`.
+     * How the client simulator moves the body. `native` (default) uses the game's movement controller and walk animations. `kinematic` moves the body directly without walk animation. Only these exact, case-sensitive strings are accepted; invalid values throw without changing the mode. Neither finds a way around anything: the game's movement controller steers straight at the point it is given. Routes come from server pathfinding, which hands either mode mesh corners -- see `moveTo`.
      */
-    locomotion: string;
+    locomotion: 'native' | 'kinematic';
 
     /**
      * What the NPC has been told to do: `hold`, `moveTo`, `follow`, `flee`, `lookAt`, `playAnim`, `talk` or `attack`.
@@ -4192,7 +4535,7 @@ declare global {
     readonly appearance: Appearance;
 
     /**
-     * What it has been told to wear, as item class GUIDs; empty when it wears its own clothes. Write it with `wear` or `setOutfit`.
+     * Its worn item classes. Before default stock is established an empty list leaves the soul's own outfit; afterward empty means undressed. Write it with `wear`, `setOutfit` or `Inventory.set`.
      */
     readonly wearing: string[];
 
@@ -4255,6 +4598,16 @@ declare global {
      */
     setNametagColor(color: number): void;
 
+    /**
+     * Returns game-data loot candidates for this animal. Does not roll or populate stock. The gamemode chooses chances and writes Inventory.set at spawn. Null for non-animals, excluded souls or unresolved adopted bodies; an empty array is a known empty preset.
+     */
+    getAnimalLoot(): AnimalLootItem[] | null;
+
+    /**
+     * Reads server-owned stock and worn row counts. Inventory.get/add/remove/setProperties/set/transfer also accept Npc handles. Default native stock becomes ready at npcInventoryReady; Inventory.set may provide it before a body exists.
+     */
+    getInventory(): InventoryState | null;
+
     /**
      * Despawns this NPC everywhere, after emitting npcDestroy.
      */
@@ -4373,7 +4726,7 @@ declare global {
     say(text: string): boolean;
 
     /**
-     * Dresses the body in exactly these items, replacing what it had on. An empty list takes off what it was given and leaves what its soul owns -- which for many souls, a role's among them, is only underwear, so re-dress those with `setOutfit`.
+     * Dresses the body in exactly these items, replacing what it had on. Existing items are reused and missing ones are added to stock. An empty list undresses it and retains its clothes as loose inventory.
      * @param itemClasses Item class GUIDs in the dashed form the game's own tables spell them.
      * @returns True when every GUID names an item class this build has. Otherwise nothing changes, and each refused GUID is logged.
      */
@@ -4418,7 +4771,7 @@ declare global {
     pin(player: Player | number | null): void;
 
     /**
-     * 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.
+     * Spawns an NPC and replicates it. Omitted or undefined `locomotion` defaults to `native`; other values must be exactly `native` or `kinematic`, otherwise it throws before spawning. 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 from `Npc.roles()`, an animal name from `Npc.animals()`, or a soul GUID; `position` is where to put it. Everything else has a default.
@@ -4427,7 +4780,7 @@ declare global {
     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;
 
     /**
-     * Takes over one of the level's own NPCs instead of spawning a new body. A level `EntityGuid` is the same number on every machine, so every client finds the same body -- which is how doors, gates and stashes are already addressed. Adopting the same guid twice returns the NPC that already has it.
+     * Takes over one of the level's own NPCs instead of spawning a new body. Locomotion is validated as for `create`. A level `EntityGuid` is the same number on every machine, so every client finds the same body -- which is how doors, gates and stashes are already addressed. Adopting the same guid twice returns the NPC that already has it without applying the options again.
      * @param levelGuid `EntityGuid` of the body the level already placed.
      * @param options The same options a spawn takes; `soul` and `class` are ignored, since the body already exists.
      * @returns The NPC handle for that body.
@@ -4461,6 +4814,11 @@ declare global {
      */
     static roles(): string[];
 
+    /**
+     * Authored human NPC placements in the configured level with matching catalog souls. These are initial placements, not current NPC schedules or proof that a quest layer is loaded. Does not spawn or adopt anything.
+     */
+    static placements(): { name: string; guid: string; level: string; layer: string; soul: string; actorClass: string; position: { x: number; y: number; z: number }; rotation: { w: number; x: number; y: number; z: number } }[];
+
     /**
      * Animal souls with matching native classes. Pass a name or soul to Npc.create. Chickens use flock entities and are excluded.
      */
@@ -4990,6 +5348,21 @@ declare global {
    * A frozen snapshot of one stew pot in one virtual world.
    */
   interface CookPotSnapshot {
+    /**
+     * Meal served by this pot, including its native nutrition and appearance.
+     */
+    food: "goulash" | "lentil" | "soup";
+
+    /**
+     * Base nutrition per meal: goulash 25, lentil 10, soup 15.
+     */
+    nutrition: number;
+
+    /**
+     * Ingested buff GUID applied to future meals, or null. Visible to server scripts only.
+     */
+    poison: string | null;
+
     /**
      * The fireplace's level GUID.
      */
@@ -5044,7 +5417,7 @@ declare global {
     get(guid: string, virtualWorld?: number): CookPotSnapshot | null;
 
     /**
-     * Replaces remaining stock and capacity, preserving enabled. Returns false for an unknown pot.
+     * Replaces remaining stock and capacity and clears poison, preserving food and 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.
@@ -5060,14 +5433,78 @@ declare global {
     setEnabled(guid: string, enabled: boolean, virtualWorld?: number): boolean;
 
     /**
-     * Changes food level and stock together, preserving enabled. Returns false for an unknown pot.
+     * Changes food level and stock together, preserving food, poison and 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.
      */
     setState(guid: string, state: "empty" | "half" | "full", virtualWorld?: number): boolean;
+
+    /**
+     * Item class GUIDs accepted by CookPot.poison, including each native strength variant.
+     */
+    poisons(): string[];
+
+    /**
+     * Changes future meals and appearance, preserving stock, poison and enabled. Already reserved meals keep their previous type.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param food Native meal type.
+     * @param virtualWorld Virtual world id; defaults to 0. The global visibility sentinel is not a stock world.
+     */
+    setFood(guid: string, food: "goulash" | "lentil" | "soup", virtualWorld?: number): boolean;
+
+    /**
+     * Spends ingredients atomically and fills an empty enabled pot. Clears old poison. Validates player, distance, ability to act, world and synchronized inventory. Never pass unvalidated client recipe data.
+     * @param player Connected player within four metres; their current virtual world selects the pot.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param recipe Ingredients and yield chosen by this server script.
+     */
+    refillFromInventory(player: Player, guid: string, recipe: CookPotRecipe): CookPotResult;
+
+    /**
+     * Poisons a stocked enabled pot with the item's ingested effect. Refuses a second poison until refill. A meal takes the poison present when reserved, applied once on its eating receipt; NPC poisoning and native crime reactions are not included.
+     * @param player Connected player within four metres; their current virtual world selects the pot.
+     * @param guid Fireplace level GUID from CookPot.all().
+     * @param rowId Inventory row containing a native Poison item; spends exactly one.
+     */
+    poison(player: Player, guid: string, rowId: string): CookPotResult;
   };
 
+  /**
+   * Server-defined ingredients and portions for refilling an empty pot.
+   */
+  interface CookPotRecipe {
+    /**
+     * Meal to put in the pot.
+     */
+    food: "goulash" | "lentil" | "soup";
+
+    /**
+     * Integer from 1 to 1000.
+     */
+    portions: number;
+
+    /**
+     * One to sixteen food item classes by name or GUID, with positive integer amounts. Split stacks are combined; spoiled rows are skipped.
+     */
+    ingredients: { item: string; amount: number }[];
+  }
+
+  /**
+   * An atomic pot action. A refusal changes neither items nor contents.
+   */
+  interface CookPotResult {
+    /**
+     * Whether the action succeeded.
+     */
+    ok: boolean;
+
+    /**
+     * ok, invalid_player, unknown_pot, disabled, too_far, cannot_act, inventory_not_ready, not_empty, invalid_recipe, missing_ingredients, empty, already_poisoned, unknown_item, not_poison, or an inventory refusal code.
+     */
+    code: string;
+  }
+
   /** */
   interface NearestDoor {
     /**
@@ -5531,38 +5968,251 @@ declare global {
     destroy(): void;
 
     /**
-     * Builds and replicates a siege engine, unloaded. The trebuchet is the game's own model and plays its own winch, load and fire animations; the cannon is the game's static gun.
-     * @param kind `trebuchet` or `cannon`.
-     * @param position World-space position of the engine's base.
-     * @param rotation Optional initial orientation: a Quaternion, or a Vector3 of Euler angles in degrees. `fire` and `aim` turn it to face their target.
-     * @param virtualWorld Optional virtual world the engine belongs to; omitted puts it in the global one.
-     * @returns The new engine's handle.
+     * Builds and replicates a siege engine, unloaded. The trebuchet is the game's own model and plays its own winch, load and fire animations; the cannon is the game's static gun.
+     * @param kind `trebuchet` or `cannon`.
+     * @param position World-space position of the engine's base.
+     * @param rotation Optional initial orientation: a Quaternion, or a Vector3 of Euler angles in degrees. `fire` and `aim` turn it to face their target.
+     * @param virtualWorld Optional virtual world the engine belongs to; omitted puts it in the global one.
+     * @returns The new engine's handle.
+     */
+    static spawn(kind: string, position: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, virtualWorld?: number): SiegeEngine;
+
+    /**
+     * Lists the siege engines the server has.
+     * @param virtualWorld Optional virtual world to list; omitted lists every one.
+     * @returns One handle per engine, in no particular order.
+     */
+    static all(virtualWorld?: number): SiegeEngine[];
+
+    /**
+     * Looks an engine up by its network entity ID.
+     * @param id Network entity identifier.
+     * @returns The engine's handle, or null when no live engine has that ID.
+     */
+    static getById(id: number): SiegeEngine | null;
+
+    /**
+     * Removes siege engines, emitting `siegeEngineDestroy` 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 SiegeEngine 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(kind: string, position: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, virtualWorld?: number): SiegeEngine;
+    static spawn(position: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, virtualWorld?: number): StonePile;
 
     /**
-     * Lists the siege engines the server has.
+     * Lists the stone piles the server has.
      * @param virtualWorld Optional virtual world to list; omitted lists every one.
-     * @returns One handle per engine, in no particular order.
+     * @returns One handle per pile, in no particular order.
      */
-    static all(virtualWorld?: number): SiegeEngine[];
+    static all(virtualWorld?: number): StonePile[];
 
     /**
-     * Looks an engine up by its network entity ID.
+     * Looks a pile up by its network entity ID.
      * @param id Network entity identifier.
-     * @returns The engine's handle, or null when no live engine has that ID.
+     * @returns The pile's handle, or null when no live pile has that ID.
      */
-    static getById(id: number): SiegeEngine | null;
+    static getById(id: number): StonePile | null;
 
     /**
-     * Removes siege engines, emitting `siegeEngineDestroy` for each one.
+     * 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 SiegeEngine extends Entity {}
+  interface StonePile extends Entity {}
 
   /** */
   interface AreaDefinition {
@@ -5631,6 +6281,11 @@ declare global {
      */
     virtualWorld?: number | undefined;
 
+    /**
+     * Invisible boundary collision from both sides; false when omitted. Polygons need a simple outline and positive height. Walls are 0.2 m thick; spheres use a tessellated boundary.
+     */
+    collision?: boolean | undefined;
+
     /**
      * Whether it starts enabled; true when omitted.
      */
@@ -5705,6 +6360,11 @@ declare global {
      */
     metadata: Record<string, unknown>;
 
+    /**
+     * Invisible boundary walls block both directions while enabled, leaving the interior empty. Authored areas only; invalid collision shapes throw.
+     */
+    collision: boolean;
+
     /**
      * Whether crossings are raised and the lookups find it. Switching it off raises `areaExit` for everyone inside on the next tick; switching it on, `areaEnter`. Works on level areas too.
      */
@@ -6099,6 +6759,11 @@ declare global {
    * The server's own clock and weather, which every client follows, and the three questions it can ask a client's engine about the level itself.
    */
   const World: {
+    /**
+     * The configured level loaded by every client in this server session.
+     */
+    readonly level: string;
+
     /**
      * Whole days the clock has run, from the level's own midnight. Starts at 0 and only grows.
      */
@@ -6164,6 +6829,11 @@ declare global {
      */
     readonly puddles: number;
 
+    /**
+     * Points of interest in the configured level only, from the compiled game catalog. Positions are ground-marker clusters checked against the level navmesh; a teleport still needs the destination to stream on the client.
+     */
+    pointsOfInterest(): { name: string; group: string; level: string; position: { x: number; y: number; z: number } }[];
+
     /**
      * Winds the clock forward to an absolute day and hour, which is how a saved clock is restored.
      * @param day Absolute day to wind forward to, as the `day` property counts them. Must be whole.
@@ -8301,219 +8971,6 @@ 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.