azeroth-shell 0.0.0-stage → 0.1.1

package/src/domain/spells/spellPushback.ts

@@ -0,0 +1,39 @@
+// Spell damage pushback delay ladder plus the resist roll. Cite: Spell.h GetNextDelayAtDamageMsTime
+// ~826; Spell.cpp Delayed ~6804–6821 and DelayedChannel ~6843–6853.
+
+// Delay ladder for the Nth pushback on the current cast/channel (0-based). Cite: Spell.h:826 `1000 -
+// m_delayAtDamageCount++ * 200`, floor 200.
+export function nextPushbackDelayMs(hitIndex: number): number {
+  // hitIndex 0..n: 1000, 800, 600, 400, 200, then stay 200
+  if (hitIndex < 0) return 1000;
+  if (hitIndex < 5) return 1000 - hitIndex * 200;
+  return 200;
+}
+
+// Chance to fully resist a cast or channel pushback on this hit: 100, modified by
+// SPELLMOD_NOT_LOSE_CASTING_TIME, plus the RESIST_PUSHBACK aura total, minus 100.
+export function pushbackResistChancePct(
+  auraResistPct: number,
+  spellModPctPoints: number = 0,
+): number {
+  // ApplySpellMod PCT on base 100: totalpct = 100 + sum(pct points) → value * totalpct/100.
+  let resistChance = 100;
+  const modPts = spellModPctPoints | 0;
+  if (modPts !== 0) {
+    resistChance = Math.floor((resistChance * (100 + modPts)) / 100);
+  }
+  resistChance += (auraResistPct | 0) - 100;
+  return Math.max(0, resistChance);
+}
+
+// True when this hit's pushback is fully resisted (no delay). `chance01` is rng.chance style: argument in
+// 0..1.
+export function resistsPushback(
+  auraResistPct: number,
+  spellModPctPoints: number,
+  chance01: (p: number) => boolean,
+): boolean {
+  const pct = pushbackResistChancePct(auraResistPct, spellModPctPoints);
+  if (pct <= 0) return false;
+  return chance01(pct / 100);
+}

package/src/domain/spells/spellReflect.ts

@@ -0,0 +1,43 @@
+// Spell reflection predicates and chance. Cite: SpellMgr.h IsReflectableSpell ~1394; Unit.cpp
+// GetReflectChance ~3425–3431; auras REFLECT_SPELLS 28 and REFLECT_SPELLS_SCHOOL 74. Pure.
+
+export const SPELL_DAMAGE_CLASS_MAGIC = 1; // classic DmgClass MAGIC (not melee/ranged)
+
+// IsReflectableSpell (SpellMgr.h). Magic, not ability, not NO_REFLECTION / NO_IMMUNITIES / PASSIVE, not
+// positive.
+export function isReflectableSpell(opts: {
+  dmgClass: number;
+  isAbility?: boolean;
+  noReflection?: boolean;
+  noImmunities?: boolean;
+  passive?: boolean;
+  positive?: boolean;
+}): boolean {
+  return (
+    opts.dmgClass === SPELL_DAMAGE_CLASS_MAGIC &&
+    !opts.isAbility &&
+    !opts.noReflection &&
+    !opts.noImmunities &&
+    !opts.passive &&
+    !opts.positive
+  );
+}
+
+// GetReflectChance (Unit.cpp ~3425). chance += REFLECT_SPELLS + REFLECT_SPELLS_SCHOOL (misc mask match).
+export function getReflectChance(
+  reflectSpellsPct: number,
+  reflectSchoolPct: number,
+): number {
+  return Math.max(0, reflectSpellsPct + reflectSchoolPct);
+}
+
+// Roll reflect: true when the spell is reflectable and the injected [0,1) roll lands under the
+// chance.
+export function rollSpellReflect(
+  reflectable: boolean,
+  chancePct: number,
+  roll01: number,
+): boolean {
+  if (!reflectable || chancePct <= 0) return false;
+  return roll01 * 100 < chancePct;
+}

package/src/domain/spells/stealth.ts

@@ -0,0 +1,183 @@
+// Stealth strength, detect range and the Phonecraft positional proxy. The behind and front geometry
+// is Classic; canUseBehindAbility is an explicit product proxy, not a DBC formula.
+
+import type { SpellDef } from '../../data/schema.ts';
+import { SHAPESHIFT_FORM } from '../../data/schema.ts';
+
+/** Cite: Unit.h MAX_PLAYER_STEALTH_DETECT_RANGE */
+export const MAX_PLAYER_STEALTH_DETECT_RANGE = 45;
+
+/** Aura interrupt bits (SpellDefines.h:362–386 AURA_INTERRUPT_FLAG_*). */
+export const AURA_INTERRUPT = {
+  HOSTILE_ACTION: 0x00000001,
+  DAMAGE: 0x00000002,
+  ACTION: 0x00000004,
+  MOVING: 0x00000008,
+  TURNING: 0x00000010,
+  ANIM_CANCELS: 0x00000020,
+  DISMOUNT: 0x00000040,
+  UNDERWATER_CANCELS: 0x00000080,
+  ABOVEWATER_CANCELS: 0x00000100,
+  SHEATHING_CANCELS: 0x00000200,
+  INTERACTING: 0x00000400,
+  LOOTING: 0x00000800,
+  ATTACKING: 0x00001000,
+  ITEM_USE: 0x00002000,
+  DAMAGE_CHANNEL_DURATION: 0x00004000,
+  SHAPESHIFTING: 0x00008000,
+  ACTION_LATE: 0x00010000,
+  MOUNTING: 0x00020000,
+  STANDING_CANCELS: 0x00040000,
+  LEAVE_WORLD: 0x00080000,
+  STEALTH_INVIS_CANCELS: 0x00100000,
+  INVULNERABILITY_BUFF_CANCELS: 0x00200000,
+  ENTER_WORLD: 0x00400000,
+  PVP_ACTIVE_CANCELS: 0x00800000,
+  NON_PERIODIC_DAMAGE: 0x01000000,
+} as const;
+
+// Stealth visibility distance in yards, from GetStealthVisibilityDistance. The alert argument is the
+// STEALTHER's player-controlled flag, so a player sneak is seen further out. Reach is the floor.
+export function stealthVisibilityDistance(
+  detectorLevel: number,
+  stealthStrength: number,
+  detectStrength = 0,
+  detectorIsPlayer = false,
+  alert = false,
+  detectorCombatReachYd = 0,
+): number {
+  let detectionValue = 30;
+  detectionValue += (Math.max(1, detectorLevel) - 1) * 5;
+  detectionValue += detectStrength;
+  detectionValue -= stealthStrength;
+  let visibilityRange = detectionValue * 0.3;
+  if (detectorIsPlayer && visibilityRange > MAX_PLAYER_STEALTH_DETECT_RANGE) {
+    visibilityRange = MAX_PLAYER_STEALTH_DETECT_RANGE;
+  }
+  if (alert) {
+    visibilityRange += visibilityRange * 0.08 + 1.5;
+  }
+  return Math.max(Math.max(0, detectorCombatReachYd), visibilityRange);
+}
+
+// Whether the detector sees the stealther at the given distance. Does not model LOS / facing cone (those
+// need world geometry).
+export function isDetectedAtDistance(
+  distanceYd: number,
+  detectorLevel: number,
+  stealthStrength: number,
+  detectStrength = 0,
+  detectorIsPlayer = false,
+): boolean {
+  const range = stealthVisibilityDistance(
+    detectorLevel, stealthStrength, detectStrength, detectorIsPlayer, false,
+  );
+  return distanceYd <= range;
+}
+
+/** Cite: Player.cpp:1546 `m_DetectInvTimer = GetMap()->IsBattleGround() ? 500 : 2000`. */
+export const STEALTH_DETECT_INTERVAL_MS = 2000;
+export const STEALTH_DETECT_INTERVAL_BG_MS = 500;
+
+/** A player's own combat reach, the floor on what it can see inside. Cite: Level3.cpp:4420. */
+export const PLAYER_COMBAT_REACH_YD = 1.5;
+
+/** How often a detector re-runs its stealth sweep. A battleground sweeps 4x as often. */
+export function stealthDetectIntervalMs(isBattleground: boolean): number {
+  return isBattleground ? STEALTH_DETECT_INTERVAL_BG_MS : STEALTH_DETECT_INTERVAL_MS;
+}
+
+// The IsVisibleForOrDetect stealth branch, in the order the core tests it. Geometry comes from the
+// caller, and `undefined` means this session has no geometry — which passes, as it always has.
+export function detectsStealth(opts: {
+  distanceYd?: number;
+  detectorLevel: number;
+  detectorAlive?: boolean;
+  detectorStunned?: boolean;
+  detectorIsPlayer?: boolean;
+  detectorCombatReachYd?: number;
+  stealthStrength: number;
+  detectStrength?: number;
+  /** UNIT_FLAG_PLAYER_CONTROLLED on the stealther — the core's `alert` arg at Unit.cpp:8265. */
+  stealtherPlayerControlled?: boolean;
+  /** The stealther already has attackers: stealth is lost whatever the geometry says. */
+  stealtherAttacked?: boolean;
+  /** `viewPoint->isInFrontInMap` — the stealther is in the detector's front half. */
+  inFrontArc?: boolean;
+  /** `IsWithinLOS` from the detector's view point. */
+  lineOfSight?: boolean;
+}): boolean {
+  // A dead detector detects nothing (Unit.cpp:8143 clears `detect` when !IsAlive).
+  if (opts.detectorAlive === false) return false;
+  // "If is attacked then stealth is lost, some creature can use stealth too".
+  if (opts.stealtherAttacked) return true;
+  // "If a mob or player is stunned he will not be able to detect stealth".
+  if (opts.detectorStunned) return false;
+  // "Always invisible from back (when stealth detection is on)".
+  if (opts.inFrontArc === false) return false;
+  if (opts.distanceYd != null) {
+    const range = stealthVisibilityDistance(
+      opts.detectorLevel,
+      opts.stealthStrength,
+      opts.detectStrength ?? 0,
+      opts.detectorIsPlayer ?? false,
+      opts.stealtherPlayerControlled ?? false,
+      opts.detectorCombatReachYd ?? 0,
+    );
+    if (range <= 0 || opts.distanceYd > range) return false;
+  }
+  if (opts.lineOfSight === false) return false;
+  return true;
+}
+
+// Phonecraft positional proxy for requiresBehind, NOT a CMaNGOS formula: true while the caster is
+// stealthed, while the target is hard-CC'd, or while the target has aggro on somebody else.
+export function canUseBehindAbility(opts: {
+  casterStealthed: boolean;
+  targetStunned: boolean;
+  targetIncapacitated: boolean;
+  /** When true, mob is facing this attacker (solo combat default once engaged). */
+  targetHasAggroOnCaster: boolean;
+}): boolean {
+  if (opts.casterStealthed) return true;
+  if (opts.targetStunned || opts.targetIncapacitated) return true;
+  if (!opts.targetHasAggroOnCaster) return true;
+  return false;
+}
+
+/** Front-facing proxy for Gouge: not stealthed-behind-only; require target facing you / not hard-CC. */
+export function canUseFrontAbility(opts: {
+  targetStunned: boolean;
+  targetIncapacitated: boolean;
+}): boolean {
+  // While the target is already incapacitated, facing is moot, so allow the re-Gouge edge cases. When
+  // free, assume frontal engagement — in non-spatial combat the solo player faces the mob.
+  void opts;
+  return true;
+}
+
+export function isStealthSpell(spell: SpellDef): boolean {
+  return spell.role === 'stealth' || spell.effects.some((e) => e.kind === 'stealth');
+}
+
+// SPELL_ATTR_CANCELS_AUTO_ATTACK_COMBAT means AttackStop after a successful cast. Prefer the baked
+// flag; when it is missing, Gouge and Sap still cancel, since white swings self-break the CC.
+export function spellCancelsAutoAttack(spell: SpellDef): boolean {
+  if (spell.cancelsAutoAttack) return true;
+  return (spell.effects ?? []).some(
+    (e) =>
+      e.kind === 'cc'
+      && e.control === 'incapacitate'
+      && e.breakOnDamage === true
+      && e.mechanic === 'sap',
+  );
+}
+
+export function isStealthForm(form: number): boolean {
+  return form === SHAPESHIFT_FORM.STEALTH;
+}
+
+/** Total stealth strength from an active stealth effect + passive level bonus. */
+export function totalStealthStrength(activeStrength: number, levelBonus: number): number {
+  return Math.max(0, (activeStrength | 0) + (levelBonus | 0));
+}

package/src/domain/spells/totem.ts

@@ -0,0 +1,394 @@
+// Pure totem helpers — parallel to domain/pet/pet.ts. Build fight-scoped totem combatants from
+// summon_totem effects (with optional baked ability kits). No DOM/RNG/Date.
+
+import type { SpellDef, SpellEffect, TotemSlot, TotemAbilityDef } from '../../data/schema.ts';
+import type { CombatantSpec } from '../../engine/combat.ts';
+import { sideForTotemSlot, type Side, type TotemSide } from '../../engine/core/events.ts';
+import { TUNING } from '../../engine/combat/formulas.ts';
+import { resolveCombatSpell } from '../../engine/spells/interpreter/item-triggers.ts';
+
+export type { TotemSlot };
+
+export const TOTEM_SLOTS: readonly TotemSlot[] = ['fire', 'earth', 'water', 'air'] as const;
+
+// Numeric indices for rotation `totemPresent` ref (CMaNGOS TotemSlot: FIRE=0 … AIR=3). Wave 1D — condition
+// "slot empty" uses ref = index, value 0/1 for occupied.
+export const TOTEM_SLOT_INDEX: Readonly<Record<TotemSlot, number>> = {
+  fire: 0,
+  earth: 1,
+  water: 2,
+  air: 3,
+} as const;
+
+export function totemSlotIndex(slot: TotemSlot): number {
+  return TOTEM_SLOT_INDEX[slot];
+}
+
+export function totemSlotFromIndex(index: number): TotemSlot | null {
+  const i = index | 0;
+  if (i === 0) return 'fire';
+  if (i === 1) return 'earth';
+  if (i === 2) return 'water';
+  if (i === 3) return 'air';
+  return null;
+}
+
+/** Effect-id → slot mapping (CMaNGOS SharedDefines / SpellEffects.cpp EffectSummonTotem). */
+export function slotFromSummonEffectId(eff: number): TotemSlot | 'none' | null {
+  if (eff === 87) return 'fire';
+  if (eff === 88) return 'earth';
+  if (eff === 89) return 'water';
+  if (eff === 90) return 'air';
+  if (eff === 74) return 'none';
+  return null;
+}
+
+export function totemSide(slot: TotemSlot, owner: Side = 'player'): TotemSide {
+  return sideForTotemSlot(slot, owner);
+}
+
+// CMaNGOS Totem::SetTypeBySummonSpell: if the totem's main spell has cast time → ACTIVE, else PASSIVE.
+// Cite: Entities/Totem.cpp SetTypeBySummonSpell.
+export function totemTypeFromAbility(ability: { castTimeMs: number } | undefined): 'active' | 'passive' {
+  if (ability && (ability.castTimeMs | 0) > 0) return 'active';
+  return 'passive';
+}
+
+/** Convert a baked TotemAbilityDef into a SpellDef the engine can cast. */
+export function abilityToSpell(a: TotemAbilityDef): SpellDef {
+  // Optional spellMagnet on kit rows (fixtures / future enrich) — type-narrow, not schema widen.
+  const magnet = (a as TotemAbilityDef & { spellMagnet?: boolean }).spellMagnet === true;
+  return {
+    id: a.id,
+    name: a.name,
+    rank: 0,
+    school: a.school,
+    powerType: 'mana',
+    cost: 0,
+    castTimeMs: a.castTimeMs,
+    cooldownMs: a.cooldownMs,
+    gcdMs: a.gcdMs,
+    rangeMax: 30,
+    reqLevel: 1,
+    effects: a.effects,
+    // Friendly-area radius (SpellRadius.dbc) — combat filters the totem's party
+    // reach by this, scaled through SPELLMOD_RADIUS on the owner.
+    ...(a.radiusYd != null && a.radiusYd > 0 ? { radiusYd: a.radiusYd } : {}),
+    ...(magnet ? { spellMagnet: true as const } : {}),
+  };
+}
+
+// True when a creature kit spell is a WEAPON-PROC endpoint rather than a standing party aura. The DB
+// lists Windfury's proc next to the metronome, and treating it as a kit aura grants a permanent +AP.
+export function isWeaponProcTotemPayload(
+  abil: { effects?: readonly { kind: string }[] } | null | undefined,
+): boolean {
+  return !!abil?.effects?.some((e) => e.kind === 'extra_attacks');
+}
+
+/** Drop swing-proc endpoints from summon-time abilities (keep them on triggerAbilities only). */
+export function filterTotemSummonAbilities<T extends { effects?: readonly { kind: string }[] }>(
+  abilities: readonly T[],
+): T[] {
+  return abilities.filter((a) => !isWeaponProcTotemPayload(a));
+}
+
+// Lookup used to attach creature_template_spells kits onto summon_totem effects when the live bake
+// lacks the embedded abilities. Cite: Totem.cpp Summon CastSpell from m_spellList.
+export interface TotemKitLookup {
+  creature: (entry: number) => { name?: string; spells?: readonly number[]; charmSpells?: readonly number[] } | undefined;
+  spell: (id: number) => SpellDef | undefined;
+  // SpellItemEnchantment type-1 payload for an ENCHANT_HELD_ITEM effect — Windfury and Flametongue
+  // Totem are nothing but this. Optional, so an older bake simply leaves those two inert.
+  weaponEnchantProc?: (enchantId: number) => { spellId: number; chancePct?: number; durationMs: number } | undefined;
+}
+
+// Map a totem-creature ability spell into a TotemAbilityDef. Empty bake effects on a periodic-trigger
+// holder chase their triggerSpell one hop to the real kit payload.
+export function slimTotemAbilityFromSpell(
+  s: SpellDef,
+  spellLookup: (id: number) => SpellDef | undefined,
+  enchantLookup?: (enchantId: number) => { spellId: number; chancePct?: number; durationMs: number } | undefined,
+): TotemAbilityDef {
+  const resolved = resolveCombatSpell(s);
+  let effects: SpellEffect[] = (resolved.effects ?? []).map((e) => ({ ...e }));
+  // The interpreter now materializes ENCHANT_HELD_ITEM as a first-class effect. Totem plumbing
+  // consumes the weapon PROC it stands for, so convert it here or the kit rows go hollow.
+  effects = effects.map((e) => {
+    // 'enchant_held_item' is interpreter-emitted and not (yet) in the SpellEffect union.
+    if ((e as { kind: string }).kind !== 'enchant_held_item') return e;
+    const enchantId = (e as { enchantId?: number }).enchantId ?? 0;
+    const payload = enchantId > 0 ? enchantLookup?.(enchantId) : undefined;
+    if (!payload) return e;
+    return {
+      kind: 'proc_trigger_spell',
+      triggerSpellId: payload.spellId,
+      durationMs: payload.durationMs || (e as { durationMs?: number }).durationMs || 10_000,
+      ...(payload.chancePct != null ? { amount: payload.chancePct } : {}),
+    } as SpellEffect;
+  });
+  if (effects.length === 0) {
+    // ENCHANT_HELD_ITEM: the payload is a temporary main-hand enchant whose type-1 row names the
+    // spell it procs. It carries the enchant's own duration and OUTLIVES the totem — that is twisting.
+    for (const r of s.rawEffects ?? []) {
+      if ((r.effect | 0) !== 92) continue;
+      const enchantId = r.miscValue | 0;
+      const payload = enchantId > 0 ? enchantLookup?.(enchantId) : undefined;
+      if (!payload) continue;
+      effects.push({
+        kind: 'proc_trigger_spell',
+        triggerSpellId: payload.spellId,
+        durationMs: payload.durationMs,
+        ...(payload.chancePct != null ? { amount: payload.chancePct } : {}),
+      });
+    }
+  }
+  if (effects.length === 0) {
+    for (const r of s.rawEffects ?? []) {
+      const trig = (r.triggerSpell | 0);
+      if (trig <= 0) continue;
+      const tr = spellLookup(trig);
+      if (!tr) continue;
+      const trResolved = resolveCombatSpell(tr);
+      for (const e of trResolved.effects ?? []) effects.push({ ...e });
+    }
+  }
+  // Radius stays with the kit spell that owns the area effect, but a periodic-trigger holder owns
+  // none, so take the same one hop the effects take. Measured 4 to 9 of 11 totems resolving a radius.
+  let radiusYd = s.radiusYd != null && s.radiusYd > 0 ? s.radiusYd : undefined;
+  if (radiusYd == null) {
+    for (const r of s.rawEffects ?? []) {
+      const trig = r.triggerSpell | 0;
+      if (trig <= 0) continue;
+      const tr = spellLookup(trig);
+      if (tr?.radiusYd != null && tr.radiusYd > 0) { radiusYd = tr.radiusYd; break; }
+    }
+  }
+  return {
+    id: s.id,
+    name: s.name,
+    castTimeMs: s.castTimeMs | 0,
+    cooldownMs: s.cooldownMs | 0,
+    gcdMs: s.gcdMs | 0,
+    school: s.school || 'physical',
+    effects,
+    ...(radiusYd != null ? { radiusYd } : {}),
+  };
+}
+
+// Attach creature ability kits onto summon_totem effects that lack them, idempotently. This is what
+// lets the pure combat engine pulse party auras without a DataStore at cast time.
+export function attachTotemKits(spell: SpellDef, lookup: TotemKitLookup): SpellDef {
+  if (!(spell.effects ?? []).some((e) => e.kind === 'summon_totem')) return spell;
+  let changed = false;
+  const effects = spell.effects.map((e) => {
+    if (e.kind !== 'summon_totem') return e;
+    if (e.abilities && e.abilities.length > 0) {
+      // Kits already baked, but a bake predating trigger abilities carries none — fill them in rather
+      // than leaving every cleanser and Windfury totem inert. Swing-proc endpoints are always stripped.
+      const cleaned = filterTotemSummonAbilities(e.abilities);
+      const abilitiesChanged = cleaned.length !== e.abilities.length;
+      if (e.triggerAbilities && e.triggerAbilities.length > 0) {
+        if (!abilitiesChanged) return e;
+        changed = true;
+        return { ...e, abilities: cleaned };
+      }
+      // resolveTriggerAbilities must see the full kit (incl. 8516 when present on creature
+      // list) so enchant→proc endpoints still materialize — then abilities drops them.
+      const trigs = resolveTriggerAbilities(e.abilities, lookup.spell, lookup.weaponEnchantProc);
+      if (!trigs.length && !abilitiesChanged) return e;
+      changed = true;
+      return {
+        ...e,
+        abilities: cleaned,
+        ...(trigs.length ? { triggerAbilities: trigs } : {}),
+      };
+    }
+    const creature = e.creature | 0;
+    if (!creature) return e;
+    const cdef = lookup.creature(creature);
+    // Totem::Summon walks m_spellList and casts EVERY row, never reading the Disabled flag only the AI
+    // checks. Reading `spells` alone left 91 of 99 totem creatures hollow — charmSpells is the fallback.
+    const abilIds = cdef?.spells?.length ? cdef.spells : (cdef?.charmSpells ?? []);
+    if (!abilIds.length) return e;
+    const rawAbilities: TotemAbilityDef[] = [];
+    for (const id of abilIds) {
+      const ab = lookup.spell(id);
+      if (ab) rawAbilities.push(slimTotemAbilityFromSpell(ab, lookup.spell, lookup.weaponEnchantProc));
+    }
+    if (!rawAbilities.length) return e;
+    changed = true;
+    // Trigger chain first (needs 8516 on the raw list for endpoint carry), then strip
+    // summon-time abilities so combat never applies +AP as a party aura.
+    const triggerAbilities = resolveTriggerAbilities(rawAbilities, lookup.spell, lookup.weaponEnchantProc);
+    const abilities = filterTotemSummonAbilities(rawAbilities);
+    return {
+      ...e,
+      name: e.name || cdef?.name || spell.name,
+      abilities,
+      ...(triggerAbilities.length ? { triggerAbilities } : {}),
+    };
+  });
+  if (!changed) return spell;
+  return { ...spell, effects };
+}
+
+// Resolve the payload spell behind every kit proc_trigger_spell: the kit spell is only the metronome,
+// and the triggered one is where the real effect lives. Resolving here keeps combat DataStore-free.
+function resolveTriggerAbilities(
+  abilities: readonly TotemAbilityDef[],
+  spellLookup: (id: number) => SpellDef | undefined,
+  enchantLookup?: (enchantId: number) => { spellId: number; chancePct?: number; durationMs: number } | undefined,
+): TotemAbilityDef[] {
+  const out: TotemAbilityDef[] = [];
+  const seen = new Set<number>();
+  for (const a of abilities) {
+    for (const e of a.effects) {
+      if (e.kind !== 'proc_trigger_spell') continue;
+      const id = e.triggerSpellId | 0;
+      if (id <= 0 || seen.has(id)) continue;
+      seen.add(id);
+      const trig = spellLookup(id);
+      if (!trig) continue;
+      const slim = slimTotemAbilityFromSpell(trig, spellLookup, enchantLookup);
+      if (!slim.effects.length) continue; // nothing resolvable — do not carry a hollow row
+      out.push(slim);
+      // A weapon-enchant payload procs a further spell (1783 → 8516). Carry that too so the
+      // party fighter can resolve the proc when it fires.
+      for (const se of slim.effects) {
+        if (se.kind !== 'proc_trigger_spell') continue;
+        const procId = se.triggerSpellId | 0;
+        if (procId <= 0 || seen.has(procId)) continue;
+        seen.add(procId);
+        const procSpell = spellLookup(procId);
+        if (!procSpell) continue;
+        const procSlim = slimTotemAbilityFromSpell(procSpell, spellLookup, enchantLookup);
+        if (procSlim.effects.length) out.push(procSlim);
+      }
+    }
+  }
+  return out;
+}
+
+export interface TotemSummonEffect {
+  kind: 'summon_totem';
+  slot: TotemSlot | 'none';
+  creature: number;
+  health: number;
+  durationMs: number;
+  name?: string;
+  abilities?: TotemAbilityDef[];
+  triggerAbilities?: TotemAbilityDef[];
+}
+
+export interface BuiltTotem {
+  slot: TotemSlot;
+  side: TotemSide;
+  summonSpellId: number;
+  creature: number;
+  name: string;
+  maxHp: number;
+  durationMs: number;
+  type: 'active' | 'passive';
+  /** All ability spells (active casts and/or passive aura sources). */
+  abilities: SpellDef[];
+  // `Totem::GetSpell()` — first kit spell id, the only aura UnSummon strips. Cite: Entities/Totem.cpp
+  // GetSpell() :169–174; UnSummon RemoveAurasDueToSpell :131–158.
+  kitSpellId: number;
+  /** Payloads fired by the aura-23 pulse schedule (never applied at summon time). */
+  triggerSpells: SpellDef[];
+  /** Widest SpellRadius yards over the whole kit — the ground this totem covers. 0 = none baked. */
+  auraRadiusYd: number;
+  spec: CombatantSpec;
+}
+
+/** Offensive kit effects that deal damage (Searing Attack, Fire Nova, Magma pulse). */
+export function isOffensiveTotemAbility(s: SpellDef): boolean {
+  return s.effects.some((e) => e.kind === 'direct_damage' || e.kind === 'dot');
+}
+
+// Build a fight-scoped totem from a summon_totem effect. Uses baked `abilities`/`name` when present
+// (enrich-totems); returns null only when slot is 'none' or health is invalid.
+export function buildTotemFromEffect(
+  eff: TotemSummonEffect,
+  summonSpellId: number,
+  ownerLevel: number,
+  ownerCritChance?: number,
+  ownerHitChance?: number,
+  summonSpellName?: string,
+  ownerSide: Side = 'player',
+): BuiltTotem | null {
+  if (eff.slot === 'none') return null;
+  const slot = eff.slot;
+  // Strip Windfury-class swing-proc endpoints even if a bake still lists them on abilities.
+  // They must only resolve via triggerAbilities → party weapon enchant → swing proc.
+  const abilities = filterTotemSummonAbilities(eff.abilities ?? []).map(abilityToSpell);
+  const main = abilities[0];
+  // CMaNGOS Totem::SetTypeBySummonSpell: castTime > 0 → TOTEM_ACTIVE (TotemAI cast loop).
+  // Fire Nova 8443 bakes castTimeMs 0 → passive; Magma Passive same. Active = Searing Attack etc.
+  const type = totemTypeFromAbility(main);
+  const maxHp = Math.max(1, eff.health | 0);
+  // Active totems carry the TotemAI combat spells; passive kits cast once on summon. Magnet carriers
+  // stay on the fighter either way, so a passive Grounding still works.
+  const combatSpells = type === 'active' ? abilities.filter(isOffensiveTotemAbility) : [];
+  const MAGNET_KIT_IDS = new Set([8178, 8179]);
+  const magnetCarriers = abilities.filter(
+    (s) => s.spellMagnet === true || MAGNET_KIT_IDS.has(s.id),
+  );
+  const spells = [...combatSpells];
+  for (const ab of magnetCarriers) {
+    if (!spells.some((s) => s.id === ab.id)) spells.push(ab);
+  }
+  const name = eff.name || summonSpellName || 'Totem';
+  const triggerSpells = (eff.triggerAbilities ?? []).map(abilityToSpell);
+  const spec: CombatantSpec = {
+    name,
+    level: ownerLevel,
+    maxHealth: maxHp,
+    startHealth: maxHp,
+    powerType: 'mana',
+    maxPower: 0,
+    startPower: 0,
+    armor: 0,
+    weapon: { dmgMin: 0, dmgMax: 0, speedMs: 60_000, school: 'physical' },
+    attackPower: 0,
+    // Crit/hit delegate to owner (CMaNGOS Totem.cpp GetCritChance).
+    critChance: ownerCritChance ?? TUNING.baseCritChance,
+    hitChance: ownerHitChance ?? TUNING.meleeHitChance,
+    haste: 0,
+    canParry: false,
+    canBlock: false,
+    creatureType: 11, // CREATURE_TYPE totem
+    spells,
+  };
+  return {
+    slot,
+    side: totemSide(slot, ownerSide),
+    summonSpellId,
+    creature: eff.creature,
+    name,
+    maxHp,
+    durationMs: Math.max(0, eff.durationMs | 0),
+    type,
+    abilities,
+    // GetSpell() is m_spellList.Spells.begin() — the FIRST kit spell, not every kit spell.
+    kitSpellId: abilities.length ? abilities[0]!.id : 0,
+    triggerSpells,
+    auraRadiusYd: [...abilities, ...triggerSpells]
+      .reduce((m, s) => Math.max(m, s.radiusYd ?? 0), 0),
+    spec,
+  };
+}
+
+/** True when a spell is a totem summon (role or effect). */
+export function isTotemSummonSpell(s: SpellDef): boolean {
+  if (s.role === 'totem_summon') return true;
+  return s.effects.some((e) => e.kind === 'summon_totem');
+}
+
+/** Slot occupied by this summon spell, or null if not a totem summon. */
+export function totemSlotOfSpell(s: SpellDef): TotemSlot | 'none' | null {
+  const eff = s.effects.find((e) => e.kind === 'summon_totem');
+  if (!eff || eff.kind !== 'summon_totem') return null;
+  return eff.slot;
+}