afnm-types 0.6.34 → 0.6.38

package/dist/buff.d.ts

@@ -128,7 +128,7 @@ export interface Buff {
     setupPercent?: number;
     cantUpgrade?: boolean;
 }
-type BuffCombatImage = ScatterCombatImage | ArcCombatImage | FloatingCombatImage | OverlayCombatImage | CompanionCombatImage | GroundCombatImage | FormationCombatImage;
+type BuffCombatImage = ScatterCombatImage | ArcCombatImage | FloatingCombatImage | OverlayCombatImage | CompanionCombatImage | GroundCombatImage | FormationCombatImage | TransformationCombatImage;
 interface BaseCombatImage {
     image: string;
     imageOverrides?: {
@@ -196,6 +196,50 @@ export interface FormationCombatImage extends BaseCombatImage {
     scale?: number;
     showSingleInstance?: boolean;
 }
+/** Image configuration for a single avatar state in transformation */
+export interface TransformationImageConfig {
+    image: string;
+    scale?: number;
+    imageOffset?: {
+        x: number;
+        y: number;
+    };
+}
+/** Stack-based override for transformation images */
+export interface TransformationImageOverride {
+    stacks: number;
+    idle?: TransformationImageConfig;
+    support?: TransformationImageConfig;
+    defensive?: TransformationImageConfig;
+    utility?: TransformationImageConfig;
+    aggressive?: TransformationImageConfig;
+    offensive?: TransformationImageConfig;
+    hit?: TransformationImageConfig;
+}
+/**
+ * Transformation combat image that replaces the avatar's images while the buff exists.
+ * Used for "transformation" techniques like turning into a spirit beast.
+ * Only the last active transformation buff applies.
+ * Unset image fields inherit from the idle image using the "closest" stack logic.
+ */
+export interface TransformationCombatImage {
+    position: 'transformation';
+    /** The base idle image for the transformation */
+    idle: TransformationImageConfig;
+    /** Optional stance-specific images. If not set, falls back to idle. */
+    support?: TransformationImageConfig;
+    defensive?: TransformationImageConfig;
+    utility?: TransformationImageConfig;
+    aggressive?: TransformationImageConfig;
+    offensive?: TransformationImageConfig;
+    hit?: TransformationImageConfig;
+    /** Stack-based overrides. Uses "closest" logic (findLast where stacks <= current). */
+    imageOverrides?: TransformationImageOverride[];
+    /** Animations to trigger on the entity when this buff is applied/updated */
+    animations?: ('buff' | 'bump' | 'attack' | 'debuff')[];
+    /** Whether animations should trigger on the entity. Defaults to true for transformation. */
+    animateOnEntity?: boolean;
+}
 export type BuffEffect = DamageEffect | DamageSelfEffect | HealEffect | BarrierEffect | CreateBuffSelfEffect | ConsumeBuffSelfEffect | CreateBuffTargetEffect | ConsumeBuffTargetEffect | NegateEffect | AddEffect | MultiplyEffect | MergeEffect | TriggerEffect | ModifyBuffGroupEffect | CleanseToxicityEffect | SetStateEffect | ConvertSelfEffect;
 interface BaseBuff {
     condition?: TechniqueCondition;

package/dist/character.d.ts

@@ -9,7 +9,7 @@ import { Realm, RealmProgress } from './realm';
 import { IntimateTrait } from './dualCultivation';
 export interface Character {
     name: string;
-    displayName?: string;
+    displayName?: Translatable;
     allegiance: string | undefined;
     bio?: string;
     condition: string;

package/dist/craftingTechnique.d.ts

@@ -37,6 +37,7 @@ export interface KnownCraftingTechnique {
 }
 export interface CraftingTechnique {
     name: string;
+    displayName?: Translatable;
     icon: string;
     poolCost: number;
     toxicityCost?: number;

package/dist/dualCultivation.d.ts

@@ -7,6 +7,7 @@ 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 declare const dualCultivationCompletionStateToName: Record<string, string>;
 export type IntimateTrait = {
     name: string;
     description: Translatable;
@@ -15,6 +16,7 @@ export type IntimateTrait = {
 };
 export type IntimateTechnique = {
     name: string;
+    displayName?: Translatable;
     condition: string;
     type: IntimateTechniqueType;
     icon: string;

package/dist/dualCultivation.js

@@ -12,3 +12,7 @@ export const intimateResourceToName = {
     excitement: 'Excitement',
     rhythm: 'Rhythm',
 };
+export const dualCultivationCompletionStateToName = {
+    success: 'Success',
+    failure: 'Failure',
+};

package/dist/entity.d.ts

@@ -20,6 +20,9 @@ export declare const entityTypes: readonly ["Player", "Lifeform", "Enemy"];
 export type EntityType = (typeof entityTypes)[number];
 export declare const sexes: readonly ["male", "female"];
 export type Sex = (typeof sexes)[number];
+export declare const sexToName: {
+    [key in Sex]: string;
+};
 export interface PlayerEntity {
     imageIndex: number;
     originalImageIndex?: number;

package/dist/entity.js

@@ -1,2 +1,6 @@
 export const entityTypes = ['Player', 'Lifeform', 'Enemy'];
 export const sexes = ['male', 'female'];
+export const sexToName = {
+    male: 'Male',
+    female: 'Female',
+};

package/dist/guild.d.ts

@@ -10,6 +10,7 @@ export interface GuildMission {
 }
 export interface Guild {
     name: string;
+    displayName?: Translatable;
     description: Translatable;
     icon: string;
     image: string;

package/dist/herbField.d.ts

@@ -1,5 +1,7 @@
+import { Translatable } from './translatable';
 export interface SoilCondition {
     name: string;
+    displayName?: Translatable;
     icon: string;
     soilImage: string;
     soilZ: number;

package/dist/house.d.ts

@@ -28,6 +28,7 @@ export interface RoomDef {
 export type Room = BuffRoom | CultivationRoom | CraftingRoom | CompendiumRoom | HealerRoom | TeleportRoom;
 interface RoomBase {
     name: string;
+    displayName?: Translatable;
     description: Translatable;
     realm: Realm | 'any';
     rarity: Rarity;

package/dist/item.d.ts

@@ -17,6 +17,9 @@ export type ItemKind = (typeof itemKinds)[number];
 export declare const itemKindToName: {
     [key in ItemKind]: string;
 };
+export declare const itemKindPluralToName: {
+    [key in ItemKind]: string;
+};
 export type ItemCostMap = {
     [key in ItemKind]: number;
 };
@@ -94,6 +97,7 @@ export interface ManualStyle {
 }
 export interface ManualStance {
     name: string;
+    displayName?: Translatable;
     stance: string[];
     stanceRule?: StoredRule;
 }
@@ -327,6 +331,7 @@ export interface Enchantment {
     rarity: Rarity;
     itemKind: ItemKind;
     name: string;
+    displayName?: Translatable;
 }
 export type EnchantmentMap<T extends Enchantment> = Record<Realm, Record<Rarity, T>>;
 export interface MountEnchantment extends Enchantment {
@@ -417,6 +422,7 @@ export interface QiDensityFormationItem extends FormationItemBase {
 }
 export interface PillarShardVariant {
     title: string;
+    displayName?: Translatable;
     icon: string;
     physicalStats?: Partial<Record<PhysicalStatistic, number>>;
     socialStats?: Partial<Record<SocialStatistic, number>>;

package/dist/item.js

@@ -68,6 +68,41 @@ export const itemKindToName = {
     device: 'Device',
     manual: 'Manual',
 };
+export const itemKindPluralToName = {
+    clothing: 'Clothing',
+    talisman: 'Talismans',
+    artefact: 'Artefacts',
+    mount: 'Mounts',
+    cauldron: 'Cauldrons',
+    flame: 'Flames',
+    upgrade: 'Upgrades',
+    fruit: 'Fruits',
+    elixir: 'Elixirs',
+    recipe: 'Recipes',
+    technique: 'Techniques',
+    action: 'Actions',
+    transport_seal: 'Transport Seals',
+    enchantment: 'Enchantments',
+    pill: 'Pills',
+    reagent: 'Reagents',
+    concoction: 'Concoctions',
+    consumable: 'Consumables',
+    recuperation: 'Recuperation',
+    formation: 'Formations',
+    breakthrough: 'Breakthroughs',
+    pillar_shard: 'Pillar Shards',
+    material: 'Materials',
+    flare: 'Flares',
+    mystical_key: 'Mystical Keys',
+    condensation_art: 'Condensation Arts',
+    blueprint: 'Blueprints',
+    trophy: 'Trophies',
+    treasure: 'Treasures',
+    token: 'Tokens',
+    life_essence: 'Life Essences',
+    device: 'Devices',
+    manual: 'Manuals',
+};
 export const buyItemCostMap = {
     technique: 3000,
     artefact: 3500,

package/dist/location.d.ts

@@ -11,7 +11,7 @@ import { Buff } from './buff';
 import { AmbienceName, MusicName } from './audio';
 export interface GameLocation {
     name: string;
-    displayName?: string;
+    displayName?: Translatable;
     description: Translatable;
     image: string;
     icon: string;

package/dist/location.js

@@ -21,7 +21,7 @@ export const buildingTypeToName = {
     house: '',
     altar: 'Compression Altar',
     research: 'Vault of Infinite Reflections',
-    reforge: `Infusion Workshop`,
+    reforge: `Reforge Workshop`,
     guild: '',
     tenThousandFlames: 'Furnace of Ten Thousand Flames',
     modBuilding: '',

package/dist/mod.d.ts

@@ -10,23 +10,25 @@ import { Character } from './character';
 import { CraftingTechnique, CraftingRecipeStats } from './craftingTechnique';
 import { RecipeConditionEffect } from './crafting';
 import { Destiny } from './destiny';
-import { CombatEntity, EnemyEntity, PlayerEntity } from './entity';
+import { BattleLength, CombatEntity, CraftingEntity, EnemyDifficulty, EnemyEntity, PlayerEntity } from './entity';
 import { AuctionStep, CombatStep, CraftingStep, DualCultivationStep, EventStep, FightCharacterStep, GameEvent, StoneCuttingStep, TournamentStep, TriggeredEvent } from './event';
 import { Guild } from './guild';
 import { Crop } from './herbField';
-import { Enchantment, Item, ItemDesc, ManualItem, RecipeItem, UncutStonePool } from './item';
+import { Enchantment, EnchantmentDesc, Item, ItemDesc, ManualItem, RecipeItem, UncutStonePool } from './item';
 import { ConditionalLink, ExplorationLink, GameLocation, LocationBuilding, LocationEnemy, LocationEvent, LocationMapEvent, SectMission, CraftingMission } from './location';
 import { MineChamber } from './mine';
 import { Quest } from './quest';
 import { Realm, RealmProgress } from './realm';
-import { CraftingStatistic, ReputationTier } from './stat';
-import { Technique } from './technique';
+import { CraftingStatistic, ReputationTier, Scaling } from './stat';
+import { KnownTechnique, Technique } from './technique';
 import { IntimateTechnique } from './dualCultivation';
+import { KnownCraftingTechnique } from './craftingTechnique';
 import { FallenStar } from './fallenStar';
 import { Room } from './house';
 import { Blessing } from './mysticalRegion';
-import { CraftingResult } from './craftingState';
-import { HarmonyTypeConfig, RecipeHarmonyType } from './crafting';
+import { CraftingResult, CraftingState, ProgressState } from './craftingState';
+import { CraftingTechniqueCondition } from './craftingBuff';
+import { CraftingCondition, HarmonyTypeConfig, RecipeHarmonyType } from './crafting';
 import { ItemKind } from './item';
 import { SoundEffectName } from './audio';
 import { ScreenEffectType } from './ScreenEffectType';
@@ -759,6 +761,99 @@ export interface ModAPI {
          * });
          */
         addTranslation: (language: string, translations: Record<string, unknown>) => void;
+        /**
+         * Set the font size multiplier for a specific language.
+         * Use this to adjust text size for languages that render larger or smaller
+         * than English (e.g., Russian text tends to be longer).
+         *
+         * @param language - Language code (e.g., 'ru', 'zh', 'de')
+         * @param multiplier - Font size multiplier (e.g., 0.9 for 90%, 1.1 for 110%)
+         * @example
+         * // Make Russian text 10% smaller
+         * setLanguageFontSize('ru', 0.9);
+         *
+         * // Make Chinese text 5% larger
+         * setLanguageFontSize('zh', 1.05);
+         */
+        setLanguageFontSize: (language: string, multiplier: number) => void;
+        /**
+         * Add a custom font that can be used in the game.
+         *
+         * @param fontFamily - Font family name to use in CSS
+         * @param fontUrl - URL or data URL of the font file (use mod:// for mod assets)
+         * @param format - Font format ('opentype', 'truetype', 'woff', 'woff2')
+         * @param options - Optional font weight and style
+         * @example
+         * // Add a custom font from a mod asset
+         * addCustomFont('MyCustomFont', 'mod://fonts/custom.ttf', 'truetype');
+         *
+         * // Add with specific weight and style
+         * addCustomFont('MyCustomFont', 'mod://fonts/custom-bold.ttf', 'truetype', {
+         *   fontWeight: 700,
+         *   fontStyle: 'normal'
+         * });
+         */
+        addCustomFont: (fontFamily: string, fontUrl: string, format: 'opentype' | 'truetype' | 'woff' | 'woff2', options?: {
+            fontWeight?: number;
+            fontStyle?: 'normal' | 'italic';
+        }) => void;
+        /**
+         * Set a custom font as the primary font for the entire game.
+         * This replaces the default fonts with the specified custom font family.
+         * The font must first be added using addCustomFont.
+         *
+         * @param fontFamily - Font family name (must match a font added via addCustomFont)
+         * @example
+         * // First add the font
+         * addCustomFont('MyCustomFont', 'mod://fonts/custom.ttf', 'truetype');
+         *
+         * // Then set it as the primary font
+         * setCustomFontFamily('MyCustomFont');
+         */
+        setCustomFontFamily: (fontFamily: string) => void;
+        /**
+         * Override the game's MUI theme with custom options.
+         * This allows complete control over colors, component styles, typography, etc.
+         * Multiple overrides are merged in order, with later overrides taking precedence.
+         *
+         * @param overrides - Partial MUI ThemeOptions to merge with the base theme
+         * @example
+         * // Change the primary color scheme
+         * addThemeOverride({
+         *   palette: {
+         *     primary: {
+         *       main: '#1976d2',
+         *       light: '#42a5f5',
+         *       dark: '#1565c0',
+         *     },
+         *   },
+         * });
+         *
+         * // Customize button styles
+         * addThemeOverride({
+         *   components: {
+         *     MuiButton: {
+         *       styleOverrides: {
+         *         root: {
+         *           borderRadius: '20px',
+         *           textTransform: 'none',
+         *         },
+         *       },
+         *     },
+         *   },
+         * });
+         *
+         * // Change background colors
+         * addThemeOverride({
+         *   palette: {
+         *     background: {
+         *       default: '#121212',
+         *       paper: '#1e1e1e',
+         *     },
+         *   },
+         * });
+         */
+        addThemeOverride: (overrides: Record<string, unknown>) => void;
     };
     utils: {
         /**
@@ -1191,6 +1286,380 @@ export interface ModAPI {
          * // Returns { 'tutorialName': 1, 'tutorialNameStarted': 1, 'tutorialNameCompleted': 1, ... }
          */
         generateSkipTutorialFlags: (tutorials: Tutorial[], triggers: TriggeredEvent[]) => Record<string, number>;
+        /**
+         * Evaluate a Scaling object against current variables.
+         * Applies base value, stat/scaling multipliers, equations, custom scaling, max constraints, and stance length division.
+         * @param scaling - The scaling definition
+         * @param variables - Current variable values (stats, buffs, etc.)
+         * @param stanceLength - Number of techniques in the current stance
+         * @param preMaxTransform - Optional transform applied before max constraint
+         * @returns The computed numeric value
+         */
+        evaluateScaling: (scaling: Scaling, variables: Record<string, number>, stanceLength: number, preMaxTransform?: (value: number) => number) => number;
+        /**
+         * Calculate crit multiplier with overflow conversion for crafting.
+         * Crit chance over 100% is converted to bonus crit multiplier at a 1:3 ratio.
+         * @param critChance - The total crit chance (can be > 100%)
+         * @param critMultiplier - The crit multiplier (as percentage, e.g., 200 for 2x)
+         * @returns Object with multiplier, critCount, and didCrit
+         */
+        calculateCraftingOvercrit: (critChance: number, critMultiplier: number) => {
+            multiplier: number;
+            critCount: number;
+            didCrit: boolean;
+        };
+        /**
+         * Get the maximum achievable completion for a recipe.
+         * @param recipe - The recipe item
+         * @param recipeStats - The crafting recipe stats
+         * @param realm - The player's realm
+         * @returns Object with flat value and percentage
+         */
+        getMaxCompletion: (recipe: RecipeItem, recipeStats: CraftingRecipeStats, realm: Realm) => {
+            flat: number;
+            percentage: number;
+        };
+        /**
+         * Get the maximum achievable perfection for a recipe.
+         * @param recipe - The recipe item
+         * @param recipeStats - The crafting recipe stats
+         * @param realm - The player's realm
+         * @returns Object with flat value and percentage
+         */
+        getMaxPerfection: (recipe: RecipeItem, recipeStats: CraftingRecipeStats, realm: Realm) => {
+            flat: number;
+            percentage: number;
+        };
+        /**
+         * Check whether a crafting technique can be used given current state.
+         * Validates pool cost, buff costs, condition requirements, buff requirements, toxicity capacity, stability, and cooldown.
+         * @param technique - The crafting technique to check
+         * @param variables - Current crafting variable values
+         * @param poolCost - The pool cost of the technique
+         * @param condition - The current crafting condition
+         * @returns Whether the technique can be used
+         */
+        canUseAction: (technique: CraftingTechnique, variables: Record<string, number>, poolCost: number, condition: CraftingCondition) => boolean;
+        /**
+         * Get a full Item from an item descriptor (name + optional enchantment, quality, etc.).
+         * Resolves techniques, manuals, blueprints, crafting actions, and regular items,
+         * then applies quality tier upgrades and enchantments.
+         * @param desc - Item descriptor with name and optional properties
+         * @returns Fully resolved Item
+         * @example
+         * const item = getFullItem({ name: 'Spirit Core (III)', qualityTier: 3 });
+         */
+        getFullItem: (desc: {
+            name: string;
+            stacks?: number;
+            enchantment?: EnchantmentDesc;
+            qualityTier?: number;
+            hiddenPotential?: number;
+        } | undefined) => Item;
+        /**
+         * Resolve a KnownCraftingTechnique into a full CraftingTechnique with masteries applied.
+         * @param known - The known crafting technique reference
+         * @returns Fully resolved CraftingTechnique
+         * @example
+         * const technique = craftingTechniqueFromKnown(knownTechnique);
+         */
+        craftingTechniqueFromKnown: (known: KnownCraftingTechnique | undefined) => CraftingTechnique;
+        /**
+         * Resolve a KnownTechnique into a full Technique with masteries applied.
+         * @param known - The known technique reference
+         * @returns Fully resolved Technique
+         * @example
+         * const technique = techniqueFromKnown(knownTechnique);
+         */
+        techniqueFromKnown: (known: KnownTechnique | undefined) => Technique;
+        /**
+         * Scale an enemy entity to a different realm and progress.
+         * Adjusts stances to fill available technique slots.
+         * @param base - Base enemy entity template
+         * @param realm - Target realm
+         * @param realmProgress - Target realm progress
+         * @returns Scaled enemy entity
+         * @example
+         * const scaledBandit = scaleEnemy(bandit, 'coreFormation', 'Middle');
+         */
+        scaleEnemy: (base: EnemyEntity, realm: Realm, realmProgress: RealmProgress) => EnemyEntity;
+        /**
+         * Calculate expected HP for an enemy based on its realm, progress, and battle length.
+         * @param enemy - Enemy entity definition
+         * @returns Expected HP value
+         * @example
+         * const hp = calculateEnemyHp(myEnemy);
+         */
+        calculateEnemyHp: (enemy: EnemyEntity) => number;
+        /**
+         * Calculate expected power for an enemy based on its realm, progress, difficulty, and battle length.
+         * @param enemy - Enemy entity definition
+         * @returns Expected power value
+         * @example
+         * const power = calculateEnemyPower(myEnemy);
+         */
+        calculateEnemyPower: (enemy: EnemyEntity) => number;
+        /**
+         * Create a full CombatEntity from an EnemyEntity definition.
+         * Applies equipment, stats, mod hooks, and spawn conditions.
+         * @param enemy - Enemy entity definition
+         * @param gameFlags - Current game flags
+         * @returns Fully resolved combat entity
+         * @example
+         * const combatEntity = createEnemyCombatEntity(myEnemy, {});
+         */
+        createEnemyCombatEntity: (enemy: EnemyEntity, gameFlags: Record<string, number>) => CombatEntity;
+        /**
+         * Convert a BattleLength enum value to a numeric time-to-kill multiplier.
+         * @param battleLength - Battle length setting
+         * @returns TTK multiplier
+         * @example
+         * const ttk = battleLengthToTTK('medium'); // Returns 4
+         */
+        battleLengthToTTK: (battleLength: BattleLength) => number;
+        /**
+         * Convert an EnemyDifficulty enum value to a numeric damage multiplier.
+         * @param difficulty - Enemy difficulty setting
+         * @returns Damage multiplier
+         * @example
+         * const dmgMult = difficultyToDamage('hard'); // Returns 1.2
+         */
+        difficultyToDamage: (difficulty: EnemyDifficulty) => number;
+        /**
+         * Calculate the spirit stone cost of an item based on kind, realm, rarity, quality, and enchantment.
+         * @param item - Fully resolved item
+         * @returns Spirit stone cost
+         * @example
+         * const cost = getItemCost(myItem);
+         */
+        getItemCost: (item: Item) => number;
+        /**
+         * Derive crafting recipe difficulty stats (stability, completion, perfection, condition type).
+         * @param recipe - Recipe item definition
+         * @param gameFlags - Current game flags
+         * @returns Crafting recipe stats
+         * @example
+         * const stats = deriveRecipeDifficulty(myRecipe, {});
+         */
+        deriveRecipeDifficulty: (recipe: RecipeItem, gameFlags: Record<string, number>) => CraftingRecipeStats;
+        /**
+         * Get the number of technique slots in a stance for a given realm.
+         * @param realm - Cultivation realm
+         * @returns Number of technique slots
+         * @example
+         * const slots = getTechniqueSlots('coreFormation'); // Returns 6
+         */
+        getTechniqueSlots: (realm: Realm) => number;
+        /**
+         * Get maximum toxicity capacity for a realm.
+         * @param realm - Cultivation realm
+         * @returns Max toxicity value
+         * @example
+         * const maxTox = getMaxToxicity('qiCondensation');
+         */
+        getMaxToxicity: (realm: Realm) => number;
+        /**
+         * Calculate damage after defense, protection, DR, and vulnerability.
+         * @param attackPower - Raw attack power
+         * @param defenderDefense - Defender's defense stat
+         * @param defenderDr - Defender's damage reduction (0-1)
+         * @param defenderDefenseFactor - Defense scaling factor
+         * @param maxReduction - Maximum damage reduction cap
+         * @param defenderVulnerability - Vulnerability percentage
+         * @param realm - Combat realm
+         * @param realmProgress - Realm progress
+         * @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;
+        /**
+         * Format a number for display (e.g. 1000 -> "1,000").
+         * @param number - Number to format
+         * @returns Formatted string
+         * @example
+         * formatNumber(12500); // "12,500"
+         */
+        formatNumber: (number: number) => string;
+        /**
+         * Get the stat scaling multiplier for a realm and progress.
+         * Used to scale base stats to appropriate power levels.
+         * @param realm - Cultivation realm
+         * @param progress - Realm progress
+         * @returns Scaling multiplier
+         * @example
+         * const scaling = getPlayerRealmScaling('coreFormation', 'Middle');
+         */
+        getPlayerRealmScaling: (realm: Realm, progress: RealmProgress) => number;
+        /**
+         * Resolve all combat variables from a CombatEntity (stats, buffs, derived values).
+         * Useful for inspecting or testing enemy/player combat state.
+         * @param entity - Combat entity to extract variables from
+         * @param opponent - Optional opponent for target-relative variables
+         * @returns Record of all combat variables
+         * @example
+         * const vars = getVariablesFromEntity(combatEntity);
+         * console.log(vars.power, vars.hp, vars.maxhp);
+         */
+        getVariablesFromEntity: (entity: CombatEntity, opponent?: CombatEntity) => Record<string, number>;
+        /**
+         * Calculate how many hits a Scaling object produces given variables.
+         * @param scaling - The scaling definition
+         * @param variables - Current variable values
+         * @param slots - Number of technique slots
+         * @returns Number of hits
+         */
+        calculateHits: (scaling: Scaling, variables: Record<string, number>, slots: number) => number;
+        /**
+         * Convert eyes stat to crit chance percentage.
+         * @param eyes - Eyes physical stat value
+         * @returns Crit chance percentage
+         * @example
+         * const critChance = eyesToCritChance(15); // 20%
+         */
+        eyesToCritChance: (eyes: number) => number;
+        /**
+         * Convert eyes stat to crit damage multiplier (combat).
+         * @param eyes - Eyes physical stat value
+         * @returns Crit damage multiplier (e.g. 150 = 1.5x)
+         * @example
+         * const critDmg = eyesToCritDamage(15); // 250
+         */
+        eyesToCritDamage: (eyes: number) => number;
+        /**
+         * Convert eyes stat to crit multiplier (crafting).
+         * @param eyes - Eyes physical stat value
+         * @returns Crit multiplier percentage
+         */
+        eyesToCritMultiplier: (eyes: number) => number;
+        /**
+         * Convert digestion stat to toxicity resistance.
+         * @param digestion - Digestion physical stat value
+         * @returns Resistance value
+         */
+        getResistance: (digestion: number) => number;
+        /**
+         * Convert digestion stat to item effectiveness.
+         * @param digestion - Digestion physical stat value
+         * @returns Item effectiveness value
+         */
+        getItemEffectiveness: (digestion: number) => number;
+        /**
+         * Convert raw affinity points to an affinity multiplier.
+         * @param points - Raw affinity points
+         * @returns Affinity multiplier
+         */
+        getAffinityMultiplier: (points: number) => number;
+        /**
+         * Convert dantian stat and realm scaling to max barrier.
+         * @param dantian - Dantian physical stat value
+         * @param scaling - Realm scaling multiplier (from getPlayerRealmScaling)
+         * @returns Max barrier value
+         */
+        dantianToMaxBarrier: (dantian: number, scaling: number) => number;
+        /**
+         * Get the UI border color for an item kind.
+         * @param kind - Item kind
+         * @returns CSS color string
+         * @example
+         * const color = getItemBorderCol('pill'); // '#7c4c85'
+         */
+        getItemBorderCol: (kind: ItemKind) => string;
+        /**
+         * Get craft skill bonus multiplier from raw craft skill value.
+         * @param craftSkill - Raw craft skill number
+         * @returns Bonus multiplier (e.g. 0.33 = +33%)
+         */
+        getCraftSkillBonus: (craftSkill: number) => number;
+        /**
+         * Get the craft skill cap for a realm and progress.
+         * Players stop earning craft skill from recipes at or below this cap.
+         * @param realm - Cultivation realm
+         * @param realmProgress - Realm progress
+         * @returns Craft skill cap
+         */
+        getCraftSkillCap: (realm: Realm, realmProgress: RealmProgress) => number;
+        /**
+         * Calculate charisma-based price discount multiplier.
+         * @param charisma - Player's charisma value
+         * @param realm - Item's realm
+         * @returns Discount multiplier (0.1 to 1.0, lower = bigger discount)
+         */
+        getCharismaDiscount: (charisma: number, realm: Realm | 'any') => number;
+        /**
+         * Calculate reputation-based price discount.
+         * @param reputation - Current reputation value
+         * @returns Discount as a fraction (e.g. 0.15 = 15% off)
+         */
+        getReputationDiscount: (reputation: number) => number;
+        /**
+         * Convert a numeric reputation value to a named tier.
+         * @param reputation - Current reputation value
+         * @returns Reputation tier name
+         * @example
+         * getReputationTierName(500); // 'honoured'
+         */
+        getReputationTierName: (reputation: number) => ReputationTier;
+        /**
+         * Get the technique element associated with a calendar year.
+         * Elements cycle every 6 years starting from 1066.
+         * @param year - In-game year
+         * @returns Technique element for that year
+         * @example
+         * getYearElement(1066); // 'blood'
+         * getYearElement(1067); // 'blossom'
+         */
+        getYearElement: (year: number) => TechniqueElement;
+        /**
+         * Resolve all crafting variables from a CraftingEntity, recipe stats, and progress.
+         * Returns actual stat values after applying buffs, conditions, and scaling.
+         * @param entity - The crafting entity
+         * @param recipe - The crafting recipe stats
+         * @param progress - The current crafting progress state
+         * @returns Record of all crafting variables
+         * @example
+         * const vars = getVariablesFromCraftingEntity(entity, recipeStats, progress);
+         * console.log(vars.control, vars.intensity, vars.pool);
+         */
+        getVariablesFromCraftingEntity: (entity: CraftingEntity, recipe: CraftingRecipeStats, progress: ProgressState) => Record<string, number>;
+        /**
+         * Calculate guaranteed bonus count and chance for the next bonus from a value/target pair.
+         * Uses exponential scaling (1.3x per tier).
+         * @param value - The current accumulated value
+         * @param target - The base target threshold
+         * @returns Object with guaranteed count, bonus chance fraction, and next threshold
+         * @example
+         * const result = getBonusAndChance(250, 100);
+         * // { guaranteed: 2, bonusChance: 0.38, nextThreshold: 269 }
+         */
+        getBonusAndChance: (value: number, target: number) => {
+            guaranteed: number;
+            bonusChance: number;
+            nextThreshold: number;
+        };
+        /**
+         * Get the effective value of a crafting statistic after applying buffs and condition effects.
+         * @param stat - The crafting statistic to evaluate
+         * @param entity - The crafting entity
+         * @param condition - The current crafting condition
+         * @param recipeConditionEffect - The recipe's condition effect configuration
+         * @param progress - The current crafting progress
+         * @param recipeStats - The recipe stats
+         * @returns The effective stat value
+         */
+        getActualCraftingStat: (stat: CraftingStatistic, entity: CraftingEntity, condition: CraftingCondition, recipeConditionEffect: RecipeConditionEffect, progress: ProgressState, recipeStats: CraftingRecipeStats) => number;
+        /**
+         * Evaluate a crafting technique condition against current state.
+         * Supports buff counts, pool/perfection/stability/completion/toxicity percentages,
+         * expression conditions, and random chance.
+         * @param condition - The condition to evaluate
+         * @param entity - The crafting entity
+         * @param variables - Current crafting variables
+         * @param selfStacks - Stack count of the technique's own buff
+         * @param progress - Current crafting progress
+         * @param state - Full crafting state
+         * @returns Whether the condition is met
+         */
+        evaluateCraftingCondition: (condition: CraftingTechniqueCondition, entity: CraftingEntity, variables: Record<string, number>, selfStacks: number, progress: ProgressState, state: CraftingState) => boolean;
     };
     hooks: {
         /**

package/dist/reduxState.d.ts

@@ -19,7 +19,6 @@ import { Buff } from './buff';
 import { EventStep, GameEvent, ReportAnalyticsStep, TournamentStep } from './event';
 import { Background } from './background';
 import { Realm } from './realm';
-import { TechniqueElement } from './element';
 export interface Viewport {
     x: number;
     y: number;
@@ -387,7 +386,7 @@ export interface RecipeFilters {
     category: 'all' | ItemKind;
 }
 export interface CharacterUiPreferencesState {
-    techniqueFilter: 'all' | TechniqueElement;
+    techniqueFilter: string;
     recipeFilters: RecipeFilters;
 }
 export interface RootState {

package/dist/stat.js

@@ -166,7 +166,7 @@ export const combatStatToDescription = {
     protection: '',
     dr: '',
     lifesteal: '',
-    critchance: 'Your chance to get a critical effect on damage, healing, and barrier. Crit chance over 100% converts to bonus crit damage at a 1:3 ratio.',
+    critchance: 'Your chance to get a critical effect on damage, healing, and barrier. Crit chance over 100% converts to bonus crit multiplier at a 1:3 ratio.',
     critmultiplier: '',
     vulnerability: '',
     weakness: '',

package/dist/technique.d.ts

@@ -21,6 +21,7 @@ export type StanceRestriction = (typeof stanceRestriction)[number];
 export declare const stanceRestrictionToName: Record<StanceRestriction, string>;
 export interface Technique {
     name: string;
+    displayName?: Translatable;
     icon: string;
     toxicityCost?: number;
     costs?: {
@@ -35,6 +36,10 @@ export interface Technique {
         mode?: 'more' | 'less' | 'equal';
         upgradeKey?: string;
     }[];
+    itemCosts?: {
+        itemName: string;
+        amount: number;
+    }[];
     type: TechniqueElement;
     noneType?: string;
     secondaryType?: TechniqueElement | 'origin';

package/dist/translatable.d.ts

@@ -7,6 +7,7 @@ export interface TranslatableString {
     readonly _translatable: true;
     readonly key: string;
     readonly variables?: Record<string, Translatable | number>;
+    readonly context?: string;
 }
 /**
  * A deferred plural translation object. Stores both singular and plural keys

package/package.json

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