afnm-types 0.6.31 → 0.6.34

package/dist/GameScreen.d.ts

@@ -1 +1 @@
-export type GameScreen = 'location' | 'recipe' | 'mission' | 'craftingHall' | 'manual' | 'cultivation' | 'map' | 'healer' | 'market' | 'favour' | 'herbField' | 'mine' | 'recipeLibrary' | 'requestBoard' | 'compendium' | 'library' | 'altar' | 'research' | 'reforge' | 'pillarGrid' | 'fallenStar' | 'trainingGround' | 'lifeScreen';
+export type GameScreen = 'location' | 'recipe' | 'mission' | 'craftingHall' | 'manual' | 'cultivation' | 'map' | 'healer' | 'market' | 'favour' | 'herbField' | 'mine' | 'recipeLibrary' | 'requestBoard' | 'compendium' | 'library' | 'altar' | 'research' | 'reforge' | 'pillarGrid' | 'fallenStar' | 'trainingGround' | 'tenThousandFlames' | 'lifeScreen';

package/dist/alternativeStart.d.ts

@@ -27,9 +27,8 @@ export interface AlternativeStart {
      */
     rootEvent: GameEvent;
     /**
-     * The starting location name. This becomes the root for location discovery
-     * (used by discoverUnlockedLocations). All location searches will branch
-     * from this location.
+     * The starting location name. This location will be registered as a root
+     * for discovery (if not already) and the player will start here.
      */
     startLocation: string;
     /**

package/dist/breakthrough.d.ts

@@ -13,33 +13,22 @@ export interface Position {
 export interface PositionAndRotation extends Position {
     rotation: number;
 }
-/** Tracks which of the 6 core essences have been placed in the gate */
-export interface EssenceGate {
-    breath: boolean;
-    pulse: boolean;
-    echo: boolean;
-    growth: boolean;
-    marrow: boolean;
-    scar: boolean;
-}
-/** A lifeform stored in the player's soul realm */
-export interface StoredLifeform {
+/** A figment stored in the player's soul realm */
+export interface StoredFigment {
     id: string;
-    baseForm: string;
-    currentForm: string;
-    slottedEssences: string[];
+    primarySpecies?: string;
+    secondarySpecies?: string;
+    customName?: string;
+    autoName?: string;
     stances: StoredStance[];
     currentStyle?: StoredStyle;
     storedStyles?: StoredStyle[];
-    evolutionPath: string[];
 }
 /** State for the Life Flourishing breakthrough system */
 export interface LifeFlourishingState {
-    essenceGate: EssenceGate;
-    storedLifeforms: StoredLifeform[];
-    manifestedLifeformId?: string;
-    fightsInstead?: boolean;
-    creatingNewLifeform?: boolean;
+    unlockedSpecies: string[];
+    storedFigments: StoredFigment[];
+    manifestedFigmentId?: string;
 }
 export interface BreakthroughState {
     mundane?: {

package/dist/buff.d.ts

@@ -2,6 +2,7 @@ import { Translatable } from './translatable';
 import { TechniqueElement } from './element';
 import { CombatStatistic, Scaling } from './stat';
 import { DamageType } from './DamageType';
+import type { CombatEntity } from './entity';
 export type TechniqueCondition = ChanceTechniqueCondition | BuffTechniqueCondition | HpTechniqueCondition | ConditionTechniqueCondition;
 export type DamageModifier = MultiplyDamageModifier | ReduceDamageModifier | ExpressionDamageModifier;
 interface MultiplyDamageModifier {
@@ -39,6 +40,7 @@ interface ConditionTechniqueCondition {
 }
 export interface Buff {
     name: string;
+    displayName?: Translatable;
     icon: string;
     colour?: string;
     canStack: boolean;
@@ -55,11 +57,10 @@ export interface Buff {
     charisma?: number;
     masteryPoints?: number;
     speed?: number;
-    applicationStats?: Record<CombatStatistic, number>;
-    applicationVariables?: Record<string, number>;
-    appliedByOpponent?: boolean;
+    applicationEntity?: CombatEntity;
     allowMultipleInstances?: boolean;
     storedVariables?: Record<string, string>;
+    storedValues?: Record<string, number>;
     uniqueId?: string;
     internalState?: Record<string, number>;
     initialState?: Record<string, string>;
@@ -195,7 +196,7 @@ export interface FormationCombatImage extends BaseCombatImage {
     scale?: number;
     showSingleInstance?: boolean;
 }
-export type BuffEffect = DamageEffect | DamageSelfEffect | HealEffect | BarrierEffect | CreateBuffSelfEffect | ConsumeBuffSelfEffect | CreateBuffTargetEffect | ConsumeBuffTargetEffect | NegateEffect | AddEffect | MultiplyEffect | MergeEffect | TriggerEffect | ModifyBuffGroupEffect | CleanseToxicityEffect | SetStateEffect;
+export type BuffEffect = DamageEffect | DamageSelfEffect | HealEffect | BarrierEffect | CreateBuffSelfEffect | ConsumeBuffSelfEffect | CreateBuffTargetEffect | ConsumeBuffTargetEffect | NegateEffect | AddEffect | MultiplyEffect | MergeEffect | TriggerEffect | ModifyBuffGroupEffect | CleanseToxicityEffect | SetStateEffect | ConvertSelfEffect;
 interface BaseBuff {
     condition?: TechniqueCondition;
     triggerKey?: string;
@@ -290,4 +291,10 @@ interface SetStateEffect extends BaseBuff {
     value: Scaling;
     mode?: 'set' | 'add';
 }
+interface ConvertSelfEffect extends BaseBuff {
+    kind: 'convertSelf';
+    source: Buff;
+    target: Buff;
+    amount: Scaling;
+}
 export {};

package/dist/calendar.d.ts

@@ -9,4 +9,6 @@ export interface CalendarEvent {
     location?: string;
     recurrenceYears: number;
     realm?: Realm;
+    /** If true, event can be re-entered multiple times during its active month */
+    reentrant?: boolean;
 }

package/dist/craftingBuff.d.ts

@@ -1,5 +1,6 @@
 import { Realm } from './realm';
 import { CraftingStatistic, Scaling } from './stat';
+import { Translatable } from './translatable';
 export type CraftingTechniqueCondition = BuffTechniqueCondition | StateTechniqueCondition | ConditionTechniqueCondition | ChanceTechniqueCondition;
 interface BuffTechniqueCondition {
     kind: 'buff';
@@ -23,6 +24,7 @@ interface ChanceTechniqueCondition {
 export type CraftingBuffDisplayLocation = 'none' | 'avatar' | 'stabilityLeft' | 'stabilityRight' | 'perfectionLeft' | 'perfectionRight' | 'completionLeft' | 'completionRight';
 export interface CraftingBuff {
     name: string;
+    displayName?: Translatable;
     icon: string;
     canStack: boolean;
     effectHint?: string;

package/dist/craftingState.d.ts

@@ -2,6 +2,7 @@ import { CraftingTechniqueType, CraftingRecipeStats } from './craftingTechnique'
 import { CraftingCondition } from './crafting';
 import { CraftingEntity } from './entity';
 import { RecipeItem, ItemDesc } from './item';
+import type { GameEventState } from './reduxState';
 export interface ForgeWorksData {
     heat: number;
 }
@@ -69,6 +70,12 @@ export interface SuccessCraftingResult {
     refund: ItemDesc[];
 }
 export type CraftingResult = FailedCraftingResult | SuccessCraftingResult;
+export interface CraftingTrainingMode {
+    flagKey: string;
+    tier: number;
+    recipeTypeId: string;
+    conditionName?: string;
+}
 export interface CraftingState {
     player?: CraftingEntity;
     recipe?: RecipeItem;
@@ -77,4 +84,7 @@ export interface CraftingState {
     consumedPills: number;
     craftingLog: string[];
     craftResult?: CraftingResult;
+    trainingMode?: CraftingTrainingMode;
+    /** Snapshot of entire event state when crafting started, restored on completion */
+    eventStateSnapshot?: GameEventState;
 }

package/dist/craftingTechnique.d.ts

@@ -62,6 +62,7 @@ export interface CraftingTechnique {
     currentCooldown: number;
     justClicked?: true;
     mastery?: CraftingTechniqueMastery[];
+    masteryKindPools?: CraftingTechniqueEffectKind[];
     upgradeMasteries?: {
         [key: string]: CraftingTechniqueMasteryRarityMap;
     };

package/dist/dualCultivation.d.ts

@@ -3,8 +3,10 @@ declare const intimateStats: readonly ["satisfaction", "energy", "painThreshold"
 export type IntimateStat = (typeof intimateStats)[number];
 declare const intimateResources: readonly ["pain", "harmony", "excitement", "rhythm"];
 export type IntimateResource = (typeof intimateResources)[number];
-declare const intimateTechniqueTypes: string[];
+declare const intimateTechniqueTypes: readonly ["rough", "tender", "passionate"];
 export type IntimateTechniqueType = (typeof intimateTechniqueTypes)[number];
+export declare const intimateTechniqueTypeToName: Record<IntimateTechniqueType, string>;
+export declare const intimateResourceToName: Record<IntimateResource, string>;
 export type IntimateTrait = {
     name: string;
     description: Translatable;

package/dist/dualCultivation.js

@@ -1,4 +1,14 @@
 const intimateStats = ['satisfaction', 'energy', 'painThreshold'];
 const intimateResources = ['pain', 'harmony', 'excitement', 'rhythm'];
 const intimateTechniqueTypes = ['rough', 'tender', 'passionate'];
-export {};
+export const intimateTechniqueTypeToName = {
+    rough: 'Rough',
+    tender: 'Tender',
+    passionate: 'Passionate',
+};
+export const intimateResourceToName = {
+    pain: 'Pain',
+    harmony: 'Harmony',
+    excitement: 'Excitement',
+    rhythm: 'Rhythm',
+};

package/dist/entity.d.ts

@@ -79,6 +79,7 @@ export type EnemyDifficulty = 'veryeasy' | 'easy' | 'mediumEasy' | 'medium' | 'm
 export type BattleLength = 'halfround' | '1round' | 'veryshort' | 'short' | 'medium' | 'long' | 'verylong' | 'verylong+' | 'verylong++' | 'verylong+++' | 'verylong++++';
 export interface EnemyEntity {
     name: string;
+    displayName?: Translatable;
     image: string;
     supportImage?: {
         image: string;
@@ -227,6 +228,7 @@ export interface CombatArtefact extends ArtefactItem {
 export interface CombatEntity {
     entityType: EntityType;
     name?: string;
+    displayName?: Translatable;
     image: string;
     supportImage?: {
         image: string;

package/dist/item.d.ts

@@ -14,6 +14,9 @@ import { CombatStatsMap, CraftingStatsMap, PhysicalStatistic, Scaling, SocialSta
 import { Technique, TechniqueEffect } from './technique';
 export declare const itemKinds: readonly ["clothing", "talisman", "artefact", "mount", "cauldron", "flame", "upgrade", "fruit", "elixir", "recipe", "technique", "action", "transport_seal", "enchantment", "pill", "reagent", "concoction", "consumable", "recuperation", "formation", "breakthrough", "pillar_shard", "material", "flare", "mystical_key", "condensation_art", "blueprint", "trophy", "treasure", "token", "life_essence", "device", "manual"];
 export type ItemKind = (typeof itemKinds)[number];
+export declare const itemKindToName: {
+    [key in ItemKind]: string;
+};
 export type ItemCostMap = {
     [key in ItemKind]: number;
 };
@@ -23,6 +26,7 @@ export type Item = TechniqueItem | TechniqueCrystalItem | TechniqueShardItem | T
 interface ItemBase {
     kind: ItemKind;
     name: string;
+    displayName?: Translatable;
     description: Translatable;
     icon: string;
     stacks: number;
@@ -157,16 +161,23 @@ export interface ArtefactTechnique {
     effects: TechniqueEffect[];
     i?: number;
 }
-export type PillKind = 'combat' | 'crafting' | 'advancement' | 'consumable';
+export type PillKind = 'combat' | 'crafting' | 'advancement' | 'consumable' | 'appearance_change';
+export declare const pillKindToName: {
+    [key in PillKind]: string;
+};
 interface BasePillItem extends ItemBase {
     kind: 'pill';
     pillKind: PillKind;
 }
-export type PillItem = CombatPillItem | CraftingPillItem | MiscPillItem | ConsumablePillItem;
+export type PillItem = CombatPillItem | CraftingPillItem | MiscPillItem | ConsumablePillItem | AppearanceChangePillItem;
 export interface MiscPillItem extends BasePillItem {
     pillKind: 'advancement';
     toxicity?: undefined;
 }
+export interface AppearanceChangePillItem extends BasePillItem {
+    pillKind: 'appearance_change';
+    toxicity?: undefined;
+}
 export interface CombatPillItem extends BasePillItem {
     pillKind: 'combat';
     toxicity: number;
@@ -249,6 +260,11 @@ export interface MountItem extends ItemBase {
     masteryPoints?: number;
     qiAbsorption?: number;
     customTransform?: string;
+    explorationBonus?: number;
+    buffs?: {
+        buff: Buff;
+        buffStacks: Scaling;
+    }[];
 }
 export interface ElixirItem extends ItemBase {
     kind: 'elixir';
@@ -319,6 +335,11 @@ export interface MountEnchantment extends Enchantment {
     speed?: number;
     masteryPoints?: number;
     qiAbsorption?: number;
+    explorationBonus?: number;
+    buffs?: {
+        buff: Buff;
+        buffStacks: Scaling;
+    }[];
 }
 export interface RegionMonsters {
     mob: EnemyEntity[];
@@ -380,6 +401,7 @@ export interface CondensationArtEnchantment extends Enchantment {
     masteryPoints?: number;
     speed?: number;
     restoredDroplets?: number;
+    combatStats?: Partial<CombatStatsMap>;
 }
 export type FormationKind = 'qiDensity';
 export type FormationItem = QiDensityFormationItem;

package/dist/item.js

@@ -33,6 +33,41 @@ export const itemKinds = [
     'device',
     'manual',
 ];
+export const itemKindToName = {
+    clothing: 'Clothing',
+    talisman: 'Talisman',
+    artefact: 'Artefact',
+    mount: 'Mount',
+    cauldron: 'Cauldron',
+    flame: 'Flame',
+    upgrade: 'Upgrade',
+    fruit: 'Fruit',
+    elixir: 'Elixir',
+    recipe: 'Recipe',
+    technique: 'Technique',
+    action: 'Action',
+    transport_seal: 'Transport Seal',
+    enchantment: 'Enchantment',
+    pill: 'Pill',
+    reagent: 'Reagent',
+    concoction: 'Concoction',
+    consumable: 'Consumable',
+    recuperation: 'Recuperation',
+    formation: 'Formation',
+    breakthrough: 'Breakthrough',
+    pillar_shard: 'Pillar Shard',
+    material: 'Material',
+    flare: 'Flare',
+    mystical_key: 'Mystical Key',
+    condensation_art: 'Condensation Art',
+    blueprint: 'Blueprint',
+    trophy: 'Trophy',
+    treasure: 'Treasure',
+    token: 'Token',
+    life_essence: 'Life Essence',
+    device: 'Device',
+    manual: 'Manual',
+};
 export const buyItemCostMap = {
     technique: 3000,
     artefact: 3500,
@@ -103,3 +138,10 @@ export const sellItemCostMap = {
     device: 600,
     manual: 0,
 };
+export const pillKindToName = {
+    combat: 'Combat Pill',
+    crafting: 'Crafting Pill',
+    advancement: 'Advancement Pill',
+    consumable: 'Consumable Pill',
+    appearance_change: 'Appearance Change Pill',
+};

package/dist/life.d.ts

@@ -2,9 +2,24 @@ import { Buff } from './buff';
 import { StoredStance, StoredStyle } from './entity';
 import { Realm } from './realm';
 import { Technique } from './technique';
+export interface LifeFormAnimationImage {
+    image: string;
+    scale?: number;
+    imageOffset?: {
+        x: number;
+        y: number;
+    };
+}
 export interface LifeForm {
-    name: string;
+    role: string;
+    species: string;
     image: string;
+    supportImage?: LifeFormAnimationImage;
+    defensiveImage?: LifeFormAnimationImage;
+    utilityImage?: LifeFormAnimationImage;
+    aggressiveImage?: LifeFormAnimationImage;
+    offensiveImage?: LifeFormAnimationImage;
+    hitImage?: LifeFormAnimationImage;
     realm: Realm;
     buffs: Buff[];
     techniques: Technique[];

package/dist/location.d.ts

@@ -36,6 +36,27 @@ export interface GameLocation {
     realmProgress?: RealmProgress;
     reputationName?: string;
 }
+/**
+ * A root location that serves as an entry point for location discovery.
+ * The map system discovers all locations reachable from root locations whose
+ * conditions are met.
+ *
+ * Root locations that are not connected to other roots by paths can only be
+ * traveled to via transport seals or event steps (useful for secret/hidden areas).
+ *
+ * The main game root (Nine Mountain Sect) uses condition '1' to always be visible.
+ * Mod roots can use conditions to only appear after certain events/flags.
+ */
+export interface RootLocation {
+    /** The name of the location to use as a discovery root (must exist in locationMap) */
+    locationName: string;
+    /**
+     * Condition expression that determines when this root becomes active.
+     * Uses the same expression syntax as other conditions (e.g., "questFlag == 1").
+     * Use '1' for roots that should always be discovered.
+     */
+    condition: string;
+}
 interface LinkBase {
     location: GameLocation;
     distance: number;
@@ -86,8 +107,8 @@ export interface CraftingMission {
     condition: string;
 }
 export declare const exploresPerUnlock = 3;
-export type BuildingType = 'cultivation' | 'manual' | 'crafting' | 'mission' | 'craftingHall' | 'healer' | 'market' | 'favourExchange' | 'vault' | 'custom' | 'herbField' | 'mine' | 'recipe' | 'requestBoard' | 'compendium' | 'mysticalRegion' | 'trainingGround' | 'library' | 'house' | 'altar' | 'research' | 'reforge' | 'guild' | 'modBuilding';
-export type LocationBuilding = CultivationBuilding | ManualBuilding | CraftingBuilding | MissionBuilding | CraftingHallBuilding | HealerBuilding | MarketBuilding | VaultBuilding | FavourExchangeBuilding | CustomBuilding | HerbFieldBuilding | MineBuilding | RecipeLibraryBuilding | RequestBoardBuilding | CompendiumBuilding | MysticalRegionBuilding | TrainingGroundBuilding | LibraryBuilding | HouseBuilding | CompressionAltarBuilding | ResearchBuilding | ReforgeBuilding | GuildBuilding | ModBuilding;
+export type BuildingType = 'cultivation' | 'manual' | 'crafting' | 'mission' | 'craftingHall' | 'healer' | 'market' | 'favourExchange' | 'vault' | 'custom' | 'herbField' | 'mine' | 'recipe' | 'requestBoard' | 'compendium' | 'mysticalRegion' | 'trainingGround' | 'library' | 'house' | 'altar' | 'research' | 'reforge' | 'guild' | 'tenThousandFlames' | 'modBuilding';
+export type LocationBuilding = CultivationBuilding | ManualBuilding | CraftingBuilding | MissionBuilding | CraftingHallBuilding | HealerBuilding | MarketBuilding | VaultBuilding | FavourExchangeBuilding | CustomBuilding | HerbFieldBuilding | MineBuilding | RecipeLibraryBuilding | RequestBoardBuilding | CompendiumBuilding | MysticalRegionBuilding | TrainingGroundBuilding | LibraryBuilding | HouseBuilding | CompressionAltarBuilding | ResearchBuilding | ReforgeBuilding | GuildBuilding | TenThousandFlamesBuilding | ModBuilding;
 export type LocationBuildingState = MissionBuildingState | CraftingHallBuildingState | ShopBuildingState | RequestBoardBuildingState | HouseBuildingState | CompressionAltarBuildingState;
 interface BuildingBase {
     kind: BuildingType;
@@ -209,10 +230,14 @@ export interface MysticalRegionBuilding extends BuildingBase {
 export interface TrainingGroundBuilding extends BuildingBase {
     kind: 'trainingGround';
 }
+export interface TenThousandFlamesBuilding extends BuildingBase {
+    kind: 'tenThousandFlames';
+}
 export type CustomBuildingPosition = 'top' | 'topleft' | 'topright' | 'belowtop' | 'belowtopleft' | 'belowtopright' | 'middleleft' | 'middle' | 'middleright' | 'bottom' | 'bottomleft' | 'bottomright';
 export interface CustomBuilding extends BuildingBase {
     kind: 'custom';
     name: string;
+    displayName?: Translatable;
     icon: string;
     position: CustomBuildingPosition;
     condition: string;
@@ -253,6 +278,7 @@ export interface ModBuilding extends BuildingBase {
     kind: 'modBuilding';
     condition?: string;
     name: string;
+    displayName?: Translatable;
     icon: string;
     screen: string;
     position: CustomBuildingPosition;

package/dist/location.js

@@ -23,5 +23,6 @@ export const buildingTypeToName = {
     research: 'Vault of Infinite Reflections',
     reforge: `Infusion Workshop`,
     guild: '',
+    tenThousandFlames: 'Furnace of Ten Thousand Flames',
     modBuilding: '',
 };

package/dist/mine.d.ts

@@ -41,10 +41,13 @@ export type MineChamber = OreChamber | EventChamber | RandomDropChamber | Releas
 interface BaseChamber {
     icon: string;
     name: string;
+    displayName?: Translatable;
     description: Translatable;
     rarity: Rarity;
     condition: string;
     isUnique?: boolean;
+    /** If set, the chamber is only considered completed for pathing purposes when this game flag is truthy */
+    completeFlag?: string;
 }
 export interface OreChamber extends BaseChamber {
     kind: 'ore';

package/dist/mod.d.ts

@@ -36,6 +36,40 @@ import { PuppetType } from './trainingGround';
 import { TechniqueElement } from './element';
 import { AlternativeStart } from './alternativeStart';
 import { Tutorial } from './tutorial';
+import { Sex } from './entity';
+/**
+ * Sprite images for a custom player character.
+ * All images should be strings (either mod:// URLs for mod assets, or data: URLs).
+ */
+export interface PlayerSpriteImages {
+    /** Base/idle image shown in most UI contexts */
+    base: string;
+    /** Image shown when using aggressive stance techniques */
+    aggressive: string;
+    /** Image shown when using defensive stance techniques */
+    defensive: string;
+    /** Image shown when the player is hit */
+    hit: string;
+    /** Image shown when using offensive stance techniques */
+    offensive: string;
+    /** Image shown when using support stance techniques */
+    support: string;
+    /** Image shown when using utility stance techniques */
+    utility: string;
+}
+/**
+ * A custom player sprite that can be selected during character creation.
+ */
+export interface PlayerSprite {
+    /** Unique identifier for this sprite */
+    id: string;
+    /** Display name shown in character creation */
+    name: string;
+    /** Which gender this sprite is available for: 'male', 'female', or 'both' */
+    gender: Sex | 'both';
+    /** The sprite images for different poses/situations */
+    sprites: PlayerSpriteImages;
+}
 export interface ModMetadata {
     name: string;
     version: string;
@@ -483,6 +517,25 @@ export interface ModAPI {
          * linkLocations('Liang Tiao Village', { location: myLocation, distance: 5, condition: "my_unlock_flag" });
          */
         linkLocations: (existing: string, link: ConditionalLink | ExplorationLink) => void;
+        /**
+         * Register a location as a root for discovery.
+         * Root locations are entry points for the map discovery system - all locations
+         * reachable from a root will be discovered when its condition is met.
+         *
+         * Use this for secret areas or alternative starting points that aren't
+         * connected to the main map by paths. Players can only travel to unconnected
+         * roots via transport seals or event teleportation.
+         *
+         * @param locationName - Name of the location to mark as root (must already exist)
+         * @param condition - Condition expression for when this root is active (use '1' for always)
+         * @example
+         * // Always-active root for an alternative start area
+         * registerRootLocation('Hidden Valley', '1');
+         *
+         * // Conditional root that unlocks after finding a secret
+         * registerRootLocation('Ancient Ruins', 'foundAncientMap == 1');
+         */
+        registerRootLocation: (locationName: string, condition: string) => void;
         /**
          * Add buildings to an existing location.
          * @param location - Location key
@@ -654,6 +707,58 @@ export interface ModAPI {
          * });
          */
         addAlternativeStart: (start: AlternativeStart) => void;
+        /**
+         * Register a custom player sprite for character creation.
+         * Custom sprites will appear in the character creation screen alongside
+         * the default sprites for the specified gender.
+         * @param sprite - Player sprite configuration with id, name, gender, and all required images
+         * @example
+         * addPlayerSprite({
+         *   id: 'myCustomCharacter',
+         *   name: 'Custom Cultivator',
+         *   gender: 'male',
+         *   sprites: {
+         *     base: baseImage,
+         *     aggressive: aggressiveImage,
+         *     defensive: defensiveImage,
+         *     hit: hitImage,
+         *     offensive: offensiveImage,
+         *     support: supportImage,
+         *     utility: utilityImage,
+         *   }
+         * });
+         */
+        addPlayerSprite: (sprite: PlayerSprite) => void;
+        /**
+         * Register translations for a language.
+         * If the language already exists (e.g., 'ru'), mod translations will be merged
+         * with the base game translations, with mod translations taking precedence.
+         * If the language is new, it will be added to the available languages list.
+         *
+         * @param language - Language code (e.g., 'ru', 'zh', 'es', 'de')
+         * @param translations - Translation data in the same format as template.json
+         * @example
+         * // Add translations for a new language
+         * addTranslation('es', {
+         *   "ui": {
+         *     "buttons": {
+         *       "[name] Continue": "Continuar",
+         *       "[name] Cancel": "Cancelar"
+         *     }
+         *   }
+         * });
+         *
+         * // Override/add translations for an existing language
+         * addTranslation('ru', {
+         *   "items": {
+         *     "myModItem": {
+         *       "[name] Magic Sword": "Волшебный меч",
+         *       "[description] A sword imbued with magic.": "Меч, наполненный магией."
+         *     }
+         *   }
+         * });
+         */
+        addTranslation: (language: string, translations: Record<string, unknown>) => void;
     };
     utils: {
         /**

package/dist/quest.d.ts

@@ -3,6 +3,7 @@ import { EventStep, GameEvent } from './event';
 import { ItemDesc } from './item';
 export interface Quest {
     name: string;
+    displayName?: Translatable;
     description: Translatable;
     category: 'main' | 'side' | 'missionHall' | 'craftingHall' | 'requestBoard' | 'guild';
     guild?: string;

package/dist/reduxState.d.ts

@@ -86,6 +86,8 @@ export interface CombatState {
         flag: string;
         value: number;
     };
+    /** Snapshot of entire event state when combat started, restored on completion */
+    eventStateSnapshot?: GameEventState;
 }
 export type CraftingSliceState = ExistingCraftingState;
 export interface ResetFlag {
@@ -168,6 +170,8 @@ export interface AuctionState {
     playerItemsSold: AuctionItem[];
     totalPlayerSales: number;
     needsPlayerSellSelection: boolean;
+    /** Snapshot of entire event state when auction started, restored on completion */
+    eventStateSnapshot?: GameEventState;
 }
 export interface BreakthroughSliceState extends BreakthroughState {
 }
@@ -245,6 +249,8 @@ export interface TournamentSliceState {
     participants?: EnemyEntity[];
     previousRounds?: TournamentRound[];
     currentRound?: TournamentRound;
+    /** Snapshot of entire event state when tournament started, restored on completion */
+    eventStateSnapshot?: GameEventState;
 }
 export interface HouseState {
     inHouse: boolean;
@@ -270,6 +276,8 @@ export interface DualCultivationState {
     };
     animations: string[];
     messages: DualCultivationMessage[];
+    /** Snapshot of entire event state when dual cultivation started, restored on completion */
+    eventStateSnapshot?: GameEventState;
 }
 export interface GuildState {
     selectedGuild?: string;
@@ -288,6 +296,8 @@ export interface StoneCuttingState {
     isCutting: boolean;
     realm: Realm;
     gainedItems: ItemDesc[];
+    /** Snapshot of entire event state when stone cutting started, restored on completion */
+    eventStateSnapshot?: GameEventState;
 }
 export interface FallenStarState {
     activeSites: Record<string, FallenStarData>;
@@ -319,12 +329,6 @@ export interface NewGameState {
 export interface GameDataState {
     flags: Record<string, number>;
     mapExploration: Record<string, number>;
-    /**
-     * The root location name for location discovery.
-     * Defaults to "Nine Mountain Sect" if not set.
-     * Can be changed by alternative starts.
-     */
-    discoveryRoot?: string;
 }
 export interface HistoryItem {
     text: string;
@@ -366,6 +370,11 @@ export interface GameEventState {
         [key: string]: StoredEventState;
     };
     analyticsToReport: ReportAnalyticsStep[];
+    /**
+     * Hash of the event content for "skip seen dialogue" feature.
+     * Generated when event starts using hashEventContent().
+     */
+    eventHash?: string;
 }
 export interface RecipeFilters {
     hideCompleted: boolean;

package/dist/stat.d.ts

@@ -3,7 +3,7 @@ import { TechniqueElement } from './element';
 export declare const physicalStatistics: readonly ["eyes", "meridians", "dantian", "muscles", "digestion", "flesh"];
 export declare const socialStatistics: readonly ["age", "lifespan", "charisma", "battlesense", "craftskill", "artefactslots", "talismanslots", "condenseEfficiency", "pillsPerRound"];
 export declare const craftingStatistics: readonly ["maxpool", "pool", "maxtoxicity", "toxicity", "resistance", "itemEffectiveness", "control", "intensity", "critchance", "critmultiplier", "pillsPerRound", "poolCostPercentage", "stabilityCostPercentage", "successChanceBonus"];
-export declare const combatStatistics: readonly ["maxhp", "hp", "maxbarrier", "barrier", "maxtoxicity", "toxicity", "resistance", "pillsPerRound", "itemEffectiveness", "power", "artefactpower", "critchance", "defense", "protection", "dr", "barrierMitigation", "lifesteal", "critmultiplier", "vulnerability", "weakness", "fistBoost", "blossomBoost", "weaponBoost", "cloudBoost", "bloodBoost", "celestialBoost", "fistAffinity", "blossomAffinity", "weaponAffinity", "cloudAffinity", "bloodAffinity", "celestialAffinity", "noneAffinity", "qiDroplets", "fistDisabled", "bloodDisabled", "blossomDisabled", "cloudDisabled", "celestialDisabled", "weaponDisabled", "fistResistance", "blossomResistance", "weaponResistance", "cloudResistance", "bloodResistance", "celestialResistance", "damageBoost", "healingBoost", "barrierBoost", "overheal", "barrierBleed"];
+export declare const combatStatistics: readonly ["maxhp", "hp", "maxbarrier", "barrier", "maxtoxicity", "toxicity", "resistance", "pillsPerRound", "itemEffectiveness", "power", "artefactpower", "critchance", "defense", "protection", "dr", "barrierMitigation", "lifesteal", "critmultiplier", "vulnerability", "weakness", "fistBoost", "blossomBoost", "weaponBoost", "cloudBoost", "bloodBoost", "celestialBoost", "fistAffinity", "blossomAffinity", "weaponAffinity", "cloudAffinity", "bloodAffinity", "celestialAffinity", "noneAffinity", "qiDroplets", "fistDisabled", "bloodDisabled", "blossomDisabled", "cloudDisabled", "celestialDisabled", "weaponDisabled", "fistResistance", "blossomResistance", "weaponResistance", "cloudResistance", "bloodResistance", "celestialResistance", "damageBoost", "healingBoost", "barrierBoost", "overheal", "barrierBleed", "formationPartRecovery"];
 export type PhysicalStatistic = (typeof physicalStatistics)[number];
 export type SocialStatistic = (typeof socialStatistics)[number];
 export type CraftingStatistic = (typeof craftingStatistics)[number];

package/dist/stat.js

@@ -85,6 +85,7 @@ export const combatStatistics = [
     'barrierBoost',
     'overheal',
     'barrierBleed',
+    'formationPartRecovery',
 ];
 export const baseStatNumber = 10;
 export const expectedHpPerFlesh = 1000;
@@ -150,6 +151,7 @@ export const combatStatToName = {
     barrierBoost: 'Barrier Boost',
     overheal: 'Overheal',
     barrierBleed: 'Barrier Bleed',
+    formationPartRecovery: 'Formation Part Recovery',
 };
 export const combatStatToDescription = {
     maxhp: 'The amount of damage you can take before you are unable to continue.',
@@ -203,6 +205,7 @@ export const combatStatToDescription = {
     barrierBoost: '',
     overheal: '',
     barrierBleed: '',
+    formationPartRecovery: '',
 };
 // Uncommon stats that need auxiliary tooltips when they appear on buffs
 // These descriptions only show as aux tooltips in buff tooltips, not in the stats dialog
@@ -211,10 +214,12 @@ export const uncommonStatTooltips = {
     healingBoost: '<n>Healing Boost</n> increases all healing received by a percentage.',
     barrierBoost: '<n>Barrier Boost</n> increases all barrier gained by a percentage.',
     overheal: '<n>Overheal</n> converts a percentage of healing beyond your maximum health into barrier.',
-    protection: '<n>Protection</n> reduces damage taken to your health. Does not affect damage taken to your barrier.',
+    protection: '<n>Protection</n> reduces damage taken to your health with diminishing returns. Does not affect damage taken to your barrier.',
     weakness: '<n>Weakness</n> reduces your power.',
     vulnerability: '<n>Vulnerability</n> increases damage taken to your <n>health</n>. Does not affect damage taken to your barrier.',
-    barrierBleed: '<n>Barrier Bleed</n> causes a percentage of your damage to bypass the enemy barrier and strike their health directly.',
+    barrierBleed: '<n>Barrier Bleed</n> causes a percentage of any damage to bypass your barrier and strike your health directly.',
+    formationPartRecovery: 'Each point of <n>Formation Part Recovery</n> returns a <n>Formation Part</n> used in combat back to your Spatial Ring after battle.',
+    dr: '<n>Damage Resistance</n> reduces damage taken to your health after defense is applied. Each point equals <num>1%</num> reduction. Does not affect damage taken to your barrier.',
 };
 export const craftingStatToName = {
     maxpool: 'Max Qi Pool',

package/dist/translatable.d.ts

@@ -6,7 +6,7 @@
 export interface TranslatableString {
     readonly _translatable: true;
     readonly key: string;
-    readonly variables?: Record<string, string | number>;
+    readonly variables?: Record<string, Translatable | number>;
 }
 /**
  * A deferred plural translation object. Stores both singular and plural keys
@@ -18,7 +18,7 @@ export interface TranslatablePlural {
     readonly countVar: string;
     readonly one: string;
     readonly other: string;
-    readonly variables?: Record<string, string | number>;
+    readonly variables?: Record<string, Translatable | number>;
 }
 /**
  * A value that can be either a plain string or a deferred translation object.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "afnm-types",
-  "version": "0.6.31",
+  "version": "0.6.34",
   "description": "Type definitions for Ascend From Nine Mountains",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",