@axiapps/gw2-data 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,156 @@
+# @axiapps/gw2-data
+
+Data library for Guild Wars 2 — wiki scraping, GW2 API access, and stat computation engine. Used by [AxiForge](https://axiforge.com).
+
+## Installation
+
+```bash
+npm install @axiapps/gw2-data
+```
+
+## Modules
+
+The package exposes four subpath imports:
+
+| Import | Description |
+|--------|-------------|
+| `@axiapps/gw2-data/wiki` | Wiki scraping and wikitext parsing |
+| `@axiapps/gw2-data/api` | GW2 API client with batching and retries |
+| `@axiapps/gw2-data/facts` | Fact merging for PvE/WvW balance splits |
+| `@axiapps/gw2-data/engine` | Stat computation, tooltips, boon analysis |
+
+## Wiki Client
+
+Fetch and parse skill/trait data from the GW2 Wiki with built-in caching and rate limiting.
+
+```js
+const { WikiClient } = require("@axiapps/gw2-data/wiki");
+
+const wiki = new WikiClient();
+
+// Fetch wikitext for a single page
+const wikitext = await wiki.getWikitext("Fireball");
+
+// Batch-fetch multiple pages (up to 50 per request)
+const pages = await wiki.getWikitextBatch(["Fireball", "Meteor Shower", "Lava Font"]);
+
+// Parse skill/trait facts from wikitext
+const { facts, hasPveOnly, splitGrouping } = wiki.parseFacts(wikitext);
+
+// Search for pages by prefix
+const matches = await wiki.prefixSearch("Fire", 10);
+
+// Invalidate cache for recently changed pages
+const changed = await wiki.refresh();
+```
+
+### Constructor Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `cache` | `MemoryCache` | Cache adapter (MemoryCache or DiskCache) |
+| `fetch` | `globalThis.fetch` | Fetch implementation |
+| `wikiApiRoot` | `https://wiki.guildwars2.com/api.php` | Wiki API endpoint |
+| `cacheTTL` | 4 hours | Cache TTL in milliseconds |
+
+## GW2 API Client
+
+Fetch data from the official GW2 API with automatic chunking, retries, and 429 handling.
+
+```js
+const { Gw2ApiClient } = require("@axiapps/gw2-data/api");
+
+const api = new Gw2ApiClient();
+
+// Fetch skills by ID (automatically chunked into 180-ID batches)
+const skills = await api.fetchByIds("/v2/skills", [5489, 5536, 5501]);
+
+// Fetch with caching
+const data = await api.fetchCached("my-key", "https://api.guildwars2.com/v2/skills/5489", 3600000);
+```
+
+### Constructor Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `cache` | `MemoryCache` | Cache adapter |
+| `fetch` | `globalThis.fetch` | Fetch implementation |
+| `apiRoot` | `https://api.guildwars2.com` | API root URL |
+| `lang` | `"en"` | Language code |
+
+## Fact Merging
+
+Merge base (PvE) facts with WvW/PvP split facts, marking which values changed.
+
+```js
+const { mergeFacts } = require("@axiapps/gw2-data/facts");
+
+const merged = mergeFacts(baseFacts, splitFacts);
+// Changed facts have _splitFact: true
+// New facts (WvW-only) have _newFact: true
+```
+
+## Engine
+
+Compute final build stats, skill tooltips, boon uptime, and combo interactions.
+
+```js
+const {
+  computeAttributes,
+  collectModifiers,
+  computeTooltip,
+  analyzeBoons,
+  analyzeCombos,
+  STAT_COMBOS_BY_LABEL,
+} = require("@axiapps/gw2-data/engine");
+
+// Compute final attributes for a build
+const attrs = computeAttributes({
+  profession: "Elementalist",
+  specializations: [...],
+  equipment: { statPackage: "Berserker" },
+}, catalogs);
+
+// Collect all stat modifiers from traits, sigils, etc.
+const modifiers = collectModifiers(ctx, catalogs, overrides);
+
+// Compute a skill tooltip with modifiers applied
+const tooltip = computeTooltip(attrs, skill, "Staff", modifiers);
+
+// Analyze boon output across a skill set
+const boons = analyzeBoons(skills, traits, overrides);
+
+// Detect combo field/finisher interactions
+const combos = analyzeCombos(skills, traits);
+```
+
+### StatEngine Class
+
+For repeated computations, use the class to avoid re-loading overrides:
+
+```js
+const { StatEngine } = require("@axiapps/gw2-data/engine");
+
+const engine = new StatEngine(catalogs);
+const attrs = engine.computeAttributes(ctx);
+const tooltip = engine.computeTooltip(ctx, skill, "Sword");
+const boons = engine.analyzeBoons(skills, traits);
+```
+
+## Caching
+
+Both clients accept a cache adapter. Two are included:
+
+```js
+const { MemoryCache, DiskCache } = require("@axiapps/gw2-data/wiki");
+
+// In-memory (default)
+const wiki = new WikiClient({ cache: new MemoryCache() });
+
+// Disk-backed (persists across restarts)
+const wiki = new WikiClient({ cache: new DiskCache("/tmp/gw2-wiki-cache") });
+```
+
+## License
+
+MIT

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,6 +1,6 @@
 {
   "name": "@axiapps/gw2-data",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "GW2 data library — wiki-sourced facts, GW2 API structural data, and stat computation",
   "main": "src/index.js",
   "exports": {
@@ -19,6 +19,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,
         });
       }
     }