@wayward/types 2.14.2-beta.dev.20241222.1 → 2.14.3-beta

package/definitions/game/ui/screen/screens/game/component/container/ContainerBucketItemList.d.ts

@@ -22,6 +22,7 @@ import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemCo
 import type { IDraggableComponentSubscriber, ISortableComponent, WithSortableEvents } from "@wayward/game/ui/util/Sortable";
 import Sortable from "@wayward/game/ui/util/Sortable";
 import { type IEventEmitter } from "@wayward/utilities/event/EventEmitter";
+import type { IMoveItemFilterArgument } from "@wayward/game/game/entity/action/actions/moveItem/MoveItemFilterArgument";
 export declare enum ContainerBucketItemListClasses {
     Main = "container-bucket-item-list",
     Anchored = "container-bucket-item-list-anchored",
@@ -29,7 +30,7 @@ export declare enum ContainerBucketItemListClasses {
     ActualTransferDestination = "container-bucket-item-list-actual-transfer-destination",
     HasStackExpanded = "container-bucket-item-list-has-stack-expanded"
 }
-export interface IContainerBucketItemListTransferDetails {
+export interface IContainerBucketItemListTransferDetails extends Omit<IMoveItemFilterArgument, "type"> {
     fromList?: ContainerBucketItemList;
     toList?: ContainerBucketItemList;
     fromContainer?: IContainer;
@@ -37,15 +38,11 @@ export interface IContainerBucketItemListTransferDetails {
     item?: Item;
     itemType: ItemType;
     moveAll: boolean;
-    moveLimit?: number;
     stackList?: ContainerBucketItemList;
     quality?: Quality;
-    text?: string;
-    excludeProtected?: true;
     index?: number;
     silent?: true;
     hidden?: true;
-    excludeEquipped?: boolean;
 }
 export interface IContainerBucketItemListEvents extends WithSortableEvents<Component> {
     addItem(item: Item): any;
@@ -81,9 +78,10 @@ export default class ContainerBucketItemList extends Component implements ISorta
     private containerRef?;
     get container(): IContainer | undefined;
     isStacked(type?: ItemType): boolean;
+    /**
+     * Returns whether this item's type is stacked in this container, *and* this item is not protected.
+     */
     isStacked(item?: Item): boolean;
-    isFirstVisiblyStacked(item?: Item, excluding?: Item): boolean;
-    getStackedItemsThatAreVisible(type?: ItemType, excluding?: Item): Item[];
     getStackedItems(type?: ItemType, excluding?: Item): Item[];
     getStackIndex(type?: ItemType): number | undefined;
     constructor(container?: IContainer);
@@ -148,6 +146,7 @@ export default class ContainerBucketItemList extends Component implements ISorta
     private getItemIdsInElements;
     private getItemElementId;
     private getItemComponentElements;
+    private getItemComponentById;
     private regenerate;
     private transfer;
     private getSorter;

package/definitions/game/ui/screen/screens/game/component/item/IItemComponent.d.ts

@@ -0,0 +1,65 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export declare enum ItemDetailIconLocation {
+    TopLeft = 0,
+    BottomRight = 1
+}
+export declare enum ItemClasses {
+    Main = "item-component",
+    _InHeading = "item-component--in-heading",
+    Active = "active",// currently used for crafting & trading
+    Icon = "item-component-icon",
+    ItemIconIsReal = "item-component-icon-item-is-real",
+    ActionIcon = "item-component-icon-action",
+    ActionIconAnyItem = "item-component-icon-action-any-item",
+    ActionIconMissingItem = "item-component-icon-action-missing-item",
+    ActionIconHasItem = "item-component-icon-action-has-item",
+    ActionIconNone = "item-component-icon-action-none",
+    TargetIcon = "item-component-icon-target",
+    TargetIcon_Creature = "item-component-icon-target--creature",
+    TargetIcon_Doodad = "item-component-icon-target--doodad",
+    TargetIcon_Vehicle = "item-component-icon-target--vehicle",
+    TargetIcon_Plant = "item-component-icon-target--plant",
+    TargetIcon_NPC = "item-component-icon-target--npc",
+    TargetIcon_TileEvent = "item-component-icon-target--tile-event",
+    SlottedIcon = "item-component-icon-slotted",
+    Equipped = "item-component-equipped",
+    EquipIcon = "item-component-icon-equip",
+    EquipIconHasItem = "item-component-icon-equip-has-item",
+    MagicalIcon = "item-component-icon-magical",
+    ProtectedIcon = "item-component-icon-protected",
+    Trading = "item-component-trading",
+    TradingIcon = "item-component-icon-trading",
+    TradingIconFromMerchant = "item-component-icon-trading-from-merchant",
+    TradingIconToMerchant = "item-component-icon-trading-to-merchant",
+    Slot = "item-component-slot",
+    Dragging = "item-component-dragging",
+    DragPreview = "item-component-drag-preview",
+    DragPreview_Small = "item-component-drag-preview--small",
+    StatBar = "item-component-stat-bar",
+    StatBars = "item-component-stat-bars-wrapper",
+    DecayBar = "item-component-stat-bar-decay",
+    CooldownBar = "item-component-stat-bar-cooldown",
+    DurabilityBar = "item-component-stat-bar-durability",
+    NearlyDestroyed = "item-component-nearly-destroyed",
+    NearlyDecayed = "item-component-nearly-decayed",
+    Transient = "item-component-transient",
+    Highlight = "item-component-highlight",
+    Stack = "item-component-stack",
+    StackQuantity = "item-component-stack-quantity",
+    StackQuantityX = "item-component-stack-quantity-x",
+    StackQuantityDigit = "item-component-stack-quantity-digit",
+    Stacked = "item-component-stacked",
+    StackedVisible = "item-component-stacked-visible"
+}
+export declare namespace ItemClasses {
+    const IconLocation: (enumValue: ItemDetailIconLocation) => "item-component-icon-location-topleft" | "item-component-icon-location-bottomright";
+}

package/definitions/game/ui/screen/screens/game/component/item/ItemComponentEventBus.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { GlobalMouseInfo } from "@wayward/game/ui/input/InputManager";
+import { type ItemRefreshType } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type ActionBar from "@wayward/game/ui/screen/screens/game/static/ActionBar";
+import type { ActionSlot } from "@wayward/game/ui/screen/screens/game/static/actions/ActionSlot";
+import EventEmitter from "@wayward/utilities/event/EventEmitter";
+interface IItemComponentEventBusEvents {
+    update(type: ItemRefreshType): any;
+    changeHovered(): any;
+}
+declare namespace _ {
+    class ItemComponentEventBus extends EventEmitter.Host<IItemComponentEventBusEvents> {
+        private readonly items;
+        private readonly itemsForTickEndEvents;
+        registerItem(component: ItemComponent): void;
+        registerForTickEndEvents(component: ItemComponent): void;
+        deregisterForTickEndEvents(component: ItemComponent): void;
+        protected onUpdate(type: ItemRefreshType): void;
+        protected onSlotUpdate(actionBar: ActionBar, slot: ActionSlot): void;
+        protected onTickEnd(): void;
+        protected onLoadedOnIsland(): void;
+        protected onActionBarItemSlottedMapUpdate(): void;
+        private hovered;
+        protected onUpdateTarget(mouse: GlobalMouseInfo): void;
+    }
+}
+type ItemComponentEventBus = _.ItemComponentEventBus;
+declare function ItemComponentEventBus(): ItemComponentEventBus;
+export default ItemComponentEventBus;

package/definitions/game/ui/screen/screens/game/component/item/ItemComponentHandler.d.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type UsableAction from "@wayward/game/game/entity/action/usable/UsableAction";
+import type { EquipType } from "@wayward/game/game/entity/IHuman";
+import type { Quality } from "@wayward/game/game/IObject";
+import type { ItemTypeExtra, IContainer } from "@wayward/game/game/item/IItem";
+import { ItemType } from "@wayward/game/game/item/IItem";
+import type Item from "@wayward/game/game/item/Item";
+import type Bindable from "@wayward/game/ui/input/Bindable";
+import type { ActionSlot } from "@wayward/game/ui/screen/screens/game/static/actions/ActionSlot";
+import type Sortable from "@wayward/game/ui/util/Sortable";
+export interface IItemComponentHandlerDescription {
+    noDrag?: true;
+    equipSlot?: EquipType;
+    hasHighlight?: SupplierOr<boolean>;
+    getItem?(): Item | undefined;
+    getItemType?(): ItemType | ItemTypeExtra | undefined;
+    getItemQuality?(): ArrayOr<Quality> | undefined;
+    getAction?(): UsableAction | undefined;
+    getActionSlot?(): ActionSlot | undefined;
+    getBindables?(bindables: Bindable[]): Bindable[];
+    getSortable?(): Sortable;
+    getStackQuantity?(): number;
+    getContainer?(): IContainer | undefined;
+    getStackItems?(): readonly Item[];
+    getStackDisplayItem?(): Item | undefined;
+    getDisplayItem?(): Item | undefined;
+    getDurability?(): number;
+    getCooldown?(): number;
+    isDamaged?(): boolean;
+    isDecayed?(): boolean;
+}
+export interface ItemComponentHandler extends IItemComponentHandlerDescription {
+}
+export declare class ItemComponentHandler {
+    readonly isItemComponentHandler = true;
+    constructor(description?: IItemComponentHandlerDescription);
+}

package/definitions/game/ui/screen/screens/game/component/item/ItemComponentTradeManager.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type Human from "@wayward/game/game/entity/Human";
+import type MerchantNPC from "@wayward/game/game/entity/npc/npcs/Merchant";
+import type Item from "@wayward/game/game/item/Item";
+import { ItemTradeType } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import WeakishSet from "@wayward/utilities/collection/set/WeakishSet";
+declare namespace _ {
+    class ItemComponentTradeManager {
+        private readonly tradingByItem;
+        private readonly tradingToMerchant;
+        private readonly tradingFromMerchant;
+        getTrading(merchant: MerchantNPC, type: ItemTradeType): WeakishSet<Item> | undefined;
+        getTradeType(item: Item): ItemTradeType | undefined;
+        isTrading(item: Item, merchant: MerchantNPC): boolean;
+        toggleTrading(items: Item[], merchant: MerchantNPC, trading: ItemTradeType): ItemTradeType;
+        private sendMerchantChatMessage;
+        clearTrading(merchant?: MerchantNPC): void;
+        onTrade(merchant: MerchantNPC, human: Human): void;
+    }
+}
+type ItemComponentTradeManager = _.ItemComponentTradeManager;
+declare function ItemComponentTradeManager(): ItemComponentTradeManager;
+export default ItemComponentTradeManager;

package/definitions/game/ui/screen/screens/game/dialog/EquipmentDialog.d.ts

@@ -14,8 +14,8 @@ import Component from "@wayward/game/ui/component/Component";
 import type { IBindHandlerApi } from "@wayward/game/ui/input/Bind";
 import Bindable from "@wayward/game/ui/input/Bindable";
 import Dialog from "@wayward/game/ui/screen/screens/game/component/Dialog";
-import type { IItemDropApi, IItemPickUpApi, ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
-import ItemComponent, { ItemRefreshType } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import { ItemRefreshType, type IItemDropApi, type IItemPickUpApi, type ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
 import EquipmentSlotTooltipHandler from "@wayward/game/ui/screen/screens/game/dialog/equipment/EquipmentSlotTooltip";
 import { MenuBarButtonType } from "@wayward/game/ui/screen/screens/game/static/menubar/IMenuBarButton";
 export declare enum EquipmentClasses {

package/definitions/game/ui/screen/screens/game/static/actions/ActionSlot.d.ts

@@ -25,10 +25,12 @@ import Component from "@wayward/game/ui/component/Component";
 import type { IRefreshable } from "@wayward/game/ui/component/Refreshable";
 import Text from "@wayward/game/ui/component/Text";
 import type { IBindHandlerApi } from "@wayward/game/ui/input/Bind";
-import type { IItemSlotEvents, ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
-import ItemComponent, { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import { type IItemSlotEvents, type ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/item/ItemComponentHandler";
 import type ActionBar from "@wayward/game/ui/screen/screens/game/static/ActionBar";
 import { ActionSlotUpdateReason, IActionBarSlotData } from "@wayward/game/ui/screen/screens/game/static/actions/IActionBar";
+import { ActionSlotInternalType } from "@wayward/game/ui/screen/screens/game/static/actions/IActionsDrawer";
 import type TooltipLocationHandler from "@wayward/game/ui/tooltip/TooltipLocationHandler";
 import type { Events, IEventEmitter } from "@wayward/utilities/event/EventEmitter";
 export declare enum ActionSlotClasses {
@@ -49,10 +51,6 @@ export declare enum ActionSlotClasses {
     History_Cleared = "game-action-slot-history--cleared",
     ItemComponent = "game-action-slot-item-component"
 }
-export declare enum ActionSlotType {
-    Normal = 0,
-    History = 1
-}
 export interface IActionSlotEvents extends Events<Button>, IItemSlotEvents {
     update(data: IActionBarSlotData | undefined, oldData: IActionBarSlotData | undefined, reason: ActionSlotUpdateReason): any;
     unequipItem(): any;
@@ -61,9 +59,9 @@ export interface IActionSlotEvents extends Events<Button>, IItemSlotEvents {
 export declare class ActionSlot extends Button implements IRefreshable, ItemSlot {
     readonly number: number;
     slotData: IActionBarSlotData;
-    readonly type: ActionSlotType;
+    readonly type: ActionSlotInternalType;
     static getHovered(): ActionSlot | undefined;
-    static tryCreate(number: number, slotData: IActionBarSlotData, type?: ActionSlotType): ActionSlot;
+    static tryCreate(number: number, slotData: IActionBarSlotData, type?: ActionSlotInternalType): ActionSlot;
     event: IEventEmitter<this, IActionSlotEvents>;
     private get actionBar();
     readonly label: Text;
@@ -75,7 +73,7 @@ export declare class ActionSlot extends Button implements IRefreshable, ItemSlot
     private lastItem?;
     private lastQuality?;
     usability: ReturnableUsableActionUsability;
-    protected constructor(number: number, slotData: IActionBarSlotData, type?: ActionSlotType);
+    protected constructor(number: number, slotData: IActionBarSlotData, type?: ActionSlotInternalType);
     isTransientSlot(): boolean;
     getItemComponent(): ItemComponent | undefined;
     private skipNextClick;
@@ -119,7 +117,7 @@ export declare class ActionSlot extends Button implements IRefreshable, ItemSlot
     getActionId(): ActionId | undefined;
     getInternalActionType(): ActionType | undefined;
     private usingCache?;
-    getUsing(fresh?: true): IUsableActionPossibleUsing | undefined;
+    getUsing(fresh?: true, forceWithHoveredTile?: true): IUsableActionPossibleUsing | undefined;
     private getBindingText;
 }
 declare class ActionSlotSlottedContainer extends ItemComponent {

package/definitions/game/ui/screen/screens/game/static/actions/ActionSlotConfigurationColumn.d.ts

@@ -22,8 +22,9 @@ import HorizontalLine from "@wayward/game/ui/component/HorizontalLine";
 import RangeChoiceList from "@wayward/game/ui/component/RangeChoiceList";
 import Text, { Heading, Paragraph } from "@wayward/game/ui/component/Text";
 import ItemDropdown from "@wayward/game/ui/component/dropdown/ItemDropdown";
-import type { IItemComponentHandlerDescription, IItemDropApi, IItemSlotEvents, ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type { IItemDropApi, ItemSlot, IItemSlotEvents } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
 import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type { IItemComponentHandlerDescription } from "@wayward/game/ui/screen/screens/game/component/item/ItemComponentHandler";
 import type { Events, IEventEmitter } from "@wayward/utilities/event/EventEmitter";
 export declare enum ActionSlotConfigurationColumnClasses {
     Main = "game-action-configuration-drawer-configuration-column",

package/definitions/game/ui/screen/screens/game/static/actions/IActionsDrawer.d.ts

@@ -11,7 +11,7 @@
 export declare enum ActionSort {
     Default = 0
 }
-export declare enum ActionSlotItemMethod {
-    ExactItem = 0,
-    AnyItem = 1
+export declare enum ActionSlotInternalType {
+    Normal = 0,
+    History = 1
 }

package/definitions/game/utilities/Version.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import TranslationImpl from "@wayward/game/language/impl/TranslationImpl";
+import type { IBuildId } from "@wayward/hosts/shared/globalTypes";
 export interface IVersionInfo {
     str: Version.String;
     strSemver: Version.StringSemVer;
@@ -22,6 +23,12 @@ export interface IVersionInfo {
      * A number representing the patch (if beta) or minor (if release), used when the stage is not known
      */
     update?: number;
+    buildId?: IBuildId;
+}
+export declare namespace IVersionInfo {
+    interface WithBuildId extends IVersionInfo {
+        buildId: IBuildId;
+    }
 }
 declare namespace Version {
     export type Stage = "beta" | "release";
@@ -29,8 +36,10 @@ declare namespace Version {
     export type StringSemVer = `${bigint}.${bigint}.${bigint}-${Stage}` | `${bigint}.${bigint}.${bigint}`;
     export type Month = "jan" | "feb" | "mar" | "apr" | "may" | "jun" | "jul" | "aug" | "sep" | "oct" | "nov" | "dec";
     export type DateString = `${Month} ${bigint} ${bigint} ${bigint | "00"}:${bigint | "00"}`;
+    export type StringBuildId = `${String}-dev${bigint}.${bigint}` | `${String}-dev${bigint}`;
     export const versionInfoRegExp: RegExp;
     export const versionInfoRegExpSemver: RegExp;
+    export const versionInfoWithBuildIdRegExp: RegExp;
     /**
      * Returns whether the given version is compatible with the game's version. This is used to check, for example,
      * if a mod is compatible with the game's version.
@@ -46,20 +55,20 @@ declare namespace Version {
      * - Compatible versions in "beta" stage require identical stage, major, minor, and a patch less than or equal to the current patch.
      * - Compatible versions in "release" stage require identical stage and major, and a minor and patch less than or equal to the current minor and patch.
      */
-    export function is(versionA: IVersionInfo | Version.String | Version.StringSemVer, versionB: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+    export function is(versionA?: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId, versionB?: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
     /**
      * Returns whether the given `version` is `atLeast` another version. This can be used, for example,
      * to see if a save or mod was created/edited after a specific thing was implemented.
      */
-    export function isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer, atLeast: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+    export function isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId, atLeast: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
     /**
      * Returns if `checkVersion` is older than `isBefore`
      */
     export function isBefore(checkVersion: IVersionInfo | Version.String | Version.StringSemVer, isBefore: IVersionInfo | Version.String | Version.StringSemVer): boolean;
     export function createRawVersionInfo(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): IVersionInfo;
-    export function convertStringToRawInfo(version: Version.String | Version.StringSemVer): IVersionInfo;
+    export function convertStringToRawInfo(version: Version.String | Version.StringSemVer | Version.StringBuildId): IVersionInfo;
     export function create(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): Info;
-    export function getVersionInfo(version: IVersionInfo | Version.String | Version.StringSemVer): Info;
+    export function getVersionInfo(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): Info;
     export function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
     export function getVersionDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo, development?: boolean): TranslationImpl;
     export function getUpdateDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo): TranslationImpl | undefined;
@@ -85,16 +94,16 @@ declare namespace Version {
          * Returns whether this version is greater than or equal to the given version. This can be used, for example,
          * to see if a save or mod was created/edited after a specific thing was implemented.
          */
-        isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+        isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
         /**
          * Returns whether this version is greater than or equal to the given version. This can be used, for example,
          * to see if a save or mod was created/edited after a specific thing was implemented.
          */
-        is(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+        is(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
         /**
          * Returns whether this version is older than the given version.
          */
-        isBefore(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+        isBefore(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
         /**
          * Returns whether this version is older than the given build time.
          *

package/definitions/game/utilities/dev/Debug.d.ts

@@ -8,8 +8,12 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
+import DebugShared from "@wayward/utilities/dev/DebugShared";
 declare namespace Debug {
     function typeIfRelevant(type: string, name: string): string | undefined;
     function where(thing: unknown): string | undefined;
+    type JIT = DebugShared.JIT;
+    const JIT: typeof DebugShared.JIT;
+    const isJIT: typeof DebugShared.isJIT;
 }
 export default Debug;

package/definitions/game/utilities/memory/MemoryLeakDetector.d.ts

@@ -26,7 +26,7 @@ declare class MemoryLeakDetector {
     onScreenShow(_: any, screen: Screen): Promise<any>;
     private onReset;
     private runCheck;
-    garbageCollect(): Promise<void>;
+    garbageCollect(source: string): Promise<void>;
     private checkObjects;
 }
 export declare const memoryLeakDetector: MemoryLeakDetector;

package/definitions/game/utilities/object/Merge.d.ts

@@ -34,6 +34,8 @@ declare namespace Merge {
      */
     function MULTIPLY_NON_ZERO(amt: number): Mergeable<number> & number;
     function DIVIDE(amt: number): Mergeable<number> & number;
+    function MIN(amt: number): Mergeable<number> & number;
+    function MAX(amt: number): Mergeable<number> & number;
     function CONCAT(str: string): Mergeable<string> & string;
     /**
      * Note: "PUSH" is used by default for merging array values.

package/definitions/game/utilities/string/Interpolator.d.ts

@@ -23,12 +23,13 @@ export interface IInterpolationOptions {
     formatDates?: boolean;
 }
 export type Ends = [start: string, end?: string, endAtStringEnd?: true];
-export interface ISegment {
+export interface ISegment<T = unknown> {
     ends?: Ends[];
     trimTrailingWhitespace?: true;
-    match?: RegExp;
-    handle(match: RegExpMatchArray, segment: string, api: ISegmentApi, ...args: any[]): string | IStringSection | Iterable<IStringSection>;
+    match?: RegExp | ((segment: string) => T | undefined);
+    handle(match: T, segment: string, api: ISegmentApi, ...args: any[]): string | IStringSection | Iterable<IStringSection>;
 }
+export type IRegexSegment = ISegment<RegExpExecArray>;
 export interface IStringSection {
     content: string | IStringSection[];
     classes?: Set<string>;
@@ -92,12 +93,42 @@ export default Interpolator;
  * - `"{test}" => args[0]["test"]`
  * - `"{3.test.4.wow}" => args[3]["test"][4]["wow"]`
  */
-export declare const argumentSegment: ISegment;
+export declare const argumentSegment: IRegexSegment;
 export type InterpolationConditionalSegmentOperator = InterpolationConditionalSegmentOperatorEquivalence | InterpolationConditionalSegmentOperatorNumeric;
 export type InterpolationConditionalSegmentOperatorEquivalence = "=" | "!=";
 export type InterpolationConditionalSegmentOperatorNumeric = "<" | ">" | "<=" | ">=";
-export declare const conditionalSegment: ISegment;
-export declare const falsyCoalescingSegment: ISegment;
+export type ConditionalSegmentCheck = string | {
+    variable: string;
+    operator: InterpolationConditionalSegmentOperator;
+    value: string;
+    variable2?: never;
+} | {
+    variable: string;
+    operator: InterpolationConditionalSegmentOperator;
+    variable2: string;
+    value?: never;
+};
+export interface IConditionalSegmentExpression {
+    checks: ConditionalSegmentCheck[];
+    operator: "&" | "|";
+    length: number;
+}
+/**
+ * Uses an argument to determine whether to show one of two segments. If the argument is truthy, returns
+ * any content in the segment after the `?` and before the `:`. If the argument is falsey, returns any
+ * content in the segment after the `:`. The colon is optional; if not provided, falsey = empty string.
+ *
+ * - `"{0?hi}"`
+ * 	- When given `[true]`, `=> "hi"`
+ * 	- When given `[false]`, `=> ""`
+ * 	- When given `[]`, `=> ""`
+ * - `"{test?hi:bye}"
+ * 	- When given `[{test: true}]`, `=> "hi"`
+ * 	- When given `[{test: false}]`, `=> "bye"`
+ * 	- When given `[]`, `=> "bye"`
+ */
+export declare const conditionalSegment: ISegment<IConditionalSegmentExpression>;
+export declare const falsyCoalescingSegment: IRegexSegment;
 export declare const classSegment: ISegment;
 export declare const basicInterpolator: Interpolator;
 export declare function interpolateSectioned(str: string, ...args: any[]): IStringSection[];

package/definitions/hosts/shared/globalTypes.d.ts

@@ -42,6 +42,10 @@ export interface IWaywardTitleBar {
     isMaximized: boolean;
     electron: IElectron;
 }
+export interface IBuildId {
+    date: number;
+    number: number;
+}
 declare global {
     interface Window {
         require: any;

package/definitions/hosts/shared/globals.d.ts

@@ -9,8 +9,8 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IWaywardTitle } from "@wayward/hosts/shared/globalTypes";
-export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 14, gameVersionPatch = 2, gameVersionName = "Runekeeper", gameVersionColor = 11015763;
-export declare const gameVersion = "beta2.14.2";
+export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 14, gameVersionPatch = 3, gameVersionName = "Runekeeper", gameVersionColor = 11015763;
+export declare const gameVersion = "beta2.14.3";
 export declare const gameVersionTitleMajor = "Wayward: Runekeeper";
 export declare const gameVersionTitleMinor: string;
 export declare const gameVersionTitle: string;

package/definitions/utilities/Errors.d.ts

@@ -14,6 +14,16 @@ declare namespace Errors {
     function getStack(error: unknown): string | undefined;
     function getName(error: unknown): string | undefined;
     function getMessage(error: unknown): string | undefined;
+    /**
+     * Returns the callsite stack string starting from the caller of this function.
+     * @param skip The number of additional callsite strings to skip
+     * @param truncate The maximum number of callsite strings to include
+     */
+    function stack(skip?: number, truncate?: number): string;
+    /**
+     * Returns the Error callsite string for the caller of the current function.
+     */
+    function caller(skip?: number): string;
 }
 export default Errors;
 export declare function ensureExhaustive(value: never): never;

package/definitions/utilities/Functions.d.ts

@@ -9,7 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 declare namespace Functions {
-    const noOp: () => void;
+    const noOp: (...args: any[]) => void;
     const noOpString: () => string;
     const noOpZero: () => number;
     const noOpNull: () => null;

package/definitions/utilities/Log.d.ts

@@ -24,6 +24,7 @@ export interface ILog {
     trace(...args: any[]): void;
     warn(...args: any[]): void;
     setSources(...sources: string[]): void;
+    ifEnabled(logger: (log: this) => any): void;
 }
 export interface ILogLine {
     type: LogLineType;
@@ -35,6 +36,7 @@ declare abstract class BaseLog implements ILog {
     info: (...args: any[]) => void;
     trace: (...args: any[]) => void;
     warn: (...args: any[]) => void;
+    ifEnabled: (logger: (log: this) => any) => void;
     protected sources: string[];
     constructor(...sources: Array<BaseLog | string>);
     setSources(...sources: Array<BaseLog | string>): void;
@@ -118,11 +120,18 @@ declare namespace Log {
      * @param sources A list of sources to log to.
      */
     function debug(...sources: string[]): (...args: any[]) => void;
+    function ifEnabled(...sources: string[]): (logger: (log: ILog) => any) => void;
+    function ifEnabled<LOG extends ILog>(log: LOG, ...sources: string[]): (logger: (log: LOG) => any) => void;
     /**
      * Returns a method that can be used to `Log.trace` with the given sources.
      * @param sources A list of sources to log to.
      */
     function trace(...sources: string[]): (...args: any[]) => void;
+    /**
+     * Warn about something once per session based on unique warning ids.
+     * This is like how node.js does warnings in console.
+     */
+    function warnOncePerSession(warningId: string | string[], ...message: any[]): void;
 }
 declare class NullLog extends BaseLog {
     setup(): void;

package/definitions/utilities/collection/map/IterableWeakMap.d.ts

@@ -0,0 +1,35 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+/**
+ * Strong keys are stored in a Map.
+ * Weak keys are stored in a WeakMap.
+ * Based on https://github.com/tc39/proposal-weakrefs?tab=readme-ov-file#iterable-weakmaps
+ */
+export declare class IterableWeakMap<K, V> implements Iterable<[K, V]> {
+    #private;
+    constructor(iterable?: Iterable<[K, V]>);
+    /**
+     * This is more of an estimate since we might be waiting for some garbage collection to happen
+     */
+    get size(): number;
+    /**
+     * This will cause keys that are cleaned up via garbage collection to be logged
+     */
+    enableLogging(): IterableWeakMap<K, V>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    [Symbol.iterator](): Generator<[K, V]>;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    private isWeakKey;
+}