azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/spells/interpreter/registry/index.ts

@@ -0,0 +1,216 @@
+// The scripted-spell registry: merge the packs and dispatch the dummy and script effects. Lookup is by
+// exact id, then family and icon matchers, so a rank table cannot leave later ranks dead.
+
+import type { RawSpellEffect, SpellDef } from '../../../../data/schema.ts';
+import type {
+  RegistryHandler,
+  RegistryMatcher,
+  RegistryPack,
+  RegistryState,
+} from './types.ts';
+import { lifeTapPack } from './packs/life-tap.ts';
+import { paladinPack } from './packs/paladin.ts';
+import { classAbilitiesPack } from './packs/class-abilities.ts';
+import { shamanPack } from './packs/shaman.ts';
+import { exWaveMPack } from './packs/ex-wave-m.ts';
+import { dummyScriptTailPack } from './packs/dummy-script-tail.ts';
+import { direMaulPack } from './packs/dire-maul.ts';
+import { raidScriptSummonsPack } from './packs/raid-script-summons.ts';
+import { raidThreatWipePack } from './packs/raid-threat-wipe.ts';
+import { si4DummyGenericAPack } from './packs/si4-dummy-generic-a.ts';
+import { si4DummyGenericBPack } from './packs/si4-dummy-generic-b.ts';
+import { si4DummyGenericCPack } from './packs/si4-dummy-generic-c.ts';
+import { si4DummyWarriorPack } from './packs/si4-dummy-warrior.ts';
+import { si4DummyHunterPack } from './packs/si4-dummy-hunter.ts';
+import { si4ScriptGenericAPack } from './packs/si4-script-generic-a.ts';
+import { si4ScriptGenericBPack } from './packs/si4-script-generic-b.ts';
+import { si4ScriptGenericCPack } from './packs/si4-script-generic-c.ts';
+
+export type {
+  RegistryHandler,
+  RegistryMatcher,
+  RegistryPack,
+  RegistryState,
+} from './types.ts';
+export { effectBaseAmount, truncTowardZero } from './helpers.ts';
+export { LIFE_TAP_MANA_SPELL_ID, PLAGUEHEART_LIFE_TAP_SPELL_ID } from './packs/life-tap.ts';
+export { JUDGEMENT_SPELL_ID } from './packs/paladin.ts';
+export {
+  ICE_LOCK_TRAP_SPELL_ID,
+  ICE_LOCK_STUN_SPELL_ID,
+  NPC_GUARD_SLIPKIK,
+  FACTION_OGRE,
+} from './packs/dire-maul.ts';
+export { LAST_STAND_SPELL_ID, LAST_STAND_BUFF_SPELL_ID } from './packs/class-abilities.ts';
+export {
+  CREATE_HEALTHSTONE_SPELL_IDS,
+  SOUL_LINK_SPELL_ID,
+  SOUL_LINK_PET_AURA_SPELL_ID,
+  TAME_BEAST_DUMMY_SPELL_ID,
+  TAME_BEAST_FINAL_SPELL_ID,
+  healthstoneItemType,
+  improvedHealthstoneRankFromTalents,
+  IMPROVED_HEALTHSTONE_RANK1_SPELL_ID,
+  IMPROVED_HEALTHSTONE_RANK2_SPELL_ID,
+} from './packs/dummy-script-tail.ts';
+
+// Packs pre-imported so later work only edits pack files and tests. A later pack overrides an earlier
+// one on the same id, and matchers are tried in reverse pack order so overrides win.
+const PACKS: readonly RegistryPack[] = [
+  lifeTapPack,
+  paladinPack,
+  classAbilitiesPack,
+  shamanPack,
+  exWaveMPack,
+  dummyScriptTailPack,
+  direMaulPack,
+  raidScriptSummonsPack,
+  raidThreatWipePack,
+  si4DummyGenericAPack,
+  si4DummyGenericBPack,
+  si4DummyGenericCPack,
+  si4DummyWarriorPack,
+  si4DummyHunterPack,
+  si4ScriptGenericAPack,
+  si4ScriptGenericBPack,
+  si4ScriptGenericCPack,
+];
+
+function mergeHandlers(
+  pick: (p: RegistryPack) => Readonly<Record<number, RegistryHandler>> | undefined,
+): Map<number, RegistryHandler> {
+  const map = new Map<number, RegistryHandler>();
+  for (const pack of PACKS) {
+    const handlers = pick(pack);
+    if (!handlers) continue;
+    for (const [idStr, handler] of Object.entries(handlers)) {
+      map.set(Number(idStr), handler);
+    }
+  }
+  return map;
+}
+
+function mergeMatchers(
+  pick: (p: RegistryPack) => readonly RegistryMatcher[] | undefined,
+): RegistryMatcher[] {
+  // Reverse so later packs win on first match.
+  const out: RegistryMatcher[] = [];
+  for (let i = PACKS.length - 1; i >= 0; i--) {
+    const list = pick(PACKS[i]!);
+    if (list?.length) out.push(...list);
+  }
+  return out;
+}
+
+const DUMMY_BY_ID = mergeHandlers((p) => p.dummy);
+const SCRIPT_BY_ID = mergeHandlers((p) => p.script);
+const DUMMY_MATCHERS = mergeMatchers((p) => p.dummyMatchers);
+const SCRIPT_MATCHERS = mergeMatchers((p) => p.scriptMatchers);
+
+// 64-bit family-flag mask check. JS `&` is int32 and drops high bits (e.g. Flametongue Totem 0x400000000) —
+// use BigInt. Cite: SpellFamilyFlags is uint64 in SpellEntry; SpellEffects.cpp IsFitToFamilyMask.
+export function spellFamilyFlagsMatch(flags: number, mask: number): boolean {
+  if (!(mask > 0) && mask !== 0) return false;
+  return (BigInt(flags || 0) & BigInt(mask)) === BigInt(mask);
+}
+
+// True when every specified matcher field matches the spell. At least one of family / flags / icon must be
+// set on the matcher.
+export function matcherMatchesSpell(spell: SpellDef, m: RegistryMatcher): boolean {
+  const hasKey =
+    m.spellFamilyName != null || m.spellFamilyFlags != null || m.spellIconId != null;
+  if (!hasKey) return false;
+  if (m.spellFamilyName != null && ((spell.spellFamilyName ?? 0) | 0) !== (m.spellFamilyName | 0)) {
+    return false;
+  }
+  if (m.spellIconId != null && ((spell.spellIconId ?? 0) | 0) !== (m.spellIconId | 0)) {
+    return false;
+  }
+  if (m.spellFamilyFlags != null) {
+    const flags = Number(spell.spellFamilyFlags ?? 0);
+    if (!spellFamilyFlagsMatch(flags, Number(m.spellFamilyFlags))) return false;
+  }
+  return true;
+}
+
+function findMatcher(
+  spell: SpellDef,
+  matchers: readonly RegistryMatcher[],
+): RegistryHandler | undefined {
+  for (const m of matchers) {
+    if (matcherMatchesSpell(spell, m)) return m.handler;
+  }
+  return undefined;
+}
+
+// The default for an unknown dummy or script: handled and empty, which is where the placeholder
+// secondary slots on finishers land. Emit a zero-payload surface so the slot is not read as unhandled.
+export function ensureHandledSurface(state: RegistryState): void {
+  if (!(state.effects?.length) && !(state.intents?.length)) {
+    state.effects.push({
+      kind: 'script_handled_noop',
+      spellId: state.spell.id | 0,
+    } as never);
+  }
+}
+
+function defaultHandledNoop(
+  state: RegistryState,
+  _raw: RawSpellEffect,
+  _slot: number,
+): boolean {
+  // C++ EffectDummy/ScriptEffect fallthrough returns empty after the per-id switch.
+  // Cite: SpellEffects.cpp EffectDummy / EffectScriptEffect empty defaults.
+  ensureHandledSurface(state);
+  return true;
+}
+
+// Dispatch the dummy effect: exact id, then the rank-generic matchers, then a handled no-op. It
+// always returns true once the opcode is registered.
+export function dispatchDummy(
+  state: RegistryState,
+  raw: RawSpellEffect,
+  slot: number,
+): boolean {
+  const id = state.spell.id | 0;
+  const handler =
+    DUMMY_BY_ID.get(id)
+    ?? findMatcher(state.spell, DUMMY_MATCHERS)
+    ?? defaultHandledNoop;
+  return handler(state, raw, slot);
+}
+
+// Dispatch the script effect: exact id, then the rank-generic matchers, then a handled no-op. It
+// always returns true once the opcode is registered.
+export function dispatchScript(
+  state: RegistryState,
+  raw: RawSpellEffect,
+  slot: number,
+): boolean {
+  const id = state.spell.id | 0;
+  const handler =
+    SCRIPT_BY_ID.get(id)
+    ?? findMatcher(state.spell, SCRIPT_MATCHERS)
+    ?? defaultHandledNoop;
+  return handler(state, raw, slot);
+}
+
+/** Test / diagnostics: registered dummy spell ids (exact-id maps only). */
+export function registeredDummySpellIds(): number[] {
+  return [...DUMMY_BY_ID.keys()].sort((a, b) => a - b);
+}
+
+/** Test / diagnostics: registered script spell ids (exact-id maps only). */
+export function registeredScriptSpellIds(): number[] {
+  return [...SCRIPT_BY_ID.keys()].sort((a, b) => a - b);
+}
+
+/** Test / diagnostics: dummy rank-generic matcher count. */
+function registeredDummyMatcherCount(): number {
+  return DUMMY_MATCHERS.length;
+}
+
+/** Test / diagnostics: script rank-generic matcher count. */
+function registeredScriptMatcherCount(): number {
+  return SCRIPT_MATCHERS.length;
+}

package/src/engine/spells/interpreter/registry/packs/class-abilities.ts

@@ -0,0 +1,304 @@
+// Class-ability dummy and script specials: Last Stand, Enrage, the cooldown resets and the racial
+// dummies. Rank-generic by icon where the C++ switches on one, per-id only where it uses a case.
+
+import type { RegistryHandler, RegistryPack } from '../types.ts';
+import { effectBaseAmount, truncTowardZero } from '../helpers.ts';
+import { IMPROVED_SPRINT_TRIGGER_SPELL_ID } from '../../../cmangos-special-cases-s21.ts';
+import { IMMUNE_TO_ROOT_AND_SNARE_MASK } from '../../../immunity.ts';
+
+// ── Spell ids (CMaNGOS per-id cases) ─────────────────────────────────────────
+
+/** Last Stand. Cite: SpellEffects.cpp:440 case 12975. */
+export const LAST_STAND_SPELL_ID = 12975;
+// Last Stand custom buff spell (MOD_INCREASE_HEALTH). Cite: SpellEffects.cpp:443 CastCustomSpell(m_caster,
+// 12976, &healthModSpellBasePoints0, …).
+export const LAST_STAND_BUFF_SPELL_ID = 12976;
+
+/** Druid Enrage. Cite: SpellEffects.cpp:1370 case 5229. */
+export const ENRAGE_SPELL_ID = 5229;
+// Enrage armor-reduction custom spell. Cite: SpellEffects.cpp:1375 CastCustomSpell(nullptr, 25503,
+// &reductionMod, …).
+export const ENRAGE_ARMOR_SPELL_ID = 25503;
+/** Dire Bear Form aura id for Enrage −16% branch. Cite: SpellEffects.cpp:1373 HasAura(9634). */
+export const DIRE_BEAR_FORM_SPELL_ID = 9634;
+// Default armor reduction (not Dire Bear). Cite: SpellEffects.cpp:1372 reductionMod = -27. spell_template
+// 25503 EffectBasePoints2 = -27 (CastCustomSpell overrides).
+export const ENRAGE_ARMOR_PCT_DEFAULT = -27;
+/** Dire Bear armor reduction. Cite: SpellEffects.cpp:1373–1374 HasAura(9634) → -16. */
+export const ENRAGE_ARMOR_PCT_DIRE_BEAR = -16;
+// Enrage armor-reduction duration (ms). spell_template 5229 / 25503 DurationIndex 1 → 10s. Cite:
+// SpellEffects.cpp:1375 CastCustomSpell(25503); duration.ts DurationIndex 1.
+export const ENRAGE_ARMOR_DURATION_MS = 10_000;
+
+/** Cold Snap. Cite: SpellEffects.cpp:1294 case 12472. */
+export const COLD_SNAP_SPELL_ID = 12472;
+/** Preparation. Cite: Rogue.cpp Preparation ~21–32; spell_template Id 14185. */
+export const PREPARATION_SPELL_ID = 14185;
+/** Readiness. Cite: SpellEffects.cpp:1412 case 23989. */
+export const READINESS_SPELL_ID = 23989;
+
+/** Blood Fury (orc racial). Cite: SpellEffects.cpp:760 case 20572. */
+export const BLOOD_FURY_SPELL_ID = 20572;
+/** Blood Fury healing reduction / side buff. Cite: SpellEffects.cpp:764 CastSpell(23230). */
+export const BLOOD_FURY_HEALING_SPELL_ID = 23230;
+/** Blood Fury AP custom buff. Cite: SpellEffects.cpp:767 CastCustomSpell(23234). */
+export const BLOOD_FURY_AP_SPELL_ID = 23234;
+
+/** Cannibalize. Cite: SpellEffects.cpp:786 case 20577. */
+export const CANNIBALIZE_SPELL_ID = 20577;
+/** Cannibalize channel heal. Cite: SpellEffects.cpp:788 CastSpell(20578). */
+export const CANNIBALIZE_HEAL_SPELL_ID = 20578;
+
+// Berserking SpellIconID — C++ switches on icon, not a rank id list. Cite: SpellEffects.cpp:1267–1285 case
+// 1661.
+export const BERSERKING_ICON_ID = 1661;
+
+/** Berserking haste custom. Cite: SpellEffects.cpp:1284 CastCustomSpell(26635, …). */
+export const BERSERKING_HASTE_SPELL_ID = 26635;
+
+// Classic Berserking rank ids (diagnostics / fixtures only — dispatch is icon-generic). Cite: spell ids
+// 20554 / 26296 / 26297 in classic DB.
+export const BERSERKING_SPELL_IDS = [20554, 26296, 26297] as const;
+
+// Wisp Spirit is a dummy with no handler body in the C++, a passive placeholder. An explicit no-op,
+// so the bake inventory is owned. Cite: game-data 20585; no case in SpellEffects.cpp.
+export const WISP_SPIRIT_SPELL_ID = 20585;
+
+// ── Bake surface constants (seed / enricher; not invented formulas) ─────────
+
+// Bake surface duration for Last Stand buff (20s). Cite: combat.scripted-talents.test.ts; classic spell
+// duration for 12976.
+const LAST_STAND_DURATION_MS = 20_000;
+
+// Blood Fury AP buff duration (ms). Companion 23234 MOD_ATTACK_POWER. Cite: SpellEffects.cpp:767
+// CastCustomSpell(23234); live spell 23234 durationMs 15000.
+const BLOOD_FURY_AP_DURATION_MS = 15_000;
+// Blood Fury healing reduction duration (ms). Companion 23230 MOD_HEALING_PCT. Cite: SpellEffects.cpp:764
+// CastSpell(23230); live spell 23230 durationMs 25000.
+const BLOOD_FURY_HEAL_DURATION_MS = 25_000;
+// Blood Fury healing taken % (spell 23230 aura 118). Bp=-51 Bd=1 → amount -50. Cite: effectAmountRange;
+// live spell 23230 rawEffects; handleModHealingPct.
+const BLOOD_FURY_HEALING_TAKEN_PCT = -50;
+
+// seed-racials Berserking combat surface — haste % at full health (bake-thin). Cite: SpellEffects.cpp:1271
+// haste_mod = 10 at full health; seed-racials.mjs 20554.
+const BERSERKING_BAKE_HASTE = 10;
+const BERSERKING_BAKE_DURATION_MS = 10_000;
+
+// The Cannibalize channel heals 7% of max health every two seconds for ten.
+// Cite: Spell_1.12.1_5875.csv 20578; SpellAuras.cpp PeriodicTick percent-of-max path.
+const CANNIBALIZE_PCT_OF_MAX = 7;
+const CANNIBALIZE_TICK_MS = 2000;
+const CANNIBALIZE_DURATION_MS = 10_000;
+
+// ── Handlers ────────────────────────────────────────────────────────────────
+
+// Last Stand casts a custom spell for 30% of max health. With a caster maximum supplied that is the
+// custom cast; on a thin bake it is the percent buff the enricher and combat kit already use.
+const handleLastStand: RegistryHandler = (state, _raw, _slot) => {
+  const maxHealth = state.ctx.casterMaxHealth;
+
+  if (maxHealth != null && maxHealth > 0) {
+    // Cite: SpellEffects.cpp:442–443 int32(GetMaxHealth() * 0.3).
+    const bp0 = truncTowardZero(maxHealth * 0.3);
+    state.intents.push({
+      kind: 'cast_custom_spell',
+      spellId: LAST_STAND_BUFF_SPELL_ID,
+      bp0,
+    });
+  }
+
+  // Bake / combat surface (percent). Always emit so bake-thin oracle + SI5 have a shape.
+  // Cite: game-data Last Stand effects; combat.scripted-talents.test.ts.
+  state.effects.push({
+    kind: 'buff',
+    mod: 'max_health_pct',
+    amount: 30,
+    durationMs: LAST_STAND_DURATION_MS,
+  });
+
+  return true;
+};
+
+// Enrage's dummy is the armor reduction only, since the rage regen is its own aura slots. The combat
+// surface also emits an armor percent so the reduction actually applies at the play surface.
+const handleEnrage: RegistryHandler = (state, _raw, _slot) => {
+  // Cite: SpellEffects.cpp:1372–1374.
+  const reductionMod = state.ctx.hasDireBearForm
+    ? ENRAGE_ARMOR_PCT_DIRE_BEAR
+    : ENRAGE_ARMOR_PCT_DEFAULT;
+  state.intents.push({
+    kind: 'cast_custom_spell',
+    spellId: ENRAGE_ARMOR_SPELL_ID,
+    bp0: reductionMod,
+  });
+  // The live armor surface, with the same numbers as the custom cast. It must be marked non-hostile:
+  // the amount is negative but self-targeted. Unshifted, or the later regen row skips the combat mod.
+  state.effects.unshift({
+    kind: 'buff',
+    mod: 'armor_pct',
+    amount: reductionMod,
+    durationMs: ENRAGE_ARMOR_DURATION_MS,
+    hostile: false,
+  });
+  return true;
+};
+
+// Cold Snap: RemoveSomeCooldown on mage frost spells with recovery time. Bake: `{ kind: 'reset_cooldowns',
+// scope: 'frost' }`. Cite: SpellEffects.cpp:1294–1308; enrich-talent-actives.mjs SCRIPTED 12472.
+const handleColdSnap: RegistryHandler = (state, _raw, _slot) => {
+  state.effects.push({ kind: 'reset_cooldowns', scope: 'frost' });
+  return true;
+};
+
+// Preparation: RemoveSomeCooldown on SPELLFAMILY_ROGUE except self. Bake: `{ kind: 'reset_cooldowns',
+// scope: 'rogue' }`. Cite: Rogue.cpp:21–32 Preparation; enrich-talent-actives.mjs SCRIPTED 14185.
+const handlePreparation: RegistryHandler = (state, _raw, _slot) => {
+  state.effects.push({ kind: 'reset_cooldowns', scope: 'rogue' });
+  return true;
+};
+
+// Improved Sprint: target dummy 30918 purges root and snare from unitTarget.
+// Cite: SpellEffects.cpp:4140-4147 EffectDummy case 30918; SharedDefines.h IMMUNE_TO_ROOT_AND_SNARE_MASK.
+const handleImprovedSprint: RegistryHandler = (state, _raw, _slot) => {
+  state.intents.push({
+    kind: 'mechanic_immunity_purge',
+    mechanic: 0,
+    mechanicMask: IMMUNE_TO_ROOT_AND_SNARE_MASK,
+  });
+  return true;
+};
+
+// Readiness: RemoveSomeCooldown on SPELLFAMILY_HUNTER with recovery, except self. Bake inventory empty for
+// 23989 — emit hunter scope for SI5 / combat. Cite: SpellEffects.cpp:1412–1419.
+const handleReadiness: RegistryHandler = (state, _raw, _slot) => {
+  state.effects.push({ kind: 'reset_cooldowns', scope: 'hunter' });
+  return true;
+};
+
+// Berserking's haste scales with missing health, from 10% at full up to 30% at or under 40%. With no
+// health in the context the full-health 10% stands. Cite: SpellEffects.cpp:1267-1285.
+const handleBerserking: RegistryHandler = (state, _raw, _slot) => {
+  const healthPerc = state.ctx.casterHealthPercent;
+  // Cite: SpellEffects.cpp:1271–1275.
+  let hasteMod = BERSERKING_BAKE_HASTE;
+  if (healthPerc != null) {
+    // Clamp to int percent like C++ uint32 cast of the float multiply. Cite: :1270.
+    const hp = truncTowardZero(healthPerc);
+    hasteMod = 10;
+    if (hp <= 40) hasteMod = 30;
+    if (hp < 100 && hp > 40) hasteMod = 10 + truncTowardZero((100 - hp) / 3);
+
+    // Cite: SpellEffects.cpp:1278–1284 — same bp for melee/range/cast haste.
+    state.intents.push({
+      kind: 'cast_custom_spell',
+      spellId: BERSERKING_HASTE_SPELL_ID,
+      bp0: hasteMod,
+      bp1: hasteMod,
+      bp2: hasteMod,
+    });
+  }
+
+  // Live combat + seed-racials surface: haste, not flat AP. Cite: seed-racials 20554; KI-125.
+  state.effects.push({
+    kind: 'buff',
+    mod: 'haste',
+    amount: hasteMod,
+    durationMs: BERSERKING_BAKE_DURATION_MS,
+  });
+  return true;
+};
+
+// Blood Fury casts a healing reduction and a flat attack-power bonus scaled off base attack power.
+// Intents alone are not applied, so the combat surface carries both. Cite: SpellEffects.cpp:760-768.
+const handleBloodFury: RegistryHandler = (state, raw, _slot) => {
+  // Cite: SpellEffects.cpp:764 CastSpell(23230).
+  state.intents.push({
+    kind: 'cast_triggered_spell',
+    spellId: BLOOD_FURY_HEALING_SPELL_ID,
+  });
+
+  // Cite: SpellEffects.cpp:766–767 damage * AP / 100 (uint32 path → trunc toward zero).
+  const pct = effectBaseAmount(raw, state.ctx);
+  const ap = state.ctx.attackPower ?? 0;
+  const bp0 = truncTowardZero((pct * ap) / 100);
+  state.intents.push({
+    kind: 'cast_custom_spell',
+    spellId: BLOOD_FURY_AP_SPELL_ID,
+    bp0,
+  });
+
+  // Live AP: % of base melee AP (dummy bp = 25). Cite: SpellEffects.cpp:766; raw 20572 bp24+1.
+  state.effects.push({
+    kind: 'buff',
+    mod: 'attack_power_pct',
+    amount: pct,
+    durationMs: BLOOD_FURY_AP_DURATION_MS,
+    hostile: false,
+  });
+  // Live heal penalty from 23230. Cite: SpellEffects.cpp:764; spell 23230 aura 118.
+  state.effects.push({
+    kind: 'buff',
+    mod: 'healing_taken_pct',
+    amount: BLOOD_FURY_HEALING_TAKEN_PCT,
+    durationMs: BLOOD_FURY_HEAL_DURATION_MS,
+    hostile: false,
+  });
+  return true;
+};
+
+// Cannibalize: CastSpell(20578) heal channel (OBS_MOD_HEALTH 7% max). Cite: SpellEffects.cpp:786–789;
+// Spell_1.12.1_5875.csv 20578; KI-806.
+const handleCannibalize: RegistryHandler = (state, _raw, _slot) => {
+  // Cite: SpellEffects.cpp:788 CastSpell(nullptr, 20578, TRIGGERED_NONE).
+  state.intents.push({
+    kind: 'cast_triggered_spell',
+    spellId: CANNIBALIZE_HEAL_SPELL_ID,
+  });
+
+  // OBS_MOD_HEALTH surface: pctOfMax wins; amountPerTick keeps bare % fallback.
+  // Cite: auras-control handleObsModHealth; rest.ts resolvePeriodicPctOfMax.
+  state.effects.push({
+    kind: 'restore_health',
+    amountPerTick: CANNIBALIZE_PCT_OF_MAX,
+    tickMs: CANNIBALIZE_TICK_MS,
+    durationMs: CANNIBALIZE_DURATION_MS,
+    pctOfMax: CANNIBALIZE_PCT_OF_MAX,
+  });
+  return true;
+};
+
+// Wisp Spirit — no EffectDummy case in CMaNGOS Classic. Handled empty. Cite: SpellEffects.cpp (absence of
+// case 20585); game-data 20585 passive dummy.
+const handleWispSpirit: RegistryHandler = (state, _raw, _slot) => {
+  state.effects.push({ kind: 'script_handled_noop', spellId: WISP_SPIRIT_SPELL_ID } as never);
+  return true;
+};
+
+// ── Pack ────────────────────────────────────────────────────────────────────
+
+export const classAbilitiesPack: RegistryPack = {
+  id: 'class-abilities',
+  // Per-id: CMaNGOS EffectDummy case <id> bodies.
+  // Cite: SpellEffects.cpp cases 12975, 5229, 12472, 23989, 20572, 20577; Rogue.cpp 14185.
+  dummy: {
+    [LAST_STAND_SPELL_ID]: handleLastStand,
+    [ENRAGE_SPELL_ID]: handleEnrage,
+    [COLD_SNAP_SPELL_ID]: handleColdSnap,
+    [PREPARATION_SPELL_ID]: handlePreparation,
+    [READINESS_SPELL_ID]: handleReadiness,
+    [BLOOD_FURY_SPELL_ID]: handleBloodFury,
+    [IMPROVED_SPRINT_TRIGGER_SPELL_ID]: handleImprovedSprint,
+    [CANNIBALIZE_SPELL_ID]: handleCannibalize,
+    [WISP_SPIRIT_SPELL_ID]: handleWispSpirit,
+  },
+  // Rank-generic Berserking: C++ switches on SpellIconID 1661 for all ranks.
+  // Cite: SpellEffects.cpp:1267–1285.
+  dummyMatchers: [
+    {
+      spellIconId: BERSERKING_ICON_ID,
+      handler: handleBerserking,
+    },
+  ],
+  script: {},
+};

package/src/engine/spells/interpreter/registry/packs/dire-maul.ts

@@ -0,0 +1,44 @@
+// Dire Maul instance script spells. Both shipped as the generic no-op fallthrough even though the
+// C++ gives each an explicit body. Cite: SpellEffects.cpp:3674-3678; instance_dire_maul.cpp:668-682.
+
+import type { RegistryHandler, RegistryPack } from '../types.ts';
+
+/** GO 179512 "Fixed Trap" trap.spellId. Cite: gameobject-data.json 179512. */
+export const ICE_LOCK_TRAP_SPELL_ID = 5249;
+/** The stun 5249 triggers: aura 12 MOD_STUN. Cite: SpellEffects.cpp:3677. */
+export const ICE_LOCK_STUN_SPELL_ID = 22856;
+/** Guard Slip'kik. Cite: dire_maul.h:98 NPC_GUARD_SLIPKIK. */
+export const NPC_GUARD_SLIPKIK = 14323;
+/** Cite: dire_maul.h:117 FACTION_OGRE. */
+export const FACTION_OGRE = 45;
+
+// 5249 Ice Lock (effect 77 SCRIPT_EFFECT): `unitTarget->CastSpell(unitTarget, 22856, TRIGGERED)`. Cite:
+// SpellEffects.cpp:3674-3678.
+const handleIceLock: RegistryHandler = (state, _raw, _slot) => {
+  state.intents.push({ kind: 'cast_triggered_spell', spellId: ICE_LOCK_STUN_SPELL_ID });
+  return true;
+};
+
+// The Guard Slip'kik trigger, fired by King of the Gordok, restores the trapped guard from the hostile
+// faction to the ogre one. The entry is instance storage, not spell targeting.
+const handleGuardSlipkikTrigger: RegistryHandler = (state, _raw, _slot) => {
+  state.intents.push({
+    kind: 'set_creature_faction',
+    creatureEntry: NPC_GUARD_SLIPKIK,
+    factionId: FACTION_OGRE,
+  });
+  state.effects.push({
+    kind: 'force_reaction',
+    factionId: FACTION_OGRE,
+    reputationRank: 4,
+    durationMs: 0,
+    stopAttackFaction: true,
+  });
+  return true;
+};
+
+export const direMaulPack: RegistryPack = {
+  id: 'dire-maul',
+  dummy: { 31770: handleGuardSlipkikTrigger },
+  script: { 5249: handleIceLock },
+};