@axiapps/gw2-data 0.1.1 → 0.1.3

package/data/overrides.json

@@ -18,8 +18,32 @@
   "trait:1831": {
     "description": "Primal Rage: grants access to Primal Bursts (no burst recharge reduction)"
   },
+  "trait:1453": {
+    "mightOverride": { "power": 40 },
+    "description": "Pinnacle of Strength: Might grants +10 bonus Power per stack (40P instead of 30P), +5% passive crit chance"
+  },
   "trait:2046": {
     "berserkConditional": true,
     "description": "Fatal Frenzy: stat bonuses only apply while in berserk mode"
+  },
+  "trait:2049": {
+    "berserkConditional": true,
+    "description": "Smash Brawler: crit chance bonus only applies while in berserk mode"
+  },
+  "trait:1338": {
+    "weaponConditional": { "weapons": ["greatsword", "spear"], "multiplier": 2 },
+    "description": "Forceful Greatsword: double Power bonus while wielding greatsword or underwater spear"
+  },
+  "trait:1011": {
+    "ignoreCritChance": true,
+    "description": "Precise Strike: 100% crit chance applies to Opening Strike only, not passive"
+  },
+  "trait:1215": {
+    "ignoreCritChance": true,
+    "description": "Hidden Killer: 100% crit chance applies while stealthed only, not passive"
+  },
+  "trait:1336": {
+    "ignoreCritChance": true,
+    "description": "Burst Precision: 100% crit chance applies to Burst skills only, not passive"
   }
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@axiapps/gw2-data",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "GW2 data library — wiki-sourced facts, GW2 API structural data, and stat computation",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
     "./wiki": "./src/wiki/client.js",
+    "./wiki/resolver": "./src/wiki/resolver.js",
     "./api": "./src/api/client.js",
     "./facts": "./src/facts/merge.js",
     "./engine": "./src/engine/index.js"
@@ -19,6 +20,8 @@
     "clearMocks": true,
     "testTimeout": 15000
   },
+  "files": ["src", "data", "README.md"],
+  "publishConfig": { "access": "public" },
   "license": "MIT",
   "keywords": ["gw2", "guild-wars-2", "wiki", "api", "build-editor"],
   "repository": {

package/src/engine/attributes.js

@@ -14,8 +14,11 @@ const {
   MIGHT_CONDI_PER_STACK,
   FURY_CRIT_CHANCE,
   FURY_CRIT_CHANCE_WVW,
+  BERSERK_CRIT_CHANCE,
+  BERSERK_CRIT_CHANCE_WVW,
   STACKING_SIGIL_DEFS,
   SIGNET_PASSIVE_BUFFS,
+  SIGNET_ACTIVE_EFFECTS,
   ALL_STAT_KEYS,
   CONVERSION_TARGET_MAP,
 } = require("./constants");
@@ -305,13 +308,31 @@ function computeAttributes(ctx, catalogs) {
 
   // -------------------------------------------------------------------------
   // Step 5: Infusions — per slot, flatMap arrays, lookup infixUpgrade.attributes
+  // For mainhand weapon slots, limit infusion count based on weapon type:
+  // 1H weapons get 1 infusion slot, 2H/aquatic weapons get 2.
   // -------------------------------------------------------------------------
   const infusionStats = zeroStats();
   if (equipment.infusions && catalogs.infusionById) {
     for (const [slotKey, infusionIds] of Object.entries(equipment.infusions)) {
       if (excluded.has(slotKey)) continue;
+      // Skip offhand infusions when the corresponding mainhand has a two-handed weapon
+      // (offhand is locked/empty when mainhand is 2H, so its infusions shouldn't count)
+      if (slotKey.startsWith("offhand") && !slotKey.startsWith("aquatic")) {
+        const mainhandKey = slotKey.replace("offhand", "mainhand");
+        if (TWO_HAND_WEAPON_TYPES.has(weapons[mainhandKey] || "")) continue;
+      }
       const ids = Array.isArray(infusionIds) ? infusionIds : [infusionIds];
-      for (const infId of ids) {
+      // Cap infusion slots for mainhand weapons: 2H = 2, 1H = 1
+      let maxSlots = ids.length;
+      if (slotKey.startsWith("mainhand") || slotKey.startsWith("aquatic")) {
+        const weaponType = weapons[slotKey] || "";
+        if (weaponType && !slotKey.startsWith("aquatic")) {
+          maxSlots = TWO_HAND_WEAPON_TYPES.has(weaponType) ? 2 : 1;
+        }
+      }
+      const limit = Math.min(ids.length, maxSlots);
+      for (let i = 0; i < limit; i++) {
+        const infId = ids[i];
         if (!infId) continue;
         const inf = catalogs.infusionById.get(Number(infId));
         if (!inf?.infixUpgrade?.attributes) continue;
@@ -341,6 +362,8 @@ function computeAttributes(ctx, catalogs) {
   // Step 7: Signets
   // -------------------------------------------------------------------------
   const signetStats = zeroStats();
+  // Boons granted by activated signet active skills (aggregated for engine use).
+  const signetActiveBoons = { might: 0, fury: false };
   if (ctx.skills) {
     const skillIds = [
       ctx.skills.healId,
@@ -348,20 +371,49 @@ function computeAttributes(ctx, catalogs) {
       ctx.skills.eliteId,
     ].filter(Boolean).map(Number);
 
+    // Signet state per signet — three values:
+    //   undefined / "passive" / true  → passive bonus applies (default)
+    //   "active"                      → skill used: active effect applies, passive removed
+    //   "cooldown" / false            → on cooldown: passive removed, no active bonus yet
+    // Absent/null activeSignets → all passives apply (backward compatible).
+    const activeSignets = ctx.activeSignets;
+    const getSignetState = (id) => {
+      if (!activeSignets) return "passive";
+      const v = activeSignets instanceof Map ? activeSignets.get(id) : activeSignets[id];
+      if (v === "active")   return "active";
+      if (v === "cooldown" || v === false) return "cooldown";
+      return "passive"; // undefined, true, "passive"
+    };
+
     for (const skillId of skillIds) {
+      const state = getSignetState(skillId);
       const buff = SIGNET_PASSIVE_BUFFS.get(skillId);
-      if (buff && buff.stat in signetStats) {
+      if (buff && buff.stat in signetStats && state === "passive") {
         signetStats[buff.stat] += buff.value;
       }
+      // When signet active is used, apply its active-skill effect.
+      if (state === "active") {
+        const active = SIGNET_ACTIVE_EFFECTS.get(skillId);
+        if (active) {
+          if (active.stats) {
+            for (const [stat, val] of Object.entries(active.stats)) {
+              if (stat in signetStats) signetStats[stat] += val;
+            }
+          }
+          if (active.boons) {
+            if (active.boons.might) signetActiveBoons.might += active.boons.might;
+            if (active.boons.fury)  signetActiveBoons.fury = true;
+          }
+        }
+      }
     }
   }
 
   // -------------------------------------------------------------------------
-  // 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.
+  // Step 9: Pre-conversion base (base + equipment + food + runes + infusions + enrichment + signets)
+  // Both utility conversions and trait conversions use this snapshot as their source so that
+  // neither can feed into the other (utility-converted stats don't inflate trait conversions
+  // and vice versa). Matches the fix for issue #227 (utility) extended to issue #228 (traits).
   // -------------------------------------------------------------------------
   const preConvBase = zeroStats();
   for (const key of ALL_STAT_KEYS) {
@@ -369,7 +421,7 @@ function computeAttributes(ctx, catalogs) {
       runeStats[key] + infusionStats[key] + enrichmentStats[key] + signetStats[key];
   }
 
-  // Parse utility buff using preConvBase as the "preConvTotal" for conversion
+  // Parse utility buff using preConvBase as the source for % conversions
   const utilityStats = zeroStats();
   if (equipment.utility && catalogs.utilityById) {
     const utility = catalogs.utilityById.get(equipment.utility);
@@ -379,39 +431,45 @@ function computeAttributes(ctx, catalogs) {
     }
   }
 
-  // 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 traitDetails = []; // per-trait breakdown: { traitId, name, target, value }
   const modifiers = collectModifiers(ctx, catalogs, overrides);
-  const furyAssumed = Boolean(ctx.assumedBoons?.fury);
+  const furyAssumed = Boolean(ctx.assumedBoons?.fury) || signetActiveBoons.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)
+    // Apply if: passive (condition === null), fury (when assumed or from signet active), 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;
+        // Extract trait ID from source (e.g. "trait:1338" → 1338)
+        const traitId = Number(mod.source?.replace("trait:", "")) || 0;
+        const trait = traitId && catalogs?.traitById?.get(traitId);
+        traitDetails.push({
+          traitId,
+          name: trait?.name || mod.source,
+          target: mod.target,
+          value: mod.value,
+        });
       }
     }
   }
 
   // -------------------------------------------------------------------------
   // Step 11: Conversions — trait conversion modifiers
+  // Source is preConvBase (same snapshot used for utility conversions, issue #228):
+  // excludes utility stats so utility-derived bonuses don't inflate trait conversions.
   // -------------------------------------------------------------------------
   const conversionStats = zeroStats();
   for (const mod of modifiers) {
     if (mod.type !== "conversion") continue;
-    const sourceVal = preConvTotal[mod.sourceAttr] || 0;
+    const sourceVal = preConvBase[mod.sourceAttr] || 0;
     const bonus = Math.floor(sourceVal * mod.percent / 100);
     if (mod.target in conversionStats) {
       conversionStats[mod.target] += bonus;
@@ -422,7 +480,10 @@ function computeAttributes(ctx, catalogs) {
   // Step 12: Boons — Might stacks, fury crit (handled in derived)
   // -------------------------------------------------------------------------
   const boonStats = zeroStats();
-  const mightStacks = ctx.assumedBoons?.might || 0;
+  // Total Might stacks = user-assumed + any from activated signet actives
+  const mightStacks = (ctx.assumedBoons?.might || 0) + signetActiveBoons.might;
+  // Fury = user-assumed OR granted by an activated signet active
+  const furyFromSignet = signetActiveBoons.fury;
 
   if (mightStacks > 0) {
     // Check for mightModifier overrides from traits
@@ -477,19 +538,35 @@ function computeAttributes(ctx, catalogs) {
 
   const health = profBaseHp + total.Vitality * 10;
 
+  // Crit bonus from traits and boons
+  let critBonus = 0;
+  // Passive crit chance modifiers (always active, condition === null)
+  for (const mod of modifiers) {
+    if (mod.type === "critChance" && mod.condition === null) {
+      critBonus += mod.value;
+    }
+  }
   // 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"
+    critBonus += gameMode === "wvw" ? FURY_CRIT_CHANCE_WVW : FURY_CRIT_CHANCE;
     for (const mod of modifiers) {
       if (mod.type === "critChance" && mod.condition === "fury") {
-        furyCritBonus += mod.value;
+        critBonus += mod.value;
+      }
+    }
+  }
+  // Berserk crit bonus (only when berserk mode is active)
+  // WvW: base berserk crit is 0; crit comes from berserk-conditional traits (e.g. Smash Brawler WvW: +5%).
+  if (berserkActive) {
+    critBonus += gameMode === "wvw" ? BERSERK_CRIT_CHANCE_WVW : BERSERK_CRIT_CHANCE;
+    for (const mod of modifiers) {
+      if (mod.type === "critChance" && mod.condition === "berserk") {
+        critBonus += mod.value;
       }
     }
   }
 
-  const critChance = Math.min(100, (total.Precision - 895) / 21 + furyCritBonus);
+  const critChance = Math.min(100, (total.Precision - 895) / 21 + critBonus);
   const critDamage = 150 + total.Ferocity / 15;
   const conditionDuration = total.Expertise / 15;
   const boonDuration = total.Concentration / 15;
@@ -513,7 +590,9 @@ function computeAttributes(ctx, catalogs) {
     enrichment: enrichmentStats,
     utility: utilityStats,
     signets: signetStats,
+    signetActiveBoons,
     traits: traitStats,
+    traitDetails,
     conversions: conversionStats,
     boons: boonStats,
     sigils: sigilStats,

package/src/engine/boons.js

@@ -60,9 +60,27 @@ function analyzeBoons(skills, traits, overrides, activeTraitIds) {
     activeTraitIds.has(2220);
 
   function processEntity(entity, type) {
-    const facts = entity.facts || [];
+    const baseFacts = entity.facts || [];
     const description = entity.description || "";
 
+    // Merge traited_facts when the required trait is active (mirrors detail-panel logic).
+    // Entries with an `overrides` index replace the base fact at that position;
+    // entries without `overrides` are appended (e.g., Specter Wells gaining Resistance).
+    let facts = baseFacts;
+    const traitedFacts = entity.traitedFacts || [];
+    if (traitedFacts.length && activeTraitIds && activeTraitIds.size) {
+      facts = [...baseFacts];
+      for (const tf of traitedFacts) {
+        if (!activeTraitIds.has(Number(tf.requires_trait))) continue;
+        const { requires_trait: _r, overrides, ...factData } = tf;
+        if (overrides !== undefined && overrides !== null && overrides >= 0 && overrides < facts.length) {
+          facts[overrides] = factData;
+        } else if (overrides === undefined || overrides === null) {
+          facts.push(factData);
+        }
+      }
+    }
+
     // Collect all boon names from this entity for ally classification
     const entityBoonNames = [];
     for (const fact of facts) {

package/src/engine/constants.js

@@ -174,8 +174,10 @@ const BUFF_FACT_TYPES = new Set(["Buff", "ApplyBuffCondition", "PrefixedBuff"]);
 // Assumed boon stat effects (per GW2 wiki, level 80)
 const MIGHT_POWER_PER_STACK = 30;
 const MIGHT_CONDI_PER_STACK = 30;
-const FURY_CRIT_CHANCE = 25;     // percentage points (PvE)
-const FURY_CRIT_CHANCE_WVW = 20; // percentage points (WvW)
+const FURY_CRIT_CHANCE = 25;        // percentage points (PvE)
+const FURY_CRIT_CHANCE_WVW = 20;    // percentage points (WvW)
+const BERSERK_CRIT_CHANCE = 5;      // base crit from Berserk mode in PvE (Berserker elite spec)
+const BERSERK_CRIT_CHANCE_WVW = 0;  // WvW: berserk has no inherent crit; bonus comes entirely from traits (Smash Brawler WvW: +5%)
 
 // ---------------------------------------------------------------------------
 // Stacking sigils
@@ -222,6 +224,26 @@ const SIGNET_PASSIVE_BUFFS = new Map([
   [10622, { stat: "Power",           value: 180 }], // Signet of Spite
 ]);
 
+// ---------------------------------------------------------------------------
+// Signet active effects
+// ---------------------------------------------------------------------------
+// What each signet grants when its active skill is used (not the passive).
+// Key = skill ID. Value:
+//   stats: { StatKey: amount } — direct flat stat boost for the active duration
+//   boons: { might: N }       — N stacks of Might (each gives +30 Power, +30 CondiDmg)
+//   boons: { fury: true }     — Fury boon (25% crit chance PvE / 20% WvW)
+// Signets whose active has no stat-relevant effect (launch, immob, revive, etc.) are omitted.
+// Source: https://wiki.guildwars2.com/wiki/Signet (PvE values)
+const SIGNET_ACTIVE_EFFECTS = new Map([
+  // Warrior
+  [14404, { boons: { might: 10 } }],                          // Signet of Might → 10× Might
+  [14410, { stats: { Precision: 360, Ferocity: 360 } }],      // Signet of Fury  → +360 Prec, +360 Fero
+  // Ranger
+  [12491, { boons: { might: 10 } }],                          // Signet of the Wild → 10× Might
+  // Elementalist
+  [5542,  { boons: { fury: true } }],                         // Signet of Fire  → Fury
+]);
+
 // ---------------------------------------------------------------------------
 // Boon / condition name sets
 // ---------------------------------------------------------------------------
@@ -287,8 +309,11 @@ module.exports = {
   MIGHT_CONDI_PER_STACK,
   FURY_CRIT_CHANCE,
   FURY_CRIT_CHANCE_WVW,
+  BERSERK_CRIT_CHANCE,
+  BERSERK_CRIT_CHANCE_WVW,
   STACKING_SIGIL_DEFS,
   SIGNET_PASSIVE_BUFFS,
+  SIGNET_ACTIVE_EFFECTS,
   BOON_NAMES,
   CONDITION_NAMES,
   CONDITION_NAME_NORMALIZE,

package/src/engine/index.js

@@ -13,8 +13,8 @@ const {
   PROFESSION_WEIGHT, ARMOR_DEFENSE_BY_WEIGHT, PROFESSION_BASE_HP,
   WEAPON_STRENGTH_MIDPOINT, BUFF_FACT_TYPES,
   MIGHT_POWER_PER_STACK, MIGHT_CONDI_PER_STACK,
-  FURY_CRIT_CHANCE, FURY_CRIT_CHANCE_WVW,
-  STACKING_SIGIL_DEFS, SIGNET_PASSIVE_BUFFS,
+  FURY_CRIT_CHANCE, FURY_CRIT_CHANCE_WVW, BERSERK_CRIT_CHANCE, BERSERK_CRIT_CHANCE_WVW,
+  STACKING_SIGIL_DEFS, SIGNET_PASSIVE_BUFFS, SIGNET_ACTIVE_EFFECTS,
   BOON_NAMES, CONDITION_NAMES, CONDITION_NAME_NORMALIZE,
   BOON_DISPLAY_ORDER, ALL_STAT_KEYS, CONVERSION_TARGET_MAP,
 } = require("./constants");
@@ -75,8 +75,8 @@ module.exports = {
   PROFESSION_WEIGHT, ARMOR_DEFENSE_BY_WEIGHT, PROFESSION_BASE_HP,
   WEAPON_STRENGTH_MIDPOINT, BUFF_FACT_TYPES,
   MIGHT_POWER_PER_STACK, MIGHT_CONDI_PER_STACK,
-  FURY_CRIT_CHANCE, FURY_CRIT_CHANCE_WVW,
-  STACKING_SIGIL_DEFS, SIGNET_PASSIVE_BUFFS,
+  FURY_CRIT_CHANCE, FURY_CRIT_CHANCE_WVW, BERSERK_CRIT_CHANCE, BERSERK_CRIT_CHANCE_WVW,
+  STACKING_SIGIL_DEFS, SIGNET_PASSIVE_BUFFS, SIGNET_ACTIVE_EFFECTS,
   BOON_NAMES, CONDITION_NAMES, CONDITION_NAME_NORMALIZE,
   BOON_DISPLAY_ORDER, ALL_STAT_KEYS, CONVERSION_TARGET_MAP,
 };

package/src/engine/modifiers.js

@@ -35,7 +35,10 @@ function collectActiveTraitIds(ctx, catalogs) {
       ? catalogs.specializationById.get(specId)
       : null;
     for (const minorId of specData?.minorTraits || []) {
-      if (minorId) ids.add(Number(minorId));
+      // minorTraits may be IDs (number) or enriched objects ({ id, name, ... })
+      // depending on whether the source is the GW2 API catalog or a serialized build.
+      const n = typeof minorId === "object" ? Number(minorId?.id) : Number(minorId);
+      if (n) ids.add(n);
     }
   }
 
@@ -57,6 +60,26 @@ function isFuryTrait(trait, traitId, overrides) {
   return trait.facts?.some((f) => f.type === "Buff" && f.status === "Fury") || false;
 }
 
+/**
+ * Return the set of weapon type strings for the active weapon set.
+ */
+function _activeWeaponTypes(ctx) {
+  const weapons = ctx?.equipment?.weapons || {};
+  const underwater = Boolean(ctx?.underwaterMode);
+  const set = Number(ctx?.activeWeaponSet) || 1;
+  const types = new Set();
+  if (underwater) {
+    const key = `aquatic${set}`;
+    if (weapons[key]) types.add(weapons[key]);
+  } else {
+    for (const prefix of ["mainhand", "offhand"]) {
+      const key = `${prefix}${set}`;
+      if (weapons[key]) types.add(weapons[key]);
+    }
+  }
+  return types;
+}
+
 /**
  * Collect typed modifier objects from active traits.
  *
@@ -77,6 +100,7 @@ function collectModifiers(ctx, catalogs, overrides) {
   if (!catalogs?.traitById) return modifiers;
 
   const gameMode = ctx?.gameMode || "pve";
+  const activeWeaponTypes = _activeWeaponTypes(ctx);
   const activeTraitIds = collectActiveTraitIds(ctx, catalogs);
   if (!activeTraitIds.size) return modifiers;
 
@@ -123,22 +147,30 @@ function collectModifiers(ctx, catalogs, overrides) {
       : fury ? "fury" : null;
 
     // 4. AttributeAdjust facts — flatBonus
-    const byTarget = new Map();
-    for (const fact of modeFacts) {
-      if (fact.type !== "AttributeAdjust" || !fact.target || fact.value == null) continue;
-      if (!byTarget.has(fact.target)) byTarget.set(fact.target, []);
-      byTarget.get(fact.target).push(fact.value);
-    }
-    for (const [target, values] of byTarget) {
-      const statKey = CONVERSION_TARGET_MAP[target] || target;
-      const idx = gameMode === "wvw" ? Math.min(1, values.length - 1) : 0;
-      modifiers.push({
-        source,
-        type: "flatBonus",
-        target: statKey,
-        value: values[idx],
-        condition,
-      });
+    //    Skip for traits with mightOverride (the bonus is folded into per-stack values)
+    if (!override?.mightOverride) {
+      const byTarget = new Map();
+      for (const fact of modeFacts) {
+        if (fact.type !== "AttributeAdjust" || !fact.target || fact.value == null) continue;
+        if (!byTarget.has(fact.target)) byTarget.set(fact.target, []);
+        byTarget.get(fact.target).push(fact.value);
+      }
+      // weaponConditional: multiply flat bonuses when an active weapon matches
+      const wc = override?.weaponConditional;
+      const weaponMatch = wc && wc.weapons?.some((w) => activeWeaponTypes.has(w));
+
+      for (const [target, values] of byTarget) {
+        const statKey = CONVERSION_TARGET_MAP[target] || target;
+        const idx = gameMode === "wvw" ? Math.min(1, values.length - 1) : 0;
+        const base = values[idx];
+        modifiers.push({
+          source,
+          type: "flatBonus",
+          target: statKey,
+          value: weaponMatch ? base * wc.multiplier : base,
+          condition,
+        });
+      }
     }
 
     // 5. BuffConversion / AttributeConversion facts — conversion
@@ -166,18 +198,22 @@ function collectModifiers(ctx, catalogs, overrides) {
       });
     }
 
-    // 6. Fury traits with "Critical Chance Increase" Percent facts — critChance
-    if (fury) {
+    // 6. "Critical Chance Increase" Percent facts — critChance
+    //    Fury traits: condition = "fury" (applied only when fury is assumed)
+    //    Berserk traits: condition = "berserk" (applied only when berserk is active)
+    //    Non-fury/non-berserk traits: condition = null (passive, always active)
+    //    Skip traits with ignoreCritChance (skill-specific crit like Opening Strike, stealth, bursts)
+    if (!override?.ignoreCritChance) {
       const critFacts = modeFacts.filter(
         (f) => f.type === "Percent" && f.text === "Critical Chance Increase" && f.percent
       );
-      if (critFacts.length > 0) {
+      if (critFacts.length > 0 && (fury || condition === null || condition === "berserk")) {
         const idx = gameMode === "wvw" ? Math.min(1, critFacts.length - 1) : 0;
         modifiers.push({
           source,
           type: "critChance",
           value: critFacts[idx].percent,
-          condition: "fury",
+          condition,
         });
       }
     }

package/src/index.js

@@ -9,6 +9,7 @@ const {
   mapWikiFactToApiFact,
   parseInfoboxParams,
 } = require("./wiki/parser");
+const { parseFactsByMode, groupFactsByMode } = require("./wiki/resolver");
 const { parseRelatedItems, parseRelatedGroups } = require("./wiki/relations");
 const { mergeFacts } = require("./facts/merge");
 const { buildMatchTables, valueChanged, VALUE_KEYS } = require("./facts/match");
@@ -34,6 +35,10 @@ module.exports = {
   mapWikiFactToApiFact,
   parseInfoboxParams,
 
+  // Resolver (mode-split: PvE/WvW/PvP facts the GW2 API lacks)
+  parseFactsByMode,
+  groupFactsByMode,
+
   // Relations
   parseRelatedItems,
   parseRelatedGroups,

package/src/wiki/parser.js

@@ -11,7 +11,11 @@ const WIKI_ATTR_MAP = {
   "Critical Damage": "CritDamage",
 };
 function normalizeAttr(name) {
-  return WIKI_ATTR_MAP[name] || name;
+  if (!name) return name;
+  // Wiki templates inconsistently use lowercase ("power") or capitalized ("Power")
+  // attribute names. Title-case before lookup so both forms produce the API stat key.
+  const titleCased = name.replace(/\b\w/g, (c) => c.toUpperCase());
+  return WIKI_ATTR_MAP[titleCased] || titleCased;
 }
 
 // Fact types to silently ignore
@@ -61,14 +65,14 @@ const BOONS = new Set([
 
 const CONDITIONS = new Set([
   "bleeding",
-  "blind",
+  "blind", "blinded",
   "burning",
-  "chilled",
+  "chill", "chilled",
   "confusion",
-  "crippled",
+  "cripple", "crippled",
   "fear",
-  "immobilize",
-  "poison",
+  "immobilize", "immobilized",
+  "poison", "poisoned",
   "slow",
   "taunt",
   "torment",
@@ -199,9 +203,13 @@ function mapWikiFactToApiFact(factType, positional, params, isWvw, isUniversal)
     const rawCoefficient = params.coefficient || positional[0] || "0";
     const coefficient = parseFloat(stripWikiMarkup(rawCoefficient));
     const hits = parseInt(stripWikiMarkup(params.hits) || "1", 10);
+    // `alt=` carries the conditional damage label (e.g. "Damage to Controlled Foes").
+    // Without this, the conditional variant collapses with the base "Damage" fact
+    // during dedup, hiding bonus-damage values from the tooltip.
+    const label = params.alt ? stripWikiMarkup(params.alt).trim() : "Damage";
     return {
       type: "Damage",
-      text: "Damage",
+      text: label,
       dmg_multiplier: coefficient,
       hit_count: hits,
     };
@@ -392,13 +400,13 @@ function mapWikiFactToApiFact(factType, positional, params, isWvw, isUniversal)
   // Many wiki fact types carry a percentage value (e.g. "damage reduction|33").
   // Without this, they fall through to generic Number and lose the % suffix.
   if (PERCENT_TYPES.has(type)) {
-    const label = type.replace(/\b\w/g, (c) => c.toUpperCase());
+    const label = params.alt ? stripWikiMarkup(params.alt).trim() : type.replace(/\b\w/g, (c) => c.toUpperCase());
     return { type: "Percent", text: label, percent: pos0Num() };
   }
 
   // ── Unknown but has a numeric value ────────────────────────────────
   if (positional[0] && !isNaN(parseFloat(stripWikiMarkup(positional[0])))) {
-    const label = type.replace(/\b\w/g, (c) => c.toUpperCase());
+    const label = params.alt ? stripWikiMarkup(params.alt).trim() : type.replace(/\b\w/g, (c) => c.toUpperCase());
     // Heuristic: fact type names containing "increase", "reduction", "chance",
     // or "rate" are almost always percentages in GW2 wiki templates.
     if (/(?:increase|reduction|chance|rate|cost|drain)$/.test(type)) {