afnm-types 0.6.50 → 0.6.52

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' | 'tenThousandFlames' | 'lifeScreen' | 'soulShardDelve' | 'enchantmentShop';
+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' | 'soulShardDelve' | 'enchantmentShop' | 'challengeBoard';

package/dist/buff.d.ts

@@ -9,7 +9,7 @@ interface BaseTechniqueCondition {
     /**
      * When true, triggered effects (triggeredBuffEffects) on this buff will still
      * run even when this condition fails. The condition still blocks normal
-     * onTechniqueEffects and onRoundEffects.
+     * beforeTechniqueEffects, afterTechniqueEffects, and onRoundEffects.
      */
     allowTriggers?: boolean;
 }
@@ -84,8 +84,10 @@ export interface Buff {
     noneType?: string;
     secondaryType?: TechniqueElement | 'origin';
     enhancement?: number;
-    onTechniqueEffects: BuffEffect[];
-    onRoundEffects: BuffEffect[];
+    beforeTechniqueEffects?: BuffEffect[];
+    afterTechniqueEffects?: BuffEffect[];
+    onStackGainEffects?: BuffEffect[];
+    onRoundEffects?: BuffEffect[];
     onRoundStartEffects?: BuffEffect[];
     onCombatStartEffects?: BuffEffect[];
     interceptBuffEffects?: {
@@ -131,7 +133,6 @@ export interface Buff {
         effects?: BuffEffect[];
     }[];
     priority?: number;
-    afterTechnique?: boolean;
     combatImage?: BuffCombatImage;
     maxStacks?: number;
     upgradeKey?: string;

package/dist/buildSubmission.d.ts

@@ -0,0 +1,113 @@
+import { BreakthroughState } from './breakthrough';
+import { PhysicalStatistic } from './stat';
+import { KnownTechnique } from './technique';
+import { StoredStance, StoredStyle, AutoUseLoadout } from './entity';
+import { TechniqueElement } from './element';
+import { ItemDesc } from './item';
+/**
+ * Optional combat modifiers chosen by the submitter when posting a challenge seal.
+ * Applied symmetrically to both sides when the challenge is accepted.
+ */
+export interface ChallengeModifiers {
+    /** Number of grace period rounds both sides get damage reduction at the start of combat (0 or undefined = no grace period). */
+    gracePeriodRounds?: number;
+    /** Restrict both sides to a single technique school — all other schools are disabled (null or undefined = no restriction). */
+    schoolVow?: TechniqueElement | null;
+    /** Disable auto-use items (pills/concoctions) for both sides. */
+    disableItems?: boolean;
+    /** Disable qi droplets for both sides — techniques with droplet costs cannot be used. */
+    disableDroplets?: boolean;
+    /** Both sides gain 1 stack of Shadow Sickness at the start of each round. */
+    shadowSickness?: boolean;
+}
+export interface SubmittedEquipment {
+    clothing: string | ItemDesc | undefined;
+    mount: string | ItemDesc | undefined;
+    talismans: (string | ItemDesc | undefined)[];
+    artefacts: (string | ItemDesc | undefined)[];
+}
+/**
+ * Serialisable representation of a player build, ready to send to the server.
+ * Stored temporarily in GameEventState.pendingBuildSubmission until dispatched.
+ *
+ * Stat normalisation:
+ *   physicalStatRelativeRatios — each stat's share of the player's total
+ *   physical stat pool (all values sum to 1.0).  On the server the NPC
+ *   rebuild allocates `getExpectedPhysicalStat(realm) × 6` points distributed
+ *   according to these ratios, so modded absolute values never inflate the NPC.
+ */
+export interface NormalizedBuildSubmission {
+    /** Game version that produced the submission. */
+    version: string;
+    /** Stable per-save UUID that identifies the submitting player. */
+    playerId: string;
+    /** Player-chosen display name for the board entry. */
+    displayName: string;
+    realm: string;
+    realmProgress: string;
+    /**
+     * Relative distribution of physical stats.  Each value is the fraction of
+     * the player's *total* physical stat pool allocated to that stat
+     * (values sum to 1.0 across all six stats).
+     */
+    physicalStatRelativeRatios: Record<PhysicalStatistic, number>;
+    /** Raw battlesense value. */
+    battlesense: number;
+    /** All techniques known by the player at time of submission. */
+    knownTechniques: KnownTechnique[];
+    /** The active style at time of submission, or null. */
+    currentStyle: StoredStyle | null;
+    /** Equipment item names at time of submission. */
+    equipment: SubmittedEquipment;
+    submittedAt: string;
+    /** Player sex — used to select the appropriate default NPC sprite when images are not yet approved. */
+    sex?: string;
+    /**
+     * Portrait index into the player sprite array for this sex.
+     * Indices < MALE/FEMALE_BUILT_IN_COUNT refer to base-game portraits and are
+     * used directly at roster load time.  Indices >= the built-in count indicate a
+     * mod sprite; these are serialised to base64 and sent through the custom image
+     * approval flow the same way user-uploaded images are.
+     */
+    imageIndex: number;
+    /** Background IDs — resolved via backgroundMap at roster load time. */
+    background: string[];
+    /** Destiny IDs — resolved via destiniesMap for combat stat bonuses. */
+    destiny?: string[];
+    /** Names of consumed stat pills — resolved via itemMap for permanent rawStats bonuses. */
+    consumedStatPills?: string[];
+    /** Full breakthrough state — used for condensation art, pillar shards, figments, etc. */
+    breakthrough: BreakthroughState;
+    /** Technique affinities — used to apply the player's affinity multipliers in combat. */
+    affinities?: Partial<Record<string, number>>;
+    /** Pills per round from socialStats — applied directly to the combat entity. */
+    pillsPerRound?: number;
+    /** Qi droplets at time of submission — applied directly to the combat entity. */
+    qiDroplets?: number;
+    /**
+     * Custom combat image filenames (locally stored, not base64).
+     * Resolved to base64 before submission by the useBuildSubmission hook.
+     */
+    customImages?: {
+        idle?: string;
+        hit?: string;
+        support?: string;
+        defensive?: string;
+        utility?: string;
+        offensive?: string;
+        aggressive?: string;
+    };
+    /** Optional combat modifiers chosen by the submitter, applied symmetrically to both sides. */
+    combatModifiers?: ChallengeModifiers;
+    /** Active auto-use item loadout at time of submission, applied as conditional pills during challenge fights. */
+    currentAutoUseLoadout?: AutoUseLoadout;
+    /** Manifested figment (lifeform companion) at time of submission, added as a party member during challenge fights. */
+    lifeform?: {
+        primarySpecies: string;
+        secondarySpecies: string;
+        /** Display name (custom or auto-generated). */
+        name?: string;
+        stances: StoredStance[];
+        currentStyle?: StoredStyle;
+    };
+}

package/dist/buildSubmission.js

@@ -0,0 +1 @@
+export {};

package/dist/character.d.ts

@@ -273,6 +273,13 @@ export interface CharacterEncounter {
         max: number;
     };
     locations?: string[];
+    /**
+     * Marks this encounter as part of the global pity pool.
+     * Works the same way as `pity` on location events: the encounter's selection
+     * weight is multiplied by the global pity counter, and a successful pity
+     * encounter resets the counter.
+     */
+    pity?: true;
 }
 export type CharacterDefinition = NeutralCharacterDefinition | EnemyCharacterDefinition | CompanionCharacterDefinition;
 interface BaseCharacterDefinition {

package/dist/cli/extract-translations/extractors.js

@@ -882,6 +882,28 @@ function extractFromFile(filePath) {
                 }
             }
         }
+        // Find shorthand property assignments where the variable name IS the property name
+        // e.g., `const description = 'text'; const item = { description }` (shorthand for description: description)
+        if (typescript_1.default.isShorthandPropertyAssignment(node)) {
+            const propName = node.name.text;
+            if ((0, config_js_1.isTranslatableProperty)(propName)) {
+                // Resolve the variable name to its string value
+                const resolved = (0, resolvers_js_1.resolveImportedString)(filePath, propName) || (0, resolvers_js_1.tryResolveExpression)(filePath, propName);
+                if (resolved && resolved.trim().length > 0 && !(0, config_js_1.isCamelCase)(resolved)) {
+                    const { parentName, objectType, nestedPath } = getParentObjectInfo(node, filePath);
+                    const contextField = nestedPath ? `${nestedPath}/${propName}` : propName;
+                    results.push({
+                        text: resolved,
+                        file: filePath,
+                        line: (0, template_processor_js_1.getLineNumber)(sourceFile, node.getStart()),
+                        context: `data-${contextField}-resolved`,
+                        original: propName,
+                        parentId: parentName,
+                        objectType,
+                    });
+                }
+            }
+        }
         // Find array literals
         // Skip DIRECT exported arrays - they're handled by extractFromToNameMaps with proper context
         // e.g., export const combatSpeeds = ["Manual", ...] - skip

package/dist/components.d.ts

@@ -32,6 +32,7 @@ export type GameButtonFC = React.ForwardRefRenderFunction<HTMLButtonElement, But
 export type GameIconButtonFC = React.ForwardRefRenderFunction<HTMLButtonElement, IconButtonProps & {
     hoverSfx?: SoundEffectName;
     clickSfx?: SoundEffectName;
+    tooltip?: ReactNode;
 }>;
 export type GameCloseButtonFC = React.ForwardRefRenderFunction<HTMLButtonElement, Omit<IconButtonProps & {
     hoverSfx?: SoundEffectName;

package/dist/element.js

@@ -23,7 +23,7 @@ export const elementToTint = {
     celestial: 'white',
     cloud: '#45d1d1',
     blossom: '#ff63dd',
-    none: 'grey',
+    none: 'rgb(73, 73, 73)',
 };
 export const elementToColour = {
     weapon: 'radial-gradient(steelblue 50%, black)',
@@ -32,7 +32,7 @@ export const elementToColour = {
     celestial: 'radial-gradient(white 30%, black)',
     cloud: 'radial-gradient(teal 50%, black)',
     blossom: 'radial-gradient(#d654b9 50%, black)',
-    none: 'radial-gradient(darkgrey 50%, black)',
+    none: 'radial-gradient(rgb(53, 53, 53) 50%, black 85%)',
 };
 export const elementToColourRaw = {
     weapon: 'steelblue',
@@ -41,5 +41,5 @@ export const elementToColourRaw = {
     celestial: 'white',
     cloud: 'teal',
     blossom: '#d654b9',
-    none: 'darkgrey',
+    none: 'rgb(15, 15, 15)',
 };

package/dist/entity.d.ts

@@ -35,6 +35,10 @@ export interface PlayerEntity {
         utility?: string;
         offensive?: string;
         aggressive?: string;
+        craftingSupport?: string;
+        craftingStabilize?: string;
+        craftingRefine?: string;
+        craftingFusion?: string;
     };
     realm: Realm;
     realmOverride?: Realm;
@@ -58,7 +62,10 @@ export interface PlayerEntity {
     clothing: ItemDesc | undefined;
     talismans: (ItemDesc | undefined)[];
     artefacts: (ItemDesc | undefined)[];
-    autoUseItems?: (string | undefined)[];
+    /** @deprecated legacy only, do not use in new code */
+    autoUseItems?: (AutoUseItem | string | undefined)[];
+    currentAutoUseLoadout?: AutoUseLoadout;
+    storedAutoUseLoadouts?: AutoUseLoadout[];
     quickAccess?: (string | undefined)[];
     cauldron: ItemDesc | undefined;
     flame: ItemDesc | undefined;
@@ -181,6 +188,9 @@ export interface EnemyEntity {
     phases?: EnemyEntity[];
     party?: PartyMemberConfig[];
     preservePartyMembers?: boolean;
+    /** When set, stance selection uses the full player-style algorithm instead of stanceRotation/rotationOverrides. */
+    playerStyleStances?: StoredStance[];
+    playerStyleCycles?: ConditionalCycle[];
 }
 export type PartyMemberConfig = EnemyEntity;
 export interface CombatMessage {
@@ -295,6 +305,13 @@ export interface CombatEntity {
     usedOverrides: boolean[];
     usedPills: boolean[];
     defenseFactor: number;
+    /** Tracks per-combat state for enemies using playerStyleStances. Mirrors PlayerStanceData. */
+    enemyStanceData?: {
+        playerStanceIndex: number;
+        usedPlayerStanceOpeners: boolean[];
+        lastPlayerStance: string;
+        lastCycleKey?: string;
+    };
     battlesenseBonus?: number;
     spawnRoar?: SoundEffectName;
     buffs: Buff[];
@@ -315,6 +332,8 @@ export interface CombatEntity {
     partyId?: string;
     /** When true, critchance is forced to 0 for this entity (used in training ground) */
     noCrit?: boolean;
+    /** Cached hash for getVariablesFromEntity. Cleared whenever stats or buffs mutate. */
+    _cachedHash?: string;
 }
 export type StanceRule = SingleStance | RandomStance;
 export interface SingleStance {
@@ -342,13 +361,31 @@ export interface ConditionalCycle {
     }>;
     operator: 'AND' | 'OR';
 }
+export interface AutoUseCondition {
+    condition: string;
+    check: '<' | '==' | '>' | '!=';
+    value: number;
+}
+export interface AutoUseItem {
+    item?: string;
+    conditions?: AutoUseCondition[];
+    maxCount?: number;
+}
+export interface AutoUseLoadout {
+    id: string;
+    name: string;
+    autoName?: boolean;
+    slots: AutoUseItem[];
+}
 export interface StoredStyle {
     name: string;
     id: string;
     autoName?: boolean;
     stances: StoredStance[];
     conditionalCycles?: ConditionalCycle[];
-    autoUseItems?: (string | undefined)[];
+    /** @deprecated legacy only, do not use in new code */
+    autoUseItems?: (AutoUseItem | string | undefined)[];
+    autoUseLoadoutId?: string;
 }
 export type StoredRule = OpenerStoredRule | RotationStoredRule | ConditionalStoredRule | ConditionalRotationStoredRule;
 export interface OpenerStoredRule {

package/dist/gameVersion.d.ts

@@ -15,4 +15,4 @@
  *   };
  * }
  */
-export declare const GAME_VERSION = "0.6.50";
+export declare const GAME_VERSION = "0.6.52";

package/dist/gameVersion.js

@@ -15,4 +15,4 @@
  *   };
  * }
  */
-export const GAME_VERSION = "0.6.50";
+export const GAME_VERSION = "0.6.52";

package/dist/item.d.ts

@@ -13,7 +13,7 @@ import type { Realm, RealmProgress } from './realm';
 import type { RecipeDifficulty } from './RecipeDifficulty';
 import type { CombatStatistic, CombatStatsMap, CraftingStatistic, CraftingStatsMap, PhysicalStatistic, Scaling, SocialStatistic } from './stat';
 import type { 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", "pillar_pattern"];
+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", "pillar_pattern", "local_map"];
 export type ItemKind = (typeof itemKinds)[number];
 export declare const itemKindToName: {
     [key in ItemKind]: string;
@@ -26,7 +26,7 @@ export type ItemCostMap = {
 };
 export declare const buyItemCostMap: ItemCostMap;
 export declare const sellItemCostMap: ItemCostMap;
-export type Item = TechniqueItem | TechniqueCrystalItem | TechniqueShardItem | TechniqueEnhancementDust | TransportSealItem | SpiritFruitItem | RecipeItem | ElixirItem | TreasureItem | CraftingItem | ClothingItem | TalismanItem | ArtefactItem | PillItem | ConcoctionItem | CombatItem | CauldronItem | FlameItem | BreakthroughItem | RecuperationItem | MountItem | FlareItem | CraftingTechniqueItem | EnchantmentItem | MysticalKeyItem | CondensationArtItem | FormationItem | PillarShardItem | TrophyItem | BlueprintItem | TokenItem | UpgradeItem | CraftingReagentItem | LifeEssenceItem | DeviceItem | ManualItem | PillarPatternItem;
+export type Item = TechniqueItem | TechniqueCrystalItem | TechniqueShardItem | TechniqueEnhancementDust | TransportSealItem | SpiritFruitItem | RecipeItem | ElixirItem | TreasureItem | CraftingItem | ClothingItem | TalismanItem | ArtefactItem | PillItem | ConcoctionItem | CombatItem | CauldronItem | FlameItem | BreakthroughItem | RecuperationItem | MountItem | FlareItem | CraftingTechniqueItem | EnchantmentItem | MysticalKeyItem | CondensationArtItem | FormationItem | PillarShardItem | TrophyItem | BlueprintItem | TokenItem | UpgradeItem | CraftingReagentItem | LifeEssenceItem | DeviceItem | ManualItem | PillarPatternItem | LocalMapItem;
 interface ItemBase {
     kind: ItemKind;
     name: string;
@@ -96,6 +96,7 @@ export interface ManualItem extends ItemBase {
 }
 export interface ManualStyle {
     name: string;
+    displayName?: Translatable;
     stances: ManualStance[];
 }
 export interface ManualStance {
@@ -528,4 +529,37 @@ export interface PillarPatternItem extends ItemBase {
         };
     }[];
 }
+/** Describes the enemy modifier and reward scaling applied during a local map run. */
+export interface LocalMapModifier {
+    /** Display name shown in the UI (e.g. "Bulwark", "Frenzied"). */
+    name: string;
+    displayName?: Translatable;
+    /** Yield multiplier applied to drops and shards. */
+    yieldMult: number;
+    /** HP stat multiplier bonus added to the enemy's base. */
+    hpBonus: number;
+    /** Power stat multiplier bonus added to the enemy's base. */
+    powerBonus: number;
+    /** Pool of buffs to draw from. A random subset is applied to each enemy. */
+    buffPool: Buff[];
+    /** Minimum number of buffs selected from the pool. */
+    minBuffs: number;
+    /** Maximum number of buffs selected from the pool. */
+    maxBuffs: number;
+}
+export interface LocalMapItem extends ItemBase {
+    kind: 'local_map';
+    /** The cultivation realm this map applies to (must match the location's realm). */
+    realm: Realm;
+    /** Number of sequential fights triggered when this map is used. */
+    encounterCount: {
+        min: number;
+        max: number;
+    };
+    /**
+     * If present, enemies are modified and drop rates are scaled.
+     * Absent on standard/scout maps — plain fights, no modifiers.
+     */
+    modifier?: LocalMapModifier;
+}
 export {};

package/dist/item.js

@@ -33,6 +33,7 @@ export const itemKinds = [
     'device',
     'manual',
     'pillar_pattern',
+    'local_map',
 ];
 export const itemKindToName = {
     clothing: 'Clothing',
@@ -69,6 +70,7 @@ export const itemKindToName = {
     device: 'Device',
     manual: 'Manual',
     pillar_pattern: 'Pillar Pattern',
+    local_map: 'Local Map',
 };
 export const itemKindPluralToName = {
     clothing: 'Clothing',
@@ -105,6 +107,7 @@ export const itemKindPluralToName = {
     device: 'Devices',
     manual: 'Manuals',
     pillar_pattern: 'Pillar Patterns',
+    local_map: 'Local Maps',
 };
 export const buyItemCostMap = {
     technique: 3000,
@@ -141,6 +144,7 @@ export const buyItemCostMap = {
     device: 2500,
     manual: 15000,
     pillar_pattern: 3000,
+    local_map: 200,
 };
 export const sellItemCostMap = {
     technique: 400,
@@ -177,6 +181,7 @@ export const sellItemCostMap = {
     device: 600,
     manual: 0,
     pillar_pattern: 500,
+    local_map: 20,
 };
 export const pillKindToName = {
     combat: 'Combat Pill',

package/dist/itemHarmonyType.js

@@ -38,4 +38,5 @@ export const itemTypeToHarmonyType = {
     life_essence: 'resonance',
     manual: 'resonance',
     pillar_pattern: 'resonance',
+    local_map: 'resonance',
 };

package/dist/location.d.ts

@@ -146,8 +146,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' | 'expedition' | 'trainingGround' | 'library' | 'house' | 'altar' | 'research' | 'reforge' | 'guild' | 'tenThousandFlames' | 'soulShardDelve' | 'enchantmentShop' | '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 | SoulShardDelveBuilding | EnchantmentShopBuilding | ModBuilding;
+export type BuildingType = 'cultivation' | 'manual' | 'crafting' | 'mission' | 'craftingHall' | 'healer' | 'market' | 'favourExchange' | 'vault' | 'custom' | 'herbField' | 'mine' | 'recipe' | 'requestBoard' | 'compendium' | 'mysticalRegion' | 'expedition' | 'trainingGround' | 'library' | 'house' | 'altar' | 'research' | 'reforge' | 'guild' | 'tenThousandFlames' | 'soulShardDelve' | 'enchantmentShop' | 'challengeBoard' | '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 | SoulShardDelveBuilding | EnchantmentShopBuilding | ChallengeBoardBuilding | ModBuilding;
 export type LocationBuildingState = MissionBuildingState | CraftingHallBuildingState | ShopBuildingState | RequestBoardBuildingState | HouseBuildingState | CompressionAltarBuildingState;
 interface BuildingBase {
     kind: BuildingType;
@@ -269,6 +269,9 @@ export interface MysticalRegionBuilding extends BuildingBase {
 export interface TrainingGroundBuilding extends BuildingBase {
     kind: 'trainingGround';
 }
+export interface ChallengeBoardBuilding extends BuildingBase {
+    kind: 'challengeBoard';
+}
 export interface TenThousandFlamesBuilding extends BuildingBase {
     kind: 'tenThousandFlames';
 }

package/dist/location.js

@@ -27,5 +27,6 @@ export const buildingTypeToName = {
     tenThousandFlames: 'Furnace of Ten Thousand Flames',
     soulShardDelve: 'Soul Shard',
     enchantmentShop: 'Enchantment Shop',
+    challengeBoard: 'Challenge Board',
     modBuilding: '',
 };

package/dist/mod.d.ts

@@ -43,6 +43,8 @@ import type { Tutorial } from './tutorial';
 import type { Sex } from './entity';
 import type { DamageType } from './DamageType';
 import { AvatarEffectShader } from './avatarEffects';
+import type { Translatable, TranslatableString } from '../types/translatable';
+import type { SaveFileInfo } from './electron';
 /**
  * Sprite images for a custom player character.
  * All images should be strings (either mod:// URLs for mod assets, or data: URLs).
@@ -301,6 +303,35 @@ export interface ModReduxAPI {
          * console.log('Completion after:', preview.progressState?.completion);
          */
         previewCraftingTechnique: (technique: CraftingTechnique, state: CraftingState) => CraftingState;
+        /**
+         * Save the current game state to a character-scoped backup file. The save is
+         * written to the character's backup folder with the given filename. Throws an
+         * error if no save is currently loaded or if the save operation fails.
+         * @param filename - Name of the save file (e.g. 'quicksave-001.json')
+         * @example
+         * makeSave('quicksave-001.json'); // Save to character-backup/quicksave-001.json
+         * makeSave('backup-myprogress.json');
+         */
+        makeSave: (filename: string) => Promise<void>;
+        /**
+         * Load game state from a character-scoped backup file. The current game state
+         * will be replaced by the loaded save. Throws an error if the file cannot be
+         * read or parsed.
+         * @param filename - Name of the save file to load (must exist in character backup folder)
+         * @example
+         * loadSave('quicksave-001.json'); // Load from character-backup/quicksave-001.json
+         * loadSave('backup-myprogress.json');
+         */
+        loadSave: (filename: string) => Promise<void>;
+        /**
+         * List all backup save files available for the current character. Throws if
+         * no save is currently loaded or if the operation fails.
+         * @returns Array of save file metadata
+         * @example
+         * const saves = listSaves();
+         * saves.forEach(s => console.log(s.name, new Date(s.lastModified)));
+         */
+        listSaves: () => Promise<SaveFileInfo[]>;
     };
     components: {
         GameDialog: GameDialogFC;
@@ -479,6 +510,17 @@ export interface ModAPI {
          * @param reputation - (Optional) Required reputation tier
          */
         addItemToGuild: (item: Item, stacks: number, guild: string, rank: number, valueModifier?: number, reputation?: ReputationTier) => void;
+        /**
+         * Add an item to the sect favour exchange shop.
+         * @param item - Item to add
+         * @param stacks - Number of stacks available
+         * @param realm - Required realm tier to purchase
+         * @param valueModifier - (Optional) Price multiplier (default 1.0)
+         * @param reputation - (Optional) Required reputation tier
+         * @example
+         * addToSectShop(myItem, 3, 'qiCondensation');
+         */
+        addToSectShop: (item: Item, stacks: number, realm: Realm, valueModifier?: number, reputation?: ReputationTier) => void;
         /**
          * Add a crafting recipe to the sect recipe library.
          * @param item - Recipe item configuration
@@ -1637,7 +1679,7 @@ export interface ModAPI {
          * @param defenderProtection - Defender's protection stat
          * @returns Final damage value
          */
-        calculateDamage: (attackPower: number, defenderDefense: number, defenderDr: number, defenderDefenseFactor: number, maxReduction: number, defenderVulnerability: number, realm: Realm, realmProgress: RealmProgress, defenderProtection: number) => number;
+        calculateDamage: (attackPower: number, defenderDefense: number, defenderDr: number, defenderDefenseFactor: number, maxReduction: number, defenderVulnerability: number, realm: Realm, realmProgress: RealmProgress, defenderProtection: number, cultivatorResistance: number) => number;
         /**
          * Format a number for display (e.g. 1000 -> "1,000").
          * @param number - Number to format
@@ -1874,6 +1916,42 @@ export interface ModAPI {
          * const bonusStacks = entity.buffs.find(b => b.name === completionBonusBuffName)?.stacks ?? 0;
          */
         completionBonusBuffName: string;
+        /**
+         * Translate a string or translatable value to the current language.
+         * @param value - The string or translatable object to translate
+         * @param variables - Optional variables to substitute in the translation
+         * @param context - Optional context key for disambiguation
+         * @returns The translated string
+         * @example
+         * t('Hello world');
+         * t('You have {count} items', { count: 5 });
+         */
+        t: (value: Translatable, variables?: Record<string, Translatable | number>, context?: string) => string;
+        /**
+         * Translate a string with pluralization support.
+         * @param count - The count to determine singular/plural
+         * @param one - Translation key for count === 1 (singular)
+         * @param other - Translation key for count !== 1 (plural), should use {count} placeholder
+         * @param variables - Additional variables to substitute
+         * @returns The translated string with pluralization applied
+         * @example
+         * tPlural(days, '1 day remaining', '{count} days remaining');
+         */
+        tPlural: (count: number, one: string, other: string, variables?: Record<string, string | number>) => string;
+        /**
+         * Create a deferred translation object. Use this in data definitions instead of t().
+         * The translation is resolved at render time, not at module load time.
+         * @param key - The English text (also serves as the translation key)
+         * @param variables - Optional variables to substitute when resolved
+         * @param context - Optional context key for disambiguation
+         * @returns A TranslatableString object to be resolved later
+         * @example
+         * const item = {
+         *   name: 'Spirit Core',
+         *   description: tr('A dense crystallisation of pure qi.'),
+         * };
+         */
+        tr: (key: string, variables?: Record<string, Translatable | number>, context?: string) => TranslatableString;
     };
     hooks: {
         /**
@@ -2061,15 +2139,15 @@ export interface ModAPI {
         }) => void;
         /**
          * Hook fired after every Redux state update. Receives the action type, the
-         * state before the action was applied, and the state after. Return a modified
-         * copy of `stateAfter` to override what is stored, or return `stateAfter`
-         * unchanged to leave the update as-is.
+         * state before the action was applied, the state after, and a readonly copy of
+         * the action payload. Return a modified copy of `stateAfter` to override what
+         * is stored, or return `stateAfter` unchanged to leave the update as-is.
          *
          * This is called inside the reducer — keep the implementation fast and avoid
          * side-effects. Thrown exceptions are caught and logged.
          *
          * @example
-         * modAPI.hooks.onReduxAction((actionType, before, after) => {
+         * modAPI.hooks.onReduxAction((actionType, before, after, payload) => {
          *   if (actionType === 'inventory/addItem') {
          *     // double every item added in hard mode
          *     if (after.gameData.flags?.hard_mode) {
@@ -2079,7 +2157,34 @@ export interface ModAPI {
          *   return after;
          * });
          */
-        onReduxAction: (interceptor: (actionType: string, stateBefore: RootState, stateAfter: RootState) => RootState) => void;
+        onReduxAction: (interceptor: (actionType: string, stateBefore: RootState, stateAfter: RootState, payload: Readonly<unknown>) => RootState) => void;
+        /**
+         * Hook fired before a Redux action is passed to the reducer. Allows
+         * intercepting and modifying the action payload, or dropping the action
+         * entirely.
+         *
+         * Return a modified payload to replace the original (any non-null value,
+         * including `undefined`, replaces the current payload), or return `null` to
+         * drop the action (the reducer will not be called and the state will remain
+         * unchanged). When multiple interceptors are chained, each one receives the
+         * payload returned by the previous one.
+         *
+         * This is called before the reducer — keep the implementation fast and avoid
+         * side-effects. Thrown exceptions are caught and logged.
+         *
+         * @example
+         * modAPI.hooks.onReduxActionPayload((actionType, payload) => {
+         *   if (actionType === 'inventory/removeItem') {
+         *     const p = payload as { name: string; stacks: number };
+         *     // prevent blueprint removal by zeroing the stack count
+         *     if (modAPI.gameData.items[p.name]?.kind === 'blueprint') {
+         *       return { ...p, stacks: 0 };
+         *     }
+         *   }
+         *   return payload;
+         * });
+         */
+        onReduxActionPayload: (interceptor: (actionType: string, payload: unknown) => unknown | null) => void;
     };
     /**
      * Inject UI into a named slot (dialog title or screen name).

package/dist/reduxState.d.ts

@@ -88,6 +88,12 @@ export interface CombatState {
     };
     /** Snapshot of entire event state when combat started, restored on completion */
     eventStateSnapshot?: GameEventState;
+    /** Set before a challenge board spar; survives cleanupCombat so the screen can process the result on remount */
+    pendingChallengeResult?: {
+        enemyName: string;
+        buildId: string | null;
+        prevWins: number;
+    };
 }
 export type CraftingSliceState = ExistingCraftingState;
 export interface ResetFlag {
@@ -318,6 +324,13 @@ export interface FallenStarState {
 export interface ExpeditionState {
     activeExpeditionKey?: string;
 }
+/** A single build entry submitted to the challenge board. */
+export interface SubmittedBuild {
+    /** Server-assigned ID for this submission. */
+    id: string;
+    /** Display name chosen by the player for this board entry. */
+    name: string;
+}
 export interface NewGameState {
     characterCreated: boolean;
     forename: string;
@@ -333,6 +346,10 @@ export interface NewGameState {
         utility?: string;
         offensive?: string;
         aggressive?: string;
+        craftingSupport?: string;
+        craftingStabilize?: string;
+        craftingRefine?: string;
+        craftingFusion?: string;
     };
     birthBackground: Background | undefined;
     childBackground: Background | undefined;
@@ -340,6 +357,11 @@ export interface NewGameState {
     createdAt: number;
     playtime: number;
     lastPlayed?: number;
+    /**
+     * Currently submitted challenge builds (up to 9).
+     * Each has its own server-assigned ID and player-chosen display name.
+     */
+    submittedBuilds: SubmittedBuild[];
 }
 export interface GameDataState {
     flags: Record<string, number>;
@@ -410,12 +432,20 @@ export interface RecipeFilters {
     recipeFilter: string;
     selectedRecipe: string;
     pinnedRecipes: string[];
-    category: 'all' | ItemKind;
+    category: 'all' | 'pinned' | 'pinned-upgrades' | ItemKind;
     realmFilter: 'all' | Realm;
 }
+export interface PinnedReforgeItem {
+    itemName: string;
+    qualityTier: number;
+    enchantmentKind?: string;
+    enchantmentRarity?: string;
+    mode: 'upgrade' | 'reforge';
+}
 export interface CharacterUiPreferencesState {
     techniqueFilter: string;
     recipeFilters: RecipeFilters;
+    pinnedReforgeItems: PinnedReforgeItem[];
 }
 export interface RootState {
     gameData: GameDataState;

package/dist/stat.d.ts

@@ -3,7 +3,7 @@ import type { 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", "poolCostFlat"];
-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", "noneDisabled", "fistResistance", "blossomResistance", "weaponResistance", "cloudResistance", "bloodResistance", "celestialResistance", "damageBoost", "healingBoost", "barrierBoost", "overheal", "barrierBleed", "formationPartRecovery", "overcrit"];
+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", "noneDisabled", "pillsDisabled", "dropletsDisabled", "fistResistance", "blossomResistance", "weaponResistance", "cloudResistance", "bloodResistance", "celestialResistance", "damageBoost", "healingBoost", "barrierBoost", "overheal", "barrierBleed", "formationPartRecovery", "overcrit", "cultivatorResistance"];
 export type PhysicalStatistic = (typeof physicalStatistics)[number];
 export type SocialStatistic = (typeof socialStatistics)[number];
 export type CraftingStatistic = (typeof craftingStatistics)[number];

package/dist/stat.js

@@ -76,6 +76,8 @@ export const combatStatistics = [
     'celestialDisabled',
     'weaponDisabled',
     'noneDisabled',
+    'pillsDisabled',
+    'dropletsDisabled',
     'fistResistance',
     'blossomResistance',
     'weaponResistance',
@@ -89,6 +91,7 @@ export const combatStatistics = [
     'barrierBleed',
     'formationPartRecovery',
     'overcrit',
+    'cultivatorResistance',
 ];
 export const baseStatNumber = 10;
 export const expectedHpPerFlesh = 1000;
@@ -113,7 +116,7 @@ export const combatStatToName = {
     power: 'Power',
     artefactpower: 'Artefact Power',
     critchance: 'Crit Chance',
-    defense: 'Defense',
+    defense: 'Armour',
     protection: 'Protection',
     dr: 'Damage Resistance',
     barrierMitigation: 'Barrier Effectiveness',
@@ -142,6 +145,8 @@ export const combatStatToName = {
     celestialDisabled: '<n>Celestial</n> techniques are disabled',
     weaponDisabled: '<n>Weapon</n> techniques are disabled',
     noneDisabled: '<n>Neutral</n> techniques are disabled',
+    pillsDisabled: 'Items are disabled',
+    dropletsDisabled: 'Qi Droplets are disabled',
     pillsPerRound: 'Items Per Round',
     itemEffectiveness: 'Item Effectiveness',
     fistResistance: 'Fist Resistance',
@@ -157,6 +162,7 @@ export const combatStatToName = {
     barrierBleed: 'Barrier Bleed',
     formationPartRecovery: 'Formation Part Recovery',
     overcrit: 'Overcrit',
+    cultivatorResistance: 'Cultivator Resistance',
 };
 export const combatStatToDescription = {
     maxhp: 'The amount of damage you can take before you are unable to continue.',
@@ -198,6 +204,8 @@ export const combatStatToDescription = {
     celestialDisabled: '',
     weaponDisabled: '',
     noneDisabled: '',
+    pillsDisabled: '',
+    dropletsDisabled: '',
     fistResistance: '',
     blossomResistance: '',
     weaponResistance: '',
@@ -213,6 +221,7 @@ export const combatStatToDescription = {
     barrierBleed: '',
     formationPartRecovery: '',
     overcrit: '',
+    cultivatorResistance: '',
 };
 // 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
@@ -261,7 +270,7 @@ export const craftingStatToDescription = {
     critmultiplier: 'The effectiveness of your critical actions.',
     successChanceBonus: '',
     itemEffectiveness: 'The effectiveness of your pills and reagents.',
-    poolCostFlat: 'A flat amount added to the Qi Pool cost of every crafting action.',
+    poolCostFlat: '',
 };
 export const socialStatToName = {
     charisma: 'Charisma',

package/dist/technique.d.ts

@@ -69,6 +69,7 @@ interface BaseTechniqueEffect {
     condition?: TechniqueCondition;
     triggerKey?: string;
     isAdditionalTooltip?: boolean;
+    cantUpgrade?: boolean;
 }
 interface BuffSelfTechniqueEffect extends BaseTechniqueEffect {
     kind: 'buffSelf';
@@ -159,7 +160,7 @@ export interface PermanentStatChangeTechniqueEffect extends BaseTechniqueEffect
     stat: PhysicalStatistic | SocialStatistic;
     amount: Scaling;
 }
-export type TechniqueMastery = PowerTechniqueMastery | EffectTechniqueMastery | CritChanceTechniqueMastery | CritMultiplierTechniqueMastery | UpgradeTechniqueMastery;
+export type TechniqueMastery = PowerTechniqueMastery | EffectTechniqueMastery | CritChanceTechniqueMastery | CritMultiplierTechniqueMastery | UpgradeTechniqueMastery | OverwriteEffectsTechniqueMastery;
 interface BaseTechniqueMastery {
     condition?: TechniqueCondition;
     tooltip?: Translatable;
@@ -188,6 +189,11 @@ export interface UpgradeTechniqueMastery extends BaseTechniqueMastery {
     change: number;
     shouldMultiply?: boolean;
 }
+export interface OverwriteEffectsTechniqueMastery extends BaseTechniqueMastery {
+    kind: 'overwriteEffects';
+    tooltip: Translatable;
+    newEffects: TechniqueEffect[];
+}
 export type TechniqueMasteryRarityMap = {
     [key in Rarity]: TechniqueMastery | undefined;
 } & {

package/package.json

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