azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/spells/interpreter/warrior-druid-kit.ts

@@ -0,0 +1,314 @@
+// Warrior and druid kit materialization at the play surface: the intents the mapper left empty, folded
+// into engine-consumable effects without inventing numbers.
+
+import type { ControlKind, SpellDef, SpellEffect } from '../../../data/schema.ts';
+import type { InterpretResult } from './types.ts';
+import { effectBaseAmount } from './registry/helpers.ts';
+import { durMs as durFromIndex } from './duration.ts';
+
+// ── SharedDefines Mechanics (subset) ─────────────────────────────────────────
+// Cite: SharedDefines.h Mechanics; EffectDispelMechanic miscValue.
+const MECHANIC_ROOT = 7;
+const MECHANIC_SNARE = 11;
+const MECHANIC_FEAR = 5;
+const MECHANIC_SLEEP = 10;
+const MECHANIC_CHARM = 1;
+const MECHANIC_STUN = 12;
+const MECHANIC_SILENCE = 9;
+const MECHANIC_DISARM = 3;
+
+// Map a mechanic id to a control kind for a cleanse. Root and snare are distinct — Escape Artist has a
+// dispel row for each. Cite: SharedDefines.h MECHANIC_ROOT and SNARE; Spell.sql 20589.
+function mechanicToControl(mechanic: number): ControlKind | null {
+  switch (mechanic) {
+    case MECHANIC_ROOT:
+      return 'root';
+    case MECHANIC_SNARE:
+      return 'snare';
+    case MECHANIC_FEAR:
+      return 'fear';
+    case MECHANIC_SLEEP:
+      return 'incapacitate';
+    case MECHANIC_CHARM:
+      return 'charm';
+    case MECHANIC_STUN:
+      return 'stun';
+    case MECHANIC_SILENCE:
+      return 'silence';
+    case MECHANIC_DISARM:
+      return 'disarm';
+    default:
+      return null;
+  }
+}
+
+// The warrior Execute family flag.
+// Cite: Spell.sql SpellFamilyFlags on 5308 and 20658-20662.
+export const EXECUTE_FAMILY_FLAGS = 0x20000000;
+export const SPELLFAMILY_WARRIOR = 4;
+
+// Execute rank → DmgMultiplier1 (rage stored * mult). Rage is stored *10 in CMaNGOS; display rage R →
+// damage += (R*10)*mult. Cite: Spell.sql DmgMultiplier1; Warrior.cpp:26–28.
+export const EXECUTE_DMG_MULTIPLIER: Readonly<Record<number, number>> = {
+  5308: 0.3,
+  20658: 0.6,
+  20660: 0.9,
+  20661: 1.2,
+  20662: 1.5,
+};
+
+/** Damage carrier cast by WarriorExecute. Cite: Warrior.cpp:28 CastCustomSpell(20647). */
+export const EXECUTE_DAMAGE_SPELL_ID = 20647;
+
+// True for the castable Execute ranks that materialize direct damage — not the empty intermediate and
+// not the damage-carrier script spell. Cite: Warrior.cpp:22-29 WarriorExecute.
+export function isWarriorExecuteSpell(spell: { id?: number } | null | undefined): boolean {
+  const id = (spell?.id ?? 0) | 0;
+  return EXECUTE_DMG_MULTIPLIER[id] != null;
+}
+
+// Execute's rage-to-damage: the effect value plus current rage times the damage multiplier. The C++
+// stores rage ten times larger than the display units this engine uses. Cite: Warrior.cpp:26-28.
+export function executeDamageAmount(
+  baseAmount: number,
+  rageDisplay: number,
+  dmgMultiplier: number,
+): number {
+  const storedRage = Math.max(0, Math.trunc(rageDisplay)) * 10;
+  return Math.max(0, Math.trunc(baseAmount + storedRage * dmgMultiplier));
+}
+
+// ── Retaliation ──────────────────────────────────────────────────────────────
+/** Retaliation self-buff. Cite: Spell.sql 20230; UnitAuraProcHandler.cpp:844. */
+export const RETALIATION_SPELL_ID = 20230;
+// Counterattack payload (WEAPON_DAMAGE_NOSCHOOL). Cite: UnitAuraProcHandler.cpp:850 triggered_spell_id =
+// 22858 (Warrior.cpp RetaliationWarrior uses 20240 — not in bake; 22858 is the DBC trigger).
+export const RETALIATION_DAMAGE_SPELL_ID = 22858;
+/** ProcCharges from Spell.sql 20230. */
+export const RETALIATION_PROC_CHARGES = 30;
+
+// The Frenzied Regeneration ranks, whose periodic trigger id is 0 and whose tick is scripted.
+// Cite: SpellAuras.cpp:1104-1116; Spell.sql 22842, 22895, 22896.
+export const FRENZIED_REGEN_SPELL_IDS = new Set([22842, 22895, 22896]);
+/** Heal carrier. Cite: SpellAuras.cpp:1115 CastCustomSpell(22845). */
+export const FRENZIED_REGEN_HEAL_SPELL_ID = 22845;
+/** Max rage (stored) converted per tick. Cite: SpellAuras.cpp:1111–1112. */
+export const FRENZIED_REGEN_MAX_STORED_RAGE = 100;
+
+// The Frenzied Regeneration tick: heal from the rage spent, at the life-per-rage rate, converting from
+// the C++'s ten-times-larger storage. Cite: SpellAuras.cpp:1108-1115.
+export function frenziedRegenTick(
+  lifePerRage: number,
+  displayRage: number,
+): { heal: number; displayRageSpent: number } {
+  const stored = Math.min(
+    Math.max(0, Math.trunc(displayRage)) * 10,
+    FRENZIED_REGEN_MAX_STORED_RAGE,
+  );
+  const heal = Math.max(0, Math.trunc((stored * lifePerRage) / 10));
+  const displayRageSpent = stored / 10;
+  return { heal, displayRageSpent };
+}
+
+// The life-per-rage rate recovered from the baked maximum tick, which is ten times it.
+// Cite: SpellAuras.cpp:1108.
+export function frenziedRegenLifePerRage(amountPerTick: number): number {
+  return Math.max(1, Math.trunc(amountPerTick / 10));
+}
+
+// ── Barkskin ─────────────────────────────────────────────────────────────────
+/** Barkskin castable. Cite: Spell.sql 22812. */
+export const BARKSKIN_SPELL_ID = 22812;
+// The Barkskin effect companion, which carries the real auras the tooltip references: -25% melee haste
+// and -20% physical damage taken. Cite: Spell.sql 22839.
+export const BARKSKIN_EFFECT_SPELL_ID = 22839;
+/** Sourced amounts from rawEffects on 22839 (bp+die). */
+export const BARKSKIN_HASTE_AMOUNT = -25;
+export const BARKSKIN_PHYSICAL_TAKEN_AMOUNT = -20;
+
+// Materialize Warrior/Druid play-surface effects from interpret intents + spell id specials. Mutates
+// nothing on `spell`; returns a new effects array (may equal input when nothing to add).
+export function materializeWarriorDruidKitEffects(
+  spell: SpellDef,
+  result: InterpretResult,
+  effectsIn: SpellEffect[],
+): SpellEffect[] {
+  let effects = effectsIn.slice();
+  const id = spell.id | 0;
+  const intents = result.intents ?? [];
+
+  // ── intent → effect bridges (SI3 intents-only auras) ─────────────────────
+  const cleanseControls = new Set<ControlKind>();
+  // immuneMs from MECHANIC_IMMUNITY duration (WotF 5s). Cite: Spell.sql DurationIndex 28 → 5s.
+  let cleanseImmuneMs = 0;
+  for (const intent of intents) {
+    if (intent.kind === 'mod_block_percent') {
+      // Cite: SpellAuras.cpp:3789–3800 HandleAuraModBlockPercent; BuffMod parry/dodge pattern.
+      if (!effects.some((e) => e.kind === 'buff' && e.mod === 'block')) {
+        effects.push({
+          kind: 'buff',
+          mod: 'block',
+          amount: intent.amount,
+          durationMs: intent.durationMs,
+        });
+      }
+    } else if (intent.kind === 'dispel_mechanic') {
+      const c = mechanicToControl(intent.mechanic);
+      if (c) cleanseControls.add(c);
+    }
+  }
+  // A mechanic immunity for charm, fear or sleep is the real breaker shape, but the interpretation
+  // drops the seed cleanse, so the racial greys out under fear. Re-materialize it for that set only.
+  const hasCharmCc = effects.some(
+    (e) =>
+      e.kind === 'cc'
+      && ((e as { mechanic?: string }).mechanic === 'charm'
+        || (e as { control?: string }).control === 'charm'),
+  );
+  const BREAKER_IMMUNITY_MECHANICS = new Set([MECHANIC_CHARM, MECHANIC_FEAR, MECHANIC_SLEEP]);
+  for (const e of effects) {
+    if (hasCharmCc) break;
+    if (e.kind !== 'mechanic_immunity') continue;
+    if (!BREAKER_IMMUNITY_MECHANICS.has(e.mechanic | 0)) continue;
+    const c = mechanicToControl(e.mechanic | 0);
+    if (c) cleanseControls.add(c);
+    const dur = e.durationMs | 0;
+    if (dur > cleanseImmuneMs) cleanseImmuneMs = dur;
+  }
+  if (cleanseControls.size > 0) {
+    // UNION into an existing cleanse rather than skipping when one is present: the bake row for the
+    // racial carries only fear and incapacitate, and whichever ran first used to win.
+    const existing = effects.find((e) => e.kind === 'cleanse');
+    if (existing && existing.kind === 'cleanse') {
+      for (const c of existing.controls ?? []) cleanseControls.add(c);
+      existing.controls = [...cleanseControls];
+      const prev = existing.immuneMs ?? 0;
+      const next = Math.max(prev, cleanseImmuneMs);
+      if (next > 0) existing.immuneMs = next;
+    } else {
+      const cleanse: SpellEffect = cleanseImmuneMs > 0
+        ? { kind: 'cleanse', controls: [...cleanseControls], immuneMs: cleanseImmuneMs }
+        : { kind: 'cleanse', controls: [...cleanseControls] };
+      effects.push(cleanse);
+    }
+  }
+
+  // ── Retaliation 20230: DUMMY aura → take-melee proc → 22858 weapon swing ──
+  // Cite: UnitAuraProcHandler.cpp:843–851; Spell.sql ProcCharges=30 DurationIndex=8.
+  if (id === RETALIATION_SPELL_ID && !effects.some((e) => e.kind === 'proc_trigger_spell')) {
+    // DurationIndex 8 → 15_000 ms. Cite: duration.ts FALLBACK_DURATION_MS; Spell.sql.
+    const durationMs = durFromIndex(spell.durationIndex) ?? 15_000;
+    effects.push({
+      kind: 'proc_trigger_spell',
+      triggerSpellId: RETALIATION_DAMAGE_SPELL_ID,
+      durationMs,
+      charges: RETALIATION_PROC_CHARGES,
+    });
+  }
+
+  // ── Retaliation payload 22858: WEAPON_DAMAGE_NOSCHOOL bp=0 → 100% weapon ──
+  if (id === RETALIATION_DAMAGE_SPELL_ID && effects.length === 0) {
+    effects.push({ kind: 'weapon_percent_damage', pct: 100 });
+  }
+
+  // Barkskin folds in its companion's combat auras. The damage-taken aura is a PERCENT, not a flat
+  // reduction. Cite: Spell.sql 22839; Unit.cpp:7628.
+  if (id === BARKSKIN_SPELL_ID) {
+    const dur = durFromIndex(spell.durationIndex) ?? 15_000;
+    // Self-buffs: amount is negative (damage taken / haste) but must NOT use the legacy "amount < 0 ⇒
+    // hostile" path. Cite: combat.ts isHostileBuffEffect; Spell.sql 22812 targetA=1 (self).
+    if (!effects.some((e) => e.kind === 'buff' && e.mod === 'physical_taken_pct')) {
+      effects.push({
+        kind: 'buff',
+        mod: 'physical_taken_pct',
+        amount: BARKSKIN_PHYSICAL_TAKEN_AMOUNT,
+        durationMs: dur,
+        hostile: false,
+      });
+    }
+    if (!effects.some((e) => e.kind === 'buff' && e.mod === 'haste')) {
+      effects.push({
+        kind: 'buff',
+        mod: 'haste',
+        amount: BARKSKIN_HASTE_AMOUNT,
+        durationMs: dur,
+        hostile: false,
+      });
+    }
+  }
+
+  // ── Frenzied Regeneration: PERIODIC_TRIGGER trigger=0 scripted ───────────
+  // Cite: SpellAuras.cpp:1104–1116.
+  if (FRENZIED_REGEN_SPELL_IDS.has(id) && !effects.some((e) => e.kind === 'restore_health')) {
+    const raw = (spell.rawEffects ?? []).find((r) => (r.effect | 0) === 6 && (r.auraName | 0) === 23);
+    if (raw) {
+      // LifePerRage = modifier amount (bp+1): r1=10, r2=15, r3=20.
+      const lifePerRage = effectBaseAmount(raw, {});
+      const tickMs = (raw.amplitude | 0) || 1000;
+      const durationMs = durFromIndex(spell.durationIndex) ?? 10_000;
+      // Max tick heal when rage pool ≥ 10 display (stored 100):
+      // FRTriggerBasePoints = lRage * LifePerRage / 10. Cite: :1114.
+      const amountPerTick = Math.max(
+        1,
+        Math.trunc((FRENZIED_REGEN_MAX_STORED_RAGE * lifePerRage) / 10),
+      );
+      effects.push({
+        kind: 'restore_health',
+        amountPerTick,
+        tickMs,
+        durationMs,
+      });
+    }
+  }
+
+  // ── Execute: DUMMY OnCast → direct damage (base + rage * mult) ────────────
+  // Cite: Warrior.cpp:22–29; replaces empty trigger→26651 dead-proc chain.
+  if (
+    ((spell.spellFamilyName ?? 0) | 0) === SPELLFAMILY_WARRIOR
+    && ((Number(spell.spellFamilyFlags) || 0) & EXECUTE_FAMILY_FLAGS) === EXECUTE_FAMILY_FLAGS
+    && EXECUTE_DMG_MULTIPLIER[id] != null
+  ) {
+    const raw0 = (spell.rawEffects ?? []).find((r) => (r.effect | 0) === 3);
+    if (raw0) {
+      const base = effectBaseAmount(raw0, {});
+      const mult = EXECUTE_DMG_MULTIPLIER[id]!;
+      // Rage not available at census-time → base only; combat passes rage via ctx later.
+      // materializeExecuteWithRage in resolveCombatSpell supplies rage when present.
+      const rage = 0;
+      const amount = executeDamageAmount(base, rage, mult);
+      // Replace trigger-only shell with real damage.
+      effects = effects.filter((e) => e.kind !== 'trigger_spell');
+      if (!effects.some((e) => e.kind === 'direct_damage')) {
+        effects.push({
+          kind: 'direct_damage',
+          school: 'physical',
+          min: amount,
+          max: amount,
+        });
+      }
+    }
+  }
+
+  return effects;
+}
+
+/** Re-apply Execute damage with cast-time rage (display 0–100). Cite: Warrior.cpp:26–28. */
+export function applyExecuteRageToEffects(
+  spell: SpellDef,
+  effects: SpellEffect[],
+  rageDisplay: number | undefined,
+): SpellEffect[] {
+  const id = spell.id | 0;
+  const mult = EXECUTE_DMG_MULTIPLIER[id];
+  if (mult == null || rageDisplay == null) return effects;
+  const raw0 = (spell.rawEffects ?? []).find((r) => (r.effect | 0) === 3);
+  if (!raw0) return effects;
+  const base = effectBaseAmount(raw0, {});
+  const amount = executeDamageAmount(base, rageDisplay, mult);
+  return effects.map((e) =>
+    e.kind === 'direct_damage'
+      ? { ...e, min: amount, max: amount }
+      : e,
+  );
+}
+

package/src/engine/spells/interpreter/weapon-imbue-kit.ts

@@ -0,0 +1,384 @@
+// Offline full kits for the temporary weapon imbues. A live bake row is often thin — enchant id,
+// duration and family — so combat needs the equip and combat payloads filled in at resolve time.
+
+import type { SpellEffect } from '../../../data/schema.ts';
+import { FLAMETONGUE_ATTACK_SPELL_ID } from './registry/packs/shaman.ts';
+
+export type WeaponImbueEffect = Extract<SpellEffect, { kind: 'weapon_imbue' }>;
+
+/** Partial kit fields merged onto a thin weapon_imbue effect. */
+export type WeaponImbueKitFields = Pick<
+  WeaponImbueEffect,
+  | 'attackPower'
+  | 'equipSpellId'
+  | 'combatSpellId'
+  | 'combatChancePct'
+  | 'combatPpm'
+  | 'damageFlat'
+  | 'rockbiterAmount'
+  | 'combat'
+>;
+
+// Rockbiter's equip passive attack power by enchant id, with the amounts from the baked passive. The
+// cached amount is for a mid-fight apply; the sheet's attack power comes from the equip aura alone.
+const ROCKBITER_BY_ENCHANT: ReadonlyMap<number, WeaponImbueKitFields> = new Map([
+  [29, { attackPower: 29, equipSpellId: 10400 }],
+  [6, { attackPower: 58, equipSpellId: 15567 }],
+  [1, { attackPower: 88, equipSpellId: 15568 }],
+  [503, { attackPower: 129, equipSpellId: 15569 }],
+  [1663, { attackPower: 211, equipSpellId: 16311 }],
+  [683, { attackPower: 393, equipSpellId: 16312 }],
+  [1664, { attackPower: 554, equipSpellId: 16313 }],
+]);
+
+// Flametongue's combat spell, whose stored value is the formula COEFFICIENT and not flat damage:
+// combat multiplies it by weapon speed. Using it flat was a ~326-per-swing bug.
+function flametongueKit(procSpellId: number, damageCoeff: number): WeaponImbueKitFields {
+  return {
+    combatSpellId: procSpellId,
+    combatChancePct: 100,
+    combat: {
+      spellId: FLAMETONGUE_ATTACK_SPELL_ID,
+      name: 'Flametongue Attack',
+      direct: { school: 'fire', min: damageCoeff, max: damageCoeff },
+    },
+  };
+}
+
+/** Enchant id → Flametongue kit. Proc bp from classicmangos spell_template + pack comments. */
+const FLAMETONGUE_BY_ENCHANT: ReadonlyMap<number, WeaponImbueKitFields> = new Map([
+  [5, flametongueKit(8026, 326)], // r1 bp 325 + dice 1
+  [4, flametongueKit(8028, 479)], // r2 bp 478 + dice 1
+  [3, flametongueKit(8029, 716)], // r3 bp 715 + dice 1
+  [523, flametongueKit(10445, 1144)], // r4 bp 1143 + dice 1
+  [1665, flametongueKit(16343, 1876)], // r5 bp 1875 + dice 1
+  [1666, flametongueKit(16344, 2498)], // r6 bp 2497 + dice 1
+]);
+
+// Frostbrand's combat spell is flat frost damage, not speed-scaled like Flametongue, and its chance is
+// a PPM. Every rank also applies a -25% chill for eight seconds, which the thin bake omits.
+const FROSTBRAND_CHILL = {
+  aura: 33,
+  pct: -25,
+  durationMs: 8000,
+  hostile: true as const,
+  mechanic: 'snare',
+};
+
+function frostbrandKit(
+  attackSpellId: number,
+  frostDamage: number,
+  ppm?: number,
+): WeaponImbueKitFields {
+  return {
+    combatSpellId: attackSpellId,
+    ...(ppm != null && ppm > 0 ? { combatPpm: ppm } : {}),
+    combat: {
+      spellId: attackSpellId,
+      name: 'Frostbrand Attack',
+      direct: { school: 'frost', min: frostDamage, max: frostDamage },
+      speed: { ...FROSTBRAND_CHILL },
+    },
+  };
+}
+
+/** Enchant id → Frostbrand kit. Damage from lock9a / enrich-weapon-imbues combatPayload. */
+const FROSTBRAND_BY_ENCHANT: ReadonlyMap<number, WeaponImbueKitFields> = new Map([
+  [2, frostbrandKit(8034, 35, 9)], // r1 PPM 9
+  [12, frostbrandKit(8037, 53)], // r2
+  [524, frostbrandKit(10458, 84)], // r3
+  [1667, frostbrandKit(16352, 134)], // r4
+  [1668, frostbrandKit(16353, 175)], // r5
+]);
+
+// Windfury — the family MISSING from this table entirely, which is why the weapon granted no extra
+// attacks: the proc carries both the attack-power aura and TWO extra attacks, and neither was produced.
+function windfuryKit(procSpellId: number, apBonus: number): WeaponImbueKitFields {
+  return {
+    combatSpellId: procSpellId,
+    combatChancePct: 20,
+    combat: {
+      spellId: procSpellId,
+      name: 'Windfury Weapon',
+      extraAttacks: WINDFURY_WEAPON_EXTRA_ATTACKS,
+      apBonus,
+    },
+  };
+}
+
+/** spell_template 8233/8236/10484/16361: EffectBasePoints 1 + EffectBaseDice 1 = 2. */
+const WINDFURY_WEAPON_EXTRA_ATTACKS = 2;
+
+/** Enchant id → Windfury kit. AP = aura-99 (bp + baseDice) on the enchant's proc spell. */
+const WINDFURY_BY_ENCHANT: ReadonlyMap<number, WeaponImbueKitFields> = new Map([
+  [283, windfuryKit(8233, 46)], // r1  bp 45  + dice 1
+  [284, windfuryKit(8236, 119)], // r2  bp 118 + dice 1
+  [525, windfuryKit(10484, 249)], // r3  bp 248 + dice 1
+  [1669, windfuryKit(16361, 333)], // r4  bp 332 + dice 1
+]);
+
+// The full kit fields for an enchant id, or undefined for a poison, oil or unknown enchant, which stay
+// thin. Coverage is per-family and hand-maintained, so a missing family is a silently dead ability.
+export function weaponImbueKitForEnchant(enchantId: number): WeaponImbueKitFields | undefined {
+  return (
+    ROCKBITER_BY_ENCHANT.get(enchantId)
+    ?? FLAMETONGUE_BY_ENCHANT.get(enchantId)
+    ?? FROSTBRAND_BY_ENCHANT.get(enchantId)
+    ?? WINDFURY_BY_ENCHANT.get(enchantId)
+  );
+}
+
+/** Every enchant id the offline shaman table covers, for the coverage gate. */
+function weaponImbueKitEnchantIds(): number[] {
+  return [
+    ...ROCKBITER_BY_ENCHANT.keys(),
+    ...FLAMETONGUE_BY_ENCHANT.keys(),
+    ...FROSTBRAND_BY_ENCHANT.keys(),
+    ...WINDFURY_BY_ENCHANT.keys(),
+  ];
+}
+
+// True when the imbue already carries a combat or equip payload. The chance and PPM fields MUST be
+// here: a poison bake carrying only a proc chance was silently rejected at the merge and never procced.
+export function weaponImbueHasCombatKit(imbue: WeaponImbueEffect): boolean {
+  return !!(
+    imbue.attackPower
+    || imbue.rockbiterAmount
+    || imbue.combat
+    || imbue.combatSpellId
+    || imbue.damageFlat
+    || (imbue.combatChancePct != null && imbue.combatChancePct > 0)
+    || (imbue.combatPpm != null && imbue.combatPpm > 0)
+    || imbue.equipSpellId
+  );
+}
+
+/** Merge kit fields onto an imbue (only fills missing keys). */
+export function mergeWeaponImbueKit(
+  imbue: WeaponImbueEffect,
+  kit: WeaponImbueKitFields,
+): WeaponImbueEffect {
+  if (kit.attackPower != null && imbue.attackPower == null) imbue.attackPower = kit.attackPower;
+  if (kit.equipSpellId != null && imbue.equipSpellId == null) imbue.equipSpellId = kit.equipSpellId;
+  if (kit.combatSpellId != null && imbue.combatSpellId == null) imbue.combatSpellId = kit.combatSpellId;
+  if (kit.combatChancePct != null && imbue.combatChancePct == null) imbue.combatChancePct = kit.combatChancePct;
+  if (kit.combatPpm != null && imbue.combatPpm == null) imbue.combatPpm = kit.combatPpm;
+  if (kit.damageFlat != null && imbue.damageFlat == null) imbue.damageFlat = kit.damageFlat;
+  if (kit.rockbiterAmount != null && imbue.rockbiterAmount == null) imbue.rockbiterAmount = kit.rockbiterAmount;
+  if (kit.combat) {
+    if (!imbue.combat) {
+      imbue.combat = {
+        ...kit.combat,
+        ...(kit.combat.direct ? { direct: { ...kit.combat.direct } } : {}),
+        ...(kit.combat.dot ? { dot: { ...kit.combat.dot } } : {}),
+        ...(kit.combat.speed ? { speed: { ...kit.combat.speed } } : {}),
+        ...(kit.combat.buffs ? { buffs: kit.combat.buffs.map((b) => ({ ...b })) } : {}),
+      };
+    } else {
+      // Deep-fill missing combat subfields (bake often has direct-only; kit adds chill).
+      if (kit.combat.direct && !imbue.combat.direct) {
+        imbue.combat.direct = { ...kit.combat.direct };
+      }
+      if (kit.combat.dot && !imbue.combat.dot) {
+        imbue.combat.dot = { ...kit.combat.dot };
+      }
+      if (kit.combat.speed && !imbue.combat.speed) {
+        imbue.combat.speed = { ...kit.combat.speed };
+      }
+      if (kit.combat.buffs?.length && !imbue.combat.buffs?.length) {
+        imbue.combat.buffs = kit.combat.buffs.map((b) => ({ ...b }));
+      }
+      if (kit.combat.extraAttacks != null && imbue.combat.extraAttacks == null) {
+        imbue.combat.extraAttacks = kit.combat.extraAttacks;
+      }
+      if (kit.combat.apBonus != null && imbue.combat.apBonus == null) {
+        imbue.combat.apBonus = kit.combat.apBonus;
+      }
+    }
+  }
+  return imbue;
+}
+
+// Map a baked enchantment row onto the imbue kit fields. An optional spell lookup fills the combat
+// damage from the combat spell's own bake; without it the id and chance still land.
+export function kitFromItemEnchant(
+  ench: {
+    effects: ReadonlyArray<{
+      type: string;
+      spellId?: number;
+      chancePct?: number;
+      ppm?: number;
+      amount?: number;
+      amountPerSecOfSpeed?: number;
+      grants?: ReadonlyArray<{ kind: string; amount?: number }>;
+    }>;
+  },
+  spellLookup?: (spellId: number) => {
+    id: number;
+    name: string;
+    effects?: ReadonlyArray<{
+      kind: string;
+      school?: string;
+      min?: number;
+      max?: number;
+      durationMs?: number;
+      tickMs?: number;
+    }>;
+  } | undefined,
+): WeaponImbueKitFields | undefined {
+  const kit: WeaponImbueKitFields = {};
+  for (const e of ench.effects) {
+    if (e.type === 'weapon_damage' && e.amount != null && e.amount > 0) {
+      kit.damageFlat = e.amount;
+    } else if (e.type === 'combat_spell' && e.spellId) {
+      kit.combatSpellId = e.spellId;
+      if (e.chancePct != null && e.chancePct > 0) kit.combatChancePct = e.chancePct;
+      if (e.ppm != null && e.ppm > 0) kit.combatPpm = e.ppm;
+      if (spellLookup) {
+        const sp = spellLookup(e.spellId);
+        if (sp) {
+          const combat = combatPayloadFromSpell(sp);
+          if (combat) kit.combat = combat;
+        }
+      }
+    } else if (e.type === 'equip_spell' && e.spellId) {
+      kit.equipSpellId = e.spellId;
+      for (const g of e.grants ?? []) {
+        if (g.kind === 'attack_power' && g.amount != null) kit.attackPower = g.amount;
+      }
+    } else if (e.type === 'totem' && e.amountPerSecOfSpeed != null && e.amountPerSecOfSpeed > 0) {
+      kit.rockbiterAmount = e.amountPerSecOfSpeed;
+    }
+  }
+  return (
+    kit.attackPower != null
+    || kit.equipSpellId != null
+    || kit.combatSpellId != null
+    || kit.damageFlat != null
+    || kit.rockbiterAmount != null
+    || kit.combat != null
+    || kit.combatChancePct != null
+    || kit.combatPpm != null
+  )
+    ? kit
+    : undefined;
+}
+
+/** Build the on-hit combat payload combat/weapon.ts consumes from a combat-spell SpellDef. */
+export function combatPayloadFromSpell(sp: {
+  id: number;
+  name: string;
+  effects?: ReadonlyArray<{
+    kind: string;
+    school?: string;
+    min?: number;
+    max?: number;
+    durationMs?: number;
+    tickMs?: number;
+    aura?: number;
+    pct?: number;
+    hostile?: boolean;
+    /** string name (speed/cc) or numeric mechanic id (mechanic_immunity) */
+    mechanic?: string | number;
+    mod?: string;
+    amount?: number;
+  }>;
+}): NonNullable<WeaponImbueKitFields['combat']> | undefined {
+  let direct: { school: import('../../../data/schema.ts').School; min: number; max: number } | undefined;
+  let dot: {
+    school: import('../../../data/schema.ts').School;
+    min: number;
+    max: number;
+    durationMs: number;
+    tickMs: number;
+  } | undefined;
+  let speed: {
+    aura: number;
+    pct: number;
+    durationMs: number;
+    hostile?: boolean;
+    mechanic?: string;
+  } | undefined;
+  const buffs: Array<{
+    mod: string;
+    amount: number;
+    durationMs: number;
+    hostile?: boolean;
+  }> = [];
+  for (const e of sp.effects ?? []) {
+    if (e.kind === 'direct_damage' && e.school && e.min != null) {
+      direct = {
+        school: e.school as import('../../../data/schema.ts').School,
+        min: e.min,
+        max: e.max ?? e.min,
+      };
+    } else if (e.kind === 'dot' && e.school && e.min != null) {
+      dot = {
+        school: e.school as import('../../../data/schema.ts').School,
+        min: e.min,
+        max: e.max ?? e.min,
+        durationMs: e.durationMs ?? 12_000,
+        tickMs: e.tickMs ?? 3_000,
+      };
+    } else if (e.kind === 'speed' && e.pct != null) {
+      // Frostbrand chill / Crippling Poison snare. Cite: aura 33; KI-581 / KI-717.
+      const mech = typeof e.mechanic === 'string' ? e.mechanic : 'snare';
+      speed = {
+        aura: e.aura ?? 33,
+        pct: e.pct,
+        durationMs: e.durationMs ?? 12_000,
+        ...(e.hostile != null ? { hostile: e.hostile } : { hostile: true }),
+        mechanic: mech,
+      };
+    } else if (e.kind === 'buff' && e.mod && e.amount != null) {
+      buffs.push({
+        mod: e.mod,
+        amount: e.amount,
+        durationMs: e.durationMs ?? 10_000,
+        ...(e.hostile != null ? { hostile: e.hostile } : { hostile: true }),
+      });
+    }
+  }
+  if (!direct && !dot && !speed && buffs.length === 0) return undefined;
+  return {
+    spellId: sp.id,
+    name: sp.name,
+    ...(direct ? { direct } : {}),
+    ...(dot ? { dot } : {}),
+    ...(speed ? { speed } : {}),
+    ...(buffs.length ? { buffs } : {}),
+  };
+}
+
+// Merge the offline kit onto a thin imbue, a no-op when it is already full or the enchant is unknown.
+// Callers with enchantment data should follow with the item-enchant merge for poisons and oils.
+export function applyWeaponImbueKit(imbue: WeaponImbueEffect): WeaponImbueEffect {
+  // Always merge — fills missing combat.speed / direct on partial bake kits (Frostbrand
+  // direct-only rows). mergeWeaponImbueKit only writes absent keys. Cite: KI-581.
+  const kit = weaponImbueKitForEnchant(imbue.enchantId);
+  if (!kit) return imbue;
+  return mergeWeaponImbueKit(imbue, kit);
+}
+
+// Fill a thin (or chance-only) weapon_imbue from a SpellItemEnchantment row. Prefer this over the offline
+// shaman table when the enchant is a poison / oil / stone. Mutates and returns the same object.
+export function applyWeaponImbueKitFromItemEnchant(
+  imbue: WeaponImbueEffect,
+  ench: Parameters<typeof kitFromItemEnchant>[0] | null | undefined,
+  spellLookup?: Parameters<typeof kitFromItemEnchant>[1],
+): WeaponImbueEffect {
+  if (!ench) return imbue;
+  // Always try to fill missing fields — even when hasCombatKit is true for chance-only rows
+  // we still want combatSpellId + combat.direct from the enchant / combat spell.
+  const kit = kitFromItemEnchant(ench, spellLookup);
+  if (!kit) return imbue;
+  return mergeWeaponImbueKit(imbue, kit);
+}
+
+// Flametongue's on-hit fire damage from the stored coefficient and weapon speed. The spell-power term
+// is omitted on the swing path, where there is no such context. Cite: SpellEffects.cpp:1484.
+export function flametongueSwingDamage(damageCoeff: number, weaponSpeedSec: number): number {
+  if (!(damageCoeff > 0) || !(weaponSpeedSec > 0)) return 0;
+  const n = damageCoeff * 0.01 * weaponSpeedSec;
+  return n < 0 ? Math.ceil(n) : Math.floor(n);
+}