@axiapps/bridge-metrics 0.1.0

package/dist/chunk-LIGIXSSA.js

@@ -0,0 +1,1383 @@
+import {
+  isResUtilitySkill
+} from "./chunk-JP2ZL44R.js";
+import {
+  resolveFightTimestamp
+} from "./chunk-J3YCFY3C.js";
+import {
+  DEFENSE_METRICS,
+  OFFENSE_METRICS,
+  SUPPORT_METRICS
+} from "./chunk-42DVJJLC.js";
+import {
+  getPlayerBlocked,
+  getPlayerBreakbarDamage,
+  getPlayerCleanses,
+  getPlayerDamageTaken,
+  getPlayerEvaded,
+  getPlayerMissed,
+  getPlayerOutgoingInterrupts,
+  getPlayerStrips,
+  getTargetStatTotal
+} from "./chunk-FU74LJEM.js";
+import {
+  applySquadStabilityGeneration,
+  computeDownContribution,
+  computeOutgoingCrowdControl,
+  computeSquadBarrier,
+  computeSquadHealing
+} from "./chunk-R5EJF5AW.js";
+import {
+  NON_DAMAGING_CONDITIONS,
+  buildConditionIconMap,
+  computeOutgoingConditions,
+  normalizeConditionLabel,
+  resolveBuffMetaById,
+  resolveConditionNameFromEntry
+} from "./chunk-RGXSI3AI.js";
+import {
+  PROFESSION_COLORS
+} from "./chunk-WW5XFXGC.js";
+
+// src/computePlayerAggregation.ts
+var getFightDownsDeaths = (details) => {
+  const players = details?.players || [];
+  const squadPlayers = players.filter((p) => !p.notInSquad);
+  let squadDownsDeaths = 0;
+  let enemyDownsDeaths = 0;
+  let squadDeaths = 0;
+  let enemyDeaths = 0;
+  squadPlayers.forEach((p) => {
+    const defenses = p.defenses?.[0];
+    if (!defenses) return;
+    const downCount = Number(defenses.downCount || 0);
+    const deadCount = Number(defenses.deadCount || 0);
+    squadDownsDeaths += downCount + deadCount;
+    squadDeaths += deadCount;
+  });
+  squadPlayers.forEach((p) => {
+    if (!p.statsTargets || p.statsTargets.length === 0) return;
+    p.statsTargets.forEach((targetStats) => {
+      if (!Array.isArray(targetStats)) return;
+      targetStats.forEach((phaseStats) => {
+        if (!phaseStats) return;
+        const downed = Number(phaseStats.downed || 0);
+        const killed = Number(phaseStats.killed || 0);
+        enemyDownsDeaths += downed + killed;
+        enemyDeaths += killed;
+      });
+    });
+  });
+  return { squadDownsDeaths, enemyDownsDeaths, squadDeaths, enemyDeaths };
+};
+var getFightOutcome = (details) => {
+  const { squadDownsDeaths, enemyDownsDeaths } = getFightDownsDeaths(details);
+  if (squadDownsDeaths > 0 || enemyDownsDeaths > 0) {
+    return enemyDownsDeaths > squadDownsDeaths;
+  }
+  if (typeof details?.success === "boolean") return details.success;
+  return false;
+};
+var knownProfessionNames = new Set(Object.keys(PROFESSION_COLORS));
+var knownProfessionList = Object.keys(PROFESSION_COLORS).filter((name) => name && name !== "Unknown").sort((a, b) => b.length - a.length);
+var baseProfessionNames = [
+  "Guardian",
+  "Revenant",
+  "Warrior",
+  "Engineer",
+  "Ranger",
+  "Thief",
+  "Elementalist",
+  "Mesmer",
+  "Necromancer"
+];
+var resolveProfessionLabel = (name) => {
+  if (!name) return "Unknown";
+  const cleaned = String(name).replace(/\s*\([^)]*\)\s*$/, "").replace(/\s*\[[^\]]*\]\s*$/, "").replace(/\s\d+$/, "").trim();
+  if (knownProfessionNames.has(cleaned)) return cleaned;
+  const lower = cleaned.toLowerCase();
+  for (const prof of knownProfessionList) {
+    if (lower.includes(prof.toLowerCase())) return prof;
+  }
+  const baseMatch = baseProfessionNames.find((prof) => lower.includes(prof.toLowerCase()));
+  return baseMatch || cleaned || "Unknown";
+};
+var supportTimeSanityFields = /* @__PURE__ */ new Set(["boonStripsTime", "condiCleanseTime", "condiCleanseTimeSelf"]);
+var isBoon = (meta) => {
+  if (!meta?.classification) return true;
+  return meta.classification === "Boon";
+};
+var createMitigationTotals = () => ({
+  totalHits: 0,
+  blocked: 0,
+  evaded: 0,
+  glanced: 0,
+  missed: 0,
+  invulned: 0,
+  interrupted: 0,
+  totalMitigation: 0,
+  minMitigation: 0
+});
+var readNumber = (value) => {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : 0;
+};
+var parseMitigationKey = (rawKey) => {
+  const parts = String(rawKey).split("|");
+  const name = parts[0] || "Unknown";
+  const profession = resolveProfessionLabel(parts[1] || "Unknown");
+  const account = parts[2] || name || "Unknown";
+  return { name, profession, account };
+};
+var ensureMitigationRow = (map, key, base) => {
+  let row = map.get(key);
+  if (!row) {
+    row = {
+      account: base.account,
+      name: base.name,
+      profession: base.profession,
+      professionList: base.profession ? [base.profession] : [],
+      activeMs: 0,
+      mitigationTotals: createMitigationTotals()
+    };
+    map.set(key, row);
+  } else if (base.profession && !row.professionList.includes(base.profession)) {
+    row.professionList.push(base.profession);
+  }
+  return row;
+};
+var ensureMitigationMinionRow = (map, key, base) => {
+  let row = map.get(key);
+  if (!row) {
+    row = {
+      account: base.account,
+      name: base.name,
+      profession: base.profession,
+      professionList: base.profession ? [base.profession] : [],
+      activeMs: 0,
+      mitigationTotals: createMitigationTotals(),
+      minion: base.minion
+    };
+    map.set(key, row);
+  } else if (base.profession && !row.professionList.includes(base.profession)) {
+    row.professionList.push(base.profession);
+  }
+  return row;
+};
+var addMitigationTotals = (totals, entry) => {
+  totals.totalHits += readNumber(entry?.skill_hits ?? entry?.skillHits);
+  totals.blocked += readNumber(entry?.blocked);
+  totals.evaded += readNumber(entry?.evaded);
+  totals.glanced += readNumber(entry?.glanced);
+  totals.missed += readNumber(entry?.missed);
+  totals.invulned += readNumber(entry?.invulned);
+  totals.interrupted += readNumber(entry?.interrupted);
+  totals.totalMitigation += readNumber(entry?.avoided_damage ?? entry?.avoidedDamage);
+  totals.minMitigation += readNumber(entry?.min_avoided_damage ?? entry?.minAvoidedDamage);
+};
+var resolveGlobalEnemyStats = (globalEnemySkillStats, skillId) => {
+  const bucket = globalEnemySkillStats.get(skillId);
+  if (!bucket) {
+    return { hasSkill: false, avg: 1, min: 1, hits: 0 };
+  }
+  const hits = bucket.connectedHits || 0;
+  const avg = hits > 0 ? bucket.totalDamage / hits : 0;
+  const min = bucket.minCount > 0 ? bucket.minTotal / bucket.minCount : 0;
+  return { hasSkill: true, avg, min, hits };
+};
+var updateCumulativeCounts = (map, key, delta) => {
+  const existing = map.get(key) || createMitigationTotals();
+  existing.totalHits += delta.totalHits;
+  existing.blocked += delta.blocked;
+  existing.evaded += delta.evaded;
+  existing.glanced += delta.glanced;
+  existing.missed += delta.missed;
+  existing.invulned += delta.invulned;
+  existing.interrupted += delta.interrupted;
+  map.set(key, existing);
+  return existing;
+};
+var getPlayerIdentity = (player, splitPlayersByClass) => {
+  const baseAccount = player?.account && player.account !== "Unknown" ? player.account : player?.name || "Unknown";
+  const profession = resolveProfessionLabel(player?.profession || "Unknown");
+  const isSplit = splitPlayersByClass && profession !== "Unknown";
+  const key = isSplit ? `${baseAccount}::${profession}` : baseAccount;
+  const accountLabel = baseAccount;
+  return { key, baseAccount, profession, accountLabel, isSplit };
+};
+var getMitigationIdentity = (account, profession, splitPlayersByClass) => {
+  const resolvedProfession = resolveProfessionLabel(profession || "Unknown");
+  const isSplit = splitPlayersByClass && resolvedProfession !== "Unknown";
+  const key = isSplit ? `${account}::${resolvedProfession}` : account;
+  const accountLabel = account;
+  return { key, accountLabel, profession: resolvedProfession };
+};
+var normalizeStatePairs = (states) => {
+  if (!Array.isArray(states)) return [];
+  return states.map((entry) => {
+    if (Array.isArray(entry)) return [Number(entry[0]), Number(entry[1])];
+    if (entry && typeof entry === "object") return [Number(entry.time), Number(entry.value)];
+    return null;
+  }).filter(
+    (entry) => !!entry && Number.isFinite(entry[0]) && Number.isFinite(entry[1]) && entry[0] >= 0
+  ).sort((a, b) => a[0] - b[0]);
+};
+var resolveNonStackingFactor = (rawValue) => {
+  const safeValue = Math.max(0, Number(rawValue || 0));
+  if (!Number.isFinite(safeValue) || safeValue <= 0) return 0;
+  if (safeValue <= 1) return safeValue;
+  if (safeValue <= 100) return safeValue / 100;
+  return 1;
+};
+var integrateSourceStates = (states, durationMs, stacking) => {
+  const normalized = normalizeStatePairs(states);
+  if (normalized.length === 0 || durationMs <= 0) return { totalMs: 0, uptimeMs: 0 };
+  const resolvedDurationMs = Math.max(1, Number(durationMs || 0));
+  const clampTime = (value) => Math.max(0, Math.min(resolvedDurationMs, Number(value || 0)));
+  let totalMs = 0;
+  let uptimeMs = 0;
+  const addSegment = (startMs, endMs, value) => {
+    const start = clampTime(startMs);
+    const end = clampTime(endMs);
+    if (end <= start) return;
+    const segmentMs = Math.max(0, end - start);
+    if (segmentMs <= 0) return;
+    const safeValue = Math.max(0, Number(value || 0));
+    if (safeValue <= 0) return;
+    uptimeMs += segmentMs;
+    if (stacking) {
+      totalMs += segmentMs * safeValue;
+    } else {
+      totalMs += segmentMs * resolveNonStackingFactor(safeValue);
+    }
+  };
+  let prevTime = clampTime(normalized[0][0]);
+  let prevValue = Math.max(0, Number(normalized[0][1] || 0));
+  for (let idx = 1; idx < normalized.length; idx += 1) {
+    const [timeMs, rawValue] = normalized[idx];
+    const currentTime = clampTime(timeMs);
+    addSegment(prevTime, currentTime, prevValue);
+    prevTime = currentTime;
+    prevValue = Math.max(0, Number(rawValue || 0));
+  }
+  addSegment(prevTime, resolvedDurationMs, prevValue);
+  return { totalMs, uptimeMs };
+};
+var ensureSpecialBuffEntry = (map, buffId, key, account, profession) => {
+  if (!map.has(buffId)) {
+    map.set(buffId, /* @__PURE__ */ new Map());
+  }
+  const bucket = map.get(buffId);
+  let agg = bucket.get(key);
+  if (!agg) {
+    agg = {
+      key,
+      account,
+      profession: profession || "Unknown",
+      professions: /* @__PURE__ */ new Set(),
+      professionTimeMs: {},
+      totalMs: 0,
+      uptimeMs: 0,
+      durationMs: 0
+    };
+    bucket.set(key, agg);
+  }
+  return agg;
+};
+var createPlayerAggregationAccumulators = () => ({
+  playerStats: /* @__PURE__ */ new Map(),
+  skillDamageMap: {},
+  incomingSkillDamageMap: {},
+  playerSkillBreakdownMap: /* @__PURE__ */ new Map(),
+  healingBreakdownMap: /* @__PURE__ */ new Map(),
+  outgoingCondiTotals: {},
+  incomingCondiTotals: {},
+  enemyProfessionCounts: {},
+  specialBuffMeta: /* @__PURE__ */ new Map(),
+  specialBuffAgg: /* @__PURE__ */ new Map(),
+  specialBuffOutputAgg: /* @__PURE__ */ new Map(),
+  damageMitigationPlayersMap: /* @__PURE__ */ new Map(),
+  damageMitigationMinionsMap: /* @__PURE__ */ new Map(),
+  globalEnemySkillStats: /* @__PURE__ */ new Map(),
+  mitigationCumulativeCounts: /* @__PURE__ */ new Map(),
+  mitigationMinionCumulativeCounts: /* @__PURE__ */ new Map(),
+  wins: 0,
+  losses: 0,
+  totalSquadSizeAccum: 0,
+  totalEnemiesAccum: 0,
+  totalSquadDeaths: 0,
+  totalSquadKills: 0,
+  totalEnemyDeaths: 0,
+  totalEnemyKills: 0,
+  totalSquadDowns: 0,
+  totalEnemyDowns: 0
+});
+var precomputeGlobalEnemySkillStats = (log, acc) => {
+  const details = log.details;
+  if (!details) return;
+  const targets = details.targets || [];
+  targets.forEach((target) => {
+    const dist = target?.totalDamageDist || [];
+    const list = Array.isArray(dist) ? dist[0] : null;
+    list?.forEach((entry) => {
+      if (!entry?.id) return;
+      const skillId = Number(entry.id);
+      const globalBucket = acc.globalEnemySkillStats.get(skillId) || { totalDamage: 0, connectedHits: 0, minTotal: 0, minCount: 0 };
+      globalBucket.totalDamage += Number(entry.totalDamage || 0);
+      globalBucket.connectedHits += Number(entry.connectedHits || 0);
+      const minValueGlobal = Number.isFinite(Number(entry.min)) ? Number(entry.min) : 0;
+      globalBucket.minTotal += minValueGlobal;
+      globalBucket.minCount += 1;
+      acc.globalEnemySkillStats.set(skillId, globalBucket);
+    });
+  });
+};
+var ingestLogPlayerData = (log, acc, options) => {
+  const { method, skillDamageSource, splitPlayersByClass } = options;
+  const details = log.details;
+  if (!details) return;
+  const players = details.players;
+  const squadPlayers = players.filter((player) => !player?.notInSquad);
+  const allPlayers = Array.isArray(players) ? players : [];
+  const specialBuffSourceIdentityByName = /* @__PURE__ */ new Map();
+  const specialBuffSourceIdentityByInstanceId = /* @__PURE__ */ new Map();
+  const specialBuffSourceActiveMsByKey = /* @__PURE__ */ new Map();
+  const specialBuffOutputDurationSeen = /* @__PURE__ */ new Set();
+  const registerSpecialSourceIdentity = (value, identity) => {
+    const normalized = String(value || "").trim().toLowerCase();
+    if (!normalized) return;
+    if (!specialBuffSourceIdentityByName.has(normalized)) {
+      specialBuffSourceIdentityByName.set(normalized, identity);
+    }
+  };
+  allPlayers.forEach((player) => {
+    const identity = getPlayerIdentity(player, splitPlayersByClass);
+    const sourceActiveMs = Array.isArray(player?.activeTimes) && typeof player.activeTimes[0] === "number" ? Number(player.activeTimes[0] || 0) : Number(details?.durationMS || 0);
+    specialBuffSourceActiveMsByKey.set(identity.key, Math.max(0, sourceActiveMs));
+    const instanceId = Number(player?.instanceID);
+    if (Number.isFinite(instanceId) && instanceId > 0 && !specialBuffSourceIdentityByInstanceId.has(instanceId)) {
+      specialBuffSourceIdentityByInstanceId.set(instanceId, identity);
+    }
+    [player?.name, player?.display_name, player?.character_name, player?.account].forEach((candidate) => {
+      registerSpecialSourceIdentity(candidate, identity);
+    });
+  });
+  const targets = details.targets || [];
+  const replayMeta = details.combatReplayMetaData || {};
+  const inchesToPixel = replayMeta?.inchToPixel > 0 ? replayMeta.inchToPixel : 1;
+  const pollingRate = replayMeta?.pollingRate > 0 ? replayMeta.pollingRate : 1;
+  const RUN_BACK_RANGE = 5e3;
+  const toPairs = (value) => {
+    if (!Array.isArray(value)) return [];
+    return value.map((entry) => Array.isArray(entry) ? [Number(entry[0]), Number(entry[1])] : null).filter((entry) => !!entry && Number.isFinite(entry[0]));
+  };
+  let commanderTagPositions = [];
+  let deadTagMark = details.durationMS || 0;
+  let deadTag = false;
+  const commanderPlayer = players.find((player) => player?.hasCommanderTag && !player?.notInSquad);
+  if (commanderPlayer?.combatReplayData?.positions) {
+    commanderTagPositions = commanderPlayer.combatReplayData.positions;
+    const commanderDeaths = toPairs(commanderPlayer.combatReplayData.dead);
+    commanderDeaths.forEach(([deathTime]) => {
+      if (deathTime > 0) {
+        deadTag = true;
+        deadTagMark = Math.min(deadTagMark, deathTime);
+      }
+    });
+  }
+  const getDistanceToTag = (p) => {
+    const stats = p.statsAll?.[0];
+    if (stats?.distToCom !== void 0 && stats?.distToCom !== "Infinity") return Math.round(Number(stats.distToCom));
+    if (stats?.stackDist !== void 0) return Math.round(Number(stats.stackDist)) || 0;
+    if (p.hasCommanderTag) return 0;
+    const combatData = p.combatReplayData;
+    if (!combatData?.positions || !commanderTagPositions.length) return 0;
+    const playerPositions = combatData.positions;
+    const playerDeaths = toPairs(combatData.dead);
+    const playerDowns = toPairs(combatData.down);
+    const playerOffset = Math.floor((combatData.start || 0) / pollingRate);
+    let playerDistToTag = 0;
+    if (playerDeaths.length && playerDowns.length) {
+      for (const [deathKey] of playerDeaths) {
+        if (deathKey < 0) continue;
+        const positionMark = Math.max(0, Math.floor(deathKey / pollingRate)) - playerOffset;
+        for (const [downKey, downValue] of playerDowns) {
+          if (deathKey !== downValue) continue;
+          const playerDeadPoll = deadTag && downKey > deadTagMark ? Math.max(1, Math.floor(deadTagMark / pollingRate)) : positionMark;
+          const limit = Math.max(0, Math.min(playerDeadPoll, playerPositions.length, commanderTagPositions.length));
+          if (limit <= 0) continue;
+          let sum = 0;
+          for (let i = 0; i < limit; i++) {
+            const [px, py] = playerPositions[i];
+            const [tx, ty] = commanderTagPositions[i];
+            sum += Math.hypot(px - tx, py - ty);
+          }
+          playerDistToTag = Math.round(sum / limit / inchesToPixel);
+        }
+      }
+    }
+    return playerDistToTag;
+  };
+  acc.totalSquadSizeAccum += squadPlayers.length;
+  acc.totalEnemiesAccum += targets.filter((t) => !t.isFake).length;
+  applySquadStabilityGeneration(players, { durationMS: details.durationMS, buffMap: details.buffMap });
+  const { squadDownsDeaths, enemyDownsDeaths, squadDeaths, enemyDeaths } = getFightDownsDeaths(details);
+  acc.totalSquadDeaths += squadDeaths;
+  acc.totalSquadKills += enemyDeaths;
+  acc.totalEnemyKills += squadDeaths;
+  acc.totalEnemyDeaths += enemyDeaths;
+  acc.totalSquadDowns += Math.max(0, squadDownsDeaths - squadDeaths);
+  acc.totalEnemyDowns += Math.max(0, enemyDownsDeaths - enemyDeaths);
+  const isWin = getFightOutcome(details);
+  if (isWin) acc.wins++;
+  else acc.losses++;
+  const battleStandardSkillId = details.skillMap ? Number(Object.keys(details.skillMap).find((key) => details.skillMap?.[key]?.name === "Battle Standard")?.replace(/^s/, "")) : null;
+  const healAddonCharacters = /* @__PURE__ */ new Set();
+  const usedExtensions = Array.isArray(details.usedExtensions) ? details.usedExtensions : [];
+  usedExtensions.forEach((ext) => {
+    if (ext?.name !== "Healing Stats") return;
+    const running = Array.isArray(ext.runningExtension) ? ext.runningExtension : [];
+    running.forEach((charName) => {
+      if (typeof charName === "string" && charName.length > 0) healAddonCharacters.add(charName);
+    });
+  });
+  players.forEach((p, playerIndex) => {
+    if (p.notInSquad) return;
+    const identity = getPlayerIdentity(p, splitPlayersByClass);
+    const key = identity.key;
+    const name = p.name || "Unknown";
+    if (!acc.playerStats.has(key)) {
+      acc.playerStats.set(key, {
+        name,
+        account: identity.accountLabel,
+        characterNames: /* @__PURE__ */ new Set(),
+        downContrib: 0,
+        cleanses: 0,
+        strips: 0,
+        stab: 0,
+        healing: 0,
+        barrier: 0,
+        cc: 0,
+        interrupts: 0,
+        logsJoined: 0,
+        totalDist: 0,
+        distCount: 0,
+        stackedLogCount: 0,
+        dodges: 0,
+        downs: 0,
+        deaths: 0,
+        kills: 0,
+        enemyDowns: 0,
+        damageTaken: 0,
+        breakbar: 0,
+        blocks: 0,
+        evades: 0,
+        misses: 0,
+        totalFightMs: 0,
+        offenseTotals: {},
+        offenseRateWeights: {},
+        defenseActiveMs: 0,
+        defenseTotals: {},
+        defenseMinionDamageTaken: {},
+        supportActiveMs: 0,
+        supportTotals: {},
+        healingActiveMs: 0,
+        healingTotals: {},
+        hasHealAddon: false,
+        profession: identity.profession,
+        professions: /* @__PURE__ */ new Set(),
+        professionTimeMs: {},
+        squadActiveMs: 0,
+        firstSeenFightTs: 0,
+        lastSeenFightTs: 0,
+        lastSeenFightDurationMs: 0,
+        isCommander: false,
+        damage: 0,
+        dps: 0,
+        revives: 0,
+        outgoingConditions: {},
+        incomingConditions: {},
+        damageModTotals: {},
+        incomingDamageModTotals: {},
+        roleClassification: { role: "damage", supportScore: 0, confidenceScore: 0, threshold: 0, factors: [] }
+      });
+    }
+    const s = acc.playerStats.get(key);
+    if (p.hasCommanderTag) s.isCommander = true;
+    if (name && name !== "Unknown") s.characterNames.add(String(name));
+    if (p.profession && p.profession !== "Unknown") {
+      s.profession = p.profession;
+      s.professions.add(p.profession);
+      const activeMs2 = Array.isArray(p.activeTimes) && typeof p.activeTimes[0] === "number" ? p.activeTimes[0] : details.durationMS || 0;
+      s.professionTimeMs[p.profession] = (s.professionTimeMs[p.profession] || 0) + activeMs2;
+    }
+    s.logsJoined++;
+    s.downContrib += computeDownContribution(p);
+    s.cleanses += getPlayerCleanses(p);
+    s.strips += getPlayerStrips(p, method);
+    s.healing += computeSquadHealing(p);
+    s.barrier += computeSquadBarrier(p);
+    s.cc += computeOutgoingCrowdControl(p, method);
+    s.interrupts += getPlayerOutgoingInterrupts(p);
+    s.stab += p.stabGeneration || 0;
+    const dist = getDistanceToTag(p);
+    if (dist <= RUN_BACK_RANGE) {
+      s.totalDist += dist;
+      s.distCount++;
+    }
+    if (dist <= 600) {
+      s.stackedLogCount++;
+    }
+    if (p.defenses?.[0]) {
+      s.dodges += p.defenses[0].dodgeCount || 0;
+      s.downs += p.defenses[0].downCount || 0;
+      s.deaths += p.defenses[0].deadCount || 0;
+    }
+    s.damageTaken += getPlayerDamageTaken(p);
+    s.breakbar += getPlayerBreakbarDamage(p);
+    s.blocks += getPlayerBlocked(p);
+    s.evades += getPlayerEvaded(p);
+    s.misses += getPlayerMissed(p);
+    s.kills += getTargetStatTotal(p, "killed");
+    s.enemyDowns += getTargetStatTotal(p, "downed");
+    if (details.durationMS) s.totalFightMs += details.durationMS;
+    const activeMs = Array.isArray(p.activeTimes) && typeof p.activeTimes[0] === "number" ? p.activeTimes[0] : details.durationMS || 0;
+    s.squadActiveMs += activeMs;
+    const fightTs = resolveFightTimestamp(details, log);
+    const fightDurationMs = Number(details?.durationMS || 0);
+    if (fightTs > 0) {
+      if (s.firstSeenFightTs <= 0 || fightTs < s.firstSeenFightTs) {
+        s.firstSeenFightTs = fightTs;
+      }
+      if (s.lastSeenFightTs <= 0 || fightTs > s.lastSeenFightTs) {
+        s.lastSeenFightTs = fightTs;
+        s.lastSeenFightDurationMs = fightDurationMs;
+      } else if (fightTs === s.lastSeenFightTs && fightDurationMs > s.lastSeenFightDurationMs) {
+        s.lastSeenFightDurationMs = fightDurationMs;
+      }
+    }
+    s.defenseActiveMs += activeMs;
+    s.supportActiveMs += activeMs;
+    s.healingActiveMs += activeMs;
+    if (Array.isArray(p.buffUptimes) && p.buffUptimes.length > 0) {
+      const nonDamagingBuffs = p.buffUptimes.filter((buff) => {
+        if (typeof buff?.id !== "number") return false;
+        const buffId = `b${buff.id}`;
+        const meta = details.buffMap?.[buffId] || details.buffMap?.[String(buff.id)];
+        if (!meta || isBoon(meta)) return false;
+        return true;
+      });
+      nonDamagingBuffs.forEach((buff) => {
+        if (typeof buff?.id !== "number") return;
+        const buffId = `b${buff.id}`;
+        const meta = details.buffMap?.[buffId] || details.buffMap?.[String(buff.id)];
+        const uptime = Number(buff.buffData?.[0]?.uptime ?? 0);
+        const presence = Number(buff.buffData?.[0]?.presence ?? 0);
+        if ((!Number.isFinite(uptime) || uptime <= 0) && (!Number.isFinite(presence) || presence <= 0)) return;
+        const stacking = meta?.stacking ?? false;
+        const uptimeFactor = stacking ? Number.isFinite(uptime) ? uptime : 0 : Number.isFinite(uptime) ? uptime / 100 : 0;
+        const totalMs = uptimeFactor * activeMs;
+        const uptimePercentRaw = stacking ? presence : uptime;
+        const uptimePercentFactor = Math.min(Math.max(Number.isFinite(uptimePercentRaw) ? uptimePercentRaw : 0, 0), 100) / 100;
+        const uptimeMs = uptimePercentFactor * activeMs;
+        const hasTotalMs = Number.isFinite(totalMs) && totalMs > 0;
+        const hasUptimeMs = Number.isFinite(uptimeMs) && uptimeMs > 0;
+        if (!hasTotalMs && !hasUptimeMs) return;
+        const conditionName = normalizeConditionLabel(meta?.name);
+        if (conditionName && NON_DAMAGING_CONDITIONS.has(conditionName) && (!meta?.classification || meta.classification === "Condition")) {
+          const seconds = totalMs / 1e3;
+          const conditionIcon = meta?.icon;
+          const incomingSummary = acc.incomingCondiTotals[conditionName] || {
+            name: conditionName,
+            icon: conditionIcon,
+            applications: 0,
+            damage: 0
+          };
+          incomingSummary.applicationsFromUptime = (incomingSummary.applicationsFromUptime || 0) + seconds;
+          if (!incomingSummary.icon && conditionIcon) incomingSummary.icon = conditionIcon;
+          acc.incomingCondiTotals[conditionName] = incomingSummary;
+          const incomingEntry = s.incomingConditions[conditionName] || {
+            applications: 0,
+            damage: 0,
+            skills: {},
+            icon: conditionIcon
+          };
+          incomingEntry.applicationsFromUptime = (incomingEntry.applicationsFromUptime || 0) + seconds;
+          if (!incomingEntry.icon && conditionIcon) incomingEntry.icon = conditionIcon;
+          s.incomingConditions[conditionName] = incomingEntry;
+        }
+        if (!acc.specialBuffMeta.has(buffId)) {
+          acc.specialBuffMeta.set(buffId, { name: meta?.name, stacking, icon: meta?.icon });
+        }
+        const specialBucketKey = identity.key;
+        const agg = ensureSpecialBuffEntry(
+          acc.specialBuffAgg,
+          buffId,
+          specialBucketKey,
+          identity.accountLabel,
+          s.profession || p.profession || "Unknown"
+        );
+        const prof = p.profession || s.profession;
+        if (prof && prof !== "Unknown") {
+          agg.professions.add(prof);
+          agg.professionTimeMs[prof] = (agg.professionTimeMs[prof] || 0) + activeMs;
+          agg.profession = prof;
+        }
+        agg.totalMs += hasTotalMs ? totalMs : 0;
+        agg.uptimeMs += hasUptimeMs ? uptimeMs : 0;
+        agg.durationMs += activeMs;
+        const statesPerSource = buff?.statesPerSource && typeof buff.statesPerSource === "object" ? buff.statesPerSource : null;
+        if (!statesPerSource || Object.keys(statesPerSource).length === 0) {
+        } else {
+          Object.entries(statesPerSource).forEach(([sourceName, states]) => {
+            const sourceNameText = String(sourceName || "").trim();
+            const sourceNameLower = sourceNameText.toLowerCase();
+            const instanceMatch = sourceNameText.match(/\bpl-(\d+)\b/i);
+            const sourceIdentity = specialBuffSourceIdentityByName.get(sourceNameLower) || (instanceMatch ? specialBuffSourceIdentityByInstanceId.get(Number(instanceMatch[1])) : void 0) || {
+              key: `source:${sourceNameLower || "unknown"}`,
+              accountLabel: sourceNameText || "Unknown Source",
+              profession: resolveProfessionLabel(sourceNameText.replace(/\s+pl-\d+\s*$/i, "").trim() || "Unknown")
+            };
+            const sourceDurationMs = Number(specialBuffSourceActiveMsByKey.get(sourceIdentity.key) || details?.durationMS || 0);
+            if (!Number.isFinite(sourceDurationMs) || sourceDurationMs <= 0) return;
+            const sourceContribution = integrateSourceStates(states, sourceDurationMs, stacking);
+            const hasSourceTotal = Number.isFinite(sourceContribution.totalMs) && sourceContribution.totalMs > 0;
+            const hasSourceUptime = Number.isFinite(sourceContribution.uptimeMs) && sourceContribution.uptimeMs > 0;
+            if (!hasSourceTotal && !hasSourceUptime) return;
+            const sourceAgg = ensureSpecialBuffEntry(
+              acc.specialBuffOutputAgg,
+              buffId,
+              sourceIdentity.key,
+              sourceIdentity.accountLabel,
+              sourceIdentity.profession
+            );
+            const sourceProf = sourceIdentity.profession || "Unknown";
+            if (sourceProf && sourceProf !== "Unknown") {
+              sourceAgg.professions.add(sourceProf);
+              sourceAgg.profession = sourceProf;
+            }
+            sourceAgg.totalMs += hasSourceTotal ? sourceContribution.totalMs : 0;
+            sourceAgg.uptimeMs += hasSourceUptime ? sourceContribution.uptimeMs : 0;
+            const durationSeenKey = `${buffId}::${sourceIdentity.key}`;
+            if (!specialBuffOutputDurationSeen.has(durationSeenKey)) {
+              specialBuffOutputDurationSeen.add(durationSeenKey);
+              if (sourceProf && sourceProf !== "Unknown") {
+                sourceAgg.professionTimeMs[sourceProf] = (sourceAgg.professionTimeMs[sourceProf] || 0) + sourceDurationMs;
+              }
+              sourceAgg.durationMs += sourceDurationMs;
+            }
+          });
+        }
+      });
+    }
+    if (p.defenses?.[0]) {
+      const normalizeMinionName = (rawName) => {
+        let minionName = String(rawName || "Unknown").replace(/^Juvenile\s+/i, "") || "Unknown";
+        if (minionName.toUpperCase().includes("UNKNOWN")) minionName = "Unknown";
+        return minionName;
+      };
+      const getMinionDamageTaken = () => {
+        const minions = Array.isArray(p?.minions) ? p.minions : [];
+        if (minions.length === 0) return { total: 0, byMinion: {} };
+        let total = 0;
+        const byMinion = {};
+        minions.forEach((minion) => {
+          const dist2 = Array.isArray(minion?.totalDamageTakenDist) ? minion.totalDamageTakenDist : [];
+          const entries = Array.isArray(dist2[0]) ? dist2[0] : [];
+          const minionName = normalizeMinionName(minion?.name);
+          entries.forEach((entry) => {
+            const damage = Number(entry?.totalDamage ?? entry?.damageTaken ?? 0);
+            if (Number.isFinite(damage)) {
+              total += damage;
+              byMinion[minionName] = (byMinion[minionName] || 0) + damage;
+            }
+          });
+        });
+        return { total, byMinion };
+      };
+      const minionDamage = getMinionDamageTaken();
+      if (minionDamage.byMinion && typeof minionDamage.byMinion === "object") {
+        Object.entries(minionDamage.byMinion).forEach(([minionName, damage]) => {
+          const numeric = Number(damage || 0);
+          if (!Number.isFinite(numeric) || numeric <= 0) return;
+          s.defenseMinionDamageTaken[minionName] = (s.defenseMinionDamageTaken[minionName] || 0) + numeric;
+        });
+      }
+      DEFENSE_METRICS.forEach((m) => {
+        const val = m.id === "minionDamageTaken" ? minionDamage.total : Number(p.defenses[0][m.field] ?? 0);
+        if (Number.isFinite(val)) s.defenseTotals[m.id] = (s.defenseTotals[m.id] || 0) + val;
+      });
+    }
+    if (p.support?.[0]) {
+      SUPPORT_METRICS.forEach((m) => {
+        if (m.id === "boonStrips") return;
+        let val = Number(p.support[0][m.field] ?? 0);
+        if (Number.isFinite(val)) {
+          if (supportTimeSanityFields.has(m.field) && val > 999999) val = 0;
+          s.supportTotals[m.id] = (s.supportTotals[m.id] || 0) + val;
+        }
+      });
+      s.supportTotals.boonStrips = (s.supportTotals.boonStrips || 0) + getPlayerStrips(p, method);
+    }
+    const addHealing = (key2, val) => {
+      if (Number.isFinite(val)) s.healingTotals[key2] = (s.healingTotals[key2] || 0) + val;
+    };
+    const sumPhaseValue = (phases, field) => {
+      if (!Array.isArray(phases)) return 0;
+      return phases.reduce((sum, phase) => sum + Number(phase?.[field] ?? 0), 0);
+    };
+    const addHealingByCategory = (fieldBase, allyIdx, value) => {
+      if (!Number.isFinite(value) || value <= 0) return;
+      const ally = players[allyIdx];
+      const isSelf = allyIdx === playerIndex;
+      const isOffSquad = ally?.notInSquad;
+      const isSquad = !isOffSquad;
+      const isGroup = isSquad && ally?.group != null && ally.group === p.group;
+      addHealing(fieldBase, value);
+      if (isSquad) addHealing(`squad${fieldBase[0].toUpperCase()}${fieldBase.slice(1)}`, value);
+      if (isGroup) addHealing(`group${fieldBase[0].toUpperCase()}${fieldBase.slice(1)}`, value);
+      if (isSelf) addHealing(`self${fieldBase[0].toUpperCase()}${fieldBase.slice(1)}`, value);
+      if (isOffSquad) addHealing(`offSquad${fieldBase[0].toUpperCase()}${fieldBase.slice(1)}`, value);
+    };
+    if (Array.isArray(p.rotation)) {
+      let resCasts = 0;
+      p.rotation.forEach((rot) => {
+        if (!rot?.id || !isResUtilitySkill(rot.id, details.skillMap)) return;
+        const count = rot.skills?.length || 0;
+        if (count > 0) {
+          resCasts += count;
+          addHealing(`resUtility_s${rot.id}`, count);
+        }
+      });
+      if (resCasts > 0) addHealing("resUtility", resCasts);
+    }
+    const outgoingHealingAllies = p.extHealingStats?.outgoingHealingAllies;
+    if (Array.isArray(outgoingHealingAllies)) {
+      outgoingHealingAllies.forEach((allyPhases, allyIdx) => {
+        const healing = sumPhaseValue(allyPhases, "healing");
+        const downedHealing = sumPhaseValue(allyPhases, "downedHealing");
+        addHealingByCategory("healing", allyIdx, healing);
+        addHealingByCategory("downedHealing", allyIdx, downedHealing);
+      });
+    }
+    const outgoingBarrierAllies = p.extBarrierStats?.outgoingBarrierAllies;
+    if (Array.isArray(outgoingBarrierAllies)) {
+      outgoingBarrierAllies.forEach((allyPhases, allyIdx) => {
+        const barrier = sumPhaseValue(allyPhases, "barrier");
+        addHealingByCategory("barrier", allyIdx, barrier);
+      });
+    }
+    const statsAll = p.statsAll?.[0];
+    const dpsAll = p.dpsAll?.[0];
+    const support = p.support?.[0];
+    OFFENSE_METRICS.forEach((m) => {
+      if (m.id === "downContributionPercent" || m.id === "downContribution" || m.id === "boonStrips") return;
+      if (!m.field) return;
+      let val = 0;
+      let denom = 0;
+      if (m.source === "dpsAll" && dpsAll) val = Number(dpsAll[m.field] ?? 0);
+      else if (m.source === "statsAll" && statsAll) {
+        val = Number(statsAll[m.field] ?? 0);
+        denom = Number(statsAll[m.denomField || m.weightField || "connectedDamageCount"] ?? 0);
+      } else if (m.source === "support" && support) {
+        val = Number(support[m.field] ?? 0);
+      } else if (p.statsTargets) {
+        p.statsTargets.forEach((t) => {
+          if (!t?.[0]) return;
+          val += Number(t[0][m.field] ?? 0);
+          denom += Number(t[0][m.denomField || m.weightField || "connectedDamageCount"] ?? 0);
+        });
+      }
+      if (Number.isFinite(val)) {
+        s.offenseTotals[m.id] = (s.offenseTotals[m.id] || 0) + val;
+        if (m.isRate && denom > 0) s.offenseRateWeights[m.id] = (s.offenseRateWeights[m.id] || 0) + denom;
+      }
+    });
+    s.offenseTotals.downContribution = (s.offenseTotals.downContribution || 0) + computeDownContribution(p);
+    s.offenseTotals.boonStrips = (s.offenseTotals.boonStrips || 0) + getPlayerStrips(p, method);
+    if (p.targetDamageDist && Number.isFinite(battleStandardSkillId)) {
+      const connectedHits = p.targetDamageDist.flatMap((group) => group || []).flatMap((list) => list || []).reduce((sum, entry) => {
+        if (!entry?.id) return sum;
+        return entry.id === battleStandardSkillId ? sum + (entry?.connectedHits || 0) : sum;
+      }, 0);
+      s.offenseTotals.battleStandardHits = (s.offenseTotals.battleStandardHits || 0) + connectedHits;
+    }
+    s.revives += p.support?.[0]?.resurrects || 0;
+    if (dpsAll) {
+      s.damage += dpsAll.damage || 0;
+      s.dps += dpsAll.dps || 0;
+    }
+    const resolveSkillMeta = (entry) => {
+      let name2 = `Skill ${entry.id}`;
+      const mapped = details.skillMap?.[`s${entry.id}`] || details.skillMap?.[`${entry.id}`];
+      let icon = mapped?.icon;
+      if (mapped?.name) name2 = mapped.name;
+      const buffMeta = resolveBuffMetaById(details.buffMap, entry.id);
+      if (name2.startsWith("Skill ") && buffMeta?.name) {
+        name2 = buffMeta.name;
+        icon = buffMeta.icon || icon;
+      }
+      if (name2.startsWith("Skill ")) {
+        const conditionName = resolveConditionNameFromEntry(name2, entry.id, details.buffMap);
+        if (conditionName) {
+          name2 = conditionName;
+          icon = buffMeta?.icon || icon;
+        }
+      }
+      return { name: name2, icon };
+    };
+    const playerProfession = p.profession || "Unknown";
+    const extractPhase0 = (dist2) => {
+      if (!Array.isArray(dist2)) return [];
+      const phase0 = dist2[0];
+      return Array.isArray(phase0) ? phase0 : [];
+    };
+    const healingPlayerKey = identity.key;
+    let healingBd = acc.healingBreakdownMap.get(healingPlayerKey);
+    if (!healingBd) {
+      healingBd = {
+        key: healingPlayerKey,
+        account: identity.accountLabel,
+        displayName: identity.accountLabel,
+        profession: playerProfession,
+        professionList: [playerProfession],
+        healingSkills: /* @__PURE__ */ new Map(),
+        barrierSkills: /* @__PURE__ */ new Map(),
+        hasHealAddon: false
+      };
+      acc.healingBreakdownMap.set(healingPlayerKey, healingBd);
+    }
+    if (playerProfession && !healingBd.professionList.includes(playerProfession)) {
+      healingBd.professionList.push(playerProfession);
+    }
+    if (typeof p.name === "string" && healAddonCharacters.has(p.name)) {
+      healingBd.hasHealAddon = true;
+      const ps = acc.playerStats.get(healingPlayerKey);
+      if (ps) ps.hasHealAddon = true;
+    }
+    const pushHealingSkillEntry = (entry, skillMap, totalField) => {
+      if (!entry?.id) return;
+      const amount = Number(entry[totalField] || 0);
+      if (!Number.isFinite(amount) || amount <= 0) return;
+      const { name: name2, icon } = resolveSkillMeta(entry);
+      const skillId = `s${entry.id}`;
+      let existing = skillMap.get(skillId);
+      if (!existing) {
+        existing = { id: skillId, name: name2, icon, total: 0, hits: 0, max: 0 };
+        skillMap.set(skillId, existing);
+      }
+      if (existing.name.startsWith("Skill ") && !name2.startsWith("Skill ")) existing.name = name2;
+      if (!existing.icon && icon) existing.icon = icon;
+      existing.total += amount;
+      existing.hits += Number(entry.hits || 0);
+      existing.max = Math.max(existing.max, Number(entry.max || 0));
+    };
+    extractPhase0(p.extHealingStats?.totalHealingDist).forEach((entry) => {
+      pushHealingSkillEntry(entry, healingBd.healingSkills, "totalHealing");
+    });
+    extractPhase0(p.extBarrierStats?.totalBarrierDist).forEach((entry) => {
+      pushHealingSkillEntry(entry, healingBd.barrierSkills, "totalBarrier");
+    });
+    const pushSkillDamageEntry = (entry) => {
+      if (!entry?.id) return;
+      const { name: name2, icon } = resolveSkillMeta(entry);
+      if (!acc.skillDamageMap[entry.id]) acc.skillDamageMap[entry.id] = { name: name2, icon, damage: 0, hits: 0, downContribution: 0 };
+      if (acc.skillDamageMap[entry.id].name.startsWith("Skill ") && !name2.startsWith("Skill ")) acc.skillDamageMap[entry.id].name = name2;
+      if (!acc.skillDamageMap[entry.id].icon && icon) acc.skillDamageMap[entry.id].icon = icon;
+      acc.skillDamageMap[entry.id].damage += entry.totalDamage;
+      acc.skillDamageMap[entry.id].hits += entry.connectedHits;
+      acc.skillDamageMap[entry.id].downContribution += Number(entry.downContribution || 0);
+    };
+    const playerKey = identity.key;
+    let playerBreakdown = acc.playerSkillBreakdownMap.get(playerKey);
+    if (!playerBreakdown) {
+      playerBreakdown = {
+        key: playerKey,
+        account: identity.accountLabel,
+        displayName: identity.accountLabel,
+        profession: playerProfession,
+        professionList: [playerProfession],
+        totalFightMs: 0,
+        skills: /* @__PURE__ */ new Map()
+      };
+      acc.playerSkillBreakdownMap.set(playerKey, playerBreakdown);
+    }
+    if (playerProfession && !playerBreakdown.professionList.includes(playerProfession)) {
+      playerBreakdown.professionList.push(playerProfession);
+    }
+    playerBreakdown.totalFightMs += details.durationMS || 0;
+    const pushPlayerSkillEntry = (entry) => {
+      if (!entry?.id) return;
+      const { name: name2, icon } = resolveSkillMeta(entry);
+      const skillId = `s${entry.id}`;
+      let skillEntry = playerBreakdown.skills.get(skillId);
+      if (!skillEntry) {
+        skillEntry = { id: skillId, name: name2, icon, damage: 0, downContribution: 0, hits: 0, casts: 0, min: Infinity, max: 0 };
+        playerBreakdown.skills.set(skillId, skillEntry);
+      }
+      if (skillEntry.name.startsWith("Skill ") && !name2.startsWith("Skill ")) skillEntry.name = name2;
+      if (!skillEntry.icon && icon) skillEntry.icon = icon;
+      skillEntry.damage += Number(entry.totalDamage || 0);
+      skillEntry.downContribution += Number(entry.downContribution || 0);
+      skillEntry.hits += Number(entry.hits || 0);
+      const entryMin = Number(entry.min);
+      if (Number.isFinite(entryMin) && entryMin > 0) {
+        skillEntry.min = Math.min(skillEntry.min, entryMin);
+      }
+      skillEntry.max = Math.max(skillEntry.max, Number(entry.max || 0));
+    };
+    if (skillDamageSource === "total") {
+      p.totalDamageDist?.forEach((list) => {
+        list?.forEach((entry) => {
+          pushSkillDamageEntry(entry);
+          pushPlayerSkillEntry(entry);
+        });
+      });
+    } else {
+      const targetSkillTotals = /* @__PURE__ */ new Map();
+      p.targetDamageDist?.forEach((targetGroup) => {
+        targetGroup?.forEach((list) => {
+          list?.forEach((entry) => {
+            const skillId = Number(entry?.id);
+            if (Number.isFinite(skillId)) {
+              const existing = targetSkillTotals.get(skillId) || { damage: 0, hits: 0, downContribution: 0 };
+              existing.damage += Number(entry?.totalDamage || 0);
+              existing.hits += Number(entry?.connectedHits || 0);
+              existing.downContribution += Number(entry?.downContribution || 0);
+              targetSkillTotals.set(skillId, existing);
+            }
+            pushSkillDamageEntry(entry);
+            pushPlayerSkillEntry(entry);
+          });
+        });
+      });
+      const allowTotalSupplement = !details?.detailedWvW;
+      if (allowTotalSupplement) {
+        p.totalDamageDist?.forEach((list) => {
+          list?.forEach((entry) => {
+            const skillId = Number(entry?.id);
+            if (!Number.isFinite(skillId)) return;
+            const target = targetSkillTotals.get(skillId);
+            if (!target) {
+              pushSkillDamageEntry(entry);
+              pushPlayerSkillEntry(entry);
+              return;
+            }
+            const totalDamage = Number(entry?.totalDamage || 0);
+            const totalHits = Number(entry?.connectedHits || 0);
+            const totalDownContribution = Number(entry?.downContribution || 0);
+            const deltaDamage = totalDamage - Number(target.damage || 0);
+            const deltaHits = totalHits - Number(target.hits || 0);
+            const deltaDownContribution = totalDownContribution - Number(target.downContribution || 0);
+            if (deltaDamage <= 0 && deltaHits <= 0 && deltaDownContribution <= 0) return;
+            const reconciledEntry = {
+              ...entry,
+              totalDamage: Math.max(0, deltaDamage),
+              connectedHits: Math.max(0, deltaHits),
+              downContribution: Math.max(0, deltaDownContribution),
+              hits: 0,
+              min: 0,
+              max: 0
+            };
+            pushSkillDamageEntry(reconciledEntry);
+            pushPlayerSkillEntry(reconciledEntry);
+          });
+        });
+      }
+    }
+    if (Array.isArray(p.rotation)) {
+      p.rotation.forEach((rot) => {
+        if (!rot?.id) return;
+        const count = rot.skills?.length || 0;
+        if (count <= 0) return;
+        const skillId = `s${rot.id}`;
+        const skillEntry = playerBreakdown.skills.get(skillId);
+        if (skillEntry) {
+          skillEntry.casts += count;
+        }
+      });
+    }
+    if (p.totalDamageTaken) {
+      p.totalDamageTaken.forEach((list) => {
+        list?.forEach((entry) => {
+          if (!entry?.id) return;
+          let name2 = `Skill ${entry.id}`;
+          const mapped = details.skillMap?.[`s${entry.id}`] || details.skillMap?.[`${entry.id}`];
+          let icon = mapped?.icon;
+          if (mapped?.name) name2 = mapped.name;
+          const buffMeta = resolveBuffMetaById(details.buffMap, entry.id);
+          if (name2.startsWith("Skill ") && buffMeta?.name) {
+            name2 = buffMeta.name;
+            icon = buffMeta.icon || icon;
+          }
+          if (name2.startsWith("Skill ")) {
+            const conditionName = resolveConditionNameFromEntry(name2, entry.id, details.buffMap);
+            if (conditionName) {
+              name2 = conditionName;
+              icon = buffMeta?.icon || icon;
+            }
+          }
+          if (!acc.incomingSkillDamageMap[entry.id]) acc.incomingSkillDamageMap[entry.id] = { name: name2, icon, damage: 0, hits: 0 };
+          if (!acc.incomingSkillDamageMap[entry.id].name.startsWith("Skill ") || name2.startsWith("Skill ")) acc.incomingSkillDamageMap[entry.id].name = name2;
+          if (!acc.incomingSkillDamageMap[entry.id].icon && icon) acc.incomingSkillDamageMap[entry.id].icon = icon;
+          acc.incomingSkillDamageMap[entry.id].damage += entry.totalDamage;
+          acc.incomingSkillDamageMap[entry.id].hits += entry.hits;
+        });
+      });
+    }
+    if (p.damageModifiers) {
+      for (const entry of p.damageModifiers) {
+        const phase0 = entry.damageModifiers?.[0];
+        if (!phase0) continue;
+        const key2 = `d${entry.id}`;
+        const existing = s.damageModTotals[key2];
+        if (existing) {
+          existing.damageGain += phase0.damageGain;
+          existing.hitCount += phase0.hitCount;
+          existing.totalHitCount += phase0.totalHitCount;
+          existing.totalDamage += phase0.totalDamage;
+        } else {
+          s.damageModTotals[key2] = {
+            damageGain: phase0.damageGain,
+            hitCount: phase0.hitCount,
+            totalHitCount: phase0.totalHitCount,
+            totalDamage: phase0.totalDamage
+          };
+        }
+      }
+    }
+    if (p.incomingDamageModifiers) {
+      for (const entry of p.incomingDamageModifiers) {
+        const phase0 = entry.damageModifiers?.[0];
+        if (!phase0) continue;
+        const key2 = `d${entry.id}`;
+        const existing = s.incomingDamageModTotals[key2];
+        if (existing) {
+          existing.damageGain += phase0.damageGain;
+          existing.hitCount += phase0.hitCount;
+          existing.totalHitCount += phase0.totalHitCount;
+          existing.totalDamage += phase0.totalDamage;
+        } else {
+          s.incomingDamageModTotals[key2] = {
+            damageGain: phase0.damageGain,
+            hitCount: phase0.hitCount,
+            totalHitCount: phase0.totalHitCount,
+            totalDamage: phase0.totalDamage
+          };
+        }
+      }
+    }
+  });
+  targets.forEach((t) => {
+    if (t?.isFake) return;
+    const name = resolveProfessionLabel(t?.profession || t?.name || t?.id);
+    if (!name) return;
+    acc.enemyProfessionCounts[name] = (acc.enemyProfessionCounts[name] || 0) + 1;
+  });
+  const conditionResult = computeOutgoingConditions({
+    players,
+    targets,
+    skillMap: details.skillMap,
+    buffMap: details.buffMap,
+    getPlayerKey: (pl) => getPlayerIdentity(pl, splitPlayersByClass).key
+  });
+  const conditionIconMap = buildConditionIconMap(details.buffMap);
+  Object.entries(conditionResult.playerConditions).forEach(([k, totals]) => {
+    const ps = acc.playerStats.get(k);
+    if (!ps) return;
+    Object.entries(totals).forEach(([cName, v]) => {
+      const ex = ps.outgoingConditions[cName] || { applications: 0, damage: 0, skills: {}, icon: v.icon };
+      ex.applications += Number(v.applications || 0);
+      ex.damage += Number(v.damage || 0);
+      if (v.applicationsFromBuffs) ex.applicationsFromBuffs = (ex.applicationsFromBuffs || 0) + v.applicationsFromBuffs;
+      if (v.applicationsFromBuffsActive) ex.applicationsFromBuffsActive = (ex.applicationsFromBuffsActive || 0) + v.applicationsFromBuffsActive;
+      if (v.uptimeMs) ex.uptimeMs = (ex.uptimeMs || 0) + v.uptimeMs;
+      Object.entries(v.skills || {}).forEach(([sn, sv]) => {
+        const sk = ex.skills[sn] || { name: sv.name, hits: 0, damage: 0, icon: sv.icon };
+        sk.hits += Number(sv.hits || 0);
+        sk.damage += Number(sv.damage || 0);
+        if (!sk.icon && sv.icon) sk.icon = sv.icon;
+        ex.skills[sn] = sk;
+      });
+      if (!ex.icon && v.icon) ex.icon = v.icon;
+      ps.outgoingConditions[cName] = ex;
+    });
+  });
+  Object.entries(conditionResult.summary).forEach(([cName, v]) => {
+    const ex = acc.outgoingCondiTotals[cName] || { name: v.name || cName, icon: v.icon, applications: 0, damage: 0 };
+    ex.applications += Number(v.applications || 0);
+    ex.damage += Number(v.damage || 0);
+    if (v.applicationsFromBuffs) ex.applicationsFromBuffs = (ex.applicationsFromBuffs || 0) + v.applicationsFromBuffs;
+    if (v.applicationsFromBuffsActive) ex.applicationsFromBuffsActive = (ex.applicationsFromBuffsActive || 0) + v.applicationsFromBuffsActive;
+    if (v.uptimeMs) ex.uptimeMs = (ex.uptimeMs || 0) + v.uptimeMs;
+    if (!ex.icon && v.icon) ex.icon = v.icon;
+    acc.outgoingCondiTotals[cName] = ex;
+  });
+  squadPlayers.forEach((p) => {
+    const key = getPlayerIdentity(p, splitPlayersByClass).key;
+    const ps = acc.playerStats.get(key);
+    if (!ps || !p.totalDamageTaken) return;
+    p.totalDamageTaken.forEach((list) => list?.forEach((entry) => {
+      if (!entry?.id) return;
+      let sName = `Skill ${entry.id}`;
+      const sm = details.skillMap?.[`s${entry.id}`] || details.skillMap?.[`${entry.id}`];
+      if (sm?.name) sName = sm.name;
+      const buffMeta = resolveBuffMetaById(details.buffMap, entry.id);
+      if (sName.startsWith("Skill ") && buffMeta?.name) sName = buffMeta.name;
+      const finalName = resolveConditionNameFromEntry(sName, entry.id, details.buffMap);
+      if (!finalName) return;
+      const buffName = buffMeta?.name;
+      const conditionIcon = conditionIconMap.get(finalName) || buffMeta?.icon;
+      const skillIcon = sm?.icon || buffMeta?.icon || conditionIcon;
+      if (sName.startsWith("Skill ") && (buffName || finalName)) {
+        sName = buffName || finalName;
+      }
+      const hits = Number(entry.hits ?? 0);
+      const dmg = Number(entry.totalDamage ?? 0);
+      const summ = acc.incomingCondiTotals[finalName] || { name: finalName, icon: conditionIcon, applications: 0, damage: 0 };
+      summ.applications += Number.isFinite(hits) ? hits : 0;
+      summ.damage += Number.isFinite(dmg) ? dmg : 0;
+      if (!summ.icon && conditionIcon) summ.icon = conditionIcon;
+      acc.incomingCondiTotals[finalName] = summ;
+      const pEntry = ps.incomingConditions[finalName] || { applications: 0, damage: 0, skills: {}, icon: conditionIcon };
+      pEntry.applications += Number.isFinite(hits) ? hits : 0;
+      pEntry.damage += Number.isFinite(dmg) ? dmg : 0;
+      const skEntry = pEntry.skills[sName] || { name: sName, hits: 0, damage: 0, icon: skillIcon };
+      skEntry.hits += Number.isFinite(hits) ? hits : 0;
+      skEntry.damage += Number.isFinite(dmg) ? dmg : 0;
+      if (!skEntry.icon && skillIcon) skEntry.icon = skillIcon;
+      pEntry.skills[sName] = skEntry;
+      if (!pEntry.icon && conditionIcon) pEntry.icon = conditionIcon;
+      ps.incomingConditions[finalName] = pEntry;
+    }));
+  });
+  const mitigationSource = details.player_damage_mitigation || details.playerDamageMitigation;
+  const hasMitigationSource = mitigationSource && typeof mitigationSource === "object" && Object.keys(mitigationSource).length > 0;
+  if (hasMitigationSource) {
+    Object.entries(mitigationSource).forEach(([rawKey, skillMap]) => {
+      if (!skillMap || typeof skillMap !== "object") return;
+      const base = parseMitigationKey(rawKey);
+      const identity = getMitigationIdentity(base.account, base.profession, splitPlayersByClass);
+      const row = ensureMitigationRow(acc.damageMitigationPlayersMap, identity.key, { ...base, account: identity.accountLabel, profession: identity.profession });
+      Object.values(skillMap).forEach((entry) => {
+        const avoided = readNumber(entry?.avoided_damage ?? entry?.avoidedDamage);
+        if (avoided <= 0) return;
+        addMitigationTotals(row.mitigationTotals, entry);
+      });
+    });
+  }
+  const mitigationMinionSource = details.player_minion_damage_mitigation || details.playerMinionDamageMitigation;
+  const hasMitigationMinionSource = mitigationMinionSource && typeof mitigationMinionSource === "object" && Object.keys(mitigationMinionSource).length > 0;
+  if (hasMitigationMinionSource) {
+    Object.entries(mitigationMinionSource).forEach(([rawKey, minionMap]) => {
+      if (!minionMap || typeof minionMap !== "object") return;
+      const base = parseMitigationKey(rawKey);
+      const identity = getMitigationIdentity(base.account, base.profession, splitPlayersByClass);
+      Object.entries(minionMap).forEach(([minionName, skillMap]) => {
+        if (!skillMap || typeof skillMap !== "object") return;
+        const rowKey = `${identity.key}::${minionName}`;
+        const row = ensureMitigationMinionRow(acc.damageMitigationMinionsMap, rowKey, {
+          ...base,
+          account: identity.accountLabel,
+          profession: identity.profession,
+          minion: String(minionName || "Unknown")
+        });
+        Object.values(skillMap).forEach((entry) => {
+          addMitigationTotals(row.mitigationTotals, entry);
+        });
+      });
+    });
+  }
+  if (!hasMitigationSource || !hasMitigationMinionSource) {
+    if (!hasMitigationSource) {
+      squadPlayers.forEach((player) => {
+        const entries = player?.totalDamageTaken || [];
+        if (!Array.isArray(entries) || entries.length === 0) return;
+        const identity = getPlayerIdentity(player, splitPlayersByClass);
+        const base = {
+          account: identity.accountLabel,
+          name: player.name || identity.accountLabel,
+          profession: identity.profession
+        };
+        ensureMitigationRow(acc.damageMitigationPlayersMap, identity.key, base);
+        const list = Array.isArray(entries) ? entries[0] : null;
+        list?.forEach((entry) => {
+          if (!entry?.id) return;
+          const blocked = readNumber(entry.blocked);
+          const evaded = readNumber(entry.evaded);
+          const glanced = readNumber(entry.glance ?? entry.glanced);
+          const missed = readNumber(entry.missed);
+          const invulned = readNumber(entry.invulned);
+          const interrupted = readNumber(entry.interrupted);
+          const skillHits = readNumber(entry.hits ?? entry.connectedHits);
+          const skillId = Number(entry.id);
+          updateCumulativeCounts(
+            acc.mitigationCumulativeCounts,
+            `${identity.key}::${skillId}`,
+            {
+              totalHits: skillHits,
+              blocked,
+              evaded,
+              glanced,
+              missed,
+              invulned,
+              interrupted,
+              totalMitigation: 0,
+              minMitigation: 0
+            }
+          );
+        });
+      });
+    }
+    if (!hasMitigationMinionSource) {
+      squadPlayers.forEach((player) => {
+        const minions = player?.minions || [];
+        if (!Array.isArray(minions) || minions.length === 0) return;
+        const identity = getPlayerIdentity(player, splitPlayersByClass);
+        const base = {
+          account: identity.accountLabel,
+          name: player.name || identity.accountLabel,
+          profession: identity.profession
+        };
+        minions.forEach((minion) => {
+          const minionEntries = minion?.totalDamageTakenDist || [];
+          if (!Array.isArray(minionEntries) || minionEntries.length === 0) return;
+          let minionName = String(minion?.name || "Unknown").replace(/^Juvenile\s+/i, "") || "Unknown";
+          if (minionName.toUpperCase().includes("UNKNOWN")) minionName = "Unknown";
+          const rowKey = `${identity.key}::${minionName}`;
+          ensureMitigationMinionRow(acc.damageMitigationMinionsMap, rowKey, { ...base, minion: minionName });
+          const list = Array.isArray(minionEntries) ? minionEntries[0] : null;
+          list?.forEach((entry) => {
+            if (!entry?.id) return;
+            const blocked = readNumber(entry.blocked);
+            const evaded = readNumber(entry.evaded);
+            const glanced = readNumber(entry.glance ?? entry.glanced);
+            const missed = readNumber(entry.missed);
+            const invulned = readNumber(entry.invulned);
+            const interrupted = readNumber(entry.interrupted);
+            const skillHits = readNumber(entry.hits ?? entry.connectedHits);
+            const skillId = Number(entry.id);
+            updateCumulativeCounts(
+              acc.mitigationMinionCumulativeCounts,
+              `${rowKey}::${skillId}`,
+              {
+                totalHits: skillHits,
+                blocked,
+                evaded,
+                glanced,
+                missed,
+                invulned,
+                interrupted,
+                totalMitigation: 0,
+                minMitigation: 0
+              }
+            );
+          });
+        });
+      });
+    }
+  }
+};
+var recomputeMitigationTotals = (rows, cumulative, globalEnemySkillStats) => {
+  const aggregate = /* @__PURE__ */ new Map();
+  const ensureAggregate = (key) => {
+    let bucket = aggregate.get(key);
+    if (!bucket) {
+      bucket = createMitigationTotals();
+      aggregate.set(key, bucket);
+    }
+    return bucket;
+  };
+  cumulative.forEach((counts, key) => {
+    const splitIndex = key.lastIndexOf("::");
+    const rowKey = splitIndex > -1 ? key.slice(0, splitIndex) : key;
+    const skillId = splitIndex > -1 ? Number(key.slice(splitIndex + 2)) : Number.NaN;
+    const enemy = Number.isFinite(skillId) ? resolveGlobalEnemyStats(globalEnemySkillStats, skillId) : { hasSkill: false, avg: 0, min: 0, hits: 0 };
+    if (!enemy.hasSkill || enemy.hits <= 0) return;
+    const avg = enemy.avg;
+    const min = enemy.min;
+    const avoid = counts.glanced * avg / 2 + (counts.blocked + counts.evaded + counts.missed + counts.invulned + counts.interrupted) * avg;
+    const avoidMin = counts.glanced * min / 2 + (counts.blocked + counts.evaded + counts.missed + counts.invulned + counts.interrupted) * min;
+    if (avoid <= 0) return;
+    const bucket = ensureAggregate(rowKey);
+    bucket.totalHits += counts.totalHits;
+    bucket.blocked += counts.blocked;
+    bucket.evaded += counts.evaded;
+    bucket.glanced += counts.glanced;
+    bucket.missed += counts.missed;
+    bucket.invulned += counts.invulned;
+    bucket.interrupted += counts.interrupted;
+    bucket.totalMitigation += avoid;
+    bucket.minMitigation += avoidMin;
+  });
+  rows.forEach((row, rowKey) => {
+    const totals = aggregate.get(rowKey) || createMitigationTotals();
+    row.mitigationTotals.totalHits = totals.totalHits;
+    row.mitigationTotals.blocked = totals.blocked;
+    row.mitigationTotals.evaded = totals.evaded;
+    row.mitigationTotals.glanced = totals.glanced;
+    row.mitigationTotals.missed = totals.missed;
+    row.mitigationTotals.invulned = totals.invulned;
+    row.mitigationTotals.interrupted = totals.interrupted;
+    row.mitigationTotals.totalMitigation = totals.totalMitigation;
+    row.mitigationTotals.minMitigation = totals.minMitigation;
+  });
+};
+var finalizePlayerAggregation = (acc) => {
+  recomputeMitigationTotals(acc.damageMitigationPlayersMap, acc.mitigationCumulativeCounts, acc.globalEnemySkillStats);
+  recomputeMitigationTotals(acc.damageMitigationMinionsMap, acc.mitigationMinionCumulativeCounts, acc.globalEnemySkillStats);
+};
+var computePlayerAggregation = ({
+  validLogs,
+  method,
+  skillDamageSource,
+  splitPlayersByClass
+}) => {
+  const acc = createPlayerAggregationAccumulators();
+  const options = { method, skillDamageSource, splitPlayersByClass };
+  for (const log of validLogs) {
+    precomputeGlobalEnemySkillStats(log, acc);
+  }
+  for (const log of validLogs) {
+    ingestLogPlayerData(log, acc, options);
+  }
+  finalizePlayerAggregation(acc);
+  return {
+    playerStats: acc.playerStats,
+    skillDamageMap: acc.skillDamageMap,
+    incomingSkillDamageMap: acc.incomingSkillDamageMap,
+    playerSkillBreakdownMap: acc.playerSkillBreakdownMap,
+    healingBreakdownMap: acc.healingBreakdownMap,
+    outgoingCondiTotals: acc.outgoingCondiTotals,
+    incomingCondiTotals: acc.incomingCondiTotals,
+    enemyProfessionCounts: acc.enemyProfessionCounts,
+    specialBuffMeta: acc.specialBuffMeta,
+    specialBuffAgg: acc.specialBuffAgg,
+    specialBuffOutputAgg: acc.specialBuffOutputAgg,
+    damageMitigationPlayersMap: acc.damageMitigationPlayersMap,
+    damageMitigationMinionsMap: acc.damageMitigationMinionsMap,
+    mitigationCumulativeCounts: acc.mitigationCumulativeCounts,
+    mitigationMinionCumulativeCounts: acc.mitigationMinionCumulativeCounts,
+    wins: acc.wins,
+    losses: acc.losses,
+    totalSquadSizeAccum: acc.totalSquadSizeAccum,
+    totalEnemiesAccum: acc.totalEnemiesAccum,
+    totalSquadDeaths: acc.totalSquadDeaths,
+    totalSquadKills: acc.totalSquadKills,
+    totalEnemyDeaths: acc.totalEnemyDeaths,
+    totalEnemyKills: acc.totalEnemyKills,
+    totalSquadDowns: acc.totalSquadDowns,
+    totalEnemyDowns: acc.totalEnemyDowns
+  };
+};
+
+export {
+  getFightDownsDeaths,
+  getFightOutcome,
+  resolveProfessionLabel,
+  createPlayerAggregationAccumulators,
+  precomputeGlobalEnemySkillStats,
+  ingestLogPlayerData,
+  finalizePlayerAggregation,
+  computePlayerAggregation
+};