azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/spells/interpreter/diff.ts

@@ -0,0 +1,246 @@
+// LOCK 9a — normalize + diff interpreter output vs baked effects[]. Test / oracle only — not used by live
+// combat.
+
+import type { SpellEffect } from '../../../data/schema.ts';
+import type { InterpretResult } from './types.ts';
+
+// Kinds the covered-opcode set can emit, and the only ones the oracle diffs: conjure, imbue, summon
+// pet, leech, power burn and drain, threat, dispel, interrupt, combo points, totem, extra attacks.
+export const SI2_KINDS = new Set([
+  'direct_damage',
+  'heal',
+  'dot',
+  'restore_health',
+  'buff',
+  'energize',
+  'trigger_spell',
+  'weapon_percent_damage',
+  'conjure',
+  'weapon_imbue',
+  'summon_pet',
+  'health_leech',
+  'power_burn',
+  'power_drain',
+  'extra_attacks',
+  'threat',
+  'dispel',
+  'interrupt_cast',
+  'combo_points',
+  'summon_totem',
+  'spell_magnet',
+  // SI3 aura batch bake surfaces
+  'cc',
+  'speed',
+  'proc_trigger_spell',
+  'resist',
+  // Aura 42 LShield / amount-only path. Cite: map-spell-effects.mjs mapProcTriggerSpell.
+  'damage_shield',
+]);
+
+export type NormalizeOpts = {
+  /** Drop durationMs so amount/kind parity can pass without DurationIndex. */
+  ignoreDuration?: boolean;
+  /** Drop applyTo (audience) if comparing amount-only. */
+  ignoreApplyTo?: boolean;
+};
+
+function sortKey(e: SpellEffect): string {
+  const k = e.kind;
+  if (k === 'direct_damage' || k === 'dot') {
+    return `${k}|${e.school}|${e.min}|${e.max}`;
+  }
+  if (k === 'health_leech') {
+    return `${k}|${e.school}|${e.min}|${e.max}|${e.multiplier}`;
+  }
+  if (k === 'heal' || k === 'energize') {
+    const extra = k === 'energize' ? `|${e.powerType}` : '';
+    return `${k}${extra}|${e.min}|${e.max}`;
+  }
+  if (k === 'buff') return `${k}|${e.mod}|${e.amount}`;
+  if (k === 'restore_health' || k === 'restore_power') {
+    return `${k}|${e.amountPerTick}|${e.tickMs}`;
+  }
+  if (k === 'trigger_spell') return `${k}|${e.spellId}`;
+  if (k === 'weapon_percent_damage') return `${k}|${e.pct}`;
+  if (k === 'conjure') return `${k}|${e.item}|${e.count}`;
+  if (k === 'summon_pet') return `${k}|${e.creature}`;
+  if (k === 'summon_wild') return `${k}|${e.creature}|${e.count}|${e.durationMs}`;
+  if (k === 'summon_guardian') return `${k}|${e.creature}|${e.count}|${e.durationMs}`;
+  if (k === 'summon_object_wild') return `${k}|${e.goEntry}|${e.durationMs}`;
+  if (k === 'activate_object') {
+    return `${k}|${e.action}|${e.summonNpcEntry ?? ''}|${e.customAnim ? 1 : 0}`;
+  }
+  if (k === 'mounted') return `${k}|${e.creatureEntry}`;
+  if (k === 'weapon_imbue') {
+    return `${k}|${e.enchantId}|${e.durationMs}|${e.family ?? ''}`;
+  }
+  if (k === 'power_burn') {
+    return `${k}|${e.powerType}|${e.min}|${e.max}|${e.multiplier}|${e.school}`;
+  }
+  if (k === 'power_drain') {
+    return `${k}|${e.powerType}|${e.min}|${e.max}|${e.multiplier}`;
+  }
+  if (k === 'extra_attacks') return `${k}|${e.count}`;
+  if (k === 'threat') return `${k}|${e.amount}`;
+  if (k === 'dispel') return `${k}|${e.dispelType}|${e.count}`;
+  if (k === 'dispel_mechanic') return `${k}|${e.mechanic}|${e.count}`;
+  if (k === 'spell_magnet') return `${k}|${e.durationMs}|${e.charges ?? 1}`;
+  if (k === 'interrupt_cast') return `${k}|${e.lockoutMs}`;
+  if (k === 'combo_points') return `${k}|${e.amount}`;
+  if (k === 'summon_totem') {
+    return `${k}|${e.slot}|${e.creature}|${e.health}|${e.durationMs}`;
+  }
+  if (k === 'cc') {
+    return `${k}|${e.control}|${e.mechanic}|${e.school}|${e.durationMs}`;
+  }
+  if (k === 'speed') {
+    return `${k}|${e.aura}|${e.pct}|${e.durationMs}`;
+  }
+  if (k === 'proc_trigger_spell') {
+    return `${k}|${e.triggerSpellId}|${e.amount ?? 0}|${e.tickMs ?? 0}|${e.durationMs}`;
+  }
+  if (k === 'damage_shield') {
+    return `${k}|${e.school}|${e.min}|${e.max}|${e.durationMs}`;
+  }
+  if (k === 'resist') {
+    return `${k}|${e.school}|${e.amount}`;
+  }
+  return JSON.stringify(e);
+}
+
+// Stable JSON for deep compare (sorted keys, optional field strip). weapon_imbue: compare interpreter core
+// only (enchantId/durationMs/family) — enrich-weapon-imbues bakes combat kit the handler does not invent.
+export function normalizeEffect(e: SpellEffect, opts: NormalizeOpts = {}): unknown {
+  // Core-only for temp enchant: map-spell-effects emits minimal; enricher adds combat kit.
+  if (e.kind === 'weapon_imbue') {
+    const core: Record<string, unknown> = {
+      kind: 'weapon_imbue',
+      enchantId: e.enchantId,
+      durationMs: e.durationMs,
+    };
+    if (e.family) core.family = e.family;
+    if (opts.ignoreDuration) delete core.durationMs;
+    const keys = Object.keys(core).sort();
+    const out: Record<string, unknown> = {};
+    for (const k of keys) out[k] = core[k];
+    return out;
+  }
+  // Core-only for totems: enrich-totems bakes name/abilities the handler does not invent.
+  // Cite: map-spell-effects.mjs :353–356; SpellEffects.cpp EffectSummonTotem.
+  if (e.kind === 'summon_totem') {
+    const core: Record<string, unknown> = {
+      kind: 'summon_totem',
+      slot: e.slot,
+      creature: e.creature,
+      health: e.health,
+      durationMs: e.durationMs,
+    };
+    if (opts.ignoreDuration) delete core.durationMs;
+    const keys = Object.keys(core).sort();
+    const out: Record<string, unknown> = {};
+    for (const k of keys) out[k] = core[k];
+    return out;
+  }
+  // combo_points: enricher may stamp requiresStealth (Premeditation); C++ effect body is amount only.
+  // Cite: SpellEffects.cpp:4213–4225 EffectAddComboPoints.
+  if (e.kind === 'combo_points') {
+    return { amount: e.amount, kind: 'combo_points' };
+  }
+  const copy = { ...e } as Record<string, unknown>;
+  if (opts.ignoreDuration && 'durationMs' in copy) delete copy.durationMs;
+  if (opts.ignoreApplyTo && 'applyTo' in copy) delete copy.applyTo;
+  // SI5: proc meta (charges/cooldownMs) came from enrich-spell-aura / LShield / proc_event —
+  // retired enrichers. Generic interpreter + proc.ts emit amount/trigger; strip for LOCK 9a.
+  if (e.kind === 'proc_trigger_spell' || e.kind === 'damage_shield') {
+    delete copy.charges;
+    delete copy.cooldownMs;
+  }
+  // SI3+: leechMultiple on DoTs and breakOnDamage on CC are combat-surface fields the
+  // pre-SI5 enricher goldens never stamped — strip so LOCK 9a compares core shapes.
+  delete copy.leechMultiple;
+  delete copy.breakOnDamage;
+  // Sort object keys for stable stringify
+  const keys = Object.keys(copy).sort();
+  const out: Record<string, unknown> = {};
+  for (const k of keys) out[k] = copy[k];
+  return out;
+}
+
+export function normalizeEffectList(
+  effects: SpellEffect[],
+  opts: NormalizeOpts = {},
+): unknown[] {
+  return [...effects]
+    .map((e) => normalizeEffect(e, opts))
+    .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+}
+
+export interface DiffMismatch {
+  spellId: number;
+  spellName: string;
+  detail: string;
+  interpreted: unknown;
+  baked: unknown;
+}
+
+// Diff SI2-covered kinds only. Baked effects of unhandled kinds are ignored (spell may have extra
+// root/cc/etc.). Interpreted effects must match the SI2-kind subset of baked effects.
+function diffSi2Effects(
+  spellId: number,
+  spellName: string,
+  interpreted: InterpretResult,
+  bakedEffects: SpellEffect[],
+  opts: NormalizeOpts = { ignoreDuration: true },
+): DiffMismatch | null {
+  const got = interpreted.effects.filter((e) => SI2_KINDS.has(e.kind));
+  const exp = bakedEffects.filter((e) => SI2_KINDS.has(e.kind));
+
+  // If neither side has SI2 kinds, no mismatch for this gate.
+  if (got.length === 0 && exp.length === 0) return null;
+
+  const nGot = normalizeEffectList(got, opts);
+  const nExp = normalizeEffectList(exp, opts);
+  if (JSON.stringify(nGot) === JSON.stringify(nExp)) return null;
+
+  return {
+    spellId,
+    spellName,
+    detail: `SI2 kinds mismatch (got ${got.map((e) => e.kind).join(',')} vs baked ${exp.map((e) => e.kind).join(',')})`,
+    interpreted: nGot,
+    baked: nExp,
+  };
+}
+
+// Full equality for spells whose every raw slot is SI2-covered and every baked effect is an SI2 kind (plus
+// optional strikeBonus).
+function diffFullCovered(
+  spellId: number,
+  spellName: string,
+  interpreted: InterpretResult,
+  bakedEffects: SpellEffect[],
+  bakedStrikeBonus: number | undefined,
+  opts: NormalizeOpts = { ignoreDuration: true },
+): DiffMismatch | null {
+  const nGot = normalizeEffectList(interpreted.effects, opts);
+  const nExp = normalizeEffectList(bakedEffects, opts);
+  const effectsOk = JSON.stringify(nGot) === JSON.stringify(nExp);
+
+  const sbGot = interpreted.strikeBonus ?? 0;
+  const sbExp = bakedStrikeBonus ?? 0;
+  // Only compare strikeBonus when either side has one (weapon flat).
+  const strikeOk = sbGot === sbExp || (sbGot === 0 && sbExp === 0);
+
+  if (effectsOk && strikeOk) return null;
+
+  return {
+    spellId,
+    spellName,
+    detail: !effectsOk
+      ? 'effects mismatch'
+      : `strikeBonus mismatch got=${sbGot} baked=${sbExp}`,
+    interpreted: { effects: nGot, strikeBonus: interpreted.strikeBonus },
+    baked: { effects: nExp, strikeBonus: bakedStrikeBonus },
+  };
+}
+
+export { sortKey };

package/src/engine/spells/interpreter/duration.ts

@@ -0,0 +1,90 @@
+// SpellDuration.dbc index to milliseconds, a port of the ETL fallback table for pure engine use with no
+// CSV at runtime. Values are already ms. Cite: spell-duration.mjs FALLBACK_DURATION_MS.
+
+// The embedded duration table for pure interpretation, already in ms. Expanded to cover every index the
+// committed bake references — a missing one resolved to 0 and expired rotation auras instantly.
+export const FALLBACK_DURATION_MS: Readonly<Record<number, number>> = {
+  0: 0,
+  1: 10_000,
+  2: 30_000,
+  3: 60_000,
+  4: 120_000,
+  5: 300_000,
+  6: 600_000,
+  7: 5000,
+  8: 15_000,
+  9: 30_000,
+  10: 60_000,
+  18: 20_000,
+  21: 0, // −1 infinite in DBC → 0 until-cancelled
+  22: 45_000,
+  23: 90_000, // SpellDuration.csv
+  25: 180_000,
+  26: 240_000, // SpellDuration.csv
+  27: 3000,
+  28: 5000,
+  29: 12_000,
+  30: 1_800_000,
+  31: 8000,
+  32: 6000,
+  35: 4000,
+  36: 1000,
+  37: 1, // SpellDuration.csv
+  39: 2000,
+  40: 1_200_000,
+  41: 360_000, // SpellDuration.csv
+  42: 3_600_000,
+  62: 75_000, // SpellDuration.csv
+  63: 25_000, // SpellDuration.csv
+  64: 40_000,
+  65: 1500, // SpellDuration.csv
+  66: 2500, // SpellDuration.csv
+  85: 18_000,
+  86: 21_000,
+  105: 9000,
+  106: 24_000, // Curse of Agony family — SpellDuration.csv ID 106
+  125: 35_000, // SpellDuration.csv
+  145: 2_700_000, // SpellDuration.csv
+  165: 7000, // SpellDuration.csv
+  185: 6000, // Slice and Dice base — MaxDuration 21000 (baked durationMaxMs)
+  186: 2000, // SpellDuration.csv (Kidney Shot base band)
+  187: 0, // SpellDuration.csv Duration 0 / Max 5000 (Kidney Shot 0-CP base)
+  205: 27_000, // SpellDuration.csv
+  225: 604_800_000, // SpellDuration.csv (7d)
+  245: 50_000, // SpellDuration.csv
+  265: 55_000, // SpellDuration.csv
+  285: 1000, // SpellDuration.csv
+  305: 14_000, // SpellDuration.csv
+  327: 500, // SpellDuration.csv
+  347: 900_000, // SpellDuration.csv
+  367: 7_200_000, // SpellDuration.csv
+  387: 16_000, // SpellDuration.csv
+  407: 100, // SpellDuration.csv
+  447: 2000, // SpellDuration.csv
+  467: 22_000, // SpellDuration.csv
+  468: 26_000, // SpellDuration.csv
+  487: 1700, // SpellDuration.csv
+  553: 6000, // Rupture base — MaxDuration 16000 (baked durationMaxMs)
+};
+
+// Duration index to base milliseconds. Undefined when the index is unknown, so the caller must not
+// invent a 10 or 12 second default.
+export function durMs(idx: number | undefined | null): number | undefined {
+  if (idx == null) return undefined;
+  const k = idx | 0;
+  if (Object.prototype.hasOwnProperty.call(FALLBACK_DURATION_MS, k)) {
+    return FALLBACK_DURATION_MS[k];
+  }
+  return undefined;
+}
+
+// Resolve an effect's duration: an explicit override first, then the duration index, then undefined —
+// which handlers read as 0, honestly unhandled or permanent, never a magic default.
+export function resolveDurationMs(
+  ctxDurationMs: number | undefined,
+  ctxDurationIndex: number | undefined,
+  spellDurationIndex: number | undefined,
+): number | undefined {
+  if (ctxDurationMs != null) return ctxDurationMs;
+  return durMs(ctxDurationIndex ?? spellDurationIndex);
+}