@kar-mi/spirit-vale-tools-combat 3.3.6 → 5.0.0

package/dist/index.js

@@ -1,15 +1,26 @@
 // @bun
-// src/combat-tracker.ts
+// src/tracking/combat-tracker.ts
 import {
-  classifyFishNetRecoveryStyle,
   CURRENT_GAME_BUILD_FINGERPRINT,
-  FishNetMonsterDirectory,
-  loadBundledFishNetSemanticMap
+  loadBundledFishNetRpcMap
 } from "@kar-mi/spirit-vale-tools-capture";
-import { readSignedPackedWhole as readSignedPackedWhole2 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+import { readSignedPackedWhole as readSignedPackedWhole3 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
 import { loadBundledSkillCatalog } from "@kar-mi/spirit-vale-tools-skills";
 
-// src/effect-display.ts
+// src/events/decoded-fields.ts
+function field(packet, name) {
+  return packet.decodedFields?.find((candidate) => candidate.name === name)?.value;
+}
+function numberField(packet, name) {
+  const value = field(packet, name);
+  return typeof value === "number" ? value : undefined;
+}
+function nullableStringField(packet, name) {
+  const value = field(packet, name);
+  return value === null || typeof value === "string" ? value : undefined;
+}
+
+// src/events/effect-display.ts
 import { FishNetProtocolError } from "@kar-mi/spirit-vale-tools-capture";
 import { checkedEnd, readSignedPackedWhole, requireBytes } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
 function decodeEffectDisplays(payload) {
@@ -69,7 +80,445 @@ function readBoolean(buffer, offset, description) {
   return { value: value === 1, nextOffset: offset + 1 };
 }
 
-// src/combat-tracker.ts
+// src/events/inference/recovery-style.ts
+function classifyFishNetRecoveryStyle(packet) {
+  if (packet.rpcName !== "Recover_C" || packet.networkBehaviourType !== "HealthComponent")
+    return "unknown";
+  const value = (name) => packet.decodedFields?.find((field2) => field2.name === name)?.value;
+  const disableFloater = value("settings.DisableFloater");
+  const disableSfx = value("settings.DisableSfx");
+  const offset = value("settings.Offset");
+  const scale = value("settings.Scale");
+  if (typeof disableFloater !== "boolean" || typeof disableSfx !== "boolean" || typeof offset !== "number" || typeof scale !== "number")
+    return "unknown";
+  if (!disableFloater && disableSfx && offset < 0 && scale > 0)
+    return "drain";
+  if (!disableFloater && disableSfx && offset === 0 && scale === 0)
+    return "passive-regeneration";
+  if (!disableFloater && !disableSfx && offset > 0 && scale === 0)
+    return "standard";
+  return "unknown";
+}
+
+// src/events/damage-observer.ts
+function observeFishNetDamagePacket(packet) {
+  if (packet.objectId === undefined || packet.rpcName !== "ApplyDamage_C" && packet.rpcName !== "Death_C")
+    return;
+  if (packet.networkBehaviourType !== undefined && packet.networkBehaviourType !== "HealthComponent")
+    return;
+  const requireVectors = packet.rpcName === "ApplyDamage_C";
+  const numeric = [
+    "dmg.Team",
+    "dmg.Value",
+    "dmg.Type",
+    "dmg.Hit",
+    "dmg.Hits",
+    "dmg.AttackerId",
+    "dmg.Element",
+    "dmg.WeaponType",
+    "dmg.Range"
+  ];
+  if (!numeric.every((name) => numberField(packet, name) !== undefined) || nullableStringField(packet, "dmg.DamageSourceId") === undefined || typeof field(packet, "dmg.IsClone") !== "boolean" || typeof field(packet, "dmg.IsSummon") !== "boolean" || requireVectors && (!Array.isArray(field(packet, "position")) || !Array.isArray(field(packet, "origin")))) {
+    return;
+  }
+  return {
+    kind: packet.rpcName === "Death_C" ? "death" : "damage",
+    tick: packet.tick,
+    actorId: numberField(packet, "dmg.AttackerId"),
+    targetId: packet.objectId,
+    value: numberField(packet, "dmg.Value"),
+    team: numberField(packet, "dmg.Team")
+  };
+}
+
+// src/events/generated/combat-semantics.ts
+var COMBAT_SEMANTICS_BUILD_FINGERPRINT = "53305f369c4176d4b7644d06ad7f0cdc5c9bda6563144d0ce8cff3d12c520158";
+var DIRECT_HEALING_SKILL_IDS = new Set([
+  "Consecration",
+  "DeathCoilSummon",
+  "FieldHealing",
+  "Heal",
+  "HighHeal"
+]);
+var REGENERATION_SKILL_IDS = new Set([
+  "GuardianBond",
+  "HealAll",
+  "Sanctuary",
+  "SanctuaryField"
+]);
+var BARRIER_SKILL_IDS = new Set([
+  "Barrier",
+  "CorpseBarrier",
+  "EclipsingAegis"
+]);
+var BARRIER_STATUS_IDS = new Set([
+  "Barrier",
+  "CorpseBarrier",
+  "EclipsingAegis",
+  "RadiantBulwark"
+]);
+
+// src/events/combat-decoding.ts
+import { readSignedPackedWhole as readSignedPackedWhole2 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+var DAMAGE_TYPE_SOURCES = new Map([
+  [4, { sourceId: "reflect", sourceLabel: "Reflect Damage" }]
+]);
+function matchesBehaviour(packet, expected) {
+  return packet.networkBehaviourType === undefined || packet.networkBehaviourType === expected;
+}
+function stringField(packet, name) {
+  const value = field(packet, name);
+  return typeof value === "string" ? value : undefined;
+}
+function requiredNumberField(packet, name) {
+  const value = numberField(packet, name);
+  if (value === undefined)
+    throw new Error(`${packet.networkBehaviourType}.${packet.rpcName} is missing numeric field ${name}`);
+  return value;
+}
+function requiredBooleanField(packet, name) {
+  const value = field(packet, name);
+  if (typeof value !== "boolean")
+    throw new Error(`${packet.networkBehaviourType}.${packet.rpcName} is missing boolean field ${name}`);
+  return value;
+}
+function requiredVectorField(packet, name) {
+  const value = field(packet, name);
+  if (!Array.isArray(value))
+    throw new Error(`${packet.networkBehaviourType}.${packet.rpcName} is missing vector field ${name}`);
+  return value;
+}
+function decodedFieldRecord(packet) {
+  return Object.fromEntries(packet.decodedFields?.map(({ name, value }) => [name, value]) ?? []);
+}
+function healthComponentIndices(map) {
+  return new Set(map?.prefabs?.flatMap(({ components }) => components.filter(({ typeName }) => typeName === "HealthComponent").map(({ index }) => index)) ?? []);
+}
+function isCompleteRecoverPacket(packet) {
+  return numberField(packet, "amount") !== undefined && typeof field(packet, "settings.DisableFloater") === "boolean" && typeof field(packet, "settings.DisableSfx") === "boolean" && numberField(packet, "settings.Offset") !== undefined && numberField(packet, "settings.Scale") !== undefined && (!packet.undecodedPayload || packet.undecodedPayload.length === 0);
+}
+function damageSignature(tick, targetId, actorId, sourceId, value, hitCode) {
+  return `${tick}\x00${targetId}\x00${actorId}\x00${sourceId}\x00${value}\x00${hitCode}`;
+}
+function drainRecoverySource(traits) {
+  if (traits?.hasSiphonHealth && !traits.hasHealthLeech) {
+    return { sourceId: "siphon-health", sourceLabel: "Siphon Health" };
+  }
+  if (traits?.hasHealthLeech && !traits.hasSiphonHealth) {
+    return { sourceId: "health-leech", sourceLabel: "Health Leech" };
+  }
+  return { sourceId: "siphon-health-leech", sourceLabel: "Siphon / Health Leech" };
+}
+function resolveDamageSource(rawSourceId, damageType, skillLabels) {
+  if (typeof rawSourceId === "string") {
+    return {
+      sourceId: rawSourceId,
+      sourceLabel: skillLabels.get(rawSourceId) ?? rawSourceId
+    };
+  }
+  return (rawSourceId === null ? DAMAGE_TYPE_SOURCES.get(damageType) : undefined) ?? {
+    sourceId: "unknown",
+    sourceLabel: "unknown"
+  };
+}
+function uniqueMonsterIdentityEvents(events) {
+  return events.filter((event, index) => event.operation !== "reset" || events.findIndex((candidate) => candidate.operation === "reset") === index);
+}
+function barrierSyncValues(packet) {
+  const values = [];
+  const read = (entry, behaviourType) => {
+    if (behaviourType !== undefined && behaviourType !== "HealthComponent")
+      return;
+    if (entry.index !== 2 && entry.name !== "barrierSync")
+      return;
+    const value = entry.fields.find(({ name }) => name === "barrierSync")?.value;
+    if (typeof value === "number")
+      values.push(value);
+  };
+  for (const entry of packet.spawnSyncEntries ?? [])
+    read(entry, entry.networkBehaviourType);
+  if (packet.packetName === "syncType" && matchesBehaviour(packet, "HealthComponent")) {
+    for (const entry of packet.syncEntries ?? [])
+      read(entry, packet.networkBehaviourType);
+    if (!packet.syncEntries) {
+      const value = numberField(packet, "barrierSync");
+      if ((packet.syncIndex === 2 || packet.syncName === "barrierSync") && value !== undefined)
+        values.push(value);
+    }
+  }
+  return values;
+}
+function bondSyncEntries(packet) {
+  const decode = (entry, behaviourType) => {
+    if (behaviourType !== undefined && behaviourType !== "SkillsComponent")
+      return;
+    if (entry.index !== 2 && entry.name !== "BondSync")
+      return;
+    const length = entry.fields.find(({ name }) => name === "Entries.length")?.value;
+    if (typeof length !== "number" || !Number.isInteger(length) || length < 0)
+      return;
+    const result = [];
+    for (let index = 0;index < length; index += 1) {
+      const prefix = `Entries[${index}]`;
+      const otherId = entry.fields.find(({ name }) => name === `${prefix}.Other`)?.value;
+      const skillId = entry.fields.find(({ name }) => name === `${prefix}.SkillId`)?.value;
+      const caster = entry.fields.find(({ name }) => name === `${prefix}.Caster`)?.value;
+      if (typeof otherId !== "number" || typeof skillId !== "string" || typeof caster !== "boolean")
+        return;
+      result.push({ otherId, skillId, caster });
+    }
+    return result;
+  };
+  for (const entry of packet.spawnSyncEntries ?? []) {
+    const result = decode(entry, entry.networkBehaviourType);
+    if (result)
+      return result;
+  }
+  if (packet.packetName === "syncType" && matchesBehaviour(packet, "SkillsComponent")) {
+    for (const entry of packet.syncEntries ?? []) {
+      const result = decode(entry, packet.networkBehaviourType);
+      if (result)
+        return result;
+    }
+  }
+  return;
+}
+function decodeFloaterSettings(payload, start) {
+  if (payload.length - start < 2)
+    return;
+  const disableFloater = payload[start];
+  const disableSfx = payload[start + 1];
+  if (disableFloater !== 0 && disableFloater !== 1 || disableSfx !== 0 && disableSfx !== 1)
+    return;
+  let offset;
+  try {
+    offset = readSignedPackedWhole2(payload, start + 2);
+  } catch {
+    return;
+  }
+  if (payload.length - offset.nextOffset !== 4)
+    return;
+  return [
+    { name: "settings.DisableFloater", codec: "boolean", value: disableFloater === 1 },
+    { name: "settings.DisableSfx", codec: "boolean", value: disableSfx === 1 },
+    { name: "settings.Offset", codec: "packedInt32", value: offset.value },
+    { name: "settings.Scale", codec: "float32", value: payload.readFloatLE(offset.nextOffset) }
+  ];
+}
+function decodedSummonCalibration(packet) {
+  if (packet.undecodedPayload && packet.undecodedPayload.length > 0)
+    return;
+  const length = numberField(packet, "data.length");
+  if (length === undefined || !Number.isInteger(length) || length < 0)
+    return;
+  const entries = [];
+  for (let index = 0;index < length; index += 1) {
+    const skillId = stringField(packet, `data[${index}].SkillId`);
+    const level = numberField(packet, `data[${index}].Level`);
+    if (skillId === undefined || level === undefined || !Number.isInteger(level) || level < 0)
+      return;
+    entries.push({ skillId, level });
+  }
+  return entries;
+}
+function decodedLoginEffects(packet) {
+  if (packet.undecodedPayload && packet.undecodedPayload.length > 0)
+    return;
+  const length = numberField(packet, "data.State.Effects.length");
+  if (length === undefined || !Number.isInteger(length) || length < 0)
+    return;
+  const entries = [];
+  for (let index = 0;index < length; index += 1) {
+    const statusId = stringField(packet, `data.State.Effects[${index}].Id`);
+    const level = numberField(packet, `data.State.Effects[${index}].Level`);
+    const duration = numberField(packet, `data.State.Effects[${index}].Duration`);
+    const stacks = numberField(packet, `data.State.Effects[${index}].Stacks`);
+    if (statusId === undefined || level === undefined || !Number.isInteger(level) || level < 0 || duration === undefined || stacks === undefined || !Number.isInteger(stacks) || stacks < 0)
+      return;
+    entries.push({
+      statusId,
+      level,
+      ...duration < 0 || !Number.isFinite(duration) ? {} : { remainingSeconds: duration },
+      stacks
+    });
+  }
+  return entries;
+}
+
+// src/tracking/monster-identity.ts
+import { FishNetMonsterDirectory } from "@kar-mi/spirit-vale-tools-capture";
+
+class FishNetMonsterIdentityTracker {
+  monsterCatalog;
+  bossCatalog;
+  monsters;
+  bossIdentities = new Map;
+  constructor(options = {}) {
+    this.monsterCatalog = options.monsterCatalog;
+    if (options.monsterCatalog)
+      this.monsters = new FishNetMonsterDirectory(options.monsterCatalog);
+    this.bossCatalog = options.bossCatalog;
+  }
+  reset() {
+    this.bossIdentities.clear();
+    this.monsters?.reset();
+  }
+  consumeDirectory(packet) {
+    const change = this.monsters?.consume(packet);
+    if (!change)
+      return;
+    const tick = packet.tick;
+    if (change.operation === "reset")
+      return { kind: "monsterIdentity", operation: "reset", tick };
+    if (change.operation === "remove") {
+      return { kind: "monsterIdentity", operation: "remove", tick, actorId: change.objectId };
+    }
+    const definition = this.monsterCatalog?.get(change.spawn.mobId);
+    return definition ? {
+      kind: "monsterIdentity",
+      operation: "upsert",
+      tick,
+      actorId: change.objectId,
+      mobId: change.spawn.mobId,
+      displayName: definition.displayName
+    } : undefined;
+  }
+  observeActivation(event) {
+    if (!event.sourceId || event.actorIdentity || this.monsters?.get(event.actorId))
+      return;
+    const definition = this.bossCatalog?.get(event.sourceId);
+    if (!definition)
+      return;
+    if (this.bossIdentities.has(event.actorId))
+      return;
+    this.bossIdentities.set(event.actorId, definition.displayName);
+    return {
+      kind: "monsterIdentity",
+      operation: "upsert",
+      tick: event.tick,
+      actorId: event.actorId,
+      mobId: `boss:${event.sourceId}`,
+      displayName: definition.displayName
+    };
+  }
+  consumeBossLifecycle(packet) {
+    if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
+      if (this.bossIdentities.size === 0)
+        return;
+      this.bossIdentities.clear();
+      return { kind: "monsterIdentity", operation: "reset", tick: packet.tick };
+    }
+    if (packet.packetName !== "objectSpawn" && packet.packetName !== "objectDespawn" || packet.objectId === undefined || !this.bossIdentities.delete(packet.objectId))
+      return;
+    return { kind: "monsterIdentity", operation: "remove", tick: packet.tick, actorId: packet.objectId };
+  }
+}
+
+// src/tracking/summon-tracker.ts
+class FishNetSummonTracker {
+  actorIdentityResolver;
+  summonStacks = new Map;
+  summonSkillSyncState = new Map;
+  authoritativeSummonActors = new Set;
+  constructor(actorIdentityResolver) {
+    this.actorIdentityResolver = actorIdentityResolver;
+  }
+  reset() {
+    this.summonStacks.clear();
+    this.summonSkillSyncState.clear();
+    this.authoritativeSummonActors.clear();
+  }
+  consumeSkillSync(packet) {
+    const summonObjectId = packet.objectId;
+    const summonerSync = packet.syncEntries?.find((candidate) => candidate.name === "SummonerSync")?.fields.find((entryField) => entryField.name === "SummonerSync")?.value;
+    const skillId = packet.syncEntries?.find((candidate) => candidate.name === "SummonSkillSync")?.fields.find((entryField) => entryField.name === "SkillId")?.value;
+    if (typeof summonerSync !== "number" && typeof skillId !== "string")
+      return [];
+    const state = this.summonSkillSyncState.get(summonObjectId) ?? { counted: false };
+    if (typeof summonerSync === "number")
+      state.ownerActorId = summonerSync;
+    if (typeof skillId === "string")
+      state.skillId = skillId;
+    this.summonSkillSyncState.set(summonObjectId, state);
+    if (state.counted || state.ownerActorId === undefined || state.skillId === undefined)
+      return [];
+    if (this.authoritativeSummonActors.has(state.ownerActorId))
+      return [];
+    state.counted = true;
+    return [this.applyDelta(state.ownerActorId, state.skillId, 1, packet, "SummonSkillSync")];
+  }
+  consumeObjectLifecycle(packet) {
+    if (packet.packetName !== "objectDespawn" && packet.packetName !== "objectSpawn" || packet.objectId === undefined) {
+      return;
+    }
+    const state = this.summonSkillSyncState.get(packet.objectId);
+    if (!state)
+      return;
+    this.summonSkillSyncState.delete(packet.objectId);
+    if (!state.counted || state.ownerActorId === undefined || state.skillId === undefined)
+      return;
+    if (this.authoritativeSummonActors.has(state.ownerActorId))
+      return;
+    return this.applyDelta(state.ownerActorId, state.skillId, -1, packet, "SummonSkillSync");
+  }
+  consumeCalibration(packet) {
+    const entries = decodedSummonCalibration(packet);
+    if (!entries)
+      return [];
+    this.authoritativeSummonActors.add(packet.objectId);
+    return this.applySnapshot(packet.objectId, packet, entries);
+  }
+  applyDelta(actorId, skillId, delta, packet, rpc) {
+    const stacks = new Map(this.summonStacks.get(actorId));
+    const nextCount = Math.max(0, (stacks.get(skillId) ?? 0) + delta);
+    if (nextCount === 0)
+      stacks.delete(skillId);
+    else
+      stacks.set(skillId, nextCount);
+    if (stacks.size === 0)
+      this.summonStacks.delete(actorId);
+    else
+      this.summonStacks.set(actorId, stacks);
+    return {
+      kind: "summon",
+      rpc,
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      skillId,
+      stacks: nextCount,
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    };
+  }
+  applySnapshot(actorId, packet, entries) {
+    const previous = this.summonStacks.get(actorId) ?? new Map;
+    const current = new Map;
+    for (const { skillId } of entries)
+      current.set(skillId, (current.get(skillId) ?? 0) + 1);
+    const changedSkillIds = [
+      ...current.keys(),
+      ...[...previous.keys()].filter((skillId) => !current.has(skillId))
+    ].filter((skillId) => current.get(skillId) !== previous.get(skillId));
+    if (current.size === 0)
+      this.summonStacks.delete(actorId);
+    else
+      this.summonStacks.set(actorId, current);
+    return changedSkillIds.map((skillId) => ({
+      kind: "summon",
+      rpc: "CalibrateSummons_T",
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      skillId,
+      stacks: current.get(skillId) ?? 0,
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    }));
+  }
+}
+
+// src/tracking/combat-tracker.ts
 var HIT_RESULTS = {
   0: "normal",
   1: "critical",
@@ -79,9 +528,6 @@ var HIT_RESULTS = {
 };
 var SKILL_RPC_NAMES = new Set(["CastBegin_C", "AutoCast_C", "ToggleBegin_C", "CastComplete_C", "CastInterrupt_C", "CastCancel_C"]);
 var CURRENT_STATUS_COMPONENT_INDICES = new Set([5, 6]);
-var CURRENT_HEALTH_COMPONENT_INDICES = new Set([2, 3]);
-var HEALING_SKILL_IDS = new Set(["Heal", "HighHeal", "FieldHealing"]);
-var REGEN_SKILL_IDS = new Set(["HealAll", "Sanctuary", "GuardianBond", "SanctuaryField"]);
 var REGEN_STATUS_ID = "Regeneration";
 
 class FishNetCombatTracker {
@@ -90,16 +536,18 @@ class FishNetCombatTracker {
   skillLabels;
   actorIdentityResolver;
   healingTraitsResolver;
-  monsterCatalog;
-  bossCatalog;
-  monsters;
-  semanticMap;
+  healthComponentIndices;
+  directHealingSkillIds;
+  regenerationSkillIds;
+  barrierSkillIds;
+  barrierStatusIds;
+  monsterIdentities;
+  summons;
   activations = new Map;
-  bossIdentities = new Map;
   activeRegenSources = new Map;
-  summonStacks = new Map;
-  summonSkillSyncState = new Map;
-  authoritativeSummonActors = new Set;
+  bondRegenSources = new Map;
+  barriers = new Map;
+  recentDamageHits = new Map;
   recentDamageSignatures = new Set;
   recentDamageTick;
   nextActivation = 1;
@@ -112,26 +560,29 @@ class FishNetCombatTracker {
     if (!Number.isInteger(maxAge) || maxAge < 1)
       throw new Error("activationMaxAgeTicks must be a positive integer");
     this.activationMaxAgeTicks = maxAge;
-    const buildFingerprint = options.buildFingerprint ?? options.skillCatalog?.buildFingerprint ?? options.semanticMap?.buildFingerprint ?? CURRENT_GAME_BUILD_FINGERPRINT;
+    const buildFingerprint = options.buildFingerprint ?? options.skillCatalog?.buildFingerprint ?? CURRENT_GAME_BUILD_FINGERPRINT;
     assertMatchingBuild("skill catalog", options.skillCatalog?.buildFingerprint, buildFingerprint);
-    assertMatchingBuild("semantic map", options.semanticMap?.buildFingerprint, buildFingerprint);
     const skillCatalog = options.skillCatalog ?? tryLoadBundledSkillCatalog(buildFingerprint);
-    const semanticMap = options.semanticMap ?? (skillCatalog ? tryLoadBundledSemanticMap(buildFingerprint) : loadBundledFishNetSemanticMap(buildFingerprint));
-    this.semanticMap = semanticMap;
+    const rpcMap = tryLoadBundledRpcMap(buildFingerprint);
+    this.healthComponentIndices = healthComponentIndices(rpcMap);
+    const currentSemantics = buildFingerprint === COMBAT_SEMANTICS_BUILD_FINGERPRINT;
+    this.directHealingSkillIds = currentSemantics ? DIRECT_HEALING_SKILL_IDS : new Set;
+    this.regenerationSkillIds = currentSemantics ? REGENERATION_SKILL_IDS : new Set;
+    this.barrierSkillIds = currentSemantics ? BARRIER_SKILL_IDS : new Set;
+    this.barrierStatusIds = currentSemantics ? BARRIER_STATUS_IDS : new Set;
     this.skillLabels = new Map(skillCatalog?.skills.map(({ id, displayName }) => [id, displayName]) ?? []);
-    for (const { value, label } of semanticMap?.verifiedSkillLabels ?? [])
-      this.skillLabels.set(value, label);
     this.actorIdentityResolver = options.actorIdentityResolver;
     this.healingTraitsResolver = options.healingTraitsResolver;
-    this.monsterCatalog = options.monsterCatalog;
-    if (options.monsterCatalog)
-      this.monsters = new FishNetMonsterDirectory(options.monsterCatalog);
-    this.bossCatalog = options.bossCatalog;
+    this.monsterIdentities = new FishNetMonsterIdentityTracker({
+      monsterCatalog: options.monsterCatalog,
+      bossCatalog: options.bossCatalog
+    });
+    this.summons = new FishNetSummonTracker(options.actorIdentityResolver);
   }
   consume(packet) {
-    const monsterIdentity = this.monsterIdentity(packet.tick, this.monsters?.consume(packet));
-    const bossLifecycle = this.bossIdentityLifecycle(packet);
-    const summonLifecycle = this.consumeSummonObjectLifecycle(packet);
+    const monsterIdentity = this.monsterIdentities.consumeDirectory(packet);
+    const bossLifecycle = this.monsterIdentities.consumeBossLifecycle(packet);
+    const summonLifecycle = this.summons.consumeObjectLifecycle(packet);
     if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
       this.reset();
       return uniqueMonsterIdentityEvents([
@@ -143,14 +594,17 @@ class FishNetCombatTracker {
     if (this.recentDamageTick !== packet.tick) {
       this.recentDamageTick = packet.tick;
       this.recentDamageSignatures.clear();
+      this.recentDamageHits.clear();
     }
     const events = [
       ...monsterIdentity ? [monsterIdentity] : [],
       ...bossLifecycle ? [bossLifecycle] : [],
       ...summonLifecycle ? [summonLifecycle] : []
     ];
+    this.consumeBondSync(packet);
+    events.push(...this.consumeBarrierSync(packet));
     if (packet.packetName === "syncType" && matchesBehaviour(packet, "SummoningComponent")) {
-      events.push(...this.consumeSummonSkillSync(packet));
+      events.push(...this.summons.consumeSkillSync(packet));
       return events;
     }
     if (packet.objectId === undefined || !packet.rpcName) {
@@ -161,7 +615,7 @@ class FishNetCombatTracker {
       const skillEvent = this.consumeSkill(packet);
       if (skillEvent) {
         events.push(skillEvent);
-        const bossIdentity = this.bossIdentity(skillEvent);
+        const bossIdentity = this.monsterIdentities.observeActivation(skillEvent);
         if (bossIdentity)
           events.push(bossIdentity);
       }
@@ -173,7 +627,7 @@ class FishNetCombatTracker {
     }
     if ((packet.rpcName === "ApplyDamage_C" || packet.rpcName === "Death_C") && matchesBehaviour(packet, "HealthComponent")) {
       const death = packet.rpcName === "Death_C";
-      if (!isCompleteDamagePacket(packet, !death))
+      if (!observeFishNetDamagePacket(packet))
         return events;
       events.push(...this.consumeDamage(packet, death));
       return events;
@@ -215,7 +669,7 @@ class FishNetCombatTracker {
       return events;
     }
     if (packet.rpcName === "CalibrateSummons_T" && packet.rpcResolution === "verified" && packet.networkBehaviourType === "SummoningComponent") {
-      events.push(...this.consumeSummonCalibration(packet));
+      events.push(...this.summons.consumeCalibration(packet));
       return events;
     }
     if (packet.rpcName === "LoadCharacter_T" && packet.rpcResolution === "verified" && packet.networkBehaviourType === "PlayerSave") {
@@ -226,61 +680,14 @@ class FishNetCombatTracker {
   }
   reset() {
     this.activations.clear();
-    this.bossIdentities.clear();
     this.activeRegenSources.clear();
-    this.summonStacks.clear();
-    this.summonSkillSyncState.clear();
-    this.authoritativeSummonActors.clear();
+    this.bondRegenSources.clear();
+    this.barriers.clear();
     this.recentDamageSignatures.clear();
+    this.recentDamageHits.clear();
     this.recentDamageTick = undefined;
-    this.monsters?.reset();
-  }
-  monsterIdentity(tick, change) {
-    if (!change)
-      return;
-    if (change.operation === "reset")
-      return { kind: "monsterIdentity", operation: "reset", tick };
-    if (change.operation === "remove") {
-      return { kind: "monsterIdentity", operation: "remove", tick, actorId: change.objectId };
-    }
-    const definition = this.monsterCatalog?.get(change.spawn.mobId);
-    return definition ? {
-      kind: "monsterIdentity",
-      operation: "upsert",
-      tick,
-      actorId: change.objectId,
-      mobId: change.spawn.mobId,
-      displayName: definition.displayName
-    } : undefined;
-  }
-  bossIdentity(event) {
-    if (!event.sourceId || event.actorIdentity || this.monsters?.get(event.actorId))
-      return;
-    const definition = this.bossCatalog?.get(event.sourceId);
-    if (!definition)
-      return;
-    if (this.bossIdentities.has(event.actorId))
-      return;
-    this.bossIdentities.set(event.actorId, definition.displayName);
-    return {
-      kind: "monsterIdentity",
-      operation: "upsert",
-      tick: event.tick,
-      actorId: event.actorId,
-      mobId: `boss:${event.sourceId}`,
-      displayName: definition.displayName
-    };
-  }
-  bossIdentityLifecycle(packet) {
-    if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
-      if (this.bossIdentities.size === 0)
-        return;
-      this.bossIdentities.clear();
-      return { kind: "monsterIdentity", operation: "reset", tick: packet.tick };
-    }
-    if (packet.packetName !== "objectSpawn" && packet.packetName !== "objectDespawn" || packet.objectId === undefined || !this.bossIdentities.delete(packet.objectId))
-      return;
-    return { kind: "monsterIdentity", operation: "remove", tick: packet.tick, actorId: packet.objectId };
+    this.monsterIdentities.reset();
+    this.summons.reset();
   }
   consumeEffectDisplays(packet) {
     let batch;
@@ -299,6 +706,14 @@ class FishNetCombatTracker {
       actorId,
       actorIdentity: this.actorIdentityResolver?.(actorId)
     };
+    for (const display of batch.applies) {
+      if (this.barrierStatusIds.has(display.statusId))
+        this.observeBarrierStatus(actorId, true, packet.tick);
+    }
+    for (const statusId of batch.removes) {
+      if (this.barrierStatusIds.has(statusId))
+        this.observeBarrierStatus(actorId, false, packet.tick);
+    }
     return [
       ...batch.applies.map((display) => ({
         ...base,
@@ -320,27 +735,28 @@ class FishNetCombatTracker {
         rpcName: "ApplyEffectDisplays_O"
       });
     }
-    if (packet.rpcHash !== 1 || !CURRENT_HEALTH_COMPONENT_INDICES.has(packet.networkBehaviourIndex))
+    if (packet.rpcHash !== 1 || !this.healthComponentIndices.has(packet.networkBehaviourIndex))
       return [];
     let amount;
     try {
-      amount = readSignedPackedWhole2(packet.payload, 0);
+      amount = readSignedPackedWhole3(packet.payload, 0);
     } catch {
       return [];
     }
     if (amount.value < 0)
       return [];
-    const settings = packet.payload.subarray(amount.nextOffset);
-    const settingsHex = settings.toString("hex");
-    const knownHealthRecovery = this.semanticMap?.recoveryStyles?.some((definition) => definition.networkBehaviourType === "HealthComponent" && definition.rpcName === "Recover_C" && definition.undecodedPayloadHex === settingsHex) ?? false;
-    if (!knownHealthRecovery)
+    const settings = decodeFloaterSettings(packet.payload, amount.nextOffset);
+    if (!settings)
       return [];
     return [this.consumeRecover({
       ...packet,
       networkBehaviourType: "HealthComponent",
       rpcName: "Recover_C",
-      decodedFields: [{ name: "amount", codec: "packedInt32", value: amount.value }],
-      undecodedPayload: settings
+      decodedFields: [
+        { name: "amount", codec: "packedInt32", value: amount.value },
+        ...settings
+      ],
+      undecodedPayload: undefined
     })];
   }
   consumeSkillDisplay(packet) {
@@ -387,94 +803,6 @@ class FishNetCombatTracker {
       actorIdentity: this.actorIdentityResolver?.(actorId)
     }));
   }
-  consumeSummonSkillSync(packet) {
-    const summonObjectId = packet.objectId;
-    const summonerSync = packet.syncEntries?.find((candidate) => candidate.name === "SummonerSync")?.fields.find((entryField) => entryField.name === "SummonerSync")?.value;
-    const skillId = packet.syncEntries?.find((candidate) => candidate.name === "SummonSkillSync")?.fields.find((entryField) => entryField.name === "SkillId")?.value;
-    if (typeof summonerSync !== "number" && typeof skillId !== "string")
-      return [];
-    const state = this.summonSkillSyncState.get(summonObjectId) ?? { counted: false };
-    if (typeof summonerSync === "number")
-      state.ownerActorId = summonerSync;
-    if (typeof skillId === "string")
-      state.skillId = skillId;
-    this.summonSkillSyncState.set(summonObjectId, state);
-    if (state.counted || state.ownerActorId === undefined || state.skillId === undefined)
-      return [];
-    if (this.authoritativeSummonActors.has(state.ownerActorId))
-      return [];
-    state.counted = true;
-    return [this.applySummonDelta(state.ownerActorId, state.skillId, 1, packet, "SummonSkillSync")];
-  }
-  consumeSummonObjectLifecycle(packet) {
-    if (packet.packetName !== "objectDespawn" && packet.packetName !== "objectSpawn" || packet.objectId === undefined) {
-      return;
-    }
-    const state = this.summonSkillSyncState.get(packet.objectId);
-    if (!state)
-      return;
-    this.summonSkillSyncState.delete(packet.objectId);
-    if (!state.counted || state.ownerActorId === undefined || state.skillId === undefined)
-      return;
-    if (this.authoritativeSummonActors.has(state.ownerActorId))
-      return;
-    return this.applySummonDelta(state.ownerActorId, state.skillId, -1, packet, "SummonSkillSync");
-  }
-  applySummonDelta(actorId, skillId, delta, packet, rpc) {
-    const stacks = new Map(this.summonStacks.get(actorId));
-    const nextCount = Math.max(0, (stacks.get(skillId) ?? 0) + delta);
-    if (nextCount === 0)
-      stacks.delete(skillId);
-    else
-      stacks.set(skillId, nextCount);
-    if (stacks.size === 0)
-      this.summonStacks.delete(actorId);
-    else
-      this.summonStacks.set(actorId, stacks);
-    return {
-      kind: "summon",
-      rpc,
-      tick: packet.tick,
-      payloadBytes: packet.payload.length,
-      fields: decodedFieldRecord(packet),
-      actorId,
-      skillId,
-      stacks: nextCount,
-      actorIdentity: this.actorIdentityResolver?.(actorId)
-    };
-  }
-  consumeSummonCalibration(packet) {
-    const entries = decodedSummonCalibration(packet);
-    if (!entries)
-      return [];
-    this.authoritativeSummonActors.add(packet.objectId);
-    return this.applySummonSnapshot(packet.objectId, packet, entries);
-  }
-  applySummonSnapshot(actorId, packet, entries) {
-    const previous = this.summonStacks.get(actorId) ?? new Map;
-    const current = new Map;
-    for (const { skillId } of entries)
-      current.set(skillId, (current.get(skillId) ?? 0) + 1);
-    const changedSkillIds = [
-      ...current.keys(),
-      ...[...previous.keys()].filter((skillId) => !current.has(skillId))
-    ].filter((skillId) => current.get(skillId) !== previous.get(skillId));
-    if (current.size === 0)
-      this.summonStacks.delete(actorId);
-    else
-      this.summonStacks.set(actorId, current);
-    return changedSkillIds.map((skillId) => ({
-      kind: "summon",
-      rpc: "CalibrateSummons_T",
-      tick: packet.tick,
-      payloadBytes: packet.payload.length,
-      fields: decodedFieldRecord(packet),
-      actorId,
-      skillId,
-      stacks: current.get(skillId) ?? 0,
-      actorIdentity: this.actorIdentityResolver?.(actorId)
-    }));
-  }
   consumeSkill(packet) {
     const actorId = packet.objectId;
     const rpcName = packet.rpcName;
@@ -485,7 +813,7 @@ class FishNetCombatTracker {
       if (!sourceId)
         return;
       const activation2 = this.createActivation(actorId, "skill", packet.tick, sourceId, false);
-      activation2.targetId = numberField(packet, "targetId");
+      activation2.targetId = rpcName === "AutoCast_C" ? numberField(packet, "obj") : numberField(packet, "targetId");
       return {
         kind: "activation",
         rpc: rpcName,
@@ -570,6 +898,8 @@ class FishNetCombatTracker {
         actorIdentity: this.actorIdentityResolver?.(actorId)
       }];
     }
+    if (value >= 0)
+      this.recentDamageHits.set(packet.objectId, { actorId, sourceId, sourceLabel });
     const hitCode = requiredNumberField(packet, "dmg.Hit");
     const hitResult = HIT_RESULTS[hitCode] ?? hitCode;
     const targetId = packet.objectId;
@@ -669,7 +999,7 @@ class FishNetCombatTracker {
   consumeRecover(packet) {
     const targetId = packet.objectId;
     const value = requiredNumberField(packet, "amount");
-    const recoveryStyle = classifyFishNetRecoveryStyle(packet, this.semanticMap);
+    const recoveryStyle = classifyFishNetRecoveryStyle(packet);
     if (recoveryStyle === "passive-regeneration") {
       return this.createSelfRecovery(packet, value, recoveryStyle, "passive-regeneration", "Passive regeneration");
     }
@@ -677,7 +1007,7 @@ class FishNetCombatTracker {
       const source = drainRecoverySource(this.healingTraitsResolver?.(targetId));
       return this.createSelfRecovery(packet, value, recoveryStyle, source.sourceId, source.sourceLabel);
     }
-    const candidates = this.eligibleHealActivations(packet.tick, targetId, HEALING_SKILL_IDS);
+    const candidates = this.eligibleHealActivations(packet.tick, targetId, this.directHealingSkillIds);
     let attribution;
     let actorId;
     let sourceId;
@@ -688,7 +1018,7 @@ class FishNetCombatTracker {
       const [candidate] = candidates;
       if (!candidate)
         throw new Error("missing combat activation candidate");
-      attribution = candidate.inferred ? "inferred" : "exact";
+      attribution = "inferred";
       actorId = candidate.actorId;
       sourceId = candidate.sourceId;
       sourceLabel = candidate.sourceLabel;
@@ -697,8 +1027,8 @@ class FishNetCombatTracker {
       attribution = "ambiguous";
       candidateActivationIds = candidates.map(({ id }) => id);
     } else {
-      const regenSource = this.activeRegenSources.get(targetId);
-      if (regenSource?.candidateActivationIds) {
+      const regenSource = this.activeRegenSources.get(targetId) ?? this.bondRegenSources.get(targetId);
+      if (regenSource?.candidateActivationIds || regenSource?.ambiguous) {
         attribution = "ambiguous";
         candidateActivationIds = regenSource.candidateActivationIds;
       } else if (regenSource?.actorId !== undefined) {
@@ -729,6 +1059,101 @@ class FishNetCombatTracker {
       actorIdentity: actorId === undefined ? undefined : this.actorIdentityResolver?.(actorId)
     };
   }
+  consumeBarrierSync(packet) {
+    if (packet.objectId === undefined)
+      return [];
+    if (packet.packetName === "objectDespawn" || packet.packetName === "objectSpawn") {
+      this.barriers.delete(packet.objectId);
+      if (packet.packetName === "objectDespawn")
+        return [];
+    }
+    const values = barrierSyncValues(packet);
+    if (values.length === 0)
+      return [];
+    const targetId = packet.objectId;
+    const events = [];
+    for (const barrierAfter of values) {
+      if (!Number.isInteger(barrierAfter) || barrierAfter < 0)
+        continue;
+      const previous = this.barriers.get(targetId);
+      if (!previous || packet.packetName === "objectSpawn") {
+        this.barriers.set(targetId, { value: barrierAfter, statusActive: previous?.statusActive ?? false });
+        continue;
+      }
+      const barrierBefore = previous.value;
+      if (barrierAfter === barrierBefore)
+        continue;
+      let source = previous;
+      let action;
+      if (barrierAfter > barrierBefore) {
+        source = sourceFromCandidates(this.eligibleHealActivations(packet.tick, targetId, this.barrierSkillIds));
+        action = "gained";
+      } else if (this.recentDamageHits.has(targetId)) {
+        action = "absorbed";
+      } else if (barrierAfter === 0 && !previous.statusActive) {
+        action = "cleared";
+      } else {
+        action = "reduced";
+      }
+      const incoming = action === "absorbed" ? this.recentDamageHits.get(targetId) : undefined;
+      const attribution = source.candidateActivationIds ? "ambiguous" : source.actorId === undefined ? "unattributed" : "inferred";
+      events.push({
+        kind: "shield",
+        rpc: "barrierSync",
+        tick: packet.tick,
+        payloadBytes: packet.payload.length,
+        fields: { barrierSync: barrierAfter },
+        targetId,
+        actorId: source.actorId,
+        sourceId: source.sourceId,
+        sourceLabel: source.sourceLabel,
+        value: Math.abs(barrierAfter - barrierBefore),
+        barrierBefore,
+        barrierAfter,
+        action,
+        ...incoming === undefined ? {} : {
+          incomingActorId: incoming.actorId,
+          incomingSourceId: incoming.sourceId,
+          incomingSourceLabel: incoming.sourceLabel
+        },
+        attribution,
+        activationId: source.activationId,
+        candidateActivationIds: source.candidateActivationIds,
+        actorIdentity: source.actorId === undefined ? undefined : this.actorIdentityResolver?.(source.actorId)
+      });
+      this.barriers.set(targetId, {
+        ...source,
+        value: barrierAfter,
+        statusActive: barrierAfter === 0 ? false : previous.statusActive
+      });
+    }
+    return events;
+  }
+  consumeBondSync(packet) {
+    if (packet.objectId === undefined)
+      return;
+    if (packet.packetName === "objectDespawn" || packet.packetName === "objectSpawn") {
+      this.bondRegenSources.delete(packet.objectId);
+      if (packet.packetName === "objectDespawn")
+        return;
+    }
+    const entries = bondSyncEntries(packet);
+    if (!entries)
+      return;
+    const sources = entries.filter((entry) => !entry.caster && this.regenerationSkillIds.has(entry.skillId));
+    if (sources.length === 0) {
+      this.bondRegenSources.delete(packet.objectId);
+    } else if (sources.length === 1) {
+      const source = sources[0];
+      this.bondRegenSources.set(packet.objectId, {
+        actorId: source.otherId,
+        sourceId: source.skillId,
+        sourceLabel: this.skillLabels.get(source.skillId) ?? source.skillId
+      });
+    } else {
+      this.bondRegenSources.set(packet.objectId, { ambiguous: true });
+    }
+  }
   createSelfRecovery(packet, value, recoveryStyle, sourceId, sourceLabel) {
     const actorId = packet.objectId;
     return {
@@ -758,7 +1183,7 @@ class FishNetCombatTracker {
     const actorId = packet.objectId;
     if (statusId === REGEN_STATUS_ID) {
       if (packet.rpcName === "ApplyEffect_T") {
-        const candidates = this.eligibleHealActivations(packet.tick, actorId, REGEN_SKILL_IDS);
+        const candidates = this.eligibleHealActivations(packet.tick, actorId, this.regenerationSkillIds);
         if (candidates.length === 1) {
           const [candidate] = candidates;
           if (!candidate)
@@ -778,6 +1203,9 @@ class FishNetCombatTracker {
         this.activeRegenSources.delete(actorId);
       }
     }
+    if (this.barrierStatusIds.has(statusId)) {
+      this.observeBarrierStatus(actorId, packet.rpcName === "ApplyEffect_T", packet.tick);
+    }
     return {
       kind: "status",
       rpc: packet.rpcName,
@@ -791,6 +1219,15 @@ class FishNetCombatTracker {
       actorIdentity: this.actorIdentityResolver?.(actorId)
     };
   }
+  observeBarrierStatus(actorId, applied, tick) {
+    const current = this.barriers.get(actorId) ?? { value: 0, statusActive: false };
+    if (!applied) {
+      this.barriers.set(actorId, { ...current, statusActive: false });
+      return;
+    }
+    const source = sourceFromCandidates(this.eligibleHealActivations(tick, actorId, this.barrierSkillIds));
+    this.barriers.set(actorId, { ...current, ...source, statusActive: true });
+  }
   createActivation(actorId, actionKind, tick, sourceId, inferred) {
     const activation = {
       id: `activation-${this.nextActivation++}`,
@@ -800,148 +1237,35 @@ class FishNetCombatTracker {
       sourceLabel: sourceId === undefined ? undefined : this.skillLabels.get(sourceId) ?? sourceId,
       startTick: tick,
       inferred
-    };
-    this.activations.set(activation.id, activation);
-    return activation;
-  }
-  findLifecycleActivation(actorId) {
-    return [...this.activations.values()].filter((activation) => activation.actorId === actorId && activation.actionKind === "skill" && activation.endTick === undefined).sort((left, right) => left.startTick - right.startTick)[0];
-  }
-  eligibleActivations(tick, actorId) {
-    return [...this.activations.values()].filter((activation) => {
-      return activation.actorId === actorId && activation.startTick <= tick && (activation.deadlineTick === undefined || tick <= activation.deadlineTick);
-    });
-  }
-  pruneExpired(tick) {
-    const expired = [...this.activations.values()].filter((activation) => activation.deadlineTick !== undefined ? activation.deadlineTick < tick : tick - activation.startTick > this.activationMaxAgeTicks).map(({ id }) => id);
-    for (const id of expired)
-      this.activations.delete(id);
-  }
-}
-function drainRecoverySource(traits) {
-  if (traits?.hasSiphonHealth && !traits.hasHealthLeech) {
-    return { sourceId: "siphon-health", sourceLabel: "Siphon Health" };
-  }
-  if (traits?.hasHealthLeech && !traits.hasSiphonHealth) {
-    return { sourceId: "health-leech", sourceLabel: "Health Leech" };
-  }
-  return { sourceId: "siphon-health-leech", sourceLabel: "Siphon / Health Leech" };
-}
-function field(packet, name) {
-  return packet.decodedFields?.find((candidate) => candidate.name === name)?.value;
-}
-function decodedFieldRecord(packet) {
-  return Object.fromEntries(packet.decodedFields?.map(({ name, value }) => [name, value]) ?? []);
-}
-function decodedSummonCalibration(packet) {
-  if (packet.undecodedPayload && packet.undecodedPayload.length > 0)
-    return;
-  const length = numberField(packet, "data.length");
-  if (length === undefined || !Number.isInteger(length) || length < 0)
-    return;
-  const entries = [];
-  for (let index = 0;index < length; index += 1) {
-    const skillId = stringField(packet, `data[${index}].SkillId`);
-    const level = numberField(packet, `data[${index}].Level`);
-    if (skillId === undefined || level === undefined || !Number.isInteger(level) || level < 0)
-      return;
-    entries.push({ skillId, level });
-  }
-  return entries;
-}
-function decodedLoginEffects(packet) {
-  if (packet.undecodedPayload && packet.undecodedPayload.length > 0)
-    return;
-  const length = numberField(packet, "data.State.Effects.length");
-  if (length === undefined || !Number.isInteger(length) || length < 0)
-    return;
-  const entries = [];
-  for (let index = 0;index < length; index += 1) {
-    const statusId = stringField(packet, `data.State.Effects[${index}].Id`);
-    const level = numberField(packet, `data.State.Effects[${index}].Level`);
-    const duration = numberField(packet, `data.State.Effects[${index}].Duration`);
-    const stacks = numberField(packet, `data.State.Effects[${index}].Stacks`);
-    if (statusId === undefined || level === undefined || !Number.isInteger(level) || level < 0 || duration === undefined || stacks === undefined || !Number.isInteger(stacks) || stacks < 0)
-      return;
-    entries.push({
-      statusId,
-      level,
-      ...duration < 0 || !Number.isFinite(duration) ? {} : { remainingSeconds: duration },
-      stacks
+    };
+    this.activations.set(activation.id, activation);
+    return activation;
+  }
+  findLifecycleActivation(actorId) {
+    return [...this.activations.values()].filter((activation) => activation.actorId === actorId && activation.actionKind === "skill" && activation.endTick === undefined).sort((left, right) => left.startTick - right.startTick)[0];
+  }
+  eligibleActivations(tick, actorId) {
+    return [...this.activations.values()].filter((activation) => {
+      return activation.actorId === actorId && activation.startTick <= tick && (activation.deadlineTick === undefined || tick <= activation.deadlineTick);
     });
   }
-  return entries;
-}
-function matchesBehaviour(packet, expected) {
-  return packet.networkBehaviourType === undefined || packet.networkBehaviourType === expected;
-}
-function numberField(packet, name) {
-  const value = field(packet, name);
-  return typeof value === "number" ? value : undefined;
-}
-function stringField(packet, name) {
-  const value = field(packet, name);
-  return typeof value === "string" ? value : undefined;
-}
-function requiredNumberField(packet, name) {
-  const value = numberField(packet, name);
-  if (value === undefined)
-    throw new Error(`${packet.networkBehaviourType}.${packet.rpcName} is missing numeric field ${name}`);
-  return value;
-}
-function requiredBooleanField(packet, name) {
-  const value = field(packet, name);
-  if (typeof value !== "boolean")
-    throw new Error(`${packet.networkBehaviourType}.${packet.rpcName} is missing boolean field ${name}`);
-  return value;
-}
-function requiredVectorField(packet, name) {
-  const value = field(packet, name);
-  if (!Array.isArray(value))
-    throw new Error(`${packet.networkBehaviourType}.${packet.rpcName} is missing vector field ${name}`);
-  return value;
-}
-function isCompleteDamagePacket(packet, requireVectors) {
-  const numeric = [
-    "dmg.Team",
-    "dmg.Value",
-    "dmg.Type",
-    "dmg.Hit",
-    "dmg.Hits",
-    "dmg.AttackerId",
-    "dmg.Element",
-    "dmg.WeaponType",
-    "dmg.Range"
-  ];
-  return numeric.every((name) => numberField(packet, name) !== undefined) && nullableStringField(packet, "dmg.DamageSourceId") !== undefined && typeof field(packet, "dmg.IsClone") === "boolean" && typeof field(packet, "dmg.IsSummon") === "boolean" && (!requireVectors || Array.isArray(field(packet, "position")) && Array.isArray(field(packet, "origin")));
-}
-function isCompleteRecoverPacket(packet) {
-  return numberField(packet, "amount") !== undefined;
-}
-function nullableStringField(packet, name) {
-  const value = field(packet, name);
-  return typeof value === "string" || value === null ? value : undefined;
-}
-function damageSignature(tick, targetId, actorId, sourceId, value, hitCode) {
-  return `${tick}\x00${targetId}\x00${actorId}\x00${sourceId}\x00${value}\x00${hitCode}`;
+  pruneExpired(tick) {
+    const expired = [...this.activations.values()].filter((activation) => activation.deadlineTick !== undefined ? activation.deadlineTick < tick : tick - activation.startTick > this.activationMaxAgeTicks).map(({ id }) => id);
+    for (const id of expired)
+      this.activations.delete(id);
+  }
 }
-var DAMAGE_TYPE_SOURCES = new Map([
-  [4, { sourceId: "reflect", sourceLabel: "Reflect Damage" }]
-]);
-function resolveDamageSource(rawSourceId, damageType, skillLabels) {
-  if (typeof rawSourceId === "string") {
+function sourceFromCandidates(candidates) {
+  if (candidates.length === 1) {
+    const candidate = candidates[0];
     return {
-      sourceId: rawSourceId,
-      sourceLabel: skillLabels.get(rawSourceId) ?? rawSourceId
+      actorId: candidate.actorId,
+      sourceId: candidate.sourceId,
+      sourceLabel: candidate.sourceLabel,
+      activationId: candidate.id
     };
   }
-  return (rawSourceId === null ? DAMAGE_TYPE_SOURCES.get(damageType) : undefined) ?? {
-    sourceId: "unknown",
-    sourceLabel: "unknown"
-  };
-}
-function uniqueMonsterIdentityEvents(events) {
-  return events.filter((event, index) => event.operation !== "reset" || events.findIndex((candidate) => candidate.operation === "reset") === index);
+  return candidates.length > 1 ? { candidateActivationIds: candidates.map(({ id }) => id) } : {};
 }
 function tryLoadBundledSkillCatalog(buildFingerprint) {
   try {
@@ -950,9 +1274,9 @@ function tryLoadBundledSkillCatalog(buildFingerprint) {
     return;
   }
 }
-function tryLoadBundledSemanticMap(buildFingerprint) {
+function tryLoadBundledRpcMap(buildFingerprint) {
   try {
-    return loadBundledFishNetSemanticMap(buildFingerprint);
+    return loadBundledFishNetRpcMap(buildFingerprint);
   } catch {
     return;
   }
@@ -962,15 +1286,14 @@ function assertMatchingBuild(label, candidate, expected) {
     throw new Error(`${label} build ${JSON.stringify(candidate)} does not match ${JSON.stringify(expected)}`);
   }
 }
-// src/boss-catalog.ts
+// src/tracking/boss-catalog.ts
 function createBossCatalog(entries) {
   const catalog = new Map(Object.entries(entries).map(([skillId, displayName]) => [skillId, { displayName }]));
   return catalog;
 }
-var CURRENT_BOSS_SKILL_NAMES = createBossCatalog({});
-// src/actor-directory.ts
-import { characterDataParameter, decodeFieldRun, loadBundledFishNetRpcMap } from "@kar-mi/spirit-vale-tools-capture";
-import { readSignedPackedWhole as readSignedPackedWhole3 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+// src/tracking/actor-directory.ts
+import { characterDataParameter, decodeFieldRun, loadBundledFishNetRpcMap as loadBundledFishNetRpcMap2 } from "@kar-mi/spirit-vale-tools-capture";
+import { readSignedPackedWhole as readSignedPackedWhole4 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
 
 class FishNetActorDirectory {
   options;
@@ -981,6 +1304,8 @@ class FishNetActorDirectory {
   sourceRevisions = new Map;
   observedPlayerActors = new Set;
   uidIdentities = new Map;
+  nonPlayerActorIds = new Set;
+  clearedOnDespawn = new Set;
   nextSourceRevision = 1;
   localIdentity;
   constructor(options = {}) {
@@ -999,6 +1324,9 @@ class FishNetActorDirectory {
       this.clear();
       return [{ kind: "actorIdentity", operation: "reset", tick: packet.tick }];
     }
+    if (this.options.stickyPlayerIdentities && packet.objectId !== undefined && (hasMonsterIdentityEvidence(packet) || hasSummonIdentityEvidence(packet))) {
+      this.nonPlayerActorIds.add(packet.objectId);
+    }
     if (packet.packetName === "objectSpawn" && packet.objectId !== undefined) {
       const observedPlayerActor = this.observedPlayerActors.has(packet.objectId);
       const events = this.removeObject(packet.objectId, packet.tick, true);
@@ -1012,7 +1340,7 @@ class FishNetActorDirectory {
       });
       if (ownerConnectionId !== undefined)
         this.addOwnerObject(ownerConnectionId, packet.objectId);
-      if (hasMonsterIdentityEvidence(packet)) {
+      if (hasMonsterIdentityEvidence(packet) || this.isStickyNonPlayer(packet)) {
         events.push(...this.clearPlayerIdentity(packet.objectId, packet.tick));
         events.push(...this.refreshOwner(ownerConnectionId, packet.tick, true));
         return events;
@@ -1036,7 +1364,12 @@ class FishNetActorDirectory {
       return events;
     }
     if (packet.packetName === "objectDespawn" && packet.objectId !== undefined) {
-      return this.removeObject(packet.objectId, packet.tick, true);
+      const events = this.removeObject(packet.objectId, packet.tick, true);
+      if (this.nonPlayerActorIds.delete(packet.objectId)) {
+        this.clearedOnDespawn.add(packet.objectId);
+        events.push(...this.reconcile(packet.objectId, undefined, packet.tick));
+      }
+      return events;
     }
     if (packet.packetName === "ownershipChange" && packet.objectId !== undefined) {
       return this.changeOwner(packet.objectId, validOwner(packet.ownerConnectionId), packet.tick);
@@ -1049,7 +1382,7 @@ class FishNetActorDirectory {
         ...this.localIdentity.archetype === undefined ? {} : { archetype: this.localIdentity.archetype }
       }, packet.tick);
     }
-    if (packet.objectId !== undefined && hasMonsterIdentityEvidence(packet)) {
+    if (packet.objectId !== undefined && (hasMonsterIdentityEvidence(packet) || this.isStickyNonPlayer(packet))) {
       return this.clearPlayerIdentity(packet.objectId, packet.tick);
     }
     if (packet.objectId !== undefined && packet.rpcName !== undefined && CHARACTER_RPC_NAMES.has(packet.rpcName)) {
@@ -1096,6 +1429,8 @@ class FishNetActorDirectory {
     return identity ? { ...identity } : undefined;
   }
   getAttribution(actorId) {
+    if (this.clearedOnDespawn.has(actorId))
+      return;
     const direct = this.identities.get(actorId);
     if (direct)
       return { ...direct };
@@ -1118,7 +1453,7 @@ class FishNetActorDirectory {
     return best ? { ...best, ownerConnectionId } : undefined;
   }
   snapshot() {
-    return [...this.identities.values()].map((identity) => ({ ...identity }));
+    return [...this.identities.values()].filter((identity) => !this.clearedOnDespawn.has(identity.actorId)).map((identity) => ({ ...identity }));
   }
   observePlayerActor(actorId, tick) {
     if (!Number.isInteger(actorId) || actorId < 0)
@@ -1204,6 +1539,9 @@ class FishNetActorDirectory {
     events.push(...this.refreshOwner(ownerConnectionId, tick, retainIdentity));
     return events;
   }
+  isStickyNonPlayer(packet) {
+    return this.options.stickyPlayerIdentities === true && hasSummonIdentityEvidence(packet);
+  }
   clearPlayerIdentity(actorId, tick) {
     this.observedPlayerActors.delete(actorId);
     this.identitySources.delete(actorId);
@@ -1280,6 +1618,7 @@ class FishNetActorDirectory {
     }
     if (current?.displayName === next.displayName && current.archetype === next.archetype && current.ownerConnectionId === next.ownerConnectionId && current.uid === next.uid)
       return [];
+    this.clearedOnDespawn.delete(actorId);
     this.identities.set(actorId, next);
     return [{ kind: "actorIdentity", operation: "upsert", tick, ...next }];
   }
@@ -1303,6 +1642,8 @@ class FishNetActorDirectory {
     this.identitySources.clear();
     this.sourceRevisions.clear();
     this.observedPlayerActors.clear();
+    this.nonPlayerActorIds.clear();
+    this.clearedOnDespawn.clear();
     this.nextSourceRevision = 1;
   }
 }
@@ -1334,8 +1675,16 @@ function hasMonsterIdentityEvidence(packet) {
   const mobId = decodedField(packet, "Data.Id") ?? decodedField(packet, "Monster.Id") ?? decodedField(packet, "Id");
   return typeof mobId === "string" && mobId.length > 0;
 }
+function hasSummonIdentityEvidence(packet) {
+  if (packet.packetName === "objectSpawn") {
+    return packet.spawnSyncEntries?.some((candidate) => candidate.networkBehaviourType === "SummoningComponent" && candidate.name === "SummonerSync") ?? false;
+  }
+  if (packet.packetName !== "syncType" || packet.networkBehaviourType !== "SummoningComponent")
+    return false;
+  return packet.decodedFields?.some((field2) => field2.name === "SummonerSync") ?? false;
+}
 var VISUAL_DATA_SYNC_INDEX = 5;
-var PLAYER_PREFAB_KEYS = new Set((loadBundledFishNetRpcMap().prefabs ?? []).filter(({ components }) => components.some(({ typeName }) => typeName === "PlayerController")).map(({ collectionId, prefabId }) => `${collectionId}:${prefabId}`));
+var PLAYER_PREFAB_KEYS = new Set((loadBundledFishNetRpcMap2().prefabs ?? []).filter(({ components }) => components.some(({ typeName }) => typeName === "PlayerController")).map(({ collectionId, prefabId }) => `${collectionId}:${prefabId}`));
 function decodeSpawnIdentity(packet) {
   if (!hasPlayerControllerEvidence(packet))
     return;
@@ -1374,7 +1723,7 @@ function decodeCharacterDataName(payload) {
     try {
       let offset = 0;
       if (skipEnum)
-        offset = readSignedPackedWhole3(payload, offset).nextOffset;
+        offset = readSignedPackedWhole4(payload, offset).nextOffset;
       const run = decodeFieldRun(payload, [characterNameParameter()], offset);
       const values = new Map(run.fields.map((field2) => [field2.name, field2.value]));
       const uid = values.get("data.UID");
@@ -1398,7 +1747,7 @@ function characterNameParameter() {
   cachedCharacterNameParameter = { ...full, fields: fields.slice(0, nameIndex + 1) };
   return cachedCharacterNameParameter;
 }
-// src/status-tracker.ts
+// src/tracking/status-tracker.ts
 import {
   FishNetStatusDirectory,
   loadBundledStatusCatalog,
@@ -1778,21 +2127,24 @@ function recordHit(actor, hit, maxTimelineBuckets) {
   if (hit.critical)
     skill.criticalHits += 1;
 }
+function foldEnemySkill(byEnemy, enemyId, sourceId, sourceLabel, value, critical) {
+  const bySkill = byEnemy.get(enemyId) ?? new Map;
+  byEnemy.set(enemyId, bySkill);
+  const stats = bySkill.get(sourceId) ?? { sourceLabel, damage: 0, hits: 0, criticalHits: 0 };
+  stats.sourceLabel = sourceLabel;
+  stats.damage += value;
+  stats.hits += 1;
+  if (critical)
+    stats.criticalHits += 1;
+  bySkill.set(sourceId, stats);
+}
 function positiveTau(value) {
   if (!Number.isFinite(value) || value <= 0)
     throw new Error("currentTauSeconds must be a positive finite number");
   return value;
 }
 function recordEnemyHit(encounter, actor, event, observedAtMs, mobIdentities) {
-  const bySkill = actor.enemySkills.get(event.targetId) ?? new Map;
-  actor.enemySkills.set(event.targetId, bySkill);
-  const stats = bySkill.get(event.sourceId) ?? { sourceLabel: event.sourceLabel, damage: 0, hits: 0, criticalHits: 0 };
-  stats.sourceLabel = event.sourceLabel;
-  stats.damage += event.value;
-  stats.hits += 1;
-  if (event.hitResult === "critical")
-    stats.criticalHits += 1;
-  bySkill.set(event.sourceId, stats);
+  foldEnemySkill(actor.enemySkills, event.targetId, event.sourceId, event.sourceLabel, event.value, event.hitResult === "critical");
   if (!encounter.enemyFirstSeenAtMs.has(event.targetId)) {
     encounter.enemyFirstSeenAtMs.set(event.targetId, observedAtMs);
   }
@@ -1813,6 +2165,9 @@ function createActor(actorId, encounterStartedAtMs, currentRate = DEFAULT_CURREN
     criticalHits: 0,
     kills: 0,
     skills: new Map,
+    absorbed: 0,
+    absorbedSkills: new Map,
+    absorbedByEnemy: new Map,
     encounterSeries: createSeries(encounterStartedAtMs, ANALYSIS_BUCKET_MS),
     actorSeries: createSeries(encounterStartedAtMs, ANALYSIS_BUCKET_MS),
     currentRate: typeof currentRate === "number" ? new EwmaRate({ tauSeconds: currentRate }) : currentRate
@@ -1846,6 +2201,7 @@ function renderEncounter(encounter, options = {}) {
   const durationMs = Math.max(minimumDurationMs, encounter.lastDamageAtMs - encounter.startedAtMs);
   const mergedActors = mergeActors(encounter.actors);
   const totalDamage = mergedActors.reduce((sum, actor) => sum + actor.damage, 0);
+  const totalAbsorbed = mergedActors.reduce((sum, actor) => sum + actor.absorbed, 0);
   const rowForActor = (actor, rowId) => actorRow(actor, rowId, encounter.startedAtMs, durationMs, totalDamage, snapshotNowMs, minimumDurationMs, actor.displayName === undefined, "encounter");
   const displayed = visibleDisplayGroups(mergedActors, encounter, {
     snapshotNowMs,
@@ -1870,6 +2226,7 @@ function renderEncounter(encounter, options = {}) {
     ...encounter.endedAtMs === undefined ? {} : { endedAtMs: encounter.endedAtMs },
     durationMs,
     totalDamage,
+    ...totalAbsorbed <= 0 ? {} : { totalAbsorbed },
     partyDps: perSecond(totalDamage, durationMs),
     partyCurrentDps,
     actors,
@@ -1887,6 +2244,12 @@ function actorRow(actor, rowId, startedAtMs, durationMs, partyDamage, nowMs, min
     ...skill.hits === 0 ? {} : { critRate: skill.criticalHits / skill.hits }
   })).sort(compareRows);
   const series = alignment === "actor" ? actor.actorSeries : actor.encounterSeries;
+  const absorbedSkills = actor.absorbed <= 0 ? undefined : [...actor.absorbedSkills.values()].map((skill) => ({
+    ...skill,
+    dps: perSecond(skill.damage, durationMs),
+    contribution: skill.damage / actor.absorbed,
+    ...skill.hits === 0 ? {} : { critRate: skill.criticalHits / skill.hits }
+  })).sort(compareRows);
   return {
     rowId,
     actorIds: [...actor.actorIds],
@@ -1895,6 +2258,8 @@ function actorRow(actor, rowId, startedAtMs, durationMs, partyDamage, nowMs, min
     durationMs,
     ...actor.lastDamageAtMs === undefined ? {} : { lastDamageAtMs: actor.lastDamageAtMs },
     damage: actor.damage,
+    ...actor.absorbed <= 0 ? {} : { absorbed: actor.absorbed },
+    ...absorbedSkills === undefined || absorbedSkills.length === 0 ? {} : { absorbedSkills },
     dps: perSecond(actor.damage, durationMs),
     currentDps: actor.currentRate.rateAt(nowMs, { fromMs: startedAtMs, minimumMs: minimumDurationMs }),
     contribution: partyDamage === 0 ? 0 : actor.damage / partyDamage,
@@ -1932,7 +2297,7 @@ function actorRowId(actor) {
 function mergeActors(actors) {
   const merged = new Map;
   for (const actor of actors) {
-    if (actor.damage <= 0)
+    if (actor.damage <= 0 && actor.absorbed <= 0)
       continue;
     const displayName = actor.displayName?.trim() || undefined;
     const key = actorRowId(actor);
@@ -2004,6 +2369,21 @@ function accumulate(target, actor) {
       target.skills.set(skill.sourceId, { ...skill });
     }
   }
+  target.absorbed += actor.absorbed;
+  for (const skill of actor.absorbedSkills.values()) {
+    const current = target.absorbedSkills.get(skill.sourceId);
+    if (current) {
+      current.sourceLabel = skill.sourceLabel;
+      current.damage += skill.damage;
+      current.hits += skill.hits;
+      current.criticalHits += skill.criticalHits;
+    } else {
+      target.absorbedSkills.set(skill.sourceId, { ...skill });
+    }
+  }
+  for (const [enemyId, value] of actor.absorbedByEnemy) {
+    target.absorbedByEnemy.set(enemyId, (target.absorbedByEnemy.get(enemyId) ?? 0) + value);
+  }
 }
 function rebase(series, originMs) {
   const shift = Math.round((series.originMs - originMs) / series.widthMs);
@@ -2038,7 +2418,7 @@ function maxDefined(left, right) {
   return Math.max(left, right);
 }
 
-// src/status-tracker.ts
+// src/tracking/status-tracker.ts
 var REFRESHING_FEEDS = new Set(["ApplyEffectDisplays_O", "ApplySkillDisplay_O"]);
 var EXPIRY_REFRESH_TOLERANCE_MS = 2000;
 var KEEP_ALIVE_GRACE_MS = 1000;
@@ -2286,31 +2666,24 @@ class FishNetStatusTracker {
 function sameTracked(previous, next) {
   return previous !== undefined && previous.level === next.level && previous.appliedAtMs === next.appliedAtMs && previous.expiresAtMs === next.expiresAtMs && previous.stacks === next.stacks && previous.summon === next.summon;
 }
-// src/replay.ts
-import { isRecord, isLogStreamHeader, parseLogRecord } from "@kar-mi/spirit-vale-tools-logging";
+// src/replay/replay.ts
+import { isRecord, LogRecordLineDecoder, readTextLines } from "@kar-mi/spirit-vale-tools-logging";
 async function loadDpsReplay(path, personalName = "") {
   const finished = [];
   const reducer = new DamageReducer({ onEncounterFinished: (encounter) => finished.push(encounter) });
   let invalidLines = 0;
   let recordedAtOriginMs;
   let lastTime = 0;
-  for await (const line of readLines(Bun.file(path).stream())) {
-    if (!line.trim())
-      continue;
-    let candidate;
-    try {
-      candidate = JSON.parse(line);
-    } catch {
-      invalidLines += 1;
+  const records = new LogRecordLineDecoder;
+  for await (const line of readTextLines(Bun.file(path).stream())) {
+    const decoded = records.decode(line);
+    if (decoded.kind === "empty" || decoded.kind === "header")
       continue;
-    }
-    if (isLogStreamHeader(candidate))
-      continue;
-    const record = parseLogRecord(candidate);
-    if (!record) {
+    if (decoded.kind === "invalid") {
       invalidLines += 1;
       continue;
     }
+    const record = decoded.record;
     const event = parseDpsLogRecord(record.type, record.data);
     if (event === null)
       continue;
@@ -2330,36 +2703,6 @@ async function loadDpsReplay(path, personalName = "") {
   const snapshots = finished.map((encounter) => renderEncounter(encounter, { personalName }));
   return { snapshots, invalidLines };
 }
-async function* readLines(stream) {
-  const reader = stream.getReader();
-  let decoder;
-  let pending = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      if (!decoder)
-        decoder = decoderFor(value);
-      pending += decoder.decode(value, { stream: true });
-      const lines = pending.split(/\r?\n/);
-      pending = lines.pop() ?? "";
-      yield* lines;
-    }
-    pending += decoder?.decode() ?? "";
-    if (pending)
-      yield pending;
-  } finally {
-    reader.releaseLock();
-  }
-}
-function decoderFor(firstChunk) {
-  if (firstChunk[0] === 255 && firstChunk[1] === 254)
-    return new TextDecoder("utf-16le");
-  if (firstChunk[0] === 254 && firstChunk[1] === 255)
-    return new TextDecoder("utf-16be");
-  return new TextDecoder("utf-8");
-}
 function parseDpsLogEvent(value) {
   if (!isRecord(value) || !isFiniteNumber(value["tick"]) || typeof value["kind"] !== "string")
     return;
@@ -2402,10 +2745,17 @@ function parseDpsLogEvent(value) {
   if (value["kind"] === "heal") {
     if (!isFiniteNumber(value["targetId"]) || !isFiniteNumber(value["value"]))
       return;
+    if (value["attribution"] !== undefined && value["attribution"] !== "exact" && value["attribution"] !== "inferred" && value["attribution"] !== "ambiguous" && value["attribution"] !== "unattributed")
+      return;
     if (value["recoveryStyle"] !== undefined && value["recoveryStyle"] !== "standard" && value["recoveryStyle"] !== "passive-regeneration" && value["recoveryStyle"] !== "drain" && value["recoveryStyle"] !== "unknown")
       return;
     return value;
   }
+  if (value["kind"] === "shield") {
+    if (!isFiniteNumber(value["targetId"]) || !isFiniteNumber(value["value"]) || !isFiniteNumber(value["barrierBefore"]) || !isFiniteNumber(value["barrierAfter"]) || value["action"] !== "gained" && value["action"] !== "absorbed" && value["action"] !== "cleared" && value["action"] !== "reduced" || value["attribution"] !== "exact" && value["attribution"] !== "inferred" && value["attribution"] !== "ambiguous" && value["attribution"] !== "unattributed")
+      return;
+    return value;
+  }
   if (value["kind"] !== "damage" && value["kind"] !== "death" || !isFiniteNumber(value["actorId"]) || !isFiniteNumber(value["value"]) || !isFiniteNumber(value["team"]) || typeof value["sourceId"] !== "string" || typeof value["sourceLabel"] !== "string")
     return;
   if (value["kind"] === "death" && typeof value["duplicatesDamageEvent"] !== "boolean")
@@ -2427,9 +2777,9 @@ function parseDpsLogRecord(type, data) {
 function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
-// src/replay-capture.ts
-import { FishNetSessionDecoder, loadBundledFishNetRpcMap as loadBundledFishNetRpcMap2, decodeLiteNetLibDatagram } from "@kar-mi/spirit-vale-tools-capture";
-import { isLogStreamHeader as isLogStreamHeader2, parseLogRecord as parseLogRecord2 } from "@kar-mi/spirit-vale-tools-logging";
+// src/replay/replay-capture.ts
+import { FishNetTransportReplay } from "@kar-mi/spirit-vale-tools-capture";
+import { LogRecordLineDecoder as LogRecordLineDecoder2, readTextLines as readTextLines2 } from "@kar-mi/spirit-vale-tools-logging";
 function decodeCombatCaptureJsonLines(text, options) {
   const replay = new CombatCaptureReplay(options);
   for (const line of text.split(/\r?\n/))
@@ -2442,7 +2792,7 @@ async function replayCombatCapture(path, options) {
 async function replayCombatCaptures(paths, options) {
   const replay = new CombatCaptureReplay(options);
   for (const path of paths) {
-    for await (const line of readLines2(Bun.file(path).stream()))
+    for await (const line of readTextLines2(Bun.file(path).stream()))
       replay.consumeLine(line);
   }
   return replay.result();
@@ -2450,120 +2800,48 @@ async function replayCombatCaptures(paths, options) {
 
 class CombatCaptureReplay {
   options;
-  session = new FishNetSessionDecoder(loadBundledFishNetRpcMap2());
-  datagrams = 0;
+  records = new LogRecordLineDecoder2;
+  transport = new FishNetTransportReplay;
   combatEvents = 0;
   identityEvents = 0;
   invalidLines = 0;
-  decodeWarnings = 0;
   constructor(options) {
     this.options = options;
   }
   consumeLine(line) {
-    if (!line.trim())
-      return;
-    let record;
-    try {
-      const value = JSON.parse(line);
-      if (isLogStreamHeader2(value))
-        return;
-      record = parseLogRecord2(value);
-    } catch {
-      record = undefined;
-    }
-    if (!record) {
-      this.invalidLines += 1;
-      return;
-    }
-    if (record.type !== "transport.packet")
+    const decoded = this.records.decode(line);
+    if (decoded.kind === "empty" || decoded.kind === "header")
       return;
-    const packet = parseUdpRecord(record.data);
-    if (!packet) {
+    if (decoded.kind === "invalid") {
       this.invalidLines += 1;
       return;
     }
-    this.datagrams += 1;
-    const observedAtMs = Date.parse(record.recordedAt);
-    const source = `${packet.sourceIP}:${packet.sourcePort}`;
-    const destination = `${packet.destinationIP}:${packet.destinationPort}`;
-    const endpoints = [source, destination].sort();
-    const connectionBase = `${endpoints[0]}<->${endpoints[1]}`;
-    const direction = source === endpoints[0] ? "a-to-b" : "b-to-a";
-    try {
-      for (const decoded of decodeLiteNetLibDatagram(Buffer.from(packet.payloadHex, "hex"))) {
-        const packet2 = decoded.packet;
-        const connectionId = `${connectionBase}#${packet2.connectionNumber}`;
-        if (packet2.property === "connectRequest" || packet2.property === "connectAccept" || packet2.property === "disconnect") {
-          this.session.reset(connectionId);
-          continue;
-        }
-        if (packet2.property !== "unreliable" && packet2.property !== "channeled" || packet2.payload.length < 6)
-          continue;
-        const fishNetPackets = this.session.decode(packet2.payload, {
-          reliable: packet2.property === "channeled",
-          connectionId,
-          direction,
-          channel: packet2.property === "channeled" ? packet2.channel : 1,
-          sequence: packet2.property === "channeled" ? packet2.sequence : undefined
-        });
-        for (const fishNetPacket of fishNetPackets) {
-          for (const event of this.options.directory.consume(fishNetPacket)) {
-            this.identityEvents += 1;
-            if (Number.isFinite(observedAtMs))
-              this.options.onEvent?.(event, observedAtMs);
-          }
-          for (const event of this.options.tracker.consume(fishNetPacket)) {
-            this.combatEvents += 1;
-            if (Number.isFinite(observedAtMs))
-              this.options.onEvent?.(event, observedAtMs);
-          }
-        }
+    const result = this.transport.consumeRecord(decoded.record, (packet, observedAtMs) => {
+      for (const event of this.options.directory.consume(packet)) {
+        this.identityEvents += 1;
+        if (observedAtMs !== undefined)
+          this.options.onEvent?.(event, observedAtMs);
       }
-    } catch {
-      this.decodeWarnings += 1;
-    }
+      for (const event of this.options.tracker.consume(packet)) {
+        this.combatEvents += 1;
+        if (observedAtMs !== undefined)
+          this.options.onEvent?.(event, observedAtMs);
+      }
+    });
+    if (result === "invalid")
+      this.invalidLines += 1;
   }
   result() {
     return {
-      datagrams: this.datagrams,
+      ...this.transport.stats(),
       combatEvents: this.combatEvents,
       identityEvents: this.identityEvents,
-      invalidLines: this.invalidLines,
-      decodeWarnings: this.decodeWarnings
+      invalidLines: this.invalidLines
     };
   }
 }
-function parseUdpRecord(data) {
-  if (data["protocol"] !== "udp" || typeof data["sourceIP"] !== "string" || typeof data["destinationIP"] !== "string" || !isPort(data["sourcePort"]) || !isPort(data["destinationPort"]) || typeof data["payloadHex"] !== "string" || !/^(?:[0-9a-fA-F]{2})*$/.test(data["payloadHex"]))
-    return;
-  return data;
-}
-function isPort(value) {
-  return Number.isInteger(value) && value >= 0 && value <= 65535;
-}
-async function* readLines2(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  let pending = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      pending += decoder.decode(value, { stream: true });
-      const lines = pending.split(/\r?\n/);
-      pending = lines.pop() ?? "";
-      yield* lines;
-    }
-    pending += decoder.decode();
-    if (pending)
-      yield pending;
-  } finally {
-    reader.releaseLock();
-  }
-}
-// src/replay-summary.ts
-import { compact, count, warnings } from "@kar-mi/spirit-vale-tools-capture";
+// src/replay/replay-summary.ts
+import { compact, count, warnings } from "@kar-mi/spirit-vale-tools-logging";
 async function readCombatReplaySummary(path) {
   const replay = await loadDpsReplay(path);
   const encounters = replay.snapshots;
@@ -2589,7 +2867,7 @@ function duration(milliseconds) {
   return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
 }
 // src/history/domain.ts
-var COMBAT_DOMAIN_VERSION = 7;
+var COMBAT_DOMAIN_VERSION = 8;
 var COMBAT_DOMAIN_NAME = "combat";
 var SCHEMA = `
 create table if not exists combat_encounters (
@@ -2642,6 +2920,8 @@ create table if not exists combat_actors (
   hits integer not null default 0,
   critical_hits integer not null default 0,
   kills integer not null default 0,
+  -- Tanked meter only: damage a shield on this actor soaked, kept apart from the damage column (raw damage taken).
+  absorbed integer not null default 0,
   -- The current-DPS rate estimator: its accumulated rate and the time that rate was last advanced
   -- to. Needed so a pass that resumes mid-encounter reports the same currentDps as one that never
   -- stopped. Two numbers, where a trailing window of recent hits used to be serialised here.
@@ -2691,11 +2971,13 @@ create table if not exists combat_timeline_buckets (
   primary key (session_id, encounter_id, meter, actor_index, origin, bucket_index)
 );
 
--- Per rendered DPS actor lifetime, per enemy, per skill. The actor index prevents a reused network
--- actor id from assigning the same hit to two rows that are actually different players.
+-- Per rendered actor lifetime, per enemy, per skill. The meter column is 'dps' (outgoing party
+-- damage by enemy skill) or 'tanked' (incoming damage by enemy skill). The actor index prevents a
+-- reused network actor id from assigning the same hit to two rows that are actually different players.
 create table if not exists combat_enemy_skills (
   session_id text not null,
   encounter_id text not null,
+  meter text not null default 'dps',
   actor_index integer not null,
   target_id integer not null,
   source_id text not null,
@@ -2703,7 +2985,7 @@ create table if not exists combat_enemy_skills (
   damage integer not null default 0,
   hits integer not null default 0,
   critical_hits integer not null default 0,
-  primary key (session_id, encounter_id, actor_index, target_id, source_id)
+  primary key (session_id, encounter_id, meter, actor_index, target_id, source_id)
 );
 
 create table if not exists combat_enemies (
@@ -2816,15 +3098,15 @@ class MeterReducer {
       actor.archetype = event.archetype;
     actor.activeIdentity = true;
   }
-  consumeCombat(event, observedAtMs, identities) {
+  consumeCombat(event, observedAtMs, identities, mobIdentities) {
     if (!this.current)
       return;
     const hit = this.kind === "tanked" ? tankedHit(event, identities) : healingHit(event, identities);
     if (!hit)
       return;
-    this.apply(hit, observedAtMs);
+    this.apply(hit, observedAtMs, mobIdentities);
   }
-  apply(hit, observedAtMs) {
+  apply(hit, observedAtMs, mobIdentities) {
     const encounter = this.current;
     encounter.lastDamageAtMs = Math.max(encounter.lastDamageAtMs, observedAtMs);
     let actor = encounter.activeActors.get(hit.actorId);
@@ -2839,12 +3121,39 @@ class MeterReducer {
         actor.archetype = hit.identity.archetype;
       actor.activeIdentity = true;
     }
+    if (hit.channel === "absorbed") {
+      recordAbsorbed(actor, hit);
+      return;
+    }
     recordHit(actor, { ...hit, atMs: observedAtMs }, this.maxTimelineBuckets);
     if (hit.counterpartId !== undefined)
       actor.targetIds.add(hit.counterpartId);
+    if (this.kind === "tanked" && hit.counterpartId !== undefined) {
+      const enemyId = hit.counterpartId;
+      actor.targetDamage.set(enemyId, (actor.targetDamage.get(enemyId) ?? 0) + hit.value);
+      foldEnemySkill(actor.enemySkills, enemyId, hit.sourceId, hit.sourceLabel, hit.value, hit.critical);
+      if (!encounter.enemyFirstSeenAtMs.has(enemyId))
+        encounter.enemyFirstSeenAtMs.set(enemyId, observedAtMs);
+      const name = mobIdentities?.get(enemyId);
+      if (name !== undefined)
+        encounter.enemyNames.set(enemyId, name);
+    }
+  }
+}
+function recordAbsorbed(actor, hit) {
+  actor.absorbed += hit.value;
+  const skill = actor.absorbedSkills.get(hit.sourceId) ?? { sourceId: hit.sourceId, sourceLabel: hit.sourceLabel, damage: 0, hits: 0, criticalHits: 0 };
+  skill.sourceLabel = hit.sourceLabel;
+  skill.damage += hit.value;
+  skill.hits += 1;
+  actor.absorbedSkills.set(hit.sourceId, skill);
+  if (hit.counterpartId !== undefined) {
+    actor.absorbedByEnemy.set(hit.counterpartId, (actor.absorbedByEnemy.get(hit.counterpartId) ?? 0) + hit.value);
   }
 }
 function tankedHit(event, identities) {
+  if (event.kind === "shield")
+    return shieldAbsorbedHit(event, identities);
   if (event.kind !== "damage" && event.kind !== "death")
     return;
   const identity = identities.get(event.targetId);
@@ -2865,11 +3174,15 @@ function tankedHit(event, identities) {
   };
 }
 function healingHit(event, identities) {
+  if (event.kind === "shield")
+    return shieldAppliedHit(event, identities);
   if (event.kind !== "heal")
     return;
   if (!Number.isFinite(event.value) || event.value <= 0)
     return;
-  const healerId = event.actorId ?? event.targetId;
+  const healerId = event.actorId;
+  if (healerId === undefined)
+    return;
   const identity = identities.get(healerId);
   if (!identity)
     return;
@@ -2883,31 +3196,113 @@ function healingHit(event, identities) {
     critical: false
   };
 }
+function shieldAppliedHit(event, identities) {
+  if (event.kind !== "shield" || event.action !== "gained")
+    return;
+  if (!Number.isFinite(event.value) || event.value <= 0)
+    return;
+  const casterId = event.actorId;
+  if (casterId === undefined)
+    return;
+  const identity = identities.get(casterId);
+  if (!identity)
+    return;
+  return {
+    actorId: casterId,
+    identity,
+    counterpartId: event.targetId,
+    value: event.value,
+    sourceId: event.sourceId ?? "shield",
+    sourceLabel: event.sourceLabel ?? "Shield",
+    critical: false
+  };
+}
+function shieldAbsorbedHit(event, identities) {
+  if (event.kind !== "shield" || event.action !== "absorbed")
+    return;
+  if (!Number.isFinite(event.value) || event.value <= 0)
+    return;
+  const identity = identities.get(event.targetId);
+  if (!identity)
+    return;
+  return {
+    actorId: event.targetId,
+    identity,
+    ...event.incomingActorId === undefined ? {} : { counterpartId: event.incomingActorId },
+    value: event.value,
+    sourceId: event.incomingSourceId ?? "absorbed:unknown",
+    sourceLabel: event.incomingSourceLabel ?? "Absorbed (unattributed)",
+    critical: false,
+    channel: "absorbed"
+  };
+}
+
+// src/reducers/meter-group.ts
+class MeterReducerGroup {
+  reducers;
+  constructor(options = {}) {
+    const shared = {
+      ...options.currentTauSeconds === undefined ? {} : { currentTauSeconds: options.currentTauSeconds },
+      ...options.maxTimelineBuckets === undefined ? {} : { maxTimelineBuckets: options.maxTimelineBuckets }
+    };
+    this.reducers = {
+      tanked: new MeterReducer({ kind: "tanked", ...shared }),
+      healing: new MeterReducer({ kind: "healing", ...shared })
+    };
+  }
+  current(kind) {
+    return this.reducers[kind].current;
+  }
+  consumeIdentity(event) {
+    for (const reducer of Object.values(this.reducers))
+      reducer.consumeIdentity(event);
+  }
+  consumeCombat(encounter, event, observedAtMs, identities, mobIdentities) {
+    if (!encounter)
+      return;
+    for (const reducer of Object.values(this.reducers)) {
+      if (reducer.current?.id !== encounter.id)
+        reducer.begin(encounter.id, encounter.startedAtMs);
+      reducer.consumeCombat(event, observedAtMs, identities, mobIdentities);
+    }
+  }
+  resume(kind, encounter) {
+    this.reducers[kind].resume(encounter);
+  }
+  snapshot() {
+    const result = new Map;
+    for (const kind of ["tanked", "healing"]) {
+      const current = this.reducers[kind].current;
+      if (current)
+        result.set(kind, current);
+    }
+    return result;
+  }
+  finish(endedAtMs) {
+    const result = this.snapshot();
+    for (const reducer of Object.values(this.reducers))
+      reducer.finish(endedAtMs);
+    return result;
+  }
+  reset() {
+    for (const reducer of Object.values(this.reducers))
+      reducer.reset();
+  }
+}
 
 // src/history/importer.ts
-var METER_KINDS = [
-  { meter: "tanked", kind: "tanked" },
-  { meter: "healing", kind: "healing" }
-];
+var ABSORBED_METER = "absorbed";
 async function indexCombatStream(model, options) {
   const { sessionId, sourcePath } = options;
   const finished = [];
   let currentSequence = 0;
   let lastObservedAtMs = 0;
-  const meters = METER_KINDS.map(({ meter, kind }) => ({
-    meter,
-    reducer: new MeterReducer({
-      kind,
-      ...options.currentTauSeconds === undefined ? {} : { currentTauSeconds: options.currentTauSeconds }
-    })
-  }));
+  const meters = new MeterReducerGroup({
+    ...options.currentTauSeconds === undefined ? {} : { currentTauSeconds: options.currentTauSeconds }
+  });
   const meterAggregates = new Map;
   const captureMeters = (encounterId) => {
-    const byMeter = meterAggregates.get(encounterId) ?? new Map;
-    for (const entry of meters) {
-      if (entry.reducer.current)
-        byMeter.set(entry.meter, entry.reducer.current);
-    }
+    const byMeter = new Map(meters.snapshot());
     if (byMeter.size > 0)
       meterAggregates.set(encounterId, byMeter);
   };
@@ -2917,8 +3312,7 @@ async function indexCombatStream(model, options) {
     createEncounterId: () => `enc-${currentSequence}`,
     onEncounterFinished: (encounter) => {
       captureMeters(encounter.id);
-      for (const entry of meters)
-        entry.reducer.finish(encounter.endedAtMs ?? encounter.lastDamageAtMs);
+      meters.finish(encounter.endedAtMs ?? encounter.lastDamageAtMs);
       finished.push(encounter);
     }
   });
@@ -2926,9 +3320,8 @@ async function indexCombatStream(model, options) {
   const open = loadOpenEncounter(model, sessionId);
   if (open) {
     reducer.resume(open);
-    for (const entry of meters) {
-      entry.reducer.resume(loadMeterAggregate(model, sessionId, open, entry.meter));
-    }
+    meters.resume("tanked", loadMeterAggregate(model, sessionId, open, "tanked"));
+    meters.resume("healing", loadMeterAggregate(model, sessionId, open, "healing"));
   }
   const request = {
     sessionId,
@@ -2964,8 +3357,7 @@ async function indexCombatStream(model, options) {
       reducer.identities.clear();
       reducer.mobIdentities.clear();
       reducer.recentHits.clear();
-      for (const entry of meters)
-        entry.reducer.reset();
+      meters.reset();
       meterAggregates.clear();
       finished.length = 0;
     }
@@ -3008,23 +3400,15 @@ function consume(reducer, meters, record, note) {
   note(record.sequence, observedAtMs);
   if (event.kind === "actorIdentity") {
     reducer.consumeIdentity(event, observedAtMs);
-    for (const entry of meters)
-      entry.reducer.consumeIdentity(event);
+    meters.consumeIdentity(event);
     return;
   }
   reducer.consumeCombat(event, observedAtMs);
-  const encounter = reducer.current;
-  if (!encounter)
-    return;
-  for (const entry of meters) {
-    if (entry.reducer.current?.id !== encounter.id)
-      entry.reducer.begin(encounter.id, encounter.startedAtMs);
-    entry.reducer.consumeCombat(event, observedAtMs, reducer.identities);
-  }
+  meters.consumeCombat(reducer.current, event, observedAtMs, reducer.identities, reducer.mobIdentities);
 }
 function writeEncounter(model, sessionId, encounter, reducer, meterAggregates) {
   const database = statements(model);
-  writeEnemiesAndDeaths(model, sessionId, encounter, reducer.mobIdentities);
+  writeEnemiesAndDeaths(model, sessionId, encounter, reducer.mobIdentities, meterAggregates?.get("tanked"));
   const totalDamage = encounter.actors.reduce((sum, actor) => sum + actor.damage, 0);
   database.query(`insert or replace into combat_encounters
       (session_id, encounter_id, started_at_ms, last_damage_at_ms, ended_at_ms, total_damage)
@@ -3044,9 +3428,9 @@ function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate
   const database = statements(model);
   const insertActor = database.query(`insert or replace into combat_actors
         (session_id, encounter_id, meter, actor_index, actor_id, active_slot, display_name, archetype, owner_connection_id, uid,
-         active_identity, damage, first_damage_at_ms, last_damage_at_ms, hits, critical_hits, kills, ewma_rate, ewma_at_ms, ewma_tau_seconds)
+         active_identity, damage, absorbed, first_damage_at_ms, last_damage_at_ms, hits, critical_hits, kills, ewma_rate, ewma_at_ms, ewma_tau_seconds)
         values ($sessionId, $encounterId, $meter, $actorIndex, $actorId, $activeSlot, $displayName, $archetype, $ownerConnectionId, $uid,
-                $activeIdentity, $damage, $firstDamageAtMs, $lastDamageAtMs, $hits, $criticalHits, $kills, $ewmaRate, $ewmaAtMs, $ewmaTauSeconds)`);
+                $activeIdentity, $damage, $absorbed, $firstDamageAtMs, $lastDamageAtMs, $hits, $criticalHits, $kills, $ewmaRate, $ewmaAtMs, $ewmaTauSeconds)`);
   const insertSkill = database.query(`insert or replace into combat_skills
     (session_id, encounter_id, meter, actor_index, source_id, source_label, damage, hits, critical_hits)
     values ($sessionId, $encounterId, $meter, $actorIndex, $sourceId, $sourceLabel, $damage, $hits, $criticalHits)`);
@@ -3057,8 +3441,8 @@ function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate
     (session_id, encounter_id, meter, actor_index, origin, origin_ms, width_ms, bucket_index, damage)
     values ($sessionId, $encounterId, $meter, $actorIndex, $origin, $originMs, $widthMs, $bucketIndex, $damage)`);
   const insertEnemySkill = database.query(`insert or replace into combat_enemy_skills
-    (session_id, encounter_id, actor_index, target_id, source_id, source_label, damage, hits, critical_hits)
-    values ($sessionId, $encounterId, $actorIndex, $targetId, $sourceId, $sourceLabel, $damage, $hits, $criticalHits)`);
+    (session_id, encounter_id, meter, actor_index, target_id, source_id, source_label, damage, hits, critical_hits)
+    values ($sessionId, $encounterId, $meter, $actorIndex, $targetId, $sourceId, $sourceLabel, $damage, $hits, $criticalHits)`);
   const deleteBucketTail = database.query(`delete from combat_timeline_buckets
     where session_id = $sessionId and encounter_id = $encounterId and meter = $meter
       and actor_index = $actorIndex and origin = $origin and bucket_index >= $bucketCount`);
@@ -3076,6 +3460,7 @@ function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate
       uid: actor.uid ?? null,
       activeIdentity: actor.activeIdentity ? 1 : 0,
       damage: actor.damage,
+      absorbed: actor.absorbed,
       firstDamageAtMs: actor.firstDamageAtMs ?? null,
       lastDamageAtMs: actor.lastDamageAtMs ?? null,
       hits: actor.hits,
@@ -3108,12 +3493,13 @@ function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate
         damage: actor.targetDamage.get(targetId) ?? 0
       });
     }
-    if (meter === "dps") {
+    if (meter === "dps" || meter === "tanked") {
       for (const [targetId, bySkill] of actor.enemySkills) {
         for (const [sourceId, stats] of bySkill) {
           insertEnemySkill.run({
             sessionId,
             encounterId,
+            meter,
             actorIndex,
             targetId,
             sourceId,
@@ -3125,6 +3511,24 @@ function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate
         }
       }
     }
+    if (meter === "tanked") {
+      for (const skill of actor.absorbedSkills.values()) {
+        insertSkill.run({
+          sessionId,
+          encounterId,
+          meter: ABSORBED_METER,
+          actorIndex,
+          sourceId: skill.sourceId,
+          sourceLabel: skill.sourceLabel,
+          damage: skill.damage,
+          hits: skill.hits,
+          criticalHits: skill.criticalHits
+        });
+      }
+      for (const [targetId, value] of actor.absorbedByEnemy) {
+        insertTarget.run({ sessionId, encounterId, meter: ABSORBED_METER, actorIndex, targetId, damage: value });
+      }
+    }
     for (const [origin, series] of [["encounter", actor.encounterSeries], ["actor", actor.actorSeries]]) {
       const dirtyFrom = takeDirtyFrom(series);
       if (dirtyFrom === Number.POSITIVE_INFINITY)
@@ -3148,7 +3552,7 @@ function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate
     }
   }
 }
-function writeEnemiesAndDeaths(model, sessionId, encounter, mobIdentities) {
+function writeEnemiesAndDeaths(model, sessionId, encounter, mobIdentities, tanked) {
   const database = statements(model);
   const scope = { sessionId, encounterId: encounter.id };
   const insertEnemy = database.query(`insert or replace into combat_enemies
@@ -3162,11 +3566,15 @@ function writeEnemiesAndDeaths(model, sessionId, encounter, mobIdentities) {
      attacker_label, attacker_is_monster, source_label, damage, critical)
     values ($sessionId, $encounterId, $deathIndex, $hitIndex, $beforeDeathMs, $attackerActorId,
             $attackerLabel, $attackerIsMonster, $sourceLabel, $damage, $critical)`);
-  for (const [targetId, firstSeenAtMs] of encounter.enemyFirstSeenAtMs) {
+  const enemyFirstSeen = new Map(encounter.enemyFirstSeenAtMs);
+  for (const [targetId, firstSeenAtMs] of tanked?.enemyFirstSeenAtMs ?? []) {
+    enemyFirstSeen.set(targetId, Math.min(firstSeenAtMs, enemyFirstSeen.get(targetId) ?? firstSeenAtMs));
+  }
+  for (const [targetId, firstSeenAtMs] of enemyFirstSeen) {
     insertEnemy.run({
       ...scope,
       targetId,
-      displayName: encounter.enemyNames.get(targetId) ?? mobIdentities.get(targetId) ?? null,
+      displayName: encounter.enemyNames.get(targetId) ?? tanked?.enemyNames.get(targetId) ?? mobIdentities.get(targetId) ?? null,
       firstSeenAtMs
     });
   }
@@ -3319,7 +3727,7 @@ function loadOpenEncounter(model, sessionId) {
       actor.targetIds.add(target.target_id);
       actor.targetDamage.set(target.target_id, target.damage);
     }
-    for (const enemySkill of database.query("select target_id, source_id, source_label, damage, hits, critical_hits from combat_enemy_skills where session_id = ? and encounter_id = ? and actor_index = ?").all(sessionId, row.encounter_id, actorRow2.actor_index)) {
+    for (const enemySkill of database.query("select target_id, source_id, source_label, damage, hits, critical_hits from combat_enemy_skills where session_id = ? and encounter_id = ? and meter = 'dps' and actor_index = ?").all(sessionId, row.encounter_id, actorRow2.actor_index)) {
       const bySkill = actor.enemySkills.get(enemySkill.target_id) ?? new Map;
       actor.enemySkills.set(enemySkill.target_id, bySkill);
       bySkill.set(enemySkill.source_id, {
@@ -3363,6 +3771,7 @@ function loadMeterAggregate(model, sessionId, open, meter) {
       actor.archetype = actorRow2.archetype;
     actor.activeIdentity = actorRow2.active_identity === 1;
     actor.damage = actorRow2.damage;
+    actor.absorbed = actorRow2.absorbed;
     if (actorRow2.first_damage_at_ms !== null)
       actor.firstDamageAtMs = actorRow2.first_damage_at_ms;
     if (actorRow2.last_damage_at_ms !== null)
@@ -3387,6 +3796,30 @@ function loadMeterAggregate(model, sessionId, open, meter) {
       actor.targetIds.add(target.target_id);
       actor.targetDamage.set(target.target_id, target.damage);
     }
+    if (meter === "tanked") {
+      for (const enemySkill of database.query("select target_id, source_id, source_label, damage, hits, critical_hits from combat_enemy_skills where session_id = ? and encounter_id = ? and meter = 'tanked' and actor_index = ?").all(sessionId, open.id, actorRow2.actor_index)) {
+        const bySkill = actor.enemySkills.get(enemySkill.target_id) ?? new Map;
+        actor.enemySkills.set(enemySkill.target_id, bySkill);
+        bySkill.set(enemySkill.source_id, {
+          sourceLabel: enemySkill.source_label,
+          damage: enemySkill.damage,
+          hits: enemySkill.hits,
+          criticalHits: enemySkill.critical_hits
+        });
+      }
+      for (const skill of database.query("select source_id, source_label, damage, hits, critical_hits from combat_skills where session_id = ? and encounter_id = ? and meter = 'absorbed' and actor_index = ?").all(sessionId, open.id, actorRow2.actor_index)) {
+        actor.absorbedSkills.set(skill.source_id, {
+          sourceId: skill.source_id,
+          sourceLabel: skill.source_label,
+          damage: skill.damage,
+          hits: skill.hits,
+          criticalHits: skill.critical_hits
+        });
+      }
+      for (const target of database.query("select target_id, damage from combat_targets where session_id = ? and encounter_id = ? and meter = 'absorbed' and actor_index = ?").all(sessionId, open.id, actorRow2.actor_index)) {
+        actor.absorbedByEnemy.set(target.target_id, target.damage);
+      }
+    }
     for (const bucket of database.query("select origin, origin_ms, width_ms, bucket_index, damage from combat_timeline_buckets where session_id = ? and encounter_id = ? and meter = ? and actor_index = ? order by bucket_index").all(sessionId, open.id, meter, actorRow2.actor_index)) {
       const series = bucket.origin === "actor" ? actor.actorSeries : actor.encounterSeries;
       series.originMs = bucket.origin_ms;
@@ -3426,23 +3859,17 @@ class CombatHistoryStore {
       ...rows.length > limit && last ? { nextCursor: encodeCursor({ startedAtMs: last.started_at_ms, encounterId: last.encounter_id }) } : {}
     };
   }
-  getEnemyBreakdown(sessionId, encounterId) {
-    const enemies = this.model.database.query("select target_id, display_name, first_seen_at_ms from combat_enemies where session_id = ? and encounter_id = ? order by first_seen_at_ms, target_id").all(sessionId, encounterId);
-    const counts = new Map;
-    for (const enemy of enemies) {
-      const name = enemy.display_name ?? `Enemy ${enemy.target_id}`;
-      counts.set(name, (counts.get(name) ?? 0) + 1);
+  getEnemyBreakdown(sessionId, encounterId, meter = "dps") {
+    const enemyRows = this.model.database.query("select target_id, display_name, first_seen_at_ms from combat_enemies where session_id = ? and encounter_id = ? order by first_seen_at_ms, target_id").all(sessionId, encounterId);
+    const names = new Map(enemyRows.map((enemy) => [enemy.target_id, enemy.display_name]));
+    if (meter === "tanked") {
+      const state = this.model.database.query("select mob_identities_json from combat_stream_state where session_id = ?").get(sessionId);
+      for (const [id, name] of JSON.parse(state?.mob_identities_json ?? "[]")) {
+        if (!names.get(id))
+          names.set(id, name);
+      }
     }
-    const nextIndex = new Map;
-    const options = enemies.map((enemy) => {
-      const name = enemy.display_name ?? `Enemy ${enemy.target_id}`;
-      if ((counts.get(name) ?? 0) <= 1)
-        return { targetId: enemy.target_id, label: name };
-      const index = (nextIndex.get(name) ?? 0) + 1;
-      nextIndex.set(name, index);
-      return { targetId: enemy.target_id, label: `${name} (${index})` };
-    });
-    const encounter = this.loadEncounter(sessionId, encounterId, "dps", { withTimeline: false });
+    const encounter = this.loadEncounter(sessionId, encounterId, meter, { withTimeline: false });
     const skills = encounter ? displayActorAggregates(encounter, { includeAllAnonymous: true }).flatMap(({ rowId, actor }) => [...actor.enemySkills].flatMap(([targetId, bySkill]) => [...bySkill].map(([sourceId, stats]) => ({
       attackerRowId: rowId,
       targetId,
@@ -3452,6 +3879,21 @@ class CombatHistoryStore {
       hits: stats.hits,
       criticalHits: stats.criticalHits
     })))).sort((left, right) => right.damage - left.damage) : [];
+    const pickerIds = orderedEnemyIds(skills, enemyRows);
+    const counts = new Map;
+    for (const targetId of pickerIds) {
+      const name = names.get(targetId) ?? `Enemy ${targetId}`;
+      counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const nextIndex = new Map;
+    const options = pickerIds.map((targetId) => {
+      const name = names.get(targetId) ?? `Enemy ${targetId}`;
+      if ((counts.get(name) ?? 0) <= 1)
+        return { targetId, label: name };
+      const index = (nextIndex.get(name) ?? 0) + 1;
+      nextIndex.set(name, index);
+      return { targetId, label: `${name} (${index})` };
+    });
     return { encounterId, enemies: options, skills };
   }
   getDeathLog(query) {
@@ -3524,6 +3966,7 @@ function hydrateActor(database, sessionId, encounterId, meter, row, encounterSta
     actor.uid = row.uid;
   actor.activeIdentity = row.active_identity === 1;
   actor.damage = row.damage;
+  actor.absorbed = row.absorbed;
   if (row.first_damage_at_ms !== null)
     actor.firstDamageAtMs = row.first_damage_at_ms;
   if (row.last_damage_at_ms !== null)
@@ -3545,8 +3988,8 @@ function hydrateActor(database, sessionId, encounterId, meter, row, encounterSta
     actor.targetIds.add(target.target_id);
     actor.targetDamage.set(target.target_id, target.damage);
   }
-  if (meter === "dps") {
-    for (const enemySkill of database.query("select target_id, source_id, source_label, damage, hits, critical_hits from combat_enemy_skills where session_id = ? and encounter_id = ? and actor_index = ?").all(sessionId, encounterId, row.actor_index)) {
+  if (meter === "dps" || meter === "tanked") {
+    for (const enemySkill of database.query("select target_id, source_id, source_label, damage, hits, critical_hits from combat_enemy_skills where session_id = ? and encounter_id = ? and meter = ? and actor_index = ?").all(sessionId, encounterId, meter, row.actor_index)) {
       const bySkill = actor.enemySkills.get(enemySkill.target_id) ?? new Map;
       actor.enemySkills.set(enemySkill.target_id, bySkill);
       bySkill.set(enemySkill.source_id, {
@@ -3557,6 +4000,20 @@ function hydrateActor(database, sessionId, encounterId, meter, row, encounterSta
       });
     }
   }
+  if (meter === "tanked") {
+    for (const skill of database.query("select source_id, source_label, damage, hits, critical_hits from combat_skills where session_id = ? and encounter_id = ? and meter = 'absorbed' and actor_index = ?").all(sessionId, encounterId, row.actor_index)) {
+      actor.absorbedSkills.set(skill.source_id, {
+        sourceId: skill.source_id,
+        sourceLabel: skill.source_label,
+        damage: skill.damage,
+        hits: skill.hits,
+        criticalHits: skill.critical_hits
+      });
+    }
+    for (const target of database.query("select target_id, damage from combat_targets where session_id = ? and encounter_id = ? and meter = 'absorbed' and actor_index = ?").all(sessionId, encounterId, row.actor_index)) {
+      actor.absorbedByEnemy.set(target.target_id, target.damage);
+    }
+  }
   if (withTimeline) {
     for (const bucket of database.query("select origin, origin_ms, width_ms, bucket_index, damage from combat_timeline_buckets where session_id = ? and encounter_id = ? and meter = ? and actor_index = ? order by bucket_index").all(sessionId, encounterId, meter, row.actor_index)) {
       const series = bucket.origin === "actor" ? actor.actorSeries : actor.encounterSeries;
@@ -3569,6 +4026,13 @@ function hydrateActor(database, sessionId, encounterId, meter, row, encounterSta
   }
   return actor;
 }
+function orderedEnemyIds(skills, enemyRows) {
+  const withSkills = new Set(skills.map((skill) => skill.targetId));
+  const ordered = enemyRows.map((enemy) => enemy.target_id).filter((id) => withSkills.has(id));
+  const seen = new Set(ordered);
+  const rest = [...withSkills].filter((id) => !seen.has(id)).sort((left, right) => left - right);
+  return [...ordered, ...rest];
+}
 function summary(sessionId, row) {
   return {
     sessionId,
@@ -3595,15 +4059,14 @@ function decodeCursor(cursor) {
     return;
   return { startedAtMs, encounterId: text.slice(separator + 1) };
 }
-// src/live-combat.ts
+// src/runtime/live-combat.ts
 class LiveCombatService {
   reducer;
   currentTauSeconds;
   minimumDurationMs;
   retainedFinishedEncounters;
   onEncounterFinished;
-  tanked;
-  healing;
+  meters;
   meterId;
   lastEventAtMs;
   latestFinished;
@@ -3624,15 +4087,13 @@ class LiveCombatService {
       maxTimelineBuckets: timelinePoints,
       onEncounterFinished: (encounter) => this.finishMeter(encounter)
     });
-    this.tanked = new MeterReducer({ kind: "tanked", currentTauSeconds: this.currentTauSeconds, maxTimelineBuckets: timelinePoints });
-    this.healing = new MeterReducer({ kind: "healing", currentTauSeconds: this.currentTauSeconds, maxTimelineBuckets: timelinePoints });
+    this.meters = new MeterReducerGroup({ currentTauSeconds: this.currentTauSeconds, maxTimelineBuckets: timelinePoints });
   }
   consumeIdentity(event, observedAtMs) {
     const previous = event.operation === "reset" ? undefined : this.reducer.identities.get(event.actorId);
     const hadIdentities = this.reducer.identities.size > 0;
     this.reducer.consumeIdentity(event, observedAtMs);
-    this.tanked.consumeIdentity(event);
-    this.healing.consumeIdentity(event);
+    this.meters.consumeIdentity(event);
     if (this.identityChanged(event, previous, hadIdentities))
       this.revision += 1;
   }
@@ -3690,30 +4151,25 @@ class LiveCombatService {
       return;
     this.meterId = encounter.id;
     this.lastEventAtMs = encounter.startedAtMs;
-    this.tanked.begin(encounter.id, encounter.startedAtMs);
-    this.healing.begin(encounter.id, encounter.startedAtMs);
   }
   recordMeterEvent(event, observedAtMs) {
     if (this.meterId === undefined)
       return;
-    const identities = this.reducer.identities;
-    this.tanked.consumeCombat(event, observedAtMs, identities);
-    this.healing.consumeCombat(event, observedAtMs, identities);
+    this.meters.consumeCombat(this.reducer.current, event, observedAtMs, this.reducer.identities, this.reducer.mobIdentities);
     this.lastEventAtMs = Math.max(this.lastEventAtMs ?? observedAtMs, observedAtMs);
   }
   finishMeter(encounter) {
     this.ensureMeter(encounter);
     const endedAtMs = encounter.endedAtMs ?? encounter.lastDamageAtMs;
+    const meterAggregates = this.meters.finish(endedAtMs);
     const finished = {
       encounter,
       endedAtMs,
       lastEventAtMs: this.lastEventAtMs ?? encounter.lastDamageAtMs,
-      ...this.tanked.current === undefined ? {} : { tanked: this.tanked.current },
-      ...this.healing.current === undefined ? {} : { healing: this.healing.current }
+      ...meterAggregates.get("tanked") === undefined ? {} : { tanked: meterAggregates.get("tanked") },
+      ...meterAggregates.get("healing") === undefined ? {} : { healing: meterAggregates.get("healing") }
     };
     const record = this.renderRecord(encounter, endedAtMs, finished);
-    this.tanked.finish(endedAtMs);
-    this.healing.finish(endedAtMs);
     this.meterId = undefined;
     this.lastEventAtMs = undefined;
     this.latestFinished = this.retainedFinishedEncounters > 0 ? finished : undefined;
@@ -3742,8 +4198,8 @@ class LiveCombatService {
         minimumDurationMs: this.minimumDurationMs,
         ...personal
       }),
-      tps: render(finished ? finished.tanked : this.tanked.current),
-      hps: render(finished ? finished.healing : this.healing.current)
+      tps: render(finished ? finished.tanked : this.meters.current("tanked")),
+      hps: render(finished ? finished.healing : this.meters.current("healing"))
     };
   }
 }
@@ -3820,17 +4276,18 @@ function positiveInteger(value, name) {
     throw new Error(`${name} must be a positive integer`);
   return value;
 }
-// src/live-log.ts
+// src/replay/live-log.ts
 import {
   DEFAULT_STREAM_BATCH_BYTES,
+  decoderForText,
   JsonlTailReader,
-  LiveLogSessionFollower,
-  isLogStreamHeader as isLogStreamHeader3,
-  parseLogRecord as parseLogRecord3
+  LogRecordLineDecoder as LogRecordLineDecoder3,
+  LiveLogSessionFollower
 } from "@kar-mi/spirit-vale-tools-logging";
 class DpsLogFollower {
   ticksPerSecond;
   reader;
+  records = new LogRecordLineDecoder3;
   recordedAtOriginMs;
   lastObservedAtMs = 0;
   originTick;
@@ -3838,7 +4295,7 @@ class DpsLogFollower {
   revision = 0;
   constructor(path, ticksPerSecond = 30) {
     this.ticksPerSecond = ticksPerSecond;
-    this.reader = new JsonlTailReader(path, { createDecoder: decoderFor2, maxReadBytes: DEFAULT_STREAM_BATCH_BYTES });
+    this.reader = new JsonlTailReader(path, { createDecoder: decoderForText, maxReadBytes: DEFAULT_STREAM_BATCH_BYTES });
   }
   async poll() {
     return this.consumeRead(await this.reader.read());
@@ -3859,22 +4316,14 @@ class DpsLogFollower {
     const events = [];
     let invalidLines = 0;
     for (const line of lines) {
-      if (!line.trim())
-        continue;
-      let candidate;
-      try {
-        candidate = JSON.parse(line);
-      } catch {
-        invalidLines += 1;
-        continue;
-      }
-      if (isLogStreamHeader3(candidate))
+      const decoded = this.records.decode(line);
+      if (decoded.kind === "empty" || decoded.kind === "header")
         continue;
-      const record = parseLogRecord3(candidate);
-      if (!record) {
+      if (decoded.kind === "invalid") {
         invalidLines += 1;
         continue;
       }
+      const record = decoded.record;
       const event = parseDpsLogRecord(record.type, record.data);
       if (event === null)
         continue;
@@ -3902,6 +4351,7 @@ class DpsLogFollower {
     return this.lastObservedAtMs;
   }
   resetState() {
+    this.records.reset();
     this.recordedAtOriginMs = undefined;
     this.lastObservedAtMs = 0;
     this.originTick = undefined;
@@ -3911,15 +4361,14 @@ class DpsLogFollower {
 
 class DpsSessionLogFollower {
   inner;
-  constructor(logDirectory, ticksPerSecond = 30, options = {}) {
-    const { ticksPerSecond: ticksOverride, ...tuning } = options;
-    const ticks = ticksOverride ?? ticksPerSecond;
+  constructor(logDirectory, options = {}) {
+    const { ticksPerSecond = 30, ...tuning } = options;
     this.inner = new LiveLogSessionFollower({
       stream: "combat",
       ...logDirectory === undefined ? {} : { logDirectory },
       ...tuning,
-      readerOptions: { createDecoder: decoderFor2, maxReadBytes: DEFAULT_STREAM_BATCH_BYTES },
-      createFollower: (path) => new DpsLogFollower(path, ticks),
+      readerOptions: { createDecoder: decoderForText, maxReadBytes: DEFAULT_STREAM_BATCH_BYTES },
+      createFollower: (path) => new DpsLogFollower(path, ticksPerSecond),
       mergeSessionChange: (batch, changedSession) => ({
         ...batch,
         reset: batch.reset || changedSession,
@@ -3929,7 +4378,7 @@ class DpsSessionLogFollower {
     });
   }
   static watch(logDirectory, options = {}) {
-    return new DpsSessionLogFollower(logDirectory, options.ticksPerSecond ?? 30, options);
+    return new DpsSessionLogFollower(logDirectory, options);
   }
   poll() {
     return this.inner.poll();
@@ -3944,14 +4393,7 @@ class DpsSessionLogFollower {
     this.inner.close();
   }
 }
-function decoderFor2(firstChunk) {
-  if (firstChunk[0] === 255 && firstChunk[1] === 254)
-    return new TextDecoder("utf-16le");
-  if (firstChunk[0] === 254 && firstChunk[1] === 255)
-    return new TextDecoder("utf-16be");
-  return new TextDecoder("utf-8");
-}
-// src/position-tracker.ts
+// src/tracking/position-tracker.ts
 class FishNetPositionTracker {
   options;
   positions = new Map;
@@ -4030,15 +4472,16 @@ export {
   ANALYSIS_BUCKET_MS,
   COMBAT_DOMAIN_NAME,
   COMBAT_DOMAIN_VERSION,
-  CURRENT_BOSS_SKILL_NAMES,
   CombatHistoryStore,
   DamageReducer,
   DpsLogFollower,
   DpsSessionLogFollower,
   FishNetActorDirectory,
   FishNetCombatTracker,
+  FishNetMonsterIdentityTracker,
   FishNetPositionTracker,
   FishNetStatusTracker,
+  FishNetSummonTracker,
   LiveCombatService,
   MeterReducer,
   actorRowId,
@@ -4051,6 +4494,7 @@ export {
   inspectCombatReplaySummary,
   loadDpsReplay,
   normalizeName,
+  observeFishNetDamagePacket,
   parseDpsLogRecord,
   readCombatReplaySummary,
   renderEncounter,