afnm-types 0.6.53 → 0.6.54-3

package/dist/avatarEffects.js

@@ -11,83 +11,83 @@
 // Replicates the hand-authored glitch art style: strong persistent chromatic
 // aberration (cyan/magenta fringing always visible), periodic brightness
 // washout, and horizontal scanline tears during burst events.
-const GLITCH_FRAG_SRC = `#version 300 es
-precision mediump float;
-in vec2 v_uv;
-uniform sampler2D u_texA;
-uniform sampler2D u_texB;
-uniform float u_mix;
-uniform float u_aspectA;
-uniform float u_aspectB;
-uniform float u_canvasAspect;
-uniform float u_time;
-out vec4 fragColor;
-
-float hash(float n) {
-  return fract(sin(n) * 43758.5453);
-}
-
-vec4 sampleContain(sampler2D tex, vec2 uv, float texAspect) {
-  float rel = texAspect / u_canvasAspect;
-  vec2 scale;
-  if (rel > 1.0) {
-    scale = vec2(1.0, 1.0 / rel);
-  } else {
-    scale = vec2(rel, 1.0);
-  }
-  vec2 offset = (1.0 - scale) * 0.5;
-  vec2 mapped = (uv - offset) / scale;
-  if (mapped.x < 0.0 || mapped.x > 1.0 || mapped.y < 0.0 || mapped.y > 1.0) {
-    return vec4(0.0);
-  }
-  return texture(tex, mapped);
-}
-
-void main() {
-  vec2 uv = v_uv;
-
-  // Glitch burst timing — ~0.8 event slots per second, 35% chance each.
-  float eventT = floor(u_time * 0.8);
-  float isGlitching = step(0.65, hash(eventT * 1.618));
-  // Sharp onset, slow decay — the burst lingers before fading.
-  float slotFrac = fract(u_time * 0.8);
-  float decay = (1.0 - smoothstep(0.1, 0.9, slotFrac)) * isGlitching;
-
-  // Band-based horizontal displacement (scanline tearing) during bursts.
-  float band = floor(uv.y * 24.0);
-  float bandActive = step(0.55, hash(band + eventT * 23.7));
-  float bandShift = (hash(band * 5.2 + eventT * 7.1) * 2.0 - 1.0) * 0.025;
-  float shift = bandShift * bandActive * decay;
-
-  // Occasional large block tears.
-  float bigTear = step(0.92, hash(band * 3.7 + eventT * 11.3));
-  shift += (hash(band * 9.1 + eventT * 4.7) * 2.0 - 1.0) * 0.08 * bigTear * decay;
-
-  vec2 shiftedUv = vec2(uv.x + shift, uv.y);
-
-  // Chromatic aberration: strong baseline always present, amplified by bursts.
-  float aberr = 0.012 + 0.018 * decay;
-
-  float rA = sampleContain(u_texA, vec2(shiftedUv.x + aberr, shiftedUv.y), u_aspectA).r;
-  float gA = sampleContain(u_texA, shiftedUv, u_aspectA).g;
-  float bA = sampleContain(u_texA, vec2(shiftedUv.x - aberr, shiftedUv.y), u_aspectA).b;
-  float aA = sampleContain(u_texA, shiftedUv, u_aspectA).a;
-  vec4 colA = vec4(rA, gA, bA, aA);
-
-  float rB = sampleContain(u_texB, vec2(shiftedUv.x + aberr, shiftedUv.y), u_aspectB).r;
-  float gB = sampleContain(u_texB, shiftedUv, u_aspectB).g;
-  float bB = sampleContain(u_texB, vec2(shiftedUv.x - aberr, shiftedUv.y), u_aspectB).b;
-  float aB = sampleContain(u_texB, shiftedUv, u_aspectB).a;
-  vec4 colB = vec4(rB, gB, bB, aB);
-
-  vec4 col = mix(colA, colB, u_mix);
-
-  // Brightness washout during bursts — push toward overexposed white,
-  // scaled by alpha so transparent edges don't bloom.
-  float blowout = decay * 0.45;
-  col.rgb = mix(col.rgb, vec3(1.0), blowout * col.a);
-
-  fragColor = col;
+const GLITCH_FRAG_SRC = `#version 300 es
+precision mediump float;
+in vec2 v_uv;
+uniform sampler2D u_texA;
+uniform sampler2D u_texB;
+uniform float u_mix;
+uniform float u_aspectA;
+uniform float u_aspectB;
+uniform float u_canvasAspect;
+uniform float u_time;
+out vec4 fragColor;
+
+float hash(float n) {
+  return fract(sin(n) * 43758.5453);
+}
+
+vec4 sampleContain(sampler2D tex, vec2 uv, float texAspect) {
+  float rel = texAspect / u_canvasAspect;
+  vec2 scale;
+  if (rel > 1.0) {
+    scale = vec2(1.0, 1.0 / rel);
+  } else {
+    scale = vec2(rel, 1.0);
+  }
+  vec2 offset = (1.0 - scale) * 0.5;
+  vec2 mapped = (uv - offset) / scale;
+  if (mapped.x < 0.0 || mapped.x > 1.0 || mapped.y < 0.0 || mapped.y > 1.0) {
+    return vec4(0.0);
+  }
+  return texture(tex, mapped);
+}
+
+void main() {
+  vec2 uv = v_uv;
+
+  // Glitch burst timing — ~0.8 event slots per second, 35% chance each.
+  float eventT = floor(u_time * 0.8);
+  float isGlitching = step(0.65, hash(eventT * 1.618));
+  // Sharp onset, slow decay — the burst lingers before fading.
+  float slotFrac = fract(u_time * 0.8);
+  float decay = (1.0 - smoothstep(0.1, 0.9, slotFrac)) * isGlitching;
+
+  // Band-based horizontal displacement (scanline tearing) during bursts.
+  float band = floor(uv.y * 24.0);
+  float bandActive = step(0.55, hash(band + eventT * 23.7));
+  float bandShift = (hash(band * 5.2 + eventT * 7.1) * 2.0 - 1.0) * 0.025;
+  float shift = bandShift * bandActive * decay;
+
+  // Occasional large block tears.
+  float bigTear = step(0.92, hash(band * 3.7 + eventT * 11.3));
+  shift += (hash(band * 9.1 + eventT * 4.7) * 2.0 - 1.0) * 0.08 * bigTear * decay;
+
+  vec2 shiftedUv = vec2(uv.x + shift, uv.y);
+
+  // Chromatic aberration: strong baseline always present, amplified by bursts.
+  float aberr = 0.012 + 0.018 * decay;
+
+  float rA = sampleContain(u_texA, vec2(shiftedUv.x + aberr, shiftedUv.y), u_aspectA).r;
+  float gA = sampleContain(u_texA, shiftedUv, u_aspectA).g;
+  float bA = sampleContain(u_texA, vec2(shiftedUv.x - aberr, shiftedUv.y), u_aspectA).b;
+  float aA = sampleContain(u_texA, shiftedUv, u_aspectA).a;
+  vec4 colA = vec4(rA, gA, bA, aA);
+
+  float rB = sampleContain(u_texB, vec2(shiftedUv.x + aberr, shiftedUv.y), u_aspectB).r;
+  float gB = sampleContain(u_texB, shiftedUv, u_aspectB).g;
+  float bB = sampleContain(u_texB, vec2(shiftedUv.x - aberr, shiftedUv.y), u_aspectB).b;
+  float aB = sampleContain(u_texB, shiftedUv, u_aspectB).a;
+  vec4 colB = vec4(rB, gB, bB, aB);
+
+  vec4 col = mix(colA, colB, u_mix);
+
+  // Brightness washout during bursts — push toward overexposed white,
+  // scaled by alpha so transparent edges don't bloom.
+  float blowout = decay * 0.45;
+  col.rgb = mix(col.rgb, vec3(1.0), blowout * col.a);
+
+  fragColor = col;
 }`;
 // ─── Registry ─────────────────────────────────────────────────────────────────
 /**

package/dist/buff.d.ts

@@ -4,6 +4,7 @@ import type { CombatStatistic, Scaling } from './stat';
 import type { DamageType } from './DamageType';
 import type { CombatEntity } from './entity';
 import { AvatarEffectId } from './avatarEffects';
+import type { EffectTargeting } from './technique';
 export type TechniqueCondition = ChanceTechniqueCondition | BuffTechniqueCondition | HpTechniqueCondition | ConditionTechniqueCondition | InventoryItemTechniqueCondition;
 interface BaseTechniqueCondition {
     /**
@@ -110,6 +111,7 @@ export interface Buff {
         trigger?: TechniqueCondition;
         damageModifier: DamageModifier;
         effects?: BuffEffect[];
+        afterBarrier?: boolean;
     }[];
     /** Amplifies outgoing damage/barrier/heal effects. Runs before the effect is applied. */
     techniqueAmplifierEffects?: {
@@ -339,11 +341,13 @@ interface HealEffect extends BaseBuff {
     kind: 'heal';
     amount: Scaling;
     hits?: Scaling;
+    targeting?: EffectTargeting;
 }
 interface BarrierEffect extends BaseBuff {
     kind: 'barrier';
     amount: Scaling;
     hits?: Scaling;
+    targeting?: EffectTargeting;
 }
 interface CreateBuffSelfEffect extends BaseBuff {
     kind: 'buffSelf';
@@ -351,6 +355,7 @@ interface CreateBuffSelfEffect extends BaseBuff {
     buff: Buff;
     silent?: boolean;
     hideBuff?: boolean;
+    targeting?: EffectTargeting;
 }
 interface ConsumeBuffSelfEffect extends BaseBuff {
     kind: 'consumeSelf';
@@ -424,6 +429,7 @@ interface RepairEffect extends BaseBuff {
     group: string;
     /** Which matching buff(s) to repair: 'all', 'lowestHealth', or 'highestHealth' */
     rule: RepairRule;
+    targeting?: EffectTargeting;
 }
 interface ConsumeInventoryItemEffect extends BaseBuff {
     kind: 'consumeInventoryItem';

package/dist/event.d.ts

@@ -86,7 +86,7 @@ export interface ChoiceStepChoice {
     hideIfDisabled?: boolean;
     children: EventStep[];
 }
-export type EventChoiceCondition = RealmCondition | PhysicalStatisticCondition | SocialStatisticCondition | ItemCondition | BuffCondition | MoneyCondition | FavourCondition | MultiCondition | AffinityCondition | QiCondition | ReputationCondition | HealthCondition | InjuredCondition;
+export type EventChoiceCondition = RealmCondition | PhysicalStatisticCondition | SocialStatisticCondition | ItemCondition | BuffCondition | MoneyCondition | FavourCondition | MultiCondition | AffinityCondition | QiCondition | ReputationCondition | HealthCondition | InjuredCondition | SexualityCondition;
 export interface RealmCondition {
     kind: 'realm';
     realm: Realm;
@@ -106,6 +106,10 @@ interface InjuredCondition {
     kind: 'injured';
     injured: boolean;
 }
+interface SexualityCondition {
+    kind: 'sexuality';
+    targetSex: 'male' | 'female';
+}
 interface SocialStatisticCondition {
     kind: 'socialStatistic';
     stat: SocialStatistic;

package/dist/gameVersion.d.ts

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

package/dist/gameVersion.js

@@ -15,4 +15,4 @@
  *   };
  * }
  */
-export const GAME_VERSION = "0.6.53";
+export const GAME_VERSION = "0.6.54";

package/dist/item.d.ts

@@ -7,12 +7,12 @@ import type { TechniqueElement } from './element';
 import type { EnemyEntity, StoredRule } from './entity';
 import type { Room } from './house';
 import type { RegionContentType } from './mysticalRegion';
-import type { AbsorberConfig } from './soulShardDelve';
 import type { Rarity } from './rarity';
 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';
 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: {
@@ -456,14 +456,7 @@ export interface PillarShardItem extends ItemBase {
     kind: 'pillar_shard';
     tooltip: Translatable;
     maxInstances?: number;
-    /**
-     * Shard subtype. 'soul' shards are used in soul shard delves — they have routing
-     * and a room type but no combat/crafting effects. Omit for normal pillar shards.
-     */
-    shardSubtype?: 'soul';
-    /** Absorber config for soul shard delves. Hardcoded on soul shards; generated
-     *  from the shard name hash for pillar shards when absent. */
-    absorberConfig?: AbsorberConfig;
+    delveRoomConfig?: DelveRoom;
     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,14 +1,14 @@
 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' | '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' | '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;
+    action: KeybindingAction | string;
     category: KeybindingCategory;
     displayName: string;
     description: string;
     defaultKey: string;
     allowRebind: boolean;
 }
-export type KeybindingsMap = Record<KeybindingAction, string>;
+export type KeybindingsMap = Record<KeybindingAction | string, string>;
 export declare const keybindingDefinitions: KeybindingDefinition[];
 export declare const keybindingCategoryInfo: Record<KeybindingCategory, {
     name: string;

package/dist/keybindings.js

@@ -237,6 +237,14 @@ export const keybindingDefinitions = [
         defaultKey: 's',
         allowRebind: true,
     },
+    {
+        action: 'combatCancel',
+        category: 'combat',
+        displayName: 'Cancel Auto Battle / Open Settings',
+        description: 'Cancel auto battle or open settings menu',
+        defaultKey: 'Escape',
+        allowRebind: true,
+    },
     // Crafting Actions (Number keys 1-9, then 0)
     {
         action: 'craftingAction1',

package/dist/manual.d.ts

@@ -0,0 +1,8 @@
+import { Realm } from './realm';
+export interface Manual {
+    name: string;
+    icon: string;
+    realm: Realm;
+    techniques: string[];
+    stance: string[];
+}

package/dist/manual.js

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

package/dist/mod.d.ts

@@ -49,6 +49,43 @@ import type { Translatable, TranslatableString } from './translatable';
 import type { SaveFileInfo } from './electron';
 import type { KeybindingDefinition } from './keybindings';
 import { ScreenType } from './GameScreen';
+export type SkipDialogueMode = 'flash' | 'silent';
+export type Sexuality = 'straight' | 'gay' | 'bisexual';
+export interface GameSettingsProps {
+    enableStancePreview: boolean;
+    setEnableStancePreview: (value: boolean) => void;
+    removeCombatNumbers: boolean;
+    setRemoveCombatNumbers: (value: boolean) => void;
+    fastRewardAnimations: boolean;
+    setFastRewardAnimations: (value: boolean) => void;
+    showCraftingRawNumbers: boolean;
+    setShowCraftingRawNumbers: (value: boolean) => void;
+    skipSeenDialogue: boolean;
+    setSkipSeenDialogue: (value: boolean) => void;
+    skipDialogueMode: SkipDialogueMode;
+    setSkipDialogueMode: (value: SkipDialogueMode) => void;
+    hideEmptySlotWarnings: boolean;
+    setHideEmptySlotWarnings: (value: boolean) => void;
+    pauseAutoBattleOnLowHealth: boolean;
+    setPauseAutoBattleOnLowHealth: (value: boolean) => void;
+    sexuality: Sexuality;
+    setSexuality: (value: Sexuality) => void;
+    eventHistoryLimit: number;
+    setEventHistoryLimit: (value: number) => void;
+}
+export type InjectPosition = 'inside' | 'before' | 'after';
+export interface NewGameIntent {
+    items: ItemDesc[];
+    techniques: string[];
+    recipes: string[];
+    destinies: string[];
+    quests: string[];
+    money: number;
+    favour: number;
+    flags: Record<string, number>;
+    player: PlayerEntity;
+    craftingActions: string[];
+}
 /**
  * Sprite images for a custom player character.
  * All images should be strings (either mod:// URLs for mod assets, or data: URLs).
@@ -131,9 +168,10 @@ export interface ModReduxAPI {
     usePlaySfx: () => (name: SoundEffectName) => void;
     /**
      * Hook to register keyboard shortcuts
-     * @param priority - Higher numbers take precedence (0-100 typical)
+     * @param priority - Higher numbers fully override lower numbers. Use 0 unless you have a specific reason to override other mods or base game keybindings.
      * @param binding - Map of key names to callback functions
      * @param disableSpaceOverride - If true, spacebar won't be overridden to map to Enter
+     * @param keyContext - Optional context string to group related keybindings (e.g. 'inventory', 'combat')
      * @example
      * useKeybinding(10, {
      *   'Escape': () => closeDialog(),
@@ -141,7 +179,16 @@ export interface ModReduxAPI {
      *   'i': () => openInventory()
      * });
      */
-    useKeybinding: (priority: number, binding: Record<string, () => void> | undefined, disableSpaceOverride?: boolean) => void;
+    useKeybinding: (priority: number, binding: Record<string, () => void> | undefined, disableSpaceOverride?: boolean, keyContext?: string) => void;
+    /**
+     * Hook to access game settings/preferences.
+     * These are player-configured preferences like sexuality, combat display options, etc.
+     * @returns Object containing game settings and their setters
+     * @example
+     * const settings = useGameSettings();
+     * if (settings.sexuality === 'gay') { // Handle same-sex scenes }
+     */
+    useGameSettings: () => GameSettingsProps;
     actions: {
         /**
          * Navigate to a different game screen.
@@ -1061,6 +1108,21 @@ export interface ModAPI {
          * });
          */
         registerKeybinding: (definition: KeybindingDefinition) => void;
+        /**
+         * Trigger a UI refresh/reset across the entire game.
+         * This causes all components wrapped in UIRefreshWrapper (including the combat screen,
+         * dual cultivation screen, and other screen components) to unmount and remount,
+         * forcing them to re-read their state and re-render fresh.
+         *
+         * Use this when your mod has modified game state that requires UI components
+         * to fully re-render, such as after batch updates to Redux state or when
+         * replacing content that mods might have extended.
+         *
+         * @example
+         * // After making changes that require a full UI refresh
+         * api.actions.triggerUIReset();
+         */
+        triggerUIReset: () => void;
     };
     utils: {
         /**
@@ -1995,6 +2057,24 @@ export interface ModAPI {
          * const screen = determineCurrentScreen(store.getState());
          */
         determineCurrentScreen: (rootState: RootState) => ScreenType;
+        /**
+         * Get the current keybind value for a registered keybinding action.
+         * Use this to check what key is currently bound to an action, useful for
+         * displaying key hints in custom UI or handling key events outside React components.
+         * @param action - The action name (e.g., 'myMod.specialAction')
+         * @returns The current bound key string (e.g., 'F12'), or undefined if not bound
+         * @example
+         * const key = modAPI.utils.getRegisteredKeybindValue('myMod.specialAction');
+         * if (key) {
+         *   console.log(`Special action is bound to ${key}`);
+         * }
+         */
+        getRegisteredKeybindValue: (action: string) => string | undefined;
+        /**
+         *
+         * @returns true if a save is currently loaded and game state is available, false otherwise.
+         */
+        getHasSaveLoaded: () => boolean;
     };
     hooks: {
         /**
@@ -2062,6 +2142,26 @@ export interface ModAPI {
          * });
          */
         onDeriveRecipeDifficulty: (interceptor: (recipe: RecipeItem, recipeStats: CraftingRecipeStats, gameFlags: Record<string, number>) => CraftingRecipeStats) => void;
+        /**
+         * Hook to modify recipe ingredients before crafting calculations.
+         * This runs before onDeriveRecipeDifficulty and allows mods to change
+         * the items or amounts used in a recipe.
+         * @param interceptor - Function to modify the recipe
+         * @example
+         * onModifyRecipeIngredients((recipe, flags) => {
+         *   if (flags.efficient_crafting) {
+         *     // Reduce all ingredient counts by 50%
+         *     const modified = { ...recipe };
+         *     modified.ingredients = recipe.ingredients.map(ing => ({
+         *       ...ing,
+         *       count: Math.max(1, Math.floor(ing.count * 0.5))
+         *     }));
+         *     return modified;
+         *   }
+         *   return recipe;
+         * });
+         */
+        onModifyRecipeIngredients: (interceptor: (recipe: RecipeItem, gameFlags: Record<string, number>) => RecipeItem) => void;
         /**
          * Hook to add events after combat completion.
          * @param interceptor - Function returning additional event steps
@@ -2267,34 +2367,98 @@ export interface ModAPI {
          *   return payload;
          * });
          */
-        onReduxActionPayload: (interceptor: (actionType: string, payload: unknown) => unknown | null) => void;
+        onReduxActionPayload: (interceptor: (actionType: string, payload: unknown, stateBefore: RootState) => unknown | null) => void;
+        /**
+         * Called before the equipment upgrade dialog is shown. Allows mutating upgrade cost items and result (but not base item).
+         *
+         * @example
+         * modAPI.hooks.onDeriveEquipmentUpgradeRequirement((baseItem, costItems, resultItem, flags) => {
+         *   // Modify the cost items (e.g., add additional requirements)
+         *   return { costItems: [...costItems, additionalItem], resultItem };
+         * });
+         */
+        onDeriveEquipmentUpgradeRequirement: (interceptor: (baseItem: Item, costItems: Item[], resultItem: Item, gameFlags: Record<string, number>) => {
+            costItems?: Item[];
+            resultItem?: Item;
+        } | undefined) => void;
+        /**
+         * Called before the completion dialog showing the upgraded equipment. Allows mutating upgrade cost items and result (but not base item).
+         *
+         * @example
+         * modAPI.hooks.onCompleteEquipmentUpgrade((baseItem, costItems, resultItem, flags) => {
+         *   // Boost the result item's stats
+         *   return { costItems, resultItem: { ...resultItem, damage: (resultItem.damage ?? 0) + 10 } };
+         * });
+         */
+        onCompleteEquipmentUpgrade: (interceptor: (baseItem: Item, costItems: Item[], resultItem: Item, gameFlags: Record<string, number>) => {
+            costItems?: Item[];
+            resultItem?: Item;
+        } | undefined) => void;
+        /**
+         * Called before the equipment reforge dialog is shown. Allows mutating reforge cost items and result (but not base item).
+         *
+         * @example
+         * modAPI.hooks.onDeriveEquipmentReforgeRequirement((baseItem, costItems, resultItem, flags) => {
+         *   // Modify the result item
+         *   return { costItems, resultItem: { ...resultItem, qualityTier: (resultItem.qualityTier ?? 0) + 1 } };
+         * });
+         */
+        onDeriveEquipmentReforgeRequirement: (interceptor: (baseItem: Item, costItems: Item[], resultItem: Item, gameFlags: Record<string, number>) => {
+            costItems?: Item[];
+            resultItem?: Item;
+        } | undefined) => void;
+        /**
+         * Called before the completion dialog showing the reforged equipment. Allows mutating reforge cost items and result (but not base item).
+         *
+         * @example
+         * modAPI.hooks.onCompleteEquipmentReforge((baseItem, costItems, resultItem, flags) => {
+         *   // Boost the result item's stats
+         *   return { costItems, resultItem: { ...resultItem, damage: (resultItem.damage ?? 0) + 5 } };
+         * });
+         */
+        onCompleteEquipmentReforge: (interceptor: (baseItem: Item, costItems: Item[], resultItem: Item, gameFlags: Record<string, number>) => {
+            costItems?: Item[];
+            resultItem?: Item;
+        } | undefined) => void;
+        /**
+         * Intercept the full set of changes planned for a new game before they are applied.
+         * Return a modified intent to change starting items, techniques, flags, etc.
+         * @param interceptor - Receives the full intent and returns a modified copy
+         * @example
+         * modAPI.hooks.onNewGame((intent) => ({
+         *   ...intent,
+         *   flags: { ...intent.flags, my_mod_enabled: 1 },
+         * }));
+         */
+        onNewGame: (interceptor: (intent: NewGameIntent) => NewGameIntent) => void;
     };
     /**
      * Inject UI into a named slot (dialog title or screen name).
      *
-     * The generator receives `(api, element, inject)`:
-     * - `api` — full `ModReduxAPI` with game state, actions, and components
-     * - `element` — root DOM element of the slot; use `querySelector` to find children
-     * - `inject(selector, content, mode?)` — helper to portal `content` into the element
-     *   matched by `selector`. `mode` is `'overlay'` (default, floats over) or `'inline'`
+     * The generator receives (api, element, inject):
+     * - api: full ModReduxAPI with game state, actions, and components
+     * - element: root DOM element of the slot; use querySelector to find children
+     * - inject(selector, content, mode?, position?): helper to portal content into the element
+     *   matched by selector. mode is 'overlay' (default, floats over) or 'inline'
      *   (inserts as a sibling after the target, flowing with the layout).
+     *   position controls where content is placed (see InjectPosition enum).
      *
-     * Slot names for dialogs are the id (e.g. `'combat-victory'`). You can find these by inspecting the DOM in dev mode.
-     * Slot names for screens match the `ScreenType` value (e.g. `'combat'`).
+     * Slot names for dialogs are the id (e.g. 'combat-victory'). You can find these by inspecting the DOM in dev mode.
+     * Slot names for screens match the ScreenType value (e.g. 'combat').
      *
      * @example
-     * // Add a "Absorb Qi" button into the main body of the combat victory dialog.
-     * // The victory dialog's main content area has aria-live="assertive".
+     * // Add a button to combat victory dialog
      * modAPI.ui.injectUI('combat-victory', (api, element, inject) => {
      *   return inject('[aria-live="assertive"]',
      *     <api.components.GameButton onClick={() => api.actions.changeQi(100)}>
      *       Absorb Qi
      *     </api.components.GameButton>,
-     *     'inline'
+     *     'inline',
+     *     InjectPosition.After
      *   );
      * });
      */
-    injectUI: (slotName: string, generator: (api: ModReduxAPI, element: HTMLElement | null, inject: (selector: string, content: React.ReactNode, mode?: 'overlay' | 'inline') => React.ReactNode) => React.ReactNode) => void;
+    injectUI: (slotName: string, generator: (api: ModReduxAPI, element: HTMLElement | null, inject: (selector: string, content: React.ReactNode, mode?: 'overlay' | 'inline', position?: InjectPosition) => React.ReactNode) => React.ReactNode) => void;
     /**
      * Subscribe to any Redux state changes. The callback receives the new state.
      * Returns an unsubscribe function.
@@ -2319,3 +2483,6 @@ export interface ModAPI {
      */
     getGameStateSnapshot: () => RootState | null;
 }
+export type ModHooks = {
+    [K in keyof ModAPI['hooks']]: Parameters<ModAPI['hooks'][K]>[0][];
+};

package/dist/reforge.d.ts

@@ -2,8 +2,10 @@ import type { Item } from './item';
 export interface UpgradeUtil {
     item: Item;
     upgrade: Item;
+    costItems: Item[];
 }
 export interface PotentialUtil {
     item: Item;
     potentialUnlocked: Item;
+    costItems: Item[];
 }

package/dist/soulShardDelve.d.ts

@@ -3,6 +3,8 @@ import type { ItemDesc, RegionMonsters } from './item';
 import type { Rarity } from './rarity';
 import type { Beam } from './pillarGrid';
 import { Translatable } from './translatable';
+import { Blessing, EnemyEntity } from '.';
+import Prando from 'prando';
 export interface PlacedShardEntry {
     shardName: string;
     x: number;
@@ -19,8 +21,40 @@ export interface GridSimulationResult {
         power?: number;
     }[];
 }
-/** Room types for placed shard encounters. Fixed per shard (deterministic from name). */
-export type DelveRoomType = 'directReward' | 'cursedReward' | 'tradeReward' | 'figment' | 'eliteCombat' | 'augmentedElite' | 'hordeCombat' | 'resurrect' | 'reinforcement' | 'penalty' | 'dual' | 'trio' | 'blessingSelect' | 'coreBlessing';
+export type DelveRoomStageKind = 'combat' | 'blessing' | 'curse' | 'reward' | 'event';
+interface BaseDelveRoomStage {
+    kind: DelveRoomStageKind;
+}
+export interface CombatStage extends BaseDelveRoomStage {
+    kind: 'combat';
+    buildEnemies: (monsters: RegionMonsters, difficultyMult: number, rng: Prando) => EnemyEntity[];
+}
+export interface BlessingStage extends BaseDelveRoomStage {
+    kind: 'blessing';
+    blessingPool: Blessing[];
+    count: number;
+}
+export interface CurseStage extends BaseDelveRoomStage {
+    kind: 'curse';
+    cursePool: Blessing[];
+    count: number;
+}
+export interface RewardStage extends BaseDelveRoomStage {
+    kind: 'reward';
+    rewardPool: string;
+    increasedRarity: boolean;
+}
+export interface EventStage extends BaseDelveRoomStage {
+    kind: 'event';
+    event: GameEvent;
+}
+export type DelveRoomStage = CombatStage | BlessingStage | CurseStage | RewardStage | EventStage;
+export interface DelveRoom {
+    name: string;
+    displayName?: Translatable;
+    description: string;
+    stages: DelveRoomStage[];
+}
 /** A pre-placed cell in the soul shard grid (source, fixed node, or fixed routing shard). */
 export interface FixedGridCell {
     inputs?: {
@@ -40,114 +74,17 @@ export interface FixedGridCell {
     isNode?: boolean;
     icon: string;
     isSource: boolean;
-    /** Minimum power to activate this node's bonus room (optional). */
+    /** Minimum qither through this node to add a one-time reward to the run. */
     nodeRoomThreshold?: number;
 }
-/** A reward slot earned from a room — the specific item is rolled when the remnant is opened. */
-export interface VictoryReward {
-    rarity: Rarity;
-}
-/** Direct reward — no combat. Adds a deferred chest to end rewards. */
-export interface DirectRewardContent {
-    kind: 'directReward';
-    reward: VictoryReward;
-}
-/** Cursed reward — gain reward immediately + a persistent curse for the rest of the delve. */
-export interface CursedRewardContent {
-    kind: 'cursedReward';
-    reward: VictoryReward;
-    curse: {
-        buffName: string;
-        buffStacks: number;
-    };
-}
-/** Trade reward — sacrifice a spirit core for a powerful reward. */
-export interface TradeRewardContent {
-    kind: 'tradeReward';
-    coreName: string;
-    reward: VictoryReward;
-}
-/** Figment — fight 3–4 normal enemies as a single party. Normal combat. */
-export interface FigmentContent {
-    kind: 'figment';
-    enemyTier: number;
-    enemyCount: number;
-    victoryReward: VictoryReward;
-}
-/** Elite combat — fight 1 elite. Normal combat. */
-export interface EliteCombatContent {
-    kind: 'eliteCombat';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Augmented elite — fight 1 elite + 1 normal as party. Normal combat. */
-export interface AugmentedEliteContent {
-    kind: 'augmentedElite';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Horde combat — fight 2 normals + 1 elite as back-to-back sequential enemies. Normal combat. */
-export interface HordeCombatContent {
-    kind: 'hordeCombat';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Resurrect — fight 1 elite + 1 normal as party; either resurrects if not killed within 2 rounds. Hard combat. */
-export interface ResurrectContent {
-    kind: 'resurrect';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Reinforcement — fight 1 elite with 1 normal summoned every 6 rounds (up to 4 party members). Hard combat. */
-export interface ReinforcementContent {
-    kind: 'reinforcement';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Penalty — any normal combat, but also applies a dangerous curse for the fight. Hard combat. */
-export interface PenaltyContent {
-    kind: 'penalty';
-    enemyTier: number;
-    playerCurse: {
-        buffName: string;
-        buffStacks: number;
-    };
-    victoryReward: VictoryReward;
-}
-/** Dual — fight 2 elites as a party. Hard combat. */
-export interface DualContent {
-    kind: 'dual';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Trio — fight 3 elites back to back (sequential). Hard combat. */
-export interface TrioContent {
-    kind: 'trio';
-    enemyTier: number;
-    victoryReward: VictoryReward;
-}
-/** Blessing select — choose 1 of 3 blessings drawn from the shard's themed pool. */
-export interface BlessingSelectContent {
-    kind: 'blessingSelect';
-    options: {
-        buffName: string;
-        buffStacks: number;
-    }[];
-}
-/** Core blessing — trade a spirit core for 1 of 3 powerful blessings. */
-export interface CoreBlessingContent {
-    kind: 'coreBlessing';
-    coreName: string;
-    options: {
-        buffName: string;
-        buffStacks: number;
-    }[];
-}
-export type DelveRoomContent = DirectRewardContent | CursedRewardContent | TradeRewardContent | FigmentContent | EliteCombatContent | AugmentedEliteContent | HordeCombatContent | ResurrectContent | ReinforcementContent | PenaltyContent | DualContent | TrioContent | BlessingSelectContent | CoreBlessingContent;
 export interface DelveDropPool {
     id: string;
     displayName: Translatable;
-    items: ItemDesc[];
+    items: {
+        name: string;
+        stacks: number;
+        rarity: Rarity;
+    }[];
 }
 /** A remnant accumulated during the delve. Item is rolled from pool when opened. */
 export interface PendingReward {
@@ -155,50 +92,22 @@ export interface PendingReward {
     /** Which loot pool to draw from when the remnant is opened. */
     pool: string;
 }
-export type BlessingRoomType = 'blessingSelect' | 'coreBlessing';
-export type RewardRoomType = Exclude<DelveRoomType, BlessingRoomType>;
-/** Absorber config for reward/combat rooms — always has a reward pool. */
-export interface RewardAbsorberConfig {
-    roomType: RewardRoomType;
-    rewardPoolId: string;
-    cursePool?: string[];
-    fightCursePool?: string[];
-}
-/** Absorber config for blessing rooms — has a blessing pool, no reward pool. */
-export interface BlessingAbsorberConfig {
-    roomType: BlessingRoomType;
-    blessingPool?: string[];
-}
-export type AbsorberConfig = RewardAbsorberConfig | BlessingAbsorberConfig;
-export interface DelveRoomDef {
-    label: string;
-    desc: string;
-    /** Rarity offset relative to the shard's base tier (-1, 0, +1). */
-    tierOffset: -1 | 0 | 1;
-}
-export declare const DELVE_ROOM_DEFS: Record<DelveRoomType, DelveRoomDef>;
 /** Static config for a soul shard delve location. */
 export interface SoulShardDelveConfig {
     key: string;
-    displayName: string;
-    description: string;
-    icon: string;
-    background: string;
-    /** The overall tier of this shard — determines base reward rarity. */
-    tier: Rarity;
+    location: string;
     /** Events played when each threshold is crossed, in order. Length determines total threshold count. */
-    thresholdEvents: (GameEvent | undefined)[];
-    essenceTypes: [string, string];
-    /** Cooldown in calendar days after a completed run. */
-    cooldownDays: number;
+    thresholdEvents: GameEvent[];
+    /** One-time item rewards granted when accumulatedQither reaches each intensity level. */
+    intensityRewards: {
+        intensity: number;
+        reward: ItemDesc;
+    }[];
     /** Source power regeneration rate: 1 qither per this many months. Default 6. */
     rechargeMonths: number;
-    music?: string;
-    /** Enemy pools — mob, elite, boss — same as mystical regions. */
     monsters: RegionMonsters;
-    /** Spirit core item name required for tradeReward and coreBlessing rooms. */
-    coreName: string;
-    /** Loot pools by category. */
+    /** The boss room fought after all vestige rooms are cleared. */
+    boss: DelveRoom;
     customDropPool: DelveDropPool;
 }
 /** Persistent placed shard entry (survives between sessions). */
@@ -221,39 +130,38 @@ export interface SoulShardProgression {
     sourcePower: number;
     /** Months elapsed toward next recharge tick. */
     rechargeProgress: number;
+    /** How many intensityRewards have already been granted. */
+    claimedIntensityRewards: number;
 }
 /** Current run state stored in Redux. */
 export interface SoulShardDelveRunState {
     shards: string[];
     currentRoomIndex: number;
+    currentStageIndex: number;
     failedRun: boolean;
     progressQither: number;
     difficultyMultiplier: number;
-    /** Player blessings gained during the delve (shown in bottom bar). */
-    playerBuffs: {
-        buffName: string;
-        stacks: number;
-    }[];
-    /** Persistent curses gained from cursedReward rooms (applied to player in every subsequent fight). */
-    delveCurses: {
-        buffName: string;
-        stacks: number;
-    }[];
-    /** Rewards accumulated during the run, revealed as chests at the end. */
-    pendingRewards: PendingReward[];
+    blessings: string[];
+    curses: string[];
+    rewards: PendingReward[];
+    openedRewards: boolean[];
 }
 export interface SoulShardDelveState {
     /** Which soul shard config is currently selected (screen is open). */
     delveKey?: string;
     currentRun?: SoulShardDelveRunState;
-    /** delveKey -> calendar day the cooldown expires */
-    cooldowns: Record<string, number>;
     /** delveKey -> persistent progression data */
     progression: Record<string, SoulShardProgression>;
 }
-/** Cumulative qither required to reach threshold n (1-indexed). Scales quadratically. */
+/** Cumulative qither required to reach threshold n (1-indexed).
+ *  Based on ~2 perfect runs per threshold, where a perfect run = 3 + gridSize.
+ *  Grid starts at ~60 cells and grows by ~15 per threshold, so run(t) = 63 + t*15.
+ *  Cumulative: sum of 2*(63 + t*15) for t=0..n-1 = n*(111 + 15n).
+ *  Gives: 126, 282, 468, 684, 930, ...
+ */
 export declare function getThresholdQither(n: number): number;
 /** Enemy difficulty multiplier from total qither used to activate all absorbers.
  *  +2% HP and power per 1 qither.
  */
 export declare function getQitherDifficulty(totalQither: number): number;
+export {};

package/dist/soulShardDelve.js

@@ -1,79 +1,11 @@
-export const DELVE_ROOM_DEFS = {
-    directReward: {
-        label: 'Offering',
-        desc: 'A remnant added to the Figment encounter, claimed on victory',
-        tierOffset: -1,
-    },
-    cursedReward: {
-        label: 'Cursed Offering',
-        desc: 'Gain a remnant immediately, but carry a curse for the rest of the delve',
-        tierOffset: 0,
-    },
-    tradeReward: {
-        label: 'Bargain',
-        desc: 'Trade a spirit core to gain a remnant',
-        tierOffset: 0,
-    },
-    figment: {
-        label: 'Figment',
-        desc: 'Fight three to four shades at once to gain a remnant',
-        tierOffset: 0,
-    },
-    eliteCombat: {
-        label: 'Keeper',
-        desc: 'Defeat an aspect to gain a remnant',
-        tierOffset: 0,
-    },
-    augmentedElite: {
-        label: "Keeper's Shadow",
-        desc: 'Defeat an aspect with a shade at its side to gain a remnant',
-        tierOffset: 0,
-    },
-    hordeCombat: {
-        label: 'Surge',
-        desc: 'Fight two shades then an aspect in sequence to gain a remnant',
-        tierOffset: 0,
-    },
-    resurrect: {
-        label: 'Tethered',
-        desc: 'Fight an aspect and a shade; either will revive the other if not killed together',
-        tierOffset: 1,
-    },
-    reinforcement: {
-        label: 'Summoner',
-        desc: 'Fight an aspect while it calls in shades every six rounds',
-        tierOffset: 1,
-    },
-    penalty: {
-        label: 'Marked',
-        desc: 'Fight while carrying a dangerous curse to gain a remnant',
-        tierOffset: 1,
-    },
-    dual: {
-        label: 'Twin Keepers',
-        desc: 'Fight two aspects at once to gain a remnant',
-        tierOffset: 1,
-    },
-    trio: {
-        label: 'Triad',
-        desc: 'Fight three aspects in sequence to gain a remnant',
-        tierOffset: 1,
-    },
-    blessingSelect: {
-        label: 'Attunement',
-        desc: "Choose one blessing from three drawn from the shard's pool",
-        tierOffset: 0,
-    },
-    coreBlessing: {
-        label: 'Deep Attunement',
-        desc: 'Trade a spirit core for one of three powerful blessings',
-        tierOffset: 0,
-    },
-};
-/** Cumulative qither required to reach threshold n (1-indexed). Scales quadratically. */
+/** Cumulative qither required to reach threshold n (1-indexed).
+ *  Based on ~2 perfect runs per threshold, where a perfect run = 3 + gridSize.
+ *  Grid starts at ~60 cells and grows by ~15 per threshold, so run(t) = 63 + t*15.
+ *  Cumulative: sum of 2*(63 + t*15) for t=0..n-1 = n*(111 + 15n).
+ *  Gives: 126, 282, 468, 684, 930, ...
+ */
 export function getThresholdQither(n) {
-    // 10, 30, 60, 100, 150, 210, ...  →  n * (n + 1) * 5
-    return n * (n + 1) * 5;
+    return n * (111 + 15 * n);
 }
 /** Enemy difficulty multiplier from total qither used to activate all absorbers.
  *  +2% HP and power per 1 qither.

package/dist/technique.d.ts

@@ -71,12 +71,14 @@ interface BaseTechniqueEffect {
     isAdditionalTooltip?: boolean;
     cantUpgrade?: boolean;
 }
+export type EffectTargeting = 'self' | 'party' | 'all';
 interface BuffSelfTechniqueEffect extends BaseTechniqueEffect {
     kind: 'buffSelf';
     buff: Buff;
     amount: Scaling;
     hits?: Scaling;
     hideBuff?: boolean;
+    targeting?: EffectTargeting;
 }
 interface ConsumeSelfTechniqueEffect extends BaseTechniqueEffect {
     kind: 'consumeSelf';
@@ -125,11 +127,13 @@ interface BarrierTechniqueEffect extends BaseTechniqueEffect {
     kind: 'barrier';
     amount: Scaling;
     hits?: Scaling;
+    targeting?: EffectTargeting;
 }
 interface HealTechniqueEffect extends BaseTechniqueEffect {
     kind: 'heal';
     amount: Scaling;
     hits?: Scaling;
+    targeting?: EffectTargeting;
 }
 interface CleanseToxicityTechniqueEffect extends BaseTechniqueEffect {
     kind: 'cleanseToxicity';
@@ -154,6 +158,7 @@ interface RepairTechniqueEffect extends BaseTechniqueEffect {
     group: string;
     /** Which matching buff(s) to repair: 'all', 'lowestHealth', or 'highestHealth' */
     rule: RepairRule;
+    targeting?: EffectTargeting;
 }
 export interface PermanentStatChangeTechniqueEffect extends BaseTechniqueEffect {
     kind: 'permanentStatChange';

package/dist/typeTests.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type Tests - These files ensure type compatibility across the codebase
+ * If any of these fail to compile, it means we have a type mismatch
+ */
+import type { RootState as StoreRootState } from '../store';
+import type { RootState as TypesRootState } from './reduxState';
+type TestExactMatch = StoreRootState extends TypesRootState ? TypesRootState extends StoreRootState ? true : false : false;
+export type RootStateIsConsistent = TestExactMatch;
+export {};

package/package.json

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