uesp-eso-build-wrapper 0.2.0 → 0.4.0

package/dist/lib/eso-engine/calculator.js

@@ -1,32 +1,33 @@
-"use strict";
 /**
- * Motor de cálculo de builds do ESO.
+ * ESO build calculation engine.
  *
- * Implementa a ideia central da arquitetura:
+ * Implements the core architecture idea:
  *
- *   1. Injetar dados do personagem nos elementos mock do DOM
- *      (jQuery vai ler via $("#esotbRace").val(), etc.)
+ *   1. Inject character data into the mock DOM elements
+ *      (jQuery will read via $("#esotbRace").val(), etc.)
  *
- *   2. Injetar dados dos itens DIRETAMENTE em g_EsoBuildItemData[slot]
- *      — sem precisar mockar jQuery para cada campo de item.
- *      Os campos vêm exatamente no formato da API pública da UESP:
+ *   2. Inject item data DIRECTLY into g_EsoBuildItemData[slot]
+ *      — no need to mock jQuery for each item field.
+ *      Fields come exactly in the UESP public API format:
  *      GET https://esolog.uesp.net/exportJson.php?table=minedItem&id=<id>&level=<lv>&quality=<q>
  *
- *   3. Chamar UpdateEsoComputedStatsList_Real(null, true)
- *      — o parâmetro `noUpdate=true` faz o motor calcular tudo mas pular
- *      as atualizações de DOM (DisplayEsoAllComputedStats, UpdateReadOnlyStats, etc.)
+ *   3. Call UpdateEsoComputedStatsList_Real(null, true)
+ *      — the `noUpdate=true` parameter makes the engine compute everything but skip
+ *      the DOM updates (DisplayEsoAllComputedStats, UpdateReadOnlyStats, etc.)
  *
- *   4. Ler os resultados de g_EsoComputedStats[statId].value
+ *   4. Read the results from g_EsoComputedStats[statId].value
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBuild = calculateBuild;
-exports.listAvailableBuffs = listAvailableBuffs;
-exports.listRacialPassives = listRacialPassives;
-exports.listClassPassives = listClassPassives;
-exports.listPassivesBySkillLine = listPassivesBySkillLine;
-exports.listAvailableSkillLines = listAvailableSkillLines;
-exports.listAvailableToggleSkills = listAvailableToggleSkills;
-const env_setup_1 = require("./env-setup");
+import { resetDomValues, setDomAttr, setDomTextContent, setDomValue } from './env-setup.js';
+import { engineGlobals } from './engine-globals.js';
+// Stat object cache — populated once after initEsoEngineFromData.
+// Avoids Object.keys/values on every calculateBuild; ~200 objects.
+let _statObjects = null;
+export function cacheStatObjects() {
+    const stats = engineGlobals().g_EsoComputedStats;
+    if (stats && typeof stats === 'object') {
+        _statObjects = Object.values(stats);
+    }
+}
 const ALL_SLOTS = [
     'Head',
     'Shoulders',
@@ -48,9 +49,9 @@ const ALL_SLOTS = [
     'Potion',
 ];
 /**
- * Normaliza os dados de um item garantindo que todos os campos opcionais
- * existam com defaults seguros. Sem isso, o motor lança TypeError ao tentar
- * chamar .includes() em campos de set bonus undefined (setBonusDesc5..12).
+ * Normalizes an item's data ensuring all optional fields
+ * exist with safe defaults. Without this, the engine throws a TypeError when trying
+ * to call .includes() on undefined set bonus fields (setBonusDesc5..12).
  */
 function normalizeItemData(item) {
     const defaults = {};
@@ -61,102 +62,169 @@ function normalizeItemData(item) {
     return { ...defaults, ...item };
 }
 /**
- * Calcula os Computed Character Statistics para a build fornecida.
+ * Calculates the Computed Character Statistics for the given build.
+ *
+ * Each call starts from a clean engine state (previous items, buffs, CP nodes
+ * and skill bars are reset), so builds never bleed into each other.
+ *
+ * @param input - The build to calculate: character sheet, items, champion
+ *   point nodes, buffs, toggle skills, skill bars and passives.
+ * @returns All computed stats — named keys (Health, Magicka, SpellDamage, ...)
+ *   plus `raw` with the full 221-stat `g_EsoComputedStats` record.
+ * @throws If the engine has not been initialized with
+ *   `initEsoEngineFromData()` first.
  *
  * @example
  * ```ts
- * import { calculateBuild } from './src/lib/eso-engine';
+ * import { calculateBuild } from 'uesp-eso-build-wrapper';
  *
  * const stats = calculateBuild({
  *   character: { race: 'High Elf', class: 'Sorcerer', level: 50,
  *                attributes: { health: 0, magicka: 64, stamina: 0 } },
  *   items: {
- *     Chest: chestItemFromUespApi,  // objeto retornado por esolog.uesp.net/exportJson.php
+ *     Chest: chestItemFromUespApi,  // object returned by esolog.uesp.net/exportJson.php
  *   },
  * });
- * console.log(stats.MaxMagicka, stats.SpellDamage);
+ * console.log(stats.Magicka, stats.SpellDamage);
  * ```
  */
-function calculateBuild(input) {
+export function calculateBuild(input) {
+    const { character, items, championPointNodes, activeBuffs, toggleSkills, skillBars, activeWeaponBar, passiveSkills, autoPassives, enchantOverrides, toggledSetBonuses, } = input;
+    // ─── GLOBAL STATE RESET ───────────────────────────────────────────────────
+    // All resets in one place — makes leaks between calls easier to spot.
+    // g_EsoComputedStats: zero value/preCapValue before computing.
+    // In the browser they all start at 0 on every load; in the wrapper the object persists
+    // across calls and stats from a previous build contaminate the next one. The deferred loop
+    // (esoEditBuild.js:4397) copies g_EsoComputedStats[name].value back into
+    // inputValues[name] at each step j, so a leftover value corrupts early-computed
+    // stats (e.g. BashDamage). _statObjects is populated once at init,
+    // avoiding Object.keys on every call.
+    if (_statObjects) {
+        for (const stat of _statObjects) {
+            stat.value = 0;
+            stat.preCapValue = 0;
+        }
+    }
+    const g = engineGlobals();
+    const itemData = g.g_EsoBuildItemData;
+    const enchantData = g.g_EsoBuildEnchantData;
+    const buffData = g.g_EsoBuildBuffData;
+    const toggleSkillData = g.g_EsoBuildToggledSkillData;
+    const emptyBar = () => Array.from({ length: 6 }, (_, i) => ({
+        skillId: 0,
+        origSkillId: 0,
+        morphIndex: 0,
+        slotIndex: i,
+    }));
+    // Items and enchantments
+    for (const slot of ALL_SLOTS) {
+        itemData[slot] = {};
+        if (enchantData)
+            enchantData[slot] = {};
+    }
+    // Champion Points
+    g.g_EsoCpData = {};
+    // Buffs: zero activation flags and counters (avoids stack bleed like Arcanist Crux)
+    if (buffData && typeof buffData === 'object') {
+        for (const key of Object.keys(buffData)) {
+            const b = buffData[key];
+            if (b && typeof b === 'object') {
+                b.enabled = false;
+                b.skillEnabled = false;
+                b.buffEnabled = false;
+                b.combatEnabled = false;
+                if (b.maxTimes != null && b.count == null)
+                    b.count = 0;
+            }
+        }
+    }
+    // Toggle skills: zero enabled AND valid (valid stayed true from previous calls)
+    if (toggleSkillData && typeof toggleSkillData === 'object') {
+        for (const key of Object.keys(toggleSkillData)) {
+            const s = toggleSkillData[key];
+            if (s && typeof s === 'object') {
+                s.enabled = false;
+                s.combatEnabled = false;
+                s.valid = false;
+            }
+        }
+    }
+    // Skill bars and passives/actives
+    g.g_EsoSkillBarData = [emptyBar(), emptyBar()];
+    g.g_EsoSkillPassiveData = {};
+    g.g_EsoSkillActiveData = {};
+    // ─── DATA INJECTION ───────────────────────────────────────────────────────
     // -------------------------------------------------------------------------
-    // PASSO 1: Injeta stats do personagem nos elementos mock do DOM.
-    // O motor lê esses valores via jQuery: $("#esotbRace").val(), etc.
+    // STEP 1: Inject character stats into the mock DOM elements.
+    // The engine reads these values via jQuery: $("#esotbRace").val(), etc.
     // -------------------------------------------------------------------------
-    (0, env_setup_1.resetDomValues)();
-    const { character, items, championPointNodes, activeBuffs, toggleSkills, skillBars, activeWeaponBar, passiveSkills, autoPassives, enchantOverrides, } = input;
-    (0, env_setup_1.setDomValue)('esotbRace', character.race);
-    (0, env_setup_1.setDomValue)('esotbClass', character.class);
-    (0, env_setup_1.setDomValue)('esotbLevel', String(Math.min(character.level, 50)));
-    (0, env_setup_1.setDomValue)('esotbAttrHea', String(character.attributes.health ?? 0));
-    (0, env_setup_1.setDomValue)('esotbAttrMag', String(character.attributes.magicka ?? 0));
-    (0, env_setup_1.setDomValue)('esotbAttrSta', String(character.attributes.stamina ?? 0));
-    // Mundus Stone (pedra de Mundus)
+    resetDomValues();
+    setDomValue('esotbRace', character.race);
+    setDomValue('esotbClass', character.class);
+    setDomValue('esotbLevel', String(Math.min(character.level, 50)));
+    setDomValue('esotbAttrHea', String(character.attributes.health ?? 0));
+    setDomValue('esotbAttrMag', String(character.attributes.magicka ?? 0));
+    setDomValue('esotbAttrSta', String(character.attributes.stamina ?? 0));
+    // Mundus Stone
     if (character.mundusStone) {
-        (0, env_setup_1.setDomValue)('esotbMundus', character.mundusStone);
+        setDomValue('esotbMundus', character.mundusStone);
     }
-    // Segunda Pedra de Mundus (requer set Twice-Born Star ou será ativada diretamente).
-    // IsTwiceBornStarEnabled() lê a flag _esoWrapperTwiceBornOverride (patch em loader.ts)
-    // quando o set não está equipado mas mundusStone2 é fornecido explicitamente.
-    global._esoWrapperTwiceBornOverride = !!character.mundusStone2;
+    // Second Mundus Stone (requires the Twice-Born Star set or it is enabled directly).
+    // IsTwiceBornStarEnabled() reads the _esoWrapperTwiceBornOverride flag (patch in loader.ts)
+    // when the set is not equipped but mundusStone2 is provided explicitly.
+    g._esoWrapperTwiceBornOverride = !!character.mundusStone2;
     if (character.mundusStone2) {
-        (0, env_setup_1.setDomValue)('esotbMundus2', character.mundusStone2);
+        setDomValue('esotbMundus2', character.mundusStone2);
     }
     // PvP Cyrodiil (Battle Spirit)
     if (character.cyrodiil) {
-        (0, env_setup_1.setDomValue)('esotbCyrodiil', 'true'); // prop("checked") retorna true quando valor é "true"
+        setDomValue('esotbCyrodiil', 'true'); // prop("checked") returns true when the value is "true"
     }
-    // Vampiro / Lobisomem
+    // Vampire / Werewolf
     if (character.vampireStage != null)
-        (0, env_setup_1.setDomValue)('esotbVampireStage', String(character.vampireStage));
+        setDomValue('esotbVampireStage', String(character.vampireStage));
     if (character.werewolfStage != null)
-        (0, env_setup_1.setDomValue)('esotbWerewolfStage', String(character.werewolfStage));
-    // Champion Points (default 0 — garante que SpellCrit e WeaponCrit sejam numéricos)
-    (0, env_setup_1.setDomValue)('esotbCPTotalPoints', String(character.championPoints ?? 0));
-    // Versão das regras (padrão: Live)
-    (0, env_setup_1.setDomValue)('esotbRulesVersion', character.rulesVersion ?? 'Live');
-    // Campos obrigatórios com defaults seguros
-    (0, env_setup_1.setDomValue)('esotbMountSpeedBonus', '0');
-    (0, env_setup_1.setDomValue)('esotbBaseWalkSpeed', '3.0');
-    (0, env_setup_1.setDomValue)('esotbBuildDescription', '');
-    (0, env_setup_1.setDomValue)('esotbUsePtsRules', 'false');
-    (0, env_setup_1.setDomValue)('esotbEnableRaceAutoPurchase', 'false');
-    // Configuração do alvo (target) — necessária para AttackSpellMitigation e EffectivePower.
-    // Target.EffectiveLevel = 0 causa divisão por zero na fórmula; padrão 50 é o nível máximo.
-    (0, env_setup_1.setDomValue)('esotbTargetResistance', '18200'); // UESP default: CP160 enemy base resistance
-    (0, env_setup_1.setDomValue)('esotbTargetEffectiveLevel', '66'); // UESP default: 66 = CP160 (endgame content)
-    (0, env_setup_1.setDomValue)('esotbTargetCritResistFlat', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetPenetrationFlat', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetPenetrationFactor', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetDefenseBonus', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetAttackBonus', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetCritDamage', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetCritChance', '0');
-    (0, env_setup_1.setDomValue)('esotbTargetPercentHealth', '100');
+        setDomValue('esotbWerewolfStage', String(character.werewolfStage));
+    // Champion Points (default 0 — ensures SpellCrit and WeaponCrit stay numeric)
+    setDomValue('esotbCPTotalPoints', String(character.championPoints ?? 0));
+    // Rules version (default: Live)
+    setDomValue('esotbRulesVersion', character.rulesVersion ?? 'Live');
+    // Required fields with safe defaults
+    setDomValue('esotbMountSpeedBonus', '0');
+    setDomValue('esotbBaseWalkSpeed', '3.0');
+    setDomValue('esotbBuildDescription', '');
+    setDomValue('esotbUsePtsRules', 'false');
+    setDomValue('esotbEnableRaceAutoPurchase', 'false');
+    // Target configuration — required for AttackSpellMitigation and EffectivePower.
+    // Target.EffectiveLevel = 0 causes a division by zero in the formula; 50 is the max level default.
+    setDomValue('esotbTargetResistance', '18200'); // UESP default: CP160 enemy base resistance
+    setDomValue('esotbTargetEffectiveLevel', '66'); // UESP default: 66 = CP160 (endgame content)
+    setDomValue('esotbTargetCritResistFlat', '0');
+    setDomValue('esotbTargetPenetrationFlat', '0');
+    setDomValue('esotbTargetPenetrationFactor', '0');
+    setDomValue('esotbTargetDefenseBonus', '0');
+    setDomValue('esotbTargetAttackBonus', '0');
+    setDomValue('esotbTargetCritDamage', '0');
+    setDomValue('esotbTargetCritChance', '0');
+    setDomValue('esotbTargetPercentHealth', '100');
     // -------------------------------------------------------------------------
-    // PASSO 2: Injeta dados de itens DIRETAMENTE em g_EsoBuildItemData[slot].
+    // STEP 2: Inject item data DIRECTLY into g_EsoBuildItemData[slot].
     //
-    // Esta é a ideia central: em vez de mockar jQuery para cada campo de item,
-    // populamos a variável global que o motor lê nativamente.
-    // Os dados vêm exatamente no formato da API pública da UESP — sem adaptação.
+    // This is the core idea: instead of mocking jQuery for each item field,
+    // we populate the global variable the engine reads natively.
+    // Data comes exactly in the UESP public API format — no adaptation.
     // -------------------------------------------------------------------------
-    const itemData = global.g_EsoBuildItemData;
-    const enchantData = global.g_EsoBuildEnchantData;
-    // Reseta todos os slots (evita dados de chamada anterior)
-    for (const slot of ALL_SLOTS) {
-        itemData[slot] = {};
-        if (enchantData) {
-            // Se há override customizado, popula g_EsoBuildEnchantData[slot] com os dados do glyph.
-            // Isso faz GetEsoEnchantData() usar o caminho customizado (isDefaultEnchant=false),
-            // e o engine aplica o fator de escala 0.4044 para slots pequenos (Hands/Waist/Feet/Shoulders).
-            // Clone raso para evitar mutação entre chamadas.
-            const override = enchantOverrides?.[slot];
-            enchantData[slot] = override ? { ...override } : {};
+    // Custom enchantments: make GetEsoEnchantData() take the isDefaultEnchant=false path,
+    // applying the 0.4044 factor for small slots (Hands/Waist/Feet/Shoulders).
+    if (enchantData && enchantOverrides) {
+        for (const slot of ALL_SLOTS) {
+            const override = enchantOverrides[slot];
+            if (override)
+                enchantData[slot] = { ...override };
         }
     }
-    // Reseta g_EsoCpData para evitar bleed-through entre chamadas
-    global.g_EsoCpData = {};
-    const cpDataGlobal = global.g_EsoCpData;
-    // Injeta os itens fornecidos (normalizados com defaults seguros)
+    const cpDataGlobal = g.g_EsoCpData;
+    // Inject the provided items (normalized with safe defaults)
     if (items) {
         for (const [slot, item] of Object.entries(items)) {
             if (item && item.itemId) {
@@ -165,22 +233,22 @@ function calculateBuild(input) {
         }
     }
     // -------------------------------------------------------------------------
-    // PASSO 3a: Injeta nodes do Champion Points 2.
+    // STEP 3a: Inject Champion Points 2 nodes.
     //
-    // Dois caminhos dependendo se buildRules.cp está carregado:
+    // Two paths depending on whether buildRules.cp is loaded:
     //
-    // Novo (preferido): quando g_EsoBuildRules['cp'] existe, o motor usa o caminho
-    //   GetEsoBuildCpRuleValues que lê cpData.description e faz match contra
-    //   ESO_CPEFFECT_MATCHES. Populamos g_EsoCpData[nodeId] com a description completa.
+    // New (preferred): when g_EsoBuildRules['cp'] exists, the engine uses the
+    //   GetEsoBuildCpRuleValues path which reads cpData.description and matches against
+    //   ESO_CPEFFECT_MATCHES. We populate g_EsoCpData[nodeId] with the full description.
     //
-    // Legado: sem cp rules, o motor usa ParseEsoCP2Value com injeção DOM via
-    //   $("#skill_<id>").attr("unlocked") e $("#descskill_<id>").text().
+    // Legacy: without cp rules, the engine uses ParseEsoCP2Value with DOM injection via
+    //   $("#skill_<id>").attr("unlocked") and $("#descskill_<id>").text().
     // -------------------------------------------------------------------------
     if (championPointNodes && Object.keys(championPointNodes).length > 0) {
-        (0, env_setup_1.setDomValue)('esotbEnableCP', 'true');
-        const hasCpRules = !!global.g_EsoBuildRules?.cp;
-        const cpSkills = global.g_EsoCpSkills ?? {};
-        const cpSkillDesc = global.g_EsoCpSkillDesc ?? {};
+        setDomValue('esotbEnableCP', 'true');
+        const hasCpRules = !!g.g_EsoBuildRules?.cp;
+        const cpSkills = g.g_EsoCpSkills ?? {};
+        const cpSkillDesc = g.g_EsoCpSkillDesc ?? {};
         // Build reverse map: name → numeric nodeId (for named-string keys in the input)
         const cpNameToId = {};
         for (const [id, meta] of Object.entries(cpSkills)) {
@@ -201,13 +269,13 @@ function calculateBuild(input) {
         }
         for (const [nodeId, nodeData] of resolvedNodes) {
             if (hasCpRules) {
-                // Resolve o nome a partir dos metadados capturados do browser.
+                // Resolve the name from the metadata captured from the browser.
                 const name = cpSkills[nodeId]?.name ?? `CP_${nodeId}`;
-                // Resolve a descrição dinamicamente:
-                //   1. Override explícito do chamador
-                //   2. Lookup exato por nodeData.points em g_EsoCpSkillDesc[nodeId]
-                //   3. Floor lookup: maior chave disponível ≤ points
-                //   4. Fallback: chave 0 ou primeira disponível
+                // Resolve the description dynamically:
+                //   1. Explicit caller override
+                //   2. Exact lookup by nodeData.points in g_EsoCpSkillDesc[nodeId]
+                //   3. Floor lookup: largest available key ≤ points
+                //   4. Fallback: key 0 or first available
                 let desc = nodeData.description;
                 if (!desc && cpSkillDesc[nodeId]) {
                     const nodeDescMap = cpSkillDesc[nodeId];
@@ -231,41 +299,31 @@ function calculateBuild(input) {
                 if (desc) {
                     // Strip HTML tags and ESO color codes (|cHHHHHH...|r) so the engine's regex matching works on plain text
                     const plainDesc = desc.replace(/<[^>]+>/g, '').replace(/\|c[0-9a-fA-F]{6}|\|r/g, '');
-                    cpDataGlobal[nodeId] = { type: 'skill', isUnlocked: true, description: plainDesc, name };
+                    // isUnlocked: use explicit value from fixture when present; default true for old fixtures without it
+                    const isUnlocked = nodeData.isUnlocked !== undefined ? nodeData.isUnlocked : true;
+                    cpDataGlobal[nodeId] = { type: 'skill', isUnlocked, description: plainDesc, name };
                 }
-                // sem descrição resolvível → node ignorado (sem efeito no motor)
+                // no resolvable description → node ignored (no engine effect)
             }
             else {
-                // caminho legado: injeção DOM para ParseEsoCP2Value
+                // legacy path: DOM injection for ParseEsoCP2Value
                 const bonus = nodeData.currentBonus;
                 const bonusStr = typeof bonus === 'string' && bonus.endsWith('%')
                     ? `Current value: ${bonus}`
                     : `Current bonus: ${bonus}`;
-                (0, env_setup_1.setDomAttr)(`skill_${nodeId}`, 'unlocked', '1');
-                (0, env_setup_1.setDomTextContent)(`descskill_${nodeId}`, bonusStr);
-                (0, env_setup_1.setDomTextContent)(`descskill_${nodeId}_prev`, `CP Node ${nodeId}`);
+                setDomAttr(`skill_${nodeId}`, 'unlocked', '1');
+                setDomTextContent(`descskill_${nodeId}`, bonusStr);
+                setDomTextContent(`descskill_${nodeId}_prev`, `CP Node ${nodeId}`);
             }
         }
     }
     // -------------------------------------------------------------------------
-    // PASSO 3b: Habilita buffs ativos.
+    // STEP 3b: Enable active buffs.
     //
-    // g_EsoBuildBuffData é um Proxy que auto-cria entradas.
-    // Setar .enabled = true é suficiente para IsEsoBuffEnabled() retornar true.
-    // Reseta todos os buffs antes para evitar bleed-through entre chamadas.
+    // g_EsoBuildBuffData is a Proxy that auto-creates entries.
+    // Setting .enabled = true is enough for IsEsoBuffEnabled() to return true.
+    // (reset already done in the global reset block above)
     // -------------------------------------------------------------------------
-    const buffData = global.g_EsoBuildBuffData;
-    if (buffData && typeof buffData === 'object') {
-        for (const key of Object.keys(buffData)) {
-            const b = buffData[key];
-            if (b && typeof b === 'object') {
-                b.enabled = false;
-                b.skillEnabled = false;
-                b.buffEnabled = false;
-                b.combatEnabled = false;
-            }
-        }
-    }
     if (activeBuffs) {
         for (const buffName of activeBuffs) {
             if (buffData) {
@@ -279,21 +337,11 @@ function calculateBuild(input) {
         }
     }
     // -------------------------------------------------------------------------
-    // PASSO 3c: Habilita toggle skills.
+    // STEP 3c: Enable toggle skills.
     //
-    // IsEsoBuildToggledSkillEnabled() verifica: skillData.valid && skillData.enabled
-    // Reseta todos os toggles antes para evitar bleed-through entre chamadas.
+    // IsEsoBuildToggledSkillEnabled() checks: skillData.valid && skillData.enabled
+    // (reset of enabled, combatEnabled and valid already done in the global reset block above)
     // -------------------------------------------------------------------------
-    const toggleSkillData = global.g_EsoBuildToggledSkillData;
-    if (toggleSkillData && typeof toggleSkillData === 'object') {
-        for (const key of Object.keys(toggleSkillData)) {
-            const s = toggleSkillData[key];
-            if (s && typeof s === 'object') {
-                s.enabled = false;
-                s.combatEnabled = false;
-            }
-        }
-    }
     if (toggleSkills) {
         for (const skillName of toggleSkills) {
             if (toggleSkillData) {
@@ -305,23 +353,17 @@ function calculateBuild(input) {
         }
     }
     // -------------------------------------------------------------------------
-    // PASSO 3d: Injeta skill bars em g_EsoSkillBarData.
+    // STEP 3d: Inject skill bars into g_EsoSkillBarData.
     //
-    // O motor usa g_EsoSkillBarData para detectar skill lines ativas e aplicar
-    // passivos condicionais (ex: passivos de Destruction Staff, set bonuses que
-    // afetam "Class abilities", etc.).
+    // The engine uses g_EsoSkillBarData to detect active skill lines and apply
+    // conditional passives (e.g. Destruction Staff passives, set bonuses affecting
+    // "Class abilities", etc.).
     //
-    // LIMITAÇÃO ATUAL: sem g_SkillsData no uesp-init-data.json, os skill IDs são
-    // injetados mas os passivos de skill line não geram stats. Será funcional
-    // quando g_SkillsData for adicionado ao JSON de extração.
+    // CURRENT LIMITATION: without g_SkillsData in uesp-init-data.json, skill IDs are
+    // injected but skill line passives produce no stats. It becomes functional
+    // once g_SkillsData is added to the extraction JSON.
+    // (g_EsoSkillBarData already initialized with empty bars in the reset block above)
     // -------------------------------------------------------------------------
-    const emptyBar = () => Array.from({ length: 6 }, (_, i) => ({
-        skillId: 0,
-        origSkillId: 0,
-        morphIndex: 0,
-        slotIndex: i,
-    }));
-    global.g_EsoSkillBarData = [emptyBar(), emptyBar()];
     if (skillBars) {
         const barMap = [
             [skillBars.bar1, 0],
@@ -331,7 +373,7 @@ function calculateBuild(input) {
             if (!slots)
                 continue;
             slots.slice(0, 6).forEach((slot, slotIndex) => {
-                global.g_EsoSkillBarData[barIndex][slotIndex] = {
+                g.g_EsoSkillBarData[barIndex][slotIndex] = {
                     skillId: slot.skillId,
                     origSkillId: slot.skillId,
                     morphIndex: slot.morphIndex ?? 0,
@@ -341,26 +383,25 @@ function calculateBuild(input) {
         }
     }
     // -------------------------------------------------------------------------
-    // PASSO 3d-2: Popula g_EsoSkillPassiveData com os passivos do personagem.
+    // STEP 3d-2: Populate g_EsoSkillPassiveData with the character's passives.
     //
-    // O engine itera g_EsoSkillPassiveData em GetEsoInputSkillPassives e aplica
-    // cada passivo via regex no texto da descrição (ESO_PASSIVEEFFECT_MATCHES).
-    // Requer g_SkillsData + GetEsoSkillDescription (de esoskills.js).
+    // The engine iterates g_EsoSkillPassiveData in GetEsoInputSkillPassives and applies
+    // each passive via regex on the description text (ESO_PASSIVEEFFECT_MATCHES).
+    // Requires g_SkillsData + GetEsoSkillDescription (from esoskills.js).
     //
-    // Cada entrada: { abilityId } — o engine busca g_SkillsData[abilityId] para
-    // obter coeficientes e gerar a descrição do passivo.
+    // Each entry: { abilityId } — the engine looks up g_SkillsData[abilityId] to
+    // get coefficients and generate the passive description.
+    // (g_EsoSkillPassiveData already zeroed in the reset block above)
     // -------------------------------------------------------------------------
-    global.g_EsoSkillPassiveData = {};
     const allPassiveIds = new Set(passiveSkills ?? []);
     if (autoPassives) {
         // Use the loader snapshot (written before any calculations) to avoid raceType mutation.
-        const snapshot = global.g_EsoPassiveSkillSnapshot;
+        const snapshot = g.g_EsoPassiveSkillSnapshot;
         if (snapshot) {
             for (const v of Object.values(snapshot)) {
                 if (!v)
                     continue;
-                if ((v.raceType === character.race || v.classType === character.class) &&
-                    (v.nextSkill === -1 || String(v.nextSkill) === '-1')) {
+                if (v.raceType === character.race && (v.nextSkill === -1 || String(v.nextSkill) === '-1')) {
                     allPassiveIds.add(Number(v.abilityId));
                 }
             }
@@ -371,16 +412,16 @@ function calculateBuild(input) {
         for (const abilityId of allPassiveIds) {
             passiveData[String(abilityId)] = { abilityId };
         }
-        global.g_EsoSkillPassiveData = passiveData;
+        g.g_EsoSkillPassiveData = passiveData;
     }
     // -------------------------------------------------------------------------
-    // PASSO 3d-3: Popula g_EsoSkillActiveData a partir das skill bars.
+    // STEP 3d-3: Populate g_EsoSkillActiveData from the skill bars.
     //
-    // GetEsoInputSkillActiveBar lê g_EsoSkillBarData[barra][slot].origSkillId e
-    // busca g_EsoSkillActiveData[origSkillId].abilityId para obter a descrição.
-    // Populamos automaticamente para todos os slots não-vazios das barras.
+    // GetEsoInputSkillActiveBar reads g_EsoSkillBarData[bar][slot].origSkillId and
+    // looks up g_EsoSkillActiveData[origSkillId].abilityId for the description.
+    // We populate automatically for every non-empty bar slot.
+    // (g_EsoSkillActiveData already zeroed in the reset block above)
     // -------------------------------------------------------------------------
-    global.g_EsoSkillActiveData = {};
     if (skillBars) {
         const activeData = {};
         const bars = [skillBars.bar1, skillBars.bar2];
@@ -395,37 +436,60 @@ function calculateBuild(input) {
                 }
             }
         }
-        global.g_EsoSkillActiveData = activeData;
+        g.g_EsoSkillActiveData = activeData;
     }
     // -------------------------------------------------------------------------
-    // PASSO 3e: Define qual barra de armas/skills está ativa.
+    // STEP 3e: Set which weapon/skill bar is active.
     //
-    // g_EsoBuildActiveWeapon  — slots MainHand/OffHand ativos para set bonuses.
-    // g_EsoBuildActiveAbilityBar — índice 1-based lido por CountEsoBarSkillsWithSkillLine/Type
-    //   para passivos que escalam com skills na barra (Expert Mage, Magicka Controller, etc.).
-    // Ambos precisam ser sincronizados; usar valores distintos resulta em passivos errados.
+    // g_EsoBuildActiveWeapon  — active MainHand/OffHand slots for set bonuses.
+    // g_EsoBuildActiveAbilityBar — 1-based index read by CountEsoBarSkillsWithSkillLine/Type
+    //   for passives scaling with slotted skills (Expert Mage, Magicka Controller, etc.).
+    // Both must be kept in sync; distinct values produce wrong passives.
     // -------------------------------------------------------------------------
     const activeBar = activeWeaponBar ?? 1;
-    global.g_EsoBuildActiveWeapon = activeBar;
-    global.g_EsoBuildActiveAbilityBar = activeBar;
+    g.g_EsoBuildActiveWeapon = activeBar;
+    g.g_EsoBuildActiveAbilityBar = activeBar;
     // -------------------------------------------------------------------------
-    // PASSO 4: Executa o cálculo.
+    // STEP 4: Run the calculation.
     //
     // UpdateEsoComputedStatsList_Real(keepSaveResults, noUpdate)
-    //   - keepSaveResults = null  → reseta os resultados salvos (comportamento padrão)
-    //   - noUpdate = true         → pula DisplayEsoAllComputedStats e UpdateReadOnlyStats
-    //                               (operações de DOM que não precisamos)
+    //   - keepSaveResults = null  → resets saved results (default behavior)
+    //   - noUpdate = true         → skips DisplayEsoAllComputedStats and UpdateReadOnlyStats
+    //                               (DOM operations we don't need)
     // -------------------------------------------------------------------------
-    const updateFn = global.UpdateEsoComputedStatsList_Real;
+    const updateFn = g.UpdateEsoComputedStatsList_Real;
     if (typeof updateFn !== 'function') {
-        throw new Error('[eso-engine] UpdateEsoComputedStatsList_Real não está disponível. ' +
-            'Certifique-se de chamar initEsoEngine() antes de calculateBuild().');
+        throw new Error('[eso-engine] UpdateEsoComputedStatsList_Real is not available. ' +
+            'Make sure to call initEsoEngineFromData() before calculateBuild().');
+    }
+    // Patch IsEsoBuildToggledSetEnabled to honour toggledSetBonuses.
+    // The UESP engine reads this inside GetEsoInputSetValues (called after UpdateEsoItemSets
+    // sets valid=true for equipped sets). Without this patch, toggle set bonuses are never
+    // enabled in Node because the DOM checkboxes used by UpdateEsoBuildToggledSetData are empty.
+    const toggledSetIds = new Set(toggledSetBonuses ?? []);
+    const origIsEnabled = g.IsEsoBuildToggledSetEnabled;
+    if (toggledSetIds.size > 0) {
+        g.IsEsoBuildToggledSetEnabled = function (setId) {
+            if (toggledSetIds.has(String(setId))) {
+                const td = g.g_EsoBuildToggledSetData?.[String(setId)];
+                if (td?.valid)
+                    return true;
+            }
+            return origIsEnabled.call(this, setId);
+        };
+    }
+    try {
+        updateFn(null, true);
+    }
+    finally {
+        if (toggledSetIds.size > 0) {
+            g.IsEsoBuildToggledSetEnabled = origIsEnabled;
+        }
     }
-    updateFn(null, true);
     // -------------------------------------------------------------------------
-    // PASSO 5: Lê os resultados de g_EsoComputedStats[statId].value
+    // STEP 5: Read the results from g_EsoComputedStats[statId].value
     // -------------------------------------------------------------------------
-    const computedStats = global.g_EsoComputedStats ?? {};
+    const computedStats = g.g_EsoComputedStats ?? {};
     const raw = {};
     for (const statId of Object.keys(computedStats)) {
         const stat = computedStats[statId];
@@ -434,40 +498,40 @@ function calculateBuild(input) {
         }
     }
     return {
-        // Atributos máximos
+        // Max attributes
         Health: raw['Health'] ?? 0,
         Magicka: raw['Magicka'] ?? 0,
         Stamina: raw['Stamina'] ?? 0,
-        // Regeneração
+        // Regeneration
         HealthRegen: raw['HealthRegen'] ?? 0,
         MagickaRegen: raw['MagickaRegen'] ?? 0,
         StaminaRegen: raw['StaminaRegen'] ?? 0,
-        // Dano
+        // Damage
         WeaponDamage: raw['WeaponDamage'] ?? 0,
         SpellDamage: raw['SpellDamage'] ?? 0,
-        // Crítico
+        // Critical
         WeaponCrit: raw['WeaponCrit'] ?? 0,
         SpellCrit: raw['SpellCrit'] ?? 0,
         SpellCritDamage: raw['SpellCritDamage'] ?? 0,
         WeaponCritDamage: raw['WeaponCritDamage'] ?? 0,
-        // Resistências
+        // Resistances
         PhysicalResist: raw['PhysicalResist'] ?? 0,
         SpellResist: raw['SpellResist'] ?? 0,
         CritResist: raw['CritResist'] ?? 0,
-        // Penetração
+        // Penetration
         PhysicalPenetration: raw['PhysicalPenetration'] ?? 0,
         SpellPenetration: raw['SpellPenetration'] ?? 0,
-        // Poder efetivo
+        // Effective power
         EffectiveSpellPower: raw['EffectiveSpellPower'] ?? 0,
         EffectiveWeaponPower: raw['EffectiveWeaponPower'] ?? 0,
         EffectivePower: raw['EffectivePower'] ?? 0,
-        // Cura
+        // Healing
         HealingDone: raw['HealingDone'] ?? 0,
         HealingTaken: raw['HealingTaken'] ?? 0,
-        // Velocidade
+        // Speed
         RunSpeed: raw['RunSpeed'] ?? 0,
         SprintSpeed: raw['SprintSpeed'] ?? 0,
-        // Mitigação
+        // Mitigation
         AttackSpellMitigation: raw['AttackSpellMitigation'] ?? 0,
         AttackPhysicalMitigation: raw['AttackPhysicalMitigation'] ?? 0,
         DefenseSpellMitigation: raw['DefenseSpellMitigation'] ?? 0,
@@ -481,14 +545,14 @@ function calculateBuild(input) {
  * Each entry maps to one row in the UESP buff tab. Pass `entry.name` to
  * `BuildInput.activeBuffs` to enable that buff in a calculation.
  *
- * Must be called after `initEsoEngine()`.
+ * Must be called after `initEsoEngineFromData()`.
  *
  * @param group - Optional filter. Ex: "Major", "Minor", "Set", "Target",
  *   "Skill", "Potion", "Poison", "Cyrodiil", "Other".
  *   Omit to return all 164 buffs.
  */
-function listAvailableBuffs(group) {
-    const buffData = global.g_EsoBuildBuffData;
+export function listAvailableBuffs(group) {
+    const buffData = engineGlobals().g_EsoBuildBuffData;
     if (!buffData || typeof buffData !== 'object')
         return [];
     const result = [];
@@ -518,7 +582,7 @@ function listAvailableBuffs(group) {
 // Uses g_EsoPassiveSkillSnapshot (written by loader.ts at engine init time) to avoid
 // the engine's mutation of g_SkillsData.raceType during calculations.
 function buildPassiveSkillInfos(filter, sortKey) {
-    const snapshot = global.g_EsoPassiveSkillSnapshot;
+    const snapshot = engineGlobals().g_EsoPassiveSkillSnapshot;
     if (!snapshot || typeof snapshot !== 'object')
         return [];
     return Object.values(snapshot)
@@ -540,12 +604,12 @@ function buildPassiveSkillInfos(filter, sortKey) {
  * Each passive may appear in multiple ranks (rank 1, 2, 3).
  * Pass the abilityId of the desired rank to BuildInput.passiveSkills.
  *
- * Must be called after initEsoEngine().
+ * Must be called after initEsoEngineFromData().
  *
  * @param race - Race name as passed to BuildInput.character.race.
  *   Ex: "High Elf", "Nord", "Khajiit"
  */
-function listRacialPassives(race) {
+export function listRacialPassives(race) {
     return buildPassiveSkillInfos((v) => v.raceType === race, (v) => v.baseName);
 }
 /**
@@ -553,12 +617,12 @@ function listRacialPassives(race) {
  * Each passive may appear in multiple ranks (rank 1, 2, 3).
  * Pass the abilityId of the desired rank to BuildInput.passiveSkills.
  *
- * Must be called after initEsoEngine().
+ * Must be called after initEsoEngineFromData().
  *
  * @param className - Class name as passed to BuildInput.character.class.
  *   Ex: "Sorcerer", "Nightblade", "Dragonknight"
  */
-function listClassPassives(className) {
+export function listClassPassives(className) {
     return buildPassiveSkillInfos((v) => v.classType === className, (v) => (v.skillLine ?? '') + v.baseName);
 }
 /**
@@ -566,7 +630,7 @@ function listClassPassives(className) {
  * Each passive may appear in multiple ranks (rank 1, 2, 3).
  * Pass the abilityId of the desired rank to BuildInput.passiveSkills.
  *
- * Must be called after initEsoEngine().
+ * Must be called after initEsoEngineFromData().
  *
  * @param skillLine - Skill line name as it appears in g_SkillsData.
  *   Use listAvailableSkillLines() to discover valid names.
@@ -574,17 +638,17 @@ function listClassPassives(className) {
  *   "Fighters Guild", "Mages Guild", "Psijic Order", "Assault", "Support",
  *   "Vampire", "Werewolf"
  */
-function listPassivesBySkillLine(skillLine) {
+export function listPassivesBySkillLine(skillLine) {
     return buildPassiveSkillInfos((v) => v.skillLine === skillLine, (v) => v.baseName);
 }
 /**
  * Returns all skill line names that have passive skills available.
  * Use the returned names with listPassivesBySkillLine().
  *
- * Must be called after initEsoEngine().
+ * Must be called after initEsoEngineFromData().
  */
-function listAvailableSkillLines() {
-    const snapshot = global.g_EsoPassiveSkillSnapshot;
+export function listAvailableSkillLines() {
+    const snapshot = engineGlobals().g_EsoPassiveSkillSnapshot;
     if (!snapshot || typeof snapshot !== 'object')
         return [];
     const lines = new Set();
@@ -602,10 +666,10 @@ function listAvailableSkillLines() {
  * Toggle skills backed by a passive (isPassive=true) need the associated skill
  * in passiveSkills/skillBars for the engine to process the description match.
  *
- * Must be called after initEsoEngine().
+ * Must be called after initEsoEngineFromData().
  */
-function listAvailableToggleSkills() {
-    const toggleData = global.g_EsoBuildToggledSkillData;
+export function listAvailableToggleSkills() {
+    const toggleData = engineGlobals().g_EsoBuildToggledSkillData;
     if (!toggleData || typeof toggleData !== 'object')
         return [];
     const result = [];