azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/combat/friendlyFan.ts

@@ -0,0 +1,55 @@
+// Same-side multi-unit target constants, shared by heal and buff routing and by the census. The old
+// bolt-on fan was deleted: it double-healed the triaged primary.
+
+import type { SpellDef, SpellEffect } from '../../data/schema.ts';
+
+// Multi-unit FRIENDLY implicit targets that use a flat party or radius fan. The chain-heal target and
+// raid-and-class are excluded, since the chain fan and the class filter own those.
+export const FRIENDLY_MULTI_TARGETS: ReadonlySet<number> = new Set([
+  20, // TARGET_ENUM_UNITS_PARTY_WITHIN_CASTER_RANGE
+  29, // TARGET_ENUM_UNITS_FRIEND_AOE_AT_DYNOBJ_LOC
+  30, // TARGET_ENUM_UNITS_FRIEND_AOE_AT_SRC_LOC
+  31, // TARGET_ENUM_UNITS_FRIEND_AOE_AT_DEST_LOC
+  33, // TARGET_ENUM_UNITS_PARTY_AOE_AT_SRC_LOC
+  34, // TARGET_ENUM_UNITS_PARTY_AOE_AT_DEST_LOC
+  37, // TARGET_UNIT_FRIEND_AND_PARTY
+  56, // TARGET_ENUM_UNITS_RAID_WITHIN_CASTER_RANGE
+  59, // TARGET_ENUM_UNITS_FRIEND_IN_CONE
+]);
+
+// True when this spell's DBC row asks for several friendly units via a flat multi-target. Reads
+// `rawEffects`; a synthesized SpellDef without them simply does not fan.
+export function wantsFriendlyFan(spell: SpellDef): boolean {
+  const raw = spell.rawEffects;
+  if (!raw?.length) return false;
+  for (const re of raw) {
+    if ((re.effect | 0) === 0) continue;
+    if (FRIENDLY_MULTI_TARGETS.has(re.targetA | 0)) return true;
+    if (FRIENDLY_MULTI_TARGETS.has(re.targetB | 0)) return true;
+  }
+  return false;
+}
+
+// Effects that once replayed onto each additional ally via the deleted fan. Kept for census / diagnostics;
+// combat no longer uses this list for a second pass.
+export function isFriendlyFannedEffect(e: SpellEffect): boolean {
+  // Real bake/SI kinds only — `hot`/`absorb`/`restore_mana` never exist on SpellEffect
+  // (HoT = restore_health, absorb = school_absorb, mana = restore_power).
+  switch (e.kind) {
+    case 'heal':
+    case 'damage_shield':
+    case 'school_absorb':
+    case 'restore_health':
+    case 'restore_power':
+    case 'dispel':
+      return (e as { hostile?: boolean }).hostile !== true;
+    default:
+      return false;
+  }
+}
+
+/** @deprecated The external friendly fan is gone — heals route through applyTo in applySpellLate.
+ * Kept as a no-op so a stray import still compiles; it always returns 0. */
+export function applyFriendlyFan(): number {
+  return 0;
+}

package/src/engine/combat/groundPoolTick.ts

@@ -0,0 +1,210 @@
+// DynamicObject::Update plus persistent-area membership for session ground pools. The pulse damage
+// stays on the shared pool clock; this pass applies, refreshes and strips the per-unit auras.
+
+import type { CombatContext } from './context.ts';
+import type { ActiveEffect, Fighter } from './types.ts';
+import type { Side } from '../core/events.ts';
+import { rollBetween } from './formulas.ts';
+import { isWithinRadiusYd } from './combatGeometry.ts';
+import { navSightClear } from './navSight.ts';
+import {
+  advanceGroundPool,
+  expireGroundPools,
+  isEnemyCasterSide,
+  isGroundPoolExpired,
+  shouldRefreshAffectedAuraDuration,
+  syncGroundPoolAffected,
+  type GroundPool,
+} from '../game/dynamicObject.ts';
+import {
+  BLIZZARD_SPELL_IDS,
+  improvedBlizzardChillSpellId,
+} from '../spells/interpreter/class-scripts-kit.ts';
+import { unitHasOverrideScript } from '../spells/overrideClassScripts.ts';
+import { isPlayerCharacterTarget } from './castTargetGates.ts';
+
+function findDynObjAura(
+  effects: readonly ActiveEffect[],
+  pool: GroundPool,
+  target: Side,
+): ActiveEffect | undefined {
+  return effects.find(
+    (e) =>
+      e.fromDynamicObject === pool.id
+      && e.spellId === pool.spellId
+      && e.source === pool.source
+      && e.target === target,
+  );
+}
+
+function applyOrRefreshDynObjAura(
+  ctx: CombatContext,
+  pool: GroundPool,
+  target: Fighter,
+  mode: 'enter' | 'refresh',
+): void {
+  const live = findDynObjAura(ctx.effectsOn(target.side), pool, target.side);
+  if (live) {
+    live.fromDynamicObject = pool.id;
+    if (shouldRefreshAffectedAuraDuration(live.expiresAt, pool.expiresAt)) {
+      live.expiresAt = pool.expiresAt;
+      ctx.touchEffect(live);
+    }
+    return;
+  }
+  if (mode === 'refresh') return;
+  ctx.effects.push({
+    kind: 'dot',
+    source: pool.source,
+    target: target.side,
+    spellId: pool.spellId,
+    name: pool.name,
+    school: pool.school,
+    min: pool.min,
+    max: pool.max,
+    tickMs: pool.tickMs,
+    nextTickAt: ctx.t + pool.tickMs,
+    expiresAt: pool.expiresAt,
+    binary: pool.binary,
+    fromDynamicObject: pool.id,
+  });
+  ctx.push({ t: ctx.t, kind: 'aura', actor: target.side, name: pool.name, applied: true });
+}
+
+function stripDynObjAura(ctx: CombatContext, pool: GroundPool, targetSide: Side): void {
+  for (let i = ctx.effects.length - 1; i >= 0; i--) {
+    const e = ctx.effects[i]!;
+    if (e.fromDynamicObject !== pool.id || e.target !== targetSide) continue;
+    ctx.effects.splice(i, 1);
+    ctx.push({ t: ctx.t, kind: 'aura', actor: targetSide, name: pool.name, applied: false });
+  }
+}
+
+function stripAllDynObjAuras(ctx: CombatContext, pool: GroundPool): void {
+  const seen = new Set<Side>();
+  for (const side of pool.affected) {
+    if (seen.has(side)) continue;
+    seen.add(side);
+    stripDynObjAura(ctx, pool, side);
+  }
+  for (let i = ctx.effects.length - 1; i >= 0; i--) {
+    const e = ctx.effects[i]!;
+    if (e.fromDynamicObject !== pool.id) continue;
+    if (seen.has(e.target)) continue;
+    ctx.effects.splice(i, 1);
+    ctx.push({ t: ctx.t, kind: 'aura', actor: e.target, name: pool.name, applied: false });
+  }
+  pool.affected.length = 0;
+}
+
+/** Units currently inside this dynobj (radius + LOS). Same gate as the pulse. */
+export function groundPoolUnitsInRadius(
+  ctx: CombatContext,
+  pool: GroundPool,
+  dead: (f: Fighter) => boolean,
+): Fighter[] {
+  const poolOrigin = pool.origin ?? ctx.posOf(pool.source);
+  let candidates = isEnemyCasterSide(pool.source) ? ctx.livingFriendlies() : ctx.livingEnemies();
+  if (
+    ctx.cfg.endless
+    && !isEnemyCasterSide(pool.source)
+    && !(pool.radius != null && pool.radius > 0)
+  ) {
+    candidates =
+      typeof ctx.livingCombatEnemies === 'function'
+        ? ctx.livingCombatEnemies()
+        : candidates.filter((e) => {
+          const tm = ctx.threatOf(e); return !!tm && !tm.isEmpty();
+        });
+  }
+  return candidates.filter((tgt) => {
+    if (dead(tgt)) return false;
+    // SPELL_ATTR_EX3_ONLY_ON_PLAYER: the dynobj visits a pet, totem or guardian and applies
+    // nothing — it is TYPEID_UNIT. Cite: GridNotifiersImpl.h:256 DynamicObjectUpdater.
+    if (pool.onlyOnPlayer === true && !isPlayerCharacterTarget(tgt)) return false;
+    const at = ctx.posOf(tgt.side);
+    if (ctx.cfg.endless && pool.radius != null && pool.radius > 0) {
+      if (poolOrigin == null || at == null) return false;
+      if (!isWithinRadiusYd(poolOrigin, at, pool.radius)) return false;
+    } else if (!isWithinRadiusYd(poolOrigin, at, pool.radius)) {
+      return false;
+    }
+    return !ctx.cfg.navLos || navSightClear(ctx.cfg, poolOrigin, at);
+  });
+}
+
+// VisitAllObjects apply/refresh, then pulse, then expire + strip. Cite: DynamicObject.cpp:122–150 Update
+// (visit even when deleteThis is set, then Delete).
+export function tickGroundPools(
+  ctx: CombatContext,
+  dead: (f: Fighter) => boolean,
+): void {
+  const { groundPools } = ctx;
+  const dealDamage = ctx.dealDamage;
+  for (const pool of groundPools) {
+    if (!isGroundPoolExpired(pool, ctx.t)) {
+      const inRadius = groundPoolUnitsInRadius(ctx, pool, dead);
+      const present = new Map(inRadius.map((t) => [t.side, t]));
+      const sync = syncGroundPoolAffected(pool, inRadius.map((t) => t.side));
+      for (const side of sync.left) stripDynObjAura(ctx, pool, side);
+      for (const side of sync.entered) {
+        const tgt = present.get(side);
+        if (tgt && !dead(tgt)) applyOrRefreshDynObjAura(ctx, pool, tgt, 'enter');
+      }
+      for (const side of sync.refreshed) {
+        const tgt = present.get(side);
+        if (tgt && !dead(tgt)) applyOrRefreshDynObjAura(ctx, pool, tgt, 'refresh');
+      }
+    }
+    const pulses = advanceGroundPool(pool, ctx.t);
+    if (pulses <= 0) continue;
+    const src = ctx.bySide(pool.source);
+    if (dead(src) || !dealDamage) continue;
+    const targets = groundPoolUnitsInRadius(ctx, pool, dead);
+    // Improved Blizzard chill on each tick end. Cite: Mage.cpp:111–124 OnPeriodicTickEnd.
+    const chillId = BLIZZARD_SPELL_IDS.has(pool.spellId | 0)
+      ? improvedBlizzardChillSpellId((scriptId) => unitHasOverrideScript(src, scriptId))
+      : 0;
+    for (let p = 0; p < pulses; p++) {
+      for (const tgt of targets) {
+        if (dead(tgt)) continue;
+        const amount = dealDamage(
+          tgt,
+          rollBetween(pool.min, pool.max, ctx.rng.next()),
+          pool.school,
+          src.spec.level,
+          { binary: pool.binary ?? true, damageType: 'dot', attacker: src },
+        );
+        ctx.push({
+          t: ctx.t, kind: 'dot_tick', actor: pool.source, target: tgt.side,
+          spellId: pool.spellId, name: pool.name, amount, school: pool.school,
+        });
+        if (chillId > 0) {
+          // Prefer kit row; else stamp speed snare from bake (−30/−50/−65, 1.5s).
+          // Cite: spell_template 12484/12485/12486 aura 33.
+          const kit = src.spec.spells.find((s) => s.id === chillId);
+          if (kit && ctx.applySpell) {
+            ctx.applySpell(src, tgt, kit, false, 1);
+          } else {
+            const pct = chillId === 12486 ? -65 : chillId === 12485 ? -50 : -30;
+            tgt.buffActive.add(chillId);
+            ctx.effects.push({
+              kind: 'buff',
+              source: src.side,
+              target: tgt.side,
+              spellId: chillId,
+              name: 'Chilled',
+              amount: pct,
+              expiresAt: ctx.t + 1500,
+            });
+            ctx.push({ t: ctx.t, kind: 'aura', actor: tgt.side, name: 'Chilled', applied: true });
+          }
+        }
+      }
+    }
+  }
+  for (const faded of expireGroundPools(groundPools, ctx.t)) {
+    stripAllDynObjAuras(ctx, faded);
+    ctx.push({ t: ctx.t, kind: 'aura', actor: faded.source, name: faded.name, applied: false });
+  }
+}

package/src/engine/combat/hazards.ts

@@ -0,0 +1,114 @@
+// WHERE the floor is dangerous, asked once. Two kinds are carried: a live POOL, and a BODY whose own
+// schedule has a ground-shaped damaging spell landing on itself and making no pool. Nothing moves alone.
+
+import { isEnemySide, type Side } from '../core/events.ts';
+import { castableKitIds } from './castableKit.ts';
+import { persistentAreaFromSpell } from '../game/dynamicObject.ts';
+import { spellAoeFromCaster, type CombatPosYd } from './combatGeometry.ts';
+import type { CombatContext } from './context.ts';
+import type { Fighter } from './types.ts';
+import type { SpellDef } from '../../data/schema.ts';
+
+export type HazardKind = 'pool' | 'body';
+
+export interface Hazard {
+  kind: HazardKind;
+  /** Session-local id — a pool's `id`, or the body's side. */
+  id: string;
+  /** Spell that makes the ground dangerous: the pool's own spell, or the body's ground AoE. */
+  spellId: number;
+  /** Pool name, or the creature's name. A row may match on any of id / spellId / name. */
+  name: string;
+  /** Who put it there. A row avoids what an enemy made, never its own party's. */
+  source: Side;
+  /** Live centre in combat yards. */
+  at: CombatPosYd;
+  radiusYd: number;
+}
+
+// The one ground-shaped damaging spell a creature's SCHEDULE carries, or null. A cone or a pbaoe
+// follows the body and is a facing problem. The spell must land AT the creature, or the site is wrong.
+function groundAoeOf(f: Fighter, spellOf: ((id: number) => SpellDef | undefined) | undefined): SpellDef | null {
+  // REACHABLE, asked once for the whole engine. A charm-bar slot never self-casts and a death cast is
+  // no hazard while the caster lives, so the spell must be scheduled or a payload of one.
+  const spec = f.spec;
+  const reach = castableKitIds(f, spellOf);
+  for (const s of spec.spells ?? []) {
+    if (reach && !reach.has(s.id | 0)) continue;
+    if (s.aoeShape !== 'ground') continue;
+    const r = s.radiusYd;
+    if (!(typeof r === 'number' && r > 0)) continue;
+    if (!(s.effects ?? []).some((e) => e.kind === 'direct_damage' || e.kind === 'dot')) continue;
+    // A spell that makes a persistent area already publishes a POOL at the origin its own pulse uses.
+    // A body would be a second and PERMANENT answer — 19 of 29 publishers were this shape.
+    if (persistentAreaFromSpell(s)) continue;
+    if (!spellAoeFromCaster(s)) continue;
+    return s;
+  }
+  return null;
+}
+
+// Every live hazard, pools and bodies alike. A pool's centre is the same resolution its damage pulse
+// uses, since reading it any other way would be a second answer to where the damage is.
+export function listHazards(
+  ctx: CombatContext,
+  dead: (f: Fighter) => boolean,
+): Hazard[] {
+  const out: Hazard[] = [];
+  const posOf = ctx.posOf;
+  for (const pool of ctx.groundPools) {
+    if (pool.expiresAt <= ctx.t) continue;
+    const at = pool.origin ?? posOf?.(pool.source);
+    if (!at) continue;
+    out.push({
+      kind: 'pool',
+      id: String(pool.id),
+      spellId: pool.spellId,
+      name: pool.name,
+      source: pool.source,
+      at,
+      radiusYd: pool.radius ?? 0,
+    });
+  }
+  for (const f of ctx.livingEnemies()) {
+    const spell = groundAoeOf(f, ctx.spellOf);
+    if (!spell) continue;
+    const at = posOf?.(f.side);
+    if (!at) continue;
+    out.push({
+      kind: 'body',
+      id: f.side,
+      spellId: spell.id,
+      name: f.spec.name,
+      source: f.side,
+      at,
+      radiusYd: spell.radiusYd ?? 0,
+    });
+  }
+  return out;
+}
+
+/** A row's `id` names a hazard by session id, by spell id, or by name. Empty matches every one. */
+export function hazardMatches(h: Hazard, id: string): boolean {
+  if (id === '') return true;
+  return id === h.id || id === String(h.spellId) || id === h.name;
+}
+
+/** Hazards a friendly unit should be off: an enemy made it. */
+export function hostileHazards(ctx: CombatContext, dead: (f: Fighter) => boolean): Hazard[] {
+  return listHazards(ctx, dead).filter((h) => isEnemySide(h.source));
+}
+
+// The same list, answered once per tick for the whole fight. "Where is the floor dangerous" is a fact
+// about the FIGHT, and deriving it per caller is how the move and the condition came to disagree.
+export function hostileHazardsThisTick(
+  ctx: CombatContext,
+  dead: (f: Fighter) => boolean,
+): readonly Hazard[] {
+  const bag = ctx as { hazardCache?: { t: number; list: readonly Hazard[] } };
+  const hit = bag.hazardCache;
+  if (hit && hit.t === ctx.t) return hit.list;
+  const list = hostileHazards(ctx, dead);
+  bag.hazardCache = { t: ctx.t, list };
+  return list;
+}

package/src/engine/combat/healTargets.ts

@@ -0,0 +1,226 @@
+// Heal and party-heal target resolution — the single site for applyTo routing. Heals are never fanned
+// externally: selection re-picks the lowest ally later, so an outside fan double-heals it.
+
+import type { SpellDef, SpellEffect } from '../../data/schema.ts';
+import { isTotemSide } from '../core/events.ts';
+import { FRIENDLY_MULTI_TARGETS, wantsFriendlyFan } from './friendlyFan.ts';
+import { TARGET_UNIT_FRIEND_CHAIN_HEAL } from './chainFan.ts';
+
+/** TARGET_UNIT_RAID_AND_CLASS — same class as the (player) target. */
+export const TARGET_UNIT_RAID_AND_CLASS = 61;
+
+/** APPLY_AREA_AURA_PARTY — a party aura even when its own target is the caster. */
+const EFFECT_APPLY_AREA_AURA_PARTY = 35;
+
+// Single selected friend/party/raid. Cite: SpellTargetDefines.h TARGET_UNIT_FRIEND/PARTY/RAID.
+const SELECTED_UNIT_HEAL_TARGETS: ReadonlySet<number> = new Set([3, 21, 35, 57, 58]);
+
+export type HealApplyTo = 'self' | 'pet' | 'friendly' | 'party';
+
+// The living pet mapped to this caster: the seat its own spec names, else the session pet. That edge
+// lives on the unit it starts from, rather than being found by scanning the ally array.
+export function resolvePetHealFighter<F extends { side: string; spec?: { petSide?: string } }>(
+  src: F,
+  unitOfSide: (side: string) => F | null | undefined,
+  pet: F | null | undefined,
+  dead: (f: F) => boolean,
+  isAlly: (side: string) => boolean,
+): F | null {
+  if (isAlly(src.side)) {
+    const ps = src.spec?.petSide;
+    const mapped = ps ? unitOfSide(ps) ?? null : null;
+    if (mapped && !dead(mapped)) return mapped;
+    return null;
+  }
+  if (pet && !dead(pet)) return pet;
+  return null;
+}
+
+// Audience for a heal effect. Raw implicit targets win over a baked applyTo so a single-unit DBC
+// row cannot keep a stale party fan. Chain-heal 45 is jump-based, not a flat splash.
+export function resolveHealApplyTo(spell: SpellDef, eff: SpellEffect & { applyTo?: HealApplyTo }): HealApplyTo | undefined {
+  const raw = spell.rawEffects;
+  if (raw?.length) {
+    let best: HealApplyTo | undefined;
+    const rank: Record<HealApplyTo, number> = { self: 0, pet: 1, friendly: 2, party: 3 };
+    for (const re of raw) {
+      if ((re.effect | 0) === 0) continue;
+      const t = (re.targetA | 0) || (re.targetB | 0);
+      if (t === TARGET_UNIT_FRIEND_CHAIN_HEAL) continue;
+      let at: HealApplyTo | undefined;
+      if ((re.effect | 0) === EFFECT_APPLY_AREA_AURA_PARTY || FRIENDLY_MULTI_TARGETS.has(t)) {
+        at = 'party';
+      } else if (SELECTED_UNIT_HEAL_TARGETS.has(t)) {
+        at = 'friendly';
+      } else if (t === 5) {
+        at = 'pet';
+      }
+      if (at && (!best || rank[at] > rank[best])) best = at;
+    }
+    if (!best && wantsFriendlyFan(spell)) best = 'party';
+    if (best) return best;
+  }
+  return eff.applyTo;
+}
+
+/** True when the spell's raw row asks for RAID_AND_CLASS (Greater Blessings). */
+export function wantsRaidAndClass(spell: SpellDef): boolean {
+  for (const re of spell.rawEffects ?? []) {
+    if ((re.targetA | 0) === TARGET_UNIT_RAID_AND_CLASS) return true;
+    if ((re.targetB | 0) === TARGET_UNIT_RAID_AND_CLASS) return true;
+  }
+  return false;
+}
+
+// Filter a party or raid audience to members sharing the primary target's class. A missing class on
+// either side keeps the unit — fail open for NPCs and test dummies.
+export function filterSameClass<F extends { spec: { classId?: number } }>(
+  primary: F,
+  pool: F[],
+): F[] {
+  const cls = primary.spec.classId;
+  if (cls == null || cls === 0) return pool;
+  return pool.filter((u) => {
+    const c = u.spec.classId;
+    if (c == null || c === 0) return true;
+    return c === cls;
+  });
+}
+
+// Implicit targets that reach the caster's SUBGROUP only — `FillRaidOrPartyTargets(raid=false)` for
+// 20/33/34, and the group walk at Spell.cpp:2449 for 37.
+const SUBGROUP_TARGETS: ReadonlySet<number> = new Set([
+  20, // TARGET_ENUM_UNITS_PARTY_WITHIN_CASTER_RANGE
+  33, // TARGET_ENUM_UNITS_PARTY_AOE_AT_SRC_LOC
+  34, // TARGET_ENUM_UNITS_PARTY_AOE_AT_DEST_LOC
+  37, // TARGET_UNIT_FRIEND_AND_PARTY
+]);
+
+// Multi-unit friendly targets that are NOT group-scoped: the raid enums, raid-and-class, and the
+// friendly area-at-location enums. A Greater Blessing walks the whole group filtered by class.
+const OPEN_FAN_TARGETS: ReadonlySet<number> = new Set([
+  56, // TARGET_ENUM_UNITS_RAID_WITHIN_CASTER_RANGE
+  TARGET_UNIT_RAID_AND_CLASS, // 61
+  29, 30, 31, 59, // friendly AoE at dynobj / src / dest / cone
+]);
+
+// Does this spell's friendly fan stop at the caster's subgroup? The raw targets decide, exactly as the
+// C++ does. Only when the raw row carries no fan at all does the baked audience stand in.
+export function fanStopsAtSubgroup(spell: SpellDef, applyTo: HealApplyTo | undefined): boolean {
+  let sawOpenFan = false;
+  for (const re of spell.rawEffects ?? []) {
+    if ((re.effect | 0) === 0) continue;
+    if ((re.effect | 0) === EFFECT_APPLY_AREA_AURA_PARTY) return true;
+    for (const t of [re.targetA | 0, re.targetB | 0]) {
+      if (SUBGROUP_TARGETS.has(t)) return true;
+      if (OPEN_FAN_TARGETS.has(t)) sawOpenFan = true;
+    }
+  }
+  return sawOpenFan ? false : applyTo === 'party';
+}
+
+// The same raid subgroup — the party half of the raid-or-party fill. Either side ungrouped is true:
+// enemy packs and 1v1 fixtures carry no group, and a missing field must not delete a real party buff.
+export function sameSubgroup(
+  a: { spec?: { subgroup?: number } },
+  b: { spec?: { subgroup?: number } },
+): boolean {
+  const ga = a.spec?.subgroup;
+  const gb = b.spec?.subgroup;
+  if (ga == null || gb == null) return true;
+  return ga === gb;
+}
+
+// A friendly fan is the group's players and each one's controlled pet — never a totem, never a
+// guardian. Cite: Spell.cpp:7345-7350 GetPet() only; SpellAuras.cpp:445 the same; Pet.cpp:378.
+export function isPartyFanBody<F extends { side: string; spec?: { summonOwnerSide?: string } }>(
+  u: F,
+): boolean {
+  return !isTotemSide(u.side) && u.spec?.summonOwnerSide == null;
+}
+
+// The class-B timed party fan: the caster's own subgroup, and of those only the units inside the
+// spell's radius at cast. A missing radius or distance fails open, and the caster is always kept.
+export function filterPartyFanByRadius<
+  F extends { side: string; spec?: { subgroup?: number; summonOwnerSide?: string } },
+>(
+  caster: F,
+  pool: readonly F[],
+  spell: SpellDef,
+  applyTo: HealApplyTo | undefined,
+  distanceBetween: (a: F, b: F) => number | undefined | null,
+): F[] {
+  const radiusYd = spell.radiusYd;
+  const bySubgroup = fanStopsAtSubgroup(spell, applyTo);
+  const out: F[] = [];
+  for (const u of pool) {
+    if (u.side === caster.side) {
+      out.push(u);
+      continue;
+    }
+    if (!isPartyFanBody(u)) continue;
+    if (bySubgroup && !sameSubgroup(caster, u)) continue;
+    if (radiusYd != null && radiusYd > 0) {
+      const d = distanceBetween(caster, u);
+      if (d != null && d > radiusYd) continue;
+    }
+    out.push(u);
+  }
+  return out;
+}
+
+// Implicit targets that name ONE friendly unit the caster SELECTED, never the caster itself.
+// Cite: Spell.cpp:2298–2306 and :2326–2330; SpellTargets.cpp:68,90 both single-enumerator.
+const SELECTED_FRIEND_TARGETS: ReadonlySet<number> = new Set([3, 21, 35, 37, 45, 57, 58, 61]);
+
+// True when a self-shaped aura — a school absorb or a damage shield — belongs on the unit the cast
+// NAMED rather than the caster. Derived from the raw implicit target, and 54 rows qualify.
+export function auraHolderIsCastTarget(spell: SpellDef): boolean {
+  for (const re of spell.rawEffects ?? []) {
+    if ((re.effect | 0) === 0) continue;
+    if (SELECTED_FRIEND_TARGETS.has(re.targetA | 0)) return true;
+    if (SELECTED_FRIEND_TARGETS.has(re.targetB | 0)) return true;
+  }
+  return false;
+}
+
+// TARGET_UNIT_FRIEND is the selected unit; an unaimed keep-up is the caster. Cite: Spell.cpp:2298-2306.
+export function selectedOrSelfFriendly<F extends { side: string }>(
+  src: F,
+  tgt: F,
+  pinned: F | null | undefined,
+  dead: (f: F) => boolean,
+  isHostileSide: (side: string) => boolean,
+): F {
+  const sameSide = (u: F): boolean => isHostileSide(u.side) === isHostileSide(src.side) && !dead(u);
+  if (pinned && sameSide(pinned)) return pinned;
+  if (sameSide(tgt)) return tgt;
+  return src;
+}
+
+// TARGET_UNIT_PARTY is the one selected-friend target the caster may NOT be, and the imp's Fire
+// Shield is the row it exists for. Cite: Spell.cpp:2325-2330 "can only be casted on a party member
+// and not on the caster (some seals, fire shield from imp, etc..)".
+const TARGET_UNIT_PARTY = 35;
+
+/** True when this spell's aura must land on a party member OTHER than the caster. */
+export function auraHolderExcludesCaster(spell: SpellDef): boolean {
+  for (const re of spell.rawEffects ?? []) {
+    if ((re.effect | 0) === 0) continue;
+    if ((re.targetA | 0) === TARGET_UNIT_PARTY) return true;
+    if ((re.targetB | 0) === TARGET_UNIT_PARTY) return true;
+  }
+  return false;
+}
+
+// SPELL_EFFECT_APPLY_AREA_AURA_PARTY. The aura sits on the caster and AreaAura::Update radiates it
+// to the subgroup — Retribution Aura is a damage shield shaped this way, not a self-only one.
+// Cite: SpellEffects.cpp EffectApplyAreaAura; SpellAuras.cpp AreaAura::Update.
+const SPELL_EFFECT_APPLY_AREA_AURA_PARTY = 35;
+
+/** True when this spell radiates its aura to the caster's party rather than landing on one unit. */
+export function auraRadiatesToParty(spell: SpellDef): boolean {
+  return (spell.rawEffects ?? []).some(
+    (re) => (re.effect | 0) === SPELL_EFFECT_APPLY_AREA_AURA_PARTY,
+  );
+}

package/src/engine/combat/heartbeatResist.ts

@@ -0,0 +1,49 @@
+// Heartbeat resist — a negative aura rolls to break early on its own clock. A pure factory over the
+// primitives, so the chip, the log line and the DR bookkeeping all reuse the existing break path.
+
+import type { Rng } from '../core/rng.ts';
+
+/** One armed holder: whose it is, what it rolls, and when the next roll is due. */
+export interface HeartbeatHolder {
+  /** Percentage points 0..100, already scaled by (1 + drLevel). */
+  chancePercent: number;
+  /** ms between rolls, floored at 1000. */
+  intervalMs: number;
+  /** Sim clock of the next roll. */
+  nextRollAt: number;
+}
+
+// SetHeartbeatResist: the chance is the land die's miss and full-resist side times one plus the DR
+// level, and the interval is the ORIGINAL duration over two plus it. Null means arm nothing.
+export function armHeartbeatResist(args: {
+  now: number;
+  /** miss + full-resist percentage from the land roll — the SAME number the die used. */
+  missPlusResistPercent: number;
+  /** Aura duration before diminishing returns shortened it. */
+  originalDurationMs: number;
+  /** Diminishing step already taken on this group (0 for the first application). */
+  drLevel: number;
+}): HeartbeatHolder | null {
+  const { now, missPlusResistPercent, originalDurationMs, drLevel } = args;
+  if (!(missPlusResistPercent > 0)) return null;
+  if (!(originalDurationMs > 0)) return null;
+  const dr = Math.max(0, drLevel | 0);
+  const chancePercent = missPlusResistPercent * (1 + dr);
+  const intervalMs = Math.max(1000, Math.trunc(originalDurationMs / (2 + dr)));
+  return { chancePercent, intervalMs, nextRollAt: now + intervalMs };
+}
+
+// One tick. The C++ catches up with a while, so a long tick may consume several intervals and the
+// first successful roll wins. Returns true when the holder broke; the caller removes it.
+export function tickHeartbeatResist(
+  holder: HeartbeatHolder,
+  now: number,
+  rng: Rng,
+): boolean {
+  if (!(holder.chancePercent > 0) || !(holder.intervalMs > 0)) return false;
+  while (now >= holder.nextRollAt) {
+    holder.nextRollAt += holder.intervalMs;
+    if (rng.chance(Math.min(1, holder.chancePercent / 100))) return true;
+  }
+  return false;
+}