@axiapps/bridge-metrics 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2902 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_DISRUPTION_METHOD: () => DEFAULT_DISRUPTION_METHOD,
+  METRICS_SPEC: () => METRICS_SPEC,
+  NON_DAMAGING_CONDITIONS: () => NON_DAMAGING_CONDITIONS,
+  PROFESSION_COLORS: () => PROFESSION_COLORS,
+  ROLLUP_SOURCES_VERSION: () => ROLLUP_SOURCES_VERSION,
+  ReportSchemaError: () => ReportSchemaError,
+  aggregatePlayers: () => aggregatePlayers,
+  applySquadStabilityGeneration: () => applySquadStabilityGeneration,
+  buildConditionIconMap: () => buildConditionIconMap,
+  buildRollupData: () => buildRollupData,
+  compareRunSets: () => compareRunSets,
+  computeDownContribution: () => computeDownContribution,
+  computeIncomingDisruptions: () => computeIncomingDisruptions,
+  computeOutgoingConditions: () => computeOutgoingConditions,
+  computeOutgoingCrowdControl: () => computeOutgoingCrowdControl,
+  computePlayerAggregation: () => computePlayerAggregation,
+  computeSquadBarrier: () => computeSquadBarrier,
+  computeSquadHealing: () => computeSquadHealing,
+  createPlayerAggregationAccumulators: () => createPlayerAggregationAccumulators,
+  extractRollupSource: () => extractRollupSource,
+  extractRunSummary: () => extractRunSummary,
+  finalizePlayerAggregation: () => finalizePlayerAggregation,
+  getDefaultConditionIcon: () => getDefaultConditionIcon,
+  getFightDownsDeaths: () => getFightDownsDeaths,
+  getFightOutcome: () => getFightOutcome,
+  getPlayerBlocked: () => getPlayerBlocked,
+  getPlayerBreakbarDamage: () => getPlayerBreakbarDamage,
+  getPlayerCleanses: () => getPlayerCleanses,
+  getPlayerDamage: () => getPlayerDamage,
+  getPlayerDamageTaken: () => getPlayerDamageTaken,
+  getPlayerDashboardTotals: () => getPlayerDashboardTotals,
+  getPlayerDeaths: () => getPlayerDeaths,
+  getPlayerDistanceToTag: () => getPlayerDistanceToTag,
+  getPlayerDodges: () => getPlayerDodges,
+  getPlayerDownsTaken: () => getPlayerDownsTaken,
+  getPlayerDps: () => getPlayerDps,
+  getPlayerEvaded: () => getPlayerEvaded,
+  getPlayerMissed: () => getPlayerMissed,
+  getPlayerOutgoingInterrupts: () => getPlayerOutgoingInterrupts,
+  getPlayerResurrects: () => getPlayerResurrects,
+  getPlayerStrips: () => getPlayerStrips,
+  getProfessionAbbrev: () => getProfessionAbbrev,
+  getProfessionAbbrevSuperscript: () => getProfessionAbbrevSuperscript,
+  getProfessionBase: () => getProfessionBase,
+  getProfessionColor: () => getProfessionColor,
+  getProfessionEmoji: () => getProfessionEmoji,
+  getTargetStatTotal: () => getTargetStatTotal,
+  hexToRgba: () => hexToRgba,
+  ingestLogPlayerData: () => ingestLogPlayerData,
+  isResUtilitySkill: () => isResUtilitySkill,
+  normalizeConditionLabel: () => normalizeConditionLabel,
+  parseFightTimestamp: () => parseTimestamp,
+  parseRollupSourcesFile: () => parseRollupSourcesFile,
+  precomputeGlobalEnemySkillStats: () => precomputeGlobalEnemySkillStats,
+  removeRollupSources: () => removeRollupSources,
+  resolveBuffMetaById: () => resolveBuffMetaById,
+  resolveConditionNameFromEntry: () => resolveConditionNameFromEntry,
+  resolveDisruptionValue: () => resolveDisruptionValue,
+  resolveFightTimestamp: () => resolveFightTimestamp,
+  resolveProfessionLabel: () => resolveProfessionLabel,
+  toSuperscript: () => toSuperscript,
+  updateRollupSourcesForPublish: () => updateRollupSourcesForPublish
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/metrics-methods.json
+var metrics_methods_default = {
+  specVersion: "v5",
+  methods: {
+    count: {
+      label: "Count Events",
+      summary: "Counts each CC/strip event once.",
+      implications: [
+        "Simple and stable across EI versions.",
+        "Multi-hit skills can inflate totals."
+      ]
+    },
+    duration: {
+      label: "Duration (Seconds)",
+      summary: "Uses total CC/strip duration in seconds.",
+      implications: [
+        "Reflects control impact more directly.",
+        "Totals represent time, not event count."
+      ]
+    },
+    tiered: {
+      label: "Tiered Impact",
+      summary: "Weights events based on average duration tiers.",
+      implications: [
+        "Balances short vs long CC/strip effects.",
+        "Uses averaged durations per player."
+      ],
+      tiers: {
+        shortMs: 500,
+        mediumMs: 1500,
+        weights: {
+          short: 0.5,
+          medium: 1,
+          long: 2
+        }
+      }
+    }
+  }
+};
+
+// src/metricsSettings.ts
+var METRICS_SPEC = metrics_methods_default;
+var DEFAULT_DISRUPTION_METHOD = "count";
+
+// src/boonGeneration.ts
+var CATEGORY_COUNT = {
+  selfBuffs: () => 1,
+  groupBuffs: (groupCount) => Math.max(groupCount - 1, 0),
+  squadBuffs: (_groupCount, squadCount) => Math.max(squadCount - 1, 0)
+};
+var toBoonId = (id) => `b${id}`;
+var computeGenerationMs = (category, stacking, generation, wasted, durationMs, groupCount, squadCount) => {
+  const count = CATEGORY_COUNT[category](groupCount, squadCount);
+  if (!count || !durationMs) {
+    return { generationMs: 0, wastedMs: 0 };
+  }
+  if (stacking) {
+    return {
+      generationMs: generation * durationMs * count,
+      wastedMs: wasted * durationMs * count
+    };
+  }
+  return {
+    generationMs: generation / 100 * durationMs * count,
+    wastedMs: wasted / 100 * durationMs * count
+  };
+};
+var getPlayerBoonGenerationMs = (player, category, boonId, durationMs, groupCount, squadCount, buffMap = {}) => {
+  const buffs = player?.[category] || [];
+  const target = buffs.find((buff) => buff.id === boonId);
+  if (!target) {
+    return { generationMs: 0, wastedMs: 0 };
+  }
+  const meta = buffMap[toBoonId(boonId)];
+  const stacking = meta?.stacking ?? false;
+  const generation = target.buffData?.[0]?.generation ?? 0;
+  const wasted = target.buffData?.[0]?.wasted ?? 0;
+  return computeGenerationMs(category, stacking, generation, wasted, durationMs, groupCount, squadCount);
+};
+
+// src/constants.ts
+var TIMESTAMP_MS_THRESHOLD = 1e12;
+var STABILITY_BOON_ID = 1122;
+
+// src/combatMetrics.ts
+var toSeconds = (ms) => (ms || 0) / 1e3;
+var applyTierWeight = (count, durationMs) => {
+  if (!count) return 0;
+  const tiers = METRICS_SPEC.methods.tiered?.tiers;
+  if (!tiers) return count;
+  const avg = durationMs / Math.max(count, 1);
+  if (avg <= tiers.shortMs) return count * tiers.weights.short;
+  if (avg <= tiers.mediumMs) return count * tiers.weights.medium;
+  return count * tiers.weights.long;
+};
+var resolveDisruptionValue = (count, durationMs, method) => {
+  if (method === "duration") return toSeconds(durationMs);
+  if (method === "tiered") return applyTierWeight(count, durationMs);
+  return count;
+};
+function computeOutgoingCrowdControl(player, method = DEFAULT_DISRUPTION_METHOD) {
+  const stats = player.statsAll?.[0];
+  const count = Number(stats?.appliedCrowdControl ?? 0);
+  const durationMs = Number(stats?.appliedCrowdControlDuration ?? 0);
+  return resolveDisruptionValue(count, durationMs, method);
+}
+function computeIncomingDisruptions(player, method = DEFAULT_DISRUPTION_METHOD) {
+  const defenses = player.defenses?.[0];
+  const incomingCcCount = Number(defenses?.receivedCrowdControl ?? 0);
+  const incomingCcDurationMs = Number(defenses?.receivedCrowdControlDuration ?? 0);
+  const incomingStripCount = Number(defenses?.boonStrips ?? 0);
+  const incomingStripDurationMs = Number(defenses?.boonStripsTime ?? 0);
+  const resolveValue = (count, durationMs) => resolveDisruptionValue(count, durationMs, method);
+  return {
+    strips: {
+      total: resolveValue(incomingStripCount, incomingStripDurationMs),
+      missed: 0,
+      blocked: 0
+    },
+    cc: {
+      total: resolveValue(incomingCcCount, incomingCcDurationMs),
+      missed: 0,
+      blocked: 0
+    }
+  };
+}
+function applySquadStabilityGeneration(players, context) {
+  const durationMs = context?.durationMS || 0;
+  const buffMap = context?.buffMap || {};
+  const squadPlayers = players.filter((p) => !p.notInSquad);
+  const squadCount = squadPlayers.length;
+  const groupCounts = /* @__PURE__ */ new Map();
+  squadPlayers.forEach((player) => {
+    const group = player.group ?? 0;
+    groupCounts.set(group, (groupCounts.get(group) || 0) + 1);
+  });
+  squadPlayers.forEach((player) => {
+    const groupCount = groupCounts.get(player.group ?? 0) || 1;
+    const self = getPlayerBoonGenerationMs(
+      player,
+      "selfBuffs",
+      STABILITY_BOON_ID,
+      durationMs,
+      groupCount,
+      squadCount,
+      buffMap
+    );
+    const squad = getPlayerBoonGenerationMs(
+      player,
+      "squadBuffs",
+      STABILITY_BOON_ID,
+      durationMs,
+      groupCount,
+      squadCount,
+      buffMap
+    );
+    player.stabGeneration = (self.generationMs + squad.generationMs) / 1e3;
+  });
+}
+function computeDownContribution(player) {
+  if (player.statsAll && player.statsAll.length > 0) {
+    const val = player.statsAll[0].downContribution;
+    if (typeof val === "number" && val > 0) return val;
+  }
+  let total = 0;
+  if (player.totalDamageDist) {
+    for (const targetList of player.totalDamageDist) {
+      if (targetList) {
+        for (const entry of targetList) {
+          total += entry.downContribution || 0;
+        }
+      }
+    }
+  }
+  if (total > 0) return total;
+  if (player.statsTargets) {
+    for (const targetStats of player.statsTargets) {
+      if (targetStats && targetStats.length > 0) {
+        total += targetStats[0].downContribution || 0;
+      }
+    }
+  }
+  return total;
+}
+function computeSquadBarrier(player) {
+  if (!player.extBarrierStats || !player.extBarrierStats.outgoingBarrierAllies) return 0;
+  let total = 0;
+  for (const squadMember of player.extBarrierStats.outgoingBarrierAllies) {
+    if (!squadMember) continue;
+    for (const phaseData of squadMember) {
+      if (phaseData) {
+        total += phaseData.barrier || 0;
+      }
+    }
+  }
+  return total;
+}
+function computeSquadHealing(player) {
+  if (!player.extHealingStats || !player.extHealingStats.outgoingHealingAllies) return 0;
+  let total = 0;
+  for (const squadMember of player.extHealingStats.outgoingHealingAllies) {
+    if (!squadMember) continue;
+    for (const phaseData of squadMember) {
+      if (phaseData) {
+        total += phaseData.healing || 0;
+      }
+    }
+  }
+  return total;
+}
+
+// src/dashboardMetrics.ts
+var getPlayerDamage = (player) => player.dpsAll?.[0]?.damage || 0;
+var getPlayerDps = (player) => player.dpsAll?.[0]?.dps || 0;
+var getPlayerCleanses = (player) => (player.support?.[0]?.condiCleanse || 0) + (player.support?.[0]?.condiCleanseSelf || 0);
+var getPlayerStrips = (player, method = DEFAULT_DISRUPTION_METHOD) => {
+  const support = player.support?.[0];
+  const count = Number(support?.boonStrips ?? 0);
+  const durationMs = Number(support?.boonStripsTime ?? 0);
+  return resolveDisruptionValue(count, durationMs, method);
+};
+var getPlayerResurrects = (player) => player.support?.[0]?.resurrects || 0;
+var getPlayerDistanceToTag = (player) => {
+  const stats = player.statsAll?.[0];
+  const distToCom = stats?.distToCom;
+  if (distToCom !== void 0 && distToCom !== null) {
+    return distToCom;
+  }
+  return stats?.stackDist || 0;
+};
+var getPlayerBreakbarDamage = (player) => player.dpsAll?.[0]?.breakbarDamage || 0;
+var getPlayerDamageTaken = (player) => player.defenses?.[0]?.damageTaken || 0;
+var getPlayerDeaths = (player) => player.defenses?.[0]?.deadCount || 0;
+var getPlayerDodges = (player) => player.defenses?.[0]?.dodgeCount || 0;
+var getPlayerMissed = (player) => player.defenses?.[0]?.missedCount || 0;
+var getPlayerBlocked = (player) => player.defenses?.[0]?.blockedCount || 0;
+var getPlayerEvaded = (player) => player.defenses?.[0]?.evadedCount || 0;
+var getPlayerDownsTaken = (player) => player.defenses?.[0]?.downCount || 0;
+var getTargetStatTotal = (player, field) => {
+  let total = 0;
+  const statsTargets = player.statsTargets || [];
+  for (const targetStats of statsTargets) {
+    if (targetStats && targetStats.length > 0) {
+      total += Number(targetStats[0][field] || 0);
+    }
+  }
+  return total;
+};
+var getPlayerOutgoingInterrupts = (player) => getTargetStatTotal(player, "interrupts");
+var getPlayerDashboardTotals = (player, method = DEFAULT_DISRUPTION_METHOD) => ({
+  downContrib: computeDownContribution(player),
+  cleanses: getPlayerCleanses(player),
+  strips: getPlayerStrips(player, method),
+  healing: computeSquadHealing(player),
+  barrier: computeSquadBarrier(player),
+  cc: computeOutgoingCrowdControl(player, method)
+});
+
+// src/conditionsMetrics.ts
+var NON_DAMAGING_CONDITIONS = /* @__PURE__ */ new Set([
+  "Vulnerability",
+  "Weakness",
+  "Blind",
+  "Cripple",
+  "Chill",
+  "Immobilize",
+  "Slow",
+  "Fear",
+  "Taunt"
+]);
+var CONDITION_NAME_MAP = /* @__PURE__ */ new Map([
+  ["bleeding", "Bleeding"],
+  ["burning", "Burning"],
+  ["confusion", "Confusion"],
+  ["poison", "Poison"],
+  ["torment", "Torment"],
+  ["vulnerability", "Vulnerability"],
+  ["weakness", "Weakness"],
+  ["weakened", "Weakness"],
+  ["blind", "Blind"],
+  ["blinded", "Blind"],
+  ["blinding", "Blind"],
+  ["cripple", "Cripple"],
+  ["crippled", "Cripple"],
+  ["chill", "Chill"],
+  ["chilled", "Chill"],
+  ["immob", "Immobilize"],
+  ["immobile", "Immobilize"],
+  ["immobilized", "Immobilize"],
+  ["slow", "Slow"],
+  ["slowed", "Slow"],
+  ["fear", "Fear"],
+  ["feared", "Fear"],
+  ["taunt", "Taunt"],
+  ["taunted", "Taunt"]
+]);
+var DEFAULT_CONDITION_ICONS = {
+  Blind: "https://render.guildwars2.com/file/09770136BB76FD0DBE1CC4267DEED54774CB20F6/102837.png",
+  Chill: "https://render.guildwars2.com/file/28C4EC547A3516AF0242E826772DA43A5EAC3DF3/102839.png",
+  Cripple: "https://render.guildwars2.com/file/070325E519C178D502A8160523766070D30C0C19/102838.png",
+  Fear: "https://render.guildwars2.com/file/30307A6E766D74B6EB09EDA12A4A2DE50E4D76F4/102869.png",
+  Immobilize: "https://render.guildwars2.com/file/397A613651BFCA2832B6469CE34735580A2C120E/102844.png",
+  Slow: "https://render.guildwars2.com/file/F60D1EF5271D7B9319610855676D320CD25F01C6/961397.png",
+  Taunt: "https://render.guildwars2.com/file/02EED459AD65FAF7DF32A260E479C625070841B9/1228472.png",
+  Vulnerability: "https://render.guildwars2.com/file/3A394C1A0A3257EB27A44842DDEEF0DF000E1241/102850.png",
+  Weakness: "https://render.guildwars2.com/file/6CB0E64AF9AA292E332A38C1770CE577E2CDE0E8/102853.png"
+};
+var getDefaultConditionIcon = (name) => {
+  if (!name) return void 0;
+  return DEFAULT_CONDITION_ICONS[name];
+};
+var resolveBuffMetaById = (buffMap, id) => {
+  if (!buffMap || id === void 0 || id === null) return void 0;
+  const numericId = Number(id);
+  if (Number.isFinite(numericId)) {
+    return buffMap[`b${numericId}`] || buffMap[String(numericId)];
+  }
+  return buffMap[String(id)];
+};
+var getConditionName = (name) => {
+  if (!name) return null;
+  const cleaned = name.trim().toLowerCase();
+  const directMatch = CONDITION_NAME_MAP.get(cleaned);
+  if (directMatch) return directMatch;
+  const tokens = cleaned.split(/[^a-z]+/).filter(Boolean);
+  for (const token of tokens) {
+    const match = CONDITION_NAME_MAP.get(token);
+    if (match) return match;
+  }
+  return null;
+};
+var normalizeConditionLabel = (name) => getConditionName(name);
+var buildConditionIconMap = (buffMap) => {
+  const map = /* @__PURE__ */ new Map();
+  if (!buffMap) return map;
+  Object.values(buffMap).forEach((meta) => {
+    if (!meta?.icon || !meta?.name) return;
+    const normalized = getConditionName(meta.name);
+    if (!normalized) return;
+    if (!map.has(normalized)) map.set(normalized, meta.icon);
+  });
+  Object.entries(DEFAULT_CONDITION_ICONS).forEach(([name, icon]) => {
+    if (!map.has(name)) map.set(name, icon);
+  });
+  return map;
+};
+var resolveConditionNameFromEntry = (skillName, id, buffMap) => {
+  if (id && buffMap) {
+    const buffName = resolveBuffMetaById(buffMap, id)?.name;
+    const resolved = getConditionName(buffName);
+    if (resolved) return resolved;
+  }
+  if (!skillName) return null;
+  return getConditionName(skillName);
+};
+var defaultGetPlayerKey = (player) => {
+  const account = player?.account || "Unknown";
+  if (account && account !== "Unknown") return account;
+  const name = player?.name || "Unknown";
+  return name || null;
+};
+var countAppliedFromStates = (states) => {
+  if (!states || states.length === 0) return 0;
+  let applied = 0;
+  let prev = null;
+  states.forEach((entry) => {
+    const value = Number(entry[1] ?? 0);
+    if (!Number.isFinite(value)) return;
+    if (prev === null) {
+      prev = value;
+      return;
+    }
+    if (value > prev) {
+      applied += value - prev;
+    }
+    prev = value;
+  });
+  return applied;
+};
+var computeUptimeFromStates = (states) => {
+  if (!states || states.length === 0) return 0;
+  let uptimeMs = 0;
+  let buffOn = 0;
+  let firstTime = 0;
+  for (const [time, value] of states) {
+    if (time === 0) continue;
+    if (value >= 1 && buffOn === 0) {
+      buffOn = value;
+      firstTime = time;
+    } else if (value === 0 && buffOn > 0) {
+      uptimeMs += time - firstTime;
+      buffOn = 0;
+    }
+  }
+  return uptimeMs;
+};
+var countActiveStateEntries = (states) => {
+  if (!states || states.length === 0) return 0;
+  let count = 0;
+  states.forEach((entry) => {
+    const time = Number(entry[0] ?? 0);
+    const value = Number(entry[1] ?? 0);
+    if (!Number.isFinite(value)) return;
+    if (time === 0) return;
+    if (value > 0) count += 1;
+  });
+  return count;
+};
+var computeOutgoingConditions = (payload) => {
+  const { players, targets, skillMap, buffMap } = payload;
+  const getPlayerKey = payload.getPlayerKey || defaultGetPlayerKey;
+  const conditionIconMap = buildConditionIconMap(buffMap);
+  const playerConditions = {};
+  const summary = {};
+  players.forEach((player) => {
+    if (player?.notInSquad) return;
+    const key = getPlayerKey(player);
+    if (!key) return;
+    if (!playerConditions[key]) {
+      playerConditions[key] = {};
+    }
+    if (!player?.totalDamageDist) return;
+    player.totalDamageDist.forEach((distList) => {
+      if (!distList) return;
+      distList.forEach((entry) => {
+        if (!entry.id) return;
+        let skillName = `Skill ${entry.id}`;
+        let skillIcon;
+        if (skillMap) {
+          if (skillMap[`s${entry.id}`]) {
+            skillName = skillMap[`s${entry.id}`].name || skillName;
+            skillIcon = skillMap[`s${entry.id}`].icon || skillIcon;
+          } else if (skillMap[`${entry.id}`]) {
+            skillName = skillMap[`${entry.id}`].name || skillName;
+            skillIcon = skillMap[`${entry.id}`].icon || skillIcon;
+          }
+        }
+        const buffMeta = resolveBuffMetaById(buffMap, entry.id);
+        if (skillName.startsWith("Skill ") && buffMeta?.name) {
+          skillName = buffMeta.name;
+          skillIcon = buffMeta.icon || skillIcon;
+        }
+        const conditionName = resolveConditionNameFromEntry(skillName, entry.id, buffMap);
+        if (!conditionName) return;
+        const buffName = buffMeta?.name;
+        const conditionIcon = conditionIconMap.get(conditionName) || buffMeta?.icon;
+        const skillLabel = skillName.startsWith("Skill ") ? buffName || conditionName : skillName;
+        const skillLabelIcon = skillIcon || buffMeta?.icon;
+        const connectedHits = Number(entry.connectedHits ?? 0);
+        const rawHits = Number(entry.hits ?? 0);
+        const hits = connectedHits > 0 ? connectedHits : rawHits;
+        const damage = Number(entry.totalDamage ?? 0);
+        if (!Number.isFinite(hits) && !Number.isFinite(damage)) return;
+        const existing = summary[conditionName] || {
+          name: conditionName,
+          icon: conditionIcon,
+          applications: 0,
+          damage: 0
+        };
+        existing.applications += Number.isFinite(hits) ? hits : 0;
+        existing.damage += Number.isFinite(damage) ? damage : 0;
+        if (!existing.icon && conditionIcon) existing.icon = conditionIcon;
+        summary[conditionName] = existing;
+        const playerConditionTotals = playerConditions[key][conditionName] || {
+          icon: conditionIcon,
+          applications: 0,
+          damage: 0,
+          skills: {}
+        };
+        playerConditionTotals.applications += Number.isFinite(hits) ? hits : 0;
+        playerConditionTotals.damage += Number.isFinite(damage) ? damage : 0;
+        const skillEntry = playerConditionTotals.skills[skillLabel] || { name: skillLabel, hits: 0, damage: 0, icon: skillLabelIcon };
+        skillEntry.hits += Number.isFinite(hits) ? hits : 0;
+        skillEntry.damage += Number.isFinite(damage) ? damage : 0;
+        if (!skillEntry.icon && skillLabelIcon) skillEntry.icon = skillLabelIcon;
+        playerConditionTotals.skills[skillLabel] = skillEntry;
+        if (!playerConditionTotals.icon && conditionIcon) playerConditionTotals.icon = conditionIcon;
+        playerConditions[key][conditionName] = playerConditionTotals;
+      });
+    });
+  });
+  const nameToKey = /* @__PURE__ */ new Map();
+  players.forEach((player) => {
+    if (player?.notInSquad) return;
+    const key = getPlayerKey(player);
+    if (!key) return;
+    if (player?.name) {
+      nameToKey.set(player.name, key);
+    }
+  });
+  let buffStateApplicationsTotal = 0;
+  let buffStateSourcesSeen = 0;
+  let targetBuffEntriesSeen = 0;
+  targets.forEach((target) => {
+    if (!target?.buffs) return;
+    target.buffs.forEach((buff) => {
+      const buffId = Number(buff?.id);
+      if (!Number.isFinite(buffId)) return;
+      const buffMeta = resolveBuffMetaById(buffMap, buffId);
+      const normalizedName = getConditionName(buffMeta?.name);
+      if (!normalizedName) return;
+      if (buffMeta?.classification && buffMeta.classification !== "Condition") return;
+      const conditionName = normalizedName;
+      if (!conditionName) return;
+      const statesPerSource = buff.statesPerSource || {};
+      targetBuffEntriesSeen += 1;
+      Object.entries(statesPerSource).forEach(([sourceName, states]) => {
+        const key = nameToKey.get(sourceName);
+        if (!key) return;
+        buffStateSourcesSeen += 1;
+        const appliedCounts = countAppliedFromStates(states);
+        const activeCounts = countActiveStateEntries(states);
+        const uptimeMs = computeUptimeFromStates(states);
+        buffStateApplicationsTotal += appliedCounts;
+        const playerConditionTotals = playerConditions[key]?.[conditionName] || {
+          applications: 0,
+          damage: 0,
+          skills: {}
+        };
+        playerConditionTotals.applicationsFromBuffs = (playerConditionTotals.applicationsFromBuffs || 0) + appliedCounts;
+        playerConditionTotals.applicationsFromBuffsActive = (playerConditionTotals.applicationsFromBuffsActive || 0) + activeCounts;
+        playerConditionTotals.uptimeMs = (playerConditionTotals.uptimeMs || 0) + uptimeMs;
+        playerConditions[key] = playerConditions[key] || {};
+        playerConditions[key][conditionName] = playerConditionTotals;
+        const overallTotals = summary[conditionName] || {
+          name: conditionName,
+          applications: 0,
+          damage: 0
+        };
+        overallTotals.applicationsFromBuffs = (overallTotals.applicationsFromBuffs || 0) + appliedCounts;
+        overallTotals.applicationsFromBuffsActive = (overallTotals.applicationsFromBuffsActive || 0) + activeCounts;
+        overallTotals.uptimeMs = (overallTotals.uptimeMs || 0) + uptimeMs;
+        summary[conditionName] = overallTotals;
+      });
+    });
+  });
+  return {
+    playerConditions,
+    summary,
+    meta: {
+      buffStateApplicationsTotal,
+      targetBuffEntriesSeen,
+      buffStateSourcesSeen
+    }
+  };
+};
+
+// src/professionUtils.ts
+var PROFESSION_COLORS = {
+  "Guardian": "#72C1D9",
+  "Dragonhunter": "#72C1D9",
+  "Firebrand": "#72C1D9",
+  "Willbender": "#72C1D9",
+  "Revenant": "#D16E5A",
+  "Herald": "#D16E5A",
+  "Renegade": "#D16E5A",
+  "Vindicator": "#D16E5A",
+  "Warrior": "#FFD166",
+  "Berserker": "#FFD166",
+  "Spellbreaker": "#FFD166",
+  "Bladesworn": "#FFD166",
+  "Engineer": "#D09C59",
+  "Scrapper": "#D09C59",
+  "Holosmith": "#D09C59",
+  "Mechanist": "#D09C59",
+  "Ranger": "#8CDC82",
+  "Druid": "#8CDC82",
+  "Soulbeast": "#8CDC82",
+  "Untamed": "#8CDC82",
+  "Thief": "#C08F95",
+  "Daredevil": "#C08F95",
+  "Deadeye": "#C08F95",
+  "Specter": "#C08F95",
+  "Elementalist": "#F68A87",
+  "Tempest": "#F68A87",
+  "Weaver": "#F68A87",
+  "Catalyst": "#F68A87",
+  "Mesmer": "#B679D5",
+  "Chronomancer": "#B679D5",
+  "Mirage": "#B679D5",
+  "Virtuoso": "#B679D5",
+  "Necromancer": "#52A76F",
+  "Reaper": "#52A76F",
+  "Scourge": "#52A76F",
+  "Harbinger": "#52A76F",
+  "Ritualist": "#52A76F",
+  "Luminary": "#72C1D9",
+  "Conduit": "#D16E5A",
+  "Paragon": "#FFD166",
+  "Amalgam": "#D09C59",
+  "Galeshot": "#8CDC82",
+  "Antiquary": "#C08F95",
+  "Evoker": "#F68A87",
+  "Troubadour": "#B679D5",
+  "Unknown": "#64748B"
+};
+var PROFESSION_BASE = {
+  Guardian: "Guardian",
+  Dragonhunter: "Guardian",
+  Firebrand: "Guardian",
+  Willbender: "Guardian",
+  Revenant: "Revenant",
+  Herald: "Revenant",
+  Renegade: "Revenant",
+  Vindicator: "Revenant",
+  Warrior: "Warrior",
+  Berserker: "Warrior",
+  Spellbreaker: "Warrior",
+  Bladesworn: "Warrior",
+  Engineer: "Engineer",
+  Scrapper: "Engineer",
+  Holosmith: "Engineer",
+  Mechanist: "Engineer",
+  Ranger: "Ranger",
+  Druid: "Ranger",
+  Soulbeast: "Ranger",
+  Untamed: "Ranger",
+  Thief: "Thief",
+  Daredevil: "Thief",
+  Deadeye: "Thief",
+  Specter: "Thief",
+  Elementalist: "Elementalist",
+  Tempest: "Elementalist",
+  Weaver: "Elementalist",
+  Catalyst: "Elementalist",
+  Mesmer: "Mesmer",
+  Chronomancer: "Mesmer",
+  Mirage: "Mesmer",
+  Virtuoso: "Mesmer",
+  Necromancer: "Necromancer",
+  Reaper: "Necromancer",
+  Scourge: "Necromancer",
+  Harbinger: "Necromancer",
+  Ritualist: "Necromancer",
+  Luminary: "Guardian",
+  Conduit: "Revenant",
+  Paragon: "Warrior",
+  Amalgam: "Engineer",
+  Galeshot: "Ranger",
+  Antiquary: "Thief",
+  Evoker: "Elementalist",
+  Troubadour: "Mesmer",
+  Unknown: "Unknown"
+};
+var PROFESSION_ABBREVIATIONS = {
+  Guardian: "gdn",
+  Dragonhunter: "dh",
+  Firebrand: "fb",
+  Willbender: "wb",
+  Revenant: "rev",
+  Herald: "her",
+  Renegade: "ren",
+  Vindicator: "vin",
+  Warrior: "war",
+  Berserker: "ber",
+  Spellbreaker: "spb",
+  Bladesworn: "bsw",
+  Engineer: "eng",
+  Scrapper: "scr",
+  Holosmith: "hol",
+  Mechanist: "mec",
+  Ranger: "rng",
+  Druid: "dru",
+  Soulbeast: "slb",
+  Untamed: "unt",
+  Thief: "thi",
+  Daredevil: "dar",
+  Deadeye: "dea",
+  Specter: "spe",
+  Elementalist: "ele",
+  Tempest: "tem",
+  Weaver: "wev",
+  Catalyst: "cat",
+  Mesmer: "mes",
+  Chronomancer: "chr",
+  Mirage: "mir",
+  Virtuoso: "vir",
+  Necromancer: "nec",
+  Reaper: "rea",
+  Scourge: "sco",
+  Harbinger: "har",
+  Ritualist: "rit",
+  Luminary: "lum",
+  Conduit: "con",
+  Paragon: "par",
+  Amalgam: "ama",
+  Galeshot: "gal",
+  Antiquary: "ant",
+  Evoker: "evo",
+  Troubadour: "tro",
+  Unknown: "unk"
+};
+var PROFESSION_EMOJI = {
+  Guardian: "\u{1F535}",
+  Revenant: "\u{1F534}",
+  Warrior: "\u{1F7E1}",
+  Engineer: "\u{1F7E0}",
+  Ranger: "\u{1F7E2}",
+  Thief: "\u26AB\uFE0F",
+  Elementalist: "\u{1F534}",
+  Mesmer: "\u{1F7E3}",
+  Necromancer: "\u{1F7E2}",
+  Unknown: "\u26AA\uFE0F"
+};
+function getProfessionColor(profession) {
+  return PROFESSION_COLORS[profession] || PROFESSION_COLORS["Unknown"];
+}
+function hexToRgba(hex, alpha) {
+  const h = hex.replace("#", "");
+  const r = parseInt(h.substring(0, 2), 16);
+  const g = parseInt(h.substring(2, 4), 16);
+  const b = parseInt(h.substring(4, 6), 16);
+  return `rgba(${r},${g},${b},${alpha})`;
+}
+function getProfessionBase(profession) {
+  if (!profession) return "Unknown";
+  return PROFESSION_BASE[profession] || profession;
+}
+function getProfessionAbbrev(profession) {
+  if (!profession) return PROFESSION_ABBREVIATIONS.Unknown;
+  return PROFESSION_ABBREVIATIONS[profession] || profession.slice(0, 3).toLowerCase();
+}
+function getProfessionEmoji(profession) {
+  const base = getProfessionBase(profession);
+  return PROFESSION_EMOJI[base] || PROFESSION_EMOJI.Unknown;
+}
+var SUPERSCRIPT_MAP = {
+  a: "\u1D43",
+  b: "\u1D47",
+  c: "\u1D9C",
+  d: "\u1D48",
+  e: "\u1D49",
+  f: "\u1DA0",
+  g: "\u1D4D",
+  h: "\u02B0",
+  i: "\u2071",
+  j: "\u02B2",
+  k: "\u1D4F",
+  l: "\u02E1",
+  m: "\u1D50",
+  n: "\u207F",
+  o: "\u1D52",
+  p: "\u1D56",
+  q: "\u146B",
+  r: "\u02B3",
+  s: "\u02E2",
+  t: "\u1D57",
+  u: "\u1D58",
+  v: "\u1D5B",
+  w: "\u02B7",
+  x: "\u02E3",
+  y: "\u02B8",
+  z: "\u1DBB",
+  "0": "\u2070",
+  "1": "\xB9",
+  "2": "\xB2",
+  "3": "\xB3",
+  "4": "\u2074",
+  "5": "\u2075",
+  "6": "\u2076",
+  "7": "\u2077",
+  "8": "\u2078",
+  "9": "\u2079"
+};
+function toSuperscript(value) {
+  return value.toLowerCase().split("").map((char) => SUPERSCRIPT_MAP[char] || char).join("");
+}
+function getProfessionAbbrevSuperscript(profession) {
+  return toSuperscript(getProfessionAbbrev(profession));
+}
+
+// src/statsMetrics.ts
+var OFFENSE_METRICS = [
+  { id: "damage", label: "Damage", field: "damage", source: "dpsAll" },
+  { id: "directDmg", label: "Direct Damage", field: "directDmg", source: "statsTargets" },
+  { id: "connectedDamageCount", label: "Connected Damage Count", field: "connectedDamageCount", source: "statsTargets" },
+  { id: "connectedDirectDamageCount", label: "Connected Direct Damage Count", field: "connectedDirectDamageCount", source: "statsTargets" },
+  { id: "battleStandardHits", label: "Battle Standard Tracking" },
+  { id: "criticalRate", label: "Critical Rate", field: "criticalRate", isRate: true, isPercent: true, denomField: "critableDirectDamageCount", source: "statsTargets" },
+  { id: "criticalDmg", label: "Critical Damage", field: "criticalDmg", source: "statsTargets" },
+  { id: "flankingRate", label: "Flanking Rate", field: "flankingRate", isRate: true, isPercent: true, denomField: "connectedDirectDamageCount", source: "statsTargets" },
+  { id: "glanceRate", label: "Glance Rate", field: "glanceRate", isRate: true, isPercent: true, denomField: "connectedDirectDamageCount", source: "statsTargets" },
+  { id: "missed", label: "Missed", field: "missed", source: "statsTargets" },
+  { id: "evaded", label: "Evaded (enemy)", field: "evaded", source: "statsTargets" },
+  { id: "blocked", label: "Blocked (enemy)", field: "blocked", source: "statsTargets" },
+  { id: "interrupts", label: "Interrupts", field: "interrupts", source: "statsTargets" },
+  { id: "invulned", label: "Invulned", field: "invulned", source: "statsTargets" },
+  { id: "killed", label: "Killed", field: "killed", source: "statsTargets" },
+  { id: "downed", label: "Downed", field: "downed", source: "statsTargets" },
+  { id: "downContribution", label: "Down Contribution", field: "downContribution", source: "statsTargets" },
+  { id: "downContributionPercent", label: "Down Contribution %", isRate: true, isPercent: true },
+  { id: "againstDownedDamage", label: "Against Downed Damage", field: "againstDownedDamage", source: "statsTargets" },
+  { id: "appliedCrowdControl", label: "Applied CC", field: "appliedCrowdControl", source: "statsTargets" },
+  { id: "appliedCrowdControlDuration", label: "Applied CC Duration", field: "appliedCrowdControlDuration", source: "statsTargets" },
+  { id: "appliedCrowdControlDownContribution", label: "Applied CC Down Contribution", field: "appliedCrowdControlDownContribution", source: "statsTargets" },
+  { id: "appliedCrowdControlDurationDownContribution", label: "Applied CC Duration Down Contribution", field: "appliedCrowdControlDurationDownContribution", source: "statsTargets" },
+  { id: "boonStrips", label: "Boon Strips", field: "boonStrips", source: "support" }
+];
+var DEFENSE_METRICS = [
+  { id: "damageTaken", label: "Damage Taken", field: "damageTaken" },
+  { id: "minionDamageTaken", label: "Minion Damage Taken" },
+  { id: "damageTakenCount", label: "Damage Taken Count", field: "damageTakenCount" },
+  { id: "conditionDamageTaken", label: "Condition Damage Taken", field: "conditionDamageTaken" },
+  { id: "conditionDamageTakenCount", label: "Condition Damage Taken Count", field: "conditionDamageTakenCount" },
+  { id: "powerDamageTaken", label: "Power Damage Taken", field: "powerDamageTaken" },
+  { id: "powerDamageTakenCount", label: "Power Damage Taken Count", field: "powerDamageTakenCount" },
+  { id: "downedDamageTaken", label: "Downed Damage Taken", field: "downedDamageTaken" },
+  { id: "downedDamageTakenCount", label: "Downed Damage Taken Count", field: "downedDamageTakenCount" },
+  { id: "damageBarrier", label: "Damage Barrier", field: "damageBarrier" },
+  { id: "damageBarrierCount", label: "Damage Barrier Count", field: "damageBarrierCount" },
+  { id: "blockedCount", label: "Blocked Count", field: "blockedCount" },
+  { id: "evadedCount", label: "Evaded Count", field: "evadedCount" },
+  { id: "missedCount", label: "Missed Count", field: "missedCount" },
+  { id: "dodgeCount", label: "Dodge Count", field: "dodgeCount" },
+  { id: "invulnedCount", label: "Invulnerable Count", field: "invulnedCount" },
+  { id: "interruptedCount", label: "Interrupted Count", field: "interruptedCount" },
+  { id: "downCount", label: "Down Count", field: "downCount" },
+  { id: "deadCount", label: "Death Count", field: "deadCount" },
+  { id: "boonStrips", label: "Boon Strips (Incoming)", field: "boonStrips" },
+  { id: "conditionCleanses", label: "Cleanses (Incoming)", field: "conditionCleanses" },
+  { id: "receivedCrowdControl", label: "Crowd Control (Incoming)", field: "receivedCrowdControl" }
+];
+var SUPPORT_METRICS = [
+  { id: "condiCleanse", label: "Condition Cleanses", field: "condiCleanse" },
+  { id: "condiCleanseTime", label: "Condition Cleanse Time", field: "condiCleanseTime", isTime: true },
+  { id: "condiCleanseSelf", label: "Condition Cleanse Self", field: "condiCleanseSelf" },
+  { id: "condiCleanseTimeSelf", label: "Condition Cleanse Time Self", field: "condiCleanseTimeSelf", isTime: true },
+  { id: "boonStrips", label: "Boon Strips", field: "boonStrips" },
+  { id: "boonStripsTime", label: "Boon Strips Time", field: "boonStripsTime", isTime: true },
+  { id: "boonStripDownContribution", label: "Boon Strip Down Contribution", field: "boonStripDownContribution" },
+  { id: "boonStripDownContributionTime", label: "Boon Strip Down Contribution Time", field: "boonStripDownContributionTime", isTime: true },
+  { id: "stunBreak", label: "Stun Breaks", field: "stunBreak" },
+  { id: "removedStunDuration", label: "Removed Stun Duration", field: "removedStunDuration", isTime: true },
+  { id: "resurrects", label: "Resurrects", field: "resurrects" },
+  { id: "resurrectTime", label: "Resurrect Time", field: "resurrectTime", isTime: true }
+];
+var RES_UTILITY_NAME_MATCHES = [
+  "battle standard",
+  "glyph of renewal",
+  "glyph of the stars",
+  "illusion of life",
+  "spirit of nature",
+  "nature spirit",
+  "search and rescue",
+  "signet of mercy"
+];
+var RES_UTILITY_IDS = /* @__PURE__ */ new Set([10244]);
+
+// src/resUtility.ts
+var isResUtilitySkill = (id, skillMap) => {
+  if (RES_UTILITY_IDS.has(id)) {
+    return true;
+  }
+  const entry = skillMap?.[`s${id}`] || skillMap?.[`${id}`];
+  const name = entry?.name?.toLowerCase() || "";
+  return RES_UTILITY_NAME_MATCHES.some((match) => name.includes(match));
+};
+
+// src/timestampUtils.ts
+var parseTimestamp = (value) => {
+  if (value === void 0 || value === null || value === "") return 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0) return 0;
+    return value > TIMESTAMP_MS_THRESHOLD ? value : value * 1e3;
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isFinite(ms) && ms > 0 ? ms : 0;
+  }
+  const str = String(value).trim();
+  if (!str) return 0;
+  const numeric = Number(str);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return numeric > TIMESTAMP_MS_THRESHOLD ? numeric : numeric * 1e3;
+  }
+  const parsed = Date.parse(str);
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  const normalized = str.replace(/([+-]\d{2})$/, "$1:00");
+  const reparsed = Date.parse(normalized);
+  return Number.isFinite(reparsed) && reparsed > 0 ? reparsed : 0;
+};
+var resolveFightTimestamp = (details, log) => {
+  return parseTimestamp(
+    details?.timeStartStd ?? details?.timeStart ?? details?.timeEndStd ?? details?.timeEnd ?? details?.timeStartText ?? details?.timeEndText ?? details?.uploadTime ?? log?.uploadTime
+  );
+};
+
+// 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
+  };
+};
+
+// src/rollup.ts
+var ROLLUP_SOURCES_VERSION = 1;
+var extractRollupSource = (payload) => {
+  const meta = payload?.meta || {};
+  const commanderRows = Array.isArray(payload?.stats?.commanderStats?.rows) ? payload.stats.commanderStats.rows : [];
+  const attendanceRows = Array.isArray(payload?.stats?.attendanceData) ? payload.stats.attendanceData : [];
+  return {
+    meta: {
+      id: meta.id,
+      dateStart: meta.dateStart,
+      dateEnd: meta.dateEnd,
+      generatedAt: meta.generatedAt
+    },
+    stats: {
+      commanderStats: {
+        rows: commanderRows.map((row) => ({
+          key: row?.key,
+          account: row?.account,
+          characterNames: Array.isArray(row?.characterNames) ? row.characterNames : [],
+          profession: row?.profession,
+          fights: row?.fights,
+          kills: row?.kills,
+          downs: row?.downs,
+          commanderDeaths: row?.commanderDeaths,
+          alliesDead: row?.alliesDead,
+          wins: row?.wins,
+          losses: row?.losses
+        }))
+      },
+      attendanceData: attendanceRows.map((row) => ({
+        account: row?.account,
+        characterNames: Array.isArray(row?.characterNames) ? row.characterNames : [],
+        combatTimeMs: row?.combatTimeMs,
+        squadTimeMs: row?.squadTimeMs,
+        classTimes: (Array.isArray(row?.classTimes) ? row.classTimes : []).map((entry) => ({
+          profession: entry?.profession,
+          timeMs: entry?.timeMs
+        }))
+      }))
+    }
+  };
+};
+var updateRollupSourcesForPublish = (options) => {
+  const { existingSources, currentReport, validIds, loadLocalReport } = options;
+  const sourcesById = /* @__PURE__ */ new Map();
+  existingSources.forEach((source) => {
+    const id = String(source?.meta?.id || "").trim();
+    if (id) sourcesById.set(id, source);
+  });
+  const currentId = String(currentReport?.meta?.id || "").trim();
+  if (currentId) {
+    sourcesById.set(currentId, extractRollupSource(currentReport));
+  }
+  const validIdSet = new Set(validIds.map((id) => String(id || "").trim()).filter(Boolean));
+  if (loadLocalReport) {
+    for (const id of validIdSet) {
+      if (sourcesById.has(id)) continue;
+      const localReport = loadLocalReport(id);
+      if (localReport) {
+        sourcesById.set(id, extractRollupSource(localReport));
+      }
+    }
+  }
+  const sources = Array.from(sourcesById.entries()).filter(([id]) => validIdSet.has(id)).map(([, source]) => source);
+  return {
+    version: ROLLUP_SOURCES_VERSION,
+    sources,
+    rollup: buildRollupData(sources)
+  };
+};
+var removeRollupSources = (file, deletedIds) => {
+  const deleted = new Set(deletedIds.map((id) => String(id || "").trim()).filter(Boolean));
+  const sources = file.sources.filter(
+    (source) => !deleted.has(String(source?.meta?.id || "").trim())
+  );
+  return {
+    version: ROLLUP_SOURCES_VERSION,
+    sources,
+    rollup: buildRollupData(sources)
+  };
+};
+var parseRollupSourcesFile = (data) => {
+  const candidate = data;
+  if (!candidate || typeof candidate !== "object") return null;
+  if (candidate.version !== ROLLUP_SOURCES_VERSION) return null;
+  if (!Array.isArray(candidate.sources)) return null;
+  if (!candidate.rollup || typeof candidate.rollup !== "object") return null;
+  return candidate;
+};
+var toFiniteNumber = (value) => {
+  const numeric = Number(value ?? 0);
+  return Number.isFinite(numeric) ? numeric : 0;
+};
+var parseTimestamp2 = (meta) => {
+  const candidates = [meta?.dateEnd, meta?.dateStart];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const parsed = new Date(candidate).getTime();
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return 0;
+};
+var parseGeneratedTimestamp = (meta) => {
+  const generated = meta?.generatedAt ? new Date(meta.generatedAt).getTime() : 0;
+  if (Number.isFinite(generated) && generated > 0) {
+    return generated;
+  }
+  return parseTimestamp2(meta);
+};
+var buildRaidKey = (report, fallbackIndex) => {
+  const dateStart = String(report?.meta?.dateStart || "").trim();
+  const dateEnd = String(report?.meta?.dateEnd || "").trim();
+  if (dateStart || dateEnd) {
+    return `${dateStart}|${dateEnd}`;
+  }
+  const id = String(report?.meta?.id || "").trim();
+  if (id) return id;
+  return `report-${fallbackIndex}`;
+};
+var choosePrimaryProfession = (professionTimeMs, fallback = "Unknown") => {
+  const entries = Object.entries(professionTimeMs).filter(([profession, timeMs]) => profession && timeMs > 0).sort((a, b) => {
+    const delta = b[1] - a[1];
+    if (delta !== 0) return delta;
+    return a[0].localeCompare(b[0]);
+  });
+  return entries[0]?.[0] || fallback;
+};
+var chooseMostCommonProfession = (professionCounts, fallback = "Unknown") => {
+  const entries = Object.entries(professionCounts).filter(([profession, count]) => profession && count > 0).sort((a, b) => {
+    const delta = b[1] - a[1];
+    if (delta !== 0) return delta;
+    return a[0].localeCompare(b[0]);
+  });
+  return entries[0]?.[0] || fallback;
+};
+var buildProfessionBreakdown = (professionRuns) => Object.entries(professionRuns).filter(([profession, runs]) => profession && runs > 0).sort((a, b) => {
+  const delta = b[1] - a[1];
+  if (delta !== 0) return delta;
+  return a[0].localeCompare(b[0]);
+}).map(([profession, runs]) => ({ profession, runs }));
+var buildRollupData = (reports) => {
+  const uniqueRaidKeys = /* @__PURE__ */ new Set();
+  const reportsByRaid = /* @__PURE__ */ new Map();
+  reports.forEach((report, index) => {
+    const raidKey = buildRaidKey(report, index);
+    uniqueRaidKeys.add(raidKey);
+    const generatedTs = parseGeneratedTimestamp(report?.meta);
+    if (!reportsByRaid.has(raidKey)) {
+      reportsByRaid.set(raidKey, []);
+    }
+    reportsByRaid.get(raidKey).push({ report, generatedTs, index });
+  });
+  const raidGroups = Array.from(reportsByRaid.values()).sort((a, b) => {
+    const aLatest = Math.max(...a.map((entry) => entry.generatedTs || 0));
+    const bLatest = Math.max(...b.map((entry) => entry.generatedTs || 0));
+    if (bLatest !== aLatest) return bLatest - aLatest;
+    const aIndex = Math.max(...a.map((entry) => entry.index));
+    const bIndex = Math.max(...b.map((entry) => entry.index));
+    return bIndex - aIndex;
+  }).map((entries) => [...entries].sort((a, b) => {
+    if (b.generatedTs !== a.generatedTs) return b.generatedTs - a.generatedTs;
+    return b.index - a.index;
+  }));
+  const commanders = /* @__PURE__ */ new Map();
+  const players = /* @__PURE__ */ new Map();
+  let reportsWithCommanderDetails = 0;
+  let reportsMissingCommanderDetails = 0;
+  let reportsWithAttendanceDetails = 0;
+  let reportsMissingAttendanceDetails = 0;
+  let includedRaidGroups = 0;
+  let includedSourceReports = 0;
+  raidGroups.forEach((group) => {
+    const attendanceSource = group.find((entry) => Array.isArray(entry.report?.stats?.attendanceData) && entry.report.stats.attendanceData.length > 0) || null;
+    const attendanceReport = attendanceSource?.report || null;
+    const attendanceTimestamp = attendanceReport ? parseTimestamp2(attendanceReport.meta) : 0;
+    const attendanceRows = Array.isArray(attendanceReport?.stats?.attendanceData) ? attendanceReport.stats.attendanceData : [];
+    if (attendanceRows.length > 0) {
+      reportsWithAttendanceDetails += 1;
+    } else {
+      reportsMissingAttendanceDetails += 1;
+    }
+    const latestCommanderRowsByAccount = /* @__PURE__ */ new Map();
+    group.forEach((entry) => {
+      const report = entry.report;
+      const timestamp = parseTimestamp2(report?.meta);
+      const commanderRows2 = Array.isArray(report?.stats?.commanderStats?.rows) ? report.stats.commanderStats.rows : [];
+      commanderRows2.forEach((row) => {
+        const account = String(row?.account || row?.key || "").trim();
+        if (!account) return;
+        const existing = latestCommanderRowsByAccount.get(account);
+        if (!existing) {
+          latestCommanderRowsByAccount.set(account, { row, timestamp, generatedTs: entry.generatedTs, index: entry.index });
+          return;
+        }
+        const shouldReplace = entry.generatedTs > existing.generatedTs || entry.generatedTs === existing.generatedTs && entry.index > existing.index;
+        if (shouldReplace) {
+          latestCommanderRowsByAccount.set(account, { row, timestamp, generatedTs: entry.generatedTs, index: entry.index });
+        }
+      });
+    });
+    if (latestCommanderRowsByAccount.size > 0) {
+      reportsWithCommanderDetails += 1;
+    } else {
+      reportsMissingCommanderDetails += 1;
+    }
+    if (attendanceRows.length === 0 || latestCommanderRowsByAccount.size === 0) {
+      return;
+    }
+    includedRaidGroups += 1;
+    includedSourceReports += group.length;
+    attendanceRows.forEach((row) => {
+      const account = String(row?.account || "").trim();
+      if (!account || account === "Unknown") return;
+      const existing = players.get(account) || {
+        account,
+        characterNames: /* @__PURE__ */ new Set(),
+        professionTimeMs: {},
+        professionRuns: {},
+        runs: 0,
+        combatTimeMs: 0,
+        squadTimeMs: 0,
+        lastSeenTs: 0
+      };
+      existing.runs += 1;
+      existing.combatTimeMs += Math.max(0, toFiniteNumber(row?.combatTimeMs));
+      existing.squadTimeMs += Math.max(0, toFiniteNumber(row?.squadTimeMs));
+      existing.lastSeenTs = Math.max(existing.lastSeenTs, attendanceTimestamp);
+      if (Array.isArray(row?.characterNames)) {
+        row.characterNames.forEach((name) => {
+          const normalized = String(name || "").trim();
+          if (normalized) existing.characterNames.add(normalized);
+        });
+      }
+      const classTimes = Array.isArray(row?.classTimes) ? row.classTimes : [];
+      const professionsThisRun = /* @__PURE__ */ new Set();
+      classTimes.forEach((classRow) => {
+        const profession = String(classRow?.profession || "").trim();
+        if (!profession || profession === "Unknown") return;
+        const timeMs = Math.max(0, toFiniteNumber(classRow?.timeMs));
+        existing.professionTimeMs[profession] = (existing.professionTimeMs[profession] || 0) + timeMs;
+        if (timeMs > 0) professionsThisRun.add(profession);
+      });
+      professionsThisRun.forEach((profession) => {
+        existing.professionRuns[profession] = (existing.professionRuns[profession] || 0) + 1;
+      });
+      players.set(account, existing);
+    });
+    latestCommanderRowsByAccount.forEach(({ row, timestamp }) => {
+      const account = String(row?.account || row?.key || "").trim();
+      if (!account) return;
+      const existing = commanders.get(account) || {
+        account,
+        characterNames: /* @__PURE__ */ new Set(),
+        professionCounts: {},
+        runs: 0,
+        fightsLed: 0,
+        kills: 0,
+        downs: 0,
+        commanderDeaths: 0,
+        alliesDead: 0,
+        wins: 0,
+        losses: 0,
+        lastSeenTs: 0
+      };
+      existing.runs += 1;
+      existing.fightsLed += Math.max(0, toFiniteNumber(row?.fights));
+      existing.kills += Math.max(0, toFiniteNumber(row?.kills));
+      existing.downs += Math.max(0, toFiniteNumber(row?.downs));
+      existing.commanderDeaths += Math.max(0, toFiniteNumber(row?.commanderDeaths));
+      existing.alliesDead += Math.max(0, toFiniteNumber(row?.alliesDead));
+      existing.wins += Math.max(0, toFiniteNumber(row?.wins));
+      existing.losses += Math.max(0, toFiniteNumber(row?.losses));
+      existing.lastSeenTs = Math.max(existing.lastSeenTs, timestamp);
+      if (Array.isArray(row?.characterNames)) {
+        row.characterNames.forEach((name) => {
+          const normalized = String(name || "").trim();
+          if (normalized) existing.characterNames.add(normalized);
+        });
+      }
+      const profession = String(row?.profession || "").trim();
+      if (profession) {
+        existing.professionCounts[profession] = (existing.professionCounts[profession] || 0) + 1;
+      }
+      commanders.set(account, existing);
+    });
+  });
+  const commanderRows = Array.from(commanders.values()).map((entry) => {
+    const kdr = entry.alliesDead > 0 ? entry.kills / entry.alliesDead : entry.kills;
+    return {
+      account: entry.account,
+      characterNames: Array.from(entry.characterNames.values()).sort((a, b) => a.localeCompare(b)),
+      profession: chooseMostCommonProfession(entry.professionCounts),
+      professionBreakdown: buildProfessionBreakdown(entry.professionCounts),
+      runs: entry.runs,
+      fightsLed: entry.fightsLed,
+      kills: entry.kills,
+      downs: entry.downs,
+      commanderDeaths: entry.commanderDeaths,
+      alliesDead: entry.alliesDead,
+      wins: entry.wins,
+      losses: entry.losses,
+      kdr,
+      lastSeenTs: entry.lastSeenTs
+    };
+  }).sort((a, b) => {
+    if (b.runs !== a.runs) return b.runs - a.runs;
+    if (b.fightsLed !== a.fightsLed) return b.fightsLed - a.fightsLed;
+    if (b.kills !== a.kills) return b.kills - a.kills;
+    return a.account.localeCompare(b.account);
+  });
+  const playerRows = Array.from(players.values()).map((entry) => ({
+    account: entry.account,
+    characterNames: Array.from(entry.characterNames.values()).sort((a, b) => a.localeCompare(b)),
+    profession: choosePrimaryProfession(entry.professionTimeMs),
+    professionBreakdown: buildProfessionBreakdown(entry.professionRuns),
+    runs: entry.runs,
+    combatTimeMs: entry.combatTimeMs,
+    squadTimeMs: entry.squadTimeMs,
+    lastSeenTs: entry.lastSeenTs
+  })).sort((a, b) => {
+    if (b.runs !== a.runs) return b.runs - a.runs;
+    if (b.lastSeenTs !== a.lastSeenTs) return b.lastSeenTs - a.lastSeenTs;
+    if (b.squadTimeMs !== a.squadTimeMs) return b.squadTimeMs - a.squadTimeMs;
+    return a.account.localeCompare(b.account);
+  });
+  return {
+    commanderRows,
+    playerRows,
+    sourceReports: reports.length,
+    uniqueRaids: includedRaidGroups,
+    duplicateReportsCollapsed: Math.max(0, includedSourceReports - includedRaidGroups),
+    raidsSkippedMissingRequiredData: Math.max(0, raidGroups.length - includedRaidGroups),
+    reportsWithCommanderDetails,
+    reportsMissingCommanderDetails,
+    reportsWithAttendanceDetails,
+    reportsMissingAttendanceDetails
+  };
+};
+
+// src/reportMetrics.ts
+var ReportSchemaError = class extends Error {
+};
+var num = (value) => {
+  const n = Number(value ?? 0);
+  return Number.isFinite(n) ? n : 0;
+};
+var extractRunSummary = (report) => {
+  const payload = report;
+  const id = String(payload?.meta?.id ?? "").trim();
+  if (!id) throw new ReportSchemaError("report has no meta.id \u2014 not an AxiBridge report.json");
+  const stats = payload?.stats ?? {};
+  const warnings = [];
+  const byAccount = /* @__PURE__ */ new Map();
+  const ensure = (row) => {
+    const account = String(row?.account ?? "").trim();
+    if (!account || account === "Unknown") return null;
+    let entry = byAccount.get(account);
+    if (!entry) {
+      entry = {
+        account,
+        profession: String(row?.profession ?? "Unknown"),
+        professionList: Array.isArray(row?.professionList) ? row.professionList.map(String) : [],
+        combatTimeMs: 0,
+        squadTimeMs: 0,
+        classTimes: [],
+        damage: 0,
+        downContribution: 0,
+        kills: 0,
+        downsCaused: 0,
+        strips: 0,
+        cleanses: 0,
+        resurrects: 0,
+        healing: 0,
+        barrier: 0,
+        hasHealAddon: false,
+        damageTaken: 0,
+        downs: 0,
+        deaths: 0,
+        logsJoined: 0
+      };
+      byAccount.set(account, entry);
+    }
+    return entry;
+  };
+  const tables = ["offensePlayers", "supportPlayers", "healingPlayers", "defensePlayers", "generalPlayers", "attendanceData"];
+  if (!tables.some((key) => Array.isArray(stats?.[key]) && stats[key].length > 0)) {
+    warnings.push("no player tables in report");
+  }
+  for (const row of Array.isArray(stats?.offensePlayers) ? stats.offensePlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.damage += num(row?.offenseTotals?.damage);
+    p.downContribution += num(row?.offenseTotals?.downContribution);
+    p.kills += num(row?.offenseTotals?.killed);
+    p.downsCaused += num(row?.offenseTotals?.downed);
+    p.strips = Math.max(p.strips, num(row?.offenseTotals?.boonStrips));
+  }
+  for (const row of Array.isArray(stats?.supportPlayers) ? stats.supportPlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.cleanses += num(row?.supportTotals?.condiCleanse);
+    p.strips = Math.max(p.strips, num(row?.supportTotals?.boonStrips));
+    p.resurrects += num(row?.supportTotals?.resurrects);
+    p.logsJoined = Math.max(p.logsJoined, num(row?.logsJoined));
+  }
+  for (const row of Array.isArray(stats?.healingPlayers) ? stats.healingPlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.healing += num(row?.healingTotals?.squadHealing ?? row?.healingTotals?.healing);
+    p.barrier += num(row?.healingTotals?.squadBarrier ?? row?.healingTotals?.barrier);
+    if (row?.hasHealAddon === true) p.hasHealAddon = true;
+  }
+  for (const row of Array.isArray(stats?.defensePlayers) ? stats.defensePlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.damageTaken += num(row?.defenseTotals?.damageTaken);
+    p.downs += num(row?.defenseTotals?.downCount);
+    p.deaths += num(row?.defenseTotals?.deadCount);
+  }
+  for (const row of Array.isArray(stats?.generalPlayers) ? stats.generalPlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.combatTimeMs = Math.max(p.combatTimeMs, num(row?.squadActiveMs ?? row?.totalFightMs));
+    p.logsJoined = Math.max(p.logsJoined, num(row?.logsJoined));
+  }
+  for (const row of Array.isArray(stats?.attendanceData) ? stats.attendanceData : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.combatTimeMs = Math.max(p.combatTimeMs, num(row?.combatTimeMs));
+    p.squadTimeMs = Math.max(p.squadTimeMs, num(row?.squadTimeMs));
+    if (Array.isArray(row?.classTimes)) {
+      p.classTimes = row.classTimes.map((c) => ({ profession: String(c?.profession ?? ""), timeMs: num(c?.timeMs) })).filter((c) => c.profession && c.timeMs > 0);
+    }
+  }
+  return {
+    id,
+    title: String(payload?.meta?.title ?? id),
+    dateStart: payload?.meta?.dateStart ?? null,
+    dateEnd: payload?.meta?.dateEnd ?? null,
+    fights: num(stats?.total),
+    wins: num(stats?.wins),
+    losses: num(stats?.losses),
+    avgSquadSize: typeof stats?.avgSquadSize === "number" ? stats.avgSquadSize : null,
+    avgEnemies: typeof stats?.avgEnemies === "number" ? stats.avgEnemies : null,
+    squadDeaths: num(stats?.totalSquadDeaths),
+    squadDowns: num(stats?.totalSquadDowns),
+    enemyDeaths: num(stats?.totalEnemyDeaths),
+    enemyDowns: num(stats?.totalEnemyDowns),
+    commanders: Array.isArray(payload?.meta?.commanders) ? payload.meta.commanders.map(String) : [],
+    players: Array.from(byAccount.values()),
+    warnings
+  };
+};
+var aggregatePlayers = (summaries, accounts) => {
+  const wanted = accounts && accounts.length > 0 ? new Set(accounts.map((a) => a.toLowerCase())) : null;
+  const map = /* @__PURE__ */ new Map();
+  for (const run of summaries) {
+    for (const p of run.players) {
+      if (wanted && !wanted.has(p.account.toLowerCase())) continue;
+      let agg = map.get(p.account);
+      if (!agg) {
+        agg = {
+          account: p.account,
+          runsJoined: 0,
+          combatTimeMs: 0,
+          squadTimeMs: 0,
+          professionTimeMs: {},
+          damage: 0,
+          dps: 0,
+          downContribution: 0,
+          kills: 0,
+          strips: 0,
+          cleanses: 0,
+          resurrects: 0,
+          healing: 0,
+          barrier: 0,
+          damageTaken: 0,
+          downs: 0,
+          deaths: 0,
+          lastSeen: null
+        };
+        map.set(p.account, agg);
+      }
+      agg.runsJoined += 1;
+      agg.combatTimeMs += p.combatTimeMs;
+      agg.squadTimeMs += p.squadTimeMs;
+      for (const c of p.classTimes) {
+        agg.professionTimeMs[c.profession] = (agg.professionTimeMs[c.profession] || 0) + c.timeMs;
+      }
+      agg.damage += p.damage;
+      agg.downContribution += p.downContribution;
+      agg.kills += p.kills;
+      agg.strips += p.strips;
+      agg.cleanses += p.cleanses;
+      agg.resurrects += p.resurrects;
+      agg.healing += p.healing;
+      agg.barrier += p.barrier;
+      agg.damageTaken += p.damageTaken;
+      agg.downs += p.downs;
+      agg.deaths += p.deaths;
+      const seen = run.dateEnd ?? run.dateStart;
+      if (seen && (!agg.lastSeen || seen > agg.lastSeen)) agg.lastSeen = seen;
+    }
+  }
+  const rows = Array.from(map.values());
+  for (const row of rows) {
+    row.dps = row.combatTimeMs > 0 ? row.damage / (row.combatTimeMs / 1e3) : 0;
+  }
+  return rows.sort((a, b) => b.damage - a.damage);
+};
+var RUN_SET_METRICS = [
+  "fights",
+  "wins",
+  "losses",
+  "squadDeaths",
+  "squadDowns",
+  "enemyDeaths",
+  "enemyDowns"
+];
+var compareRunSets = (a, b) => {
+  const total = (runs, metric) => runs.reduce((sum, run) => sum + num(run[metric]), 0);
+  return {
+    metrics: RUN_SET_METRICS.map((metric) => {
+      const va = total(a, metric);
+      const vb = total(b, metric);
+      return { metric, a: va, b: vb, delta: vb - va, deltaPct: va !== 0 ? (vb - va) / va : null };
+    })
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DISRUPTION_METHOD,
+  METRICS_SPEC,
+  NON_DAMAGING_CONDITIONS,
+  PROFESSION_COLORS,
+  ROLLUP_SOURCES_VERSION,
+  ReportSchemaError,
+  aggregatePlayers,
+  applySquadStabilityGeneration,
+  buildConditionIconMap,
+  buildRollupData,
+  compareRunSets,
+  computeDownContribution,
+  computeIncomingDisruptions,
+  computeOutgoingConditions,
+  computeOutgoingCrowdControl,
+  computePlayerAggregation,
+  computeSquadBarrier,
+  computeSquadHealing,
+  createPlayerAggregationAccumulators,
+  extractRollupSource,
+  extractRunSummary,
+  finalizePlayerAggregation,
+  getDefaultConditionIcon,
+  getFightDownsDeaths,
+  getFightOutcome,
+  getPlayerBlocked,
+  getPlayerBreakbarDamage,
+  getPlayerCleanses,
+  getPlayerDamage,
+  getPlayerDamageTaken,
+  getPlayerDashboardTotals,
+  getPlayerDeaths,
+  getPlayerDistanceToTag,
+  getPlayerDodges,
+  getPlayerDownsTaken,
+  getPlayerDps,
+  getPlayerEvaded,
+  getPlayerMissed,
+  getPlayerOutgoingInterrupts,
+  getPlayerResurrects,
+  getPlayerStrips,
+  getProfessionAbbrev,
+  getProfessionAbbrevSuperscript,
+  getProfessionBase,
+  getProfessionColor,
+  getProfessionEmoji,
+  getTargetStatTotal,
+  hexToRgba,
+  ingestLogPlayerData,
+  isResUtilitySkill,
+  normalizeConditionLabel,
+  parseFightTimestamp,
+  parseRollupSourcesFile,
+  precomputeGlobalEnemySkillStats,
+  removeRollupSources,
+  resolveBuffMetaById,
+  resolveConditionNameFromEntry,
+  resolveDisruptionValue,
+  resolveFightTimestamp,
+  resolveProfessionLabel,
+  toSuperscript,
+  updateRollupSourcesForPublish
+});