azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/spells/interpreter/registry/packs/ex-wave-m.ts

@@ -0,0 +1,70 @@
+// The ex-Wave-M families: Feign Death, the hunter traps and the possess and charm fixtures. This pack
+// owns the sourced gameobject notes for the trap trigger spells and invents no spell ids.
+
+import type { RegistryPack } from '../types.ts';
+
+// A hunter trap cast to its summoned gameobject entry and that trap's trigger spell — the entry from
+// the raw effect's misc value, the trigger from the gameobject template. Cite: gameobject-data.json.
+export interface HunterTrapGoNote {
+  /** Player cast spell id (Freezing / Immolation / Frost / Explosive ranks). */
+  spellId: number;
+  name: string;
+  /** EffectMiscValue = gameobject entry. */
+  goEntry: number;
+  // GO trap data3 spell cast on trigger (Use). Not on the cast spell row — attached only via
+  // gameobject_template.
+  triggerSpellId: number;
+  /** Object slot for SUMMON_OBJECT_SLOT1. Cite: SpellEffects.cpp:4739 → 0. */
+  slot: 0;
+}
+
+/** Sourced hunter trap family rows for fixtures / SI5 GO arm. */
+export const HUNTER_TRAP_GO_NOTES: readonly HunterTrapGoNote[] = [
+  // Freezing Trap R1: misc 2561 → Freezing Trap GO → spell 3355.
+  // Cite: game-data 1499; gameobject-data 2561 trap.spellId 3355; enrich smoke trap 2561.
+  { spellId: 1499, name: 'Freezing Trap', goEntry: 2561, triggerSpellId: 3355, slot: 0 },
+  // Freezing Trap R2: GO Freezing Trap II. Cite: game-data 14310; gameobject-data 164876.
+  { spellId: 14310, name: 'Freezing Trap', goEntry: 164876, triggerSpellId: 14308, slot: 0 },
+  // Freezing Trap R3: GO Freezing Trap III. Cite: game-data 14311; gameobject-data 164877.
+  { spellId: 14311, name: 'Freezing Trap', goEntry: 164877, triggerSpellId: 14309, slot: 0 },
+  // Immolation Trap R1. Cite: game-data 13795; gameobject-data 164638 trap.spellId 13797.
+  { spellId: 13795, name: 'Immolation Trap', goEntry: 164638, triggerSpellId: 13797, slot: 0 },
+  // Frost Trap. Cite: game-data 13809; gameobject-data 164639 trap.spellId 13810.
+  { spellId: 13809, name: 'Frost Trap', goEntry: 164639, triggerSpellId: 13810, slot: 0 },
+  // Explosive Trap R1. Cite: game-data 13813; gameobject-data 164839 trap.spellId 13812.
+  { spellId: 13813, name: 'Explosive Trap', goEntry: 164839, triggerSpellId: 13812, slot: 0 },
+] as const;
+
+/** Lookup by cast spell id. */
+export const HUNTER_TRAP_BY_SPELL_ID: ReadonlyMap<number, HunterTrapGoNote> = new Map(
+  HUNTER_TRAP_GO_NOTES.map((n) => [n.spellId, n]),
+);
+
+// The interrupt flag bit for a damage break. The sampled charm and possess spells carry no interrupt
+// flags in the classic table, so the charm surface has no break-on-damage.
+export const AURA_INTERRUPT_FLAG_DAMAGE = 0x2;
+
+/** Sample charm/possess spells for fixtures (aura 6 / 2). */
+export const EX_WAVE_M_CHARM_POSSESS = {
+  /** Dominate Mind — MOD_CHARM. Cite: spell-data 7645; SpellAuras.cpp:2282. */
+  dominateMind: 7645,
+  /** Enslave Demon — MOD_CHARM. Cite: game-data 1098. */
+  enslaveDemon: 1098,
+  /** Mind Control — MOD_POSSESS. Cite: game-data 605; charm-possess.md. */
+  mindControl: 605,
+  /** Control Shredder — MOD_POSSESS. Cite: SpellAuras.cpp possess path; spell-data 21556. */
+  controlShredder: 21556,
+} as const;
+
+// Feign Death spell ids. 5384 = aura apply (FEIGN_DEATH 66); 5385 = dummy learn/trigger of 5384. Cite:
+// game-data 5384/5385; SpellAuras.cpp:2382 HandleFeignDeath.
+export const FEIGN_DEATH_SPELL_ID = 5384;
+export const FEIGN_DEATH_TRIGGER_SPELL_ID = 5385;
+
+// No dummy/script handlers here — Life Tap is life-tap.ts; traps/charm/feign use SI3 generic EFFECT/AURA
+// handlers. Pack keeps GO notes + family constants.
+export const exWaveMPack: RegistryPack = {
+  id: 'ex-wave-m',
+  dummy: {},
+  script: {},
+};

package/src/engine/spells/interpreter/registry/packs/life-tap.ts

@@ -0,0 +1,107 @@
+// Life Tap, the warlock dummy that converts health to mana. Rank-generic on the warlock family plus
+// its family flag, so every rank matches. Cite: Warlock.cpp LifeTap ~52-103.
+
+import type { RegistryHandler, RegistryPack } from '../types.ts';
+import { effectBaseAmount, truncTowardZero } from '../helpers.ts';
+import { LIFE_TAP_BASE_AMOUNT } from '../../priest-warlock-kit.ts';
+
+/** Life Tap mana energize custom spell. Cite: Warlock.cpp:102 CastCustomSpell(nullptr, 31818, &mana, …). */
+export const LIFE_TAP_MANA_SPELL_ID = 31818;
+
+// Plagueheart Raiment dummy — reduces/scales hp cost only, not mana. Cite: Warlock.cpp:75–76, :94–95 case
+// 28830.
+export const PLAGUEHEART_LIFE_TAP_SPELL_ID = 28830;
+
+/** SPELLFAMILY_WARLOCK. Cite: DBCEnums.h SPELLFAMILY_WARLOCK = 5. */
+export const SPELLFAMILY_WARLOCK = 5;
+
+// Life Tap family flag bit (0x40000). Shared by all classic ranks. Cite: spell_template SpellFamilyFlags
+// for 1454/1455/…/11689.
+export const LIFE_TAP_FAMILY_FLAGS = 0x0004_0000;
+
+// The Life Tap handler: the script value is the mana, scaled by the Improved Life Tap dummy auras,
+// and the health is paid as a power cost. Cite: Warlock.cpp:52-103.
+const handleLifeTap: RegistryHandler = (state, raw, _slot) => {
+  // The rank table is flat per rank, matching the tooltip. The DBC per-level term is NOT applied to
+  // player Life Tap ranks — with it, level 20 read 34 instead of 20.
+  const rankBase = LIFE_TAP_BASE_AMOUNT[state.spell.id | 0];
+  let cost = rankBase != null
+    ? rankBase
+    : effectBaseAmount(raw, { ...state.ctx, casterLevel: undefined, spellLevel: undefined });
+
+  // ApplySpellMod SPELLMOD_COST when ctx supplies. Cite: Warlock.cpp:58–60.
+  if (state.ctx.spellModCost != null) {
+    cost += state.ctx.spellModCost;
+  }
+
+  // SpellDamageBonusDone/Taken on self — flat hook when provided. Cite: Warlock.cpp:62–64.
+  let scriptValue = truncTowardZero(cost > 0 ? cost : 0);
+  if (state.ctx.lifeTapSpellDamageBonus != null) {
+    scriptValue = truncTowardZero(scriptValue + state.ctx.lifeTapSpellDamageBonus);
+  }
+  if (scriptValue < 0) scriptValue = 0;
+
+  // OnCheckCast fizzle: script value > current health → SPELL_FAILED_FIZZLE. Compared against
+  // pre-Plagueheart script value (GetScriptValue), not power cost. Cite: Warlock.cpp:69–70.
+  const fizzled =
+    state.ctx.casterHealth != null && scriptValue > (state.ctx.casterHealth | 0);
+
+  // Health cost = script value; Plagueheart adds dmg * amount/100 to power cost only.
+  // Cite: Warlock.cpp:74–77 OnCheckCast (!strict) SetPowerCost.
+  let healthCost = scriptValue;
+  let mana = scriptValue;
+
+  const dummies = state.ctx.lifeTapDummyAuras ?? [];
+  for (const aura of dummies) {
+    if (aura.spellId === PLAGUEHEART_LIFE_TAP_SPELL_ID) {
+      // Plagueheart: hp cost only. Cite: Warlock.cpp:75–76, :94–95 break.
+      healthCost = truncTowardZero(healthCost + (healthCost * aura.amount) / 100);
+      continue;
+    }
+    // Improved Life Tap (and any other isAffected dummy): scale mana.
+    // Cite: Warlock.cpp:97 mana = (amount+100)*mana/100; C++ int32 arithmetic.
+    mana = truncTowardZero(((aura.amount + 100) * mana) / 100);
+  }
+
+  // Intent for SI5; bake effects [] so LOCK 9a oracle matches empty.
+  // Cite: Warlock.cpp OnEffectExecute + power cost path.
+  const lifeTapIntent: {
+    kind: 'life_tap';
+    healthCost: number;
+    manaGain: number;
+    manaSpellId: number;
+    fizzled?: boolean;
+  } = {
+    kind: 'life_tap',
+    healthCost,
+    manaGain: fizzled ? 0 : mana,
+    manaSpellId: LIFE_TAP_MANA_SPELL_ID,
+  };
+  if (fizzled) lifeTapIntent.fizzled = true;
+  state.intents.push(lifeTapIntent);
+
+  // OnEffectExecute only runs when cast succeeds — no CastCustomSpell on fizzle.
+  // Cite: Warlock.cpp:82–102; OnCheckCast :69–70.
+  if (!fizzled) {
+    state.intents.push({
+      kind: 'cast_custom_spell',
+      spellId: LIFE_TAP_MANA_SPELL_ID,
+      bp0: mana,
+    });
+  }
+
+  return true;
+};
+
+export const lifeTapPack: RegistryPack = {
+  id: 'life-tap',
+  // Rank-generic: all Life Tap ranks share family 5 + 0x40000.
+  // Cite: spell_template ranks 1454–11689; Warlock.cpp LifeTap (no per-id switch body).
+  dummyMatchers: [
+    {
+      spellFamilyName: SPELLFAMILY_WARLOCK,
+      spellFamilyFlags: LIFE_TAP_FAMILY_FLAGS,
+      handler: handleLifeTap,
+    },
+  ],
+};

package/src/engine/spells/interpreter/registry/packs/paladin.ts

@@ -0,0 +1,246 @@
+// The paladin dummy and script surface: Holy Shock and the two holy heals rank-generically by icon,
+// with per-id entries only where the C++ scripts a specific id. Seals live in paladin-seals.ts.
+
+import type { RegistryHandler, RegistryPack } from '../types.ts';
+import { effectBaseAmount, truncTowardZero } from '../helpers.ts';
+import { clampPositiveRange, effectAmountRange } from '../../amount.ts';
+
+/** SPELLFAMILY_PALADIN. Cite: DBCEnums.h SPELLFAMILY_PALADIN = 10. */
+export const SPELLFAMILY_PALADIN = 10;
+
+/** Judgement (player ability). Cite: spell_template Id 20271; Paladin.cpp RegisterSpellScript. */
+export const JUDGEMENT_SPELL_ID = 20271;
+
+/** Holy Light CastCustomSpell payload. Cite: SpellEffects.cpp:4161 (19968). */
+export const HOLY_LIGHT_HEAL_SPELL_ID = 19968;
+
+/** Flash of Light CastCustomSpell payload. Cite: SpellEffects.cpp:4170 (19993). */
+export const FLASH_OF_LIGHT_HEAL_SPELL_ID = 19993;
+
+/** Judgement of Light Intermediate. Cite: Paladin.cpp:37–55; RegisterSpellScript. */
+export const JUDGEMENT_OF_LIGHT_INTERMEDIATE_ID = 5373;
+
+/** Judgement of Wisdom Intermediate. Cite: Paladin.cpp:58–75; RegisterSpellScript. */
+export const JUDGEMENT_OF_WISDOM_INTERMEDIATE_ID = 1826;
+
+/** Holy Shock SpellIconID. Cite: SpellEffects.cpp:1431 case 156. */
+export const HOLY_SHOCK_ICON_ID = 156;
+
+/** Holy Light SpellIconID. Cite: SpellEffects.cpp:4155. */
+export const HOLY_LIGHT_ICON_ID = 70;
+
+/** Flash of Light SpellIconID. Cite: SpellEffects.cpp:4164. */
+export const FLASH_OF_LIGHT_ICON_ID = 242;
+
+/** Judgement of Command SpellIconID. Cite: SpellEffects.cpp:1456 case 561. */
+export const JUDGEMENT_OF_COMMAND_ICON_ID = 561;
+
+// The Holy Shock branch tables, per id as the C++ switches them, with the sub-spell ranges read off
+// the raw base points and dice. Cite: SpellEffects.cpp:1439-1443.
+
+interface HolyShockBranch {
+  hurt: number;
+  heal: number;
+  /** Shared min/max on hurt + heal sub-spells (Classic ranks match). */
+  min: number;
+  max: number;
+}
+
+// CMaNGOS per-id hurt/heal + bake-sourced ranges for classic ranks. Handler entry is rank-generic (icon
+// 156); branch lookup stays id-keyed because C++ switches on Id. Cite: SpellEffects.cpp:1439–1443.
+const HOLY_SHOCK_BRANCH: Readonly<Record<number, HolyShockBranch>> = {
+  20473: { hurt: 25912, heal: 25914, min: 204, max: 220 },
+  20929: { hurt: 25911, heal: 25913, min: 279, max: 301 },
+  20930: { hurt: 25902, heal: 25903, min: 365, max: 395 },
+};
+
+// JoL intermediate: triggered-by Judgement of Light aura → periodic heal spell. CMaNGOS scripts per aura
+// id. Cite: Paladin.cpp:47–51.
+const JOL_INTERMEDIATE_TRIGGERS: Readonly<Record<number, number>> = {
+  20185: 20267, // Rank 1
+  20344: 20341, // Rank 2
+  20345: 20342, // Rank 3
+  20346: 20343, // Rank 4
+};
+
+// JoW intermediate: triggered-by Judgement of Wisdom aura → mana restore spell. CMaNGOS scripts per aura
+// id. Cite: Paladin.cpp:69–71.
+const JOW_INTERMEDIATE_TRIGGERS: Readonly<Record<number, number>> = {
+  20186: 20268, // Rank 1
+  20354: 20352, // Rank 2
+  20355: 20353, // Rank 3
+};
+
+// ── Handlers ─────────────────────────────────────────────────────────────────
+
+// The judgement script finds the seal's dummy pointer, removes the seal and casts what it names. The
+// bake already carries a judgement kind, so that is always emitted. Cite: Paladin.cpp:78-116.
+const handleJudgement: RegistryHandler = (state, _raw, _slot) => {
+  // Bake surface — LOCK 9a. Cite: game-data Judgement effects; schema kind judgement.
+  state.effects.push({ kind: 'judgement' });
+
+  const seal = state.ctx.activeSeal;
+  if (seal && seal.judgementSpellId > 1) {
+    // Cite: Paladin.cpp:104–115 spellId2 from seal; RemoveAurasDueToSpell; CastSpell.
+    state.intents.push({
+      kind: 'judgement_cast',
+      sealSpellId: seal.spellId,
+      judgementSpellId: seal.judgementSpellId,
+    });
+    // Seal consume as generic consume_aura (SPELL_AURA_DUMMY = 4).
+    // Cite: Paladin.cpp:110 RemoveAurasDueToSpell((*itr)->GetId()).
+    state.intents.push({
+      kind: 'consume_aura',
+      spellId: seal.spellId,
+      spellFamilyName: SPELLFAMILY_PALADIN,
+      spellFamilyFlags: 0,
+      auraType: 4, // SPELL_AURA_DUMMY
+      casterOnly: true,
+    });
+  }
+
+  return true;
+};
+
+// Judgement of Command casts the spell id in the effect base points.
+// Cite: SpellEffects.cpp:1456-1465.
+const handleJudgementOfCommand: RegistryHandler = (state, raw, _slot) => {
+  const spellId = effectBaseAmount(raw, state.ctx);
+  if (spellId > 0) {
+    state.intents.push({ kind: 'cast_triggered_spell', spellId });
+  }
+  return true;
+};
+
+// Holy Shock casts the heal on a friendly target and the hurt on anyone else. A thin bake emits both
+// halves from the branch table; with a target known, the branch cast is emitted too.
+const handleHolyShock: RegistryHandler = (state, _raw, _slot) => {
+  const id = state.spell.id | 0;
+  const rank = HOLY_SHOCK_BRANCH[id];
+  if (!rank) {
+    // Unknown rank under icon 156: handled no-op (C++ logs error and returns).
+    // Cite: SpellEffects.cpp:1444–1446 default.
+    return true;
+  }
+
+  // Bake dual surface — combat branches on target reaction. Cite: schema holy_shock;
+  //   enrich-talent-actives.mjs 20473; game-data sub-spells 25912/25914.
+  state.effects.push({
+    kind: 'holy_shock',
+    damage: { school: 'holy', min: rank.min, max: rank.max },
+    heal: { min: rank.min, max: rank.max },
+  });
+
+  // Cast-time branch when unit reaction is known.
+  // Cite: SpellEffects.cpp:1449–1452 CanAssistSpell → heal else hurt.
+  if (state.ctx.targetCanAssist != null) {
+    const spellId = state.ctx.targetCanAssist ? rank.heal : rank.hurt;
+    state.intents.push({ kind: 'cast_spell', spellId });
+  }
+
+  return true;
+};
+
+// Holy Light and Flash of Light's script effect casts a custom heal for the effect value, emitted as a
+// plain heal to match the bake mapper. Cite: SpellEffects.cpp:4154-4171.
+function makeHolyHealScript(customSpellId: number): RegistryHandler {
+  return (state, raw, _slot) => {
+    const { min, max } = effectAmountRange(raw, state.ctx);
+    // Mapper: Math.max(1, min/max). Cite: map-spell-effects.mjs:410.
+    if (min > 1) {
+      const range = clampPositiveRange(min, max);
+      state.effects.push({ kind: 'heal', min: range.min, max: range.max });
+    }
+
+    // C++ uses rolled damage; bake-thin uses range min as bp0 (deterministic snapshot).
+    // Cite: SpellEffects.cpp:4159–4161 heal = damage; CastCustomSpell(…, &heal, &spellid).
+    const healBp = truncTowardZero(effectBaseAmount(raw, state.ctx));
+    if (healBp > 0) {
+      state.intents.push({
+        kind: 'cast_custom_spell',
+        spellId: customSpellId,
+        bp0: healBp,
+        bp1: state.spell.id | 0, // main spell id as unused effect basepoints
+      });
+    }
+
+    return true;
+  };
+}
+
+const handleHolyLight = makeHolyHealScript(HOLY_LIGHT_HEAL_SPELL_ID);
+const handleFlashOfLight = makeHolyHealScript(FLASH_OF_LIGHT_HEAL_SPELL_ID);
+
+// The Judgement of Light intermediate reads the triggering aura's rank and heals from it.
+// Cite: Paladin.cpp:37-55.
+const handleJudgementOfLightIntermediate: RegistryHandler = (state, _raw, _slot) => {
+  const byAura = state.ctx.triggeredByAuraSpellId;
+  if (byAura == null) {
+    state.effects.push({ kind: 'script_handled_noop', spellId: JUDGEMENT_OF_LIGHT_INTERMEDIATE_ID } as never);
+    return true;
+  }
+  const triggerSpell = JOL_INTERMEDIATE_TRIGGERS[byAura];
+  if (triggerSpell) {
+    state.intents.push({ kind: 'cast_spell', spellId: triggerSpell });
+  }
+  return true;
+};
+
+// The Judgement of Wisdom intermediate reads the triggering aura's rank and restores mana from it.
+// Cite: Paladin.cpp:58-75.
+const handleJudgementOfWisdomIntermediate: RegistryHandler = (state, _raw, _slot) => {
+  const byAura = state.ctx.triggeredByAuraSpellId;
+  if (byAura == null) {
+    state.effects.push({ kind: 'script_handled_noop', spellId: JUDGEMENT_OF_WISDOM_INTERMEDIATE_ID } as never);
+    return true;
+  }
+  const triggerSpell = JOW_INTERMEDIATE_TRIGGERS[byAura];
+  if (triggerSpell) {
+    state.intents.push({ kind: 'cast_spell', spellId: triggerSpell });
+  }
+  return true;
+};
+
+// ── Pack maps ────────────────────────────────────────────────────────────────
+
+export const paladinPack: RegistryPack = {
+  id: 'paladin',
+  // Per-id: CMaNGOS RegisterSpellScript / intermediate dummies are single ids.
+  // Cite: Paladin.cpp LoadPaladinScripts; JoL 5373 / JoW 1826.
+  dummy: {
+    [JUDGEMENT_OF_LIGHT_INTERMEDIATE_ID]: handleJudgementOfLightIntermediate,
+    [JUDGEMENT_OF_WISDOM_INTERMEDIATE_ID]: handleJudgementOfWisdomIntermediate,
+  },
+  // Rank-generic Holy Shock: all ranks share icon 156 under family paladin.
+  // Cite: SpellEffects.cpp:1429–1454 switch (SpellIconID) case 156.
+  dummyMatchers: [
+    {
+      spellFamilyName: SPELLFAMILY_PALADIN,
+      spellIconId: HOLY_SHOCK_ICON_ID,
+      handler: handleHolyShock,
+    },
+    {
+      spellFamilyName: SPELLFAMILY_PALADIN,
+      spellIconId: JUDGEMENT_OF_COMMAND_ICON_ID,
+      handler: handleJudgementOfCommand,
+    },
+  ],
+  // Judgement is a single player ability id. Cite: Paladin.cpp spell_judgement 20271.
+  script: {
+    [JUDGEMENT_SPELL_ID]: handleJudgement,
+  },
+  // Rank-generic HL / FoL: C++ keys on SpellIconID 70 / 242, not a rank id list.
+  // Cite: SpellEffects.cpp:4154–4171.
+  scriptMatchers: [
+    {
+      spellFamilyName: SPELLFAMILY_PALADIN,
+      spellIconId: HOLY_LIGHT_ICON_ID,
+      handler: handleHolyLight,
+    },
+    {
+      spellFamilyName: SPELLFAMILY_PALADIN,
+      spellIconId: FLASH_OF_LIGHT_ICON_ID,
+      handler: handleFlashOfLight,
+    },
+  ],
+};

package/src/engine/spells/interpreter/registry/packs/raid-script-summons.ts

@@ -0,0 +1,26 @@
+// Raid script rows whose body is a cast fan-out in the boss script. The spell row carries no misc
+// value, so the generic dispatcher has nothing to read and the C++ script is the source.
+
+import type { RegistryHandler, RegistryPack } from '../types.ts';
+
+/** Moam's 90 s add wave. Cite: boss_moam.cpp:40 SPELL_SUMMON_MANAFIENDS, :156-160. */
+export const SUMMON_MANA_FIENDS_SPELL_ID = 25684;
+
+// The three fixed-bearing summons it fans out to: the same creature with three different bearings, so
+// they land around the boss rather than on one point. Cite: boss_moam.cpp:43-45, :180-182.
+export const MANA_FIEND_SUMMON_SPELL_IDS: readonly number[] = [25681, 25682, 25683];
+
+const handleSummonManaFiends: RegistryHandler = (state) => {
+  for (const spellId of MANA_FIEND_SUMMON_SPELL_IDS) {
+    state.intents.push({ kind: 'cast_triggered_spell', spellId });
+    // Play surface: combat resolves a triggered payload off the caster's own kit, so the three
+    // ids are in BOSS_MOAM.spellIds beside 25684 (same rule as the Magmadar lava-bomb chain).
+    state.effects.push({ kind: 'trigger_spell', spellId });
+  }
+  return true;
+};
+
+export const raidScriptSummonsPack: RegistryPack = {
+  id: 'raid-script-summons',
+  script: { [SUMMON_MANA_FIENDS_SPELL_ID]: handleSummonManaFiends },
+};

package/src/engine/spells/interpreter/registry/packs/raid-threat-wipe.ts

@@ -0,0 +1,22 @@
+// "Hate to Zero": the dummy whose C++ body resets threat. Both ids carry no misc value, so the generic
+// dispatcher no-ops and the boss kept the table a mechanic exists to lose. Cite: UnitAI.cpp:773-781.
+
+import type { RegistryHandler, RegistryPack } from '../types.ts';
+
+/** Arlokk's, cast on her vanish. Cite: boss_arlokk.cpp:50. */
+export const HATE_TO_ZERO_20538 = 20538;
+/** The Enrage-carried one: 23537 Enrage triggers it on Chromaggus, Venoxis and Mandokir. */
+export const HATE_TO_ZERO_9204 = 9204;
+
+const handleHateToZero: RegistryHandler = (state) => {
+  state.effects.push({ kind: 'reset_own_threat' });
+  return true;
+};
+
+export const raidThreatWipePack: RegistryPack = {
+  id: 'raid-threat-wipe',
+  dummy: {
+    [HATE_TO_ZERO_20538]: handleHateToZero,
+    [HATE_TO_ZERO_9204]: handleHateToZero,
+  },
+};