azeroth-shell 0.0.0-stage → 0.1.1

package/src/engine/combat/modTaunt.ts

@@ -0,0 +1,43 @@
+// MOD_TAUNT (11) — the session-side apply and clear of threat-list taunt state. It does NOT equalize
+// threat, which is the separate attack-me effect; while it holds, victim selection prefers the taunter.
+import type { ActiveEffect, Fighter } from './types.ts';
+import type { ThreatManager } from './threat.ts';
+import { TAUNT_STATE } from './threat.ts';
+import { isEnemySide } from '../core/events.ts';
+
+// Apply MOD_TAUNT on an enemy threat list: ensure taunter is listed, set STATE_TAUNTED, force current
+// victim. Returns the ActiveEffect row to track duration (or null if skipped).
+export function applyModTauntAura(
+  tm: ThreatManager,
+  src: Fighter,
+  tgt: Fighter,
+  spellId: number,
+  name: string,
+  expiresAt: number,
+): ActiveEffect | null {
+  if (!isEnemySide(tgt.side)) return null;
+  // Ensure the taunter is on the list so SetTauntState has a reference.
+  // Cite: ThreatManager.cpp:557–575 — taunt states keyed by caster guid on threat refs.
+  tm.addThreatDirectly(src.side, 0, false);
+  tm.setTauntState(src.side, TAUNT_STATE.TAUNTED);
+  tm.setCurrentVictimByTarget(src.side);
+  return {
+    kind: 'mod_taunt',
+    source: src.side,
+    target: tgt.side,
+    spellId,
+    name,
+    expiresAt,
+  };
+}
+
+// Clear MOD_TAUNT when the aura expires or is stripped. The C++ re-scans the remaining taunt auras, so
+// the state clears only when no other same-source row still holds on this target.
+function clearModTauntAura(
+  tm: ThreatManager,
+  taunterId: string,
+  remainingSameSource: boolean,
+): void {
+  if (remainingSameSource) return;
+  tm.setTauntState(taunterId, TAUNT_STATE.NONE);
+}

package/src/engine/combat/motionClaim.ts

@@ -0,0 +1,268 @@
+// ONE motion decision per unit at a time. The chain already runs one arm a tick; what this book fixes
+// is re-deciding from scratch, per-arm latches nobody else could see, and 19 producers with no priority.
+
+import type { CombatPosYd } from './combatGeometry.ts';
+import { detHypot } from '../core/detMath.ts';
+
+// Who is moving the unit. The priority table below mirrors the `advanceGapClose` chain, so arbitration
+// cannot silently re-order what the chain already decides inside one tick.
+export type MotionOwner =
+  /** Knockback / leap / charge arrival / teleport — a displacement, not a decision. */
+  | 'forced'
+  /** Fear, DoFlee, NO_MELEE_FLEE. Cite: FleeingMovementGenerator. */
+  | 'flee'
+  /** Scripted mechanic move (a rotation `move` row). */
+  | 'mechanic'
+  /** Held direction — WASD / virtual stick. */
+  | 'key'
+  /** Explicit player dest that must survive a pre-cast: the `holdCourse` click. */
+  | 'course'
+  /** Authored after-cast retreat (`after.stepBackYd`). */
+  | 'stepback'
+  /** Explicit player dest — floor click, RTS order, summon reposition. */
+  | 'click'
+  /** Policy dest — autopilot route step, loot approach, formation, camera recentre. */
+  | 'route'
+  /** Pet bar Stay / Follow. */
+  | 'pet'
+  /** Guardian / spirit MoveFollow. */
+  | 'follow'
+  /** Hold-ground return to anchor (`cfg.friendlyHoldYd`). */
+  | 'home'
+  /** Melee flank slot / cone rotation slide. */
+  | 'flank'
+  /** AI gap-close and the ranged stand band. */
+  | 'chase';
+
+/** Higher wins. Same order as the chain in `advanceGapClose`. */
+export const MOTION_PRIO: Record<MotionOwner, number> = {
+  forced: 110,
+  flee: 100,
+  mechanic: 90,
+  key: 80,
+  course: 75,
+  stepback: 70,
+  click: 60,
+  route: 55,
+  pet: 50,
+  follow: 45,
+  home: 40,
+  flank: 30,
+  chase: 20,
+};
+
+// How long a live claim may not be taken by an owner at or BELOW its priority. Zero for anything a
+// person does or a script forces; non-zero only where the flip was actually measured.
+export const MOTION_HOLD_MS: Record<MotionOwner, number> = {
+  forced: 0,
+  flee: 0,
+  mechanic: 0,
+  key: 0,
+  course: 0,
+  stepback: 0,
+  click: 0,
+  // A policy walk owns the unit until it arrives, capped so a wedged one cannot hold it for the fight.
+  // Two seconds measured best: 246 yd walked and 99 reversals became 87 and 12.
+  route: 2_000,
+  pet: 0,
+  follow: 0,
+  home: 0,
+  flank: 800,
+  // Chase is the floor of the order, so a hold here could only ever block chase itself.
+  chase: 0,
+};
+
+// After an owner releases, how long before that SAME owner may claim again — the settle latch
+// generalised. Without it a slide that just finished re-solves against the boundary and walks back in.
+export const MOTION_SETTLE_MS: Record<MotionOwner, number> = {
+  forced: 0,
+  flee: 0,
+  mechanic: 0,
+  key: 0,
+  course: 0,
+  stepback: 0,
+  click: 0,
+  route: 0,
+  pet: 0,
+  follow: 0,
+  home: 0,
+  flank: 1_500,
+  chase: 0,
+};
+
+// Yards the goal must move before the SAME owner may re-aim. A mob that walked half a yard is not a new
+// destination. Zero for a person: every click is a new goal, however small.
+export const MOTION_REAIM_YD: Record<MotionOwner, number> = {
+  forced: 0,
+  flee: 0,
+  mechanic: 0,
+  key: 0,
+  course: 0,
+  stepback: 0,
+  click: 0,
+  route: 2.5,
+  pet: 0,
+  follow: 0,
+  home: 0,
+  flank: 1,
+  // Zero on purpose. A chase goal is a moving body, and the corridor churn a band would stop is already
+  // stopped by the path regrid. With a 2 yd band the aim lagged and catch-up cost 200 yd for 37 net.
+  chase: 0,
+};
+
+export type MotionClaim = {
+  owner: MotionOwner;
+  /** Goal in combat yards. `key` passes its per-tick aim — a null goal reads as a refusal
+   *  through `takeMotion`, which is exactly how WASD shipped dead (sessionMoveIntent.ts:54). */
+  goal: CombatPosYd | null;
+  since: number;
+  /** No owner at or below this priority may take the claim before this. */
+  holdUntil: number;
+  /** Last tick this owner moved the unit — a claim nobody refreshes is stale, not eternal. */
+  touched: number;
+};
+
+// A claim nobody refreshed for this many ticks is dead. Motion runs every tick for every living unit,
+// so staleness IS the release for every arm whose settle window is zero.
+const CLAIM_STALE_TICKS = 3;
+
+export type MotionClaimOpts = {
+  /** Skip the dead band and the settle window (a person acted). */
+  force?: boolean;
+  /** Override the owner's hold window — the authored step-back walks its own deadline. */
+  holdMs?: number;
+};
+
+export type MotionClaims = {
+  // Take motion for `owner` toward `goal`, or return false and move nothing this tick. A refusal is final
+  // for the tick: the caller returns, it never falls through to a lower arm.
+  take: (
+    side: string,
+    owner: MotionOwner,
+    goal: CombatPosYd | null,
+    now: number,
+    opts?: MotionClaimOpts,
+  ) => boolean;
+  /** Owner of this unit's live motion, or null. */
+  ownerOf: (side: string, now: number) => MotionOwner | null;
+  /** Goal the live claim is walking, or null. */
+  goalOf: (side: string, now: number) => CombatPosYd | null;
+  /** Arrived / cancelled: drop the claim and start this owner's settle window. */
+  release: (side: string, owner: MotionOwner, now: number) => void;
+  /** A displacement landed (knockback, leap, teleport): nothing anyone was walking survives. */
+  breakAll: (side: string) => void;
+  /** Priority / settle denials since session start — proves the gate is not inert. */
+  refused: () => number;
+  /** Same-owner re-aims kept inside the dead band: the goal churn that no longer happens. */
+  reaimsKept: () => number;
+  /** Grants where the owner changed. High means the arms are still trading the unit. */
+  handovers: () => number;
+};
+
+export function createMotionClaims(tickMs: number): MotionClaims {
+  const staleMs = Math.max(1, tickMs) * CLAIM_STALE_TICKS;
+  const live = new Map<string, MotionClaim>();
+  /** side -> owner -> earliest tick that owner may claim again. */
+  const settle = new Map<string, Map<MotionOwner, number>>();
+  // Per side and owner, the last goal that owner walked, kept AFTER the claim ends. The dead band has to
+  // outlive arrival or a wobbling dest re-claims as brand new — 220 yd walked for 40 net.
+  const lastGoal = new Map<string, Map<MotionOwner, CombatPosYd>>();
+  let refused = 0;
+  let reaimsKept = 0;
+  let handovers = 0;
+
+  const fresh = (cur: MotionClaim | undefined, now: number, side: string): MotionClaim | null => {
+    if (!cur) return null;
+    // The owner stopped moving without releasing (a cast started, its arm went ineligible).
+    // Without this a one-tick claim would hold the unit for the rest of the fight.
+    if (now - cur.touched > staleMs) {
+      live.delete(side);
+      return null;
+    }
+    return cur;
+  };
+
+  return {
+    take: (side, owner, goal, now, opts) => {
+      const held = fresh(live.get(side), now, side);
+      const prio = MOTION_PRIO[owner];
+      if (held && held.owner !== owner) {
+        // Below the holder always waits. At or above it waits only out the hold window.
+        if (prio < MOTION_PRIO[held.owner] || now < held.holdUntil) {
+          refused += 1;
+          return false;
+        }
+      } else if (held) {
+        // Same owner re-aiming. A goal inside the dead band IS the live goal: keep the claim and
+        // its corridor instead of issuing a new one every tick.
+        const band = opts?.force === true ? 0 : MOTION_REAIM_YD[owner];
+        if (band > 0 && held.goal && goal
+          && detHypot(goal.x - held.goal.x, goal.y - held.goal.y) <= band) {
+          // Not a denial: the owner keeps the unit and keeps walking the goal it already has.
+          held.touched = now;
+          reaimsKept += 1;
+          return false;
+        }
+        // A NEW goal from the same owner inside its own hold window is a re-plan, and a re-plan is not
+        // an intention. This is the arm that stops a policy producer redrawing the walk every few ticks.
+        if (opts?.force !== true && now < held.holdUntil) {
+          held.touched = now;
+          refused += 1;
+          return false;
+        }
+      } else if (opts?.force !== true) {
+        if ((settle.get(side)?.get(owner) ?? 0) > now) {
+          refused += 1;
+          return false;
+        }
+        const band = MOTION_REAIM_YD[owner];
+        const prevGoal = band > 0 ? lastGoal.get(side)?.get(owner) : undefined;
+        if (prevGoal && goal
+          && detHypot(goal.x - prevGoal.x, goal.y - prevGoal.y) <= band) {
+          reaimsKept += 1;
+          return false;
+        }
+      }
+      if (!held || held.owner !== owner) handovers += 1;
+      if (goal) {
+        let byOwner = lastGoal.get(side);
+        if (!byOwner) {
+          byOwner = new Map();
+          lastGoal.set(side, byOwner);
+        }
+        byOwner.set(owner, { x: goal.x, y: goal.y });
+      }
+      live.set(side, {
+        owner,
+        goal: goal ? { ...goal } : null,
+        since: held && held.owner === owner ? held.since : now,
+        holdUntil: now + (opts?.holdMs ?? MOTION_HOLD_MS[owner]),
+        touched: now,
+      });
+      return true;
+    },
+    ownerOf: (side, now) => fresh(live.get(side), now, side)?.owner ?? null,
+    goalOf: (side, now) => fresh(live.get(side), now, side)?.goal ?? null,
+    release: (side, owner, now) => {
+      const cur = live.get(side);
+      if (cur && cur.owner !== owner) return;
+      live.delete(side);
+      const ms = MOTION_SETTLE_MS[owner];
+      if (ms <= 0) return;
+      let byOwner = settle.get(side);
+      if (!byOwner) {
+        byOwner = new Map();
+        settle.set(side, byOwner);
+      }
+      byOwner.set(owner, now + ms);
+    },
+    breakAll: (side) => {
+      live.delete(side);
+      settle.delete(side);
+      lastGoal.delete(side);
+    },
+    refused: () => refused,
+    reaimsKept: () => reaimsKept,
+    handovers: () => handovers,
+  };
+}

package/src/engine/combat/motionGate.ts

@@ -0,0 +1,150 @@
+// WHY a unit did not move, named at the gate that stopped it. More than twenty early returns stop a
+// unit dead and from outside they are indistinguishable. Diagnosis only — nothing reads it back.
+
+// The gate that resolved a unit's motion this tick, in `advanceGapClose` order. `stepped` is the only one
+// that means the unit actually walked.
+export type MotionGateName =
+  /** No geometry on this session — motion never runs. */
+  | 'noPositions'
+  | 'dead'
+  | 'casting'
+  | 'charging'
+  | 'channeling'
+  /** Root / stun / incapacitate / SESSILE. */
+  | 'immobile'
+  /** Fear, DoFlee, NO_MELEE_FLEE — forced flight, not a stop. */
+  | 'fleeing'
+  | 'totem'
+  /** A rotation `move` row owns the unit. */
+  | 'mechanicMove'
+  /** Held key / stick. */
+  | 'moveIntent'
+  /** After-cast authored retreat. */
+  | 'stepBack'
+  /** Click-to-move / RTS order is walking it. */
+  | 'moveOrder'
+  /** The player holds motion (kiting latch) — gap-close may not take over. */
+  | 'manualMotion'
+  | 'petCommand'
+  | 'guardianFollow'
+  | 'spiritFollow'
+  /** RTS stance hold / passive. */
+  | 'stance'
+  /** Enemy with an empty threat list: no pull yet. */
+  | 'notEngaged'
+  /** cfg.friendlyHoldYd bubble — walking home, not toward a foe. */
+  | 'holdGround'
+  /** cfg.partyFollowYd bubble — no target in acquire range, walking back to the leader. */
+  | 'partyFollow'
+  /** EventAI / ScriptDev combat movement off: stands and fights, never gap-closes. */
+  | 'noCombatMovement'
+  | 'noTarget'
+  /** `foeOf`'s "no living hostiles" sentinel handed back the unit itself. */
+  | 'targetIsSelf'
+  /** One of the two units has no position this tick. */
+  | 'noPose'
+  /** Different floor: dz past STOREY_DZ_YD, which folds combat distance out of range. */
+  | 'storeyMismatch'
+  | 'pastAcquire'
+  /** Past COMBAT_DROP_YD: the leash dropped the fight. Cite: CombatManager.cpp:41. */
+  | 'combatDrop'
+  /** 100% snare / immobilised by aura stack. */
+  | 'speedZero'
+  /** The unreachable watchdog fired and the unit evaded. */
+  | 'unreachable'
+  /** A higher-priority arm owns motion this tick (motionClaim.ts). */
+  | 'claimHeldBy'
+  /** Already inside its stand band with range, storey and LOS. */
+  | 'inRange'
+  /** `movement: 'hold'` never closes voluntarily. */
+  | 'policyHold'
+  /** The step would walk inside an unpulled passive's GetAttackDistance — chain pull. */
+  | 'wouldPull'
+  /** No melee weapon and no fireable range: nothing to close for. */
+  | 'noWeapon'
+  /** The claim was taken but no corridor reached the slot — stand and fight. */
+  | 'noRoute'
+  | 'stepped';
+
+/** Inputs the gate read, when it read any. Absent means the gate did not measure it. */
+export interface MotionGateInfo {
+  dist?: number;
+  acquire?: number;
+  dz?: number;
+  threat?: number;
+  ms?: number;
+  owner?: string;
+}
+
+/** What `session.motionExplain(side)` hands back: the gate plus whatever it measured. */
+export interface MotionGateReport extends MotionGateInfo {
+  gate: MotionGateName;
+  /** `ctx.t` of the tick that wrote this row. */
+  at: number;
+}
+
+export type MotionGates = {
+  /** Record the gate that resolved this side's motion. Last write in a tick wins. */
+  mark: (side: string, gate: MotionGateName, at: number, info?: MotionGateInfo) => void;
+  /** This side's last gate, or null when motion has never resolved it. */
+  read: (side: string) => MotionGateReport | null;
+  /** Every side that has a row — the shape `navDiag()` returns. */
+  all: () => Record<string, MotionGateReport>;
+};
+
+/** Live row: fixed shape, mutated in place, so a 40-man raid allocates once per side. */
+interface LiveGate {
+  gate: MotionGateName;
+  at: number;
+  dist: number;
+  acquire: number;
+  dz: number;
+  threat: number;
+  ms: number;
+  owner: string;
+}
+
+/** NaN / '' is "the gate did not measure this", which `report` drops rather than pass on. */
+function report(r: LiveGate): MotionGateReport {
+  const out: MotionGateReport = { gate: r.gate, at: r.at };
+  if (Number.isFinite(r.dist)) out.dist = r.dist;
+  if (Number.isFinite(r.acquire)) out.acquire = r.acquire;
+  if (Number.isFinite(r.dz)) out.dz = r.dz;
+  if (Number.isFinite(r.threat)) out.threat = r.threat;
+  if (Number.isFinite(r.ms)) out.ms = r.ms;
+  if (r.owner !== '') out.owner = r.owner;
+  return out;
+}
+
+export function createMotionGates(): MotionGates {
+  const live = new Map<string, LiveGate>();
+  return {
+    mark: (side, gate, at, info) => {
+      let r = live.get(side);
+      if (!r) {
+        r = {
+          gate, at, dist: Number.NaN, acquire: Number.NaN, dz: Number.NaN,
+          threat: Number.NaN, ms: Number.NaN, owner: '',
+        };
+        live.set(side, r);
+      }
+      r.gate = gate;
+      r.at = at;
+      r.dist = info?.dist ?? Number.NaN;
+      r.acquire = info?.acquire ?? Number.NaN;
+      r.dz = info?.dz ?? Number.NaN;
+      r.threat = info?.threat ?? Number.NaN;
+      r.ms = info?.ms ?? Number.NaN;
+      r.owner = info?.owner ?? '';
+    },
+    read: (side) => {
+      const r = live.get(side);
+      return r ? report(r) : null;
+    },
+    all: () => {
+      const out: Record<string, MotionGateReport> = {};
+      for (const [side, r] of live) out[side] = report(r);
+      return out;
+    },
+  };
+}

package/src/engine/combat/motionGenerator.ts

@@ -0,0 +1,27 @@
+// One motion behaviour as an object that owns its own state, mirroring the C++ generator: "am I stuck",
+// "where do I reset to" and "what kind am I" are questions the behaviour answers about itself.
+
+import type { MotionOwner } from './motionClaim.ts';
+import type { CombatPosYd } from './combatGeometry.ts';
+import type { Fighter } from './types.ts';
+
+export interface MotionGenerator {
+  /** GetMovementGeneratorType (MovementGenerator.h:48). MOTION_PRIO orders these. */
+  readonly owner: MotionOwner;
+  // Update: true when this generator HANDLED the unit this tick, so nothing below it may run — a
+  // deliberate stand is handled. False means it declined and the chain falls through.
+  update: (f: Fighter, tickMs: number) => boolean;
+  /** Initialize (`:37`) — before this generator goes on the unit's stack. */
+  initialize?: (f: Fighter) => void;
+  /** Finalize (`:39`) — off the stack for good; drop the unit's per-leg state here. */
+  finalize?: (f: Fighter) => void;
+  /** Interrupt (`:42`) — something took the top; keep state, stop steering. */
+  interrupt?: (f: Fighter) => void;
+  /** Reset (`:44`) — back on top after the generator above it left. */
+  reset?: (f: Fighter) => void;
+  // IsReachable: false when this generator's own dest cannot be walked to from here. Today an outside
+  // arm decides that off a plan-level test; the phase that makes this the input is still ahead.
+  isReachable?: (f: Fighter) => boolean;
+  /** GetResetPosition (`:55`) — where an evade sends the unit back to. */
+  resetPosition?: (f: Fighter) => CombatPosYd | null;
+}

package/src/engine/combat/navSight.ts

@@ -0,0 +1,138 @@
+// Line of sight for a live combat tick — one implementation for casts and AoE fan-out. Three callers
+// each carried their own copy of translate-then-test, and none knew about the storey stack.
+
+import {
+  sightClearForMap,
+} from '../../domain/nav/nav.ts';
+import { findNearestPoly, navMeshForMap } from '../../domain/nav/navmesh.ts';
+import { type CombatPosYd, type PullGeometryAnchor } from './combatGeometry.ts';
+
+export interface NavSightCfg {
+  geometryAnchor?: PullGeometryAnchor;
+}
+
+// A combat-yard offset to client world, when the session is anchored to real coordinates. The z is
+// carried, and that is the whole reason this works: without it every test matched any stacked layer.
+function toWorld(p: CombatPosYd, anchor: PullGeometryAnchor | undefined): CombatPosYd {
+  const o = anchor?.frame === 'world-translated' ? anchor.origin : undefined;
+  const x = o ? o.x + p.x : p.x;
+  const y = o ? o.y + p.y : p.y;
+  // One literal per shape, not `{ ...xy, z }`: the spread was 235 ms of CopyDataProperties
+  // on top of 234 ms of toWorld itself (Firefox capture 2026-08-20).
+  return p.z != null && Number.isFinite(p.z) ? { x, y, z: p.z } : { x, y };
+}
+
+// Is this body on the floor? The SAME question motion asks, to the same tolerance — a stricter one
+// here made a step that ended on a door lip read "sight clear". Cite: sessionMotion.ts:653 offMesh.
+function onMesh(mapId: number | undefined, p: CombatPosYd): boolean {
+  const mesh = mapId != null ? navMeshForMap(mapId) : null;
+  if (!mesh) return false;
+  const hit = findNearestPoly(mesh, p.x, p.y, p.z, 2);
+  return !!hit && hit.dist <= 1.6;
+}
+
+// A per-step pair memo, still keyed on exact world coords so a mid-tick move misses, but with no
+// strings: the string keys cost more than the geometry they cached. Per map, so two masks cannot share.
+interface MapMemo {
+  /** x -> y -> z -> position id. z is NaN when the caller had none (a valid, distinct Map key). */
+  xs: Map<number, Map<number, Map<number, number>>>;
+  next: number;
+  pairs: Map<number, boolean>;
+  // The on-mesh answer per position id. It is a property of the POINT but sat inside the pair test, so
+  // a 40-unit floor asked it up to 40 times per position per step.
+  mesh: (boolean | undefined)[];
+}
+
+const byMap = new Map<number, MapMemo>();
+let memoLive = false;
+
+/** Pair key radix. Ids are per-step and per-map; ~10^2 units, so 2^20 is unreachable. */
+const ID_RADIX = 1 << 20;
+
+export function resetNavSightMemo(): void {
+  if (memoLive) {
+    byMap.clear();
+    memoLive = false;
+  }
+}
+
+function internPos(m: MapMemo, x: number, y: number, z: number): number {
+  let ys = m.xs.get(x);
+  if (ys === undefined) {
+    ys = new Map<number, Map<number, number>>();
+    m.xs.set(x, ys);
+  }
+  let zs = ys.get(y);
+  if (zs === undefined) {
+    zs = new Map<number, number>();
+    ys.set(y, zs);
+  }
+  let id = zs.get(z);
+  if (id === undefined) {
+    id = m.next++;
+    zs.set(z, id);
+  }
+  return id;
+}
+
+/** Same two shapes toWorld produces: z carried only when the caller had a finite one. */
+function worldPos(x: number, y: number, z: number): CombatPosYd {
+  return Number.isNaN(z) ? { x, y } : { x, y, z };
+}
+
+function onMeshCached(m: MapMemo, id: number, mapId: number, p: CombatPosYd): boolean {
+  const hit = m.mesh[id];
+  if (hit !== undefined) return hit;
+  const ans = onMesh(mapId, p);
+  m.mesh[id] = ans;
+  return ans;
+}
+
+function sightUncached(mapId: number | undefined, aw: CombatPosYd, bw: CombatPosYd): boolean {
+  if (!onMesh(mapId, aw) || !onMesh(mapId, bw)) return true;
+  return (mapId != null ? sightClearForMap(mapId, aw, bw) : null) ?? true;
+}
+
+// True when nothing opaque stands between two combat positions. FAILS OPEN with no registered geometry,
+// with a missing position, and when either end is off-mesh: the mask is authoritative only where it says
+export function navSightClear(
+  cfg: NavSightCfg,
+  a: CombatPosYd | undefined,
+  b: CombatPosYd | undefined,
+): boolean {
+  if (!a || !b) return true;
+  const anchor = cfg.geometryAnchor;
+  const mapId = anchor?.mapId;
+  // Memo only when the registry keys the geometry (live maps). A session with no map id has
+  // nothing registered to ask, and inventing geometry is what this fails open to avoid.
+  if (mapId == null) return true;
+  const o = anchor?.frame === 'world-translated' ? anchor.origin : undefined;
+  const ax = o ? o.x + a.x : a.x;
+  const ay = o ? o.y + a.y : a.y;
+  const az = a.z != null && Number.isFinite(a.z) ? a.z : NaN;
+  const bx = o ? o.x + b.x : b.x;
+  const by = o ? o.y + b.y : b.y;
+  const bz = b.z != null && Number.isFinite(b.z) ? b.z : NaN;
+  let m = byMap.get(mapId);
+  if (m === undefined) {
+    m = { xs: new Map(), next: 0, pairs: new Map(), mesh: [] };
+    byMap.set(mapId, m);
+    memoLive = true;
+  }
+  const ia = internPos(m, ax, ay, az);
+  const ib = internPos(m, bx, by, bz);
+  // The world positions are the only allocation left, and only a miss pays for them.
+  if (ia >= ID_RADIX || ib >= ID_RADIX) {
+    return sightUncached(mapId, worldPos(ax, ay, az), worldPos(bx, by, bz));
+  }
+  const k = ia < ib ? ia * ID_RADIX + ib : ib * ID_RADIX + ia;
+  const hit = m.pairs.get(k);
+  if (hit !== undefined) return hit;
+  const aw = worldPos(ax, ay, az);
+  const bw = worldPos(bx, by, bz);
+  const ans = !onMeshCached(m, ia, mapId, aw) || !onMeshCached(m, ib, mapId, bw)
+    ? true
+    : (sightClearForMap(mapId, aw, bw) ?? true);
+  m.pairs.set(k, ans);
+  return ans;
+}

package/src/engine/combat/perfSink.ts

@@ -0,0 +1,28 @@
+// The phase timer for the engine tick, installed by the UI and absent everywhere else. The engine must
+// not import the UI, and there is one profiler per page, so one sink is the right shape.
+type PerfFn = <T>(name: string, fn: () => T) => T;
+/** enter/leave for a phase whose body is too large to wrap in a closure. Same self-time contract. */
+interface SpanSink { enter: (name: string) => void; leave: (name: string) => void }
+
+let sink: PerfFn | null = null;
+let spans: SpanSink | null = null;
+
+/** Null uninstalls. runProfiler.time is already a no-op while the profiler is stopped. */
+export function setCombatPerfSink(fn: PerfFn | null, span?: SpanSink | null): void {
+  sink = fn;
+  spans = span ?? null;
+}
+
+/** One extra frame when no sink is installed; the JIT inlines it. */
+export function combatPerf<T>(name: string, fn: () => T): T {
+  return sink ? sink(name, fn) : fn();
+}
+
+/** Balanced pair around one tick phase, for a block a closure would have to re-indent. */
+export function combatPerfEnter(name: string): void {
+  spans?.enter(name);
+}
+
+export function combatPerfLeave(name: string): void {
+  spans?.leave(name);
+}