@kingdomsconnected/types 1.6.0 → 1.6.1

package/generated/client-api.d.ts

@@ -835,7 +835,7 @@ declare global {
     readonly local: boolean;
 
     /**
-     * The engine entity this body was spawned as, or 0 across a level load and before the puppet exists. Not stable across a session: the engine reuses entity ids.
+     * The engine entity behind this player: the game's own player entity for the local player, otherwise the entity the puppet was spawned as, or 0 across a level load and before it exists. Not stable across a session: the engine reuses entity ids.
      */
     readonly entityId: number;
 
@@ -1093,6 +1093,13 @@ declare global {
      * @returns False once it has been removed and faded, has run its duration out, or was dropped by its resource stopping, the session ending or the level changing.
      */
     isScreenEffectActive(handle: number): boolean;
+
+    /**
+     * Projects a world point through the camera this frame is drawn with, so a resource can pin its own overlay to the world.
+     * @param point World position to project.
+     * @returns Its screen position, or null when the point is behind the camera or there is no view to place it in.
+     */
+    worldToScreen(point: Vector3): ScreenPoint | null;
   };
 
   /**
@@ -1150,6 +1157,26 @@ declare global {
     params: ScreenEffectParam[];
   }
 
+  /**
+   * Where a world point lands on screen, in the pixels Web views are placed in.
+   */
+  interface ScreenPoint {
+    /**
+     * Pixels from the left edge of the window's client area.
+     */
+    x: number;
+
+    /**
+     * Pixels from the top edge of the window's client area.
+     */
+    y: number;
+
+    /**
+     * Whether the point is inside the view. One past an edge keeps its coordinates with this false.
+     */
+    onScreen: boolean;
+  }
+
   /**
    * The game's own sound triggers, played at this machine. A trigger is a name the game's audio data declares -- `a_o_bell_kkut_kostelni`, `c_torch_whoosh1`, `f_ge_cough_woman` -- standing for an FMOD event. The full vocabulary is `Libs/GameAudio/*.xml` in `IPL_GameData.pak`, with the gameplay-facing subset listed in `Libs/Tables/GameAudio/SkaldAtlTrigger.xml`. Nothing here is replicated: a sound everyone should hear is one the server tells every client to play. Every call returns false while the audio system is not up, which is the case before a world is loaded, and for a trigger name the audio data does not declare.
    */
@@ -1228,7 +1255,7 @@ declare global {
   };
 
   /**
-   * What the server streams, seen from this machine. Models, materials, textures, sounds and particle libraries a server streams load by path like the game's own -- `objects/kcdc/<resource>/chair.cgf` works wherever a model path does -- so nothing here is needed to use them. Clips play through the server's `playClip`.
+   * What the server streams, seen from this machine. Models, materials, textures, sounds and particle libraries a server streams load by path like the game's own -- `objects/kcdc/<resource>/chair.cgf` works wherever a model path does -- so nothing here is needed to use them. Clips play through the server's `playAnimation("", { clip })`.
    */
   const Assets: {
     /**
@@ -2539,12 +2566,12 @@ declare global {
   /**
    * The world builder: a free camera, the game's mesh catalog as an asset library, a placement brush, a gizmo that moves anything, and maps saved to and loaded from files.
    * 
-   * No key opens it. A resource decides when it does, and only on a server whose `server.json` sets `mod.map_editor` to true; anywhere else `open` refuses. While it is open it holds the one free camera, so a `NoClip` flight in progress ends and `NoClip.enable` refuses. The player can still close it from its own window.
+   * F7 or a client resource opens it. Multiplayer requires the server to grant this player access with `player.setWorldBuilderEnabled(true)`; single-player and offline editing are always allowed. While it is open it holds the one free camera, so a `NoClip` flight in progress ends and `NoClip.enable` refuses. The player can still close it from its own window.
    */
   const MapEditor: {
     /**
      * Opens the editor.
-     * @returns `opened` when it opened. `alreadyOpen` when it was open already. `disabled` when the server has not turned `mod.map_editor` on, which includes no session at all.
+     * @returns `opened` when it opened. `alreadyOpen` when it was open already. `disabled` when this multiplayer connection has not been granted access.
      */
     open(): "opened" | "alreadyOpen" | "disabled";
 
@@ -2561,8 +2588,8 @@ declare global {
     isOpen(): boolean;
 
     /**
-     * Whether the connected server lets the editor open.
-     * @returns True when its `server.json` sets `mod.map_editor` to true.
+     * Whether this client may open World Builder.
+     * @returns True offline or when the server has granted this player access.
      */
     isEnabled(): boolean;
   };
@@ -5107,6 +5134,8 @@ declare global {
    * Arbitrary key/value state attached to one replicated entity, reached as `entity.state`. Keys set on the server replicate to every client that can currently see the entity.
    */
   class StateBag {
+    private constructor();
+
     /**
      * Reads one key from this entity's state.
      * @param key Key to read.

package/generated/server-api.d.ts

@@ -23,7 +23,7 @@ declare global {
     playerDied: [player: Player, killer: Player | null, reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm"];
 
     /**
-     * Dispatched when something takes health off a player: a weapon, an arrow, a fall, a collision, a scripted hit. The hit player's own client reports it, because only it resolved the blow against its armour and its skills, so `amount` is what was really taken. It arrives ahead of the `playerDied` a killing blow causes.
+     * Dispatched when something takes health off a player: a weapon, an arrow, a fall, a collision, a scripted hit. Another player's blow is raised by the server as it rules on it, after `playerHit` had its say, so `amount` is what the ruling takes; anything else is reported by the hit player's own client, which resolved it against its armour and its skills. It arrives ahead of the `playerDied` a killing blow causes.
      * 
      * `attacker` is the player who dealt it, or null. `bodyPart` is where it landed, or null for damage that lands nowhere in particular. The weapon is the attacker's own `rightHandItem` or `leftHandItem`.
      * 
@@ -31,6 +31,23 @@ declare global {
      */
     playerDamage: [player: Player, attacker: Player | null, amount: number, bodyPart: "head" | "torso" | "leftArm" | "rightArm" | "leftLeg" | "rightLeg" | null, reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm"];
 
+    /**
+     * A melee swing aimed at another player was admitted by the server, including a miss. Raised once per attack generation, after presentation admission. Use it to track combat inactivity in your resource.
+     */
+    playerAttack: [player: Player, opponent: Player];
+
+    /**
+     * A resource called cancelCombat for this pair. Raised after the cancellation was sent to both players and their observers.
+     */
+    playerCombatCancelled: [first: Player, second: Player];
+
+    /**
+     * Dispatched when another player's blade or arrow lands on a player, before anything is taken -- the place for teams, safe zones, friendly fire and damage rules. The game resolved the blow against the guard the victim really held -- whether it was blocked, perfectly or not, and where it landed -- and the server works out what a swing takes from there; it has checked that the swing was one it relayed and could still land, or that the arrow was one whose impact it accepted, and that the two stood within reach. Only what is ruled here comes off the victim's health, on every client at once.
+     * 
+     * Return `false` from a handler to refuse the blow: no health is taken and no `playerDamage` follows. Scale `hit.modifiers` to change how a swing is worked out -- a stronger attack, weaker armour -- or set `hit.damage` to say outright what it takes: `0` for a blow that lands harmlessly, more for a heavier one. Either way the blow is still seen and heard: the blades met. Handlers run synchronously, so the decision cannot wait on anything awaited.
+     */
+    playerHit: [player: Player, attacker: Player, hit: PlayerHit];
+
     /**
      * Dispatched when a limb becomes injured -- usually a blow landing there, sometimes a fall on both legs. `player.injuries` already says so. A limb hit again while injured stays injured and raises nothing new.
      */
@@ -442,7 +459,7 @@ declare global {
     siegeFire: [engine: SiegeEngine, attacker: Player | null, target: Vector3];
 
     /**
-     * Dispatched where a projectile came down: what the player nearest the target saw it hit, checked against the arc it was thrown on, or the target itself when nobody could see it. Players within `damageRadius` have already been told to take their share, and NPCs have taken theirs. `engine` is null when it was destroyed while the stone was in the air.
+     * Dispatched where a projectile came down: what the reporting player -- the attacker when near enough, else whoever is nearest the target -- saw it hit, checked against the arc it was thrown on, or the target itself when nobody could see it. Players within `damageRadius` have already been told to take their share, and NPCs have taken theirs. `engine` is null when it was destroyed while the stone was in the air.
      */
     siegeImpact: [engine: SiegeEngine | null, position: Vector3, attacker: Player | null];
 
@@ -456,6 +473,11 @@ declare global {
      */
     areaExit: [area: Area, entity: Player | Horse | Cart | Npc, matchingVirtualWorld: boolean];
 
+    /**
+     * Raised once after every configured world export has loaded successfully, including an empty list. WorldResource.ready is true inside the handler. A script starting later must check WorldResource.ready first; the event is not replayed. Do not await this event inside resourceStart: exports load after script startup. Handler promises are not awaited.
+     */
+    worldResourcesReady: [];
+
     /**
      * A container now exists: a scripted chest, a virtual stash, or one the level places, built in a virtual world the first time anything there asked for it. Every container starts empty; restore saved contents here with `setInventory`. The level's containers in the global world are built before any resource runs, so restore those from `resourceStart` by walking `Stash.all()`.
      */
@@ -956,6 +978,136 @@ declare global {
     walkEnforced: boolean;
   }
 
+  /**
+   * One number per damage type a blow is worked out in. A blade's stab, slash and smash are priced separately and added; a blow runs only the passes its attack and weapon call for.
+   */
+  interface DamagePasses {
+    /**
+     * The stab pass.
+     */
+    stab: number;
+
+    /**
+     * The slash pass.
+     */
+    slash: number;
+
+    /**
+     * The smash pass.
+     */
+    smash: number;
+  }
+
+  /**
+   * Scales a `playerHit` handler puts on the server's price of a melee blow, each 1 until a handler changes it. The server works the blow out again with them, step by step as the game does: a heavier attack has to get through the same armour and the same block, so doubling `attack` does not simply double the damage. Never negative.
+   */
+  interface PlayerHitModifiers {
+    /**
+     * Scales the attacker's attack in every pass, after their weapon, strength, skill and the swing itself.
+     */
+    attack: number;
+
+    /**
+     * Scales the victim's armour where the blow landed.
+     */
+    defense: number;
+
+    /**
+     * Scales what the victim's block put up. Nothing for a blow that was not blocked.
+     */
+    block: number;
+
+    /**
+     * Scales the health the blow takes, once everything else is worked out. The game's own cap of 200 a blow is applied before it, so this can go past it.
+     */
+    health: number;
+  }
+
+  /**
+   * Another player's blow, as `playerHit` shows it before the referee rules. `damage` is what the blow will take and `modifiers` scale how the server works it out; a handler may change either. Every other field describes what happened and is read-only in effect.
+   */
+  interface PlayerHit {
+    /**
+     * Health the blow takes. For a swing the server works it out itself, the way the game does, from the attacker's weapon and its wear, both players' strength and skills, the armour the victim wears where it landed, the block and the perks and buffs it can vouch for; for an arrow it is what the victim's own game worked out. Set it and it stands as set: `modifiers` are then ignored. Never negative.
+     */
+    damage: number;
+
+    /**
+     * Health the game itself took for the blow on the machine that saw it land. Matches `damage` unless a perk that depends on the moment -- a heavy weapon's, a first strike's -- was in play, which the server leaves out.
+     */
+    engineDamage: number;
+
+    /**
+     * Whether the server worked `damage` out itself: true for a swing, false for an arrow.
+     */
+    priced: boolean;
+
+    /**
+     * The attacker's weapon as 32 hex digits, or null for a bare hand.
+     */
+    weapon: string | null;
+
+    /**
+     * The attacker's attack in each pass, after the swing's own strength and before `modifiers`.
+     */
+    attack: DamagePasses;
+
+    /**
+     * The victim's armour in each pass where the blow landed, before `modifiers`.
+     */
+    armor: DamagePasses;
+
+    /**
+     * What the victim's block put up, or 0 when nothing blocked it.
+     */
+    blockDefense: number;
+
+    /**
+     * How much the place it landed multiplies the damage by: 1.5 for the head, 1 for the torso, 0.7 for a limb.
+     */
+    bodyPartCoefficient: number;
+
+    /**
+     * Scales on the server's price; see `PlayerHitModifiers`. Ignored for an arrow.
+     */
+    modifiers: PlayerHitModifiers;
+
+    /**
+     * Stamina the blow cost the victim. Already spent: stamina decides their next block, which cannot wait for a ruling.
+     */
+    stamina: number;
+
+    /**
+     * The limb it landed on, or null for none in particular.
+     */
+    bodyPart: "head" | "torso" | "leftArm" | "rightArm" | "leftLeg" | "rightLeg" | null;
+
+    /**
+     * The game's own reason for the damage: `combat` for a blade or a bow.
+     */
+    reason: "unknown" | "combat" | "gunshot" | "starvation" | "collision" | "scripted" | "disintegrate" | "fall" | "poison" | "bleeding" | "selfHarm";
+
+    /**
+     * Whether it was a swing or an arrow.
+     */
+    source: "melee" | "missile";
+
+    /**
+     * The victim's block caught it.
+     */
+    blocked: boolean;
+
+    /**
+     * The victim's perfect block caught it. The game takes nothing for one.
+     */
+    perfectBlock: boolean;
+
+    /**
+     * The victim's block gave way under it.
+     */
+    blockBroken: boolean;
+  }
+
   /**
    * Which of a player's limbs carry an injury, one flag per limb. An injury is the game's own: it lowers the stamina ceiling (`healthyStamina`), can bleed, and heals slowly by itself or at once with a bandage or `player.heal`.
    */
@@ -1356,6 +1508,13 @@ declare global {
      */
     revive(): boolean;
 
+    /**
+     * Ends melee combat between these two players and retires their pending blows against each other. Other opponents are left alone. A later attack can start combat again. Consent and timeout rules belong to your resource.
+     * @param opponent The other player. Both sides are cancelled.
+     * @returns True when sent; false for disconnected players, the same player, or different virtual worlds.
+     */
+    cancelCombat(opponent: Player): boolean;
+
     /**
      * Puts this player somewhere, as a spawn rather than as a teleport: their client holds the body still until there is real ground under it, so it cannot fall through a world that has not streamed in yet.
      * 
@@ -1434,6 +1593,13 @@ declare global {
      */
     setAppearance(appearance: Partial<Appearance>): boolean;
 
+    /**
+     * Grants or revokes World Builder access for this player. Multiplayer connections start without access. Enabling allows F7 and the client MapEditor.open API; disabling also closes an open editor. The permission lasts until changed or disconnected and does not affect other players. Offline editing is always allowed.
+     * @param enabled Whether this player may open World Builder.
+     * @returns True when the permission was sent; false for a player with no connection. Throws unless enabled is a boolean.
+     */
+    setWorldBuilderEnabled(enabled: boolean): boolean;
+
     /**
      * Puts a pace rule on this player. `walkByDefault` makes walking the pace they keep coming back to and leaves their own key working; `walkEnforced` forbids running and sprinting outright, and their key stops mattering.
      * 
@@ -1448,7 +1614,7 @@ declare global {
     setMovementMode(mode: Partial<MovementMode>): boolean;
 
     /**
-     * Grants items into this player's inventory, which the server holds; their game shows them on the next tick. `Inventory.add` does the same and can also set the items' properties.
+     * Grants items into this player's inventory, which the server holds; their game shows them on the next tick and announces them with its own "You received" toast. `Inventory.add` does the same, can set the items' properties, and can leave out the toast.
      * @param item Item class GUID, or the exact name the game's own item tables use.
      * @param amount How many to grant; defaults to 1, and at most 10000.
      * @returns True when the items were added; false for an unknown item, an amount outside 1..10000, or a player with no inventory.
@@ -1456,7 +1622,7 @@ declare global {
     giveItem(item: string, amount?: number): boolean;
 
     /**
-     * Takes items of a class out of this player's inventory, across its rows, all of them or none. The server holds the inventory, so the promise is already settled when it is returned; it stays a promise so existing scripts keep working. To move items between players use `Inventory.transfer`, which cannot lose them half way.
+     * Takes items of a class out of this player's inventory, across its rows, all of them or none. The server holds the inventory, so the promise is already settled when it is returned; it stays a promise so existing scripts keep working. Their game announces the loss with its own toast; `Inventory.remove` can leave it out. To move items between players use `Inventory.transfer`, which cannot lose them half way.
      * @param item Item class GUID, or the exact name the game's own item tables use. The same spelling `giveItem` takes.
      * @param amount How many units to take; defaults to 1, and at most 10000. Zero is refused rather than read as "all of them".
      * @returns An object carrying `removed` (the amount when it happened, otherwise 0), `requested`, `ok`, and `reason` (empty on success, otherwise the inventory code, such as `insufficientItems`).
@@ -1676,7 +1842,7 @@ declare global {
     revision: number;
 
     /**
-     * `add`, `remove`, `properties`, `set`, `transfer`, `wear` when the player's game wore an item down in use, `use` for food, potions and ointments, `shot` for a fired round, `pickpocket`, `trade` for a vendor deal, `drop` for `player.dropInventory`, or the ground, stash and gathering reasons.
+     * `add`, `remove`, `properties`, `set`, `transfer`, `wear` when the player's game wore an item down in use, `use` for food, potions and ointments, `shot` for a fired round, `pickpocket`, `trade` for a vendor deal, `repair` for a repair kit, `drop` for `player.dropInventory`, or the ground, stash and gathering reasons.
      */
     reason: string;
 
@@ -1696,7 +1862,7 @@ declare global {
     ok: boolean;
 
     /**
-     * Empty on success, otherwise why not: `inventoryUnavailable`, `invalidRequest`, `staleRevision`, `invalidItem`, `invalidItems`, `invalidAmount`, `unknownItem`, `insufficientItems`, `inventoryCapacity`, `sameInventory`, or a property policy code (`invalidMetadata`, `unknownItemClass`, `questItem`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
+     * Empty on success, otherwise why not: `inventoryUnavailable`, `invalidRequest`, `staleRevision`, `invalidItem`, `invalidItems`, `invalidAmount`, `unknownItem`, `insufficientItems`, `inventoryCapacity`, `sameInventory`, `invalidEquipment`, or a property policy code (`invalidMetadata`, `unknownItemClass`, `questItem`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
      */
     code: string;
 
@@ -1722,14 +1888,14 @@ declare global {
     get(player: Player): InventoryState | null;
 
     /**
-     * Gives a player items of a class, 1 to 10000 at a time. `item` is the class GUID or the exact name the game's own item tables use, the same spelling `giveItem` takes. Left-out properties mean quality 1 at full condition; `metadata.quality` asks for a higher tier, up to what the class is made in, and `invalidQuality` refuses one past it. The units join the row that already holds this class with these properties, if there is one.
+     * Gives a player items of a class, 1 to 10000 at a time. `item` is the class GUID or the exact name the game's own item tables use, the same spelling `giveItem` takes. Left-out properties mean quality 1 at full condition; `metadata.quality` asks for a higher tier, up to what the class is made in, and `invalidQuality` refuses one past it. The units join the row that already holds this class with these properties, if there is one. The player's game announces them with its own "You received" toast unless `notify` is false.
      */
-    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number }): InventoryResult;
+    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number; notify?: boolean }): InventoryResult;
 
     /**
-     * Takes exact units from named rows, every one of them or none.
+     * Takes exact units from named rows, every one of them or none. The player's game announces the loss with its own toast unless `notify` is false.
      */
-    remove(player: Player, request: { units: InventoryUnit[]; revision?: number }): InventoryResult;
+    remove(player: Player, request: { units: InventoryUnit[]; revision?: number; notify?: boolean }): InventoryResult;
 
     /**
      * Replaces a row's properties. The row keeps its identity and amount. It replaces rather than merges: carry over anything you want to keep, and give `health` or `condition`, not two that disagree.
@@ -1737,14 +1903,14 @@ declare global {
     setProperties(player: Player, request: { id: string; metadata: Record<string, unknown>; revision?: number }): InventoryResult;
 
     /**
-     * Replaces a player's whole inventory, which is how a saved one comes back. Rows keep the ids they are given (letters, digits and `-_:.`, up to 64) and get new ones when they have none. `equipped` is how many units of a gear row the body wears, up to 48 in all; their game dresses in them. An empty list clears the inventory.
+     * Replaces a player's whole inventory, which is how a saved one comes back. It is never announced in the player's game. Rows keep the ids they are given (letters, digits and `-_:.`, up to 64) and get new ones when they have none. `equipped` is how many units of a gear row the body wears, up to 48 in all; their game dresses in them. An empty list clears the inventory.
      */
     set(player: Player, request: { items: { id?: string; item: string; amount: number; metadata?: Record<string, unknown>; equipped?: number }[]; revision?: number }): InventoryResult;
 
     /**
-     * Moves exact units from one player to another with their properties, all or nothing. They join matching rows in the target, so the target's row ids are the ones in the result's `items`. Whether the two may trade -- distance, consent, price -- is for the script to decide.
+     * Moves exact units from one player to another with their properties, all or nothing. They join matching rows in the target, so the target's row ids are the ones in the result's `items`. Whether the two may trade -- distance, consent, price -- is for the script to decide. Both players' games announce what they lost and gained unless `notify` is false.
      */
-    transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number }): InventoryResult;
+    transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number; notify?: boolean }): InventoryResult;
 
     /**
      * What the game prices one unit of an item at, in money units, worked out the way the game does it. `pristine` is the price at the best health its quality allows, `current` at its own health. Quality changes the price only through that health. The metadata reads as `Inventory.add` reads it -- left out, quality 1 at full condition -- so `Inventory.getItemPrice(row.item, row.metadata)` prices a row. This is the item's own worth: what the game's shopkeepers would ask depends on their terms and the haggling, and a `Vendor` charges whatever its script says.
@@ -3009,12 +3175,12 @@ declare global {
      * @param model Mesh to build, as either a full catalog path (`objects/manmade/barrels/barrel_a.cgf`) or its file stem (`barrel_a`). A stem several meshes share resolves to the first of them, so pass the path when it matters which. A mesh this server streams -- a `.cgf` in a resource's `stream/objects/kcdc/<resource>/` folder -- is named by its full path, `objects/kcdc/<resource>/chair.cgf`; a player whose game does not have it yet sees the prop as soon as it does.
      * @param position Optional world-space spawn position; omitted components default to zero.
      * @param rotation Optional initial orientation: a Quaternion, or a Vector3 of Euler angles in degrees.
-     * @param scale Optional uniform scale from 0.01 to 100; omitted spawns the mesh at its own size.
+     * @param scale Uniform size or separate X/Y/Z sizes, each from 0.01 to 100. Omitted uses the mesh size. Nonuniform collision follows the native engine limitations.
      * @param physics Optional collision: `static` (the default), `rigid` or `none`.
      * @param virtualWorld Optional virtual world the prop belongs to; omitted puts it in the global one.
      * @returns The newly spawned prop handle.
      */
-    static spawn(model: string, position?: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, scale?: number, physics?: string, virtualWorld?: number): Prop;
+    static spawn(model: string, position?: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, scale?: number | Vector3, physics?: string, virtualWorld?: number): Prop;
 
     /**
      * Lists every prop the server currently has.
@@ -3536,7 +3702,7 @@ declare global {
    */
   class LevelEdit {
     /**
-     * Wraps an edit the server already holds; use LevelEdit.apply or LevelEdit.applyMap to make one.
+     * Wraps an edit the server already holds; use LevelEdit.apply to make one, or WorldResource for a whole export.
      * @param id Network entity identifier.
      */
     constructor(id: number);
@@ -3620,14 +3786,6 @@ declare global {
      */
     static apply(definition: LevelEditDefinition, virtualWorld?: number): LevelEdit;
 
-    /**
-     * Applies every entry of a map's `world` array, which is how edits made in the World Builder reach every player instead of being loaded by hand on each.
-     * @param map A World Builder map saved from the editor, as its JSON text or the parsed object. Only its `world` array is read: its placed objects are `Prop.spawn`'s, its areas `Area.create`'s.
-     * @param virtualWorld Optional virtual world whose players see the edits; the global one when omitted.
-     * @returns One edit per entry, in the map's order. Throws, naming the entry, for one no client could find the object by.
-     */
-    static applyMap(map: string | Record<string, unknown>, virtualWorld?: number): LevelEdit[];
-
     /**
      * Lists every edit the server currently has.
      * @param virtualWorld Optional virtual world to list; omitted lists every one of them.
@@ -4557,7 +4715,7 @@ declare global {
   }
 
   /**
-   * Replicated handle for one of the level's animated gates.
+   * Replicated handle for one of the level's castle gates.
    */
   class Gate {
     /**
@@ -4567,12 +4725,12 @@ declare global {
     constructor(id: number);
 
     /**
-     * The level's own EntityGuid, as sixteen lowercase hex digits. The same on every machine, so it is the identity to store a gate under; `Gate.find` takes it back.
+     * The level's own EntityGuid, as sixteen lowercase hex digits. The same on every machine, so it is the identity to store a gate under; `Gate.find` takes it back. A `gate` has no entity of its own, so its key is the GUID of the layer that draws it shut.
      */
     readonly guid: string;
 
     /**
-     * What piece of architecture this is: `drawbridge` or `portcullis`. The shipped game has two in total.
+     * What piece of architecture this is: `drawbridge` or `portcullis`, which animate, or `gate`, a pair of leaves the level swaps between drawn open and drawn shut -- the Ratborsch and Nebakov fortress gates and the Ruthard palace gate. A `gate` opens and closes at once.
      */
     readonly kind: string;
 
@@ -4592,7 +4750,7 @@ declare global {
     readonly moving: boolean;
 
     /**
-     * How long opening takes, in seconds, from the key range the asset's animation database stores. A gate with no opening clip runs its closing one backwards, so this is that clip's length.
+     * How long opening takes, in seconds, from the key range the asset's animation database stores. A gate with no opening clip runs its closing one backwards, so this is that clip's length. 0 for a `gate`.
      */
     readonly openDuration: number;
 
@@ -4743,7 +4901,7 @@ declare global {
     load(): SiegeResult;
 
     /**
-     * Turns a loaded engine to face the target and shoots at it. A trebuchet's arm lets the stone go at one angle, so its speed is solved for the distance; a cannon fires at one speed, so its elevation is. The stone is let go partway through the shot (`seconds`), then every client nearby draws it along the same arc. It comes down where the world stops it, which the player nearest the target is asked to report, or on the target when nobody can.
+     * Turns a loaded engine to face the target and shoots at it. A trebuchet's arm lets the stone go at one angle, so its speed is solved for the distance; a cannon fires at one speed, so its elevation is. The stone is let go partway through the shot (`seconds`), then every client nearby draws it along the same arc. It comes down where the world stops it, which the attacker is asked to report when near enough, else the player nearest the target, or on the target when nobody can.
      * @param target Where the projectile should come down.
      * @param attacker The player credited with whatever it hits, in `playerDamage`, `npcDamage` and `siegeImpact`.
      * @returns What happened, and the phrase to explain it with when nothing did.
@@ -5091,6 +5249,71 @@ declare global {
     static all(kind?: 'level' | 'script'): Area[];
   }
 
+  /**
+   * A named world export loaded from mod.world_resources. Server-owned, with live access to its surviving props, effects, level edits and areas. Obtain handles through all or find; runtime loading, reloading and unloading are not exposed.
+   */
+  class WorldResource {
+    private constructor();
+
+    /**
+     * Unique case-sensitive resource name: the filename without .world.json, or the explicit config name. Empty after shutdown.
+     */
+    readonly name: string;
+
+    /**
+     * Resolved absolute source file path, in UTF-8. Empty after shutdown.
+     */
+    readonly path: string;
+
+    /**
+     * The exported game level, checked against the server level at startup. Empty after shutdown.
+     */
+    readonly level: string;
+
+    /**
+     * Whether this export is registered. Remains true even if scripts destroy all of its contents.
+     */
+    readonly loaded: boolean;
+
+    /**
+     * A fresh array of surviving props in export order. Changing the array does not change membership; the handles support normal Prop operations.
+     */
+    readonly props: Prop[];
+
+    /**
+     * A fresh array of surviving effects in export order, excluding destroyed effects.
+     */
+    readonly effects: Vfx[];
+
+    /**
+     * A fresh array of surviving level edits in export order, excluding restored edits.
+     */
+    readonly levelEdits: LevelEdit[];
+
+    /**
+     * A fresh array of surviving exported areas in export order, excluding destroyed areas.
+     */
+    readonly areas: Area[];
+
+    /**
+     * True after every configured export has loaded successfully, even when the config list is empty. Check this before subscribing to worldResourcesReady when a script may start later.
+     */
+    static readonly ready: boolean;
+
+    /**
+     * Lists config-loaded world exports in configuration order. Empty before successful startup and after shutdown.
+     * @returns A fresh array of resource handles.
+     */
+    static all(): WorldResource[];
+
+    /**
+     * Finds a config-loaded export by name. Throws for a non-string argument.
+     * @param name Exact, case-sensitive resource name.
+     * @returns The resource, or null when absent or startup has not completed.
+     */
+    static find(name: string): WorldResource | null;
+  }
+
   /**
    * Container handle for a spawned chest, a level chest, or virtual stock without a world entity.
    */
@@ -7289,6 +7512,8 @@ declare global {
    * Arbitrary key/value state attached to one replicated entity, reached as `entity.state`. Keys set on the server replicate to every client that can currently see the entity.
    */
   class StateBag {
+    private constructor();
+
     /**
      * Reads one key from this entity's state.
      * @param key Key to read.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingdomsconnected/types",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "TypeScript declarations for the Kingdoms Connected scripting API, one entry per side: @kingdomsconnected/types/server and @kingdomsconnected/types/client",
   "license": "UNLICENSED",
   "keywords": [