@axiapps/gw2-data 0.1.0

package/src/engine/attributes.js

@@ -0,0 +1,525 @@
+"use strict";
+
+const {
+  STAT_COMBOS_BY_LABEL,
+  getEffectiveStats,
+  SLOT_WEIGHTS,
+  TWO_HAND_WEIGHTS,
+  LAND_ONLY_SLOTS,
+  AQUATIC_SLOTS,
+  PROFESSION_BASE_HP,
+  PROFESSION_WEIGHT,
+  ARMOR_DEFENSE_BY_WEIGHT,
+  MIGHT_POWER_PER_STACK,
+  MIGHT_CONDI_PER_STACK,
+  FURY_CRIT_CHANCE,
+  FURY_CRIT_CHANCE_WVW,
+  STACKING_SIGIL_DEFS,
+  SIGNET_PASSIVE_BUFFS,
+  ALL_STAT_KEYS,
+  CONVERSION_TARGET_MAP,
+} = require("./constants");
+
+const { collectModifiers, isFuryTrait } = require("./modifiers");
+const { loadOverrides } = require("./overrides");
+
+// ---------------------------------------------------------------------------
+// Two-handed weapon types (no GW2_WEAPONS_BY_ID map — check by type string)
+// ---------------------------------------------------------------------------
+const TWO_HAND_WEAPON_TYPES = new Set([
+  "greatsword", "hammer", "longbow", "shortbow", "rifle", "staff",
+  "spear", "trident", "harpoon-gun",
+]);
+
+// ---------------------------------------------------------------------------
+// Stat name normalization maps for text parsing
+// ---------------------------------------------------------------------------
+const FOOD_STAT_MAP = {
+  "Condition Damage": "ConditionDamage",
+  "Healing Power": "HealingPower",
+  "Healing": "HealingPower",
+  "Power": "Power",
+  "Precision": "Precision",
+  "Toughness": "Toughness",
+  "Vitality": "Vitality",
+  "Ferocity": "Ferocity",
+  "Concentration": "Concentration",
+  "Expertise": "Expertise",
+};
+
+// Regex patterns for text parsing
+const FOOD_REGEX = /\+(\d+)\s+(Condition Damage|Healing Power|Healing|Power|Precision|Toughness|Vitality|Ferocity|Concentration|Expertise|to All Attributes)/g;
+const RUNE_REGEX = /\+(\d+)\s+(Condition Damage|Healing Power|Healing|Power|Precision|Toughness|Vitality|Ferocity|Concentration|Expertise|to All Stats)/;
+const UTILITY_CONVERSION_REGEX = /Gain (Condition Damage|Healing Power|Power|Precision|Toughness|Vitality|Ferocity|Concentration|Expertise) Equal to (\d+(?:\.\d+)?)% of Your (Condition Damage|Healing Power|Power|Precision|Toughness|Vitality|Ferocity|Concentration|Expertise)/g;
+const UTILITY_WRIT_REGEX = /Gain (\d+) (Condition Damage|Healing Power|Power|Precision|Toughness|Vitality|Ferocity|Concentration|Expertise) When Health/g;
+const UTILITY_FLAT_REGEX = /\+(\d+)\s+(Condition Damage|Healing Power|Power|Precision|Toughness|Vitality|Ferocity|Concentration|Expertise)/g;
+
+// ---------------------------------------------------------------------------
+// Helper: create zeroed stat object
+// ---------------------------------------------------------------------------
+function zeroStats() {
+  const obj = {};
+  for (const key of ALL_STAT_KEYS) obj[key] = 0;
+  return obj;
+}
+
+// ---------------------------------------------------------------------------
+// Helper: add value to stat object in-place
+// ---------------------------------------------------------------------------
+function addStat(obj, stat, value) {
+  const key = CONVERSION_TARGET_MAP[stat] || stat;
+  if (key in obj) {
+    obj[key] += value;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// getExcludedSlots(underwaterMode, activeWeaponSet) — pure function
+// ---------------------------------------------------------------------------
+function getExcludedSlots(underwaterMode, activeWeaponSet) {
+  const isUnderwater = Boolean(underwaterMode);
+  const activeSet = Number(activeWeaponSet) || 1;
+  const excluded = new Set(isUnderwater ? LAND_ONLY_SLOTS : AQUATIC_SLOTS);
+
+  if (isUnderwater) {
+    excluded.add(activeSet === 2 ? "aquatic1" : "aquatic2");
+  } else {
+    if (activeSet === 2) {
+      excluded.add("mainhand1");
+      excluded.add("offhand1");
+    } else {
+      excluded.add("mainhand2");
+      excluded.add("offhand2");
+    }
+  }
+
+  return excluded;
+}
+
+// ---------------------------------------------------------------------------
+// computeSlotStats(comboLabel, slotKey, weapons, gameMode) — pure function
+// ---------------------------------------------------------------------------
+function computeSlotStats(comboLabel, slotKey, weapons, gameMode) {
+  const combo = STAT_COMBOS_BY_LABEL.get(comboLabel);
+  if (!combo) return [];
+
+  // Determine slot weights
+  let weights = SLOT_WEIGHTS[slotKey];
+  if (!weights) return [];
+
+  // Check for two-handed weapon
+  const isTwoHand =
+    slotKey.startsWith("mainhand") &&
+    TWO_HAND_WEAPON_TYPES.has(weapons && weapons[slotKey]);
+  if (isTwoHand) {
+    weights = TWO_HAND_WEIGHTS;
+  }
+
+  const effectiveStats = getEffectiveStats(combo, gameMode);
+  const count = effectiveStats.length;
+  const result = [];
+
+  if (count <= 3) {
+    // p/s pattern: first stat is major (p), rest are minor (s)
+    effectiveStats.forEach((stat, i) => {
+      result.push({ stat, value: i === 0 ? weights.p : weights.s });
+    });
+  } else if (count === 4) {
+    // p4/p4/s4/s4 pattern: first 2 major, last 2 minor
+    effectiveStats.forEach((stat, i) => {
+      result.push({ stat, value: i < 2 ? weights.p4 : weights.s4 });
+    });
+  } else {
+    // >4 stats: celestial — all use c weight
+    effectiveStats.forEach((stat) => {
+      result.push({ stat, value: weights.c });
+    });
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Parse food buff text into stat contributions
+// ---------------------------------------------------------------------------
+function parseFoodBuff(buffText) {
+  const stats = zeroStats();
+  if (!buffText) return stats;
+
+  FOOD_REGEX.lastIndex = 0;
+  let match;
+  while ((match = FOOD_REGEX.exec(buffText)) !== null) {
+    const value = parseInt(match[1], 10);
+    const statName = match[2];
+    if (statName === "to All Attributes") {
+      for (const key of ALL_STAT_KEYS) stats[key] += value;
+    } else {
+      const key = FOOD_STAT_MAP[statName];
+      if (key) stats[key] += value;
+    }
+  }
+  return stats;
+}
+
+// ---------------------------------------------------------------------------
+// Parse rune bonus text (single bonus string)
+// ---------------------------------------------------------------------------
+function parseRuneBonus(bonusText) {
+  const match = RUNE_REGEX.exec(bonusText);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const statName = match[2];
+  if (statName === "to All Stats") {
+    return { allStats: true, value };
+  }
+  const key = FOOD_STAT_MAP[statName];
+  if (!key) return null;
+  return { stat: key, value };
+}
+
+// ---------------------------------------------------------------------------
+// Parse utility buff text into stat contributions
+// Uses preConvTotal for conversion-style bonuses
+// ---------------------------------------------------------------------------
+function parseUtilityBuff(buffText, preConvTotal) {
+  const stats = zeroStats();
+  if (!buffText) return stats;
+
+  // Pattern 1: conversion ("Gain [Stat] Equal to N% of Your [SourceStat]")
+  UTILITY_CONVERSION_REGEX.lastIndex = 0;
+  let match;
+  while ((match = UTILITY_CONVERSION_REGEX.exec(buffText)) !== null) {
+    const targetStat = FOOD_STAT_MAP[match[1]] || match[1];
+    const pct = parseFloat(match[2]);
+    const sourceStat = FOOD_STAT_MAP[match[3]] || match[3];
+    const sourceVal = preConvTotal[sourceStat] || 0;
+    const bonus = Math.round(sourceVal * pct / 100);
+    if (targetStat in stats) stats[targetStat] += bonus;
+  }
+
+  // Pattern 2: writ ("Gain N [Stat] When Health")
+  UTILITY_WRIT_REGEX.lastIndex = 0;
+  while ((match = UTILITY_WRIT_REGEX.exec(buffText)) !== null) {
+    const value = parseInt(match[1], 10);
+    const key = FOOD_STAT_MAP[match[2]] || match[2];
+    if (key in stats) stats[key] += value;
+  }
+
+  // Pattern 3: flat ("+N [Stat]")
+  UTILITY_FLAT_REGEX.lastIndex = 0;
+  while ((match = UTILITY_FLAT_REGEX.exec(buffText)) !== null) {
+    const value = parseInt(match[1], 10);
+    const key = FOOD_STAT_MAP[match[2]] || match[2];
+    if (key in stats) stats[key] += value;
+  }
+
+  return stats;
+}
+
+// ---------------------------------------------------------------------------
+// computeAttributes(ctx, catalogs) — main function
+// ---------------------------------------------------------------------------
+function computeAttributes(ctx, catalogs) {
+  const overrides = loadOverrides();
+  const gameMode = ctx.gameMode || "pve";
+  const underwaterMode = ctx.underwaterMode || false;
+  const activeWeaponSet = ctx.activeWeaponSet || 1;
+  const equipment = ctx.equipment || {};
+  const weapons = equipment.weapons || {};
+
+  // Get excluded slots
+  const excluded = getExcludedSlots(underwaterMode, activeWeaponSet);
+
+  // -------------------------------------------------------------------------
+  // Step 1: Base stats
+  // -------------------------------------------------------------------------
+  const base = {
+    Power: 1000,
+    Precision: 1000,
+    Toughness: 1000,
+    Vitality: 1000,
+    Ferocity: 0,
+    ConditionDamage: 0,
+    Expertise: 0,
+    Concentration: 0,
+    HealingPower: 0,
+  };
+
+  // -------------------------------------------------------------------------
+  // Step 2: Equipment slots
+  // -------------------------------------------------------------------------
+  const equipmentStats = zeroStats();
+  const slots = equipment.slots || {};
+  for (const [slotKey, comboLabel] of Object.entries(slots)) {
+    if (excluded.has(slotKey)) continue;
+    if (!comboLabel) continue;
+    const slotStats = computeSlotStats(comboLabel, slotKey, weapons, gameMode);
+    for (const { stat, value } of slotStats) {
+      if (stat in equipmentStats) equipmentStats[stat] += value;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 3: Food
+  // -------------------------------------------------------------------------
+  const foodStats = zeroStats();
+  if (equipment.food && catalogs.foodById) {
+    const food = catalogs.foodById.get(equipment.food);
+    if (food?.buff) {
+      const parsed = parseFoodBuff(food.buff);
+      for (const key of ALL_STAT_KEYS) foodStats[key] += parsed[key];
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 4: Runes — count per rune ID across equipped slots, apply cumulative bonuses
+  // -------------------------------------------------------------------------
+  const runeStats = zeroStats();
+  if (equipment.runes && catalogs.runeById) {
+    // Count rune IDs (excluding excluded slots)
+    const runeCounts = new Map();
+    for (const [slotKey, runeId] of Object.entries(equipment.runes)) {
+      if (excluded.has(slotKey)) continue;
+      if (!runeId) continue;
+      const id = Number(runeId);
+      runeCounts.set(id, (runeCounts.get(id) || 0) + 1);
+    }
+
+    // Apply cumulative bonuses up to count (max 6)
+    for (const [runeId, count] of runeCounts) {
+      const rune = catalogs.runeById.get(runeId);
+      if (!rune?.bonuses) continue;
+      const bonuses = rune.bonuses;
+      const applyCount = Math.min(count, 6, bonuses.length);
+      for (let i = 0; i < applyCount; i++) {
+        const parsed = parseRuneBonus(bonuses[i]);
+        if (!parsed) continue;
+        if (parsed.allStats) {
+          for (const key of ALL_STAT_KEYS) runeStats[key] += parsed.value;
+        } else {
+          runeStats[parsed.stat] += parsed.value;
+        }
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 5: Infusions — per slot, flatMap arrays, lookup infixUpgrade.attributes
+  // -------------------------------------------------------------------------
+  const infusionStats = zeroStats();
+  if (equipment.infusions && catalogs.infusionById) {
+    for (const [slotKey, infusionIds] of Object.entries(equipment.infusions)) {
+      if (excluded.has(slotKey)) continue;
+      const ids = Array.isArray(infusionIds) ? infusionIds : [infusionIds];
+      for (const infId of ids) {
+        if (!infId) continue;
+        const inf = catalogs.infusionById.get(Number(infId));
+        if (!inf?.infixUpgrade?.attributes) continue;
+        for (const attr of inf.infixUpgrade.attributes) {
+          const key = CONVERSION_TARGET_MAP[attr.attribute] || attr.attribute;
+          if (key in infusionStats) infusionStats[key] += attr.modifier || 0;
+        }
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 6: Enrichment
+  // -------------------------------------------------------------------------
+  const enrichmentStats = zeroStats();
+  if (equipment.enrichment && catalogs.enrichmentById) {
+    const enr = catalogs.enrichmentById.get(Number(equipment.enrichment));
+    if (enr?.infixUpgrade?.attributes) {
+      for (const attr of enr.infixUpgrade.attributes) {
+        const key = CONVERSION_TARGET_MAP[attr.attribute] || attr.attribute;
+        if (key in enrichmentStats) enrichmentStats[key] += attr.modifier || 0;
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 7: Signets
+  // -------------------------------------------------------------------------
+  const signetStats = zeroStats();
+  if (ctx.skills) {
+    const skillIds = [
+      ctx.skills.healId,
+      ...(ctx.skills.utilityIds || []),
+      ctx.skills.eliteId,
+    ].filter(Boolean).map(Number);
+
+    for (const skillId of skillIds) {
+      const buff = SIGNET_PASSIVE_BUFFS.get(skillId);
+      if (buff && buff.stat in signetStats) {
+        signetStats[buff.stat] += buff.value;
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 9: Pre-conversion totals (base + equipment + food + runes + infusions + enrichment + signets)
+  // (Utility is added after — but wait for its conversion to use pre-conv totals)
+  // Note: We compute pre-conv totals without utility first, then add utility (non-conversion parts)
+  // Actually per spec: utility conversion uses preConvTotal. We'll compute pre-conv WITHOUT utility,
+  // parse utility conversions using that, then add utility flat/writ parts separately.
+  // -------------------------------------------------------------------------
+  const preConvBase = zeroStats();
+  for (const key of ALL_STAT_KEYS) {
+    preConvBase[key] = (base[key] || 0) + equipmentStats[key] + foodStats[key] +
+      runeStats[key] + infusionStats[key] + enrichmentStats[key] + signetStats[key];
+  }
+
+  // Parse utility buff using preConvBase as the "preConvTotal" for conversion
+  const utilityStats = zeroStats();
+  if (equipment.utility && catalogs.utilityById) {
+    const utility = catalogs.utilityById.get(equipment.utility);
+    if (utility?.buff) {
+      const parsed = parseUtilityBuff(utility.buff, preConvBase);
+      for (const key of ALL_STAT_KEYS) utilityStats[key] += parsed[key];
+    }
+  }
+
+  // Recompute pre-conv totals including utility (for trait conversions)
+  const preConvTotal = zeroStats();
+  for (const key of ALL_STAT_KEYS) {
+    preConvTotal[key] = preConvBase[key] + utilityStats[key];
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 10: Traits — flat bonuses from active traits
+  // -------------------------------------------------------------------------
+  const traitStats = zeroStats();
+  const modifiers = collectModifiers(ctx, catalogs, overrides);
+  const furyAssumed = Boolean(ctx.assumedBoons?.fury);
+  const berserkActive = Boolean(ctx.berserkActive);
+
+  for (const mod of modifiers) {
+    if (mod.type !== "flatBonus") continue;
+    // Apply if: passive (condition === null), fury (when assumed), or berserk (when toggled)
+    if (mod.condition === null
+        || (mod.condition === "fury" && furyAssumed)
+        || (mod.condition === "berserk" && berserkActive)) {
+      if (mod.target in traitStats) {
+        traitStats[mod.target] += mod.value;
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 11: Conversions — trait conversion modifiers
+  // -------------------------------------------------------------------------
+  const conversionStats = zeroStats();
+  for (const mod of modifiers) {
+    if (mod.type !== "conversion") continue;
+    const sourceVal = preConvTotal[mod.sourceAttr] || 0;
+    const bonus = Math.floor(sourceVal * mod.percent / 100);
+    if (mod.target in conversionStats) {
+      conversionStats[mod.target] += bonus;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 12: Boons — Might stacks, fury crit (handled in derived)
+  // -------------------------------------------------------------------------
+  const boonStats = zeroStats();
+  const mightStacks = ctx.assumedBoons?.might || 0;
+
+  if (mightStacks > 0) {
+    // Check for mightModifier overrides from traits
+    let mightPower = MIGHT_POWER_PER_STACK;
+    let mightCondi = MIGHT_CONDI_PER_STACK;
+    for (const mod of modifiers) {
+      if (mod.type === "mightModifier") {
+        if (mod.power != null) mightPower = mod.power;
+        if (mod.condi != null) mightCondi = mod.condi;
+      }
+    }
+    boonStats.Power += mightStacks * mightPower;
+    boonStats.ConditionDamage += mightStacks * mightCondi;
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 13: Sigils — stacking sigil contributions
+  // -------------------------------------------------------------------------
+  const sigilStats = zeroStats();
+  const sigilStacks = ctx.sigilStacks || {};
+  for (const def of STACKING_SIGIL_DEFS) {
+    const stacks = sigilStacks[def.key] || 0;
+    if (stacks <= 0) continue;
+    if (def.stat) {
+      if (def.stat in sigilStats) sigilStats[def.stat] += stacks * def.perStack;
+    } else if (def.allStats) {
+      for (const stat of def.allStats) {
+        if (stat in sigilStats) sigilStats[stat] += stacks * def.perStack;
+      }
+    }
+    // Note: def.modifier (e.g., "Outgoing Healing") is not a stat — skip
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 14: Total
+  // -------------------------------------------------------------------------
+  const total = zeroStats();
+  const sources = [base, equipmentStats, foodStats, runeStats, infusionStats,
+    enrichmentStats, utilityStats, signetStats, traitStats, conversionStats,
+    boonStats, sigilStats];
+  for (const src of sources) {
+    for (const key of ALL_STAT_KEYS) {
+      total[key] += src[key] || 0;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Step 15: Derived stats
+  // -------------------------------------------------------------------------
+  const weightClass = PROFESSION_WEIGHT[ctx.profession] || "medium";
+  const profBaseHp = PROFESSION_BASE_HP[ctx.profession] || 0;
+
+  const health = profBaseHp + total.Vitality * 10;
+
+  // Fury crit bonus
+  let furyCritBonus = 0;
+  if (furyAssumed) {
+    furyCritBonus += gameMode === "wvw" ? FURY_CRIT_CHANCE_WVW : FURY_CRIT_CHANCE;
+    // Add any critChance modifiers from traits that have condition === "fury"
+    for (const mod of modifiers) {
+      if (mod.type === "critChance" && mod.condition === "fury") {
+        furyCritBonus += mod.value;
+      }
+    }
+  }
+
+  const critChance = Math.min(100, (total.Precision - 895) / 21 + furyCritBonus);
+  const critDamage = 150 + total.Ferocity / 15;
+  const conditionDuration = total.Expertise / 15;
+  const boonDuration = total.Concentration / 15;
+  const armor = total.Toughness + ARMOR_DEFENSE_BY_WEIGHT[weightClass];
+
+  const derived = {
+    health,
+    critChance,
+    critDamage,
+    conditionDuration,
+    boonDuration,
+    armor,
+  };
+
+  return {
+    base,
+    equipment: equipmentStats,
+    food: foodStats,
+    runes: runeStats,
+    infusions: infusionStats,
+    enrichment: enrichmentStats,
+    utility: utilityStats,
+    signets: signetStats,
+    traits: traitStats,
+    conversions: conversionStats,
+    boons: boonStats,
+    sigils: sigilStats,
+    total,
+    derived,
+  };
+}
+
+module.exports = { computeAttributes, computeSlotStats, getExcludedSlots };

package/src/engine/boons.js

@@ -0,0 +1,156 @@
+"use strict";
+
+const {
+  BOON_NAMES, CONDITION_NAMES, CONDITION_NAME_NORMALIZE,
+  BOON_DISPLAY_ORDER, BUFF_FACT_TYPES,
+} = require("./constants");
+
+function normalizeName(status) {
+  return CONDITION_NAME_NORMALIZE[status] || status;
+}
+
+function isAllyTargeted(description, statusName, allBoonNames) {
+  if (!description) return false;
+  const desc = description.toLowerCase();
+  const statusLower = statusName.toLowerCase();
+  const sentences = desc.split(".");
+
+  // Check if boon name in ally sentence
+  let foundInAllySentence = false;
+  let foundInDescription = false;
+  for (const sentence of sentences) {
+    const trimmed = sentence.trim();
+    if (!trimmed) continue;
+    const hasAlly = /\balli(?:es|ed)?\b/.test(trimmed) || /\bally\b/.test(trimmed);
+    const hasBoon = trimmed.includes(statusLower);
+    if (hasBoon) foundInDescription = true;
+    if (hasBoon && hasAlly) foundInAllySentence = true;
+  }
+
+  if (foundInAllySentence) return true;
+  if (foundInDescription) return false;
+
+  // Boon not named in description — check for generic ally mention
+  const hasGenericAlly = /\balli(?:es|ed)?\b/.test(desc) || /\bally\b/.test(desc);
+  if (!hasGenericAlly) return false;
+
+  // But if specific boons ARE named with allies, this unnamed one is probably self
+  if (allBoonNames && allBoonNames.length > 0) {
+    for (const otherBoon of allBoonNames) {
+      const otherLower = otherBoon.toLowerCase();
+      if (otherLower === statusLower) continue;
+      for (const sentence of sentences) {
+        const trimmed = sentence.trim();
+        const hasAlly = /\balli(?:es|ed)?\b/.test(trimmed) || /\bally\b/.test(trimmed);
+        if (trimmed.includes(otherLower) && hasAlly) return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+function analyzeBoons(skills, traits, overrides, activeTraitIds) {
+  const boonMap = new Map(); // name → { name, sources: [] }
+  const condMap = new Map();
+
+  // Check for Twisted Medicine override
+  const twistedMedicineOverride = overrides.get("trait:2220");
+  const hasTwistedMedicine = activeTraitIds && twistedMedicineOverride &&
+    activeTraitIds.has(2220);
+
+  function processEntity(entity, type) {
+    const facts = entity.facts || [];
+    const description = entity.description || "";
+
+    // Collect all boon names from this entity for ally classification
+    const entityBoonNames = [];
+    for (const fact of facts) {
+      if (!BUFF_FACT_TYPES.has(fact.type)) continue;
+      const name = normalizeName(fact.status);
+      if (BOON_NAMES.has(name)) entityBoonNames.push(name);
+    }
+
+    // Track section context from NoData facts
+    let currentContext = null;
+
+    for (const fact of facts) {
+      if (fact.type === "NoData" && fact.text) {
+        currentContext = fact.text;
+        continue;
+      }
+
+      if (!BUFF_FACT_TYPES.has(fact.type)) continue;
+      if (!fact.status) continue;
+
+      const name = normalizeName(fact.status);
+      const stacks = fact.apply_count || 1;
+      const duration = fact.duration || 0;
+
+      const isBoon = BOON_NAMES.has(name);
+      const isCondition = CONDITION_NAMES.has(name);
+      if (!isBoon && !isCondition) continue;
+
+      // Determine ally targeting
+      let isAlly = isAllyTargeted(description, name, entityBoonNames);
+
+      // Twisted Medicine override
+      if (hasTwistedMedicine && entity.categories) {
+        const cats = entity.categories.map((c) => c.toLowerCase());
+        const allyTargetedCats = twistedMedicineOverride.allyTargeted || [];
+        if (allyTargetedCats.some((c) => cats.includes(c.toLowerCase()))) {
+          isAlly = true;
+        }
+      }
+
+      const source = {
+        type,
+        name: entity.name || "",
+        sourceName: entity.name || "",
+        stacks,
+        duration,
+        isAlly,
+        context: currentContext,
+      };
+
+      const map = isBoon ? boonMap : condMap;
+      if (!map.has(name)) {
+        map.set(name, { name, sources: [] });
+      }
+
+      // Deduplicate by (sourceName, stacks, duration, context)
+      const entry = map.get(name);
+      const isDuplicate = entry.sources.some(
+        (s) => s.sourceName === source.sourceName &&
+               s.stacks === source.stacks &&
+               s.duration === source.duration &&
+               s.context === source.context
+      );
+      if (!isDuplicate) {
+        entry.sources.push(source);
+      }
+    }
+  }
+
+  for (const skill of skills || []) {
+    if (skill) processEntity(skill, "skill");
+  }
+  for (const trait of traits || []) {
+    if (trait) processEntity(trait, "trait");
+  }
+
+  // Sort boons by display order
+  const boonOrder = new Map(BOON_DISPLAY_ORDER.map((name, i) => [name, i]));
+  const boons = [...boonMap.values()].sort((a, b) => {
+    const ai = boonOrder.has(a.name) ? boonOrder.get(a.name) : 999;
+    const bi = boonOrder.has(b.name) ? boonOrder.get(b.name) : 999;
+    return ai - bi;
+  });
+
+  // Sort conditions alphabetically
+  const conditions = [...condMap.values()].sort((a, b) => a.name.localeCompare(b.name));
+
+  return { boons, conditions };
+}
+
+module.exports = { analyzeBoons, isAllyTargeted, normalizeName };