@kingdomsconnected/types 1.5.1 → 1.5.2

package/generated/server-api.d.ts

@@ -88,16 +88,38 @@ declare global {
      */
     playerReady: [player: Player];
 
+    /**
+     * 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.
+     */
+    playerInventoryChanged: [player: Player, change: InventoryChange];
+
+    /**
+     * The player's game spent items: ate, drank, applied or fired them. Raised after the `playerInventoryChanged` that removed them. `item` is the class GUID.
+     * 
+     * This is the player's own game saying so: the server checked that the units existed and were of a kind that can be spent that way, and took them, but did not see the meal or the shot. A handler that rewards a use -- a heal, a buff -- can be had for the price of the item.
+     */
+    playerItemUsed: [player: Player, item: string, kind: "food" | "potion" | "ointment" | "shot", amount: number];
+
+    /**
+     * A player's game shows their inventory for the first time this session. Their inventory exists from `playerConnect`; restore a saved one there with `Inventory.set`, and it is what they load in with.
+     */
+    playerInventoryReady: [player: Player];
+
     /**
      * Dispatched immediately after a horse is created and replicated, whether by `Horse.spawn`, the `/horse` command, or anything else.
      */
     horseSpawn: [horse: Horse];
 
     /**
-     * Dispatched while a horse is being despawned. The handle still resolves, so its rider and name can be read one last time.
+     * Dispatched while a horse is being despawned, including the despawn its owner's disconnect implies. The handle still resolves, so its owner and name can be read one last time.
      */
     horseDestroy: [horse: Horse];
 
+    /**
+     * Dispatched after a horse is handed to another player, or left ownerless -- by `giveTo`, or by its owner disconnecting while `destroyWithOwner` is false.
+     */
+    horseOwnerChanged: [horse: Horse, player: Player | null];
+
     /**
      * Dispatched after a player climbs into a saddle and the horse's authority has been handed to their client.
      */
@@ -172,6 +194,31 @@ declare global {
      */
     playerPickpocketCaught: [thief: Player, victim: Player];
 
+    /**
+     * A player asks to open an alchemy table. Every handler runs; one returning literal `false` refuses it. An async handler cannot refuse.
+     */
+    craftingStarting: [player: Player, proposal: CraftStartProposal];
+
+    /**
+     * A batch is brewing.
+     */
+    craftingStarted: [player: Player, event: CraftStartedEvent];
+
+    /**
+     * A batch finished and its result is computed. Every handler runs; one returning literal `false` refuses it: the batch ends as failed, what was spent stays spent, and nothing is granted.
+     */
+    craftingCompleting: [player: Player, proposal: CraftCompletionProposal];
+
+    /**
+     * A batch's result was granted, followed by `craftingEnded`. Raised after the `playerInventoryChanged` it caused.
+     */
+    craftingCompleted: [player: Player, event: CraftCompletedEvent];
+
+    /**
+     * A batch is over. Raised after the `playerInventoryChanged` of any refund.
+     */
+    craftingEnded: [player: Player, event: CraftEndedEvent];
+
     /**
      * Dispatched immediately after a dog is created and replicated, whether by `Dog.spawn` or anything else.
      */
@@ -297,6 +344,16 @@ declare global {
      */
     groundItemPickup: [groundItem: GroundItem, player: Player | null];
 
+    /**
+     * A player picked a plant within their reach, and the server is about to give them the herb. Return false to refuse it: nothing is given and the plants stay. The proposal is frozen; every handler runs whatever an earlier one returned, and an async handler cannot refuse.
+     */
+    gatheringHarvest: [player: Player, proposal: GatheringProposal];
+
+    /**
+     * A player was given a herb, after the `playerInventoryChanged` it caused. The plant and the same-kind plants harvested with it are picked for everyone in the virtual world until they regrow; nothing about them survives a restart.
+     */
+    gatheringHarvested: [player: Player, event: GatheringHarvestedEvent];
+
     /**
      * Dispatched when a player's client reports working a door, before the server applies it. `action` is `open`, `close`, `lock`, `unlock` or `lockpick`; a key turned in the same use as the push arrives as `unlock` and then `open`. `keySide` says whether the player stood on the side with the keyhole, which is where an unlock needs a key.
      * 
@@ -304,6 +361,31 @@ declare global {
      */
     doorInteract: [player: Player, door: Door, action: "open" | "close" | "lock" | "unlock" | "lockpick", keySide: boolean];
 
+    /**
+     * A container now exists: one a script spawned, 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()`.
+     */
+    stashSpawn: [stash: Stash];
+
+    /**
+     * A player opened a container and sees what it holds.
+     */
+    stashOpen: [stash: Stash, player: Player];
+
+    /**
+     * A player no longer has a container open: they closed it, walked away, died or changed world (`lostAccess`), sent nothing for two minutes, left, or the container went.
+     */
+    stashClose: [stash: Stash, player: Player, reason: "closed" | "lostAccess" | "timeout" | "disconnected" | "destroyed"];
+
+    /**
+     * What a container holds changed. `player` moved the units -- `change.reason` is `deposit` or `withdraw`, and their inventory raises `playerInventoryChanged` too -- or is null for a script's `addItem`, `removeItem` or `setInventory`, or `destroy` when the container went with something in it. Save from here to keep contents across restarts: the server keeps nothing itself. A linked child's `stash` is the one the player used; its stock is its master's.
+     */
+    stashInventoryChanged: [stash: Stash, player: Player | null, change: InventoryChange];
+
+    /**
+     * A container is about to go. Raised after its close and its contents' removal, while it can still be read.
+     */
+    stashDestroy: [stash: Stash];
+
     /**
      * Dispatched when a player presses a container's prompt, before anything happens: the player's client holds the game's own handler until the server answers. `action` is `open`, `unlock` -- a key turned, which opens it in the same use -- or `lockpick`, the minigame starting; a successful pick then opens it without asking again.
      * 
@@ -346,6 +428,41 @@ declare global {
      */
     playerBuffBlocked: [player: Player, buff: string];
 
+    /**
+     * Dispatched when a player's own game produced XP -- a hit landed, a lock picked, a page read -- and asks for it. Return `false` to refuse it; the gain then never happens. `xp` is before this server's rate and the player's own multipliers. `source` is the game's name for what caused it: `Attack`, `LockpickingResult` and so on, or empty. Nothing is asked while `Progression.setNativeXp(false)` is in force.
+     */
+    playerXpGaining: [player: Player, track: string, xp: number, source: string];
+
+    /**
+     * Dispatched when XP landed on a player's character, from their game or from this server, after every multiplier.
+     */
+    playerXpGained: [player: Player, track: string, xp: number];
+
+    /**
+     * Dispatched when one of a player's tracks reaches a new level. `perkPoints` is what that track's tree now has unspent.
+     */
+    playerLevelUp: [player: Player, track: string, level: number, perkPoints: number];
+
+    /**
+     * Dispatched when a player confirmed a perk on the perk screen and every rule of the game allows it: the tree's level, the parent perk, the exclusive partner, a point to spend, and this server's block list. Return `false` to refuse it; the point is not spent and their client raises `progressionPerkRefused`.
+     */
+    playerPerkLearning: [player: Player, perk: string];
+
+    /**
+     * Dispatched when a perk appeared on a player's character: learnt on the perk screen, given by this server, or granted by the game on its own -- a codex entry, a recipe, a combat move it teaches.
+     */
+    playerPerkAdded: [player: Player, perk: string, source: "learned" | "server" | "native"];
+
+    /**
+     * Dispatched when a perk left a player's character: taken or respecced by this server, or removed by the game.
+     */
+    playerPerkRemoved: [player: Player, perk: string, source: "server" | "native"];
+
+    /**
+     * Dispatched when a player's client reported progression this server never ordered: a track that rose further than any gain it granted could take it, or a perk-screen perk nobody learnt. The report is kept -- the game has no way to take a level back -- so what happens to the player is the handler's call; a kick is the usual answer.
+     */
+    playerProgressionRejected: [player: Player, reason: string];
+
     /**
      * Dispatched after a resource entry point has run and immediately before the resource becomes running.
      */
@@ -360,6 +477,16 @@ declare global {
      * Dispatched when one key of an entity's state changes: on the server when a script writes it, on a client when the write arrives. `value` is undefined when the key was removed and `previous` is undefined when it held nothing before, so a stored null stays distinguishable from an absent key. The entity is whatever the game's WrapScriptEntity answers, and the base Entity handle by default.
      */
     entityStateChange: [entity: Entity, key: string, value: any, previous: any];
+
+    /**
+     * Dispatched for a line typed into the server console that no built-in command (help, ensure, refresh, ...) claimed. `args` is the rest of the line, split on whitespace. The console is the operator's, so this is the place for commands no player may run.
+     */
+    consoleCommand: [command: string, args: string[]];
+
+    /**
+     * 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];
   }
 
   /** Names of native events available in this scripting environment. */
@@ -494,6 +621,231 @@ declare global {
     unarmed: number;
   }
 
+  /**
+   * One skill or stat a player levels, as the game's own tables describe it.
+   */
+  interface TrackInfo {
+    /**
+     * The name every progression verb takes, as the game's tables spell it: `weapon_sword`, `thievery`, `strength`.
+     */
+    name: string;
+
+    /**
+     * Whether it is a skill or one of the stats the skills sit on.
+     */
+    kind: "skill" | "stat";
+
+    /**
+     * The highest level the game lets it reach.
+     */
+    cap: number;
+
+    /**
+     * True for fencing alone: it is never earned, the game derives it from the five weapon skills, so XP handed to it is refused.
+     */
+    induced: boolean;
+  }
+
+  /**
+   * One perk, as the game's own perk tables describe it.
+   */
+  interface PerkInfo {
+    /**
+     * The perk's `perk_name`, unique across the tables, and the spelling every perk verb takes alongside its GUID.
+     */
+    name: string;
+
+    /**
+     * The perk's GUID.
+     */
+    id: string;
+
+    /**
+     * The localisation key the perk screen shows, or empty for a perk it never shows.
+     */
+    uiName: string;
+
+    /**
+     * The track whose points pay for it: a track name, `main` for the main-level bank, or null for a perk no player's tree carries.
+     */
+    track: string | null;
+
+    /**
+     * The level that track has to reach before the perk can be learnt. 0 for none.
+     */
+    level: number;
+
+    /**
+     * The perk that has to be owned first, or null.
+     */
+    parent: string | null;
+
+    /**
+     * `visible` perks are the ones on the perk screen and the only ones a player can learn; `hidden` ones appear once something grants them; `system` ones implement game features and are never shown.
+     */
+    visibility: "system" | "hidden" | "visible" | "obsolete";
+
+    /**
+     * What the perk does when owned, from the game's side tables: `buff` (a real status effect), `script`, `technique` (a combat move), `ability`, `param` (rewrites a game rule), `companion` (the dog), `recipe`, `codex`. Empty for a perk that only gates others.
+     */
+    kinds: string[];
+
+    /**
+     * Whether the game grants it on its own once its requirements are met, rather than on the perk screen.
+     */
+    autolearnable: boolean;
+  }
+
+  /**
+   * Where a player stands on one track.
+   */
+  interface TrackProgress {
+    /**
+     * The level reached.
+     */
+    level: number;
+
+    /**
+     * XP earned towards the next level, in the game's own units.
+     */
+    xp: number;
+
+    /**
+     * XP the next level costs in total, from the start of this one. `xp / xpToNext` is the bar the character sheet draws.
+     */
+    xpToNext: number;
+
+    /**
+     * Unspent perk points in this track's tree.
+     */
+    perkPoints: number;
+  }
+
+  /**
+   * A player's level on every track, keyed by track name.
+   */
+  interface TrackLevels {
+    /**
+     * The level reached.
+     */
+    stealth: number;
+
+    /**
+     * The level reached.
+     */
+    horse_riding: number;
+
+    /**
+     * The level reached.
+     */
+    fencing: number;
+
+    /**
+     * The level reached.
+     */
+    thievery: number;
+
+    /**
+     * The level reached.
+     */
+    alchemy: number;
+
+    /**
+     * The level reached.
+     */
+    craftsmanship: number;
+
+    /**
+     * The level reached.
+     */
+    drinking: number;
+
+    /**
+     * The level reached.
+     */
+    survival: number;
+
+    /**
+     * The level reached.
+     */
+    weapon_sword: number;
+
+    /**
+     * The level reached.
+     */
+    heavy_weapons: number;
+
+    /**
+     * The level reached.
+     */
+    marksmanship: number;
+
+    /**
+     * The level reached.
+     */
+    weapon_large: number;
+
+    /**
+     * The level reached.
+     */
+    weapon_unarmed: number;
+
+    /**
+     * The level reached.
+     */
+    scholarship: number;
+
+    /**
+     * The level reached.
+     */
+    houndmaster: number;
+
+    /**
+     * The level reached.
+     */
+    strength: number;
+
+    /**
+     * The level reached.
+     */
+    agility: number;
+
+    /**
+     * The level reached.
+     */
+    vitality: number;
+
+    /**
+     * The level reached.
+     */
+    speech: number;
+
+    /**
+     * The level reached.
+     */
+    prestige: number;
+  }
+
+  /**
+   * Everything a server needs to put a player's progression back: plain JSON a resource can store however it likes. A player starts every session with a fresh character, so this is how progression outlives a disconnect.
+   */
+  interface ProgressionSnapshot {
+    /**
+     * Level and XP into the next level, per track name.
+     */
+    tracks: Record<string, { level: number; xp: number }>;
+
+    /**
+     * Every perk owned, by name.
+     */
+    perks: string[];
+
+    /**
+     * Unspent points per tree: track names, and `main`.
+     */
+    perkPoints: Record<string, number>;
+  }
+
   /**
    * The pace rule a server puts on one player. Both halves default to off, and a call to `setMovementMode` states both of them.
    */
@@ -761,6 +1113,26 @@ declare global {
      */
     readonly equipment: string[];
 
+    /**
+     * The player's main level, the one the game derives from the stats, as their client last reported it. 0 until the first report.
+     */
+    readonly level: number;
+
+    /**
+     * The level of every skill and stat, keyed by track name, as this server last accepted it. All zero until the first report.
+     */
+    readonly levels: TrackLevels;
+
+    /**
+     * Every perk the player owns, by name.
+     */
+    readonly perks: string[];
+
+    /**
+     * Everything about this player's progression, as plain JSON to store however the resource likes. A player starts every session with a fresh character, so `restoreProgression` with a stored snapshot is how progression outlives a disconnect. Null until their client's first report.
+     */
+    readonly progression: ProgressionSnapshot | null;
+
     /**
      * Whether this player is in a saddle.
      */
@@ -809,39 +1181,104 @@ declare global {
     toString(): string;
 
     /**
-     * Requests revival of this player after playerDied.
-     * @returns True when sent; false when disconnected, no death was reported, or revival was already requested.
+     * 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()`.
+     * @returns The progress, or null before their client's first report. Throws for a track name the tables do not carry.
      */
-    revive(): boolean;
+    getTrack(track: string): TrackProgress | null;
 
     /**
-     * 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.
-     * 
-     * Called from a `playerSpawning` handler this *is* the answer to that request -- the player is still behind their loading screen, and nothing is seen. Called at any other time it moves a player who is already in the world, which is visible.
-     * 
-     * Nothing else names a spawn: with no handler calling this, everybody arrives at the level's own start point, because every client asks the game for the identical map start.
-     * @param position Where the body goes; a Vector3 or any object carrying x, y and z.
-     * @param rotation Which way they face: a Quaternion, or a Vector3 of Euler degrees.
-     * @returns True when the placement was accepted; false for a position that is not somewhere in the world, or a player with no connection to ask.
+     * Whether this player owns a perk.
+     * @param perk A perk's name or GUID.
+     * @returns True when their last report carried it.
      */
-    spawn(position: Vector3 | Partial<Vector3>, rotation?: Quaternion | Vector3): boolean;
+    hasPerk(perk: string): boolean;
 
     /**
-     * Asks this player's own client to put them somewhere else. The owning client is authoritative for its body's pose, so this is a request that lands on their next frame rather than a write.
-     * @param position World-space destination; a Vector3 or any object carrying x, y and z.
-     * @param label Optional name for the destination, echoed back in the client's own teleport panel. Display only.
-     * @returns True when the request went out; false when the position is not finite or the player has no connection to ask.
+     * Grants XP on one track, through the game's own path on the player's client -- so their perks' XP multipliers apply, a level crossed pops the game's own level-up, and a level grants its perk points. Rates, budgets and caps do not apply: those rule over what a player earns, and this is the server giving.
+     * @param track A track name. Not `fencing`: the game derives it from the weapon skills.
+     * @param xp XP, in the game's own units.
+     * @returns True when the order went out. Throws for an unknown track or an xp that is not positive.
      */
-    teleport(position: Vector3 | Partial<Vector3>, label?: string): boolean;
+    addXp(track: string, xp: number): boolean;
 
     /**
-     * Makes this player's body play one of the game's animations, on their own screen and on everybody else's -- a wave, a bow, a woodcutter's swing with the axe in hand. It is state rather than a one-off: a player who streams in or joins while it plays sees it too, and it lasts until `stopAnimation` or the next `playAnimation`, even after a one-shot has finished.
-     * 
-     * A new `playAnimation`, `stopAnimation` and `teleport` cut a running animation at once rather than waiting for it to finish. The game can cut it short too: a hit, a fall or drawing a weapon ends it, and so can the player walking off from one that leaves the legs free. `loop` starts it again when that happens, and keeps a one-shot going pass after pass with no gap between them.
-     * 
-     * `playerAnimationEnd` fires once when the animation this request started is over, and says how. A loop ends only by being stopped or replaced.
-     * 
-     * A hand tag is only half of holding something. `r_bucket` makes the body move as if it carried a bucket, but the bucket itself is a `props` entry.
+     * Raises one track to a level, as the game's own `AdvanceToSkillLevel` does: exactly the XP between the two levels, with the level-ups and perk points on the way. The game has no way to lower a level, so asking for one below the current level throws.
+     * @param track A track name. Not `fencing`.
+     * @param level The level to raise it to, at most the game's cap of 30.
+     * @returns True when the order went out; false for a level past the cap.
+     */
+    setLevel(track: string, level: number): boolean;
+
+    /**
+     * Gives this player a perk outright, spending no point and skipping the perk screen's requirements. It still has to be one the game can add: an owned or blocked perk is turned down by the game itself.
+     * @param perk A perk's name or GUID.
+     * @returns True when the order went out. Throws for an unknown perk.
+     */
+    addPerk(perk: string): boolean;
+
+    /**
+     * Takes a perk away. The point it cost is not refunded; `respecPerks` is the way to hand points back.
+     * @param perk A perk's name or GUID.
+     * @returns True when the order went out. Throws for an unknown perk.
+     */
+    removePerk(perk: string): boolean;
+
+    /**
+     * Gives this player unspent perk points in one tree, on top of what their levels earned.
+     * @param track The tree to add to: a track name, or `main` for the main-level bank.
+     * @param count How many, from 1 to 65535.
+     * @returns True when the order went out.
+     */
+    addPerkPoints(track: string, count: number): boolean;
+
+    /**
+     * The game's own respec: every perk learnt on the perk screen is taken away and every tree's points are rebuilt from the player's current levels. Perks the game granted on its own stay.
+     * @returns True when the order went out.
+     */
+    respecPerks(): boolean;
+
+    /**
+     * Puts a stored progression back: levels, XP, perks and unspent points, through the game's own paths. Only ever raises -- a track already past the snapshot keeps its level -- so call it as the player arrives, from `playerReady`, on the fresh character every session starts with.
+     * @param snapshot What `player.progression` returned, as the resource stored it.
+     * @returns True when every order went out.
+     */
+    restoreProgression(snapshot: ProgressionSnapshot): boolean;
+
+    /**
+     * Requests revival of this player after playerDied.
+     * @returns True when sent; false when disconnected, no death was reported, or revival was already requested.
+     */
+    revive(): 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.
+     * 
+     * Called from a `playerSpawning` handler this *is* the answer to that request -- the player is still behind their loading screen, and nothing is seen. Called at any other time it moves a player who is already in the world, which is visible.
+     * 
+     * Nothing else names a spawn: with no handler calling this, everybody arrives at the level's own start point, because every client asks the game for the identical map start.
+     * @param position Where the body goes; a Vector3 or any object carrying x, y and z.
+     * @param rotation Which way they face: a Quaternion, or a Vector3 of Euler degrees.
+     * @returns True when the placement was accepted; false for a position that is not somewhere in the world, or a player with no connection to ask.
+     */
+    spawn(position: Vector3 | Partial<Vector3>, rotation?: Quaternion | Vector3): boolean;
+
+    /**
+     * Asks this player's own client to put them somewhere else. The owning client is authoritative for its body's pose, so this is a request that lands on their next frame rather than a write.
+     * @param position World-space destination; a Vector3 or any object carrying x, y and z.
+     * @param label Optional name for the destination, echoed back in the client's own teleport panel. Display only.
+     * @returns True when the request went out; false when the position is not finite or the player has no connection to ask.
+     */
+    teleport(position: Vector3 | Partial<Vector3>, label?: string): boolean;
+
+    /**
+     * Makes this player's body play one of the game's animations, on their own screen and on everybody else's -- a wave, a bow, a woodcutter's swing with the axe in hand. It is state rather than a one-off: a player who streams in or joins while it plays sees it too, and it lasts until `stopAnimation` or the next `playAnimation`, even after a one-shot has finished.
+     * 
+     * A new `playAnimation`, `stopAnimation` and `teleport` cut a running animation at once rather than waiting for it to finish. The game can cut it short too: a hit, a fall or drawing a weapon ends it, and so can the player walking off from one that leaves the legs free. `loop` starts it again when that happens, and keeps a one-shot going pass after pass with no gap between them.
+     * 
+     * `playerAnimationEnd` fires once when the animation this request started is over, and says how. A loop ends only by being stopped or replaced.
+     * 
+     * A hand tag is only half of holding something. `r_bucket` makes the body move as if it carried a bucket, but the bucket itself is a `props` entry.
      * @param fragment A Mannequin fragment, as `Animations.list` names it. `""` plays none and only puts the props and tags on, which with a hand tag like `r_bucket` makes the player carry something while they walk.
      * @param options `tags` pick the variant, `loop` repeats it until stopped, `lockMovement` holds the player still, `props` puts up to two models in their hands.
      * @returns True when the request went out; false for a player with no body yet. Throws for a prop or option it cannot use.
@@ -906,25 +1343,34 @@ declare global {
     setMovementMode(mode: Partial<MovementMode>): boolean;
 
     /**
-     * Grants items into this player's inventory on their own client. The server holds no inventory of its own, so this is an instruction rather than a transfer.
+     * 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.
      * @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 grant went out; false for an unknown item or an amount the wire refuses.
+     * @returns True when the items were added; false for an unknown item, an amount outside 1..10000, or a player with no inventory.
      */
     giveItem(item: string, amount?: number): boolean;
 
     /**
-     * Takes items back out of this player's inventory, on their own client -- the mirror of `giveItem`, and what makes a trade or a theft able to move in both directions.
-     * 
-     * It is a promise rather than a boolean because a grant always lands and a take may not. The server holds no inventory of its own, so it cannot know what the player is carrying: it asks their client, and the answer is a round trip away. Await it, and read `ok` before crediting the other side of a trade -- a player who has only one of the three you asked for gives back `removed: 1, ok: false`, and their client is already one short.
-     * 
-     * Across stacks of the same class, oldest first, and an item counts even while it is in the player's hand. Nothing else of theirs is touched.
+     * 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.
      * @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` (units that actually went), `requested` (what was asked for), `ok` (true only when the client answered and removed every unit), and `reason` (empty when it answered, otherwise what went wrong).
+     * @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`).
      */
     takeItem(item: string, amount?: number): Promise<{ removed: number; requested: number; ok: boolean; reason: string }>;
 
+    /**
+     * Moves this player's items into a container spawned at their body, as a death drop: `playerInventoryChanged` (reason `drop`) and `stashInventoryChanged` follow, then the container is anyone's to open. At most 128 rows go. What happens to it next -- who may loot it, when it goes -- is the script's.
+     * @param options `keepEquipped` keeps the units their body wears or holds.
+     * @returns The container, or null when there was nothing to drop or the player has no inventory.
+     */
+    dropInventory(options?: { keepEquipped?: boolean }): Stash | null;
+
+    /**
+     * 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.
+     */
+    getInventory(): InventoryState | null;
+
     /**
      * Puts a status effect on this player's body. The server runs no effects of its own, so this asks their client rather than writing anything, and it lands a moment later -- `hasBuff` right after this call still says false. Watch `playerBuffAdded` for the moment it is really on.
      * 
@@ -999,6 +1445,172 @@ declare global {
 
   interface Player extends BasePlayer {}
 
+  /**
+   * A count of units from one row.
+   */
+  interface InventoryUnit {
+    /**
+     * The row.
+     */
+    id: string;
+
+    /**
+     * How many of its units.
+     */
+    amount: number;
+  }
+
+  /**
+   * 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.
+   */
+  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`.
+     */
+    id: string;
+
+    /**
+     * Item class GUID.
+     */
+    item: string;
+
+    /**
+     * The item's name in the game's own tables; not localized text.
+     */
+    name: string;
+
+    /**
+     * Units in the row.
+     */
+    amount: number;
+
+    /**
+     * Quality, from 1 up to the class's maximum. Same as `metadata.quality`.
+     */
+    quality: number;
+
+    /**
+     * Absolute item health. Same as `metadata.health`.
+     */
+    health: number;
+
+    /**
+     * Health as a fraction of what this quality allows, 0 to 1. Same as `metadata.condition`.
+     */
+    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.
+     */
+    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.
+     */
+    metadata: Record<string, unknown>;
+  }
+
+  /**
+   * One player'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`.
+     */
+    ready: boolean;
+
+    /**
+     * Advances by one with every change. Pass it as a request's `revision` to refuse the request if anything changed in between.
+     */
+    revision: number;
+
+    /**
+     * Every row.
+     */
+    items: InventoryRow[];
+  }
+
+  /**
+   * What one operation did to one player's inventory.
+   */
+  interface InventoryChange {
+    /**
+     * The revision the operation produced.
+     */
+    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`, `drop` for `player.dropInventory`, or the ground, stash and gathering reasons.
+     */
+    reason: string;
+
+    /**
+     * Only the rows that changed. `before: null` is a new row and `after: null` an emptied one.
+     */
+    items: { id: string; before: InventoryRow | null; after: InventoryRow | null }[];
+  }
+
+  /**
+   * What an inventory operation did.
+   */
+  interface InventoryResult {
+    /**
+     * It happened. Nothing changes when it did not.
+     */
+    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`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
+     */
+    code: string;
+
+    /**
+     * The revision after the operation; for a transfer, the source's. 0 when refused.
+     */
+    revision: number;
+
+    /**
+     * The rows that received units: the row an `add` merged into or created, a transfer's rows in the target, every row a `set` wrote. Empty for `remove`.
+     */
+    items: InventoryUnit[];
+  }
+
+  /**
+   * 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.
+   */
+  const Inventory: {
+    /**
+     * Reads a player's inventory.
+     * @returns A copy of it, or null for a player who is not connected.
+     */
+    get(player: Player): InventoryState | null;
+
+    /**
+     * Gives a player items of a class, 1 to 10000 at a time. Left-out properties mean quality 1 at full condition. The units join the row that already holds this class with these properties, if there is one.
+     */
+    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number }): InventoryResult;
+
+    /**
+     * Takes exact units from named rows, every one of them or none.
+     */
+    remove(player: Player, request: { units: InventoryUnit[]; 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;
+
+    /**
+     * 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.
+     */
+    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.
+     */
+    transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number }): InventoryResult;
+  };
+
   /**
    * Replicated KCD2 horse handle.
    */
@@ -1049,6 +1661,21 @@ declare global {
      */
     readonly mounted: boolean;
 
+    /**
+     * Network ID of the player this horse belongs to, or 0 when it is nobody's. Not necessarily its rider.
+     */
+    readonly ownerId: number;
+
+    /**
+     * The player this horse belongs to, or null when it is nobody's. Set with `giveTo`.
+     */
+    readonly owner: Player | null;
+
+    /**
+     * Whether this horse is despawned when its owner disconnects. True by default. Set it to false to keep the horse in the world: it is left ownerless instead (`horseOwnerChanged` with a null player) until `giveTo` hands it to someone. Saving it across server restarts is the script's own business.
+     */
+    destroyWithOwner: boolean;
+
     /**
      * Health, as the client running this horse last reported it off the animal's own soul -- 0 before any client has. Assigning sets it on that client, clamped to `maxHealth`; 0 kills. A dead horse ignores the write: `revive` is what brings one back.
      */
@@ -1085,6 +1712,12 @@ declare global {
      */
     destroy(): 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.
+     */
+    giveTo(player: Player | null): void;
+
     /**
      * Rears the horse on every client so it throws its rider off. The game's own animation, not a pose.
      * @returns True when the request went out; false when nobody is riding it.
@@ -1246,203 +1879,648 @@ declare global {
     update(session: number, page: DialoguePage): boolean;
 
     /**
-     * Ends a conversation and takes the list off that player's screen.
-     * @param session The session to end.
-     * @returns False when the session had already ended.
+     * Ends a conversation and takes the list off that player's screen.
+     * @param session The session to end.
+     * @returns False when the session had already ended.
+     */
+    close(session: number): boolean;
+
+    /**
+     * The conversation that player is in.
+     * @param player NetworkID of the player to ask about.
+     * @returns The session id, or 0 when they are not in one.
+     */
+    sessionOf(player: number): number;
+  };
+
+  /**
+   * How a vendor starts out.
+   */
+  interface VendorOptions {
+    /**
+     * Shown in the server's log only. The trade screen names whoever keeps the shop.
+     */
+    name: string | undefined;
+
+    /**
+     * Money units the vendor starts with, and all it can pay out. Omit it for a purse that never runs out.
+     */
+    purse: number | undefined;
+
+    /**
+     * Whether the vendor takes the player's items at all. On by default; `setBuyPrices` says which ones.
+     */
+    buys: boolean | undefined;
+  }
+
+  /**
+   * One thing a vendor sells.
+   */
+  interface VendorStockRow {
+    /**
+     * The item class, by GUID or by the game's own item name.
+     */
+    item: string;
+
+    /**
+     * How many the vendor has. A row the players buy out disappears.
+     */
+    amount: number;
+
+    /**
+     * 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;
+  }
+
+  /**
+   * One thing a vendor buys from players.
+   */
+  interface VendorBuyRow {
+    /**
+     * The item class, by GUID or by the game's own item name.
+     */
+    item: string;
+
+    /**
+     * What the vendor pays for one, in money units.
+     */
+    price: number;
+  }
+
+  /**
+   * One settled line of a deal.
+   */
+  interface VendorTradeLine {
+    /**
+     * The item class GUID.
+     */
+    item: string;
+
+    /**
+     * The game's own name for the item class.
+     */
+    name: string;
+
+    /**
+     * How many changed hands.
+     */
+    amount: number;
+
+    /**
+     * What one was priced at when the deal settled.
+     */
+    price: number;
+  }
+
+  /**
+   * Price lists and purses the server owns, traded on the game's own shop screen.
+   * 
+   * A vendor is attached to nothing: open one in front of a player from wherever the gamemode decides the counter is -- `npcInteract`, a dialogue option, a command. The screen is a preview. Its prices come from here, and pressing Trade sends a basket that the server re-prices, settles and moves itself; nothing the client shows is trusted.
+   * 
+   * Prices count in money units, the amount of the game's `money` item.
+   */
+  const Vendor: {
+    /**
+     * Creates a vendor with nothing to sell and nothing it buys.
+     * @param options Name, starting purse and whether it buys. All optional.
+     * @returns The vendor id.
+     */
+    create(options?: VendorOptions): number;
+
+    /**
+     * Closes every session at the vendor and forgets it. A deal already settling still completes.
+     * @param vendor The vendor to remove.
+     * @returns False when there was no such vendor.
+     */
+    destroy(vendor: number): boolean;
+
+    /**
+     * Replaces what a vendor sells. Every player with its screen open sees the new shelf straight away, and a basket priced against the old one is refused.
+     * @param vendor The vendor to stock.
+     * @param rows Everything it sells, at most 128 rows and each item class once. Replaces the old list.
+     * @returns False when there is no such vendor.
+     */
+    setStock(vendor: number, rows: VendorStockRow[]): boolean;
+
+    /**
+     * Replaces what a vendor buys from players and what it pays. Anything not listed is shown at no value and a basket selling it is refused.
+     * @param vendor The vendor to change.
+     * @param rows Everything it buys, at most 128 rows and each item class once. Replaces the old list.
+     * @returns False when there is no such vendor.
+     */
+    setBuyPrices(vendor: number, rows: VendorBuyRow[]): boolean;
+
+    /**
+     * Sets what a vendor can pay out. Deals keep it current: what players pay goes in, what they are paid comes out.
+     * @param vendor The vendor to change.
+     * @param purse Money units it holds, or null for a purse that never runs out.
+     * @returns False when there is no such vendor.
+     */
+    setPurse(vendor: number, purse: number | null): boolean;
+
+    /**
+     * What a vendor holds.
+     * @param vendor The vendor to ask about.
+     * @returns Money units, or null for a purse that never runs out or a vendor that does not exist.
+     */
+    getPurse(vendor: number): number | null;
+
+    /**
+     * Opens the game's own trade screen on a player. A player already trading has that session closed with reason 2 first, because the game has one trade screen.
+     * @param vendor The vendor to trade with.
+     * @param player NetworkID of the player to show it to.
+     * @param npc NetworkID of the NPC who keeps the shop. The screen shows that NPC as the trader; omit it to trade with nobody in particular.
+     * @returns The session id, or 0 when the vendor or the player is gone.
+     */
+    open(vendor: number, player: number, npc?: number): number;
+
+    /**
+     * Takes the trade screen off that player.
+     * @param session The session to end.
+     * @returns False when the session had already ended.
+     */
+    close(session: number): boolean;
+
+    /**
+     * The trading session a player is in.
+     * @param player NetworkID of the player to ask about.
+     * @returns The session id, or 0 when they are not trading.
+     */
+    sessionOf(player: number): number;
+
+    /**
+     * The vendor a session trades with.
+     * @param session The session to ask about.
+     * @returns The vendor id, or 0 when the session has ended.
+     */
+    vendorOf(session: number): number;
+  };
+
+  /**
+   * One item class that left a victim's pockets for a thief's.
+   */
+  interface PickpocketLine {
+    /**
+     * The item class GUID.
+     */
+    item: string;
+
+    /**
+     * The game's own name for the item class.
+     */
+    name: string;
+
+    /**
+     * How many moved.
+     */
+    amount: number;
+  }
+
+  /**
+   * A table a player is about to open. Frozen: a handler can refuse it, not change it.
+   */
+  interface CraftStartProposal {
+    /**
+     * Station id, as `Crafting.stations` names it.
+     */
+    station: string;
+
+    /**
+     * The player's virtual world; each world has its own tables.
+     */
+    virtualWorld: number;
+
+    /**
+     * The batch this one follows at a table the player kept, or empty for a fresh entry.
+     */
+    continuationOf: string;
+  }
+
+  /**
+   * A batch that is now brewing: the table's opening animation finished, or the next batch started at a table the player kept.
+   */
+  interface CraftStartedEvent {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * The previous batch at this table, or empty for the first.
+     */
+    continuationOf: string;
+  }
+
+  /**
+   * What a finished batch is about to grant, computed by the server. Frozen: a handler can refuse it, not change it.
+   */
+  interface CraftCompletionProposal {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * `failed` brews the game's failed potion.
+     */
+    outcome: 'success' | 'failed';
+
+    /**
+     * The recipe the brew matched, or empty when it matched none.
+     */
+    recipe: string;
+
+    /**
+     * The product's native rank.
+     */
+    grade: number;
+
+    /**
+     * Item class GUID of what would be granted, or empty when the yield came out at zero.
+     */
+    product: string;
+
+    /**
+     * How many.
+     */
+    amount: number;
+
+    /**
+     * Brewing quality, 0 to 1, after perks and the table-entry bonus.
+     */
+    quality: number;
+
+    /**
+     * Base alchemy XP; the player's own multipliers apply on top.
+     */
+    xp: number;
+  }
+
+  /**
+   * A batch whose result was granted: the output is in the inventory and the XP was ordered.
+   */
+  interface CraftCompletedEvent {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * `failed` granted the game's failed potion.
+     */
+    outcome: 'success' | 'failed';
+
+    /**
+     * The recipe matched, or empty.
+     */
+    recipe: string;
+
+    /**
+     * The product's native rank.
+     */
+    grade: number;
+
+    /**
+     * Brewing quality, 0 to 1.
+     */
+    quality: number;
+
+    /**
+     * Base alchemy XP ordered.
+     */
+    xp: number;
+
+    /**
+     * The inventory rows that received the output. Do not grant it again.
+     */
+    outputs: InventoryUnit[];
+
+    /**
+     * The player's recipe knowledge after this batch, as `Crafting.knowledge` returns it.
+     */
+    knowledge: Record<string, number>;
+  }
+
+  /**
+   * A batch that is over, for any reason. A table kept for the next batch is not closed by this.
+   */
+  interface CraftEndedEvent {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * How it ended.
+     */
+    outcome: 'success' | 'failed' | 'cancelled';
+
+    /**
+     * Empty for a completed batch. `craftingCompletingRejected` when a handler refused the result; `cancelled` by the player or a script; `disconnected`; `timeout` after 30 minutes; `contextInvalidated` when the player walked away, died or changed world.
+     */
+    reason: string;
+
+    /**
+     * The inventory rows ingredients went back to. Wholly unmilled bowl, mortar and herb groups come back; everything else put on the table was spent.
+     */
+    refunded: InventoryUnit[];
+  }
+
+  /**
+   * Units required by a shipped recipe.
+   */
+  interface CraftMaterialRequirement {
+    /**
+     * Item class GUID.
+     */
+    item: string;
+
+    /**
+     * Native item name, useful with Player.giveItem.
+     */
+    name: string;
+
+    /**
+     * Units required for one attempt.
+     */
+    amount: number;
+  }
+
+  /**
+   * One possible product row. These are alternatives, not a reward list.
+   */
+  interface CraftProductInfo {
+    /**
+     * Product class GUID.
+     */
+    item: string;
+
+    /**
+     * Alchemy product rank or smithing minimum quality percent.
+     */
+    threshold: number;
+
+    /**
+     * Alchemy base maximum yield before modifiers; one for smithing.
+     */
+    maxYield: number;
+  }
+
+  /**
+   * Shipped recipe data allowed by server DLC policy. Presence is not proof of player knowledge, skill, quest eligibility or materials.
+   */
+  interface CraftRecipeInfo {
+    /**
+     * Tagged native recipe identity.
+     */
+    key: { kind: 'alchemy'; id: number } | { kind: 'smithing'; id: string };
+
+    /**
+     * Localization key from the native table.
+     */
+    name: string;
+
+    /**
+     * Native DLC id; zero for untagged content.
+     */
+    dlcId: number;
+
+    /**
+     * Minimum craftsmanship skill, or zero for alchemy.
+     */
+    minSkill: number;
+
+    /**
+     * Smithing recipe unlock perk GUID, empty for alchemy.
+     */
+    perk: string;
+
+    /**
+     * Alchemy base liquid, empty for smithing. Supplied by the station.
+     */
+    base: string;
+
+    /**
+     * Required ingredient quantities.
+     */
+    ingredients: CraftMaterialRequirement[];
+
+    /**
+     * Possible products by native rank or threshold.
+     */
+    products: CraftProductInfo[];
+  }
+
+  /**
+   * An authored station in the configured level. The catalog does not guarantee that its quest layer is loaded or that native use is currently permitted.
+   */
+  interface CraftStationInfo {
+    /**
+     * Level and stable placement GUID.
+     */
+    id: string;
+
+    /**
+     * The station's recipe family.
      */
-    close(session: number): boolean;
+    kind: 'alchemy' | 'smithing';
 
     /**
-     * The conversation that player is in.
-     * @param player NetworkID of the player to ask about.
-     * @returns The session id, or 0 when they are not in one.
+     * Level directory name.
      */
-    sessionOf(player: number): number;
-  };
+    level: string;
 
-  /**
-   * How a vendor starts out.
-   */
-  interface VendorOptions {
     /**
-     * Shown in the server's log only. The trade screen names whoever keeps the shop.
+     * Authored editor layer, for identifying the location.
      */
-    name: string | undefined;
+    layer: string;
 
     /**
-     * Money units the vendor starts with, and all it can pay out. Omit it for a purse that never runs out.
+     * World position of the station.
      */
-    purse: number | undefined;
+    position: { x: number; y: number; z: number };
 
     /**
-     * Whether the vendor takes the player's items at all. On by default; `setBuyPrices` says which ones.
+     * Horizontal facing direction.
      */
-    buys: boolean | undefined;
+    forward: { x: number; y: number };
   }
 
   /**
-   * One thing a vendor sells.
+   * Who holds an alchemy table. A player keeps it between batches until they leave it.
    */
-  interface VendorStockRow {
+  interface CraftStationOccupant {
     /**
-     * The item class, by GUID or by the game's own item name.
+     * The player's id.
      */
-    item: string;
+    playerId: number;
 
     /**
-     * How many the vendor has. A row the players buy out disappears.
+     * The first batch of this visit; the same across every batch of it.
      */
-    amount: number;
+    entryId: string;
 
     /**
-     * What one costs, in money units -- the amount of the game's `money` item, which is also what `player.giveItem('money', n)` hands out.
+     * The batch now running, or the last one to finish.
      */
-    price: number;
-  }
+    sessionId: string;
 
-  /**
-   * One thing a vendor buys from players.
-   */
-  interface VendorBuyRow {
     /**
-     * The item class, by GUID or by the game's own item name.
+     * `entering` until the opening animation finishes; `finishing` while a finished batch waits to settle.
      */
-    item: string;
+    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches';
 
     /**
-     * What the vendor pays for one, in money units.
+     * Milliseconds until the table is taken back. Each batch has 30 minutes.
      */
-    price: number;
+    expiresInMs: number;
   }
 
   /**
-   * One settled line of a deal.
+   * One table in one virtual world. A free table may still be unusable in the game, for instance behind a quest layer.
    */
-  interface VendorTradeLine {
+  interface CraftStationOccupancy {
     /**
-     * The item class GUID.
+     * Station id.
      */
-    item: string;
+    station: string;
 
     /**
-     * The game's own name for the item class.
+     * The virtual world asked about.
      */
-    name: string;
+    virtualWorld: number;
 
     /**
-     * How many changed hands.
+     * Someone holds it, brewing or between batches.
      */
-    amount: number;
+    occupied: boolean;
 
     /**
-     * What one was priced at when the deal settled.
+     * Who, or null when free.
      */
-    price: number;
+    occupant: CraftStationOccupant | null;
   }
 
   /**
-   * Price lists and purses the server owns, traded on the game's own shop screen.
-   * 
-   * A vendor is attached to nothing: open one in front of a player from wherever the gamemode decides the counter is -- `npcInteract`, a dialogue option, a command. The screen is a preview. Its prices come from here, and pressing Trade sends a basket that the server re-prices, settles and moves itself; nothing the client shows is trusted.
-   * 
-   * Prices count in money units, the amount of the game's `money` item.
+   * A player's alchemy session, or the table they kept between batches. A copy: changing it changes nothing.
    */
-  const Vendor: {
+  interface CraftSessionInfo {
     /**
-     * Creates a vendor with nothing to sell and nothing it buys.
-     * @param options Name, starting purse and whether it buys. All optional.
-     * @returns The vendor id.
+     * The batch's session id.
      */
-    create(options?: VendorOptions): number;
+    id: string;
 
     /**
-     * Closes every session at the vendor and forgets it. A deal already settling still completes.
-     * @param vendor The vendor to remove.
-     * @returns False when there was no such vendor.
+     * Station id.
      */
-    destroy(vendor: number): boolean;
+    station: string;
 
     /**
-     * Replaces what a vendor sells. Every player with its screen open sees the new shelf straight away, and a basket priced against the old one is refused.
-     * @param vendor The vendor to stock.
-     * @param rows Everything it sells, at most 128 rows and each item class once. Replaces the old list.
-     * @returns False when there is no such vendor.
+     * The table's virtual world.
      */
-    setStock(vendor: number, rows: VendorStockRow[]): boolean;
+    virtualWorld: number;
 
     /**
-     * Replaces what a vendor buys from players and what it pays. Anything not listed is shown at no value and a basket selling it is refused.
-     * @param vendor The vendor to change.
-     * @param rows Everything it buys, at most 128 rows and each item class once. Replaces the old list.
-     * @returns False when there is no such vendor.
+     * Where the batch is.
      */
-    setBuyPrices(vendor: number, rows: VendorBuyRow[]): boolean;
+    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches';
 
     /**
-     * Sets what a vendor can pay out. Deals keep it current: what players pay goes in, what they are paid comes out.
-     * @param vendor The vendor to change.
-     * @param purse Money units it holds, or null for a purse that never runs out.
-     * @returns False when there is no such vendor.
+     * Native actions accepted so far.
      */
-    setPurse(vendor: number, purse: number | null): boolean;
+    sequence: number;
 
     /**
-     * What a vendor holds.
-     * @param vendor The vendor to ask about.
-     * @returns Money units, or null for a purse that never runs out or a vendor that does not exist.
+     * What is on the table: item class, the inventory row it came from (empty for a base liquid), and the native table position.
      */
-    getPurse(vendor: number): number | null;
+    resources: { id: number; item: string; itemId: string; position: number; base: boolean; milled: boolean; distilled: boolean }[];
 
     /**
-     * Opens the game's own trade screen on a player. A player already trading has that session closed with reason 2 first, because the game has one trade screen.
-     * @param vendor The vendor to trade with.
-     * @param player NetworkID of the player to show it to.
-     * @param npc NetworkID of the NPC who keeps the shop. The screen shows that NPC as the trader; omit it to trade with nobody in particular.
-     * @returns The session id, or 0 when the vendor or the player is gone.
+     * Milliseconds until the session times out.
      */
-    open(vendor: number, player: number, npc?: number): number;
+    expiresInMs: number;
+  }
 
+  /**
+   * Crafting catalogs, alchemy table occupancy, sessions and recipe knowledge. Held in memory for each connection; nothing is saved.
+   */
+  const Crafting: {
     /**
-     * Takes the trade screen off that player.
-     * @param session The session to end.
-     * @returns False when the session had already ended.
+     * True for alchemy, false for smithing, which is not synchronized yet. Omitted kind checks alchemy.
      */
-    close(session: number): boolean;
+    isAvailable(kind?: 'alchemy' | 'smithing'): boolean;
 
     /**
-     * The trading session a player is in.
-     * @param player NetworkID of the player to ask about.
-     * @returns The session id, or 0 when they are not trading.
+     * Placed stations in this server's level. Does not load deferred layers or bypass quests.
      */
-    sessionOf(player: number): number;
+    stations(kind?: 'alchemy' | 'smithing'): readonly CraftStationInfo[];
 
     /**
-     * The vendor a session trades with.
-     * @param session The session to ask about.
-     * @returns The vendor id, or 0 when the session has ended.
+     * Production recipes enabled by server DLC policy. The player must be connected but does not change the list. Catalog presence does not establish knowledge or skill.
      */
-    vendorOf(session: number): number;
-  };
+    recipes(player: Player, kind?: 'alchemy' | 'smithing'): readonly CraftRecipeInfo[];
 
-  /**
-   * One item class that left a victim's pockets for a thief's.
-   */
-  interface PickpocketLine {
     /**
-     * The item class GUID.
+     * The player's alchemy session or the table they kept between batches, or null.
      */
-    item: string;
+    session(player: Player): CraftSessionInfo | null;
 
     /**
-     * The game's own name for the item class.
+     * Who holds a table. World defaults to 0. Null for an unknown or non-alchemy station.
      */
-    name: string;
+    occupancy(stationId: string, virtualWorld?: number): CraftStationOccupancy | null;
 
     /**
-     * How many moved.
+     * Ends the player's session as leaving the table would: wholly unmilled groups go back to the inventory, the rest is spent, the table is released and their game closes it. `craftingEnded` follows next tick. False when there was nothing to end.
      */
-    amount: number;
-  }
+    cancel(player: Player): boolean;
+
+    /**
+     * The player's recipe knowledge: recipe id to a mask of its 29 authored steps, 536870911 when the whole recipe is known. A recipe not listed is unknown. Starts empty every session; save it from `craftingCompleted` or here and restore it with `setKnowledge`.
+     */
+    knowledge(player: Player): Record<string, number>;
+
+    /**
+     * Sets which steps of one recipe the player knows, and sends it to their game's recipe book. 0 forgets the recipe. False for an unknown recipe, a mask above 536870911, or a player who is not connected.
+     */
+    setKnowledge(player: Player, recipeId: string | number, mask: number): boolean;
+  };
 
   /**
    * Replicated KCD2 dog companion handle.
@@ -1474,6 +2552,11 @@ declare global {
      */
     readonly owner: Player | null;
 
+    /**
+     * Whether this dog is despawned when its owner disconnects. True by default. Set it to false to keep the dog in the world: it is left masterless instead (`dogOwnerChanged` with a null player), and with nobody's game running its brain it stands where it was until `giveTo` hands it to someone. Saving it across server restarts is the script's own business.
+     */
+    destroyWithOwner: boolean;
+
     /**
      * The dog's companion mode: 0 Wait, 1 Follow, 2 Free, 3 Aggressive, 4 Search, 5 Hunt, 6 Guard, 7 Ambush. Assignment applies it on every client.
      */
@@ -1501,7 +2584,7 @@ declare global {
     destroy(): void;
 
     /**
-     * Hands this dog to another player. Every client re-possesses the body onto the new master's soul, and authority over its pose moves with it.
+     * Hands this dog to another player. Every client re-possesses the body onto the new master's soul, and authority over its pose moves with it. Throws when `player` is not a connected player.
      * @param player The dog's new master, or null to leave it masterless.
      */
     giveTo(player: Player | null): void;
@@ -2399,7 +3482,7 @@ declare global {
     readonly condition: number;
 
     /**
-     * Whether the stack has settled where it will stay. A stack a script spawned is resting from the start; one a player threw down is false until that player's own physics stops it and publishes the final pose, and its position moves until then.
+     * Whether the stack has settled where it will stay. A stack a script spawned is resting from the start; one a player dropped is false while the nearest client simulates its fall, and its position moves until then. A resting stack's pose is the server's and does not move again.
      */
     readonly resting: boolean;
 
@@ -2459,6 +3542,71 @@ declare global {
 
   interface GroundItem extends Entity {}
 
+  /**
+   * A plant a player picked and what it is about to give them.
+   */
+  interface GatheringProposal {
+    /**
+     * 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[];
+  }
+
   /** */
   interface NearestDoor {
     /**
@@ -2754,10 +3902,15 @@ declare global {
     readonly name: string;
 
     /**
-     * How many stacks the server is holding. Contents are not replicated -- they are pulled when a player opens the container and pushed back when they close it -- so this is the only view of what is in one. A container linked to another in the level opens that one's contents, and reads them here too.
+     * How many rows the server is holding. A container linked to another in the level opens that one's contents, and reads them here too.
      */
     readonly itemCount: number;
 
+    /**
+     * Whether a player has it open. Every client animates the lid by it.
+     */
+    readonly isOpen: boolean;
+
     /**
      * The network ID of the player who has its contents open, or 0. While it is held, every other player's open is refused before their transfer screen appears.
      */
@@ -2805,7 +3958,28 @@ declare global {
     destroy(): void;
 
     /**
-     * Spawns and replicates an empty container. Empty by design: an item class is a 16-byte engine GUID only the game's own parser turns from text, and the server has no game to ask. Fill one by having a player put things in it.
+     * Reads what the container holds. A linked child reads its master's.
+     * @returns A copy of its rows, or null once the container is gone.
+     */
+    getInventory(): { revision: number; items: InventoryRow[] } | null;
+
+    /**
+     * Puts items in the container, as `Inventory.add` gives them to a player.
+     */
+    addItem(request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number }): InventoryResult;
+
+    /**
+     * Takes exact units out of named rows, every one of them or none.
+     */
+    removeItem(request: { units: InventoryUnit[]; revision?: number }): InventoryResult;
+
+    /**
+     * Replaces everything in the container, which is how saved contents come back. At most 128 rows. An empty list empties it.
+     */
+    setInventory(request: { items: { id?: string; item: string; amount: number; metadata?: Record<string, unknown> }[]; revision?: number }): InventoryResult;
+
+    /**
+     * Spawns and replicates an empty container. Fill it with `addItem` or `setInventory`, or let players put things in it.
      * @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 virtualWorld Optional virtual world the container belongs to; omitted puts it in the global one.
@@ -3248,6 +4422,94 @@ declare global {
     claim(classNames: string[]): string[];
   };
 
+  /**
+   * The game's skills, stats and perks, and the rules this server puts on how players move along them.
+   */
+  const Progression: {
+    /**
+     * Whether players' own games may earn XP. See `setNativeXp`.
+     */
+    readonly nativeXp: boolean;
+
+    /**
+     * The perks this server blocks.
+     */
+    readonly blockedPerks: string[];
+
+    /**
+     * Every skill and stat a player levels: the fifteen skills the character sheet shows, then strength, agility, vitality, speech and prestige.
+     * @returns The tracks, in that order.
+     */
+    tracks(): TrackInfo[];
+
+    /**
+     * Looks a perk up.
+     * @param query A perk's name, as the game's perk tables spell it, or its GUID.
+     * @returns What the tables say about it, or null for a name they do not carry.
+     */
+    findPerk(query: string): PerkInfo | null;
+
+    /**
+     * Lists the game's perks: 945 of them, most of them hidden system perks. `Progression.perks({ visibleOnly: true })` is the perk screen.
+     * @param filter `track` keeps the perks one tree pays for -- a track name, or `main`; `visibleOnly` keeps the perks the perk screen shows.
+     * @returns The perks, sorted by name.
+     */
+    perks(filter?: { track?: string; visibleOnly?: boolean }): PerkInfo[];
+
+    /**
+     * The total XP a track costs from level 0 to `level`, on the game's own curve: each level costs `base + diff * level`, with base and diff from the game's RPG tables.
+     * @param track A track name.
+     * @param level The level to reach.
+     * @returns The XP. Throws for a track name the tables do not carry.
+     */
+    xpForLevel(track: string, level: number): number;
+
+    /**
+     * Switches off XP from play. Every gain the game produces is dropped on the player's own client, and only `player.addXp` and `player.setLevel` move a track -- for servers where progression comes from jobs, trainers or quests a resource runs.
+     * @param enabled False to stop players' own games from earning XP at all.
+     * @returns Nothing.
+     */
+    setNativeXp(enabled: boolean): void;
+
+    /**
+     * Scales the XP players earn by playing. Applied before the player's own perk multipliers, which still work as they do in single player. `player.addXp` is not scaled.
+     * @param track A track name, or `*` for every track.
+     * @param rate What a gain is multiplied by before it is granted: 1 is the game's own pace, 0.5 half, 0 none at all.
+     * @returns Nothing.
+     */
+    setXpRate(track: string, rate: number): void;
+
+    /**
+     * Limits how fast a track can be ground. The budget holds a minute's worth and refills steadily, so a burst after a quiet spell goes through and a loop -- two players sparring for sword XP, a lock picked over and over -- runs dry. `player.addXp` is not limited.
+     * @param track A track name, or `*` for every track.
+     * @param xpPerMinute How much XP a player may earn on the track per minute, before multipliers. 0 is unlimited.
+     * @returns Nothing.
+     */
+    setXpBudget(track: string, xpPerMinute: number): void;
+
+    /**
+     * Stops a track at a level. Gains close to it are granted exactly what is left, so no multiplier carries the track past it. `player.setLevel` and `player.addXp` can still go beyond: the cap rules over what is earned.
+     * @param track A track name, or `*` for every track.
+     * @param level The highest level XP from play may reach, at most the game's own 30.
+     * @returns Nothing.
+     */
+    setLevelCap(track: string, level: number): void;
+
+    /**
+     * Makes perks unobtainable: the perk screen's learn is refused, the game's own grants are turned down on every client, and a report carrying one is rejected. `player.addPerk` still works.
+     * @param perks Perk names or GUIDs.
+     * @returns Nothing. Throws for an unknown perk.
+     */
+    blockPerks(perks: string[]): void;
+
+    /**
+     * Lifts `blockPerks`.
+     * @param perks Perk names or GUIDs.
+     * @returns Nothing. Throws for an unknown perk.
+     */
+    unblockPerks(perks: string[]): void;
+  };
+
   /**
    * The game's own character-component catalog: every face, hairstyle, beard and skin a player's body can be given.
    * 
@@ -4536,6 +5798,59 @@ declare global {
     isPlayerTalking(player: Entity): boolean;
   };
 
+  /**
+   * A player asking to join, handed to `playerConnecting`. Every identifier is reported by the player's own client and is not verified by the server.
+   */
+  interface PendingConnection {
+    /**
+     * The name the player asked to join under.
+     */
+    readonly nickname: string;
+
+    /**
+     * Steam identifier the client reported, or an empty string when it had none.
+     */
+    readonly steamId: string;
+
+    /**
+     * Discord identifier the client reported, or an empty string when it had none.
+     */
+    readonly discordId: string;
+
+    /**
+     * Framework hardware identifier the client reported, or an empty string when it had none.
+     */
+    readonly hardwareId: string;
+
+    /**
+     * The string the client was launched with, as the `ticket` of its launch link, or an empty string. The framework passes it through untouched; checking it -- against a one-time join ticket your own launcher or website issued, typically -- is the script's job.
+     */
+    readonly ticket: string;
+
+    /**
+     * The remote address the connection comes from, without its port.
+     */
+    readonly ip: string;
+
+    /**
+     * Turns the player away before they receive anything. Takes effect on the next server tick, whatever other handlers are still doing. Does nothing once the connection is decided or the player has left.
+     * @param reason Shown to the player as written, up to 512 bytes. Omitted, they read that the server refused the connection.
+     */
+    reject(reason?: string): void;
+
+    /**
+     * Shows the waiting player a line of status and restarts the admission timeout, so a queue that keeps updating its players is never timed out. Does nothing once the connection is decided or the player has left.
+     * @param message One line for the player's connecting screen, up to 256 bytes: 'Checking the whitelist', 'You are 4th in the queue'.
+     */
+    update(message: string): void;
+
+    /**
+     * Checks whether this connection is still waiting on a decision.
+     * @returns False once it was let in or turned away, or the player gave up and left; a queue drops such entries.
+     */
+    isPending(): boolean;
+  }
+
   /**
    * Base handle for a live replicated network entity.
    */