@kar-mi/spirit-vale-tools-combat 3.3.5 → 4.0.0

package/dist/index.js

@@ -1,12 +1,11 @@
 // @bun
 // src/combat-tracker.ts
 import {
-  classifyFishNetRecoveryStyle,
   CURRENT_GAME_BUILD_FINGERPRINT,
   FishNetMonsterDirectory,
-  loadBundledFishNetSemanticMap
+  loadBundledFishNetRpcMap
 } from "@kar-mi/spirit-vale-tools-capture";
-import { readSignedPackedWhole as readSignedPackedWhole3 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+import { readSignedPackedWhole as readSignedPackedWhole2 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
 import { loadBundledSkillCatalog } from "@kar-mi/spirit-vale-tools-skills";
 
 // src/effect-display.ts
@@ -69,51 +68,53 @@ function readBoolean(buffer, offset, description) {
   return { value: value === 1, nextOffset: offset + 1 };
 }
 
-// src/summon-calibration.ts
-import { FishNetProtocolError as FishNetProtocolError2 } from "@kar-mi/spirit-vale-tools-capture";
-import { checkedEnd as checkedEnd2, readSignedPackedWhole as readSignedPackedWhole2, requireBytes as requireBytes2 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
-function decodeSummonCalibration(payload) {
-  const count = readSignedPackedWhole2(payload, 0);
-  if (count.value === -1) {
-    requireComplete(payload, count.nextOffset);
-    return [];
-  }
-  if (count.value < 0)
-    throw new FishNetProtocolError2("invalid summon calibration array length");
-  const entries = [];
-  let offset = count.nextOffset;
-  for (let index = 0;index < count.value; index += 1) {
-    const skill = readString2(payload, offset);
-    offset = skill.nextOffset;
-    const primary = readBoolean2(payload, offset, "summon primary flag");
-    offset = primary.nextOffset;
-    const mounted = readBoolean2(payload, offset, "summon mounted flag");
-    offset = mounted.nextOffset;
-    entries.push({ skillId: skill.value, isPrimary: primary.value, isMountedSummon: mounted.value });
-  }
-  requireComplete(payload, offset);
-  return entries;
-}
-function readString2(buffer, offset) {
-  const length = readSignedPackedWhole2(buffer, offset);
-  if (length.value < 0)
-    throw new FishNetProtocolError2("summon skill id must not be null");
-  const nextOffset = checkedEnd2(buffer, length.nextOffset, length.value);
-  return { value: buffer.toString("utf8", length.nextOffset, nextOffset), nextOffset };
-}
-function readBoolean2(buffer, offset, description) {
-  requireBytes2(buffer, offset, 1, description);
-  const value = buffer[offset];
-  if (value !== 0 && value !== 1)
-    throw new FishNetProtocolError2(`invalid ${description}`);
-  return { value: value === 1, nextOffset: offset + 1 };
-}
-function requireComplete(buffer, offset) {
-  if (offset !== buffer.length) {
-    throw new FishNetProtocolError2(`summon calibration left ${buffer.length - offset} undecoded bytes`);
-  }
+// src/inference/recovery-style.ts
+function classifyFishNetRecoveryStyle(packet) {
+  if (packet.rpcName !== "Recover_C" || packet.networkBehaviourType !== "HealthComponent")
+    return "unknown";
+  const value = (name) => packet.decodedFields?.find((field) => field.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/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/combat-tracker.ts
 var HIT_RESULTS = {
   0: "normal",
@@ -124,10 +125,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 MAX_RECOVERED_SUMMON_BYTES = 256;
-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 {
@@ -136,15 +133,23 @@ class FishNetCombatTracker {
   skillLabels;
   actorIdentityResolver;
   healingTraitsResolver;
-  localActorIdResolver;
   monsterCatalog;
   bossCatalog;
   monsters;
-  semanticMap;
+  healthComponentIndices;
+  directHealingSkillIds;
+  regenerationSkillIds;
+  barrierSkillIds;
+  barrierStatusIds;
   activations = new Map;
   bossIdentities = new Map;
   activeRegenSources = new Map;
+  bondRegenSources = new Map;
+  barriers = new Map;
+  recentDamageHits = new Map;
   summonStacks = new Map;
+  summonSkillSyncState = new Map;
+  authoritativeSummonActors = new Set;
   recentDamageSignatures = new Set;
   recentDamageTick;
   nextActivation = 1;
@@ -157,18 +162,19 @@ 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.localActorIdResolver = options.localActorIdResolver;
     this.monsterCatalog = options.monsterCatalog;
     if (options.monsterCatalog)
       this.monsters = new FishNetMonsterDirectory(options.monsterCatalog);
@@ -177,6 +183,7 @@ class FishNetCombatTracker {
   consume(packet) {
     const monsterIdentity = this.monsterIdentity(packet.tick, this.monsters?.consume(packet));
     const bossLifecycle = this.bossIdentityLifecycle(packet);
+    const summonLifecycle = this.consumeSummonObjectLifecycle(packet);
     if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
       this.reset();
       return uniqueMonsterIdentityEvents([
@@ -188,14 +195,21 @@ class FishNetCombatTracker {
     if (this.recentDamageTick !== packet.tick) {
       this.recentDamageTick = packet.tick;
       this.recentDamageSignatures.clear();
+      this.recentDamageHits.clear();
     }
     const events = [
       ...monsterIdentity ? [monsterIdentity] : [],
-      ...bossLifecycle ? [bossLifecycle] : []
+      ...bossLifecycle ? [bossLifecycle] : [],
+      ...summonLifecycle ? [summonLifecycle] : []
     ];
+    this.consumeBondSync(packet);
+    events.push(...this.consumeBarrierSync(packet));
+    if (packet.packetName === "syncType" && matchesBehaviour(packet, "SummoningComponent")) {
+      events.push(...this.consumeSummonSkillSync(packet));
+      return events;
+    }
     if (packet.objectId === undefined || !packet.rpcName) {
       events.push(...this.recoverAmbiguousCombat(packet));
-      events.push(...this.recoverSummons(packet));
       return events;
     }
     if (SKILL_RPC_NAMES.has(packet.rpcName) && matchesBehaviour(packet, "SkillsComponent")) {
@@ -255,18 +269,27 @@ class FishNetCombatTracker {
       }
       return events;
     }
-    if (packet.rpcName === "CalibrateSummons_T" && matchesBehaviour(packet, "SummoningComponent")) {
+    if (packet.rpcName === "CalibrateSummons_T" && packet.rpcResolution === "verified" && packet.networkBehaviourType === "SummoningComponent") {
       events.push(...this.consumeSummonCalibration(packet));
       return events;
     }
+    if (packet.rpcName === "LoadCharacter_T" && packet.rpcResolution === "verified" && packet.networkBehaviourType === "PlayerSave") {
+      events.push(...this.consumeLoginEffects(packet));
+      return events;
+    }
     return events;
   }
   reset() {
     this.activations.clear();
     this.bossIdentities.clear();
     this.activeRegenSources.clear();
+    this.bondRegenSources.clear();
+    this.barriers.clear();
     this.summonStacks.clear();
+    this.summonSkillSyncState.clear();
+    this.authoritativeSummonActors.clear();
     this.recentDamageSignatures.clear();
+    this.recentDamageHits.clear();
     this.recentDamageTick = undefined;
     this.monsters?.reset();
   }
@@ -334,6 +357,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,
@@ -355,27 +386,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 = readSignedPackedWhole3(packet.payload, 0);
+      amount = readSignedPackedWhole2(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) {
@@ -397,35 +429,92 @@ class FishNetCombatTracker {
       actorIdentity: this.actorIdentityResolver?.(actorId)
     };
   }
-  recoverSummons(packet) {
-    if (packet.rpcName || packet.rpcResolution === "verified" || packet.rpcResolution === "recovered")
+  consumeLoginEffects(packet) {
+    const entries = decodedLoginEffects(packet);
+    if (!entries)
       return [];
-    if (packet.payload.length < 2 || packet.payload.length > MAX_RECOVERED_SUMMON_BYTES)
-      return [];
-    if (this.skillLabels.size === 0)
+    const actorId = packet.objectId;
+    return entries.map((entry) => ({
+      kind: "status",
+      rpc: "LoadCharacter_T",
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: {
+        Id: entry.statusId,
+        Level: entry.level,
+        Duration: entry.remainingSeconds ?? null,
+        Stacks: entry.stacks
+      },
+      actorId,
+      statusId: entry.statusId,
+      level: entry.level,
+      action: "applied",
+      ...entry.remainingSeconds === undefined ? {} : { remainingSeconds: entry.remainingSeconds },
+      stacks: entry.stacks,
+      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 actorId = packet.objectId ?? this.localActorIdResolver?.();
-    if (actorId === undefined)
+    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 [];
-    let entries;
-    try {
-      entries = decodeSummonCalibration(packet.payload);
-    } catch {
+    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;
     }
-    if (entries.length === 0)
-      return [];
-    if (!entries.every(({ skillId }) => this.skillLabels.has(skillId)))
-      return [];
-    return this.applySummonSnapshot(actorId, packet, entries).map((event) => ({ ...event, recovered: true }));
+    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) {
-    let entries;
-    try {
-      entries = decodeSummonCalibration(packet.payload);
-    } catch {
+    const entries = decodedSummonCalibration(packet);
+    if (!entries)
       return [];
-    }
+    this.authoritativeSummonActors.add(packet.objectId);
     return this.applySummonSnapshot(packet.objectId, packet, entries);
   }
   applySummonSnapshot(actorId, packet, entries) {
@@ -446,7 +535,7 @@ class FishNetCombatTracker {
       rpc: "CalibrateSummons_T",
       tick: packet.tick,
       payloadBytes: packet.payload.length,
-      fields: {},
+      fields: decodedFieldRecord(packet),
       actorId,
       skillId,
       stacks: current.get(skillId) ?? 0,
@@ -463,7 +552,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,
@@ -548,6 +637,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;
@@ -647,7 +738,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");
     }
@@ -655,7 +746,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;
@@ -666,7 +757,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;
@@ -675,8 +766,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) {
@@ -707,6 +798,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 {
@@ -736,7 +922,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)
@@ -756,6 +942,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,
@@ -769,6 +958,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++}`,
@@ -805,12 +1003,147 @@ function drainRecoverySource(traits) {
   }
   return { sourceId: "siphon-health-leech", sourceLabel: "Siphon / Health Leech" };
 }
+function sourceFromCandidates(candidates) {
+  if (candidates.length === 1) {
+    const candidate = candidates[0];
+    return {
+      actorId: candidate.actorId,
+      sourceId: candidate.sourceId,
+      sourceLabel: candidate.sourceLabel,
+      activationId: candidate.id
+    };
+  }
+  return candidates.length > 1 ? { candidateActivationIds: candidates.map(({ id }) => id) } : {};
+}
+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 healthComponentIndices(map) {
+  return new Set(map?.prefabs?.flatMap(({ components }) => components.filter(({ typeName }) => typeName === "HealthComponent").map(({ index }) => index)) ?? []);
+}
 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
+    });
+  }
+  return entries;
+}
 function matchesBehaviour(packet, expected) {
   return packet.networkBehaviourType === undefined || packet.networkBehaviourType === expected;
 }
@@ -855,7 +1188,7 @@ function isCompleteDamagePacket(packet, requireVectors) {
   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;
+  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 nullableStringField(packet, name) {
   const value = field(packet, name);
@@ -889,9 +1222,9 @@ function tryLoadBundledSkillCatalog(buildFingerprint) {
     return;
   }
 }
-function tryLoadBundledSemanticMap(buildFingerprint) {
+function tryLoadBundledRpcMap(buildFingerprint) {
   try {
-    return loadBundledFishNetSemanticMap(buildFingerprint);
+    return loadBundledFishNetRpcMap(buildFingerprint);
   } catch {
     return;
   }
@@ -908,8 +1241,8 @@ function createBossCatalog(entries) {
 }
 var CURRENT_BOSS_SKILL_NAMES = createBossCatalog({});
 // src/actor-directory.ts
-import { characterDataParameter, decodeFieldRun, loadBundledFishNetRpcMap } from "@kar-mi/spirit-vale-tools-capture";
-import { readSignedPackedWhole as readSignedPackedWhole4 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+import { characterDataParameter, decodeFieldRun, loadBundledFishNetRpcMap as loadBundledFishNetRpcMap2 } from "@kar-mi/spirit-vale-tools-capture";
+import { readSignedPackedWhole as readSignedPackedWhole3 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
 
 class FishNetActorDirectory {
   options;
@@ -1274,7 +1607,7 @@ function hasMonsterIdentityEvidence(packet) {
   return typeof mobId === "string" && mobId.length > 0;
 }
 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;
@@ -1313,7 +1646,7 @@ function decodeCharacterDataName(payload) {
     try {
       let offset = 0;
       if (skipEnum)
-        offset = readSignedPackedWhole4(payload, offset).nextOffset;
+        offset = readSignedPackedWhole3(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");
@@ -1717,21 +2050,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);
   }
@@ -1752,6 +2088,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
@@ -1785,6 +2124,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,
@@ -1809,6 +2149,7 @@ function renderEncounter(encounter, options = {}) {
     ...encounter.endedAtMs === undefined ? {} : { endedAtMs: encounter.endedAtMs },
     durationMs,
     totalDamage,
+    ...totalAbsorbed <= 0 ? {} : { totalAbsorbed },
     partyDps: perSecond(totalDamage, durationMs),
     partyCurrentDps,
     actors,
@@ -1826,6 +2167,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],
@@ -1834,6 +2181,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,
@@ -1871,7 +2220,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);
@@ -1943,6 +2292,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);
@@ -2341,10 +2705,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")
@@ -2367,7 +2738,7 @@ 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 { FishNetSessionDecoder, loadBundledFishNetRpcMap as loadBundledFishNetRpcMap3, decodeLiteNetLibDatagram } from "@kar-mi/spirit-vale-tools-capture";
 import { isLogStreamHeader as isLogStreamHeader2, parseLogRecord as parseLogRecord2 } from "@kar-mi/spirit-vale-tools-logging";
 function decodeCombatCaptureJsonLines(text, options) {
   const replay = new CombatCaptureReplay(options);
@@ -2389,7 +2760,7 @@ async function replayCombatCaptures(paths, options) {
 
 class CombatCaptureReplay {
   options;
-  session = new FishNetSessionDecoder(loadBundledFishNetRpcMap2());
+  session = new FishNetSessionDecoder(loadBundledFishNetRpcMap3());
   datagrams = 0;
   combatEvents = 0;
   identityEvents = 0;
@@ -2528,7 +2899,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 (
@@ -2581,6 +2952,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.
@@ -2630,11 +3003,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,
@@ -2642,7 +3017,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 (
@@ -2755,15 +3130,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);
@@ -2778,12 +3153,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);
@@ -2804,11 +3206,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;
@@ -2822,8 +3228,49 @@ 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/history/importer.ts
+var ABSORBED_METER = "absorbed";
 var METER_KINDS = [
   { meter: "tanked", kind: "tanked" },
   { meter: "healing", kind: "healing" }
@@ -2958,12 +3405,12 @@ function consume(reducer, meters, record, note) {
   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);
+    entry.reducer.consumeCombat(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)
@@ -2983,9 +3430,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)`);
@@ -2996,8 +3443,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`);
@@ -3015,6 +3462,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,
@@ -3047,12 +3495,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,
@@ -3064,6 +3513,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)
@@ -3087,7 +3554,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
@@ -3101,11 +3568,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
     });
   }
@@ -3258,7 +3729,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, {
@@ -3302,6 +3773,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)
@@ -3326,6 +3798,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;
@@ -3365,23 +3861,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,
@@ -3391,6 +3881,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) {
@@ -3463,6 +3968,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)
@@ -3484,8 +3990,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, {
@@ -3496,6 +4002,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;
@@ -3508,6 +4028,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,
@@ -3636,7 +4163,7 @@ class LiveCombatService {
     if (this.meterId === undefined)
       return;
     const identities = this.reducer.identities;
-    this.tanked.consumeCombat(event, observedAtMs, identities);
+    this.tanked.consumeCombat(event, observedAtMs, identities, this.reducer.mobIdentities);
     this.healing.consumeCombat(event, observedAtMs, identities);
     this.lastEventAtMs = Math.max(this.lastEventAtMs ?? observedAtMs, observedAtMs);
   }