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

package/dist/index.js

@@ -0,0 +1,3998 @@
+// @bun
+// src/combat-tracker.ts
+import {
+  classifyFishNetRecoveryStyle,
+  CURRENT_GAME_BUILD_FINGERPRINT,
+  FishNetMonsterDirectory,
+  loadBundledFishNetSemanticMap
+} from "@kar-mi/spirit-vale-tools-capture";
+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
+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) {
+  const applies = [];
+  let offset = 0;
+  const count = readSignedPackedWhole(payload, offset);
+  offset = count.nextOffset;
+  if (count.value < -1)
+    throw new FishNetProtocolError("invalid effect display array length");
+  for (let index = 0;index < count.value; index += 1) {
+    const status = readString(payload, offset);
+    offset = status.nextOffset;
+    requireBytes(payload, offset, 4, "effect display remaining seconds");
+    const remainingSeconds = payload.readFloatLE(offset);
+    offset += 4;
+    const stacks = readSignedPackedWhole(payload, offset);
+    offset = stacks.nextOffset;
+    const maxStacks = readSignedPackedWhole(payload, offset);
+    offset = maxStacks.nextOffset;
+    offset = readBoolean(payload, offset, "effect display flag").nextOffset;
+    if (stacks.value < 0)
+      throw new FishNetProtocolError("negative effect display stack count");
+    applies.push({
+      statusId: status.value,
+      ...remainingSeconds < 0 || !Number.isFinite(remainingSeconds) ? {} : { remainingSeconds },
+      stacks: stacks.value,
+      maxStacks: Math.max(0, maxStacks.value)
+    });
+  }
+  const removes = [];
+  const removeCount = readSignedPackedWhole(payload, offset);
+  offset = removeCount.nextOffset;
+  if (removeCount.value < -1)
+    throw new FishNetProtocolError("invalid effect removal array length");
+  for (let index = 0;index < removeCount.value; index += 1) {
+    const status = readString(payload, offset);
+    offset = status.nextOffset;
+    removes.push(status.value);
+  }
+  if (offset !== payload.length) {
+    throw new FishNetProtocolError(`effect displays left ${payload.length - offset} undecoded bytes`);
+  }
+  return { applies, removes };
+}
+function readString(buffer, offset) {
+  const length = readSignedPackedWhole(buffer, offset);
+  if (length.value < 0)
+    throw new FishNetProtocolError("effect display status id must not be null");
+  const nextOffset = checkedEnd(buffer, length.nextOffset, length.value);
+  return { value: buffer.toString("utf8", length.nextOffset, nextOffset), nextOffset };
+}
+function readBoolean(buffer, offset, description) {
+  requireBytes(buffer, offset, 1, description);
+  const value = buffer[offset];
+  if (value !== 0 && value !== 1)
+    throw new FishNetProtocolError(`invalid ${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/combat-tracker.ts
+var HIT_RESULTS = {
+  0: "normal",
+  1: "critical",
+  2: "miss",
+  3: "blocked",
+  4: "dodged"
+};
+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 {
+  hitGraceTicks;
+  activationMaxAgeTicks;
+  skillLabels;
+  actorIdentityResolver;
+  healingTraitsResolver;
+  localActorIdResolver;
+  monsterCatalog;
+  bossCatalog;
+  monsters;
+  semanticMap;
+  activations = new Map;
+  bossIdentities = new Map;
+  activeRegenSources = new Map;
+  summonStacks = new Map;
+  recentDamageSignatures = new Set;
+  recentDamageTick;
+  nextActivation = 1;
+  constructor(options = {}) {
+    const grace = options.hitGraceTicks ?? 30;
+    if (!Number.isInteger(grace) || grace < 0)
+      throw new Error("hitGraceTicks must be a non-negative integer");
+    this.hitGraceTicks = grace;
+    const maxAge = options.activationMaxAgeTicks ?? 900;
+    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;
+    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;
+    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);
+    this.bossCatalog = options.bossCatalog;
+  }
+  consume(packet) {
+    const monsterIdentity = this.monsterIdentity(packet.tick, this.monsters?.consume(packet));
+    const bossLifecycle = this.bossIdentityLifecycle(packet);
+    if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
+      this.reset();
+      return uniqueMonsterIdentityEvents([
+        ...monsterIdentity ? [monsterIdentity] : [],
+        ...bossLifecycle ? [bossLifecycle] : []
+      ]);
+    }
+    this.pruneExpired(packet.tick);
+    if (this.recentDamageTick !== packet.tick) {
+      this.recentDamageTick = packet.tick;
+      this.recentDamageSignatures.clear();
+    }
+    const events = [
+      ...monsterIdentity ? [monsterIdentity] : [],
+      ...bossLifecycle ? [bossLifecycle] : []
+    ];
+    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")) {
+      const skillEvent = this.consumeSkill(packet);
+      if (skillEvent) {
+        events.push(skillEvent);
+        const bossIdentity = this.bossIdentity(skillEvent);
+        if (bossIdentity)
+          events.push(bossIdentity);
+      }
+      return events;
+    }
+    if (packet.rpcName === "Attack_C" && matchesBehaviour(packet, "CombatComponent")) {
+      events.push(this.beginAttack(packet));
+      return events;
+    }
+    if ((packet.rpcName === "ApplyDamage_C" || packet.rpcName === "Death_C") && matchesBehaviour(packet, "HealthComponent")) {
+      const death = packet.rpcName === "Death_C";
+      if (!isCompleteDamagePacket(packet, !death))
+        return events;
+      events.push(...this.consumeDamage(packet, death));
+      return events;
+    }
+    if (packet.rpcName === "Recover_C" && matchesBehaviour(packet, "HealthComponent")) {
+      if (!isCompleteRecoverPacket(packet))
+        return events;
+      events.push(this.consumeRecover(packet));
+      return events;
+    }
+    if ((packet.rpcName === "ApplyEffect_T" || packet.rpcName === "RemoveEffect_T") && matchesBehaviour(packet, "StatusComponent")) {
+      const statusEvent = this.consumeStatus(packet);
+      if (statusEvent)
+        events.push(statusEvent);
+      return events;
+    }
+    if (packet.rpcName === "ApplyEffectDisplays_O" && matchesBehaviour(packet, "StatusComponent")) {
+      events.push(...this.consumeEffectDisplays(packet));
+      return events;
+    }
+    if ((packet.rpcName === "ApplySkillDisplay_O" || packet.rpcName === "RemoveSkillDisplay_O") && matchesBehaviour(packet, "StatusComponent")) {
+      const skillDisplay = this.consumeSkillDisplay(packet);
+      if (skillDisplay)
+        events.push(skillDisplay);
+      return events;
+    }
+    if (packet.rpcName === "FullHeal_C" && matchesBehaviour(packet, "PlayerController")) {
+      if (packet.payload.length === 0) {
+        events.push({
+          kind: "fullHeal",
+          rpc: "FullHeal_C",
+          tick: packet.tick,
+          payloadBytes: 0,
+          fields: {},
+          targetId: packet.objectId,
+          actorIdentity: this.actorIdentityResolver?.(packet.objectId)
+        });
+      }
+      return events;
+    }
+    if (packet.rpcName === "CalibrateSummons_T" && matchesBehaviour(packet, "SummoningComponent")) {
+      events.push(...this.consumeSummonCalibration(packet));
+      return events;
+    }
+    return events;
+  }
+  reset() {
+    this.activations.clear();
+    this.bossIdentities.clear();
+    this.activeRegenSources.clear();
+    this.summonStacks.clear();
+    this.recentDamageSignatures.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 };
+  }
+  consumeEffectDisplays(packet) {
+    let batch;
+    try {
+      batch = decodeEffectDisplays(packet.payload);
+    } catch {
+      return [];
+    }
+    const actorId = packet.objectId;
+    const base = {
+      kind: "status",
+      rpc: "ApplyEffectDisplays_O",
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: {},
+      actorId,
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    };
+    return [
+      ...batch.applies.map((display) => ({
+        ...base,
+        statusId: display.statusId,
+        action: "applied",
+        ...display.remainingSeconds === undefined ? {} : { remainingSeconds: display.remainingSeconds },
+        stacks: display.stacks
+      })),
+      ...batch.removes.map((statusId) => ({ ...base, statusId, action: "removed" }))
+    ];
+  }
+  recoverAmbiguousCombat(packet) {
+    if (packet.rpcResolution !== "ambiguous" || packet.packetName !== "observersRpc" || packet.objectId === undefined || packet.networkBehaviourIndex === undefined)
+      return [];
+    if (packet.rpcHash === 5 && CURRENT_STATUS_COMPONENT_INDICES.has(packet.networkBehaviourIndex)) {
+      return this.consumeEffectDisplays({
+        ...packet,
+        networkBehaviourType: "StatusComponent",
+        rpcName: "ApplyEffectDisplays_O"
+      });
+    }
+    if (packet.rpcHash !== 1 || !CURRENT_HEALTH_COMPONENT_INDICES.has(packet.networkBehaviourIndex))
+      return [];
+    let amount;
+    try {
+      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)
+      return [];
+    return [this.consumeRecover({
+      ...packet,
+      networkBehaviourType: "HealthComponent",
+      rpcName: "Recover_C",
+      decodedFields: [{ name: "amount", codec: "packedInt32", value: amount.value }],
+      undecodedPayload: settings
+    })];
+  }
+  consumeSkillDisplay(packet) {
+    const statusId = stringField(packet, "id");
+    if (!statusId)
+      return;
+    const actorId = packet.objectId;
+    const level = numberField(packet, "lv");
+    return {
+      kind: "status",
+      rpc: packet.rpcName,
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      statusId,
+      action: packet.rpcName === "ApplySkillDisplay_O" ? "applied" : "removed",
+      ...level === undefined ? {} : { level },
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    };
+  }
+  recoverSummons(packet) {
+    if (packet.rpcName || packet.rpcResolution === "verified" || packet.rpcResolution === "recovered")
+      return [];
+    if (packet.payload.length < 2 || packet.payload.length > MAX_RECOVERED_SUMMON_BYTES)
+      return [];
+    if (this.skillLabels.size === 0)
+      return [];
+    const actorId = packet.objectId ?? this.localActorIdResolver?.();
+    if (actorId === undefined)
+      return [];
+    let entries;
+    try {
+      entries = decodeSummonCalibration(packet.payload);
+    } catch {
+      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 }));
+  }
+  consumeSummonCalibration(packet) {
+    let entries;
+    try {
+      entries = decodeSummonCalibration(packet.payload);
+    } catch {
+      return [];
+    }
+    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: {},
+      actorId,
+      skillId,
+      stacks: current.get(skillId) ?? 0,
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    }));
+  }
+  consumeSkill(packet) {
+    const actorId = packet.objectId;
+    const rpcName = packet.rpcName;
+    if (!rpcName)
+      return;
+    if (rpcName === "CastBegin_C" || rpcName === "AutoCast_C" || rpcName === "ToggleBegin_C") {
+      const sourceId = rpcName === "ToggleBegin_C" ? stringField(packet, "id") : stringField(packet, "dto.Id");
+      if (!sourceId)
+        return;
+      const activation2 = this.createActivation(actorId, "skill", packet.tick, sourceId, false);
+      activation2.targetId = numberField(packet, "targetId");
+      return {
+        kind: "activation",
+        rpc: rpcName,
+        tick: packet.tick,
+        payloadBytes: packet.payload.length,
+        fields: decodedFieldRecord(packet),
+        actorId,
+        activationId: activation2.id,
+        actionKind: "skill",
+        phase: "begin",
+        sourceId,
+        sourceLabel: activation2.sourceLabel,
+        targetId: activation2.targetId,
+        level: numberField(packet, "dto.Level")
+      };
+    }
+    const phases = {
+      CastComplete_C: "complete",
+      CastInterrupt_C: "interrupt",
+      CastCancel_C: "cancel"
+    };
+    const phase = phases[rpcName];
+    if (!phase)
+      return;
+    const activation = this.findLifecycleActivation(actorId);
+    if (activation) {
+      activation.endTick = packet.tick;
+      activation.deadlineTick = packet.tick + this.hitGraceTicks;
+    }
+    return {
+      kind: "activation",
+      rpc: rpcName,
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      activationId: activation?.id,
+      actionKind: activation?.actionKind ?? "skill",
+      phase,
+      sourceId: activation?.sourceId,
+      sourceLabel: activation?.sourceLabel
+    };
+  }
+  beginAttack(packet) {
+    const actorId = packet.objectId;
+    const attackIndex = numberField(packet, "attackIndex");
+    const activation = this.createActivation(actorId, "basicAttack", packet.tick, undefined, false);
+    activation.endTick = packet.tick;
+    activation.deadlineTick = packet.tick + this.hitGraceTicks;
+    return {
+      kind: "activation",
+      rpc: "Attack_C",
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      activationId: activation.id,
+      actionKind: "basicAttack",
+      phase: "begin",
+      attackIndex
+    };
+  }
+  consumeDamage(packet, death) {
+    const actorId = requiredNumberField(packet, "dmg.AttackerId");
+    const damageType = requiredNumberField(packet, "dmg.Type");
+    const rawSourceId = nullableStringField(packet, "dmg.DamageSourceId");
+    const { sourceId, sourceLabel } = resolveDamageSource(rawSourceId, damageType, this.skillLabels);
+    const value = requiredNumberField(packet, "dmg.Value");
+    if (!death && value < 0) {
+      return [{
+        kind: "heal",
+        rpc: "ApplyDamage_C",
+        tick: packet.tick,
+        payloadBytes: packet.payload.length,
+        fields: decodedFieldRecord(packet),
+        targetId: packet.objectId,
+        actorId,
+        sourceId,
+        sourceLabel,
+        value: -value,
+        attribution: "exact",
+        actorIdentity: this.actorIdentityResolver?.(actorId)
+      }];
+    }
+    const hitCode = requiredNumberField(packet, "dmg.Hit");
+    const hitResult = HIT_RESULTS[hitCode] ?? hitCode;
+    const targetId = packet.objectId;
+    const exactCandidates = this.eligibleActivations(packet.tick, actorId).filter((activation) => activation.sourceId === sourceId);
+    let candidates = exactCandidates;
+    if (candidates.length === 0) {
+      const unboundAttacks = this.eligibleActivations(packet.tick, actorId).filter((activation) => activation.actionKind === "basicAttack" && activation.sourceId === undefined);
+      if (unboundAttacks.length === 1) {
+        const [attack] = unboundAttacks;
+        if (attack) {
+          attack.sourceId = sourceId;
+          attack.sourceLabel = sourceLabel;
+          candidates = [attack];
+        }
+      } else if (unboundAttacks.length > 1) {
+        candidates = unboundAttacks;
+      }
+    }
+    const events = [];
+    let attribution;
+    let activationId;
+    let candidateActivationIds;
+    if (candidates.length === 0) {
+      const inferred = this.createActivation(actorId, "inferred", packet.tick, sourceId, true);
+      inferred.endTick = packet.tick;
+      inferred.deadlineTick = packet.tick + this.hitGraceTicks;
+      candidates = [inferred];
+      attribution = "inferred";
+      activationId = inferred.id;
+      events.push({
+        kind: "activation",
+        rpc: "inferred",
+        tick: packet.tick,
+        payloadBytes: 0,
+        fields: {},
+        actorId,
+        activationId: inferred.id,
+        actionKind: "inferred",
+        phase: "inferred",
+        sourceId,
+        sourceLabel,
+        inferred: true
+      });
+    } else if (candidates.length === 1) {
+      const [candidate] = candidates;
+      if (!candidate)
+        throw new Error("missing combat activation candidate");
+      attribution = candidate.inferred ? "inferred" : "exact";
+      activationId = candidate.id;
+    } else {
+      attribution = "ambiguous";
+      candidateActivationIds = candidates.map(({ id }) => id);
+    }
+    const common = {
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      targetId,
+      sourceId,
+      sourceLabel,
+      value,
+      hitResult,
+      wireHits: requiredNumberField(packet, "dmg.Hits"),
+      damageType,
+      team: requiredNumberField(packet, "dmg.Team"),
+      element: requiredNumberField(packet, "dmg.Element"),
+      weaponType: requiredNumberField(packet, "dmg.WeaponType"),
+      range: requiredNumberField(packet, "dmg.Range"),
+      isClone: requiredBooleanField(packet, "dmg.IsClone"),
+      isSummon: requiredBooleanField(packet, "dmg.IsSummon"),
+      attribution,
+      activationId,
+      candidateActivationIds,
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    };
+    const signature = damageSignature(packet.tick, targetId, actorId, sourceId, value, hitCode);
+    if (death) {
+      events.push({
+        kind: "death",
+        rpc: "Death_C",
+        ...common,
+        duplicatesDamageEvent: this.recentDamageSignatures.has(signature)
+      });
+    } else {
+      this.recentDamageSignatures.add(signature);
+      events.push({
+        kind: "damage",
+        rpc: "ApplyDamage_C",
+        ...common,
+        position: requiredVectorField(packet, "position"),
+        origin: requiredVectorField(packet, "origin")
+      });
+    }
+    return events;
+  }
+  consumeRecover(packet) {
+    const targetId = packet.objectId;
+    const value = requiredNumberField(packet, "amount");
+    const recoveryStyle = classifyFishNetRecoveryStyle(packet, this.semanticMap);
+    if (recoveryStyle === "passive-regeneration") {
+      return this.createSelfRecovery(packet, value, recoveryStyle, "passive-regeneration", "Passive regeneration");
+    }
+    if (recoveryStyle === "drain") {
+      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);
+    let attribution;
+    let actorId;
+    let sourceId;
+    let sourceLabel;
+    let activationId;
+    let candidateActivationIds;
+    if (candidates.length === 1) {
+      const [candidate] = candidates;
+      if (!candidate)
+        throw new Error("missing combat activation candidate");
+      attribution = candidate.inferred ? "inferred" : "exact";
+      actorId = candidate.actorId;
+      sourceId = candidate.sourceId;
+      sourceLabel = candidate.sourceLabel;
+      activationId = candidate.id;
+    } else if (candidates.length > 1) {
+      attribution = "ambiguous";
+      candidateActivationIds = candidates.map(({ id }) => id);
+    } else {
+      const regenSource = this.activeRegenSources.get(targetId);
+      if (regenSource?.candidateActivationIds) {
+        attribution = "ambiguous";
+        candidateActivationIds = regenSource.candidateActivationIds;
+      } else if (regenSource?.actorId !== undefined) {
+        attribution = "inferred";
+        actorId = regenSource.actorId;
+        sourceId = regenSource.sourceId;
+        sourceLabel = regenSource.sourceLabel;
+        activationId = regenSource.activationId;
+      } else {
+        attribution = "unattributed";
+      }
+    }
+    return {
+      kind: "heal",
+      rpc: "Recover_C",
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      targetId,
+      actorId,
+      sourceId,
+      sourceLabel,
+      value,
+      recoveryStyle,
+      attribution,
+      activationId,
+      candidateActivationIds,
+      actorIdentity: actorId === undefined ? undefined : this.actorIdentityResolver?.(actorId)
+    };
+  }
+  createSelfRecovery(packet, value, recoveryStyle, sourceId, sourceLabel) {
+    const actorId = packet.objectId;
+    return {
+      kind: "heal",
+      rpc: "Recover_C",
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      targetId: actorId,
+      actorId,
+      sourceId,
+      sourceLabel,
+      value,
+      recoveryStyle,
+      attribution: "inferred",
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    };
+  }
+  eligibleHealActivations(tick, recipientId, skillIds) {
+    return [...this.activations.values()].filter((activation) => activation.actionKind === "skill" && activation.sourceId !== undefined && skillIds.has(activation.sourceId) && activation.startTick <= tick && (activation.deadlineTick === undefined || tick <= activation.deadlineTick) && activation.targetId === recipientId);
+  }
+  consumeStatus(packet) {
+    const statusId = stringField(packet, "statusId");
+    const level = numberField(packet, "level");
+    if (statusId === undefined || level === undefined)
+      return;
+    const actorId = packet.objectId;
+    if (statusId === REGEN_STATUS_ID) {
+      if (packet.rpcName === "ApplyEffect_T") {
+        const candidates = this.eligibleHealActivations(packet.tick, actorId, REGEN_SKILL_IDS);
+        if (candidates.length === 1) {
+          const [candidate] = candidates;
+          if (!candidate)
+            throw new Error("missing combat activation candidate");
+          this.activeRegenSources.set(actorId, {
+            actorId: candidate.actorId,
+            sourceId: candidate.sourceId,
+            sourceLabel: candidate.sourceLabel,
+            activationId: candidate.id
+          });
+        } else if (candidates.length > 1) {
+          this.activeRegenSources.set(actorId, { candidateActivationIds: candidates.map(({ id }) => id) });
+        } else {
+          this.activeRegenSources.delete(actorId);
+        }
+      } else {
+        this.activeRegenSources.delete(actorId);
+      }
+    }
+    return {
+      kind: "status",
+      rpc: packet.rpcName,
+      tick: packet.tick,
+      payloadBytes: packet.payload.length,
+      fields: decodedFieldRecord(packet),
+      actorId,
+      statusId,
+      level,
+      action: packet.rpcName === "ApplyEffect_T" ? "applied" : "removed",
+      actorIdentity: this.actorIdentityResolver?.(actorId)
+    };
+  }
+  createActivation(actorId, actionKind, tick, sourceId, inferred) {
+    const activation = {
+      id: `activation-${this.nextActivation++}`,
+      actorId,
+      actionKind,
+      sourceId,
+      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 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}`;
+}
+var DAMAGE_TYPE_SOURCES = new Map([
+  [4, { sourceId: "reflect", sourceLabel: "Reflect Damage" }]
+]);
+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 tryLoadBundledSkillCatalog(buildFingerprint) {
+  try {
+    return loadBundledSkillCatalog(buildFingerprint);
+  } catch {
+    return;
+  }
+}
+function tryLoadBundledSemanticMap(buildFingerprint) {
+  try {
+    return loadBundledFishNetSemanticMap(buildFingerprint);
+  } catch {
+    return;
+  }
+}
+function assertMatchingBuild(label, candidate, expected) {
+  if (candidate !== undefined && candidate !== expected) {
+    throw new Error(`${label} build ${JSON.stringify(candidate)} does not match ${JSON.stringify(expected)}`);
+  }
+}
+// src/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 readSignedPackedWhole4 } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+
+class FishNetActorDirectory {
+  options;
+  identities = new Map;
+  objects = new Map;
+  ownerObjects = new Map;
+  identitySources = new Map;
+  sourceRevisions = new Map;
+  observedPlayerActors = new Set;
+  uidIdentities = new Map;
+  nextSourceRevision = 1;
+  localIdentity;
+  constructor(options = {}) {
+    this.options = options;
+    this.localIdentity = options.localIdentity;
+    for (const known of options.knownIdentities ?? []) {
+      this.uidIdentities.set(known.uid, {
+        displayName: known.displayName,
+        ...known.archetype === undefined ? {} : { archetype: known.archetype }
+      });
+    }
+    this.seedLocalIdentity();
+  }
+  consume(packet) {
+    if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
+      this.clear();
+      return [{ kind: "actorIdentity", operation: "reset", tick: packet.tick }];
+    }
+    if (packet.packetName === "objectSpawn" && packet.objectId !== undefined) {
+      const observedPlayerActor = this.observedPlayerActors.has(packet.objectId);
+      const events = this.removeObject(packet.objectId, packet.tick, true);
+      if (observedPlayerActor)
+        this.observedPlayerActors.add(packet.objectId);
+      const ownerConnectionId = validOwner(packet.ownerConnectionId);
+      const identityEligible = hasIdentityBehaviourEvidence(packet) || observedPlayerActor;
+      this.objects.set(packet.objectId, {
+        ...ownerConnectionId === undefined ? {} : { ownerConnectionId },
+        identityEligible
+      });
+      if (ownerConnectionId !== undefined)
+        this.addOwnerObject(ownerConnectionId, packet.objectId);
+      if (hasMonsterIdentityEvidence(packet)) {
+        events.push(...this.clearPlayerIdentity(packet.objectId, packet.tick));
+        events.push(...this.refreshOwner(ownerConnectionId, packet.tick, true));
+        return events;
+      }
+      const embeddedIdentity = this.resolveSpawnIdentity(packet);
+      if (embeddedIdentity) {
+        const next = {
+          actorId: packet.objectId,
+          displayName: embeddedIdentity.displayName,
+          ...embeddedIdentity.archetype === undefined ? {} : { archetype: embeddedIdentity.archetype }
+        };
+        this.identitySources.set(packet.objectId, next);
+        this.sourceRevisions.set(packet.objectId, this.nextSourceRevision++);
+        const object = this.objects.get(packet.objectId);
+        if (object)
+          object.identityEligible = true;
+        if (ownerConnectionId === undefined)
+          events.push(...this.reconcile(packet.objectId, next, packet.tick));
+      }
+      events.push(...this.refreshOwner(ownerConnectionId, packet.tick, true));
+      return events;
+    }
+    if (packet.packetName === "objectDespawn" && packet.objectId !== undefined) {
+      return this.removeObject(packet.objectId, packet.tick, true);
+    }
+    if (packet.packetName === "ownershipChange" && packet.objectId !== undefined) {
+      return this.changeOwner(packet.objectId, validOwner(packet.ownerConnectionId), packet.tick);
+    }
+    if (packet.packetName === "serverRpc" && packet.objectId !== undefined && this.localIdentity !== undefined && !this.identitySources.has(packet.objectId)) {
+      return this.applyIdentitySource(packet.objectId, {
+        actorId: packet.objectId,
+        displayName: this.localIdentity.displayName,
+        ...this.localIdentity.uid === undefined ? {} : { uid: this.localIdentity.uid },
+        ...this.localIdentity.archetype === undefined ? {} : { archetype: this.localIdentity.archetype }
+      }, packet.tick);
+    }
+    if (packet.objectId !== undefined && hasMonsterIdentityEvidence(packet)) {
+      return this.clearPlayerIdentity(packet.objectId, packet.tick);
+    }
+    if (packet.objectId !== undefined && packet.rpcName !== undefined && CHARACTER_RPC_NAMES.has(packet.rpcName)) {
+      const character = decodeCharacterDataName(packet.payload);
+      if (character === undefined)
+        return [];
+      const archetype2 = this.localIdentity?.displayName === character.displayName ? this.localIdentity.archetype : undefined;
+      const identity = {
+        ...character,
+        ...archetype2 === undefined ? {} : { archetype: archetype2 }
+      };
+      this.learnUidIdentity(character.uid, identity);
+      this.updateLocalIdentity(identity);
+      return this.applyIdentitySource(packet.objectId, { actorId: packet.objectId, ...identity }, packet.tick);
+    }
+    if (packet.packetName !== "syncType" || packet.objectId === undefined || packet.networkBehaviourType !== "PlayerController" || packet.syncName !== "VisualData" && packet.syncIndex !== 5) {
+      return [];
+    }
+    const displayName = decodedField(packet, "Appearance.DisplayName");
+    if (typeof displayName !== "string" || displayName.length === 0)
+      return [];
+    const decodedArchetype = decodedField(packet, "Appearance.Archetype");
+    const archetype = typeof decodedArchetype === "number" && Number.isInteger(decodedArchetype) ? decodedArchetype : undefined;
+    return this.applyIdentitySource(packet.objectId, {
+      actorId: packet.objectId,
+      displayName,
+      ...archetype === undefined ? {} : { archetype }
+    }, packet.tick);
+  }
+  applyIdentitySource(actorId, next, tick) {
+    const current = this.identitySources.get(actorId);
+    const identity = next.archetype === undefined && current?.displayName === next.displayName && current.archetype !== undefined ? { ...next, archetype: current.archetype } : next;
+    this.identitySources.set(actorId, identity);
+    this.sourceRevisions.set(actorId, this.nextSourceRevision++);
+    const object = this.objects.get(actorId);
+    if (object)
+      object.identityEligible = true;
+    if (object?.ownerConnectionId !== undefined)
+      return this.refreshOwner(object.ownerConnectionId, tick);
+    return this.reconcile(actorId, identity, tick);
+  }
+  get(actorId) {
+    const identity = this.identities.get(actorId);
+    return identity ? { ...identity } : undefined;
+  }
+  getAttribution(actorId) {
+    const direct = this.identities.get(actorId);
+    if (direct)
+      return { ...direct };
+    const ownerConnectionId = this.objects.get(actorId)?.ownerConnectionId;
+    if (ownerConnectionId === undefined)
+      return;
+    const objectIds = this.ownerObjects.get(ownerConnectionId);
+    if (!objectIds)
+      return;
+    let best;
+    let bestRevision = -1;
+    for (const objectId of objectIds) {
+      const identity = this.identities.get(objectId) ?? this.identitySources.get(objectId);
+      const revision = this.sourceRevisions.get(objectId) ?? -1;
+      if (identity && revision >= bestRevision) {
+        best = identity;
+        bestRevision = revision;
+      }
+    }
+    return best ? { ...best, ownerConnectionId } : undefined;
+  }
+  snapshot() {
+    return [...this.identities.values()].map((identity) => ({ ...identity }));
+  }
+  observePlayerActor(actorId, tick) {
+    if (!Number.isInteger(actorId) || actorId < 0)
+      return [];
+    this.observedPlayerActors.add(actorId);
+    const object = this.objects.get(actorId);
+    if (!object)
+      return [];
+    object.identityEligible = true;
+    if (object.ownerConnectionId !== undefined)
+      return this.refreshOwner(object.ownerConnectionId, tick);
+    return this.reconcile(actorId, this.identitySources.get(actorId), tick);
+  }
+  reset() {
+    this.clear();
+    this.seedLocalIdentity();
+  }
+  setLocalIdentity(identity) {
+    this.localIdentity = mergeLocalIdentity(this.localIdentity, identity);
+    this.seedLocalIdentity();
+  }
+  seedLocalIdentity() {
+    if (!this.localIdentity)
+      return;
+    if (this.localIdentity.uid) {
+      this.learnUidIdentity(this.localIdentity.uid, {
+        displayName: this.localIdentity.displayName,
+        ...this.localIdentity.archetype === undefined ? {} : { archetype: this.localIdentity.archetype }
+      });
+    }
+  }
+  updateLocalIdentity(identity) {
+    const next = mergeLocalIdentity(this.localIdentity, identity);
+    if (this.localIdentity?.displayName === next.displayName && this.localIdentity.uid === next.uid && this.localIdentity.archetype === next.archetype)
+      return;
+    this.localIdentity = next;
+    this.options.onLocalIdentity?.(next);
+  }
+  resolveSpawnIdentity(packet) {
+    return decodeSpawnIdentity(packet);
+  }
+  learnUidIdentity(uid, identity) {
+    const current = this.uidIdentities.get(uid);
+    const archetype = identity.archetype ?? (current?.displayName === identity.displayName ? current.archetype : undefined);
+    const next = {
+      displayName: identity.displayName,
+      ...archetype === undefined ? {} : { archetype }
+    };
+    if (current?.displayName === next.displayName && current.archetype === next.archetype)
+      return;
+    this.uidIdentities.set(uid, next);
+    this.options.onIdentityLearned?.({ uid, ...next });
+  }
+  changeOwner(actorId, ownerConnectionId, tick) {
+    const current = this.objects.get(actorId) ?? { identityEligible: false };
+    const previousOwner = current.ownerConnectionId;
+    if (previousOwner === ownerConnectionId)
+      return [];
+    if (previousOwner !== undefined)
+      this.removeOwnerObject(previousOwner, actorId);
+    current.ownerConnectionId = ownerConnectionId;
+    this.objects.set(actorId, current);
+    if (ownerConnectionId !== undefined)
+      this.addOwnerObject(ownerConnectionId, actorId);
+    const events = this.refreshOwner(previousOwner, tick, true);
+    if (ownerConnectionId === undefined) {
+      events.push(...this.reconcile(actorId, this.identitySources.get(actorId), tick));
+    } else {
+      events.push(...this.refreshOwner(ownerConnectionId, tick, true));
+    }
+    return events;
+  }
+  removeObject(actorId, tick, retainIdentity = false) {
+    const object = this.objects.get(actorId);
+    const ownerConnectionId = object?.ownerConnectionId;
+    if (ownerConnectionId !== undefined)
+      this.removeOwnerObject(ownerConnectionId, actorId);
+    this.objects.delete(actorId);
+    this.observedPlayerActors.delete(actorId);
+    this.identitySources.delete(actorId);
+    this.sourceRevisions.delete(actorId);
+    const events = retainIdentity ? [] : this.reconcile(actorId, undefined, tick);
+    events.push(...this.refreshOwner(ownerConnectionId, tick, retainIdentity));
+    return events;
+  }
+  clearPlayerIdentity(actorId, tick) {
+    this.observedPlayerActors.delete(actorId);
+    this.identitySources.delete(actorId);
+    this.sourceRevisions.delete(actorId);
+    const object = this.objects.get(actorId);
+    if (object)
+      object.identityEligible = false;
+    const events = this.reconcile(actorId, undefined, tick);
+    events.push(...this.refreshOwner(object?.ownerConnectionId, tick, true));
+    return events;
+  }
+  refreshOwner(ownerConnectionId, tick, retainExistingWhenSourceMissing = false) {
+    if (ownerConnectionId === undefined)
+      return [];
+    const objectIds = this.ownerObjects.get(ownerConnectionId);
+    if (!objectIds)
+      return [];
+    let source;
+    let revision = -1;
+    for (const objectId of objectIds) {
+      const candidate = this.identitySources.get(objectId);
+      const candidateRevision = this.sourceRevisions.get(objectId) ?? -1;
+      if (candidate && candidateRevision > revision) {
+        source = candidate;
+        revision = candidateRevision;
+      }
+    }
+    if (!source && retainExistingWhenSourceMissing)
+      return [];
+    if (source && source.archetype === undefined) {
+      const sourceDisplayName = source.displayName;
+      let classSource;
+      let classRevision = -1;
+      for (const objectId of objectIds) {
+        const candidate = this.identitySources.get(objectId);
+        const candidateRevision = this.sourceRevisions.get(objectId) ?? -1;
+        if (candidate?.displayName === sourceDisplayName && candidate.archetype !== undefined && candidateRevision > classRevision) {
+          classSource = candidate;
+          classRevision = candidateRevision;
+        }
+      }
+      if (classSource?.archetype !== undefined)
+        source = { ...source, archetype: classSource.archetype };
+    }
+    if (source?.archetype !== undefined) {
+      for (const objectId of objectIds) {
+        const candidate = this.identitySources.get(objectId);
+        if (candidate?.displayName === source.displayName && candidate.archetype !== source.archetype) {
+          this.identitySources.set(objectId, { ...candidate, archetype: source.archetype });
+        }
+      }
+    }
+    const events = [];
+    for (const objectId of objectIds) {
+      if (!this.objects.get(objectId)?.identityEligible)
+        continue;
+      const identity = source && {
+        actorId: objectId,
+        displayName: source.displayName,
+        ...source.archetype === undefined ? {} : { archetype: source.archetype },
+        ...source.uid === undefined ? {} : { uid: source.uid },
+        ownerConnectionId
+      };
+      events.push(...this.reconcile(objectId, identity, tick));
+    }
+    return events;
+  }
+  reconcile(actorId, next, tick) {
+    const current = this.identities.get(actorId);
+    if (!next) {
+      if (!this.identities.delete(actorId))
+        return [];
+      return [{ kind: "actorIdentity", operation: "remove", tick, actorId }];
+    }
+    if (current?.displayName === next.displayName && current.archetype === next.archetype && current.ownerConnectionId === next.ownerConnectionId && current.uid === next.uid)
+      return [];
+    this.identities.set(actorId, next);
+    return [{ kind: "actorIdentity", operation: "upsert", tick, ...next }];
+  }
+  addOwnerObject(ownerConnectionId, actorId) {
+    const objects = this.ownerObjects.get(ownerConnectionId) ?? new Set;
+    objects.add(actorId);
+    this.ownerObjects.set(ownerConnectionId, objects);
+  }
+  removeOwnerObject(ownerConnectionId, actorId) {
+    const objects = this.ownerObjects.get(ownerConnectionId);
+    if (!objects)
+      return;
+    objects.delete(actorId);
+    if (objects.size === 0)
+      this.ownerObjects.delete(ownerConnectionId);
+  }
+  clear() {
+    this.identities.clear();
+    this.objects.clear();
+    this.ownerObjects.clear();
+    this.identitySources.clear();
+    this.sourceRevisions.clear();
+    this.observedPlayerActors.clear();
+    this.nextSourceRevision = 1;
+  }
+}
+var IDENTITY_BEHAVIOURS = new Set(["PlayerController", "SkillsComponent", "CombatComponent", "HealthComponent"]);
+function validOwner(ownerConnectionId) {
+  return ownerConnectionId !== undefined && Number.isInteger(ownerConnectionId) && ownerConnectionId >= 0 ? ownerConnectionId : undefined;
+}
+function mergeLocalIdentity(current, next) {
+  const sameCharacter = current?.displayName === next.displayName;
+  const uid = next.uid ?? (sameCharacter ? current?.uid : undefined);
+  const archetype = next.archetype ?? (sameCharacter ? current?.archetype : undefined);
+  return {
+    displayName: next.displayName,
+    ...uid === undefined ? {} : { uid },
+    ...archetype === undefined ? {} : { archetype }
+  };
+}
+function decodedField(packet, name) {
+  return packet.decodedFields?.find((field2) => field2.name === name)?.value;
+}
+function hasMonsterIdentityEvidence(packet) {
+  if (packet.packetName === "objectSpawn") {
+    const entry = packet.spawnSyncEntries?.find((candidate) => candidate.networkBehaviourType === "MonsterController" && candidate.name === "Data");
+    const mobId2 = entry?.fields.find((field2) => field2.name === "Id")?.value;
+    return typeof mobId2 === "string" && mobId2.length > 0;
+  }
+  if (packet.packetName !== "syncType" || packet.networkBehaviourType !== "MonsterController" || packet.syncName !== "Data" && packet.syncIndex !== 0)
+    return false;
+  const mobId = decodedField(packet, "Data.Id") ?? decodedField(packet, "Monster.Id") ?? decodedField(packet, "Id");
+  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}`));
+function decodeSpawnIdentity(packet) {
+  if (!hasPlayerControllerEvidence(packet))
+    return;
+  const entry = packet.spawnSyncEntries?.find((candidate) => candidate.networkBehaviourType === "PlayerController" && candidate.index === VISUAL_DATA_SYNC_INDEX);
+  if (!entry)
+    return;
+  const displayName = entry.fields.find((field2) => field2.name === "Appearance.DisplayName")?.value;
+  const archetype = entry.fields.find((field2) => field2.name === "Appearance.Archetype")?.value;
+  if (typeof displayName !== "string" || displayName.length === 0 || !Number.isInteger(archetype))
+    return;
+  return { displayName, archetype };
+}
+function hasIdentityBehaviourEvidence(packet) {
+  return isCurrentPlayerPrefab(packet) || (packet.rpcLinkRegistrations?.some(({ networkBehaviourType }) => networkBehaviourType !== undefined && IDENTITY_BEHAVIOURS.has(networkBehaviourType)) ?? false);
+}
+function hasPlayerControllerEvidence(packet) {
+  return isCurrentPlayerPrefab(packet) || (packet.rpcLinkRegistrations?.some(({ networkBehaviourType }) => networkBehaviourType === "PlayerController") ?? false);
+}
+function isCurrentPlayerPrefab(packet) {
+  if (packet.spawnCollectionId === undefined || packet.spawnPrefabId === undefined)
+    return false;
+  return PLAYER_PREFAB_KEYS.has(`${packet.spawnCollectionId}:${packet.spawnPrefabId}`);
+}
+function hasControlCharacters(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0);
+    if (code < 32 || code === 127)
+      return true;
+  }
+  return false;
+}
+var CHARACTER_RPC_NAMES = new Set(["LoadCharacter_T", "CharacterCallback_T"]);
+var GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function decodeCharacterDataName(payload) {
+  for (const skipEnum of [true, false]) {
+    try {
+      let offset = 0;
+      if (skipEnum)
+        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");
+      if (typeof uid !== "string" || !GUID_PATTERN.test(uid))
+        continue;
+      const name = values.get("data.Name");
+      if (typeof name !== "string" || !name.trim() || hasControlCharacters(name))
+        continue;
+      return { displayName: name, uid };
+    } catch {}
+  }
+  return;
+}
+var cachedCharacterNameParameter;
+function characterNameParameter() {
+  if (cachedCharacterNameParameter)
+    return cachedCharacterNameParameter;
+  const full = characterDataParameter();
+  const fields = full.fields ?? [];
+  const nameIndex = fields.findIndex((field2) => field2.name === "Name");
+  cachedCharacterNameParameter = { ...full, fields: fields.slice(0, nameIndex + 1) };
+  return cachedCharacterNameParameter;
+}
+// src/status-tracker.ts
+import {
+  FishNetStatusDirectory,
+  loadBundledStatusCatalog,
+  statusDurationSeconds
+} from "@kar-mi/spirit-vale-tools-statuses";
+import { FishNetSkillDirectory, loadBundledSkillCatalog as loadBundledSkillCatalog2 } from "@kar-mi/spirit-vale-tools-skills";
+
+// src/reducers/damage.ts
+import { EwmaRate } from "@kar-mi/spirit-vale-tools-metrics";
+
+// src/reducers/timeline.ts
+var ANALYSIS_BUCKET_MS = 5000;
+function createSeries(originMs, widthMs = ANALYSIS_BUCKET_MS) {
+  return { originMs, widthMs, buckets: [], dirtyFrom: Number.POSITIVE_INFINITY };
+}
+function takeDirtyFrom(series) {
+  const from = series.dirtyFrom;
+  series.dirtyFrom = Number.POSITIVE_INFINITY;
+  return from;
+}
+function addToSeries(series, atMs, damage, maxBuckets = Number.POSITIVE_INFINITY) {
+  let index = Math.max(0, Math.floor((atMs - series.originMs) / series.widthMs));
+  while (index >= maxBuckets) {
+    collapse(series);
+    index = Math.max(0, Math.floor((atMs - series.originMs) / series.widthMs));
+  }
+  series.dirtyFrom = Math.min(series.dirtyFrom, series.buckets.length, index);
+  while (series.buckets.length <= index)
+    series.buckets.push(0);
+  series.buckets[index] += damage;
+}
+function collapse(series) {
+  const merged = [];
+  for (let index = 0;index < series.buckets.length; index += 2) {
+    merged.push((series.buckets[index] ?? 0) + (series.buckets[index + 1] ?? 0));
+  }
+  series.buckets = merged;
+  series.widthMs *= 2;
+  series.dirtyFrom = 0;
+}
+function addSeries(target, source) {
+  if (source.originMs === target.originMs && source.widthMs === target.widthMs) {
+    for (const [index, damage] of source.buckets.entries()) {
+      while (target.buckets.length <= index)
+        target.buckets.push(0);
+      target.buckets[index] += damage;
+    }
+    return;
+  }
+  for (const [index, damage] of source.buckets.entries()) {
+    if (damage === 0)
+      continue;
+    addToSeries(target, source.originMs + index * source.widthMs, damage);
+  }
+}
+function seriesPoints(series, durationMs) {
+  const bucketCount = Math.max(1, Math.ceil(durationMs / series.widthMs));
+  const points = [{ elapsedMs: 0, damage: 0, cumulativeDamage: 0, dps: 0 }];
+  let cumulativeDamage = 0;
+  for (let index = 0;index < bucketCount; index += 1) {
+    const elapsedMs = Math.min(durationMs, (index + 1) * series.widthMs);
+    const bucketDurationMs = Math.max(1, elapsedMs - index * series.widthMs);
+    let damage = series.buckets[index] ?? 0;
+    if (index === bucketCount - 1) {
+      for (let overflow = bucketCount;overflow < series.buckets.length; overflow += 1) {
+        damage += series.buckets[overflow] ?? 0;
+      }
+    }
+    cumulativeDamage += damage;
+    points.push({ elapsedMs, damage, cumulativeDamage, dps: damage / (bucketDurationMs / 1000) });
+  }
+  return points;
+}
+
+// src/reducers/damage.ts
+var DEFAULT_IDLE_GAP_MS = 30000;
+var DEFAULT_MINIMUM_DURATION_MS = 1000;
+var DEFAULT_CURRENT_TAU_SECONDS = 2.5;
+var MOB_IDENTITY_PREFIX = "__spiritvaleMobIdentity:";
+var DEATH_LOOKBACK_MS = 1e4;
+var MAX_MOB_IDENTITIES = 4096;
+var MAX_IDENTITIES = 4096;
+
+class DamageReducer {
+  identities = new Map;
+  mobIdentities = new Map;
+  current;
+  recentHits = new Map;
+  lastSweepAtMs;
+  idleGapMs;
+  currentTauSeconds;
+  maxTimelineBuckets;
+  createEncounterId;
+  onEncounterFinished;
+  nextEncounter = 1;
+  constructor(options = {}) {
+    this.idleGapMs = options.idleGapMs ?? DEFAULT_IDLE_GAP_MS;
+    this.currentTauSeconds = positiveTau(options.currentTauSeconds ?? DEFAULT_CURRENT_TAU_SECONDS);
+    this.maxTimelineBuckets = options.maxTimelineBuckets ?? Number.POSITIVE_INFINITY;
+    this.createEncounterId = options.createEncounterId ?? (() => `encounter-${this.nextEncounter++}`);
+    if (options.onEncounterFinished)
+      this.onEncounterFinished = options.onEncounterFinished;
+  }
+  resume(encounter) {
+    this.current = encounter;
+  }
+  consumeIdentity(event, _observedAtMs) {
+    if (event.operation === "reset") {
+      this.identities.clear();
+      this.mobIdentities.clear();
+      if (this.current) {
+        for (const actor2 of this.current.actors)
+          actor2.activeIdentity = false;
+        this.current.activeActors.clear();
+      }
+      return;
+    }
+    if (event.operation === "remove") {
+      this.identities.delete(event.actorId);
+      const actor2 = this.current?.activeActors.get(event.actorId);
+      if (actor2)
+        actor2.activeIdentity = false;
+      this.current?.activeActors.delete(event.actorId);
+      return;
+    }
+    const previousIdentity = this.identities.get(event.actorId);
+    const archetype = event.archetype ?? previousIdentity?.archetype;
+    const ownerConnectionId = event.ownerConnectionId ?? previousIdentity?.ownerConnectionId;
+    const uid = event.uid ?? previousIdentity?.uid;
+    this.rememberIdentity(event.actorId, {
+      displayName: event.displayName,
+      ...archetype === undefined ? {} : { archetype },
+      ...ownerConnectionId === undefined ? {} : { ownerConnectionId },
+      ...uid === undefined ? {} : { uid }
+    });
+    if (!this.current)
+      return;
+    const actor = this.actorFor(event.actorId);
+    actor.displayName = event.displayName;
+    if (event.archetype !== undefined)
+      actor.archetype = event.archetype;
+    if (event.ownerConnectionId !== undefined)
+      actor.ownerConnectionId = event.ownerConnectionId;
+    if (event.uid !== undefined)
+      actor.uid = event.uid;
+    actor.activeIdentity = true;
+  }
+  consumeCombat(event, observedAtMs) {
+    if (event.kind === "monsterIdentity") {
+      if (event.operation === "reset")
+        this.mobIdentities.clear();
+      else if (event.operation === "remove")
+        this.mobIdentities.delete(event.actorId);
+      else {
+        this.rememberMobIdentity(event.actorId, event.displayName);
+        if (this.current?.enemyFirstSeenAtMs.has(event.actorId)) {
+          this.current.enemyNames.set(event.actorId, event.displayName);
+        }
+      }
+      return;
+    }
+    const actorId = event.actorId;
+    if (event.actorIdentity && actorId !== undefined) {
+      const previousIdentity = this.identities.get(actorId);
+      const archetype = event.actorIdentity.archetype ?? previousIdentity?.archetype;
+      const ownerConnectionId = event.actorIdentity.ownerConnectionId ?? previousIdentity?.ownerConnectionId;
+      const uid = event.actorIdentity.uid ?? previousIdentity?.uid;
+      this.rememberIdentity(actorId, {
+        displayName: event.actorIdentity.displayName,
+        ...archetype === undefined ? {} : { archetype },
+        ...ownerConnectionId === undefined ? {} : { ownerConnectionId },
+        ...uid === undefined ? {} : { uid }
+      });
+    }
+    if (event.kind === "activation" && event.sourceId?.startsWith(MOB_IDENTITY_PREFIX) && event.sourceLabel) {
+      this.rememberMobIdentity(event.actorId, event.sourceLabel);
+      return;
+    }
+    this.trackRecentHit(event, observedAtMs);
+    const countedDamage = isCountedDamage(event);
+    const countedKill = isCountedKill(event);
+    if (!countedDamage && !countedKill) {
+      if (this.current && observedAtMs - this.current.lastDamageAtMs >= this.idleGapMs) {
+        this.finish(this.current.lastDamageAtMs + this.idleGapMs);
+      }
+      if (this.current)
+        this.recordEncounterHit(event, observedAtMs);
+      return;
+    }
+    if (this.current && observedAtMs - this.current.lastDamageAtMs >= this.idleGapMs) {
+      this.finish(this.current.lastDamageAtMs + this.idleGapMs);
+    }
+    if (!this.current && !countedDamage)
+      return;
+    if (!this.current) {
+      const actors = [...this.identities].map(([identityActorId, identity]) => ({
+        ...createActor(identityActorId, observedAtMs),
+        ...identity,
+        activeIdentity: true
+      }));
+      this.current = {
+        id: this.createEncounterId(observedAtMs),
+        startedAtMs: observedAtMs,
+        lastDamageAtMs: observedAtMs,
+        actors,
+        activeActors: new Map(actors.map((actor2) => [actor2.actorId, actor2])),
+        enemyFirstSeenAtMs: new Map,
+        enemyNames: new Map,
+        deaths: []
+      };
+    }
+    const encounter = this.current;
+    if (countedDamage)
+      encounter.lastDamageAtMs = observedAtMs;
+    this.recordEncounterHit(event, observedAtMs);
+    const actor = this.actorFor(event.actorId);
+    const eventIdentity = event.actorIdentity ?? this.identities.get(event.actorId);
+    if (eventIdentity) {
+      actor.displayName = eventIdentity.displayName;
+      if (eventIdentity.archetype !== undefined)
+        actor.archetype = eventIdentity.archetype;
+      if (eventIdentity.ownerConnectionId !== undefined)
+        actor.ownerConnectionId = eventIdentity.ownerConnectionId;
+      if (eventIdentity.uid !== undefined)
+        actor.uid = eventIdentity.uid;
+      actor.activeIdentity = true;
+    }
+    if (countedDamage) {
+      recordHit(actor, {
+        value: event.value,
+        atMs: observedAtMs,
+        critical: event.hitResult === "critical",
+        sourceId: event.sourceId,
+        sourceLabel: event.sourceLabel
+      }, this.maxTimelineBuckets);
+      if (isMobTarget(this.identities, event.actorId, event.targetId)) {
+        recordEnemyHit(encounter, actor, event, observedAtMs, this.mobIdentities);
+        actor.targetIds.add(event.targetId);
+        actor.targetDamage.set(event.targetId, (actor.targetDamage.get(event.targetId) ?? 0) + event.value);
+      }
+    }
+    if (countedKill)
+      actor.kills += 1;
+  }
+  advance(observedAtMs) {
+    if (this.current && observedAtMs - this.current.lastDamageAtMs >= this.idleGapMs) {
+      this.finish(this.current.lastDamageAtMs + this.idleGapMs);
+    }
+  }
+  reset(observedAtMs) {
+    this.finish(observedAtMs);
+  }
+  finish(endedAtMs) {
+    if (!this.current)
+      return;
+    const encounter = this.current;
+    encounter.endedAtMs = Math.max(endedAtMs, encounter.lastDamageAtMs);
+    this.current = undefined;
+    this.onEncounterFinished?.(encounter);
+  }
+  trackRecentHit(event, observedAtMs) {
+    if (event.kind !== "damage" && event.kind !== "death")
+      return;
+    if (!isPositiveHit(event))
+      return;
+    const attackerLabel = this.identities.get(event.actorId)?.displayName ?? this.mobIdentities.get(event.actorId) ?? `Actor ${event.actorId}`;
+    const hits = this.recentHits.get(event.targetId) ?? [];
+    hits.push({
+      atMs: observedAtMs,
+      hit: {
+        beforeDeathMs: 0,
+        attackerActorId: event.actorId,
+        attackerLabel,
+        attackerIsMonster: this.mobIdentities.has(event.actorId),
+        sourceLabel: event.sourceLabel,
+        damage: event.value,
+        critical: event.hitResult === "critical"
+      }
+    });
+    const cutoffMs = observedAtMs - DEATH_LOOKBACK_MS;
+    while (hits.length > 0 && hits[0].atMs < cutoffMs)
+      hits.shift();
+    if (hits.length === 0)
+      this.recentHits.delete(event.targetId);
+    else
+      this.recentHits.set(event.targetId, hits);
+    this.sweepRecentHits(observedAtMs);
+  }
+  pruneRecentHits(observedAtMs) {
+    this.sweepRecentHits(observedAtMs, true);
+  }
+  sweepRecentHits(observedAtMs, force = false) {
+    if (!force && this.lastSweepAtMs !== undefined && observedAtMs - this.lastSweepAtMs < DEATH_LOOKBACK_MS)
+      return;
+    this.lastSweepAtMs = observedAtMs;
+    const cutoffMs = observedAtMs - DEATH_LOOKBACK_MS;
+    for (const [targetId, hits] of this.recentHits) {
+      while (hits.length > 0 && hits[0].atMs < cutoffMs)
+        hits.shift();
+      if (hits.length === 0)
+        this.recentHits.delete(targetId);
+    }
+  }
+  rememberIdentity(actorId, identity) {
+    this.identities.delete(actorId);
+    this.identities.set(actorId, identity);
+    while (this.identities.size > MAX_IDENTITIES) {
+      const oldest = this.identities.keys().next();
+      if (oldest.done)
+        break;
+      this.identities.delete(oldest.value);
+    }
+  }
+  rememberMobIdentity(actorId, displayName) {
+    this.mobIdentities.delete(actorId);
+    this.mobIdentities.set(actorId, displayName);
+    while (this.mobIdentities.size > MAX_MOB_IDENTITIES) {
+      const oldest = this.mobIdentities.keys().next();
+      if (oldest.done)
+        break;
+      this.mobIdentities.delete(oldest.value);
+    }
+  }
+  recordEncounterHit(event, observedAtMs) {
+    if (event.kind !== "damage" && event.kind !== "death")
+      return;
+    if (!this.current)
+      return;
+    if (event.kind !== "death")
+      return;
+    if (this.mobIdentities.has(event.targetId))
+      return;
+    if (event.team === 0 && !this.identities.has(event.targetId) && event.actorId !== event.targetId)
+      return;
+    const windowStartMs = observedAtMs - DEATH_LOOKBACK_MS;
+    const victimHits = (this.recentHits.get(event.targetId) ?? []).filter((entry) => entry.atMs >= windowStartMs && entry.atMs <= observedAtMs).map((entry) => ({ ...entry.hit, beforeDeathMs: Math.max(0, observedAtMs - entry.atMs) })).sort((left, right) => right.beforeDeathMs - left.beforeDeathMs);
+    this.current.deaths.push({
+      victimName: this.identities.get(event.targetId)?.displayName ?? "Unidentified player",
+      targetId: event.targetId,
+      diedAtMs: observedAtMs,
+      totalDamage: victimHits.reduce((total, hit) => total + hit.damage, 0),
+      hits: victimHits
+    });
+  }
+  actorFor(actorId) {
+    const encounter = this.current;
+    let actor = encounter.activeActors.get(actorId);
+    if (!actor) {
+      actor = createActor(actorId, encounter.startedAtMs, this.currentTauSeconds);
+      encounter.actors.push(actor);
+      encounter.activeActors.set(actorId, actor);
+    }
+    return actor;
+  }
+}
+function recordHit(actor, hit, maxTimelineBuckets) {
+  actor.damage += hit.value;
+  if (actor.firstDamageAtMs === undefined) {
+    actor.firstDamageAtMs = hit.atMs;
+    actor.actorSeries.originMs = hit.atMs;
+  }
+  actor.lastDamageAtMs = hit.atMs;
+  actor.hits += 1;
+  if (hit.critical)
+    actor.criticalHits += 1;
+  addToSeries(actor.encounterSeries, hit.atMs, hit.value, maxTimelineBuckets);
+  addToSeries(actor.actorSeries, hit.atMs, hit.value, maxTimelineBuckets);
+  actor.currentRate.record(hit.value, hit.atMs);
+  let skill = actor.skills.get(hit.sourceId);
+  if (!skill) {
+    skill = { sourceId: hit.sourceId, sourceLabel: hit.sourceLabel, damage: 0, hits: 0, criticalHits: 0 };
+    actor.skills.set(hit.sourceId, skill);
+  }
+  skill.sourceLabel = hit.sourceLabel;
+  skill.damage += hit.value;
+  skill.hits += 1;
+  if (hit.critical)
+    skill.criticalHits += 1;
+}
+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);
+  if (!encounter.enemyFirstSeenAtMs.has(event.targetId)) {
+    encounter.enemyFirstSeenAtMs.set(event.targetId, observedAtMs);
+  }
+  const targetName = mobIdentities.get(event.targetId);
+  if (targetName !== undefined)
+    encounter.enemyNames.set(event.targetId, targetName);
+}
+function createActor(actorId, encounterStartedAtMs, currentRate = DEFAULT_CURRENT_TAU_SECONDS) {
+  return {
+    actorId,
+    actorIds: [actorId],
+    activeIdentity: false,
+    damage: 0,
+    targetIds: new Set,
+    targetDamage: new Map,
+    enemySkills: new Map,
+    hits: 0,
+    criticalHits: 0,
+    kills: 0,
+    skills: new Map,
+    encounterSeries: createSeries(encounterStartedAtMs, ANALYSIS_BUCKET_MS),
+    actorSeries: createSeries(encounterStartedAtMs, ANALYSIS_BUCKET_MS),
+    currentRate: typeof currentRate === "number" ? new EwmaRate({ tauSeconds: currentRate }) : currentRate
+  };
+}
+function isCountedDamage(event) {
+  if (event.kind !== "damage" && event.kind !== "death")
+    return false;
+  if (event.team !== 0 || event.actorId === event.targetId || !Number.isFinite(event.value) || event.value <= 0)
+    return false;
+  return event.kind === "damage" || !event.duplicatesDamageEvent;
+}
+function isCountedKill(event) {
+  return event.kind === "death" && event.team === 0 && event.actorId !== event.targetId && Number.isFinite(event.value) && event.value > 0;
+}
+function isPositiveHit(event) {
+  return Number.isFinite(event.value) && event.value > 0 && (event.kind === "damage" || !event.duplicatesDamageEvent);
+}
+function isMobTarget(identities, actorId, targetId) {
+  return targetId >= 0 && targetId !== actorId && !identities.has(targetId);
+}
+
+// src/reducers/rows.ts
+var DEFAULT_ANONYMOUS_IDENTITY_GRACE_MS = 1e4;
+function renderEncounter(encounter, options = {}) {
+  const minimumDurationMs = options.minimumDurationMs ?? DEFAULT_MINIMUM_DURATION_MS;
+  const anonymousIdentityGraceMs = options.anonymousIdentityGraceMs ?? DEFAULT_ANONYMOUS_IDENTITY_GRACE_MS;
+  const personalName = options.personalName ?? "";
+  const personalActorId = options.personalActorId;
+  const snapshotNowMs = Math.max(options.nowMs ?? encounter.lastDamageAtMs, encounter.lastDamageAtMs);
+  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 rowForActor = (actor, rowId) => actorRow(actor, rowId, encounter.startedAtMs, durationMs, totalDamage, snapshotNowMs, minimumDurationMs, actor.displayName === undefined, "encounter");
+  const displayed = visibleDisplayGroups(mergedActors, encounter, {
+    snapshotNowMs,
+    anonymousIdentityGraceMs,
+    personalActorId
+  });
+  const actors = displayed.map(({ actor, rowId }) => rowForActor(actor, rowId)).sort(compareRows);
+  const partyCurrentDps = mergedActors.reduce((sum, actor) => sum + rowForActor(actor, actorRowId(actor)).currentDps, 0);
+  const namedActors = mergedActors.filter((actor) => actor.displayName !== undefined);
+  const unidentifiedActorIds = displayed.filter(({ actor }) => actor.displayName === undefined).flatMap(({ actor }) => actor.actorIds);
+  const normalizedPersonalName = normalizeName(personalName);
+  const selectedPersonalActor = personalActorId === undefined ? undefined : mergedActors.find((actor) => actor.actorIds.includes(personalActorId));
+  const personalActor = selectedPersonalActor ?? (normalizedPersonalName ? namedActors.find((actor) => normalizeName(actor.displayName ?? "") === normalizedPersonalName) : undefined);
+  const personalMatch = selectedPersonalActor ? "matched" : personalActorId !== undefined ? "missing" : !normalizedPersonalName ? "unconfigured" : personalActor ? "matched" : "missing";
+  const personalStartMs = personalActor?.firstDamageAtMs ?? encounter.startedAtMs;
+  const personalDurationMs = Math.max(minimumDurationMs, (personalActor?.lastDamageAtMs ?? personalStartMs) - personalStartMs);
+  const personal = personalActor === undefined ? undefined : actorRow(personalActor, actorRowId(personalActor), personalStartMs, personalDurationMs, totalDamage, snapshotNowMs, minimumDurationMs, personalActor.displayName === undefined, "actor");
+  return {
+    id: encounter.id,
+    startedAtMs: encounter.startedAtMs,
+    lastDamageAtMs: encounter.lastDamageAtMs,
+    ...encounter.endedAtMs === undefined ? {} : { endedAtMs: encounter.endedAtMs },
+    durationMs,
+    totalDamage,
+    partyDps: perSecond(totalDamage, durationMs),
+    partyCurrentDps,
+    actors,
+    unidentifiedActorIds,
+    personalName,
+    personalMatch,
+    ...personalMatch === "matched" && personal ? { personal } : {}
+  };
+}
+function actorRow(actor, rowId, startedAtMs, durationMs, partyDamage, nowMs, minimumDurationMs, isUnidentified, alignment) {
+  const skills = [...actor.skills.values()].map((skill) => ({
+    ...skill,
+    dps: perSecond(skill.damage, durationMs),
+    contribution: actor.damage === 0 ? 0 : skill.damage / actor.damage,
+    ...skill.hits === 0 ? {} : { critRate: skill.criticalHits / skill.hits }
+  })).sort(compareRows);
+  const series = alignment === "actor" ? actor.actorSeries : actor.encounterSeries;
+  return {
+    rowId,
+    actorIds: [...actor.actorIds],
+    displayName: actor.displayName ?? (isUnidentified ? unidentifiedLabel(actor) : "Unknown"),
+    ...actor.archetype === undefined ? {} : { archetype: actor.archetype },
+    durationMs,
+    ...actor.lastDamageAtMs === undefined ? {} : { lastDamageAtMs: actor.lastDamageAtMs },
+    damage: actor.damage,
+    dps: perSecond(actor.damage, durationMs),
+    currentDps: actor.currentRate.rateAt(nowMs, { fromMs: startedAtMs, minimumMs: minimumDurationMs }),
+    contribution: partyDamage === 0 ? 0 : actor.damage / partyDamage,
+    hits: actor.hits,
+    criticalHits: actor.criticalHits,
+    ...actor.hits === 0 ? {} : { critRate: actor.criticalHits / actor.hits },
+    kills: actor.kills,
+    mobsHit: actor.targetIds.size,
+    skills,
+    timeline: seriesPoints(series, durationMs),
+    ...isUnidentified ? { isUnidentified: true } : {}
+  };
+}
+function unidentifiedLabel(actor) {
+  return `Unidentified (${Math.min(...actor.actorIds)})`;
+}
+function displayActorAggregates(encounter, options = {}) {
+  return visibleDisplayGroups(mergeActors(encounter.actors), encounter, options);
+}
+function visibleDisplayGroups(mergedActors, encounter, options) {
+  const snapshotNowMs = Math.max(options.snapshotNowMs ?? encounter.lastDamageAtMs, encounter.lastDamageAtMs);
+  const anonymousIdentityGraceMs = options.anonymousIdentityGraceMs ?? DEFAULT_ANONYMOUS_IDENTITY_GRACE_MS;
+  return mergedActors.filter((actor) => actor.displayName !== undefined || options.includeAllAnonymous === true || encounter.endedAtMs !== undefined || options.personalActorId !== undefined && actor.actorIds.includes(options.personalActorId) || actor.firstDamageAtMs === undefined || snapshotNowMs - actor.firstDamageAtMs >= anonymousIdentityGraceMs).map((actor) => ({ rowId: actorRowId(actor), actor }));
+}
+function actorRowId(actor) {
+  const displayName = actor.displayName?.trim();
+  if (displayName)
+    return `name:${normalizeName(displayName)}`;
+  if (actor.uid !== undefined)
+    return `uid:${actor.uid}`;
+  if (actor.ownerConnectionId !== undefined)
+    return `owner:${actor.ownerConnectionId}`;
+  return `actor:${actor.actorId}`;
+}
+function mergeActors(actors) {
+  const merged = new Map;
+  for (const actor of actors) {
+    if (actor.damage <= 0)
+      continue;
+    const displayName = actor.displayName?.trim() || undefined;
+    const key = actorRowId(actor);
+    let target = merged.get(key);
+    if (!target) {
+      target = {
+        ...createActor(actor.actorId, actor.encounterSeries.originMs, actor.currentRate.emptyLike()),
+        ...displayName === undefined ? {} : { displayName },
+        activeIdentity: actor.activeIdentity,
+        ...actor.archetype === undefined ? {} : { archetype: actor.archetype },
+        ...actor.ownerConnectionId === undefined ? {} : { ownerConnectionId: actor.ownerConnectionId },
+        ...actor.uid === undefined ? {} : { uid: actor.uid }
+      };
+      merged.set(key, target);
+    }
+    if (actor.activeIdentity && actor.archetype !== undefined) {
+      target.archetype = actor.archetype;
+    } else if (target.archetype === undefined) {
+      target.archetype = actor.archetype;
+    }
+    target.activeIdentity ||= actor.activeIdentity;
+    accumulate(target, actor);
+  }
+  return [...merged.values()];
+}
+function accumulate(target, actor) {
+  target.damage += actor.damage;
+  target.firstDamageAtMs = minDefined(target.firstDamageAtMs, actor.firstDamageAtMs);
+  target.lastDamageAtMs = maxDefined(target.lastDamageAtMs, actor.lastDamageAtMs);
+  target.hits += actor.hits;
+  target.criticalHits += actor.criticalHits;
+  target.kills += actor.kills;
+  target.actorIds = [...new Set([...target.actorIds, ...actor.actorIds])];
+  for (const targetId of actor.targetIds)
+    target.targetIds.add(targetId);
+  for (const [targetId, damage] of actor.targetDamage) {
+    target.targetDamage.set(targetId, (target.targetDamage.get(targetId) ?? 0) + damage);
+  }
+  for (const [targetId, skills] of actor.enemySkills) {
+    const targetSkills = target.enemySkills.get(targetId) ?? new Map;
+    target.enemySkills.set(targetId, targetSkills);
+    for (const [sourceId, stats] of skills) {
+      const current = targetSkills.get(sourceId) ?? { sourceLabel: stats.sourceLabel, damage: 0, hits: 0, criticalHits: 0 };
+      current.sourceLabel = stats.sourceLabel;
+      current.damage += stats.damage;
+      current.hits += stats.hits;
+      current.criticalHits += stats.criticalHits;
+      targetSkills.set(sourceId, current);
+    }
+  }
+  target.currentRate.add(actor.currentRate);
+  addSeries(target.encounterSeries, actor.encounterSeries);
+  if (target.actorSeries.buckets.length === 0) {
+    target.actorSeries = { ...actor.actorSeries, buckets: [...actor.actorSeries.buckets] };
+  } else {
+    if (actor.actorSeries.originMs < target.actorSeries.originMs) {
+      rebase(target.actorSeries, actor.actorSeries.originMs);
+    }
+    addSeries(target.actorSeries, actor.actorSeries);
+  }
+  for (const skill of actor.skills.values()) {
+    const current = target.skills.get(skill.sourceId);
+    if (current) {
+      current.sourceLabel = skill.sourceLabel;
+      current.damage += skill.damage;
+      current.hits += skill.hits;
+      current.criticalHits += skill.criticalHits;
+    } else {
+      target.skills.set(skill.sourceId, { ...skill });
+    }
+  }
+}
+function rebase(series, originMs) {
+  const shift = Math.round((series.originMs - originMs) / series.widthMs);
+  if (shift <= 0) {
+    series.originMs = originMs;
+    return;
+  }
+  series.buckets = [...new Array(shift).fill(0), ...series.buckets];
+  series.originMs = originMs;
+}
+function compareRows(left, right) {
+  return right.damage - left.damage || (left.sourceLabel ?? left.displayName ?? "").localeCompare(right.sourceLabel ?? right.displayName ?? "");
+}
+function perSecond(damage, durationMs) {
+  return damage / (durationMs / 1000);
+}
+function normalizeName(name) {
+  return name.normalize("NFC").trim().toLowerCase();
+}
+function minDefined(left, right) {
+  if (left === undefined)
+    return right;
+  if (right === undefined)
+    return left;
+  return Math.min(left, right);
+}
+function maxDefined(left, right) {
+  if (left === undefined)
+    return right;
+  if (right === undefined)
+    return left;
+  return Math.max(left, right);
+}
+
+// src/status-tracker.ts
+var REFRESHING_FEEDS = new Set(["ApplyEffectDisplays_O", "ApplySkillDisplay_O"]);
+var EXPIRY_REFRESH_TOLERANCE_MS = 2000;
+var KEEP_ALIVE_GRACE_MS = 1000;
+
+class FishNetStatusTracker {
+  directory;
+  skillDirectory;
+  active = new Map;
+  identities = new Map;
+  actorIdByUid = new Map;
+  revisionValue = 0;
+  nextExpiryRevision = -1;
+  nextExpiry;
+  constructor(options = {}) {
+    this.directory = new FishNetStatusDirectory(options.statusCatalog ?? loadBundledStatusCatalog());
+    this.skillDirectory = new FishNetSkillDirectory(options.skillCatalog ?? loadBundledSkillCatalog2());
+  }
+  get revision() {
+    return this.revisionValue;
+  }
+  nextExpiryAtMs() {
+    if (this.nextExpiryRevision === this.revisionValue)
+      return this.nextExpiry;
+    let earliest;
+    for (const statuses of this.active.values()) {
+      for (const tracked of statuses.values()) {
+        if (tracked.expiresAtMs === undefined)
+          continue;
+        if (earliest === undefined || tracked.expiresAtMs < earliest)
+          earliest = tracked.expiresAtMs;
+      }
+    }
+    this.nextExpiry = earliest;
+    this.nextExpiryRevision = this.revisionValue;
+    return earliest;
+  }
+  touch() {
+    this.revisionValue += 1;
+  }
+  consume(event, observedAtMs) {
+    if (event.kind === "status")
+      this.consumeStatus(event, observedAtMs);
+    else if (event.kind === "summon")
+      this.consumeSummon(event, observedAtMs);
+    else if (event.kind === "activation")
+      this.consumeActivation(event, observedAtMs);
+    else if (event.kind === "death" && this.active.delete(event.targetId))
+      this.touch();
+  }
+  consumeIdentity(event) {
+    if (event.operation === "reset") {
+      this.identities.clear();
+      if (this.active.size > 0)
+        this.touch();
+      this.active.clear();
+      return;
+    }
+    if (event.operation === "remove") {
+      this.identities.delete(event.actorId);
+      if (this.active.delete(event.actorId))
+        this.touch();
+      return;
+    }
+    if (event.uid) {
+      const previousActorId = this.actorIdByUid.get(event.uid);
+      if (previousActorId !== undefined && previousActorId !== event.actorId) {
+        this.migrateActive(previousActorId, event.actorId);
+      }
+      this.actorIdByUid.set(event.uid, event.actorId);
+    }
+    this.identities.set(event.actorId, event.displayName);
+  }
+  migrateActive(fromActorId, toActorId) {
+    const fromStatuses = this.active.get(fromActorId);
+    if (!fromStatuses)
+      return;
+    this.active.delete(fromActorId);
+    const toStatuses = this.active.get(toActorId) ?? new Map;
+    for (const [statusId, tracked] of fromStatuses) {
+      if (!toStatuses.has(statusId))
+        toStatuses.set(statusId, tracked);
+    }
+    this.active.set(toActorId, toStatuses);
+    this.touch();
+  }
+  consumeStatus(event, observedAtMs) {
+    if (event.actorIdentity)
+      this.identities.set(event.actorId, event.actorIdentity.displayName);
+    const statuses = this.active.get(event.actorId) ?? new Map;
+    if (event.action === "removed") {
+      if (statuses.delete(event.statusId))
+        this.touch();
+      if (statuses.size === 0)
+        this.active.delete(event.actorId);
+      else
+        this.active.set(event.actorId, statuses);
+      return;
+    }
+    const previous = statuses.get(event.statusId);
+    const level = event.level ?? previous?.level ?? 1;
+    const expiresAtMs = this.resolveExpiry(event, level, observedAtMs, previous);
+    const tracked = {
+      level,
+      appliedAtMs: REFRESHING_FEEDS.has(event.rpc) ? previous?.appliedAtMs ?? observedAtMs : observedAtMs,
+      ...expiresAtMs === undefined ? {} : { expiresAtMs },
+      ...event.stacks === undefined ? {} : { stacks: event.stacks }
+    };
+    statuses.set(event.statusId, tracked);
+    this.active.set(event.actorId, statuses);
+    if (!sameTracked(previous, tracked))
+      this.touch();
+  }
+  isTimed(statusId, level) {
+    return statusDurationSeconds(this.directory.resolve(statusId), level) !== undefined;
+  }
+  resolveExpiry(event, level, observedAtMs, previous) {
+    if (event.remainingSeconds !== undefined) {
+      const reported = observedAtMs + event.remainingSeconds * 1000;
+      if (!this.isTimed(event.statusId, level))
+        return reported + KEEP_ALIVE_GRACE_MS;
+      const established = previous?.expiresAtMs;
+      if (established !== undefined && reported > established && reported - established < EXPIRY_REFRESH_TOLERANCE_MS) {
+        return established;
+      }
+      return reported;
+    }
+    if (event.rpc === "ApplyEffectDisplays_O")
+      return;
+    if (event.rpc === "ApplySkillDisplay_O")
+      return previous?.expiresAtMs;
+    const durationSeconds = statusDurationSeconds(this.directory.resolve(event.statusId), level);
+    return durationSeconds === undefined ? undefined : observedAtMs + durationSeconds * 1000;
+  }
+  consumeSummon(event, observedAtMs) {
+    if (event.actorIdentity)
+      this.identities.set(event.actorId, event.actorIdentity.displayName);
+    const statuses = this.active.get(event.actorId) ?? new Map;
+    if (event.stacks <= 0) {
+      if (statuses.delete(event.skillId))
+        this.touch();
+      if (statuses.size === 0)
+        this.active.delete(event.actorId);
+      else
+        this.active.set(event.actorId, statuses);
+      return;
+    }
+    const previous = statuses.get(event.skillId);
+    const tracked = { level: 1, stacks: event.stacks, appliedAtMs: observedAtMs, summon: true };
+    statuses.set(event.skillId, tracked);
+    this.active.set(event.actorId, statuses);
+    if (!sameTracked(previous, tracked))
+      this.touch();
+  }
+  consumeActivation(event, observedAtMs) {
+    if (event.phase === "interrupt" || event.phase === "cancel")
+      return;
+    if (!event.sourceId)
+      return;
+    const statuses = this.active.get(event.actorId);
+    if (!statuses)
+      return;
+    for (const [statusId, tracked] of statuses) {
+      if (tracked.summon)
+        continue;
+      const definition = this.directory.resolve(statusId);
+      const isGranter = statusId === event.sourceId || definition?.effects.some((effect) => effect.id === event.sourceId);
+      if (!isGranter)
+        continue;
+      const sourceEffect = definition?.effects.find((effect) => effect.id === event.sourceId);
+      const durationDefinition = definition && sourceEffect ? { ...definition, effects: [sourceEffect] } : definition;
+      const durationSeconds = statusDurationSeconds(durationDefinition, event.level ?? tracked.level);
+      const expiresAtMs = durationSeconds === undefined ? undefined : observedAtMs + durationSeconds * 1000;
+      if (tracked.appliedAtMs !== observedAtMs || tracked.expiresAtMs !== expiresAtMs)
+        this.touch();
+      tracked.appliedAtMs = observedAtMs;
+      tracked.expiresAtMs = expiresAtMs;
+    }
+  }
+  advance(nowMs) {
+    let expired = false;
+    for (const [actorId, statuses] of this.active) {
+      for (const [statusId, tracked] of statuses) {
+        if (tracked.expiresAtMs !== undefined && tracked.expiresAtMs <= nowMs) {
+          statuses.delete(statusId);
+          expired = true;
+        }
+      }
+      if (statuses.size === 0)
+        this.active.delete(actorId);
+    }
+    if (expired)
+      this.touch();
+  }
+  getActiveStatuses(actorId, nowMs) {
+    const statuses = this.active.get(actorId);
+    if (!statuses)
+      return [];
+    const result = [];
+    for (const [statusId, tracked] of statuses) {
+      if (tracked.expiresAtMs !== undefined && tracked.expiresAtMs <= nowMs)
+        continue;
+      const definition = this.directory.resolve(statusId);
+      const skillDefinition = this.skillDirectory.resolve(statusId);
+      const spriteId = definition?.spriteId ?? skillDefinition?.spriteId;
+      const timed = statusDurationSeconds(definition, tracked.level) !== undefined;
+      result.push({
+        statusId,
+        displayName: definition?.displayName ?? skillDefinition?.displayName ?? statusId,
+        ...spriteId === undefined ? {} : { spriteId },
+        isDebuff: definition?.isDebuff ?? false,
+        level: tracked.level,
+        appliedAtMs: tracked.appliedAtMs,
+        ...tracked.stacks === undefined ? {} : { stacks: tracked.stacks },
+        ...tracked.expiresAtMs === undefined || !timed ? {} : { expiresAtMs: tracked.expiresAtMs, remainingMs: Math.max(0, tracked.expiresAtMs - nowMs) }
+      });
+    }
+    return result.sort((left, right) => left.appliedAtMs - right.appliedAtMs);
+  }
+  getActiveStatusesForActors(actorIds, nowMs) {
+    const byStatusId = new Map;
+    for (const actorId of actorIds) {
+      for (const status of this.getActiveStatuses(actorId, nowMs)) {
+        const current = byStatusId.get(status.statusId);
+        if (!current || status.appliedAtMs > current.appliedAtMs)
+          byStatusId.set(status.statusId, status);
+      }
+    }
+    return [...byStatusId.values()].sort((left, right) => left.appliedAtMs - right.appliedAtMs);
+  }
+  getActiveStatusesForName(personalName, nowMs) {
+    const normalized = normalizeName(personalName);
+    if (!normalized)
+      return [];
+    const actorIds = [...this.identities].filter(([, displayName]) => normalizeName(displayName) === normalized).map(([actorId]) => actorId);
+    return this.getActiveStatusesForActors(actorIds, nowMs);
+  }
+  reset() {
+    if (this.active.size > 0)
+      this.touch();
+    this.active.clear();
+    this.identities.clear();
+    this.actorIdByUid.clear();
+  }
+}
+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";
+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;
+      continue;
+    }
+    if (isLogStreamHeader(candidate))
+      continue;
+    const record = parseLogRecord(candidate);
+    if (!record) {
+      invalidLines += 1;
+      continue;
+    }
+    const event = parseDpsLogRecord(record.type, record.data);
+    if (event === null)
+      continue;
+    if (!event) {
+      invalidLines += 1;
+      continue;
+    }
+    const recordedAtMs = Date.parse(record.recordedAt);
+    recordedAtOriginMs ??= recordedAtMs;
+    lastTime = Math.max(lastTime, recordedAtMs - recordedAtOriginMs);
+    if (event.kind === "actorIdentity")
+      reducer.consumeIdentity(event, lastTime);
+    else
+      reducer.consumeCombat(event, lastTime);
+  }
+  reducer.reset(lastTime);
+  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;
+  if (value["kind"] === "actorIdentity") {
+    if (value["operation"] === "reset")
+      return value;
+    if (!isFiniteNumber(value["actorId"]))
+      return;
+    if (value["operation"] === "remove")
+      return value;
+    if (value["operation"] === "upsert" && typeof value["displayName"] === "string" && value["displayName"].length > 0) {
+      return value;
+    }
+    return;
+  }
+  if (value["kind"] === "monsterIdentity") {
+    if (value["operation"] === "reset")
+      return value;
+    if (!isFiniteNumber(value["actorId"]))
+      return;
+    if (value["operation"] === "remove")
+      return value;
+    if (value["operation"] === "upsert" && typeof value["mobId"] === "string" && value["mobId"].length > 0 && typeof value["displayName"] === "string" && value["displayName"].length > 0) {
+      return value;
+    }
+    return;
+  }
+  if (value["kind"] === "activation")
+    return value;
+  if (value["kind"] === "status") {
+    if (!isFiniteNumber(value["actorId"]) || typeof value["statusId"] !== "string" || value["level"] !== undefined && !isFiniteNumber(value["level"]) || value["remainingSeconds"] !== undefined && !isFiniteNumber(value["remainingSeconds"]) || value["action"] !== "applied" && value["action"] !== "removed")
+      return;
+    return value;
+  }
+  if (value["kind"] === "summon") {
+    if (!isFiniteNumber(value["actorId"]) || typeof value["skillId"] !== "string" || value["skillId"].length === 0 || !isFiniteNumber(value["stacks"]) || !Number.isInteger(value["stacks"]) || value["stacks"] < 0)
+      return;
+    return value;
+  }
+  if (value["kind"] === "heal") {
+    if (!isFiniteNumber(value["targetId"]) || !isFiniteNumber(value["value"]))
+      return;
+    if (value["recoveryStyle"] !== undefined && value["recoveryStyle"] !== "standard" && value["recoveryStyle"] !== "passive-regeneration" && value["recoveryStyle"] !== "drain" && value["recoveryStyle"] !== "unknown")
+      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")
+    return;
+  return value;
+}
+function parseDpsLogRecord(type, data) {
+  if (type !== "combat.actorIdentity" && type !== "combat.event")
+    return null;
+  const event = parseDpsLogEvent(data);
+  if (!event)
+    return;
+  if (type === "combat.actorIdentity" && event.kind !== "actorIdentity")
+    return;
+  if (type === "combat.event" && event.kind === "actorIdentity")
+    return;
+  return event;
+}
+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";
+function decodeCombatCaptureJsonLines(text, options) {
+  const replay = new CombatCaptureReplay(options);
+  for (const line of text.split(/\r?\n/))
+    replay.consumeLine(line);
+  return replay.result();
+}
+async function replayCombatCapture(path, options) {
+  return replayCombatCaptures([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()))
+      replay.consumeLine(line);
+  }
+  return replay.result();
+}
+
+class CombatCaptureReplay {
+  options;
+  session = new FishNetSessionDecoder(loadBundledFishNetRpcMap2());
+  datagrams = 0;
+  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")
+      return;
+    const packet = parseUdpRecord(record.data);
+    if (!packet) {
+      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);
+          }
+        }
+      }
+    } catch {
+      this.decodeWarnings += 1;
+    }
+  }
+  result() {
+    return {
+      datagrams: this.datagrams,
+      combatEvents: this.combatEvents,
+      identityEvents: this.identityEvents,
+      invalidLines: this.invalidLines,
+      decodeWarnings: this.decodeWarnings
+    };
+  }
+}
+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";
+async function readCombatReplaySummary(path) {
+  const replay = await loadDpsReplay(path);
+  const encounters = replay.snapshots;
+  return {
+    encounters: encounters.length,
+    totalDamage: encounters.reduce((total, encounter) => total + encounter.totalDamage, 0),
+    durationMs: encounters.reduce((total, encounter) => total + encounter.durationMs, 0),
+    invalidLines: replay.invalidLines
+  };
+}
+async function formatCombatReplaySummary(path) {
+  return formatSummary(await readCombatReplaySummary(path));
+}
+async function inspectCombatReplaySummary(path) {
+  const summary = await readCombatReplaySummary(path);
+  return { recordCount: summary.encounters, summary: formatSummary(summary) };
+}
+function formatSummary(summary) {
+  return `${count(summary.encounters, "encounter")} \xB7 ${compact(summary.totalDamage)} damage \xB7 ${duration(summary.durationMs)}${warnings(summary.invalidLines)}`;
+}
+function duration(milliseconds) {
+  const seconds = Math.round(milliseconds / 1000);
+  return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+}
+// src/history/domain.ts
+var COMBAT_DOMAIN_VERSION = 7;
+var COMBAT_DOMAIN_NAME = "combat";
+var SCHEMA = `
+create table if not exists combat_encounters (
+  session_id text not null,
+  encounter_id text not null,
+  started_at_ms integer not null,
+  last_damage_at_ms integer not null,
+  ended_at_ms integer,
+  total_damage integer not null default 0,
+  primary key (session_id, encounter_id)
+);
+create index if not exists combat_encounters_by_start on combat_encounters (session_id, started_at_ms, encounter_id);
+
+-- Reducer state scoped to the whole stream, not to one encounter: the actor identity map, the
+-- monster names seen so far, and the death-log lookback buffer. All bounded. This is kept per
+-- session because an incremental pass creates a fresh reducer each time and there is frequently no
+-- encounter open at the boundary \u2014 between fights, and always before the first one.
+create table if not exists combat_stream_state (
+  session_id text not null primary key,
+  identities_json text not null default '[]',
+  mob_identities_json text not null default '[]',
+  recent_hits_json text not null default '[]',
+  -- Lines that were not a valid log record, accumulated across passes so the figure covers the whole
+  -- stream rather than whichever slice the last incremental pass happened to read.
+  invalid_lines integer not null default 0
+);
+create index if not exists combat_encounters_open on combat_encounters (session_id) where ended_at_ms is null;
+
+-- One row set per meter: "dps" is outgoing party damage, "tanked" is incoming damage grouped by the
+-- party member taking it, and "healing" is restored health grouped by the healer. All three share
+-- these tables because they accumulate identically and render through the same code.
+create table if not exists combat_actors (
+  session_id text not null,
+  encounter_id text not null,
+  meter text not null default 'dps',
+  -- Position within the encounter's actor list. An actor id can appear more than once when an
+  -- identity is removed and the id is reused, and those aggregates must stay distinct.
+  actor_index integer not null,
+  actor_id integer not null,
+  -- Whether this aggregate is the one further events for actor_id accumulate into.
+  active_slot integer not null default 0,
+  display_name text,
+  archetype integer,
+  owner_connection_id integer,
+  uid text,
+  active_identity integer not null default 0,
+  damage integer not null default 0,
+  first_damage_at_ms integer,
+  last_damage_at_ms integer,
+  hits integer not null default 0,
+  critical_hits integer not null default 0,
+  kills 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.
+  ewma_rate real not null default 0,
+  ewma_at_ms integer not null default 0,
+  -- The decay constant the rate was accumulated with. Stored rather than assumed because the rate
+  -- only means anything paired with it, so a reader rebuilds the estimator that produced the value.
+  ewma_tau_seconds real not null default 2.5,
+  primary key (session_id, encounter_id, meter, actor_index)
+);
+
+create table if not exists combat_skills (
+  session_id text not null,
+  encounter_id text not null,
+  meter text not null default 'dps',
+  actor_index integer not null,
+  source_id text not null,
+  source_label text not null,
+  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, meter, actor_index, source_id)
+);
+
+create table if not exists combat_targets (
+  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,
+  damage integer not null default 0,
+  primary key (session_id, encounter_id, meter, actor_index, target_id)
+);
+
+create table if not exists combat_timeline_buckets (
+  session_id text not null,
+  encounter_id text not null,
+  meter text not null default 'dps',
+  actor_index integer not null,
+  -- "encounter" buckets start at the encounter; "actor" buckets start at that actor's first damage,
+  -- which is the alignment the personal row uses.
+  origin text not null,
+  origin_ms integer not null,
+  width_ms integer not null,
+  bucket_index integer not null,
+  damage integer not null default 0,
+  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.
+create table if not exists combat_enemy_skills (
+  session_id text not null,
+  encounter_id text not null,
+  actor_index integer not null,
+  target_id integer not null,
+  source_id text not null,
+  source_label text not null,
+  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)
+);
+
+create table if not exists combat_enemies (
+  session_id text not null,
+  encounter_id text not null,
+  target_id integer not null,
+  display_name text,
+  first_seen_at_ms integer not null,
+  primary key (session_id, encounter_id, target_id)
+);
+
+create table if not exists combat_deaths (
+  session_id text not null,
+  encounter_id text not null,
+  death_index integer not null,
+  victim_name text not null,
+  target_id integer not null,
+  died_at_ms integer not null,
+  total_damage integer not null default 0,
+  primary key (session_id, encounter_id, death_index)
+);
+create index if not exists combat_deaths_by_time on combat_deaths (session_id, died_at_ms, death_index);
+
+create table if not exists combat_death_hits (
+  session_id text not null,
+  encounter_id text not null,
+  death_index integer not null,
+  hit_index integer not null,
+  before_death_ms integer not null,
+  attacker_actor_id integer not null,
+  attacker_label text not null,
+  attacker_is_monster integer not null default 0,
+  source_label text not null,
+  damage integer not null default 0,
+  critical integer not null default 0,
+  primary key (session_id, encounter_id, death_index, hit_index)
+);
+`;
+function createCombatDomain() {
+  return {
+    name: COMBAT_DOMAIN_NAME,
+    version: COMBAT_DOMAIN_VERSION,
+    createSchema(database) {
+      database.exec(SCHEMA);
+    },
+    dropSchema(database) {
+      for (const table of [
+        "combat_stream_state",
+        "combat_death_hits",
+        "combat_deaths",
+        "combat_enemies",
+        "combat_enemy_skills",
+        "combat_timeline_buckets",
+        "combat_targets",
+        "combat_skills",
+        "combat_actors",
+        "combat_encounters"
+      ]) {
+        database.exec(`drop table if exists ${table}`);
+      }
+    }
+  };
+}
+// src/reducers/meter.ts
+class MeterReducer {
+  kind;
+  current;
+  currentTauSeconds;
+  maxTimelineBuckets;
+  constructor(options) {
+    this.kind = options.kind;
+    this.currentTauSeconds = positiveTau(options.currentTauSeconds ?? DEFAULT_CURRENT_TAU_SECONDS);
+    this.maxTimelineBuckets = options.maxTimelineBuckets ?? Number.POSITIVE_INFINITY;
+  }
+  begin(id, startedAtMs) {
+    this.current = {
+      id,
+      startedAtMs,
+      lastDamageAtMs: startedAtMs,
+      actors: [],
+      activeActors: new Map,
+      enemyFirstSeenAtMs: new Map,
+      enemyNames: new Map,
+      deaths: []
+    };
+    return this.current;
+  }
+  resume(encounter) {
+    this.current = encounter;
+  }
+  finish(endedAtMs) {
+    const encounter = this.current;
+    if (!encounter)
+      return;
+    encounter.endedAtMs = Math.max(endedAtMs, encounter.lastDamageAtMs);
+    this.current = undefined;
+    return encounter;
+  }
+  reset() {
+    this.current = undefined;
+  }
+  consumeIdentity(event) {
+    if (!this.current || event.operation !== "upsert")
+      return;
+    const actor = this.current.activeActors.get(event.actorId);
+    if (!actor)
+      return;
+    actor.displayName = event.displayName;
+    if (event.archetype !== undefined)
+      actor.archetype = event.archetype;
+    actor.activeIdentity = true;
+  }
+  consumeCombat(event, observedAtMs, identities) {
+    if (!this.current)
+      return;
+    const hit = this.kind === "tanked" ? tankedHit(event, identities) : healingHit(event, identities);
+    if (!hit)
+      return;
+    this.apply(hit, observedAtMs);
+  }
+  apply(hit, observedAtMs) {
+    const encounter = this.current;
+    encounter.lastDamageAtMs = Math.max(encounter.lastDamageAtMs, observedAtMs);
+    let actor = encounter.activeActors.get(hit.actorId);
+    if (!actor) {
+      actor = createActor(hit.actorId, encounter.startedAtMs, this.currentTauSeconds);
+      encounter.actors.push(actor);
+      encounter.activeActors.set(hit.actorId, actor);
+    }
+    if (hit.identity) {
+      actor.displayName = hit.identity.displayName;
+      if (hit.identity.archetype !== undefined)
+        actor.archetype = hit.identity.archetype;
+      actor.activeIdentity = true;
+    }
+    recordHit(actor, { ...hit, atMs: observedAtMs }, this.maxTimelineBuckets);
+    if (hit.counterpartId !== undefined)
+      actor.targetIds.add(hit.counterpartId);
+  }
+}
+function tankedHit(event, identities) {
+  if (event.kind !== "damage" && event.kind !== "death")
+    return;
+  const identity = identities.get(event.targetId);
+  const reflected = event.team === 0 && event.actorId === event.targetId;
+  const incoming = event.team !== 0 && event.actorId !== event.targetId;
+  if (!identity && !reflected && !incoming)
+    return;
+  if (!isPositiveHit(event))
+    return;
+  return {
+    actorId: event.targetId,
+    ...identity === undefined ? {} : { identity },
+    counterpartId: event.actorId,
+    value: event.value,
+    sourceId: event.sourceId,
+    sourceLabel: event.sourceLabel,
+    critical: event.hitResult === "critical"
+  };
+}
+function healingHit(event, identities) {
+  if (event.kind !== "heal")
+    return;
+  if (!Number.isFinite(event.value) || event.value <= 0)
+    return;
+  const healerId = event.actorId ?? event.targetId;
+  const identity = identities.get(healerId);
+  if (!identity)
+    return;
+  return {
+    actorId: healerId,
+    identity,
+    counterpartId: event.targetId,
+    value: event.value,
+    sourceId: event.sourceId ?? "heal",
+    sourceLabel: event.sourceLabel ?? "Healing",
+    critical: false
+  };
+}
+
+// src/history/importer.ts
+var METER_KINDS = [
+  { meter: "tanked", kind: "tanked" },
+  { meter: "healing", kind: "healing" }
+];
+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 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);
+    }
+    if (byMeter.size > 0)
+      meterAggregates.set(encounterId, byMeter);
+  };
+  const reducer = new DamageReducer({
+    ...options.idleGapMs === undefined ? {} : { idleGapMs: options.idleGapMs },
+    ...options.currentTauSeconds === undefined ? {} : { currentTauSeconds: options.currentTauSeconds },
+    createEncounterId: () => `enc-${currentSequence}`,
+    onEncounterFinished: (encounter) => {
+      captureMeters(encounter.id);
+      for (const entry of meters)
+        entry.reducer.finish(encounter.endedAtMs ?? encounter.lastDamageAtMs);
+      finished.push(encounter);
+    }
+  });
+  loadStreamState(model, sessionId, reducer);
+  const open = loadOpenEncounter(model, sessionId);
+  if (open) {
+    reducer.resume(open);
+    for (const entry of meters) {
+      entry.reducer.resume(loadMeterAggregate(model, sessionId, open, entry.meter));
+    }
+  }
+  const request = {
+    sessionId,
+    stream: "combat",
+    domain: COMBAT_DOMAIN_NAME,
+    sourcePath,
+    ...options.batchBytes === undefined ? {} : { batchBytes: options.batchBytes },
+    apply(records) {
+      const previouslyOpen = reducer.current?.id;
+      for (const record of records) {
+        consume(reducer, meters, record, (sequence, observedAtMs) => {
+          currentSequence = sequence;
+          lastObservedAtMs = observedAtMs;
+        });
+      }
+      for (const encounter of finished.splice(0)) {
+        writeEncounter(model, sessionId, encounter, reducer, meterAggregates.get(encounter.id));
+        meterAggregates.delete(encounter.id);
+      }
+      if (reducer.current) {
+        captureMeters(reducer.current.id);
+        writeEncounter(model, sessionId, reducer.current, reducer, meterAggregates.get(reducer.current.id));
+      } else if (previouslyOpen)
+        clearEncounter(model, sessionId, previouslyOpen, { keepFinished: true });
+      reducer.pruneRecentHits(lastObservedAtMs);
+      writeStreamState(model, sessionId, reducer);
+    },
+    clear(scope, database) {
+      for (const table of TABLES) {
+        database.query(`delete from ${table} where session_id = $sessionId`).run({ sessionId: scope.sessionId });
+      }
+      reducer.current = undefined;
+      reducer.identities.clear();
+      reducer.mobIdentities.clear();
+      reducer.recentHits.clear();
+      for (const entry of meters)
+        entry.reducer.reset();
+      meterAggregates.clear();
+      finished.length = 0;
+    }
+  };
+  const result = await model.indexStream(request);
+  recordInvalidLines(model, sessionId, result.invalidLines, result.rebuilt);
+  if (options.finalize && reducer.current) {
+    model.transaction(() => {
+      reducer.reset(lastObservedAtMs);
+      for (const encounter of finished.splice(0)) {
+        writeEncounter(model, sessionId, encounter, reducer, meterAggregates.get(encounter.id));
+        meterAggregates.delete(encounter.id);
+      }
+    });
+  }
+  return result;
+}
+var TABLES = [
+  "combat_stream_state",
+  "combat_death_hits",
+  "combat_deaths",
+  "combat_enemies",
+  "combat_enemy_skills",
+  "combat_timeline_buckets",
+  "combat_targets",
+  "combat_skills",
+  "combat_actors",
+  "combat_encounters"
+];
+function statements(model) {
+  return { query: (sql) => model.statement(sql) };
+}
+function consume(reducer, meters, record, note) {
+  const event = parseDpsLogRecord(record.type, record.data);
+  if (!event)
+    return;
+  const observedAtMs = Date.parse(record.recordedAt);
+  if (!Number.isFinite(observedAtMs))
+    return;
+  note(record.sequence, observedAtMs);
+  if (event.kind === "actorIdentity") {
+    reducer.consumeIdentity(event, observedAtMs);
+    for (const entry of meters)
+      entry.reducer.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);
+  }
+}
+function writeEncounter(model, sessionId, encounter, reducer, meterAggregates) {
+  const database = statements(model);
+  writeEnemiesAndDeaths(model, sessionId, encounter, reducer.mobIdentities);
+  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)
+      values ($sessionId, $encounterId, $startedAtMs, $lastDamageAtMs, $endedAtMs, $totalDamage)`).run({
+    sessionId,
+    encounterId: encounter.id,
+    startedAtMs: encounter.startedAtMs,
+    lastDamageAtMs: encounter.lastDamageAtMs,
+    endedAtMs: encounter.endedAtMs ?? null,
+    totalDamage
+  });
+  writeActors(model, sessionId, encounter, "dps");
+  for (const [meter, aggregate] of meterAggregates ?? [])
+    writeActors(model, sessionId, aggregate, meter, encounter.id);
+}
+function writeActors(model, sessionId, aggregate, meter, encounterId = aggregate.id) {
+  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)
+        values ($sessionId, $encounterId, $meter, $actorIndex, $actorId, $activeSlot, $displayName, $archetype, $ownerConnectionId, $uid,
+                $activeIdentity, $damage, $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)`);
+  const insertTarget = database.query(`insert or replace into combat_targets
+    (session_id, encounter_id, meter, actor_index, target_id, damage)
+    values ($sessionId, $encounterId, $meter, $actorIndex, $targetId, $damage)`);
+  const insertBucket = database.query(`insert or replace into combat_timeline_buckets
+    (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)`);
+  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`);
+  for (const [actorIndex, actor] of aggregate.actors.entries()) {
+    insertActor.run({
+      sessionId,
+      encounterId,
+      meter,
+      actorIndex,
+      actorId: actor.actorId,
+      activeSlot: aggregate.activeActors.get(actor.actorId) === actor ? 1 : 0,
+      displayName: actor.displayName ?? null,
+      archetype: actor.archetype ?? null,
+      ownerConnectionId: actor.ownerConnectionId ?? null,
+      uid: actor.uid ?? null,
+      activeIdentity: actor.activeIdentity ? 1 : 0,
+      damage: actor.damage,
+      firstDamageAtMs: actor.firstDamageAtMs ?? null,
+      lastDamageAtMs: actor.lastDamageAtMs ?? null,
+      hits: actor.hits,
+      criticalHits: actor.criticalHits,
+      kills: actor.kills,
+      ewmaRate: actor.currentRate.state().rate,
+      ewmaAtMs: actor.currentRate.state().updatedAtMs,
+      ewmaTauSeconds: actor.currentRate.tauSeconds
+    });
+    for (const skill of actor.skills.values()) {
+      insertSkill.run({
+        sessionId,
+        encounterId,
+        meter,
+        actorIndex,
+        sourceId: skill.sourceId,
+        sourceLabel: skill.sourceLabel,
+        damage: skill.damage,
+        hits: skill.hits,
+        criticalHits: skill.criticalHits
+      });
+    }
+    for (const targetId of actor.targetIds) {
+      insertTarget.run({
+        sessionId,
+        encounterId,
+        meter,
+        actorIndex,
+        targetId,
+        damage: actor.targetDamage.get(targetId) ?? 0
+      });
+    }
+    if (meter === "dps") {
+      for (const [targetId, bySkill] of actor.enemySkills) {
+        for (const [sourceId, stats] of bySkill) {
+          insertEnemySkill.run({
+            sessionId,
+            encounterId,
+            actorIndex,
+            targetId,
+            sourceId,
+            sourceLabel: stats.sourceLabel,
+            damage: stats.damage,
+            hits: stats.hits,
+            criticalHits: stats.criticalHits
+          });
+        }
+      }
+    }
+    for (const [origin, series] of [["encounter", actor.encounterSeries], ["actor", actor.actorSeries]]) {
+      const dirtyFrom = takeDirtyFrom(series);
+      if (dirtyFrom === Number.POSITIVE_INFINITY)
+        continue;
+      if (dirtyFrom === 0) {
+        deleteBucketTail.run({ sessionId, encounterId, meter, actorIndex, origin, bucketCount: series.buckets.length });
+      }
+      for (let bucketIndex = dirtyFrom;bucketIndex < series.buckets.length; bucketIndex += 1) {
+        insertBucket.run({
+          sessionId,
+          encounterId,
+          meter,
+          actorIndex,
+          origin,
+          originMs: series.originMs,
+          widthMs: series.widthMs,
+          bucketIndex,
+          damage: series.buckets[bucketIndex] ?? 0
+        });
+      }
+    }
+  }
+}
+function writeEnemiesAndDeaths(model, sessionId, encounter, mobIdentities) {
+  const database = statements(model);
+  const scope = { sessionId, encounterId: encounter.id };
+  const insertEnemy = database.query(`insert or replace into combat_enemies
+    (session_id, encounter_id, target_id, display_name, first_seen_at_ms)
+    values ($sessionId, $encounterId, $targetId, $displayName, $firstSeenAtMs)`);
+  const insertDeath = database.query(`insert or replace into combat_deaths
+    (session_id, encounter_id, death_index, victim_name, target_id, died_at_ms, total_damage)
+    values ($sessionId, $encounterId, $deathIndex, $victimName, $targetId, $diedAtMs, $totalDamage)`);
+  const insertDeathHit = database.query(`insert or replace into combat_death_hits
+    (session_id, encounter_id, death_index, hit_index, before_death_ms, attacker_actor_id,
+     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) {
+    insertEnemy.run({
+      ...scope,
+      targetId,
+      displayName: encounter.enemyNames.get(targetId) ?? mobIdentities.get(targetId) ?? null,
+      firstSeenAtMs
+    });
+  }
+  for (const [deathIndex, death] of encounter.deaths.entries()) {
+    insertDeath.run({
+      ...scope,
+      deathIndex,
+      victimName: death.victimName,
+      targetId: death.targetId,
+      diedAtMs: death.diedAtMs,
+      totalDamage: death.totalDamage
+    });
+    for (const [hitIndex, hit] of death.hits.entries()) {
+      insertDeathHit.run({
+        ...scope,
+        deathIndex,
+        hitIndex,
+        beforeDeathMs: hit.beforeDeathMs,
+        attackerActorId: hit.attackerActorId,
+        attackerLabel: hit.attackerLabel,
+        attackerIsMonster: hit.attackerIsMonster ? 1 : 0,
+        sourceLabel: hit.sourceLabel,
+        damage: hit.damage,
+        critical: hit.critical ? 1 : 0
+      });
+    }
+  }
+}
+function clearEncounter(model, sessionId, encounterId, options = {}) {
+  const database = statements(model);
+  if (options.keepFinished) {
+    const stored = database.query("select ended_at_ms from combat_encounters where session_id = $sessionId and encounter_id = $encounterId").get({ sessionId, encounterId });
+    if (stored && stored.ended_at_ms !== null)
+      return;
+  }
+  for (const table of TABLES) {
+    database.query(`delete from ${table} where session_id = $sessionId and encounter_id = $encounterId`).run({ sessionId, encounterId });
+  }
+}
+function recordInvalidLines(model, sessionId, invalidLines, rebuilt) {
+  if (invalidLines === 0 && !rebuilt)
+    return;
+  model.transaction(() => {
+    statements(model).query(`insert into combat_stream_state (session_id, invalid_lines) values ($sessionId, $invalidLines)
+        on conflict(session_id) do update set
+          invalid_lines = case when $rebuilt = 1 then $invalidLines else combat_stream_state.invalid_lines + $invalidLines end`).run({ sessionId, invalidLines, rebuilt: rebuilt ? 1 : 0 });
+  });
+}
+function loadStreamState(model, sessionId, reducer) {
+  const row = statements(model).query("select identities_json, mob_identities_json, recent_hits_json from combat_stream_state where session_id = $sessionId").get({ sessionId });
+  if (!row)
+    return;
+  for (const [actorId, identity] of JSON.parse(row.identities_json)) {
+    reducer.identities.set(actorId, identity);
+  }
+  for (const [actorId, name] of JSON.parse(row.mob_identities_json)) {
+    reducer.mobIdentities.set(actorId, name);
+  }
+  for (const [targetId, hits] of JSON.parse(row.recent_hits_json)) {
+    reducer.recentHits.set(targetId, hits);
+  }
+}
+function writeStreamState(model, sessionId, reducer) {
+  statements(model).query(`insert into combat_stream_state
+      (session_id, identities_json, mob_identities_json, recent_hits_json)
+      values ($sessionId, $identitiesJson, $mobIdentitiesJson, $recentHitsJson)
+      on conflict(session_id) do update set
+        identities_json = excluded.identities_json,
+        mob_identities_json = excluded.mob_identities_json,
+        recent_hits_json = excluded.recent_hits_json`).run({
+    sessionId,
+    identitiesJson: JSON.stringify([...reducer.identities]),
+    mobIdentitiesJson: JSON.stringify([...reducer.mobIdentities]),
+    recentHitsJson: JSON.stringify([...reducer.recentHits])
+  });
+}
+function loadEnemyIdentity(database, sessionId, encounterId) {
+  const rows = database.query("select target_id, display_name, first_seen_at_ms from combat_enemies where session_id = ? and encounter_id = ?").all(sessionId, encounterId);
+  return {
+    enemyFirstSeenAtMs: new Map(rows.map((enemy) => [enemy.target_id, enemy.first_seen_at_ms])),
+    enemyNames: new Map(rows.filter((enemy) => enemy.display_name !== null).map((enemy) => [enemy.target_id, enemy.display_name]))
+  };
+}
+function loadDeaths(database, sessionId, encounterId) {
+  return database.query("select * from combat_deaths where session_id = ? and encounter_id = ? order by death_index").all(sessionId, encounterId).map((row) => ({
+    victimName: row.victim_name,
+    targetId: row.target_id,
+    diedAtMs: row.died_at_ms,
+    totalDamage: row.total_damage,
+    hits: database.query("select * from combat_death_hits where session_id = ? and encounter_id = ? and death_index = ? order by hit_index").all(sessionId, encounterId, row.death_index).map((hit) => ({
+      beforeDeathMs: hit.before_death_ms,
+      attackerActorId: hit.attacker_actor_id,
+      attackerLabel: hit.attacker_label,
+      attackerIsMonster: hit.attacker_is_monster === 1,
+      sourceLabel: hit.source_label,
+      damage: hit.damage,
+      critical: hit.critical === 1
+    }))
+  }));
+}
+function loadOpenEncounter(model, sessionId) {
+  const database = statements(model);
+  const row = database.query("select encounter_id, started_at_ms, last_damage_at_ms, ended_at_ms from combat_encounters where session_id = $sessionId and ended_at_ms is null").get({ sessionId });
+  if (!row)
+    return;
+  const encounter = {
+    id: row.encounter_id,
+    startedAtMs: row.started_at_ms,
+    lastDamageAtMs: row.last_damage_at_ms,
+    actors: [],
+    activeActors: new Map,
+    ...loadEnemyIdentity(database, sessionId, row.encounter_id),
+    deaths: loadDeaths(database, sessionId, row.encounter_id)
+  };
+  const actorRows = database.query("select * from combat_actors where session_id = $sessionId and encounter_id = $encounterId and meter = 'dps' order by actor_index").all({ sessionId, encounterId: row.encounter_id });
+  for (const actorRow2 of actorRows) {
+    const actor = createActor(actorRow2.actor_id, encounter.startedAtMs, actorRow2.ewma_tau_seconds);
+    if (actorRow2.display_name !== null)
+      actor.displayName = actorRow2.display_name;
+    if (actorRow2.archetype !== null)
+      actor.archetype = actorRow2.archetype;
+    if (actorRow2.owner_connection_id !== null)
+      actor.ownerConnectionId = actorRow2.owner_connection_id;
+    if (actorRow2.uid !== null)
+      actor.uid = actorRow2.uid;
+    actor.activeIdentity = actorRow2.active_identity === 1;
+    actor.damage = actorRow2.damage;
+    if (actorRow2.first_damage_at_ms !== null)
+      actor.firstDamageAtMs = actorRow2.first_damage_at_ms;
+    if (actorRow2.last_damage_at_ms !== null)
+      actor.lastDamageAtMs = actorRow2.last_damage_at_ms;
+    actor.hits = actorRow2.hits;
+    actor.criticalHits = actorRow2.critical_hits;
+    actor.kills = actorRow2.kills;
+    actor.currentRate.restore({
+      rate: actorRow2.ewma_rate,
+      updatedAtMs: actorRow2.ewma_at_ms,
+      tauSeconds: actorRow2.ewma_tau_seconds
+    });
+    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 = 'dps' and actor_index = ?").all(sessionId, row.encounter_id, actorRow2.actor_index)) {
+      actor.skills.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 = 'dps' and actor_index = ?").all(sessionId, row.encounter_id, actorRow2.actor_index)) {
+      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)) {
+      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 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 = 'dps' and actor_index = ? order by bucket_index").all(sessionId, row.encounter_id, actorRow2.actor_index)) {
+      const series = bucket.origin === "actor" ? actor.actorSeries : actor.encounterSeries;
+      series.originMs = bucket.origin_ms;
+      series.widthMs = bucket.width_ms;
+      while (series.buckets.length <= bucket.bucket_index)
+        series.buckets.push(0);
+      series.buckets[bucket.bucket_index] = bucket.damage;
+    }
+    encounter.actors.push(actor);
+    if (actorRow2.active_slot === 1)
+      encounter.activeActors.set(actor.actorId, actor);
+  }
+  return encounter;
+}
+function loadMeterAggregate(model, sessionId, open, meter) {
+  const database = statements(model);
+  const aggregate = {
+    id: open.id,
+    startedAtMs: open.startedAtMs,
+    lastDamageAtMs: open.lastDamageAtMs,
+    actors: [],
+    activeActors: new Map,
+    enemyFirstSeenAtMs: new Map,
+    enemyNames: new Map,
+    deaths: []
+  };
+  for (const actorRow2 of database.query("select * from combat_actors where session_id = ? and encounter_id = ? and meter = ? order by actor_index").all(sessionId, open.id, meter)) {
+    const actor = createActor(actorRow2.actor_id, aggregate.startedAtMs, actorRow2.ewma_tau_seconds);
+    if (actorRow2.display_name !== null)
+      actor.displayName = actorRow2.display_name;
+    if (actorRow2.archetype !== null)
+      actor.archetype = actorRow2.archetype;
+    actor.activeIdentity = actorRow2.active_identity === 1;
+    actor.damage = actorRow2.damage;
+    if (actorRow2.first_damage_at_ms !== null)
+      actor.firstDamageAtMs = actorRow2.first_damage_at_ms;
+    if (actorRow2.last_damage_at_ms !== null)
+      actor.lastDamageAtMs = actorRow2.last_damage_at_ms;
+    actor.hits = actorRow2.hits;
+    actor.criticalHits = actorRow2.critical_hits;
+    actor.currentRate.restore({
+      rate: actorRow2.ewma_rate,
+      updatedAtMs: actorRow2.ewma_at_ms,
+      tauSeconds: actorRow2.ewma_tau_seconds
+    });
+    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 = ? and actor_index = ?").all(sessionId, open.id, meter, actorRow2.actor_index)) {
+      actor.skills.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 = ? and actor_index = ?").all(sessionId, open.id, meter, actorRow2.actor_index)) {
+      actor.targetIds.add(target.target_id);
+      actor.targetDamage.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;
+      series.widthMs = bucket.width_ms;
+      while (series.buckets.length <= bucket.bucket_index)
+        series.buckets.push(0);
+      series.buckets[bucket.bucket_index] = bucket.damage;
+    }
+    aggregate.actors.push(actor);
+    if (actorRow2.active_slot === 1)
+      aggregate.activeActors.set(actor.actorId, actor);
+  }
+  return aggregate;
+}
+// src/history/store.ts
+var DEFAULT_LIMIT = 50;
+
+class CombatHistoryStore {
+  model;
+  constructor(model) {
+    this.model = model;
+  }
+  invalidLines(sessionId) {
+    const row = this.model.statement("select invalid_lines from combat_stream_state where session_id = $sessionId").get({ sessionId });
+    return row?.invalid_lines ?? 0;
+  }
+  listEncounters(query) {
+    const limit = Math.max(1, query.limit ?? DEFAULT_LIMIT);
+    const cursor = decodeCursor(query.cursor);
+    const rows = cursor ? this.model.database.query(`select * from combat_encounters
+           where session_id = ? and (started_at_ms > ? or (started_at_ms = ? and encounter_id > ?))
+           order by started_at_ms, encounter_id limit ?`).all(query.sessionId, cursor.startedAtMs, cursor.startedAtMs, cursor.encounterId, limit + 1) : this.model.database.query("select * from combat_encounters where session_id = ? order by started_at_ms, encounter_id limit ?").all(query.sessionId, limit + 1);
+    const page = rows.slice(0, limit);
+    const last = page.at(-1);
+    return {
+      items: page.map((row) => summary(query.sessionId, row)),
+      ...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);
+    }
+    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 skills = encounter ? displayActorAggregates(encounter, { includeAllAnonymous: true }).flatMap(({ rowId, actor }) => [...actor.enemySkills].flatMap(([targetId, bySkill]) => [...bySkill].map(([sourceId, stats]) => ({
+      attackerRowId: rowId,
+      targetId,
+      sourceId,
+      sourceLabel: stats.sourceLabel,
+      damage: stats.damage,
+      hits: stats.hits,
+      criticalHits: stats.criticalHits
+    })))).sort((left, right) => right.damage - left.damage) : [];
+    return { encounterId, enemies: options, skills };
+  }
+  getDeathLog(query) {
+    const limit = Math.max(1, query.limit ?? DEFAULT_LIMIT);
+    const cursor = decodeCursor(query.cursor);
+    const rows = cursor ? this.model.database.query(`select * from combat_deaths
+           where session_id = ? and (died_at_ms < ? or (died_at_ms = ? and encounter_id || ':' || death_index < ?))
+           order by died_at_ms desc, encounter_id desc, death_index desc limit ?`).all(query.sessionId, cursor.startedAtMs, cursor.startedAtMs, cursor.encounterId, limit + 1) : this.model.database.query("select * from combat_deaths where session_id = ? order by died_at_ms desc, encounter_id desc, death_index desc limit ?").all(query.sessionId, limit + 1);
+    const page = rows.slice(0, limit);
+    const last = page.at(-1);
+    return {
+      items: page.map((row) => ({
+        encounterId: row.encounter_id,
+        deathIndex: row.death_index,
+        victimName: row.victim_name,
+        targetId: row.target_id,
+        diedAtMs: row.died_at_ms,
+        totalDamage: row.total_damage,
+        hits: this.model.database.query("select * from combat_death_hits where session_id = ? and encounter_id = ? and death_index = ? order by hit_index").all(query.sessionId, row.encounter_id, row.death_index).map((hit) => ({
+          beforeDeathMs: hit.before_death_ms,
+          attackerActorId: hit.attacker_actor_id,
+          attackerLabel: hit.attacker_label,
+          attackerIsMonster: hit.attacker_is_monster === 1,
+          sourceLabel: hit.source_label,
+          damage: hit.damage,
+          critical: hit.critical === 1
+        }))
+      })),
+      ...rows.length > limit && last ? { nextCursor: encodeCursor({ startedAtMs: last.died_at_ms, encounterId: `${last.encounter_id}:${last.death_index}` }) } : {}
+    };
+  }
+  getEncounter(sessionId, encounterId, options = {}) {
+    const { meter = "dps", ...renderOptions } = options;
+    const encounter = this.loadEncounter(sessionId, encounterId, meter);
+    if (!encounter)
+      return;
+    return renderEncounter(encounter, { nowMs: encounter.lastDamageAtMs, ...renderOptions });
+  }
+  loadEncounter(sessionId, encounterId, meter, options = {}) {
+    const database = this.model.database;
+    const row = database.query("select * from combat_encounters where session_id = ? and encounter_id = ?").get(sessionId, encounterId);
+    if (!row)
+      return;
+    const encounter = {
+      id: row.encounter_id,
+      startedAtMs: row.started_at_ms,
+      lastDamageAtMs: row.last_damage_at_ms,
+      ...row.ended_at_ms === null ? {} : { endedAtMs: row.ended_at_ms },
+      actors: [],
+      activeActors: new Map,
+      enemyFirstSeenAtMs: new Map,
+      enemyNames: new Map,
+      deaths: []
+    };
+    for (const actorRow2 of database.query("select * from combat_actors where session_id = ? and encounter_id = ? and meter = ? order by actor_index").all(sessionId, encounterId, meter)) {
+      encounter.actors.push(hydrateActor(database, sessionId, encounterId, meter, actorRow2, encounter.startedAtMs, options.withTimeline ?? true));
+    }
+    return encounter;
+  }
+}
+function hydrateActor(database, sessionId, encounterId, meter, row, encounterStartedAtMs, withTimeline) {
+  const actor = createActor(row.actor_id, encounterStartedAtMs, row.ewma_tau_seconds);
+  if (row.display_name !== null)
+    actor.displayName = row.display_name;
+  if (row.archetype !== null)
+    actor.archetype = row.archetype;
+  if (row.owner_connection_id !== null)
+    actor.ownerConnectionId = row.owner_connection_id;
+  if (row.uid !== null)
+    actor.uid = row.uid;
+  actor.activeIdentity = row.active_identity === 1;
+  actor.damage = row.damage;
+  if (row.first_damage_at_ms !== null)
+    actor.firstDamageAtMs = row.first_damage_at_ms;
+  if (row.last_damage_at_ms !== null)
+    actor.lastDamageAtMs = row.last_damage_at_ms;
+  actor.hits = row.hits;
+  actor.criticalHits = row.critical_hits;
+  actor.kills = row.kills;
+  actor.currentRate.restore({ rate: row.ewma_rate, updatedAtMs: row.ewma_at_ms, tauSeconds: row.ewma_tau_seconds });
+  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 = ? and actor_index = ?").all(sessionId, encounterId, meter, row.actor_index)) {
+    actor.skills.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 = ? and actor_index = ?").all(sessionId, encounterId, meter, row.actor_index)) {
+    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)) {
+      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
+      });
+    }
+  }
+  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;
+      series.originMs = bucket.origin_ms;
+      series.widthMs = bucket.width_ms;
+      while (series.buckets.length <= bucket.bucket_index)
+        series.buckets.push(0);
+      series.buckets[bucket.bucket_index] = bucket.damage;
+    }
+  }
+  return actor;
+}
+function summary(sessionId, row) {
+  return {
+    sessionId,
+    encounterId: row.encounter_id,
+    startedAtMs: row.started_at_ms,
+    lastDamageAtMs: row.last_damage_at_ms,
+    ...row.ended_at_ms === null ? {} : { endedAtMs: row.ended_at_ms },
+    durationMs: Math.max(1000, row.last_damage_at_ms - row.started_at_ms),
+    totalDamage: row.total_damage
+  };
+}
+function encodeCursor(cursor) {
+  return Buffer.from(`${cursor.startedAtMs}:${cursor.encounterId}`, "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!cursor)
+    return;
+  const text = Buffer.from(cursor, "base64url").toString("utf8");
+  const separator = text.indexOf(":");
+  if (separator < 0)
+    return;
+  const startedAtMs = Number(text.slice(0, separator));
+  if (!Number.isFinite(startedAtMs))
+    return;
+  return { startedAtMs, encounterId: text.slice(separator + 1) };
+}
+// src/live-combat.ts
+class LiveCombatService {
+  reducer;
+  currentTauSeconds;
+  minimumDurationMs;
+  retainedFinishedEncounters;
+  onEncounterFinished;
+  tanked;
+  healing;
+  meterId;
+  lastEventAtMs;
+  latestFinished;
+  personalName;
+  personalActorId;
+  revision = 0;
+  constructor(options = {}) {
+    this.currentTauSeconds = positive(options.currentTauSeconds ?? DEFAULT_CURRENT_TAU_SECONDS, "currentTauSeconds");
+    this.minimumDurationMs = positive(options.minimumDurationMs ?? 1000, "minimumDurationMs");
+    this.retainedFinishedEncounters = integerAtLeast(options.retainedFinishedEncounters ?? 1, "retainedFinishedEncounters");
+    const timelinePoints = positiveInteger(options.timelinePoints ?? 720, "timelinePoints");
+    this.personalName = options.personalName ?? "";
+    this.personalActorId = options.personalActorId;
+    this.onEncounterFinished = options.onEncounterFinished;
+    this.reducer = new DamageReducer({
+      idleGapMs: options.idleGapMs,
+      currentTauSeconds: this.currentTauSeconds,
+      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 });
+  }
+  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);
+    if (this.identityChanged(event, previous, hadIdentities))
+      this.revision += 1;
+  }
+  identityChanged(event, previous, hadIdentities) {
+    if (event.operation === "reset")
+      return hadIdentities;
+    if (event.operation === "remove")
+      return previous !== undefined;
+    const current = this.reducer.identities.get(event.actorId);
+    if (!previous || !current)
+      return true;
+    return previous.displayName !== current.displayName || previous.archetype !== current.archetype || previous.ownerConnectionId !== current.ownerConnectionId || previous.uid !== current.uid;
+  }
+  consumeCombat(event, observedAtMs) {
+    this.reducer.consumeCombat(event, observedAtMs);
+    const encounter = this.reducer.current;
+    if (encounter) {
+      this.ensureMeter(encounter);
+      this.recordMeterEvent(event, observedAtMs);
+    }
+    this.revision += 1;
+  }
+  setPersonalName(personalName) {
+    if (this.personalName === personalName)
+      return;
+    this.personalName = personalName;
+    this.revision += 1;
+  }
+  setPersonalActorId(personalActorId) {
+    if (this.personalActorId === personalActorId)
+      return;
+    this.personalActorId = personalActorId;
+    this.revision += 1;
+  }
+  getPersonalActorId() {
+    return this.personalActorId;
+  }
+  advance(observedAtMs) {
+    this.reducer.advance(observedAtMs);
+  }
+  reset(observedAtMs) {
+    this.reducer.reset(observedAtMs);
+  }
+  getState(nowMs) {
+    const current = this.reducer.current && this.meterId === this.reducer.current.id ? this.renderRecord(this.reducer.current, nowMs) : undefined;
+    const latestFinished = this.latestFinished ? this.renderRecord(this.latestFinished.encounter, this.latestFinished.endedAtMs, this.latestFinished) : undefined;
+    return {
+      revision: this.revision,
+      ...current ? { current } : {},
+      ...latestFinished ? { latestFinished } : {}
+    };
+  }
+  ensureMeter(encounter) {
+    if (this.meterId === encounter.id)
+      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.lastEventAtMs = Math.max(this.lastEventAtMs ?? observedAtMs, observedAtMs);
+  }
+  finishMeter(encounter) {
+    this.ensureMeter(encounter);
+    const endedAtMs = encounter.endedAtMs ?? encounter.lastDamageAtMs;
+    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 }
+    };
+    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;
+    this.revision += 1;
+    const callback = this.onEncounterFinished;
+    if (callback)
+      Promise.resolve(callback(record));
+  }
+  renderRecord(encounter, nowMs, finished) {
+    const atMs = Math.max(nowMs ?? finished?.lastEventAtMs ?? this.lastEventAtMs ?? encounter.lastDamageAtMs, encounter.lastDamageAtMs);
+    const personal = {
+      personalName: this.personalName,
+      ...this.personalActorId === undefined ? {} : { personalActorId: this.personalActorId }
+    };
+    const render = (aggregate) => renderMeter(aggregate ?? emptyAggregate(encounter), {
+      nowMs: atMs,
+      windowEndMs: encounter.endedAtMs ?? atMs,
+      lastEventAtMs: finished?.lastEventAtMs ?? this.lastEventAtMs ?? encounter.lastDamageAtMs,
+      minimumDurationMs: this.minimumDurationMs,
+      ...personal,
+      ...encounter.endedAtMs === undefined ? {} : { endedAtMs: encounter.endedAtMs }
+    });
+    return {
+      dps: renderEncounter(encounter, {
+        nowMs: atMs,
+        minimumDurationMs: this.minimumDurationMs,
+        ...personal
+      }),
+      tps: render(finished ? finished.tanked : this.tanked.current),
+      hps: render(finished ? finished.healing : this.healing.current)
+    };
+  }
+}
+function emptyAggregate(encounter) {
+  return {
+    id: encounter.id,
+    startedAtMs: encounter.startedAtMs,
+    lastDamageAtMs: encounter.startedAtMs,
+    actors: [],
+    activeActors: new Map,
+    enemyFirstSeenAtMs: new Map,
+    enemyNames: new Map,
+    deaths: [],
+    ...encounter.endedAtMs === undefined ? {} : { endedAtMs: encounter.endedAtMs }
+  };
+}
+function renderMeter(aggregate, options) {
+  const windowed = {
+    ...aggregate,
+    lastDamageAtMs: Math.max(aggregate.lastDamageAtMs, options.windowEndMs)
+  };
+  const detail = renderEncounter(windowed, {
+    nowMs: options.nowMs,
+    minimumDurationMs: options.minimumDurationMs,
+    ...options.personalName === undefined ? {} : { personalName: options.personalName },
+    ...options.personalActorId === undefined ? {} : { personalActorId: options.personalActorId }
+  });
+  const firstByActorId = new Map;
+  for (const actor of aggregate.actors) {
+    if (actor.firstDamageAtMs !== undefined)
+      firstByActorId.set(actor.actorId, actor.firstDamageAtMs);
+  }
+  const rows = detail.actors.map((actor) => {
+    const firstAtMs = actor.actorIds.reduce((earliest, actorId) => {
+      const candidate = firstByActorId.get(actorId);
+      if (candidate === undefined)
+        return earliest;
+      return earliest === undefined ? candidate : Math.min(earliest, candidate);
+    }, undefined);
+    return {
+      displayName: actor.displayName,
+      actorIds: [...actor.actorIds],
+      amount: actor.damage,
+      rate: actor.dps,
+      hits: actor.hits,
+      ...firstAtMs === undefined ? {} : { firstAtMs },
+      ...actor.lastDamageAtMs === undefined ? {} : { lastAtMs: actor.lastDamageAtMs }
+    };
+  });
+  return {
+    id: aggregate.id,
+    startedAtMs: aggregate.startedAtMs,
+    lastEventAtMs: options.lastEventAtMs,
+    ...options.endedAtMs === undefined ? {} : { endedAtMs: options.endedAtMs },
+    durationMs: detail.durationMs,
+    total: detail.totalDamage,
+    rate: detail.partyDps,
+    rows,
+    detail
+  };
+}
+function positive(value, name) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new Error(`${name} must be a positive finite number`);
+  return value;
+}
+function integerAtLeast(value, name) {
+  if (!Number.isInteger(value) || value < 0)
+    throw new Error(`${name} must be a non-negative integer`);
+  return value;
+}
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0)
+    throw new Error(`${name} must be a positive integer`);
+  return value;
+}
+// src/live-log.ts
+import {
+  DEFAULT_STREAM_BATCH_BYTES,
+  JsonlTailReader,
+  LiveLogSessionFollower,
+  isLogStreamHeader as isLogStreamHeader3,
+  parseLogRecord as parseLogRecord3
+} from "@kar-mi/spirit-vale-tools-logging";
+class DpsLogFollower {
+  ticksPerSecond;
+  reader;
+  recordedAtOriginMs;
+  lastObservedAtMs = 0;
+  originTick;
+  lastTick;
+  revision = 0;
+  constructor(path, ticksPerSecond = 30) {
+    this.ticksPerSecond = ticksPerSecond;
+    this.reader = new JsonlTailReader(path, { createDecoder: decoderFor2, maxReadBytes: DEFAULT_STREAM_BATCH_BYTES });
+  }
+  async poll() {
+    return this.consumeRead(await this.reader.read());
+  }
+  consumeRead({ missing, reset, lines }) {
+    if (missing) {
+      return { events: [], invalidLines: 0, missing: true, reset: false, changed: false, revision: this.revision };
+    }
+    if (reset)
+      this.resetState();
+    const consumed = this.consume(lines);
+    const changed = reset || consumed.events.length > 0;
+    if (changed)
+      this.revision += 1;
+    return { ...consumed, missing: false, reset, changed, revision: this.revision };
+  }
+  consume(lines) {
+    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))
+        continue;
+      const record = parseLogRecord3(candidate);
+      if (!record) {
+        invalidLines += 1;
+        continue;
+      }
+      const event = parseDpsLogRecord(record.type, record.data);
+      if (event === null)
+        continue;
+      if (!event) {
+        invalidLines += 1;
+        continue;
+      }
+      const observedAtMs = this.observedAt(record.recordedAt, event.tick);
+      events.push({ event, observedAtMs });
+    }
+    return { events, invalidLines };
+  }
+  observedAt(recordedAt, tick) {
+    const recordedAtMs = Date.parse(recordedAt);
+    if (Number.isFinite(recordedAtMs)) {
+      this.recordedAtOriginMs ??= recordedAtMs;
+      this.lastObservedAtMs = Math.max(this.lastObservedAtMs, recordedAtMs - this.recordedAtOriginMs);
+      return this.lastObservedAtMs;
+    }
+    if (this.lastTick !== undefined && tick < this.lastTick)
+      this.originTick = undefined;
+    this.originTick ??= tick;
+    this.lastTick = tick;
+    this.lastObservedAtMs = Math.max(this.lastObservedAtMs, (tick - this.originTick) * 1000 / this.ticksPerSecond);
+    return this.lastObservedAtMs;
+  }
+  resetState() {
+    this.recordedAtOriginMs = undefined;
+    this.lastObservedAtMs = 0;
+    this.originTick = undefined;
+    this.lastTick = undefined;
+  }
+}
+
+class DpsSessionLogFollower {
+  inner;
+  constructor(logDirectory, ticksPerSecond = 30, options = {}) {
+    const { ticksPerSecond: ticksOverride, ...tuning } = options;
+    const ticks = ticksOverride ?? ticksPerSecond;
+    this.inner = new LiveLogSessionFollower({
+      stream: "combat",
+      ...logDirectory === undefined ? {} : { logDirectory },
+      ...tuning,
+      readerOptions: { createDecoder: decoderFor2, maxReadBytes: DEFAULT_STREAM_BATCH_BYTES },
+      createFollower: (path) => new DpsLogFollower(path, ticks),
+      mergeSessionChange: (batch, changedSession) => ({
+        ...batch,
+        reset: batch.reset || changedSession,
+        changed: batch.changed || changedSession
+      }),
+      noStreamBatch: (reset) => ({ events: [], invalidLines: 0, missing: true, reset, changed: reset, revision: 0 })
+    });
+  }
+  static watch(logDirectory, options = {}) {
+    return new DpsSessionLogFollower(logDirectory, options.ticksPerSecond ?? 30, options);
+  }
+  poll() {
+    return this.inner.poll();
+  }
+  next() {
+    return this.inner.next();
+  }
+  [Symbol.asyncIterator]() {
+    return this.inner[Symbol.asyncIterator]();
+  }
+  close() {
+    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
+class FishNetPositionTracker {
+  options;
+  positions = new Map;
+  localObjectId;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  setLocalObjectId(objectId) {
+    this.localObjectId = objectId;
+  }
+  self() {
+    return this.localObjectId === undefined ? undefined : this.positions.get(this.localObjectId);
+  }
+  get(objectId) {
+    return this.positions.get(objectId);
+  }
+  snapshot() {
+    return [...this.positions].map(([objectId, position]) => ({ objectId, position: { ...position } }));
+  }
+  reset() {
+    this.positions.clear();
+    this.localObjectId = undefined;
+  }
+  consume(packet) {
+    if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
+      this.reset();
+      return [];
+    }
+    if (packet.objectId === undefined)
+      return [];
+    if (packet.packetName === "objectDespawn") {
+      this.positions.delete(packet.objectId);
+      return [];
+    }
+    if (packet.packetName === "objectSpawn") {
+      const spawn = packet.spawnLocalPosition;
+      if (!spawn)
+        return [];
+      const position2 = { x: spawn[0], y: spawn[1], z: spawn[2] };
+      if (packet.spawnHeading !== undefined)
+        position2.heading = packet.spawnHeading;
+      this.positions.set(packet.objectId, position2);
+      return [this.event(packet, packet.objectId, position2)];
+    }
+    const update = packet.networkTransform;
+    if (!update)
+      return [];
+    const previous = this.positions.get(packet.objectId);
+    const next = {
+      x: update.position.x ?? previous?.x,
+      y: update.position.y ?? previous?.y,
+      z: update.position.z ?? previous?.z
+    };
+    if (next.x === undefined || next.y === undefined || next.z === undefined)
+      return [];
+    const position = { x: next.x, y: next.y, z: next.z };
+    const heading = update.heading ?? previous?.heading;
+    if (heading !== undefined)
+      position.heading = heading;
+    this.positions.set(packet.objectId, position);
+    return [this.event(packet, packet.objectId, position)];
+  }
+  event(packet, objectId, position) {
+    const displayName = this.options.directory?.getAttribution(objectId)?.displayName;
+    return {
+      kind: "position",
+      tick: packet.tick,
+      objectId,
+      position: { ...position },
+      ...displayName === undefined ? {} : { displayName },
+      self: objectId === this.localObjectId
+    };
+  }
+}
+export {
+  ANALYSIS_BUCKET_MS,
+  COMBAT_DOMAIN_NAME,
+  COMBAT_DOMAIN_VERSION,
+  CURRENT_BOSS_SKILL_NAMES,
+  CombatHistoryStore,
+  DamageReducer,
+  DpsLogFollower,
+  DpsSessionLogFollower,
+  FishNetActorDirectory,
+  FishNetCombatTracker,
+  FishNetPositionTracker,
+  FishNetStatusTracker,
+  LiveCombatService,
+  MeterReducer,
+  actorRowId,
+  createBossCatalog,
+  createCombatDomain,
+  decodeCombatCaptureJsonLines,
+  displayActorAggregates,
+  formatCombatReplaySummary,
+  indexCombatStream,
+  inspectCombatReplaySummary,
+  loadDpsReplay,
+  normalizeName,
+  parseDpsLogRecord,
+  readCombatReplaySummary,
+  renderEncounter,
+  replayCombatCapture,
+  replayCombatCaptures
+};