azeroth-shell 0.0.0-stage → 0.1.1

package/src/domain/spells/equipSpells.ts

@@ -0,0 +1,247 @@
+// ITEM_SPELLTRIGGER_ON_EQUIP materialization — equip auras plus ENCHANT_HELD_ITEM chains. We keep
+// the combat kit on the temp slot while the item stays equipped, and never overwrite another coat.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { ItemDef } from '../../data/schema.ts';
+import type { Character, TempEnchantState } from '../character/character.ts';
+import { applyAura, equippedItems, getActiveBuffIds } from '../character/characterStats.ts';
+import { applyTempEnchant, clearTempEnchantHand, getTempEnchant } from '../professions/characterEnchants.ts';
+import {
+  combatPayloadFromSpell,
+  kitFromItemEnchant,
+} from '../../engine/spells/interpreter/weapon-imbue-kit.ts';
+import { SPELL_EFFECT_ENCHANT_HELD_ITEM } from '../../engine/spells/interpreter/opcodes.ts';
+import { AD_COMMISSION_AURA_SPELL_IDS } from '../../engine/spells/conditions.ts';
+
+/** Resolved held-item combat kit from an equip-spell chain (Firestone Passive → Effect → enchant). */
+export interface HeldEnchantFromEquip {
+  /** Passive equip spell (e.g. 758 Firestone Passive). */
+  passiveSpellId: number;
+  /** Intermediate ENCHANT_HELD_ITEM spell (e.g. 1054). */
+  effectSpellId: number;
+  enchantId: number;
+  combatSpellId: number;
+  combat: NonNullable<TempEnchantState['combat']>;
+  combatChancePct?: number;
+  combatPpm?: number;
+}
+
+// Walk equip-spell → proc_trigger (or raw trigger) → ENCHANT_HELD_ITEM (92) → combat kit. Returns undefined
+// when the chain is absent or has no combat_spell payload.
+export function heldItemEnchantFromEquipSpell(
+  ds: DataStore,
+  equipSpellId: number,
+): HeldEnchantFromEquip | undefined {
+  const passive = ds.spell(equipSpellId);
+  if (!passive) return undefined;
+
+  // Prefer baked proc_trigger_spell; fall back to raw APPLY_AURA triggerSpell.
+  let effectSpellId: number | undefined;
+  for (const e of passive.effects ?? []) {
+    if (e.kind === 'proc_trigger_spell' && e.triggerSpellId) {
+      effectSpellId = e.triggerSpellId | 0;
+      break;
+    }
+  }
+  if (effectSpellId == null) {
+    for (const r of passive.rawEffects ?? []) {
+      const trig = r.triggerSpell | 0;
+      if (trig > 0) {
+        effectSpellId = trig;
+        break;
+      }
+    }
+  }
+  if (effectSpellId == null || effectSpellId <= 0) return undefined;
+
+  const effectSpell = ds.spell(effectSpellId);
+  if (!effectSpell) return undefined;
+
+  let enchantId = 0;
+  for (const r of effectSpell.rawEffects ?? []) {
+    if ((r.effect | 0) === SPELL_EFFECT_ENCHANT_HELD_ITEM && (r.miscValue | 0) > 0) {
+      enchantId = r.miscValue | 0;
+      break;
+    }
+  }
+  if (enchantId <= 0) return undefined;
+
+  const ench = ds.itemEnchant?.(enchantId);
+  if (!ench) return undefined;
+
+  const kit = kitFromItemEnchant(ench, (id) => {
+    const sp = ds.spell(id);
+    return sp ?? undefined;
+  });
+  if (!kit?.combatSpellId) return undefined;
+
+  let combat = kit.combat;
+  if (!combat) {
+    const proc = ds.spell(kit.combatSpellId);
+    if (proc) combat = combatPayloadFromSpell(proc);
+  }
+  if (!combat?.direct && !combat?.dot) return undefined;
+
+  return {
+    passiveSpellId: equipSpellId,
+    effectSpellId,
+    enchantId,
+    combatSpellId: kit.combatSpellId,
+    combat,
+    ...(kit.combatChancePct != null ? { combatChancePct: kit.combatChancePct } : {}),
+    ...(kit.combatPpm != null ? { combatPpm: kit.combatPpm } : {}),
+  };
+}
+
+/** First held-enchant chain among an item's equipSpells (Firestone ranks). */
+export function heldItemEnchantFromItem(
+  ds: DataStore,
+  item: ItemDef | undefined,
+): HeldEnchantFromEquip | undefined {
+  if (!item?.equipSpells?.length) return undefined;
+  for (const sid of item.equipSpells) {
+    const held = heldItemEnchantFromEquipSpell(ds, sid);
+    if (held) return held;
+  }
+  return undefined;
+}
+
+// Scan all equipped gear for a Firestone-style held enchant chain. Cite: Player.cpp ApplyItemEquipSpell on
+// each equipped item.
+export function heldItemEnchantFromEquipped(
+  char: Pick<Character, 'equipped'>,
+  ds: DataStore,
+): HeldEnchantFromEquip | undefined {
+  for (const it of equippedItems(char as Character, ds)) {
+    const held = heldItemEnchantFromItem(ds, it);
+    if (held) return held;
+  }
+  return undefined;
+}
+
+// Apply equip-trigger combat surfaces for `item`: a permanent aura for passives carrying a proc or
+// damage shield, and a main-hand temp enchant for a held-item chain. Stat-only equips are skipped.
+export function applyItemEquipSpells(
+  char: Character,
+  item: ItemDef | undefined,
+  ds: DataStore,
+  now: number = Date.now(),
+): Character {
+  if (!item?.equipSpells?.length) return char;
+  let next = char;
+
+  for (const sid of item.equipSpells) {
+    const sp = ds.spell(sid);
+    if (!sp) continue;
+
+    // Combat aura shells: proc triggers and damage shields, and SPELL_AURA_DUMMY too. Pure stat
+    // buffs already collapsed into ItemDef.equipMods are skipped.
+    const hasCombatAura = (sp.effects ?? []).some(
+      (e) => e.kind === 'proc_trigger_spell' || e.kind === 'damage_shield',
+    );
+    const rawHasProcTrigger = (sp.rawEffects ?? []).some(
+      (r) => (r.effect | 0) === 6 && ((r.auraName | 0) === 42 || (r.auraName | 0) === 23)
+        && (r.triggerSpell | 0) > 0,
+    );
+    const rawDummy = (sp.rawEffects ?? []).some(
+      (r) => (r.effect | 0) === 6 && (r.auraName | 0) === 4,
+    );
+    // Seal/Rune/Mark of the Champion are AP/SP auras, not dummy — still HasAura for type 10.
+    // Cite: Conditions.cpp:228-234; Player.cpp ApplyItemEquipSpell.
+    const adCommission = AD_COMMISSION_AURA_SPELL_IDS.has(sid);
+    if (hasCombatAura || rawHasProcTrigger || rawDummy || adCommission) {
+      // durationMs undefined → permanent while equipped (ITEM_SPELLTRIGGER_ON_EQUIP).
+      next = applyAura(next, sid, undefined, now, ds);
+    }
+  }
+
+  const held = heldItemEnchantFromItem(ds, item);
+  if (held) {
+    next = applyHeldEnchantIfFree(next, held, ds, now);
+  }
+  return next;
+}
+
+/** Remove equip auras + firestone held enchant when `item` leaves the paperdoll. */
+export function removeItemEquipSpells(
+  char: Character,
+  item: ItemDef | undefined,
+  ds: DataStore,
+  now: number = Date.now(),
+): Character {
+  if (!item?.equipSpells?.length) return char;
+  let next = char;
+
+  const held = heldItemEnchantFromItem(ds, item);
+  if (held) {
+    const te = getTempEnchant(next, 'mainhand', now);
+    if (te && te.enchantId === held.enchantId) {
+      next = clearTempEnchantHand(next, 'mainhand', now, ds);
+    }
+  }
+
+  // Drop permanent equip-spell auras that this item owned.
+  const drop = new Set(item.equipSpells);
+  if (next.activeAuras?.some((a) => drop.has(a.spellId))) {
+    const auras = (next.activeAuras ?? []).filter((a) => !drop.has(a.spellId));
+    next = {
+      ...next,
+      activeAuras: auras,
+      activeBuffs: getActiveBuffIds({ ...next, activeAuras: auras }, now, ds),
+    };
+  }
+  return next;
+}
+
+// After a main-hand swap or unequip of a poison, re-apply a held enchant from the remaining equip.
+// A no-op when the main hand already has a different temp enchant.
+export function syncHeldEnchantFromEquipped(
+  char: Character,
+  ds: DataStore,
+  now: number = Date.now(),
+): Character {
+  const held = heldItemEnchantFromEquipped(char, ds);
+  if (!held) return char;
+  return applyHeldEnchantIfFree(char, held, ds, now);
+}
+
+function applyHeldEnchantIfFree(
+  char: Character,
+  held: HeldEnchantFromEquip,
+  ds: DataStore,
+  now: number,
+): Character {
+  const existing = getTempEnchant(char, 'mainhand', now);
+  // EffectEnchantHeldItem: do not overwrite a different temp enchant (poison/oil/shaman).
+  if (existing && existing.enchantId !== held.enchantId) return char;
+
+  // Refresh same enchant or apply fresh. No expiresAt — lives while equip item is worn
+  // (vanilla re-applies every 5s for 10s; we keep authority continuous while equipped).
+  const state: TempEnchantState = {
+    spellId: held.passiveSpellId,
+    enchantId: held.enchantId,
+    combatSpellId: held.combatSpellId,
+    combat: held.combat,
+    ...(held.combatChancePct != null ? { combatChancePct: held.combatChancePct } : {}),
+    ...(held.combatPpm != null ? { combatPpm: held.combatPpm } : {}),
+  };
+  return applyTempEnchant(char, 'mainhand', state, now, ds);
+}
+
+// Combat-time kit for buildCombatant when char.tempEnchants is empty but a firestone (or similar) is still
+// equipped — e.g. after poison expiry mid-session.
+export function combatHeldEnchantFromEquipped(
+  char: Pick<Character, 'equipped'>,
+  ds: DataStore,
+): TempEnchantState | undefined {
+  const held = heldItemEnchantFromEquipped(char, ds);
+  if (!held) return undefined;
+  return {
+    spellId: held.passiveSpellId,
+    enchantId: held.enchantId,
+    combatSpellId: held.combatSpellId,
+    combat: held.combat,
+    ...(held.combatChancePct != null ? { combatChancePct: held.combatChancePct } : {}),
+    ...(held.combatPpm != null ? { combatPpm: held.combatPpm } : {}),
+  };
+}

package/src/domain/spells/learnOnTargets.ts

@@ -0,0 +1,260 @@
+// Who can learn a teach item out of the player's bags — a recipe, an enchant formula, a class book or
+// a pet grimoire. Pure: DataStore and party state in, candidate list out. The UI builds the picker.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { ItemDef } from '../../data/schema.ts';
+import type { Character } from '../character/character.ts';
+import type { SpellBook } from '../character/spellbook.ts';
+import type { Companion } from '../bots/squad.ts';
+import { companionLevel, companionSkillMap, companionSpellbook } from '../bots/squad.ts';
+import { className } from '../core/ids.ts';
+import { knows } from '../character/spellbook.ts';
+import { petRepertoireHas } from '../pet/pet.ts';
+import { isSpellFitByClassAndRace, spellHasClassRestrictingAbility } from '../character/combatSkills.ts';
+import { itemTeachIntent, type ItemTeach } from '../items/itemTeaches.ts';
+
+export type LearnOnWho = 'self' | string; // companion id
+
+// Every body the engine will actually teach, deduped by id. MUST stay the same three pools the squad
+// lookup uses: reading only two hid a 39-man raid's hunters from a tome they could learn.
+export function learnOnCompanionPool(
+  squad: readonly Companion[] | undefined,
+  botRoster: Readonly<Record<string, Companion>> | undefined,
+  raidMembers: Readonly<Record<string, Companion>> | undefined,
+): Companion[] {
+  const byId = new Map<string, Companion>();
+  for (const c of squad ?? []) byId.set(c.id, c);
+  for (const c of Object.values(botRoster ?? {})) byId.set(c.id, c);
+  for (const c of Object.values(raidMembers ?? {})) byId.set(c.id, c);
+  return [...byId.values()];
+}
+
+/** Teach kinds a party member other than the player can study. */
+export type LearnOnKind = 'recipe' | 'enchant' | 'spell' | 'petSpell';
+
+export interface LearnOnCandidate {
+  who: LearnOnWho;
+  name: string;
+  /** e.g. "Blacksmithing 150" for a recipe, "Druid 54" for a class book. */
+  skillLabel?: string;
+  /** Short reason when ineligible (shown greyed); omit when ok. */
+  reason?: string;
+  /** They already hold it. A book nobody can read for THIS reason is vendor stock. */
+  known?: boolean;
+}
+
+export interface LearnOnProbe {
+  teach: ItemTeach;
+  kind: LearnOnKind;
+  teachName: string;
+  /** Requirement line under the title, already worded for this kind. Empty = no line. */
+  reqLabel: string;
+  /** What to say when nobody can take the book. */
+  noneLabel: string;
+  /** Eligible first, then rejected (so the UI can list "who can" prominently). */
+  candidates: LearnOnCandidate[];
+  eligibleCount: number;
+}
+
+// Probe everyone in the party who might study this item. A profession tier book returns null, since
+// it raises the READER's own line. A body who cannot use it is greyed, not dropped.
+export function probeLearnOnTargets(
+  itemEntry: number,
+  ds: DataStore,
+  char: Character,
+  companions: readonly Companion[],
+  /** The player's own spellbook — needed to grey "Already known" on a class book. */
+  playerBook?: SpellBook,
+): LearnOnProbe | null {
+  const it = ds.item(itemEntry);
+  const teach = itemTeachIntent(it, ds);
+  if (!it) return null;
+  if (teach?.kind === 'spell' || teach?.kind === 'petSpell') {
+    return probeSpellBook(it, teach, ds, char, companions, playerBook);
+  }
+  if (!teach || (teach.kind !== 'recipe' && teach.kind !== 'enchant')) return null;
+
+  let teachName = '';
+  let skillLine: keyof Character['skills'] | null = null;
+  let reqSkill = 0;
+  if (teach.kind === 'recipe') {
+    const r = ds.recipe(teach.id);
+    if (!r) return null;
+    teachName = r.name;
+    skillLine = r.skill;
+    reqSkill = r.orange | 0;
+  } else {
+    const e = ds.enchant(teach.id);
+    if (!e) return null;
+    teachName = e.name;
+    skillLine = 'enchanting';
+    reqSkill = e.orange | 0;
+  }
+
+  const skillName = skillLine
+    ? (ds.profession(skillLine as never)?.name ?? String(skillLine))
+    : 'Unknown';
+
+  const candidates: LearnOnCandidate[] = [];
+  /** Does this body already hold the row? Same catalog per kind for the player and a companion. */
+  const holds = (b: { knownRecipes?: number[]; knownEnchants?: number[] }): boolean => (
+    teach.kind === 'recipe'
+      ? (b.knownRecipes ?? []).includes(teach.id)
+      : (b.knownEnchants ?? []).includes(teach.id)
+  );
+
+  // The player is ALWAYS listed. "Who already has it" is the question this picker exists to
+  // answer, and an omitted row reads as "not here" rather than "untrained" or "knows it".
+  {
+    const skill = skillLine ? char.skills[skillLine] : undefined;
+    const known = holds(char);
+    const reason = known ? 'Already known'
+      : !skill ? `Learn ${skillName} first`
+        : undefined;
+    candidates.push({
+      who: 'self',
+      name: char.name || 'You',
+      ...(skill ? { skillLabel: `${skillName} ${skill.current}` } : {}),
+      ...(reason ? { reason } : {}),
+      ...(known ? { known } : {}),
+    });
+  }
+
+  for (const comp of companions) {
+    const lvl = companionLevel(comp, char.level);
+    const skills = companionSkillMap(comp, lvl);
+    const skill = skillLine ? skills[skillLine] : undefined;
+    // No profession at all → the book can never reach that body, so it is not a row.
+    if (!skill) continue;
+    // Below the orange they cannot take it, but the row is LISTED, not dropped: a dropped row
+    // cannot say "Enchanting 150", and the player reads that absence as "nobody has it".
+    const known = holds(comp);
+    const reason = known ? 'Already known'
+      : comp.mission ? 'Away on a mission'
+        : skill.current < reqSkill ? `Needs ${skillName} ${reqSkill}`
+          : undefined;
+    candidates.push({
+      who: comp.id,
+      name: comp.name,
+      skillLabel: `${skillName} ${skill.current}`,
+      ...(reason ? { reason } : {}),
+      ...(known ? { known } : {}),
+    });
+  }
+
+  const eligibleCount = candidates.filter((c) => !c.reason).length;
+  // Eligible first for the list order the player wants.
+  candidates.sort((a, b) => Number(!!a.reason) - Number(!!b.reason));
+
+  return {
+    teach,
+    kind: teach.kind,
+    teachName,
+    reqLabel: `Requires ${skillName} (${reqSkill})`,
+    noneLabel: `Nobody can learn that. Need ${skillName} ${reqSkill}+ and not already known`,
+    candidates,
+    eligibleCount,
+  };
+}
+
+// Nobody can read it, and the only reason is that everyone who could already has. A skill or level
+// gate can still lift later, so those stay protected; this one is vendor stock.
+export function teachKnownToAll(probe: LearnOnProbe): boolean {
+  return probe.eligibleCount === 0
+    && probe.candidates.length > 0
+    && probe.candidates.every((c) => c.known);
+}
+
+// Nobody can read it because nobody has the LINE it is written on — no blacksmith for a smithing
+// plan, no mage for a mage tome. Every candidate that holds the profession or the class carries a
+// skillLabel ("Blacksmithing 150", "Mage 54"), and probeSpellBook drops a body of the wrong class
+// outright, so an empty list or a list with no skillLabel on it means the book has no reader here.
+// A "Needs Cooking 175" or "Needs level 40" row is NOT this: that gate lifts on its own, and the
+// never-sell box keeps guarding it.
+export function teachUnreachable(probe: LearnOnProbe): boolean {
+  return probe.eligibleCount === 0
+    && probe.candidates.every((c) => !c.skillLabel);
+}
+
+// Class book and pet grimoire: both are per-BODY reads with no skill line, gated on AllowableClass,
+// RequiredLevel and the taught spell's own level. A companion of the wrong class never appears.
+function probeSpellBook(
+  it: ItemDef,
+  teach: Extract<ItemTeach, { kind: 'spell' | 'petSpell' }>,
+  ds: DataStore,
+  char: Character,
+  companions: readonly Companion[],
+  playerBook?: SpellBook,
+): LearnOnProbe | null {
+  const sp = ds.spell(teach.id);
+  if (!sp) return null;
+  const teachName = sp.rank > 0 ? `${sp.name} (Rank ${sp.rank})` : sp.name;
+  const allow = it.allowClass;
+  const reqLevel = Math.max(it.requiredLevel | 0, sp.reqLevel | 0);
+  const classLabel = allow?.length ? allow.map(className).join(' / ') : '';
+  const reqLabel = [
+    classLabel ? `${classLabel} only` : '',
+    reqLevel > 0 ? `requires level ${reqLevel}` : '',
+  ].filter(Boolean).join(' · ');
+
+  const fits = (cls: number): boolean => !allow?.length || allow.includes(cls);
+  // Empty AllowableClass: require a nonzero classMask SLA. Measured 9 such kind=spell
+  // items, 3 refuse (5657 Instant Toxin + deprecated 2404/2405). Cite: Player.cpp:18369.
+  const meta = ds.combatSkillMeta?.();
+  const fitsBody = (race: number, cls: number, level: number): boolean => (
+    fits(cls)
+    && (teach.kind === 'petSpell'
+      || ((!!allow?.length || spellHasClassRestrictingAbility(teach.id, meta))
+        && isSpellFitByClassAndRace(teach.id, race, cls, meta, level)))
+  );
+  /** Greyed reason for someone the book's class gate already accepted. */
+  const rejectFor = (level: number, taught: boolean): string | undefined => (
+    taught ? 'Already known' : level < reqLevel ? `Needs level ${reqLevel}` : undefined
+  );
+  const candidates: LearnOnCandidate[] = [];
+
+  if (fits(char.cls)) {
+    const taught = teach.kind === 'petSpell'
+      ? petRepertoireHas(char.petSpells ?? [], teach.id, ds)
+      : !!playerBook && knows(playerBook, teach.id);
+    const reason = rejectFor(char.level, taught);
+    candidates.push({
+      who: 'self',
+      name: char.name || 'You',
+      skillLabel: `${className(char.cls)} ${char.level}`,
+      ...(reason ? { reason } : {}),
+      ...(taught ? { known: true } : {}),
+    });
+  }
+
+  for (const comp of companions) {
+    const lvl = companionLevel(comp, char.level);
+    if (!fitsBody(comp.race, comp.cls, lvl)) continue;
+    const taught = teach.kind === 'petSpell'
+      ? petRepertoireHas(comp.petSpells ?? [], teach.id, ds)
+      : knows(companionSpellbook(comp, lvl, ds), teach.id);
+    const reason = comp.mission ? 'Away on a mission' : rejectFor(lvl, taught);
+    candidates.push({
+      who: comp.id,
+      name: comp.name,
+      skillLabel: `${className(comp.cls)} ${lvl}`,
+      ...(reason ? { reason } : {}),
+      ...(taught ? { known: true } : {}),
+    });
+  }
+
+  const eligibleCount = candidates.filter((c) => !c.reason).length;
+  candidates.sort((a, b) => Number(!!a.reason) - Number(!!b.reason));
+
+  return {
+    teach,
+    kind: teach.kind,
+    teachName,
+    reqLabel,
+    noneLabel: classLabel
+      ? `Nobody can learn that. Need a ${classLabel} of level ${reqLevel} who does not know it yet`
+      : 'Nobody in the party can learn that yet',
+    candidates,
+    eligibleCount,
+  };
+}

package/src/domain/spells/mergeSchoolImmunityFromRaw.ts

@@ -0,0 +1,66 @@
+// Merge missing self school_immunity effects from rawEffects onto incomplete bake rows: Divine Shield
+// shipped haste-only because effects[] was already non-empty. Hostile aura-39 is skipped.
+
+import type { SpellDef, SpellEffect } from '../../data/schema.ts';
+import { durMs } from '../../engine/spells/interpreter/duration.ts';
+
+/** SPELL_EFFECT_APPLY_AURA. Cite: SpellEffectDefines.h = 6. */
+const SPELL_EFFECT_APPLY_AURA = 6;
+/** SPELL_AURA_SCHOOL_IMMUNITY. Cite: SpellAuraDefines.h = 39. */
+const SPELL_AURA_SCHOOL_IMMUNITY = 39;
+
+// Enemy-family EffectImplicitTargetA values — same set as enrich-spell-effects.mjs HOSTILE_IMM_TGT (Banish
+// etc.). Cite: SpellTargetDefines.h TARGET_UNIT_ENEMY=6, …
+const HOSTILE_IMM_TGT = new Set([2, 6, 15, 16, 22, 24, 28, 36, 54]);
+
+function durationFromSpell(spell: SpellDef): number {
+  for (const e of spell.effects ?? []) {
+    const d = (e as { durationMs?: number }).durationMs;
+    if (d != null && d > 0) return d | 0;
+  }
+  return durMs(spell.durationIndex) ?? 0;
+}
+
+// Return a SpellDef whose effects[] include every self school_immunity from rawEffects. Idempotent; never
+// invents masks or durations — only raw miscValue + sourced duration. Does not mutate the input.
+export function mergeSchoolImmunityFromRaw(spell: SpellDef): SpellDef {
+  const raw = spell.rawEffects;
+  if (!raw?.length) return spell;
+
+  const slots = raw.filter(
+    (r) =>
+      (r.effect | 0) === SPELL_EFFECT_APPLY_AURA
+      && (r.auraName | 0) === SPELL_AURA_SCHOOL_IMMUNITY
+      && !HOSTILE_IMM_TGT.has(r.targetA | 0),
+  );
+  if (!slots.length) return spell;
+
+  const effects: SpellEffect[] = spell.effects ? spell.effects.slice() : [];
+  const dur = durationFromSpell(spell);
+  let changed = false;
+
+  for (const r of slots) {
+    const schoolMask = r.miscValue | 0;
+    if (effects.some((e) => e.kind === 'school_immunity' && (e.schoolMask | 0) === schoolMask)) {
+      continue;
+    }
+    effects.push({
+      kind: 'school_immunity',
+      schoolMask,
+      durationMs: dur,
+      positive: true,
+    });
+    changed = true;
+  }
+
+  if (!changed) return spell;
+  return { ...spell, effects };
+}
+
+/** In-place hydrate for Map/list loaders (dataStore). Mutates spell.effects when needed. */
+export function hydrateSchoolImmunityOnSpell(spell: SpellDef): void {
+  const next = mergeSchoolImmunityFromRaw(spell);
+  if (next !== spell) {
+    spell.effects = next.effects;
+  }
+}

package/src/domain/spells/resurrectSpell.ts

@@ -0,0 +1,124 @@
+// Player-corpse resurrection effects from the raw spell slots, stamped into schema effects so the
+// DataStore and OOC cast see a live payload. Cite: SpellEffects.cpp:4797–4871 EffectResurrect.
+
+import type { RawSpellEffect, SpellDef, SpellEffect } from '../../data/schema.ts';
+
+/** SpellEffectDefines.h SPELL_EFFECT_RESURRECT = 18 */
+export const SPELL_EFFECT_RESURRECT = 18;
+/** SpellEffectDefines.h SPELL_EFFECT_RESURRECT_NEW = 113 */
+export const SPELL_EFFECT_RESURRECT_NEW = 113;
+
+/** The only two kinds resurrectEffectsFromRaw emits. */
+export type ResurrectEffect = Extract<SpellEffect, { kind: 'resurrect' } | { kind: 'resurrect_pct' }>;
+
+/** Bake-parity amount: basePoints + max(baseDice, 0). Cite: map-spell-effects.mjs; amount.ts. */
+function effectMinAmount(raw: RawSpellEffect): number {
+  const bp = raw.basePoints | 0;
+  const bd = raw.baseDice | 0;
+  return bp + Math.max(bd, 0);
+}
+
+/** Map raw RESURRECT / RESURRECT_NEW slots to schema effects. Empty when no resurrect opcodes present. */
+export function resurrectEffectsFromRaw(
+  rawEffects: readonly RawSpellEffect[] | undefined,
+): ResurrectEffect[] {
+  const out: ResurrectEffect[] = [];
+  for (const r of rawEffects ?? []) {
+    const eff = r.effect | 0;
+    if (eff === SPELL_EFFECT_RESURRECT_NEW) {
+      // Flat health = damage, mana = misc. Cite: EffectResurrect :4815–4818.
+      out.push({
+        kind: 'resurrect',
+        health: Math.max(0, effectMinAmount(r)),
+        mana: Math.max(0, r.miscValue | 0),
+      });
+    } else if (eff === SPELL_EFFECT_RESURRECT) {
+      // Percent of max. Cite: EffectResurrect :4819–4824.
+      out.push({
+        kind: 'resurrect_pct',
+        percent: Math.max(0, effectMinAmount(r)),
+      });
+    }
+  }
+  return out;
+}
+
+// When the bake left effects empty but raw carries a resurrect, stamp the schema payload and mark it
+// out-of-combat only. Never clobbers non-empty effects.
+export function withResurrectEffectsIfEmpty(spell: SpellDef): SpellDef {
+  if ((spell.effects?.length ?? 0) > 0) return spell;
+  const fx = resurrectEffectsFromRaw(spell.rawEffects);
+  if (!fx.length) return spell;
+  return {
+    ...spell,
+    effects: fx,
+    outOfCombatOnly: true,
+  };
+}
+
+/** Subset of DeathFlowState used for OOC res apply (avoids circular domain imports). */
+export interface ResurrectDeathFlow {
+  deathState: string;
+  deathExpireTimeSec: number;
+}
+
+export interface ApplyResurrectInput {
+  effect: ResurrectEffect;
+  maxHealth: number;
+  maxMana: number;
+  deathFlow: ResurrectDeathFlow | null | undefined;
+  /** Harness / self-force when no multiparty corpse model. */
+  forceSelf?: boolean;
+  powerType: string;
+  hasParallelMana: boolean;
+}
+
+export interface ApplyResurrectResult {
+  /** Flat HP after res (clamped 1..maxHealth). Null when no dead target. */
+  health: number | null;
+  mana: number | null;
+  /** New ALIVE death flow when self was dead; undefined when unchanged. */
+  clearDeathFlow?: { deathState: 'ALIVE'; deathExpireTimeSec: number };
+  log: string;
+}
+
+// Pure OOC apply for RESURRECT and RESURRECT_NEW. The core offers a res request to a dead player, so
+// single-player only applies when the caster is dead or forceSelf is set. No sickness.
+export function applyResurrectEffect(input: ApplyResurrectInput): ApplyResurrectResult {
+  const flow = input.deathFlow;
+  const selfDead = !!flow
+    && flow.deathState !== 'ALIVE'
+    && flow.deathState !== 'JUST_ALIVED';
+  if (!selfDead && !input.forceSelf) {
+    return {
+      health: null,
+      mana: null,
+      log: 'no dead target (party corpse resurrection not modelled in single-player)',
+    };
+  }
+  const maxHp = Math.max(1, input.maxHealth | 0);
+  const maxMp = Math.max(0, input.maxMana | 0);
+  let healthAmt: number;
+  let manaAmt: number;
+  if (input.effect.kind === 'resurrect') {
+    healthAmt = Math.max(1, Math.min(maxHp, input.effect.health | 0));
+    manaAmt = Math.max(0, Math.min(maxMp, input.effect.mana | 0));
+  } else {
+    const pct = Math.max(0, input.effect.percent | 0);
+    // Integer division like C++: max * damage / 100. Cite: :4822–4823.
+    healthAmt = Math.max(1, Math.trunc((maxHp * pct) / 100));
+    manaAmt = Math.max(0, Math.trunc((maxMp * pct) / 100));
+  }
+  const out: ApplyResurrectResult = {
+    health: healthAmt,
+    mana: manaAmt,
+    log: `You return to life with ${healthAmt} health.`,
+  };
+  if (selfDead && flow) {
+    out.clearDeathFlow = {
+      deathState: 'ALIVE',
+      deathExpireTimeSec: flow.deathExpireTimeSec,
+    };
+  }
+  return out;
+}