@axiapps/gw2-data 0.1.0

package/tests/engine/modifiers.test.js

@@ -0,0 +1,473 @@
+"use strict";
+
+const { collectActiveTraitIds, isFuryTrait, collectModifiers } = require("../../src/engine/modifiers");
+
+// ---------------------------------------------------------------------------
+// Helpers — build minimal catalog and context objects for tests
+// ---------------------------------------------------------------------------
+
+function makeCtx(specs = [], gameMode = "pve") {
+  return { specializations: specs, gameMode };
+}
+
+function makeCatalogs(traitMap = {}, specMap = {}) {
+  return {
+    traitById: new Map(Object.entries(traitMap).map(([k, v]) => [Number(k), v])),
+    specializationById: new Map(Object.entries(specMap).map(([k, v]) => [Number(k), v])),
+  };
+}
+
+function makeOverrides(entries = {}) {
+  return new Map(Object.entries(entries));
+}
+
+// ---------------------------------------------------------------------------
+// collectActiveTraitIds
+// ---------------------------------------------------------------------------
+
+describe("collectActiveTraitIds()", () => {
+  it("collects major trait choices", () => {
+    const ctx = makeCtx([
+      { id: 4, majorChoices: { 1: 1444, 2: 1449, 3: 1437 } },
+    ]);
+    const catalogs = makeCatalogs({}, {});
+    const ids = collectActiveTraitIds(ctx, catalogs);
+    expect(ids).toContain(1444);
+    expect(ids).toContain(1449);
+    expect(ids).toContain(1437);
+    expect(ids.size).toBe(3);
+  });
+
+  it("collects minor traits from spec data", () => {
+    const ctx = makeCtx([{ id: 4, majorChoices: {} }]);
+    const catalogs = makeCatalogs({}, { 4: { minorTraits: [100, 200, 300] } });
+    const ids = collectActiveTraitIds(ctx, catalogs);
+    expect(ids).toContain(100);
+    expect(ids).toContain(200);
+    expect(ids).toContain(300);
+  });
+
+  it("supports specializationId key (editor format)", () => {
+    const ctx = makeCtx([{ specializationId: 5, majorChoices: { 1: 555 } }]);
+    const catalogs = makeCatalogs({}, { 5: { minorTraits: [999] } });
+    const ids = collectActiveTraitIds(ctx, catalogs);
+    expect(ids).toContain(555);
+    expect(ids).toContain(999);
+  });
+
+  it("returns empty set with no specializations", () => {
+    const ids = collectActiveTraitIds(makeCtx([]), makeCatalogs());
+    expect(ids.size).toBe(0);
+  });
+
+  it("returns empty set when ctx.specializations is missing", () => {
+    const ids = collectActiveTraitIds({}, makeCatalogs());
+    expect(ids.size).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isFuryTrait
+// ---------------------------------------------------------------------------
+
+describe("isFuryTrait()", () => {
+  it("returns true for a trait with a Buff(Fury) fact", () => {
+    const trait = {
+      facts: [
+        { type: "Buff", status: "Fury" },
+        { type: "AttributeAdjust", target: "Ferocity", value: 150 },
+      ],
+    };
+    expect(isFuryTrait(trait, 9999, makeOverrides())).toBe(true);
+  });
+
+  it("returns true for the implicit fury trait (1719) via overrides", () => {
+    const overrides = makeOverrides({ "trait:1719": { implicitFury: true } });
+    const trait = { facts: [] }; // no Buff(Fury) fact
+    expect(isFuryTrait(trait, 1719, overrides)).toBe(true);
+  });
+
+  it("returns false for a non-fury trait", () => {
+    const trait = {
+      facts: [{ type: "AttributeAdjust", target: "Power", value: 120 }],
+    };
+    expect(isFuryTrait(trait, 1234, makeOverrides())).toBe(false);
+  });
+
+  it("returns false when facts array is empty", () => {
+    expect(isFuryTrait({ facts: [] }, 1234, makeOverrides())).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// collectModifiers
+// ---------------------------------------------------------------------------
+
+describe("collectModifiers()", () => {
+  it("collects flatBonus from AttributeAdjust facts", () => {
+    const traitId = 1001;
+    const trait = {
+      slot: "Major",
+      description: "Some trait",
+      facts: [
+        { type: "AttributeAdjust", target: "Power", value: 120 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const flatMods = mods.filter((m) => m.type === "flatBonus");
+    expect(flatMods).toHaveLength(1);
+    expect(flatMods[0]).toMatchObject({
+      source: `trait:${traitId}`,
+      type: "flatBonus",
+      target: "Power",
+      value: 120,
+      condition: null,
+    });
+  });
+
+  it("classifies fury-gated bonuses with condition: 'fury'", () => {
+    const traitId = 1002;
+    const trait = {
+      slot: "Major",
+      description: "Fury trait",
+      facts: [
+        { type: "Buff", status: "Fury" },
+        { type: "AttributeAdjust", target: "Ferocity", value: 180 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const flatMods = mods.filter((m) => m.type === "flatBonus");
+    expect(flatMods).toHaveLength(1);
+    expect(flatMods[0].condition).toBe("fury");
+    expect(flatMods[0].target).toBe("Ferocity");
+  });
+
+  it("excludes pet stat traits (trait 1016 via overrides)", () => {
+    const traitId = 1016;
+    const trait = {
+      slot: "Major",
+      description: "Pet trait",
+      facts: [
+        { type: "AttributeAdjust", target: "Power", value: 300 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+    const overrides = makeOverrides({ "trait:1016": { petStatOnly: true } });
+
+    const mods = collectModifiers(ctx, catalogs, overrides);
+    expect(mods).toHaveLength(0);
+  });
+
+  it("collects conversion from BuffConversion facts", () => {
+    const traitId = 1003;
+    const trait = {
+      slot: "Major",
+      description: "Conversion trait",
+      facts: [
+        { type: "BuffConversion", source: "Toughness", target: "Power", percent: 10 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const convMods = mods.filter((m) => m.type === "conversion");
+    expect(convMods).toHaveLength(1);
+    expect(convMods[0]).toMatchObject({
+      source: `trait:${traitId}`,
+      type: "conversion",
+      sourceAttr: "Toughness",
+      target: "Power",
+      percent: 10,
+      condition: null,
+    });
+  });
+
+  it("normalizes BoonDuration target via CONVERSION_TARGET_MAP", () => {
+    const traitId = 1004;
+    const trait = {
+      slot: "Major",
+      description: "Boon duration trait",
+      facts: [
+        { type: "BuffConversion", source: "Vitality", target: "BoonDuration", percent: 15 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const convMods = mods.filter((m) => m.type === "conversion");
+    expect(convMods[0].target).toBe("Concentration");
+  });
+
+  it("collects critChance from Percent fact on fury trait", () => {
+    const traitId = 1005;
+    const trait = {
+      slot: "Major",
+      description: "Crit chance while furious",
+      facts: [
+        { type: "Buff", status: "Fury" },
+        { type: "Percent", text: "Critical Chance Increase", percent: 10 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const critMods = mods.filter((m) => m.type === "critChance");
+    expect(critMods).toHaveLength(1);
+    expect(critMods[0]).toMatchObject({
+      source: `trait:${traitId}`,
+      type: "critChance",
+      value: 10,
+      condition: "fury",
+    });
+  });
+
+  it("collects mightModifier from overrides (trait 1765)", () => {
+    const traitId = 1765;
+    const trait = {
+      slot: "Major",
+      description: "Notoriety",
+      facts: [],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+    const overrides = makeOverrides({
+      "trait:1765": { mightOverride: { power: 40, condi: 20 } },
+    });
+
+    const mods = collectModifiers(ctx, catalogs, overrides);
+    const mightMods = mods.filter((m) => m.type === "mightModifier");
+    expect(mightMods).toHaveLength(1);
+    expect(mightMods[0]).toMatchObject({
+      source: `trait:${traitId}`,
+      type: "mightModifier",
+      power: 40,
+      condi: 20,
+      condition: null,
+    });
+  });
+
+  it("handles WvW game mode indexing (uses second fact value)", () => {
+    const traitId = 1006;
+    const trait = {
+      slot: "Major",
+      description: "WvW trait",
+      facts: [
+        // Two AttributeAdjust facts for same target: [0]=PvE, [1]=WvW
+        { type: "AttributeAdjust", target: "Power", value: 150 },
+        { type: "AttributeAdjust", target: "Power", value: 100 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctxWvw = makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "wvw");
+
+    const mods = collectModifiers(ctxWvw, catalogs, makeOverrides());
+    const flatMods = mods.filter((m) => m.type === "flatBonus" && m.target === "Power");
+    expect(flatMods).toHaveLength(1);
+    expect(flatMods[0].value).toBe(100); // WvW value (index 1)
+  });
+
+  it("uses PvE value (index 0) by default", () => {
+    const traitId = 1007;
+    const trait = {
+      slot: "Major",
+      description: "PvE trait",
+      facts: [
+        { type: "AttributeAdjust", target: "Precision", value: 200 },
+        { type: "AttributeAdjust", target: "Precision", value: 150 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "pve");
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const flatMods = mods.filter((m) => m.type === "flatBonus" && m.target === "Precision");
+    expect(flatMods[0].value).toBe(200);
+  });
+
+  it("does not collect burstRecharge from Primal Rage (no recharge reduction)", () => {
+    const traitId = 1831;
+    const trait = { slot: "Major", description: "Primal Rage", facts: [] };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+    const overrides = makeOverrides({ "trait:1831": { description: "no burst recharge" } });
+
+    const mods = collectModifiers(ctx, catalogs, overrides);
+    const burstMods = mods.filter((m) => m.type === "burstRecharge");
+    expect(burstMods).toHaveLength(0);
+  });
+
+  it("collects burstRecharge from minor trait with Recharge Reduced Percent fact", () => {
+    const traitId = 2001;
+    const trait = {
+      slot: "Minor",
+      description: "Reduces burst skill recharge",
+      facts: [
+        { type: "Percent", text: "Recharge Reduced", percent: 20 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const burstMods = mods.filter((m) => m.type === "burstRecharge");
+    expect(burstMods).toHaveLength(1);
+    expect(burstMods[0].value).toBe(20);
+  });
+
+  it("returns empty array when no active traits", () => {
+    const catalogs = makeCatalogs({});
+    const ctx = makeCtx([]);
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    expect(mods).toEqual([]);
+  });
+
+  it("returns empty array when catalogs.traitById is missing", () => {
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: 999 } }]);
+    const mods = collectModifiers(ctx, {}, makeOverrides());
+    expect(mods).toEqual([]);
+  });
+
+  // Blood Reaction bug: GW2 API returns multiple BuffConversion facts for
+  // same source→target pair with different percentages (PvE/WvW variants).
+  // Only the first (PvE) or second (WvW) should be used — not all summed.
+  it("marks berserkConditional override traits with condition: 'berserk'", () => {
+    const traitId = 2046;
+    const trait = {
+      slot: "Minor",
+      description: "Fatal Frenzy",
+      facts: [
+        { type: "AttributeAdjust", target: "Power", value: 150 },
+        { type: "AttributeAdjust", target: "ConditionDamage", value: 300 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }]);
+    const overrides = makeOverrides({ "trait:2046": { berserkConditional: true } });
+
+    const mods = collectModifiers(ctx, catalogs, overrides);
+    const flatMods = mods.filter((m) => m.type === "flatBonus");
+    expect(flatMods).toHaveLength(2);
+    expect(flatMods[0].condition).toBe("berserk");
+    expect(flatMods[1].condition).toBe("berserk");
+  });
+
+  it("uses wvwFacts for flatBonus when gameMode is wvw and wvwFacts exists", () => {
+    const traitId = 2046;
+    const trait = {
+      slot: "Minor",
+      description: "Fatal Frenzy",
+      facts: [
+        { type: "AttributeAdjust", target: "Power", value: 300 },
+        { type: "AttributeAdjust", target: "ConditionDamage", value: 300 },
+      ],
+      wvwFacts: [
+        { type: "AttributeAdjust", target: "Power", value: 150 },
+        { type: "AttributeAdjust", target: "ConditionDamage", value: 300 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const overrides = makeOverrides({ "trait:2046": { berserkConditional: true } });
+
+    const wvwMods = collectModifiers(
+      makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "wvw"),
+      catalogs, overrides
+    );
+    const wvwFlat = wvwMods.filter((m) => m.type === "flatBonus");
+    expect(wvwFlat).toHaveLength(2);
+    const powerMod = wvwFlat.find((m) => m.target === "Power");
+    const condiMod = wvwFlat.find((m) => m.target === "ConditionDamage");
+    expect(powerMod.value).toBe(150);
+    expect(condiMod.value).toBe(300);
+
+    // PvE should still use trait.facts
+    const pveMods = collectModifiers(
+      makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "pve"),
+      catalogs, overrides
+    );
+    const pveFlat = pveMods.filter((m) => m.type === "flatBonus");
+    const pvePower = pveFlat.find((m) => m.target === "Power");
+    expect(pvePower.value).toBe(300);
+  });
+
+  it("uses wvwFacts for conversions when gameMode is wvw and wvwFacts exists", () => {
+    const traitId = 2011;
+    const trait = {
+      slot: "Major",
+      description: "Blood Reaction",
+      facts: [
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 12 },
+        { type: "BuffConversion", source: "Power", target: "ConditionDamage", percent: 15 },
+      ],
+      wvwFacts: [
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 5 },
+        { type: "BuffConversion", source: "Power", target: "ConditionDamage", percent: 10 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+
+    const wvwMods = collectModifiers(
+      makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "wvw"),
+      catalogs, makeOverrides()
+    );
+    const convMods = wvwMods.filter((m) => m.type === "conversion");
+    expect(convMods).toHaveLength(2);
+    expect(convMods.find((m) => m.target === "Ferocity").percent).toBe(5);
+    expect(convMods.find((m) => m.target === "ConditionDamage").percent).toBe(10);
+  });
+
+  it("deduplicates BuffConversion facts by source+target (PvE picks first)", () => {
+    const traitId = 2011;
+    const trait = {
+      slot: "Major",
+      description: "Blood Reaction",
+      facts: [
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 12 },
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 10 },
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 5 },
+        { type: "BuffConversion", source: "Power", target: "ConditionDamage", percent: 10 },
+        { type: "BuffConversion", source: "Power", target: "ConditionDamage", percent: 15 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "pve");
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const convMods = mods.filter((m) => m.type === "conversion");
+    expect(convMods).toHaveLength(2);
+    expect(convMods[0]).toMatchObject({ sourceAttr: "Precision", target: "Ferocity", percent: 12 });
+    expect(convMods[1]).toMatchObject({ sourceAttr: "Power", target: "ConditionDamage", percent: 10 });
+  });
+
+  it("deduplicates BuffConversion facts by source+target (WvW picks second)", () => {
+    const traitId = 2011;
+    const trait = {
+      slot: "Major",
+      description: "Blood Reaction",
+      facts: [
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 12 },
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 10 },
+        { type: "BuffConversion", source: "Precision", target: "CritDamage", percent: 5 },
+        { type: "BuffConversion", source: "Power", target: "ConditionDamage", percent: 10 },
+        { type: "BuffConversion", source: "Power", target: "ConditionDamage", percent: 15 },
+      ],
+    };
+    const catalogs = makeCatalogs({ [traitId]: trait });
+    const ctx = makeCtx([{ id: 1, majorChoices: { 1: traitId } }], "wvw");
+
+    const mods = collectModifiers(ctx, catalogs, makeOverrides());
+    const convMods = mods.filter((m) => m.type === "conversion");
+    expect(convMods).toHaveLength(2);
+    expect(convMods[0]).toMatchObject({ sourceAttr: "Precision", target: "Ferocity", percent: 10 });
+    expect(convMods[1]).toMatchObject({ sourceAttr: "Power", target: "ConditionDamage", percent: 15 });
+  });
+});

package/tests/engine/overrides.test.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const { loadOverrides, getOverride } = require("../../src/engine/overrides");
+
+describe("overrides module", () => {
+  let overrides;
+
+  beforeAll(() => {
+    overrides = loadOverrides();
+  });
+
+  describe("loadOverrides()", () => {
+    it("returns a Map", () => {
+      expect(overrides).toBeInstanceOf(Map);
+    });
+
+    it("contains exactly 6 entries", () => {
+      expect(overrides.size).toBe(6);
+    });
+
+    it("trait:1719 has implicitFury: true", () => {
+      const entry = overrides.get("trait:1719");
+      expect(entry).toBeDefined();
+      expect(entry.implicitFury).toBe(true);
+    });
+
+    it("trait:1016 has petStatOnly: true", () => {
+      const entry = overrides.get("trait:1016");
+      expect(entry).toBeDefined();
+      expect(entry.petStatOnly).toBe(true);
+    });
+
+    it("trait:1765 has mightOverride with power and condi", () => {
+      const entry = overrides.get("trait:1765");
+      expect(entry).toBeDefined();
+      expect(entry.mightOverride).toEqual({ power: 40, condi: 20 });
+    });
+
+    it("trait:2220 has allyTargeted array containing 'elixir'", () => {
+      const entry = overrides.get("trait:2220");
+      expect(entry).toBeDefined();
+      expect(Array.isArray(entry.allyTargeted)).toBe(true);
+      expect(entry.allyTargeted).toContain("elixir");
+    });
+
+    it("trait:1831 has no burstRechargeReduction (Primal Rage only grants Primal Bursts)", () => {
+      const entry = overrides.get("trait:1831");
+      expect(entry).toBeDefined();
+      expect(entry.burstRechargeReduction).toBeUndefined();
+    });
+  });
+
+  describe("getOverride()", () => {
+    it("returns the entry for a known trait key", () => {
+      const result = getOverride(overrides, "trait:1719");
+      expect(result).not.toBeNull();
+      expect(result.implicitFury).toBe(true);
+    });
+
+    it("returns null for an unknown key", () => {
+      const result = getOverride(overrides, "trait:9999");
+      expect(result).toBeNull();
+    });
+
+    it("returns null for an empty string key", () => {
+      const result = getOverride(overrides, "");
+      expect(result).toBeNull();
+    });
+  });
+});

package/tests/engine/snapshot.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { computeAttributes } = require("../../src/engine/attributes");
+const { hydrateCatalogs } = require("./test-utils");
+
+const FIXTURE_DIR = path.join(__dirname, "fixtures");
+
+const fixtureFiles = fs.readdirSync(FIXTURE_DIR).filter((f) => f.endsWith(".json"));
+
+describe("snapshot fixtures", () => {
+  for (const file of fixtureFiles) {
+    const fixture = JSON.parse(fs.readFileSync(path.join(FIXTURE_DIR, file), "utf-8"));
+
+    describe(fixture.name, () => {
+      let result;
+
+      beforeAll(() => {
+        const catalogs = hydrateCatalogs(fixture.catalogs);
+        result = computeAttributes(fixture.ctx, catalogs);
+      });
+
+      test("total stats match expected", () => {
+        expect(result.total).toEqual(fixture.expected.total);
+      });
+
+      test("derived health matches", () => {
+        expect(result.derived.health).toBe(fixture.expected.derived.health);
+      });
+
+      test("derived critChance matches", () => {
+        expect(result.derived.critChance).toBeCloseTo(fixture.expected.derived.critChance, 1);
+      });
+
+      test("derived critDamage matches", () => {
+        expect(result.derived.critDamage).toBeCloseTo(fixture.expected.derived.critDamage, 1);
+      });
+
+      test("derived armor matches", () => {
+        expect(result.derived.armor).toBe(fixture.expected.derived.armor);
+      });
+
+      test("derived conditionDuration matches", () => {
+        expect(result.derived.conditionDuration).toBeCloseTo(fixture.expected.derived.conditionDuration, 1);
+      });
+
+      test("derived boonDuration matches", () => {
+        expect(result.derived.boonDuration).toBeCloseTo(fixture.expected.derived.boonDuration, 1);
+      });
+    });
+  }
+});

package/tests/engine/test-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+
+/**
+ * Hydrates raw JSON catalog data (arrays) into the Map-based shape
+ * expected by the engine's computeAttributes function.
+ */
+function hydrateCatalogs(raw) {
+  return {
+    traitById: new Map((raw.traits || []).map((t) => [t.id, t])),
+    skillById: new Map((raw.skills || []).map((s) => [s.id, s])),
+    specializationById: new Map((raw.specializations || []).map((s) => [s.id, s])),
+    runeById: new Map((raw.runes || []).map((r) => [r.id, r])),
+    foodById: new Map((raw.foods || []).map((f) => [f.id, f])),
+    utilityById: new Map((raw.utilities || []).map((u) => [u.id, u])),
+    infusionById: new Map((raw.infusions || []).map((i) => [i.id, i])),
+    enrichmentById: new Map((raw.enrichments || []).map((e) => [e.id, e])),
+  };
+}
+
+module.exports = { hydrateCatalogs };

package/tests/engine/tooltips.test.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { computeTooltip } = require("../../src/engine/tooltips");
+const { WEAPON_STRENGTH_MIDPOINT } = require("../../src/engine/constants");
+
+describe("computeTooltip", () => {
+  const baseAttrs = {
+    total: { Power: 3000, Precision: 2000, Ferocity: 900 },
+    derived: { critChance: 57.6, critDamage: 210.0 },
+  };
+
+  test("computes damage from coefficient and weapon strength", () => {
+    const skill = {
+      id: 5489, name: "Fireball",
+      facts: [{ type: "Damage", dmg_multiplier: 0.75, hit_count: 1 }],
+    };
+    const result = computeTooltip(baseAttrs, skill, "staff", []);
+    expect(result.coefficient).toBe(0.75);
+    expect(result.hits).toBe(1);
+    expect(result.weaponStrength).toBe(WEAPON_STRENGTH_MIDPOINT.staff);
+    expect(result.damage).toBeGreaterThan(0);
+  });
+
+  test("multi-hit skill multiplies by hit count", () => {
+    const skill = {
+      id: 100, name: "Multi",
+      facts: [{ type: "Damage", dmg_multiplier: 0.5, hit_count: 3 }],
+    };
+    const result = computeTooltip(baseAttrs, skill, "sword", []);
+    expect(result.hits).toBe(3);
+    expect(result.totalDamage).toBe(result.damage * 3);
+  });
+
+  test("applies damage multiplier modifiers", () => {
+    const skill = {
+      id: 101, name: "Big Hit",
+      facts: [{ type: "Damage", dmg_multiplier: 1.0, hit_count: 1 }],
+    };
+    const mods = [{ source: "trait:500", type: "damageMultiplier", value: 10, condition: null }];
+    const withMods = computeTooltip(baseAttrs, skill, "greatsword", mods);
+    const withoutMods = computeTooltip(baseAttrs, skill, "greatsword", []);
+    expect(withMods.damage).toBeGreaterThan(withoutMods.damage);
+  });
+
+  test("returns null for skill with no Damage fact", () => {
+    const skill = { id: 102, name: "Heal", facts: [{ type: "AttributeAdjust" }] };
+    const result = computeTooltip(baseAttrs, skill, "staff", []);
+    expect(result).toBeNull();
+  });
+
+  test("uses correct weapon strength for weapon type", () => {
+    const skill = {
+      id: 103, name: "Shot",
+      facts: [{ type: "Damage", dmg_multiplier: 1.0, hit_count: 1 }],
+    };
+    const rifle = computeTooltip(baseAttrs, skill, "rifle", []);
+    const dagger = computeTooltip(baseAttrs, skill, "dagger", []);
+    expect(rifle.weaponStrength).toBe(1095.5);
+    expect(dagger.weaponStrength).toBe(952.5);
+    expect(rifle.damage).toBeGreaterThan(dagger.damage);
+  });
+});