azeroth-shell 0.0.0-stage → 0.1.0

package/src/domain/rotation/classes/paladin.ts

@@ -0,0 +1,296 @@
+// PURE: no DOM/RNG/Date. Paladin rotation post-pass + kit policy.
+
+import type { DataStore } from '../../../data/dataStore.ts';
+import type { SpellDef } from '../../../data/schema.ts';
+import { resolveCombatSpell } from '../../../engine/spells/interpreter/item-triggers.ts';
+import type { RotationRule } from '../types.ts';
+import {
+  cond,
+  isJudgementSpell,
+  isSealSpell,
+  sealKindOf,
+  sealKindPriority,
+} from '../classify.ts';
+import { auraHolderIsCastTarget } from '../../../engine/combat/healTargets.ts';
+import type { AllyFilter, Condition, RotationPhase } from '../types.ts';
+import type { ClassRotationHooks, FinalizeContext } from './hooks.ts';
+import {
+  blessingFamilyOf,
+  paladinAuraOf,
+  planPaladinAuras,
+  planPaladinBlessings,
+  type PaladinProvider,
+} from '../paladinBuffs.ts';
+import { rebuildPhaseUsed } from './hooks.ts';
+import { gateSupportDamageRows } from './supportSpec.ts';
+
+// Bake seals: empty effects or only proc_trigger (SoC) — resolve before sealKindOf.
+function resolvedSealDef(def: SpellDef): SpellDef {
+  return resolveCombatSpell(def);
+}
+
+/** One seal + Judgement gate; `spec` picks kind (Ret→Command, Holy/Prot→SoR). */
+export function finalizePaladinSealJudge(
+  combat: RotationRule[],
+  knownById: Map<number, SpellDef>,
+  ds?: DataStore,
+  spec?: string | null,
+): RotationRule[] {
+  const defOf = (id: number): SpellDef | undefined => knownById.get(id) ?? ds?.spell(id);
+  const sealRules: { rule: RotationRule; def: SpellDef }[] = [];
+  for (const r of combat) {
+    if (r.action.kind !== 'spell') continue;
+    const def = defOf(r.action.spellId);
+    if (def && isSealSpell(def)) sealRules.push({ rule: r, def });
+  }
+  if (!sealRules.length) return combat;
+
+  const pri = sealKindPriority(spec);
+  // Kind first (resolved effects); rank only ties same kind (highest rank wins).
+  const best = [...sealRules].sort((a, b) => {
+    const kindA = sealKindOf(resolvedSealDef(a.def));
+    const kindB = sealKindOf(resolvedSealDef(b.def));
+    return (pri[kindB] ?? -1) - (pri[kindA] ?? -1)
+      || (b.def.rank ?? 0) - (a.def.rank ?? 0);
+  })[0]!;
+  const bestId = best.def.id;
+  const dropSealIds = new Set(
+    sealRules.filter((s) => s.def.id !== bestId).map((s) => s.def.id),
+  );
+
+  const out: RotationRule[] = [];
+  let keptBestSeal = false;
+  for (const r of combat) {
+    if (r.action.kind === 'spell' && dropSealIds.has(r.action.spellId)) continue;
+    if (r.action.kind === 'spell' && r.action.spellId === bestId) {
+      if (keptBestSeal) continue; // one seal upkeep rule only
+      keptBestSeal = true;
+      out.push({
+        ...r,
+        conditions: [cond('self', 'buffPresent', '==', 0, bestId)],
+      });
+      continue;
+    }
+    if (r.action.kind === 'spell') {
+      const def = defOf(r.action.spellId);
+      // isJudgementSpell needs resolved effects; bake Judgement often has empty effects[].
+      const resolved = def ? (def.effects?.length ? def : resolveCombatSpell(def)) : undefined;
+      if (resolved && def && (isJudgementSpell(resolved) || /^judgement$/i.test(def.name))) {
+        out.push({
+          ...r,
+          conditions: [cond('self', 'buffPresent', '==', 1, bestId)],
+        });
+        continue;
+      }
+    }
+    out.push(r);
+  }
+  return out;
+}
+
+function firstSealId(
+  rules: RotationRule[],
+  knownById: Map<number, SpellDef>,
+  ds: DataStore,
+): number | null {
+  for (const r of rules) {
+    if (r.action.kind !== 'spell') continue;
+    const def = knownById.get(r.action.spellId) ?? ds.spell(r.action.spellId);
+    if (def && isSealSpell(def)) return r.action.spellId;
+  }
+  return null;
+}
+
+/** Same preferred seal on pull + combat (opener must match keep-up). */
+function finalizePaladinPhases(ctx: FinalizeContext): void {
+  ctx.phases.pull = finalizePaladinSealJudge(ctx.phases.pull, ctx.knownById, ctx.ds, ctx.spec);
+  ctx.phases.combat = finalizePaladinSealJudge(ctx.phases.combat, ctx.knownById, ctx.ds, ctx.spec);
+
+  const combatSeal = firstSealId(ctx.phases.combat, ctx.knownById, ctx.ds);
+  const pullSeal = firstSealId(ctx.phases.pull, ctx.knownById, ctx.ds);
+  if (combatSeal != null && pullSeal != null && combatSeal !== pullSeal) {
+    // Asymmetric pools (or leftover order): force pull onto combat's seal id.
+    let rewritten = false;
+    ctx.phases.pull = ctx.phases.pull.flatMap((r) => {
+      if (r.action.kind !== 'spell') return [r];
+      if (r.action.spellId === pullSeal && !rewritten) {
+        rewritten = true;
+        return [{
+          ...r,
+          action: { kind: 'spell' as const, spellId: combatSeal },
+          conditions: [cond('self', 'buffPresent', '==', 0, combatSeal)],
+        }];
+      }
+      const def = ctx.knownById.get(r.action.spellId) ?? ctx.ds.spell(r.action.spellId);
+      if (def && isSealSpell(def)) return [];
+      return [r];
+    });
+  }
+
+  rebuildPhaseUsed(ctx, 'pull');
+  rebuildPhaseUsed(ctx, 'combat');
+}
+
+function isHammerOfJustice(ctx: FinalizeContext, spellId: number): boolean {
+  const def = ctx.knownById.get(spellId) ?? ctx.ds.spell(spellId);
+  return /^hammer of justice$/i.test(def?.name ?? '');
+}
+
+// A Hammer of Justice boss keep-up never fires: a stun-immune boss reads as already debuffed. Hold
+// a second mob instead. ONLY that gate is repaired — this used to overwrite every HoJ row.
+function finalizePaladinHoJ(ctx: FinalizeContext): void {
+  const addCc = [
+    cond('self', 'enemyCount', '>=', 2),
+  ];
+  const isDeadKeepUp = (r: { conditions: readonly { subject?: string; metric: string }[] }): boolean =>
+    r.conditions.some(
+      (c) => c.subject === 'target' && (c.metric === 'debuffPresent' || c.metric === 'debuffStacks'),
+    );
+  ctx.phases.pull = ctx.phases.pull.filter(
+    (r) => !(r.action.kind === 'spell' && isHammerOfJustice(ctx, r.action.spellId) && isDeadKeepUp(r)),
+  );
+  ctx.phases.combat = ctx.phases.combat.map((r) => {
+    if (r.action.kind !== 'spell' || !isHammerOfJustice(ctx, r.action.spellId)) return r;
+    if (!isDeadKeepUp(r)) return r;
+    return {
+      ...r,
+      action: { ...r.action, target: 'other' as const },
+      conditions: addCc,
+    };
+  });
+  rebuildPhaseUsed(ctx, 'pull');
+  rebuildPhaseUsed(ctx, 'combat');
+}
+
+// One Blessing row and one Aura row, always. The shipped packs left a Prot paladin with no blessing
+// at all and gave every spec the same aura, so a second paladin in the group added nothing. Which
+// aura and which blessing family is CheckAuras / BuffHelper's call; who else is in the party is the
+// pre-pull plan's (bots/paladinPrePull.ts), which restamps these rows before a pull.
+function finalizePaladinBlessingAndAura(ctx: FinalizeContext): void {
+  // `Character` carries no group role; the build's own spec string is what names it, the same way
+  // sealKindPriority reads it. Cite: classify.ts:69 primarySpec buckets.
+  const role = /prot/i.test(ctx.spec) ? 'tank' : /holy/i.test(ctx.spec) ? 'healer' : 'dps';
+  const provider: PaladinProvider = {
+    key: 'self',
+    name: ctx.char.name,
+    level: ctx.char.level,
+    known: ctx.sb.known,
+    spec: ctx.spec,
+    role,
+  };
+  const has = (pred: (sp: SpellDef | undefined) => boolean): boolean =>
+    ctx.phases.buffs.some(
+      (r) => r.action.kind === 'spell'
+        && pred(ctx.knownById.get(r.action.spellId) ?? ctx.ds.spell(r.action.spellId)),
+    );
+  if (!has((sp) => blessingFamilyOf(sp) != null)) {
+    const own = planPaladinBlessings(
+      [provider],
+      [{ key: 'self', cls: ctx.char.cls, role }],
+      ctx.ds,
+      { preferGreater: false },
+    ).blessings[0];
+    if (own) {
+      ctx.phases.buffs.push({
+        id: ctx.nextFallbackId(),
+        action: { kind: 'spell', spellId: own.spellId },
+        conditions: [cond('self', 'buffPresent', '==', 0, own.spellId)],
+        enabled: true,
+      });
+      ctx.usedSpellsByPhase.buffs.add(own.spellId);
+    }
+  }
+  // Only ADD a missing aura row. Which aura beats which is CheckAuras' call and its first clause
+  // reads "is there a tank in the group" (:414-432) — a fact a single-unit rotation build cannot
+  // see. paladinPrePull.restampPaladinRotation makes that call once the party is known.
+  if (!has((sp) => paladinAuraOf(sp) != null)) {
+    const aura = planPaladinAuras([provider], ctx.ds)[0];
+    if (aura) {
+      ctx.phases.buffs.push({
+        id: ctx.nextFallbackId(),
+        action: { kind: 'spell', spellId: aura.spellId },
+        conditions: [cond('self', 'buffPresent', '==', 0, aura.spellId)],
+        enabled: true,
+      });
+      ctx.usedSpellsByPhase.buffs.add(aura.spellId);
+    }
+  }
+  rebuildPhaseUsed(ctx, 'buffs');
+}
+
+// Left behind by every MECHANIC_INVULNERABILITY cast, and it locks out the next one.
+// Cite: Spell.cpp:3144-3145 AddPrecastSpell(25771).
+const FORBEARANCE_ID = 25771;
+
+// The one paladin invulnerability aimed at somebody ELSE. Divine Shield / Divine Protection carry
+// the same mechanic on the CASTER, so the target column is what separates them.
+function isProtectionBlessing(sp: SpellDef | undefined): boolean {
+  if (!sp || sp.mechanic !== 'invulnerability') return false;
+  if ((sp.id | 0) === FORBEARANCE_ID) return false;
+  return auraHolderIsCastTarget(sp);
+}
+
+const allyCond = (
+  metric: 'healthPct' | 'buffPresent',
+  op: '<' | '==',
+  value: number,
+  ally: AllyFilter,
+  ref?: number,
+): Condition => ({ subject: 'ally', metric, op, value, ally, ...(ref != null ? { ref } : {}) });
+
+// A tank is never a band: it holds threat on purpose, and BoP drops it.
+// Cite: PlayerbotPaladinAI.cpp:305-313 (hp < 25 && JOB_HEAL) || (hp < 15 && !JOB_TANK).
+const BOP_BANDS: readonly { filter: AllyFilter; hpPct: number }[] = [
+  { filter: { role: 'healer' }, hpPct: 25 },
+  { filter: { notRole: 'tank' }, hpPct: 15 },
+];
+
+// One row per band: `allyFilterOfRule` takes the FIRST ally filter, so a shared row would aim both
+// bands at the healer bar. Cite: evaluate.ts allyFilterOfRule.
+function finalizePaladinProtection(ctx: FinalizeContext): void {
+  // PvP too: PaladinAI.cpp:268-273 PVP→PVE FindTargetAndHeal, HealPlayer :304-313.
+  const bop = ctx.known
+    .filter((sp) => isProtectionBlessing(sp))
+    .sort((a, b) => (b.rank ?? 0) - (a.rank ?? 0) || b.id - a.id)[0];
+  if (!bop) return;
+  const phase: RotationPhase = 'combat';
+  // Skip only an already-aimed ally row. Self-BoP (every pvp holy band) is not that.
+  if (ctx.phases[phase].some((r) => {
+    if (r.action.kind !== 'spell') return false;
+    if (!isProtectionBlessing(ctx.knownById.get(r.action.spellId) ?? ctx.ds.spell(r.action.spellId))) {
+      return false;
+    }
+    return r.conditions.some((c) => c.subject === 'ally');
+  })) return;
+  const rows: RotationRule[] = BOP_BANDS.map(({ filter, hpPct }) => ({
+    id: ctx.nextFallbackId(),
+    action: { kind: 'spell', spellId: bop.id },
+    conditions: [
+      allyCond('healthPct', '<', hpPct, filter),
+      // Through Forbearance the cast is wasted; on a body already holding BoP it is a re-cast.
+      allyCond('buffPresent', '==', 0, filter, FORBEARANCE_ID),
+      allyCond('buffPresent', '==', 0, filter, bop.id),
+    ],
+    enabled: true,
+  }));
+  // Ahead of the damage tail: a 15% non-tank outranks a Judgement.
+  ctx.phases[phase].unshift(...rows);
+  rebuildPhaseUsed(ctx, phase);
+}
+
+export const paladinHooks: ClassRotationHooks = {
+  afterSuggestion(ctx) {
+    finalizePaladinPhases(ctx);
+    finalizePaladinHoJ(ctx);
+    if (/^holy$/i.test(ctx.spec)) gateSupportDamageRows(ctx);
+  },
+  afterFallback(ctx) {
+    // Re-finalize after fallback so role-bucket cannot re-introduce a rival seal (KI-217).
+    finalizePaladinPhases(ctx);
+    finalizePaladinHoJ(ctx);
+    finalizePaladinBlessingAndAura(ctx);
+    finalizePaladinProtection(ctx);
+    // Seal and Judgement cost the Holy paladin nothing; Exorcism / Holy Wrath / Consecration do.
+    if (/^holy$/i.test(ctx.spec)) gateSupportDamageRows(ctx);
+  },
+};

package/src/domain/rotation/classes/priest.ts

@@ -0,0 +1,94 @@
+// PURE: no DOM/RNG/Date. Priest rotation post-pass + kit policy.
+
+import { SHAPESHIFT_FORM, type SpellDef } from '../../../data/schema.ts';
+import { cond, isMultiTargetCombatSpell } from '../classify.ts';
+import type { ClassRotationHooks, FinalizeContext } from './hooks.ts';
+import { rebuildPhaseUsed } from './hooks.ts';
+import { gateSupportDamageRows } from './supportSpec.ts';
+
+/** Canonical tree → combat damage schools allowed in role-bucket fallback. */
+const PRIEST_FALLBACK_SCHOOLS: Readonly<Record<string, ReadonlySet<string>>> = {
+  Shadow: new Set(['shadow']),
+  Holy: new Set(['holy']),
+  Discipline: new Set(['holy']),
+};
+
+function schoolAllowed(spell: SpellDef, spec: string): boolean {
+  const allowed = PRIEST_FALLBACK_SCHOOLS[spec];
+  if (!allowed) return true;
+  if (isMultiTargetCombatSpell(spell)) return true;
+  const school = (spell.school ?? '').toLowerCase();
+  if (allowed.has(school)) return true;
+  return false;
+}
+
+function isHolyHealSpell(spell: SpellDef): boolean {
+  if ((spell.school ?? '').toLowerCase() !== 'holy') return false;
+  return spell.effects.some(
+    (e) => e.kind === 'heal' || e.kind === 'restore_health' || e.kind === 'heal_max_health',
+  );
+}
+
+// Shadowform forbids Holy, and recovery holy heals used to win the GCD or drop the form, so the
+// priest died without a shadow spell. Gate holy heals on being out of form; keep PW:S and Fade.
+function finalizeShadowRecovery(ctx: FinalizeContext): void {
+  if (!/^shadow$/i.test(ctx.spec)) return;
+  const sf = SHAPESHIFT_FORM.SHADOWFORM;
+  ctx.phases.recovery = ctx.phases.recovery.map((r) => {
+    if (r.action.kind !== 'spell') return r;
+    const sp = ctx.knownById.get(r.action.spellId) ?? ctx.ds.spell(r.action.spellId);
+    if (!sp || !isHolyHealSpell(sp)) return r;
+    if (r.conditions.some((c) => c.metric === 'formId')) return r;
+    return { ...r, conditions: [...r.conditions, cond('self', 'formId', '!=', sf)] };
+  });
+  const inject = (
+    phase: 'recovery' | 'combat',
+    spell: SpellDef | undefined,
+    conditions: ReturnType<typeof cond>[],
+  ): void => {
+    if (!spell) return;
+    if (ctx.phases[phase].some((r) => r.action.kind === 'spell' && r.action.spellId === spell.id)) {
+      return;
+    }
+    ctx.phases[phase].unshift({
+      id: ctx.nextFallbackId(),
+      action: { kind: 'spell', spellId: spell.id },
+      conditions,
+      enabled: true,
+    });
+  };
+  const pws = ctx.known.find((s) => /^power word: shield$/i.test(s.name));
+  const fade = ctx.known.find((s) => /^fade$/i.test(s.name));
+  const form = ctx.known.find((s) => /^shadowform$/i.test(s.name));
+  inject('recovery', fade, [cond('self', 'hasAggro', '==', 1)]);
+  if (pws) {
+    inject('recovery', pws, [
+      cond('self', 'healthPct', '<', 50),
+      cond('self', 'buffPresent', '==', 0, pws.id),
+    ]);
+  }
+  inject('combat', form, [cond('self', 'formId', '!=', sf)]);
+  rebuildPhaseUsed(ctx, 'recovery');
+  rebuildPhaseUsed(ctx, 'combat');
+}
+
+// Holy and Discipline both heal the party. Their lists ended Holy Fire -> SW:P -> Smite with no
+// gate on any of them, which is the bar a 60 priest arrives at the last pull without.
+function finalizeHealerDamage(ctx: FinalizeContext): void {
+  if (!/^(holy|discipline)$/i.test(ctx.spec)) return;
+  gateSupportDamageRows(ctx);
+}
+
+export const priestHooks: ClassRotationHooks = {
+  allowFallbackSpell(spell, spec) {
+    return schoolAllowed(spell, spec);
+  },
+  afterSuggestion(ctx) {
+    finalizeShadowRecovery(ctx);
+    finalizeHealerDamage(ctx);
+  },
+  afterFallback(ctx) {
+    finalizeShadowRecovery(ctx);
+    finalizeHealerDamage(ctx);
+  },
+};

package/src/domain/rotation/classes/pullOpener.ts

@@ -0,0 +1,92 @@
+// Caster kits pull by STARTING a cast-time nuke, not by dumping an instant while walking in. An
+// empty pull phase falls through to combat, which is how priests opened with an instant DoT.
+
+import { inferRole } from '../../../engine/combat/roles.ts';
+import { isMultiTargetCombatSpell } from '../classify.ts';
+import type { FinalizeContext } from './hooks.ts';
+import type { SpellDef } from '../../../data/schema.ts';
+
+const CASTER_CLASS = new Set(['mage', 'warlock', 'priest']);
+const CASTER_SPEC = /^(frost|fire|arcane|affliction|demonology|destruction|shadow|holy|discipline|elemental|balance)\b/i;
+
+function isCasterKit(ctx: FinalizeContext): boolean {
+  if (CASTER_CLASS.has(ctx.classKey)) return true;
+  return CASTER_SPEC.test(ctx.spec);
+}
+
+function isCastTimePullNuke(s: SpellDef): boolean {
+  if ((s.castTimeMs ?? 0) <= 0) return false;
+  if ((s.channelMs ?? 0) > 0) return false;
+  if (isMultiTargetCombatSpell(s)) return false;
+  const role = s.role ?? inferRole(s);
+  return role === 'nuke' || role === 'dot';
+}
+
+// Yards a pull is opened from — the ranged stand band. Only used to turn a projectile's SpellDef.speed
+// (yards/sec) into the travel time it actually spends in the air.
+const PULL_OPEN_YD = 30;
+
+// Time from pressing the button to the damage LANDING: cast time plus missile flight. A projectile
+// keeps travelling after the cast bar ends; a direct-land cast does not. Cite: Spell.cpp speed.
+function timeToLandMs(s: SpellDef): number {
+  const cast = s.castTimeMs ?? 0;
+  const speed = s.speed ?? 0;
+  const travel = speed > 0 ? Math.round((PULL_OPEN_YD / speed) * 1000) : 0;
+  return cast + travel;
+}
+
+// Order the opener so the slowest-landing cast goes FIRST and the sequence lands together. Only
+// cast-time nukes are reordered among themselves — stances, shouts and buffs keep their slot.
+export function orderPullByTimeToLand(ctx: FinalizeContext): void {
+  const pull = ctx.phases.pull;
+  const idx: number[] = [];
+  for (let i = 0; i < pull.length; i++) {
+    const r = pull[i]!;
+    if (!r.enabled || r.action.kind !== 'spell') continue;
+    const s = ctx.knownById.get(r.action.spellId);
+    if (s && isCastTimePullNuke(s)) idx.push(i);
+  }
+  if (idx.length < 2) return;
+  const sorted = idx
+    .slice()
+    .sort((a, b) => {
+      const sa = ctx.knownById.get((pull[a]!.action as { spellId: number }).spellId)!;
+      const sb = ctx.knownById.get((pull[b]!.action as { spellId: number }).spellId)!;
+      const d = timeToLandMs(sb) - timeToLandMs(sa);
+      return d !== 0 ? d : a - b; // stable: authored order breaks ties
+    })
+    .map((i) => pull[i]!);
+  idx.forEach((slot, k) => { pull[slot] = sorted[k]!; });
+}
+
+export function ensureCastTimePullOpener(ctx: FinalizeContext): void {
+  if (!isCasterKit(ctx)) return;
+  const hasCastPull = ctx.phases.pull.some((r) => {
+    if (!r.enabled || r.action.kind !== 'spell') return false;
+    const s = ctx.knownById.get(r.action.spellId);
+    return !!s && isCastTimePullNuke(s);
+  });
+  if (hasCastPull) return;
+  for (const r of ctx.phases.combat) {
+    if (!r.enabled || r.action.kind !== 'spell') continue;
+    const s = ctx.knownById.get(r.action.spellId);
+    if (!s || !isCastTimePullNuke(s)) continue;
+    if (r.conditions.some((c) =>
+      c.metric === 'castingPresent'
+      || c.metric === 'creatureTypeMask'
+      || (c.metric === 'healthPct' && c.subject === 'target')
+    )) {
+      continue;
+    }
+    ctx.phases.pull.unshift({
+      id: ctx.nextFallbackId(),
+      action: { kind: 'spell', spellId: s.id },
+      conditions: r.conditions.filter((c) =>
+        c.metric === 'debuffPresent' || c.metric === 'formId' || c.metric === 'inCombat',
+      ),
+      enabled: true,
+    });
+    ctx.usedSpellsByPhase.pull.add(s.id);
+    return;
+  }
+}

package/src/domain/rotation/classes/rogue.ts

@@ -0,0 +1,69 @@
+// PURE: no DOM/RNG/Date. Rogue rotation post-pass + kit policy.
+// Shared pipeline + JSON pack cover current rogue needs; class fixes land here.
+
+import { cond } from '../classify.ts';
+import { expandFinisherLadder } from '../finisherLadder.ts';
+import { rebuildPhaseUsed, type ClassRotationHooks, type FinalizeContext } from './hooks.ts';
+import type { RotationRule } from '../types.ts';
+import { bestFamilyItem, consumableFamilyKey } from '../../items/consumableFamily.ts';
+import { INSTANT_POISON_ITEM, isPoisonCraftRecipe } from '../../professions/poisons.ts';
+
+// A poisons vial is CRAFTED in the profession tab and never cast: oocCastMethods.ts:75 refuses a
+// poison craft with "Craft that from the profession tab". A craft row in buffs therefore stops the
+// whole pre-pull prep loop at itself (liveRunControl.ts:401 breaks on the first refusal), so the
+// rogue's authored poison rows are the two COATS instead — the item, on each hand.
+function isPoisonCraftRow(ctx: FinalizeContext, r: RotationRule): boolean {
+  return r.action.kind === 'spell' && isPoisonCraftRecipe(ctx.ds.recipe(r.action.spellId));
+}
+
+// Best Instant Poison rank this rogue can use, resolved as a family LADDER so the row follows the
+// bags: 6947 is the r1 vial the profession grants (poisons.ts INSTANT_POISON_ITEM) and anchors the
+// ladder. Bags win over the catalog, and requiredLevel 20 is what keeps the row off a low rogue.
+function instantPoisonCoatRows(ctx: FinalizeContext): RotationRule[] {
+  const family = consumableFamilyKey(ctx.ds.item(INSTANT_POISON_ITEM), ctx.ds);
+  if (!family) return [];
+  const best = bestFamilyItem(family, ctx.ds, {
+    char: ctx.char,
+    ...(ctx.inventory ? { inventory: ctx.inventory } : {}),
+  });
+  if (!best) return [];
+  // ref 0 is mainhand and 1 is offhand, the same gate a hand-added imbue row gets (build.ts:415).
+  return (['mainhand', 'offhand'] as const).map((hand, i) => ({
+    id: ctx.nextFallbackId(),
+    action: { kind: 'item' as const, itemEntry: best.entry, family, hand },
+    conditions: [cond('self', 'weaponImbuePresent', '==', 0, i)],
+    enabled: true,
+  }));
+}
+
+function finalizeRoguePoisonBuffs(ctx: FinalizeContext): void {
+  const kept = ctx.phases.buffs.filter((r) => !isPoisonCraftRow(ctx, r));
+  const coats = ctx.phases.buffs.some((r) => r.action.kind === 'item' && r.action.hand != null)
+    ? []
+    : instantPoisonCoatRows(ctx);
+  if (kept.length === ctx.phases.buffs.length && !coats.length) return;
+  ctx.phases.buffs = [...coats, ...kept];
+  rebuildPhaseUsed(ctx, 'buffs');
+}
+
+// Eviscerate on the ladder instead of a bare `combo points >= 4`. finisherLadder.ts owns the rungs.
+function finalizeRogueFinishers(ctx: FinalizeContext): void {
+  // PvE only. A duel has no "it will die inside two builder GCDs" that a trinket cannot undo, and
+  // pvp rogue burst is authored against Cold Blood windows in the duel lab, not against a band.
+  if (ctx.mode === 'pvp') return;
+  const spellOf = (id: number) => ctx.knownById.get(id) ?? ctx.ds.spell(id);
+  if (expandFinisherLadder(ctx.phases.combat, spellOf, ctx.nextFallbackId)) {
+    rebuildPhaseUsed(ctx, 'combat');
+  }
+}
+
+export const rogueHooks: ClassRotationHooks = {
+  afterSuggestion(ctx) {
+    finalizeRoguePoisonBuffs(ctx);
+    finalizeRogueFinishers(ctx);
+  },
+  afterFallback(ctx) {
+    finalizeRoguePoisonBuffs(ctx);
+    finalizeRogueFinishers(ctx);
+  },
+};

package/src/domain/rotation/classes/shaman.ts

@@ -0,0 +1,29 @@
+// Shaman rotation post-pass and kit policy. Pure. Ghost Wolf is travel-only and never a combat form
+// enter — pickAction cancels it to fight.
+
+import type { ClassRotationHooks, FinalizeContext } from './hooks.ts';
+import {
+  gateSupportDamageOnTopped,
+  gateSupportDamageRows,
+  hoistSupportHealsIntoCombat,
+} from './supportSpec.ts';
+
+/** Restoration: heals in the combat list, and no mana on damage while in a party. */
+function restoFinalize(ctx: FinalizeContext): void {
+  if (!/^restoration$/i.test(ctx.spec)) return;
+  hoistSupportHealsIntoCombat(ctx);
+  gateSupportDamageOnTopped(ctx);
+  gateSupportDamageRows(ctx);
+}
+
+export const shamanHooks: ClassRotationHooks = {
+  allowFormFallback() {
+    return false;
+  },
+  afterSuggestion(ctx) {
+    restoFinalize(ctx);
+  },
+  afterFallback(ctx) {
+    restoFinalize(ctx);
+  },
+};

package/src/domain/rotation/classes/supportSpec.ts

@@ -0,0 +1,94 @@
+// PURE: no DOM/RNG/Date. The healing-tree post-pass, shared by all four healer trees. Resto druid
+// and resto shaman each held a copy; priest Holy/Discipline and paladin Holy held neither.
+
+import type { SpellDef } from '../../../data/schema.ts';
+import { inferRole } from '../../../engine/combat.ts';
+import { cond } from '../classify.ts';
+import type { Condition, RotationPhase, RotationRule } from '../types.ts';
+import type { FinalizeContext } from './hooks.ts';
+import { rebuildPhaseUsed } from './hooks.ts';
+
+/** Party health above which a healer may spend the GCD on damage at all. */
+const TOPPED_PCT = 90;
+
+/** Roles a healer pays mana for damage with. `shoot` (the wand) and `control` are not on it. */
+const DAMAGE_ROLES: ReadonlySet<string> = new Set(['nuke', 'instant_nuke', 'dot']);
+
+function isPartyHealSpell(spell: SpellDef): boolean {
+  return spell.effects.some(
+    (e) =>
+      e.kind === 'heal'
+      || e.kind === 'restore_health'
+      || e.kind === 'heal_max_health'
+      || e.kind === 'holy_shock',
+  );
+}
+
+// A healer in a GROUP spends no mana on damage; solo it keeps the kit. The wand, Judgement, the
+// dispels, the interrupts and the CC rows stay — deleting the one condition hands the damage back.
+export function gateSupportDamageRows(ctx: FinalizeContext): void {
+  if (ctx.mode === 'pvp') return; // hand-authored fight lists; the duel/arena lab benches those
+  addToDamageRows(ctx, cond('self', 'partySeats', '<=', 1), ['pull', 'combat']);
+}
+
+/** Hold damage until the party is topped. Resto shaman / druid have shipped this since the packs. */
+export function gateSupportDamageOnTopped(ctx: FinalizeContext): void {
+  addToDamageRows(ctx, cond('self', 'allyLowestHpPct', '>=', TOPPED_PCT), ['combat']);
+}
+
+/** Append `extra` to every mana-for-damage row in `phases` that does not already carry its metric. */
+function addToDamageRows(
+  ctx: FinalizeContext,
+  extra: Condition,
+  phases: readonly RotationPhase[],
+): void {
+  const defOf = (id: number): SpellDef | undefined => ctx.knownById.get(id) ?? ctx.ds.spell(id);
+  for (const phase of phases) {
+    ctx.phases[phase] = ctx.phases[phase].map((r: RotationRule) => {
+      if (r.action.kind !== 'spell') return r;
+      if (r.conditions.some((c) => c.metric === extra.metric)) return r;
+      const sp = defOf(r.action.spellId);
+      if (!sp || isPartyHealSpell(sp)) return r;
+      if (!DAMAGE_ROLES.has(sp.role ?? inferRole(sp))) return r;
+      return { ...r, conditions: [...r.conditions, extra] };
+    });
+    rebuildPhaseUsed(ctx, phase);
+  }
+}
+
+// Resto combat was all Balance: heals lived only in recovery at <75%, so Wrath ate the GCD while
+// the tank sat at 75-90%. Copies ally heals into combat; the callers gate the damage rows.
+export function hoistSupportHealsIntoCombat(ctx: FinalizeContext): void {
+  const defOf = (id: number): SpellDef | undefined => ctx.knownById.get(id) ?? ctx.ds.spell(id);
+  const isHealRule = (r: RotationRule): boolean => {
+    if (r.action.kind !== 'spell') return false;
+    const sp = defOf(r.action.spellId);
+    return !!sp && isPartyHealSpell(sp);
+  };
+  const heals = ctx.phases.recovery.filter(isHealRule).map((r) => {
+    if (r.action.kind !== 'spell') return r;
+    const next = r.conditions.map((c) =>
+      c.metric === 'allyLowestHpPct' && c.op === '<' && c.value === 75
+        ? { ...c, value: 80 }
+        : c,
+    );
+    return next === r.conditions ? r : { ...r, conditions: next };
+  });
+  ctx.phases.recovery = ctx.phases.recovery.map((r) => {
+    const hit = heals.find((h) =>
+      h.action.kind === 'spell' && r.action.kind === 'spell' && h.action.spellId === r.action.spellId,
+    );
+    return hit ?? r;
+  });
+  const combatHealIds = new Set(
+    ctx.phases.combat.filter(isHealRule).map((r) =>
+      r.action.kind === 'spell' ? r.action.spellId : -1,
+    ),
+  );
+  const toAdd = heals.filter((r) =>
+    r.action.kind === 'spell' && !combatHealIds.has(r.action.spellId),
+  );
+  ctx.phases.combat = [...toAdd, ...ctx.phases.combat];
+  rebuildPhaseUsed(ctx, 'combat');
+  rebuildPhaseUsed(ctx, 'recovery');
+}