afnm-types 0.6.55 → 0.6.57

package/dist/auction.d.ts

@@ -18,6 +18,7 @@ export interface AuctionItemDef {
     condition: string;
     countOverride?: number;
     countMultiplier?: number;
+    costMultiplier?: number;
 }
 export interface AuctionCharacter {
     name: string;

package/dist/buff.d.ts

@@ -18,14 +18,17 @@ export type DamageModifier = MultiplyDamageModifier | ReduceDamageModifier | Exp
 interface MultiplyDamageModifier {
     kind: 'multiply';
     value: number;
+    cantUpgrade?: boolean;
 }
 interface ReduceDamageModifier {
     kind: 'reduce';
     percent: number;
+    cantUpgrade?: boolean;
 }
 interface ExpressionDamageModifier {
     kind: 'expression';
     expression: string;
+    cantUpgrade?: boolean;
 }
 interface ChanceTechniqueCondition extends BaseTechniqueCondition {
     kind: 'chance';
@@ -54,6 +57,20 @@ interface InventoryItemTechniqueCondition extends BaseTechniqueCondition {
     count: number;
     mode: 'more' | 'less' | 'equal';
 }
+/**
+ * Configures how a buff lives outside combat. Buffs without a `persistence`
+ * field are combat or event scoped only.
+ */
+export interface BuffPersistence {
+    /**
+     * When combat ends, the surviving stack count of this buff on the player is
+     * written back into `player.monthBuffs`. Existing entries are replaced, not
+     * additively merged. Stacks of zero or below remove the buff.
+     */
+    persistAfterCombat?: boolean;
+    /** Stacks of this buff lost at the end of every month. */
+    decayPerMonth?: number;
+}
 export interface Buff {
     name: string;
     displayName?: Translatable;
@@ -105,6 +122,7 @@ export interface Buff {
     /** Block specific triggers from executing. Used to prevent effects like celestial rotation. */
     blockTriggerEffects?: {
         trigger: string;
+        condition?: TechniqueCondition;
         effects: BuffEffect[];
     }[];
     damageInterceptorEffects?: {
@@ -119,9 +137,10 @@ export interface Buff {
         amplifier: {
             kind: 'multiply';
             value: number;
+            cantUpgrade?: boolean;
         };
         effects?: BuffEffect[];
-        appliesTo: ('damage' | 'barrier' | 'heal')[];
+        appliesTo: ('damage' | 'barrier' | 'heal' | 'tempHealth')[];
     }[];
     /** Amplifies buff creation. Modifies stack count when matching buffs are created on self. */
     buffAmplifierEffects?: {
@@ -131,6 +150,7 @@ export interface Buff {
         modifier: {
             kind: 'add' | 'multiply';
             value: number;
+            cantUpgrade?: boolean;
         };
         effects?: BuffEffect[];
     }[];
@@ -141,6 +161,12 @@ export interface Buff {
     stacks: number;
     stacksAreDays?: boolean;
     stacksAreMonths?: boolean;
+    /**
+     * Marks the buff as carrying state on the player between events. When set,
+     * the buff opts out of the default daily monthBuffs decay (which treats
+     * stacks as days remaining) and follows the rules in this object instead.
+     */
+    persistence?: BuffPersistence;
     buffType?: string;
     buffTypeTooltip?: string;
     endurePercent?: number;
@@ -152,6 +178,11 @@ export interface Buff {
     guardianIntercept?: {
         percent: Scaling;
         maxHp: Scaling;
+        /** How re-application of the guardian buff combines with existing guardian HP.
+         *  'refresh' (default): maxHp = max(old, new); hp = maxHp (fully heal).
+         *  'extend': hp = oldHp + newMaxHp; maxHp = max(oldMaxHp, hp). Adds onto current and extends the cap. */
+        refreshMode?: 'refresh' | 'extend';
+        canUpgrade?: boolean;
     };
     /** Runtime guardian HP — set automatically from guardianIntercept.maxHp at buff creation */
     guardianHp?: number;
@@ -317,7 +348,7 @@ export interface TransformationCombatImage {
     animateOnEntity?: boolean;
 }
 export type RepairRule = 'all' | 'lowestHealth' | 'highestHealth';
-export type BuffEffect = DamageEffect | DamageSelfEffect | HealEffect | BarrierEffect | CreateBuffSelfEffect | ConsumeBuffSelfEffect | CreateBuffTargetEffect | ConsumeBuffTargetEffect | NegateEffect | AddEffect | MultiplyEffect | MergeEffect | TriggerEffect | ModifyBuffGroupEffect | CleanseToxicityEffect | SetStateEffect | ConvertSelfEffect | RepairEffect | ConsumeInventoryItemEffect;
+export type BuffEffect = DamageEffect | DamageSelfEffect | HealEffect | BarrierEffect | GiveTemporaryHealthEffect | CreateBuffSelfEffect | ConsumeBuffSelfEffect | CreateBuffTargetEffect | ConsumeBuffTargetEffect | NegateEffect | AddEffect | MultiplyEffect | MergeEffect | TriggerEffect | ModifyBuffGroupEffect | CleanseToxicityEffect | SetStateEffect | ConvertSelfEffect | RepairEffect | ConsumeInventoryItemEffect;
 interface BaseBuff {
     condition?: TechniqueCondition;
     triggerKey?: string;
@@ -325,6 +356,7 @@ interface BaseBuff {
         [key in CombatStatistic]: Scaling;
     }>;
     hidden?: boolean;
+    cantUpgrade?: boolean;
 }
 interface DamageEffect extends BaseBuff {
     kind: 'damage';
@@ -349,6 +381,12 @@ interface BarrierEffect extends BaseBuff {
     hits?: Scaling;
     targeting?: EffectTargeting;
 }
+interface GiveTemporaryHealthEffect extends BaseBuff {
+    kind: 'temporaryHealth';
+    amount: Scaling;
+    hits?: Scaling;
+    targeting?: EffectTargeting;
+}
 interface CreateBuffSelfEffect extends BaseBuff {
     kind: 'buffSelf';
     amount: Scaling;
@@ -363,6 +401,7 @@ interface ConsumeBuffSelfEffect extends BaseBuff {
     buff: Buff | string;
     silent?: boolean;
     hideBuff?: boolean;
+    targeting?: EffectTargeting;
 }
 interface CreateBuffTargetEffect extends BaseBuff {
     kind: 'buffTarget';
@@ -409,6 +448,9 @@ interface ModifyBuffGroupEffect extends BaseBuff {
     onTarget?: boolean;
     group: string;
     amount: Scaling;
+    /** Defaults to 'all'. 'highest'/'lowest' restrict the effect to a single matching buff
+     *  chosen by stack count. */
+    mode?: 'all' | 'highest' | 'lowest';
 }
 interface SetStateEffect extends BaseBuff {
     kind: 'setState';

package/dist/character.d.ts

@@ -331,7 +331,7 @@ export interface CharacterRelationshipDefinition {
     tooltip: Translatable;
     followCharacter?: FollowCharacterDefinition;
     dualCultivation?: DualCultivationDefinition;
-    progressionEvent: {
+    progressionEvent?: {
         name: string;
         tooltip: Translatable;
         event: EventStep[];

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

@@ -3,7 +3,7 @@
  * Configuration constants for the translation extraction script
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUIREMENT_STRINGS = exports.CONDITION_TEMPLATES = exports.CONDITION_WORDS = exports.HARDCODED_TEMPLATE_PATTERNS = exports.TIER_ONLY_MAPS = exports.STATIC_MAPS = exports.STATIC_ARRAY_NAMES = exports.TEXT_SHADOW = exports.STYLE_COLORS = exports.ELEMENTS = exports.ELEMENT_TO_NAME = exports.RARITIES = exports.RARITY_TO_TIER = exports.REALMS = exports.REALM_TO_NAME = exports.REALM_TO_TIER = exports.CODE_CHANGE_EXCLUDE_FILES = exports.CODE_CHANGE_EXCLUDE_PATTERNS = exports.EXCLUDE_PATTERNS = exports.NON_TRANSLATABLE_PROPERTIES = exports.MIN_STRING_LENGTH = void 0;
+exports.REQUIREMENT_STRINGS = exports.CONDITION_TEMPLATES = exports.CONDITION_WORDS = exports.HARDCODED_TEMPLATE_PATTERNS = exports.TIER_ONLY_MAPS = exports.STATIC_MAPS = exports.STATIC_ARRAY_NAMES = exports.ENEMY_STANCE_NAMES = exports.TEXT_SHADOW = exports.STYLE_COLORS = exports.ELEMENTS = exports.ELEMENT_TO_NAME = exports.RARITIES = exports.RARITY_TO_TIER = exports.REALMS = exports.REALM_TO_NAME = exports.REALM_TO_TIER = exports.CODE_CHANGE_EXCLUDE_FILES = exports.CODE_CHANGE_EXCLUDE_PATTERNS = exports.EXCLUDE_PATTERNS = exports.NON_TRANSLATABLE_PROPERTIES = exports.MIN_STRING_LENGTH = void 0;
 exports.isTranslatableProperty = isTranslatableProperty;
 exports.isCamelCase = isCamelCase;
 exports.shouldExclude = shouldExclude;
@@ -512,6 +512,33 @@ exports.STYLE_COLORS = {
     num: '#ff877d',
 };
 exports.TEXT_SHADOW = 'textShadow: -1px 1px 0 #000, 1px 1px 0 #000, 1px -1px 0 #000, -1px -1px 0 #000;';
+/** Internal stance name identifiers used by EnemyEntity definitions. Never player-facing. */
+exports.ENEMY_STANCE_NAMES = new Set([
+    'absorb', 'accelerate', 'aggressive', 'agitation', 'amplify', 'animate', 'ascension',
+    'assault', 'assess', 'attack', 'attack1', 'attack2', 'attack3', 'attack4', 'attackBig',
+    'barrier', 'barrierHater', 'barrierMit', 'bigBloat', 'blast', 'block', 'blood', 'blossom',
+    'boil', 'bolt', 'buff', 'buffSelf', 'buffStance', 'buffTarget', 'build', 'burn',
+    'burrowStrike', 'burst', 'cacophonyPhase', 'celestial', 'celestialradiance', 'chaosForge',
+    'charge', 'cleave', 'cloud', 'collapse', 'compliance', 'constrict', 'consume', 'consuming',
+    'control', 'corrupt', 'corrupted_swarm', 'counterattack', 'crownedascension',
+    'crownedgathering', 'crownedradiance', 'crushing', 'damage', 'damageHeavy', 'debuff',
+    'debuffHeal', 'debuffStance', 'defend', 'defending', 'defensive', 'defensiveHeavy',
+    'defensiveStance', 'desertGuardian', 'desperate', 'destabilize', 'dissonancePhase', 'drain',
+    'eclipse', 'emerald', 'endure', 'enhanced_attack', 'enhanced_attack1', 'enhanced_attack2',
+    'enhanced_attack3', 'enhanced_block', 'enhanced_rend', 'escalation1', 'escalation2',
+    'fieldSet', 'finale', 'first', 'firstRound', 'fist', 'float', 'focus', 'forging', 'fortify',
+    'frenzy', 'gathering', 'gore', 'gossamerLight', 'gossamerShadow', 'gossamerVault', 'guard',
+    'harm', 'harmonyPhase', 'heal', 'healDebuff', 'initializing', 'kick', 'lash', 'lethargy',
+    'mend', 'meteor', 'mindlessAttack', 'moon', 'multihits', 'mystic', 'needle', 'offensiveStance',
+    'opener', 'origin', 'overcharged', 'pause', 'peck', 'pierce', 'plumagegathering', 'power',
+    'powerBuildUp', 'preparation', 'prepare', 'pressureAssault', 'pulse', 'punch', 'purge',
+    'recklessness', 'rend', 'ruby', 'sandstorm', 'sap', 'sapphire', 'seal', 'setup', 'setup1',
+    'setup2', 'setup3', 'shatter', 'shroudLight', 'shroudShadow', 'shroudVault', 'siphon', 'soar',
+    'spin', 'stack', 'stacks', 'steal', 'sun', 'surge', 'sustain', 'swarm', 'swarmling',
+    'swarmlord', 'touch', 'turtle', 'twisted_rampage', 'underground', 'unleash', 'unravel',
+    'unstableFury', 'vaultBreak', 'venom', 'venomMaster', 'wail', 'weapon', 'weave',
+    'weaveAttacker', 'weaveHealer', 'weaveLight', 'weaveProtector', 'weaveShadow', 'windDancer',
+]);
 /** Arrays that indicate static map iteration */
 exports.STATIC_ARRAY_NAMES = ['realms', 'techniqueElements'];
 /** Static maps that can be expanded */

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

@@ -537,6 +537,18 @@ function extractFromFile(filePath) {
                         });
                     }
                 }
+                else if (typescript_1.default.isBinaryExpression(arg) && arg.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+                    // String concatenation with + is supported - try to resolve it
+                    const resolved = (0, template_processor_js_1.tryResolveBinaryExpression)(arg, sourceFile, filePath);
+                    if (resolved !== null && resolved.trim().length > 0) {
+                        results.push({
+                            text: resolved,
+                            file: filePath,
+                            line: (0, template_processor_js_1.getLineNumber)(sourceFile, node.getStart()),
+                            context: `${funcName}-call`,
+                        });
+                    }
+                }
                 else if (typescript_1.default.isTemplateExpression(arg)) {
                     const templateText = arg.getText(sourceFile);
                     const processed = (0, template_processor_js_1.processTemplateExpression)(arg, sourceFile, filePath);
@@ -653,9 +665,10 @@ function extractFromFile(filePath) {
                 // not player-facing text (e.g., "attack1", "enhanced_attack2", "stack", "power")
                 // Exception: manual items have style/stances with player-facing names like "Defensive Focus"
                 if (propName === 'name' &&
-                    nestedPath &&
-                    ((/\bstances\b/.test(nestedPath) && !/\bstyle\b/.test(nestedPath)) ||
-                        /\bmastery\b/.test(nestedPath))) {
+                    ((nestedPath &&
+                        ((/\bstances\b/.test(nestedPath) && !/\bstyle\b/.test(nestedPath)) ||
+                            /\bmastery\b/.test(nestedPath))) ||
+                        (typescript_1.default.isStringLiteral(node.initializer) && config_js_1.ENEMY_STANCE_NAMES.has(node.initializer.text)))) {
                     typescript_1.default.forEachChild(node, visit);
                     return;
                 }
@@ -923,7 +936,12 @@ function extractFromFile(filePath) {
                     }
                 }
             }
-            if (!isDirectExportedArray) {
+            // Skip arrays that are values of non-translatable properties (e.g., stances: ['attack1', ...])
+            const isInsideNonTranslatableProperty = parent &&
+                typescript_1.default.isPropertyAssignment(parent) &&
+                typescript_1.default.isIdentifier(parent.name) &&
+                !(0, config_js_1.isTranslatableProperty)(parent.name.text);
+            if (!isDirectExportedArray && !isInsideNonTranslatableProperty) {
                 const stringElements = node.elements.filter((el) => typescript_1.default.isStringLiteral(el) || typescript_1.default.isNoSubstitutionTemplateLiteral(el));
                 if (stringElements.length > 0) {
                     const translatableStrings = stringElements

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

@@ -1037,20 +1037,31 @@ function buildTranslationLookup(langData) {
 function loadExistingLanguageFiles() {
     const languageFiles = new Map();
     const translationsDir = path_1.default.join('src', 'translations');
-    // List of language codes to look for
-    const languages = ['zh', 'de', 'fr', 'es', 'ru'];
-    for (const lang of languages) {
-        const langPath = path_1.default.join(translationsDir, `${lang}.json`);
-        if (fs_1.default.existsSync(langPath)) {
-            try {
-                const data = JSON.parse(fs_1.default.readFileSync(langPath, 'utf-8'));
-                languageFiles.set(lang, data);
-                console.log(`  Loaded existing translations from ${lang}.json`);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.warn(`  Warning: Failed to parse ${lang}.json: ${message}`);
-            }
+    // Discover languages by scanning the translations directory rather than maintaining
+    // a hardcoded list (which silently dropped ja/ko/vi/fi/pl/pt-BR/th/zh-CN/zh-TW).
+    // Filenames are <lang>.json; non-language files in this dir are explicitly excluded.
+    const NON_LANGUAGE_FILES = new Set([
+        'template.json',
+        'debug.json',
+        'custom-strings.json',
+        'technique-tooltip-templates.json',
+    ]);
+    const entries = fs_1.default.readdirSync(translationsDir);
+    for (const file of entries) {
+        if (!file.endsWith('.json'))
+            continue;
+        if (NON_LANGUAGE_FILES.has(file))
+            continue;
+        const lang = file.replace(/\.json$/, '');
+        const langPath = path_1.default.join(translationsDir, file);
+        try {
+            const data = JSON.parse(fs_1.default.readFileSync(langPath, 'utf-8'));
+            languageFiles.set(lang, data);
+            console.log(`  Loaded existing translations from ${lang}.json`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Failed to parse ${lang}.json: ${message}`);
         }
     }
     return languageFiles;

package/dist/combat.d.ts

@@ -0,0 +1,186 @@
+import { Buff, Translatable } from '.';
+import { BreakthroughState } from './breakthrough';
+import { PlayerEntity, CombatEntity, EnemyEntity, CombatEffectTracking, EntityType } from './entity';
+import { ArtefactTechnique, Item } from './item';
+import { InventoryItemState } from './reduxState';
+import { Technique } from './technique';
+import { PhysicalStatistic, SocialStatistic } from './stat';
+export interface CombatLogEffects {
+    source: string;
+    damage?: number;
+    barrier?: number;
+    healing?: number;
+    temporaryHealth?: number;
+    /** Delta toxicity: positive = gained, negative = cleansed */
+    toxicity?: number;
+    buffsCreated?: Record<string, number>;
+    buffsInflicted?: Record<string, number>;
+    buffsConsumed?: Record<string, number>;
+}
+/**
+ * Optional semantic metadata for structured analysis of log entries.
+ * Used by defeatAnalysis and other systems to avoid regex-based string parsing.
+ */
+export interface CombatLogMeta {
+    /** Name of the technique or buff that was executed */
+    techniqueName?: string;
+    /** True when the technique failed to execute */
+    failed?: boolean;
+    /** The resource that was insufficient/excessive when a technique failed */
+    failedResource?: string;
+    /** True when this entry records a self-damage event */
+    selfDamage?: boolean;
+    /** Remaining HP of the target after this damage event */
+    remainingHp?: number;
+    /** True when this entry marks the end of a round */
+    roundEnd?: boolean;
+    /** True when this entry is a turn section header (Player's Turn, Enemy's Turn, etc.) */
+    turnHeader?: boolean;
+}
+export interface CombatEntitySnapshot {
+    hp: number;
+    maxHp: number;
+    barrier: number;
+}
+export interface CombatPartyMemberSnapshot extends CombatEntitySnapshot {
+    partyId?: string;
+}
+export interface CombatStateSnapshot {
+    player?: CombatEntitySnapshot;
+    enemy?: CombatEntitySnapshot;
+    playerParty?: CombatPartyMemberSnapshot[];
+    enemyParty?: CombatPartyMemberSnapshot[];
+}
+export interface CombatLogEntry {
+    path: string;
+    /** Which entity this log entry is about */
+    entity: EntityType;
+    /** UUID of the specific party member — only set when entity is PlayerParty or EnemyParty */
+    partyId?: string;
+    message: string;
+    effects?: CombatLogEffects;
+    meta?: CombatLogMeta;
+    /** Snapshot of HP/barrier for all combat entities at the moment this entry was created */
+    state?: CombatStateSnapshot;
+}
+export interface StanceTracking {
+    techniques: string[];
+    name: string;
+    count: number;
+}
+export interface PlayerStanceData {
+    playerStanceIndex: number;
+    usedPlayerStanceOpeners: boolean[];
+    lastPlayerStance: string;
+    lastCycleKey?: string;
+}
+export interface CurrentCombatState {
+    player: PlayerEntity | undefined;
+    playerState: CombatEntity | undefined;
+    breakthrough: BreakthroughState | undefined;
+    playerStanceData: PlayerStanceData | undefined;
+    enemies: EnemyEntity[];
+    foughtEnemies: EnemyEntity[];
+    enemyState: CombatEntity | undefined;
+    lastEnemyStance: string | undefined;
+    currentPhase: number;
+    allPhases: EnemyEntity[];
+    phaseTransitioning: boolean;
+    roundNum: number;
+    roundState: RoundState | undefined;
+    consumedPills: number;
+    noEnhancement?: boolean;
+    noCrit?: boolean;
+    trainingMode?: boolean;
+    isSpar?: boolean;
+    playerEffectTracking: Record<string, CombatEffectTracking>;
+    enemyEffectTracking: Record<string, CombatEffectTracking>;
+    stanceTracking: Record<string, StanceTracking>;
+    partyStanceTracking: Record<number, Record<string, StanceTracking>>;
+    pillTracking: Record<string, number>;
+    autoUseRowTracking: Record<number, number>;
+    inventoryItems?: InventoryItemState[];
+    loot: Item[];
+    kills: {
+        name: string;
+        displayName?: Translatable;
+    }[];
+    qi: number;
+    combatState: 'victory' | 'defeat' | undefined;
+    combatLog: CombatLogEntry[];
+    gameFlags: Record<string, number>;
+    precalculatedLoot: {
+        items: Item[];
+        qi: number;
+    }[];
+    lootBurstTriggered: boolean;
+    lootBurstQueue: {
+        id: string;
+        loot: Item[];
+        qi: number;
+        enemyPosition: {
+            x: number;
+            y: number;
+        };
+        playerPosition: {
+            x: number;
+            y: number;
+        };
+    }[];
+    previewCallbacks?: {
+        onBuffFailed: (buff: Buff) => void;
+    };
+    /** Permanent stat changes accumulated during combat to be applied to the player on exit. */
+    permanentStatChanges?: Partial<Record<PhysicalStatistic | SocialStatistic, number>>;
+}
+export interface RoundState {
+    player: EntityRoundState;
+    enemy: EntityRoundState;
+    playerArtefacts: ArtefactRoundState[];
+    enemyArtefacts: ArtefactRoundState[];
+    playerParty: EntityRoundState[];
+    enemyParty: EntityRoundState[];
+    roundQueue: RoundStep[];
+    delay: number;
+}
+export type RoundStep = PlayerRoundStep | PlayerArtefactRoundStep | PlayerPartyRoundStep | EnemyRoundStep | EnemyArtefactRoundStep | EnemyPartyRoundStep | BuffsRoundStep | BuffsRoundStartStep | EndRoundStep;
+export interface PlayerRoundStep {
+    kind: 'player';
+}
+export interface PlayerArtefactRoundStep {
+    kind: 'playerArtefact';
+    index: number;
+}
+export interface PlayerPartyRoundStep {
+    kind: 'playerParty';
+    index: number;
+}
+export interface EnemyArtefactRoundStep {
+    kind: 'enemyArtefact';
+    index: number;
+}
+export interface EnemyPartyRoundStep {
+    kind: 'enemyParty';
+    index: number;
+}
+export interface EnemyRoundStep {
+    kind: 'enemy';
+}
+export interface BuffsRoundStep {
+    kind: 'buffs';
+}
+export interface BuffsRoundStartStep {
+    kind: 'buffsStart';
+}
+export interface EndRoundStep {
+    kind: 'end';
+}
+export interface EntityRoundState {
+    techniques: Technique[];
+    used: Technique[];
+    doneUltimate: boolean;
+}
+export interface ArtefactRoundState {
+    techniques: ArtefactTechnique[];
+    used: ArtefactTechnique[];
+}

package/dist/combat.js

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

package/dist/entity.d.ts

@@ -14,6 +14,7 @@ export interface CombatEffectTracking {
     damage: number;
     healing: number;
     barrier: number;
+    temphp: number;
     damageTaken: number;
 }
 export declare const entityTypes: readonly ["Player", "Lifeform", "Enemy", "PlayerParty", "EnemyParty", "System"];
@@ -332,6 +333,8 @@ export interface CombatEntity {
     partyId?: string;
     /** When true, critchance is forced to 0 for this entity (used in training ground) */
     noCrit?: boolean;
+    /** Maximum qi droplets for this entity (set during combat entity creation) */
+    maxqiDroplets?: number;
     /** Cached hash for getVariablesFromEntity. Cleared whenever stats or buffs mutate. */
     _cachedHash?: string;
 }

package/dist/event.d.ts

@@ -464,6 +464,10 @@ export interface SetAidBreakthroughCooldownStep extends BaseEventStep {
 export interface StoneCuttingStep extends BaseEventStep {
     kind: 'stoneCutting';
     realm: Realm;
+    /** Percentage discount to apply to stone cutting costs (0-100), evaluated as expression */
+    discountPercentage?: string;
+    /** Number of stones the player can cut for free, evaluated as expression */
+    freeCount?: string;
 }
 export interface GiveItemStep extends BaseEventStep {
     kind: 'giveItem';

package/dist/gameVersion.d.ts

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

package/dist/gameVersion.js

@@ -15,4 +15,4 @@
  *   };
  * }
  */
-export const GAME_VERSION = "0.6.55";
+export const GAME_VERSION = "0.6.57";

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './calendar';
 export * from './character';
 export * from './CharacterRequestEncounter';
 export * from './components';
+export * from './combat';
 export * from './crafting';
 export * from './craftingBuff';
 export * from './craftingState';

package/dist/index.js

@@ -8,6 +8,7 @@ export * from './calendar';
 export * from './character';
 export * from './CharacterRequestEncounter';
 export * from './components';
+export * from './combat';
 export * from './crafting';
 export * from './craftingBuff';
 export * from './craftingState';

package/dist/item.d.ts

@@ -12,7 +12,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';
-import { DelveRoom } from './soulShardDelve';
+import { DelveRoomConfig } from './soulShardDelve';
 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: {
@@ -43,6 +43,13 @@ interface ItemBase {
     qualityTier?: number;
     hiddenPotential?: number;
     minimumPotential?: number;
+    corruption?: ItemCorruption;
+}
+export interface ItemCorruption {
+    name: Translatable;
+    debuff: Buff;
+    threshold: number;
+    countPerCombat: number;
 }
 export interface ItemDesc {
     name: string;
@@ -223,6 +230,14 @@ export interface CombatItem extends ItemBase {
 export interface ConsumablePillItem extends BasePillItem {
     pillKind: 'consumable';
     max: number;
+    /**
+     * Optional shared consumption group. When set, the player can consume at most `groupCap`
+     * pills total across every pill that names the same `consumptionGroup`, in addition to
+     * each pill's individual `max` limit.
+     */
+    consumptionGroup?: string;
+    /** Lifetime cap for the entire consumption group. Required when `consumptionGroup` is set. */
+    groupCap?: number;
     physicalStats: Partial<Record<PhysicalStatistic, number>>;
     socialStats: Partial<Record<SocialStatistic, number>>;
     rawStats?: Partial<Record<CombatStatistic | CraftingStatistic, Scaling>>;
@@ -454,9 +469,9 @@ export interface PillarShardVariant {
 }
 export interface PillarShardItem extends ItemBase {
     kind: 'pillar_shard';
-    tooltip: Translatable;
+    tooltip?: Translatable;
     maxInstances?: number;
-    delveRoomConfig?: DelveRoom;
+    delveRoomConfig?: DelveRoomConfig;
     variants?: PillarShardVariant[];
     stability?: number;
     portal?: {

package/dist/itemAction.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+import type { AppDispatch } from '../store';
+import type { BreakthroughState } from './breakthrough';
+import type { SoundEffectName } from './audio';
+import type { Item } from './item';
+import type { PlayerEntity } from './entity';
+import type { InventoryState } from './reduxState';
+interface OpenItem {
+    item: Item;
+    data: unknown;
+    onComplete: () => void;
+}
+export interface ItemActionContext {
+    item: Item;
+    player: PlayerEntity;
+    inventory: InventoryState;
+    breakthrough: BreakthroughState;
+    flags: Record<string, number | string | boolean>;
+    dispatch: AppDispatch;
+    setResult: (result: ReactNode) => void;
+    setClicked: (clicked: boolean) => void;
+    setOpenItem?: (openItem: OpenItem) => void;
+    setDoEnchant?: (doEnchant: boolean) => void;
+    setDoUpgrade?: (doUpgrade: boolean) => void;
+    setDoAppearanceChange?: (doAppearanceChange: boolean) => void;
+    playSfx: (sound: SoundEffectName) => void;
+    usageRestricted: boolean;
+}
+export interface ItemActionResult {
+    buttons: ReactNode[];
+}
+export type ItemActionHandler = (context: ItemActionContext) => ItemActionResult;
+export {};

package/dist/itemAction.js

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

package/dist/keybindings.d.ts

@@ -1,5 +1,5 @@
 export type KeybindingCategory = 'general' | 'navigation' | 'ui' | 'world' | 'combat' | 'crafting' | 'dialogs' | 'gamepad';
-export type KeybindingAction = 'confirm' | 'cancel' | 'pause' | 'alternateConfirm' | 'moveUp' | 'moveDown' | 'moveLeft' | 'moveRight' | 'openInventory' | 'openQuests' | 'openCharacterStats' | 'openTechniques' | 'openCalendar' | 'openWorldMap' | 'combatSelectStance0' | 'combatSelectStance1' | 'combatSelectStance2' | 'combatSelectStance3' | 'combatSelectStance4' | 'combatSelectStance5' | 'combatSelectStance6' | 'combatSelectStance7' | 'combatSelectStance8' | 'combatSelectStance9' | 'combatToggleSpeed' | 'combatToggleLog' | 'combatShowStats' | 'combatAutoBattle' | 'combatUseItem' | 'combatCancel' | 'craftingAction1' | 'craftingAction2' | 'craftingAction3' | 'craftingAction4' | 'craftingAction5' | 'craftingAction6' | 'craftingAction7' | 'craftingAction8' | 'craftingAction9' | 'craftingAction10' | 'craftingAction11' | 'craftingAction12' | 'craftingAction13' | 'craftingAction14' | 'craftingAction15' | 'craftingAction16' | 'craftingAction17' | 'craftingAction18' | 'craftingAction19' | 'craftingAction20' | 'craftingAction21' | 'craftingAction22' | 'craftingAction23' | 'craftingAction24' | 'craftingAction25' | 'craftingAction26' | 'craftingAction27' | 'craftingAction28' | 'craftingAction29' | 'craftingAction30' | 'craftingAction31' | 'craftingAction32' | 'craftingAction33' | 'craftingAction34' | 'craftingAction35' | 'craftingAction36' | 'craftingAction37' | 'craftingAction38' | 'craftingAction39' | 'craftingAction40' | 'craftingAction41' | 'craftingAction42' | 'craftingAction43' | 'craftingAction44' | 'craftingAction45' | 'craftingAction46' | 'craftingAction47' | 'craftingAction48' | 'craftingAction49' | 'craftingAction50' | 'dialogChoice1' | 'dialogChoice2' | 'dialogChoice3' | 'dialogChoice4' | 'dialogChoice5' | 'dialogChoice6' | 'dialogChoice7' | 'dialogChoice8' | 'dialogChoice9' | 'gamepadConfirm' | 'gamepadCancel' | 'gamepadUp' | 'gamepadDown' | 'gamepadLeft' | 'gamepadRight';
+export type KeybindingAction = 'confirm' | 'cancel' | 'pause' | 'alternateConfirm' | 'moveUp' | 'moveDown' | 'moveLeft' | 'moveRight' | 'openInventory' | 'openQuests' | 'openCharacterStats' | 'openTechniques' | 'openCalendar' | 'lockTooltip' | 'openWorldMap' | 'combatSelectStance0' | 'combatSelectStance1' | 'combatSelectStance2' | 'combatSelectStance3' | 'combatSelectStance4' | 'combatSelectStance5' | 'combatSelectStance6' | 'combatSelectStance7' | 'combatSelectStance8' | 'combatSelectStance9' | 'combatToggleSpeed' | 'combatToggleLog' | 'combatShowStats' | 'combatAutoBattle' | 'combatUseItem' | 'combatCancel' | 'craftingAction1' | 'craftingAction2' | 'craftingAction3' | 'craftingAction4' | 'craftingAction5' | 'craftingAction6' | 'craftingAction7' | 'craftingAction8' | 'craftingAction9' | 'craftingAction10' | 'craftingAction11' | 'craftingAction12' | 'craftingAction13' | 'craftingAction14' | 'craftingAction15' | 'craftingAction16' | 'craftingAction17' | 'craftingAction18' | 'craftingAction19' | 'craftingAction20' | 'craftingAction21' | 'craftingAction22' | 'craftingAction23' | 'craftingAction24' | 'craftingAction25' | 'craftingAction26' | 'craftingAction27' | 'craftingAction28' | 'craftingAction29' | 'craftingAction30' | 'craftingAction31' | 'craftingAction32' | 'craftingAction33' | 'craftingAction34' | 'craftingAction35' | 'craftingAction36' | 'craftingAction37' | 'craftingAction38' | 'craftingAction39' | 'craftingAction40' | 'craftingAction41' | 'craftingAction42' | 'craftingAction43' | 'craftingAction44' | 'craftingAction45' | 'craftingAction46' | 'craftingAction47' | 'craftingAction48' | 'craftingAction49' | 'craftingAction50' | 'dialogChoice1' | 'dialogChoice2' | 'dialogChoice3' | 'dialogChoice4' | 'dialogChoice5' | 'dialogChoice6' | 'dialogChoice7' | 'dialogChoice8' | 'dialogChoice9' | 'gamepadConfirm' | 'gamepadCancel' | 'gamepadUp' | 'gamepadDown' | 'gamepadLeft' | 'gamepadRight';
 export interface KeybindingDefinition {
     action: KeybindingAction | string;
     category: KeybindingCategory;
@@ -28,6 +28,7 @@ export declare const MODIFIER_PREFIXES: {
     readonly alt: "Alt+";
     readonly shift: "Shift+";
 };
+export declare const baseKeyToCode: Record<string, string>;
 export declare function getBaseKeyFromEvent(event: KeyboardEvent): string;
 export declare function buildKeybindingString(key: string, modifiers: {
     ctrl?: boolean;