← retour au collage›Modifier / dupliquer

HV Monster PL Planner

#5kPLpH6qr8public / publicnouvelle version

anonyme créé 4 days ago Expire dans 3 months 103.6 KB syntaxe: javascript

Vos changements créent un nouveau collage lié à celui-ci — l’original reste intact.

nouvelle version Vos changements créent un nouveau collage lié à celui-ci — l’original reste intact.

Visibilité Fil public Accès public

Note de changement (facultatif)

Ce collage sera affiché dans le fil public. Changez la visibilité si vous voulez seulement le partager par lien.

Annuler

// ==UserScript==
// @name         HV Monster PL Planner
// @namespace    https://hentaiverse.org/
// @version      0.2.5
// @description  Standalone Monster Lab batch PL planner, upgrader and crystal buyer with HV Utils compatibility.
// @author       KirisameReiko
// @include      /^https:\/\/hentaiverse\.org\/\?s=Bazaar&ss=ml(?:&.*)?$/
// @include      /^https:\/\/alt\.hentaiverse\.org\/\?s=Bazaar&ss=ml(?:&.*)?$/
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @run-at       document-end
// ==/UserScript==

(function () {
  'use strict';

const query = Object.fromEntries(new URLSearchParams(location.search));
  if (
    location.protocol !== 'https:' ||
    !['hentaiverse.org', 'alt.hentaiverse.org'].includes(location.hostname) ||
    location.pathname !== '/' ||
    query.s !== 'Bazaar' ||
    query.ss !== 'ml'
  ) return;

const STORE_KEY = 'hv_exact_pl_planner_v1';
  const EPS = 1e-9;
  const PL_SCALE = 2;
  const PRIMARY_COST_BASE = 50;
  const PRIMARY_COST_RATE = 1.555079154;
  const ELEMENTAL_COST_BASE = 10;
  const ELEMENTAL_COST_RATE = 1.26485522;
  const REQUEST_DELAY_MS = 300;
  const DIRECT_BUY_RETRY_DELAY_MS = 5000;
  const DIRECT_BUY_MAX_RETRIES = 3;
  const MARKET_DETAIL_CONCURRENCY = 6;

const primary = ['STR', 'DEX', 'AGI', 'END', 'INT', 'WIS'];
  const elemental = ['FIRE', 'COLD', 'ELEC', 'WIND', 'HOLY', 'DARK'];
  const all = [...primary, ...elemental];
  const displayElemental = ['WIND', 'ELEC', 'FIRE', 'COLD', 'DARK', 'HOLY'];
  const displayAll = [...primary, ...displayElemental];
  const primarySet = new Set(primary);
  // Add new Easter eggs here, one string per line.
  const easterEggMessages = [
    'Isekaijoucho',
    '🍜',
    '⑨',
    'Dokidoki Wakuwaku',
    'wawawaa',
    '( ・_ゝ・)',
    'Rina Hidaka',
    'How high can borrowed wings really fly?',
    'Aizawa Nachu',
    'Soyokaze Ame',
    'Otherside Picnic',
  ];
  const languageOptions = [
    ['en', 'English'],
    ['zh-CN', '简体中文'],
  ];
  const languageValues = languageOptions.map(([value]) => value);

const crystalByAttr = {
    STR: 'Crystal of Vigor',
    DEX: 'Crystal of Finesse',
    AGI: 'Crystal of Swiftness',
    END: 'Crystal of Fortitude',
    INT: 'Crystal of Cunning',
    WIS: 'Crystal of Knowledge',

FIRE: 'Crystal of Flames',
    COLD: 'Crystal of Frost',
    ELEC: 'Crystal of Lightning',
    WIND: 'Crystal of Tempest',
    HOLY: 'Crystal of Devotion',
    DARK: 'Crystal of Corruption',
  };

const upgradeQueryByAttr = {
    STR: 'pa_str',
    DEX: 'pa_dex',
    AGI: 'pa_agi',
    END: 'pa_end',
    INT: 'pa_int',
    WIS: 'pa_wis',

FIRE: 'er_fire',
    COLD: 'er_cold',
    ELEC: 'er_elec',
    WIND: 'er_wind',
    HOLY: 'er_holy',
    DARK: 'er_dark',
  };

const crystalNames = all.map((a) => crystalByAttr[a]);
  const attrByCrystal = Object.fromEntries(all.map((attr) => [crystalByAttr[attr], attr]));
  const priceSourceValues = ['ask', 'bid', 'day', 'week', 'month', 'year', 'hvut'];
  const marketPriceSources = ['ask', 'bid', 'day', 'week', 'month', 'year'];

const crystalNameAliases = new Map();
  all.forEach((attr) => {
    const canonical = crystalByAttr[attr];
    [canonical, translations.en.crystal[attr], translations['zh-CN'].crystal[attr]]
      .forEach((name) => crystalNameAliases.set(name, canonical));
  });

const defaultPrice = {
    STR: 2.18,
    DEX: 1.52,
    AGI: 1.23,
    END: 1.95,
    INT: 1.25,
    WIS: 1.23,

FIRE: 1.11,
    COLD: 1.09,
    ELEC: 1.11,
    WIND: 1.11,
    HOLY: 1.09,
    DARK: 1.10,
  };

function $(q, d = document) {
    return d.querySelector(q);
  }

function $all(q, d = document) {
    return Array.from(d.querySelectorAll(q));
  }

function randomEasterEgg(current = '') {
    const candidates = easterEggMessages.filter((message) => message !== current);
    const pool = candidates.length ? candidates : easterEggMessages;
    return pool[Math.floor(Math.random() * pool.length)] || '';
  }

function htmlToDoc(html) {
    const doc = document.implementation.createHTMLDocument('');
    doc.documentElement.innerHTML = html;
    return doc;
  }

function elt(tag, attrs = {}, children = []) {
    const e = document.createElement(tag);

Object.entries(attrs || {}).forEach(([k, v]) => {
      if (v === undefined || v === null) return;

if (k === 'class') {
        e.className = v;
      } else if (k === 'style') {
        e.style.cssText = v;
      } else if (k === 'dataset') {
        Object.assign(e.dataset, v);
      } else if (k === 'text') {
        e.textContent = v;
      } else if (k in e) {
        e[k] = v;
      } else {
        e.setAttribute(k, v);
      }
    });

if (!Array.isArray(children)) children = [children];

children.forEach((c) => {
      if (c === null || c === undefined) return;
      e.appendChild(
        typeof c === 'string' || typeof c === 'number'
          ? document.createTextNode(String(c))
          : c
      );
    });

return e;
  }

function parseNum(text) {
    const m = String(text || '').replace(/,/g, '').match(/-?\d+(?:\.\d+)?/);
    return m ? Number(m[0]) : NaN;
  }

function positiveNumber(value) {
    const n = Number(value);
    return Number.isFinite(n) && n > 0 ? n : 0;
  }

function clampInt(value, min, max) {
    const n = parseInt(value, 10);
    return Number.isFinite(n) ? Math.max(min, Math.min(max, n)) : min;
  }

function gmGet(key, fallback) {
    try {
      const v = typeof GM_getValue === 'function'
        ? GM_getValue(key, null)
        : localStorage.getItem(key);

return parseStoredJson(v, fallback);
    } catch (e) {
      return fallback;
    }
  }

function isPlainObject(value) {
    return value && typeof value === 'object' && !Array.isArray(value);
  }

function normalizeLanguage(language) {
    return languageValues.includes(language) ? language : 'en';
  }

function readTranslation(path, language = state.language) {
    const parts = path.split('.');
    let value = translations[normalizeLanguage(language)];

for (const part of parts) {
      value = value?.[part];
    }

if (value !== undefined) return value;

value = translations.en;
    for (const part of parts) {
      value = value?.[part];
    }

return value ?? path;
  }

function t(path, params = {}) {
    const value = readTranslation(path);
    return typeof value === 'function' ? value(params) : value;
  }

function attrLabel(attr) {
    return t(`attr.${attr}`);
  }

function crystalLabel(crystalOrAttr) {
    const attr = crystalByAttr[crystalOrAttr] ? crystalOrAttr : attrByCrystal[crystalOrAttr];
    return attr ? t(`crystal.${attr}`) : String(crystalOrAttr || '');
  }

function canonicalCrystalName(name) {
    return crystalNameAliases.get(String(name || '').trim()) || '';
  }

function priceSourceLabel(value) {
    return t(`priceSource.${value}`);
  }

function joinList(values) {
    return values.join(t('listSeparator'));
  }

function readHvutPriceStore() {
    try {
      const prices = parseStoredJson(localStorage.getItem('hvut_prices'));
      if (isPlainObject(prices)) return prices;
    } catch (e) {
      // fall through to this script's GM storage
    }

try {
      if (typeof GM_getValue === 'function') {
        const prices = parseStoredJson(GM_getValue('hvut_prices', null));
        if (isPlainObject(prices)) return prices;
      }
    } catch (e) {
      // ignore invalid external storage
    }

return {};
  }

function writeHvutPrices(pricePatch) {
    const prices = Object.assign({}, readHvutPriceStore(), pricePatch);

try {
      if (typeof GM_setValue === 'function') {
        GM_setValue('hvut_prices', prices);
      }
    } catch (e) {
      console.warn('[PL Planner] HV Utils GM price save failed:', e);
    }

try {
      localStorage.setItem('hvut_prices', JSON.stringify(prices));
    } catch (e) {
      console.warn('[PL Planner] HV Utils localStorage price save failed:', e);
    }
  }

async function fetchText(url, data = null) {
    const full = new URL(url, location.origin).href;
    const response = await fetch(full, {
      method: data ? 'POST' : 'GET',
      body: data || undefined,
      credentials: 'same-origin',
      headers: data ? { 'Content-Type': 'application/x-www-form-urlencoded' } : undefined,
      redirect: 'follow',
      cache: 'no-store',
    });
    const text = await response.text();
    if (!response.ok) throw new Error(`${response.status} ${response.statusText}: ${full}`);
    if (text === 'state lock limiter in effect') throw new Error(text);
    return text;
  }

function defaultLevels() {
    return Object.fromEntries(all.map((a) => [a, 0]));
  }

function normalizeMonsterLevels(levels) {
    if (!isPlainObject(levels) || all.some((a) => !Number.isFinite(Number(levels[a])))) return null;
    return Object.fromEntries(all.map((a) => [a, clampInt(levels[a], 0, maxLevel(a))]));
  }

function normalizeAttrPrices(value) {
    const source = isPlainObject(value) ? value : {};
    return Object.fromEntries(all.map((attr) => [
      attr,
      positiveNumber(source[attr]) || defaultPrice[attr],
    ]));
  }

state.prices = normalizeAttrPrices(state.prices);

const storedPriceCache = isPlainObject(state.priceCache) ? state.priceCache : {};
  state.priceCache = {};

state.levels = normalizeMonsterLevels(state.levels) || defaultLevels();

state.orderUnitPrices = normalizeAttrPrices(state.orderUnitPrices);

if (!priceSourceValues.includes(state.priceSource)) {
    state.priceSource = 'ask';
  }

if (!priceSourceValues.includes(state.orderPriceSource)) {
    state.orderPriceSource = 'bid';
  }

if (!Array.isArray(state.selectedMonsterSlots)) {
    state.selectedMonsterSlots = [];
  }

state.selectedMonsterSlots = Array.from(new Set(
    state.selectedMonsterSlots.map(String).filter((slot) => /^\d+$/.test(slot))
  ));

state.language = normalizeLanguage(state.language);

const hvutSavedPrices = readHvutPriceStore();

for (const a of all) {
    const crystal = crystalByAttr[a];
    const storedCache = isPlainObject(storedPriceCache[crystal]) ? storedPriceCache[crystal] : {};
    const cached = {};
    state.priceCache[crystal] = cached;
    marketPriceSources.forEach((source) => {
      const value = positiveNumber(storedCache[source]);
      if (value) cached[source] = value;
    });
    cached.hvut = positiveNumber(storedCache.hvut) || positiveNumber(hvutSavedPrices[crystal]) || undefined;
    cached[state.priceSource] = positiveNumber(cached[state.priceSource]) || state.prices[a];
    cached.batchSize = Math.floor(positiveNumber(storedCache.batchSize)) || undefined;

state.levels[a] = clampInt(state.levels[a], 0, maxLevel(a));
  }

const runtime = {
    monsterList: [],
    monsters: new Map(Object.entries(state.monsterCache)),
    marketData: Object.fromEntries(crystalNames.map((name) => [name, Object.assign({}, state.priceCache[name])])),
    inventoryLoaded: false,
    orderBooksLoaded: false,
    lastPlan: null,
    busy: false,
    calculationTimer: null,
    calculationPending: false,
  };

const initialCachedMonster = runtime.monsters.get(String(state.lastMonsterSlot || state.selectedMonsterSlots[0] || ''));
  if (initialCachedMonster) state.levels = Object.assign({}, initialCachedMonster.levels);

function saveState() {
    gmSet(STORE_KEY, state);
  }

function isPrimary(a) {
    return primarySet.has(a);
  }

function maxLevel(a) {
    return isPrimary(a) ? 25 : 50;
  }

function primaryTotalPL(n) {
    return n * (6 + (n - 1) * 0.5) / 2;
  }

function elementalTotalPL(n) {
    const t = Math.floor(n / 10);
    const r = n % 10;
    return (t + 1) * (t * 5 + r);
  }

function deltaPL(a, n) {
    return isPrimary(a) ? 3 + n * 0.5 : Math.floor(1 + n * 0.1);
  }

function crystalCost(a, n) {
    const primaryAttr = isPrimary(a);
    const base = primaryAttr ? PRIMARY_COST_BASE : ELEMENTAL_COST_BASE;
    const rate = primaryAttr ? PRIMARY_COST_RATE : ELEMENTAL_COST_RATE;
    return Math.round(base * Math.pow(rate, n));
  }

function totalPL(levels) {
    let pl = 0;

primary.forEach((a) => {
      pl += primaryTotalPL(levels[a] || 0);
    });

elemental.forEach((a) => {
      pl += elementalTotalPL(levels[a] || 0);
    });

return pl;
  }

const maxPL = primary.length * primaryTotalPL(25) + elemental.length * elementalTotalPL(50);

function formatPL(v) {
    return Math.abs(v - Math.round(v)) < EPS
      ? String(Math.round(v))
      : v.toFixed(2).replace(/\.?0+$/, '');
  }

function formatMoney(v) {
    if (!Number.isFinite(v)) return '-';
    if (v >= 1000000) return (v / 1000000).toFixed(3) + ' MC';
    if (v >= 1000) return (v / 1000).toFixed(3) + ' KC';
    return v.toFixed(2) + ' C';
  }

function buildOptions(attr, startLevel, targetW) {
    const opts = [{
      k: 0,
      w: 0,
      cost: 0,
    }];

let accW = 0;
    let accCrystals = 0;
    let accCost = 0;

for (let n = startLevel; n < maxLevel(attr); n++) {
      const dpl = deltaPL(attr, n);
      const w = Math.round(dpl * PL_SCALE);
      const crystals = crystalCost(attr, n);
      const c = crystals * Number(state.prices[attr] || defaultPrice[attr]);

accW += w;
      accCrystals += crystals;
      accCost += c;

if (accW > targetW) break;

opts.push({
        attr,
        k: n - startLevel + 1,
        w: accW,
        crystals: accCrystals,
        cost: accCost,
      });
    }

return opts;
  }

function solveExact(startLevels, target) {
    const currentPL = totalPL(startLevels);
    const effectiveTarget = Math.max(target, currentPL);

if (effectiveTarget > maxPL + EPS) {
      return {
        ok: false,
        message: t('errorTargetOverMax', { max: formatPL(maxPL) }),
      };
    }

const need = effectiveTarget - currentPL;
    const needWFloat = need * PL_SCALE;
    const needW = Math.round(needWFloat);

if (Math.abs(needWFloat - needW) > 1e-7) {
      return {
        ok: false,
        message: t('errorTargetUnit'),
      };
    }

let dp = new Array(needW + 1).fill(Infinity);
    dp[0] = 0;

const parents = [];

for (let gi = 0; gi < all.length; gi++) {
      const attr = all[gi];
      const opts = buildOptions(attr, startLevels[attr], needW);

const ndp = new Array(needW + 1).fill(Infinity);
      const parent = new Array(needW + 1).fill(null);

for (let j = 0; j <= needW; j++) {
        if (!Number.isFinite(dp[j])) continue;

for (const opt of opts) {
          const nj = j + opt.w;
          if (nj > needW) continue;

const candidate = dp[j] + opt.cost;

if (candidate + EPS < ndp[nj]) {
            ndp[nj] = candidate;
            parent[nj] = { prev: j, opt };
          }
        }
      }

dp = ndp;
      parents.push(parent);
    }

if (!Number.isFinite(dp[needW])) {
      return {
        ok: false,
        message: t('errorTargetUnreachable'),
      };
    }

const chosen = [];
    let cur = needW;

for (let gi = all.length - 1; gi >= 0; gi--) {
      const p = parents[gi][cur];

if (!p) {
        return {
          ok: false,
          message: t('errorCalculationPath'),
        };
      }

if (p.opt.k > 0) chosen.push(p.opt);
      cur = p.prev;
    }

const finalLevels = Object.assign({}, startLevels);
    const agg = Object.fromEntries(all.map((attr) => [attr, {
      from: startLevels[attr],
      to: startLevels[attr],
      k: 0,
      crystals: 0,
      cost: 0,
    }]));
    let totalCost = 0;

chosen.forEach((opt) => {
      finalLevels[opt.attr] += opt.k;
      const item = agg[opt.attr];
      item.to += opt.k;
      item.k += opt.k;
      item.crystals += opt.crystals;
      item.cost += opt.cost;
      totalCost += opt.cost;
    });

return {
      ok: true,
      currentPL,
      targetPL: effectiveTarget,
      finalLevels,
      agg,
      totalCost,
    };
  }

function readInputs({ save = true } = {}) {
    all.forEach((a) => {
      const orderPrice = $(`#hvmepp-order-price-${a}`);

if (orderPrice) {
        const crystal = crystalByAttr[a];
        const batchSize = Math.floor(positiveNumber(runtime.marketData[crystal]?.batchSize));
        const batchPrice = Math.max(1, Math.round(positiveNumber(orderPrice.value)));
        if (batchSize && batchPrice) {
          state.orderUnitPrices[a] = batchPrice / batchSize;
          orderPrice.value = batchPrice;
        }
      }
    });

const target = $('#hvmepp-target');
    if (target) state.targetPL = parseFloat(target.value) || 0;

const source = $('#hvmepp-source');
    if (source) state.priceSource = source.value;

const orderSource = $('#hvmepp-order-source');
    if (orderSource) state.orderPriceSource = orderSource.value;

if (save) saveState();
  }

function setLevels(levels, { save = true } = {}) {
    all.forEach((a) => {
      state.levels[a] = clampInt(levels[a], 0, maxLevel(a));
    });

updateCurrentPL({ save: false });
    if (save) saveState();
  }

function updateCurrentPL({ save = true } = {}) {
    readInputs({ save });

const current = totalPL(state.levels);
    const need = (Number(state.targetPL) || 0) - current;
    const node = $('#hvmepp-live');

if (node) {
      node.replaceChildren(
        `${t('labelCurrentPL')}: `, elt('b', { text: formatPL(current) }),
        `  ${t('labelTargetPL')}: `, elt('b', { text: formatPL(state.targetPL || 0) }),
        `  ${t('labelNeedPL')}: `, elt('b', { text: formatPL(need) }),
        `  ${t('labelMaxPL')}: `, elt('b', { text: formatPL(maxPL) })
      );
    }
  }

function parseMonsterLevelsFromDoc(doc) {
    const stats = $all('#monsterstats_top td:nth-child(2)', doc)
      .map((td) => parseInt(td.textContent, 10))
      .filter((n) => Number.isFinite(n));

if (stats.length < 12) return null;

return Object.fromEntries(all.map((a, i) => [a, stats[i]]));
  }

function extractSlotFromMonsterRow(row) {
    const candidates = [
      row.getAttribute('onclick') || '',
      ...$all('a[href]', row).map((a) => a.getAttribute('href') || ''),
    ];

for (const text of candidates) {
      const slot = text.match(/[?&]slot=(\d+)/)?.[1];
      if (slot) return slot;
    }

return '';
  }

function parseMonsterName(row, slot) {
    const explicit = row.querySelector('[data-name], .hvmepp-monster-name')?.textContent?.trim();
    if (explicit) return explicit;

const cells = Array.from(row.children);
    const originalName = cells[1]?.textContent?.trim();
    if (originalName) return originalName;

const text = row.textContent.replace(/\s+/g, ' ').trim();
    const withoutPL = text.replace(/\bPL\s*\d+\b/i, '').trim();
    return withoutPL || t('monsterFallback', { slot });
  }

function parseMonsterPL(row) {
    const text = row.textContent.replace(/\s+/g, ' ');
    const fromText = text.match(/\bPL\s*(\d+)/i)?.[1];
    if (fromText) return parseInt(fromText, 10);

const structuredPL = parseNum(row.children[2]?.textContent);
    if (Number.isFinite(structuredPL)) return Math.floor(structuredPL);

const originalPL = Array.from(row.children).slice(2)
      .map((child) => child.textContent || '')
      .map((text) => text.match(/^\s*(?:PL\s*)?(\d{1,4})\s*$/i)?.[1])
      .find(Boolean);

return originalPL ? parseInt(originalPL, 10) : 0;
  }

function parseMonsterList() {
    return $all('#slot_pane > div').map((div) => {
      const onclick = div.getAttribute('onclick') || '';
      if (onclick.includes('&create=new')) return null;

const index = extractSlotFromMonsterRow(div);
      if (!index) return null;

return {
        index,
        name: parseMonsterName(div, index),
        pl: parseMonsterPL(div),
      };
    }).filter(Boolean);
  }

async function fetchMonsterLevels(slot) {
    const html = await fetchText(`?s=Bazaar&ss=ml&slot=${encodeURIComponent(slot)}`);
    const doc = htmlToDoc(html);
    const levels = parseMonsterLevelsFromDoc(doc);

if (!levels) {
      throw new Error(t('errorParseMonster'));
    }

return levels;
  }

function getMonsterMeta(slot) {
    const key = String(slot);
    return runtime.monsterList.find((monster) => String(monster.index) === key) || {
      name: t('monsterFallback', { slot: key }),
    };
  }

function cacheMonsterRecord(record, { save = true } = {}) {
    const slot = String(record?.slot || '');
    const levels = normalizeMonsterLevels(record?.levels);
    if (!/^\d+$/.test(slot) || !levels) return null;

const meta = getMonsterMeta(slot);
    const cached = {
      slot,
      name: String(record.name || meta.name || t('monsterFallback', { slot })),
      levels,
    };
    state.monsterCache[slot] = cached;
    runtime.monsters.set(slot, cached);
    if (save) saveState();
    return cached;
  }

function getSelectedMonsterSlots() {
    const checkboxes = $all('.hvmepp-monster-check');
    if (checkboxes.length) {
      return checkboxes.filter((checkbox) => checkbox.checked).map((checkbox) => String(checkbox.value));
    }

if (query.slot) return [String(query.slot)];
    return state.selectedMonsterSlots.slice();
  }

function clearCurrentPlan() {
    runtime.lastPlan = null;
    const box = $('#hvmepp-result');
    if (box) replacePlanContent(box);
  }

function invalidateCurrentPlan() {
    runtime.lastPlan = null;
    const box = $('#hvmepp-result');
    if (!box) return;
    box.setAttribute('aria-busy', 'true');
    $all('button, input, select', box).forEach((control) => {
      control.disabled = true;
    });
  }

function clearScheduledCalculation() {
    if (runtime.calculationTimer !== null) clearTimeout(runtime.calculationTimer);
    runtime.calculationTimer = null;
    runtime.calculationPending = false;
  }

function syncMonsterSelection() {
    if (runtime.busy) {
      const selected = new Set(state.selectedMonsterSlots.map(String));
      $all('.hvmepp-monster-check').forEach((checkbox) => {
        checkbox.checked = selected.has(String(checkbox.value));
      });
      runtime.calculationPending = true;
      return;
    }

state.selectedMonsterSlots = getSelectedMonsterSlots();
    if (state.selectedMonsterSlots.length) {
      state.lastMonsterSlot = state.selectedMonsterSlots[0];
      const loaded = runtime.monsters.get(state.lastMonsterSlot);
      setLevels(loaded?.levels || defaultLevels(), { save: false });
    } else {
      state.lastMonsterSlot = '';
      setLevels(defaultLevels(), { save: false });
    }
    refreshMonsterSelectionSummary();
    if (state.selectedMonsterSlots.length) scheduleCalculation();
    else calculate();
  }

function refreshMonsterSelectionSummary() {
    const node = $('#hvmepp-selection-summary');
    if (!node) return;

async function mapLimit(values, limit, worker) {
    const items = Array.from(values);
    const results = new Array(items.length);
    let nextIndex = 0;

async function run() {
      while (nextIndex < items.length) {
        const index = nextIndex++;
        results[index] = await worker(items[index], index);
      }
    }

await Promise.all(Array.from({ length: Math.min(limit, items.length) }, run));
    return results;
  }

async function loadSelectedMonsters() {
    const slots = getSelectedMonsterSlots();
    if (!slots.length) throw new Error(t('errorNoMonsterSelection'));

state.selectedMonsterSlots = slots;
    state.lastMonsterSlot = slots[0];
    saveState();

if (records[0]?.levels) setLevels(records[0].levels, { save: false });
    calculate();
    setStatus(t('statusLoadedMonsters', { total: records.length }));
    return records;
  }

function readCurrentMonsterIfAny({ recalculate = true } = {}) {
    const levels = parseMonsterLevelsFromDoc(document);
    if (!levels) return false;

setLevels(levels, { save: false });

saveState();
    refreshMonsterSelectionSummary();
    if (recalculate) calculate();
    setStatus(t('statusLoadedCurrentMonster'));

return true;
  }

function parseMarketRows(doc, result) {
    const table = $('#market_itemlist table', doc);
    if (!table) return;

const headers = Array.from(table.rows[0]?.cells || [])
      .map((cell) => cell.textContent.trim().replace(/\s+/g, ' '));
    const findCol = (...names) => headers.findIndex((header) => names.includes(header));
    const nameCol = Math.max(0, findCol('Item', '物品'));
    const stockCol = findCol('Your Stock', '你的库存');
    const bidCol = findCol('Market Bid', '市场买价');
    const askCol = findCol('Market Ask', '市场卖价');

Array.from(table.rows).forEach((tr, i) => {
      if (i === 0 || !tr.cells || tr.cells.length < 2) return;

const name = canonicalCrystalName(tr.cells[nameCol]?.textContent);
      if (!name) return;

const onclick = tr.getAttribute('onclick') || '';
      const href = tr.querySelector('a[href*="itemid="]')?.getAttribute('href') || '';
      const itemid = (onclick + ' ' + href).match(/itemid=(\d+)/)?.[1];
      const stock = stockCol < 0 ? NaN : parseNum(tr.cells[stockCol]?.textContent);
      const bid = bidCol < 0 ? NaN : parseNum(tr.cells[bidCol]?.textContent);
      const ask = askCol < 0 ? NaN : parseNum(tr.cells[askCol]?.textContent);

result[name] = Object.assign(result[name] || {}, {
        itemid,
        stock,
        bid,
        ask,
        unitBid: bid,
        unitAsk: ask,
      });
    });
  }

async function fetchMarketCrystalIndex() {
    const result = {};

const urls = [
      '?s=Bazaar&ss=mk&filter=mo&screen=browseitems',
      '?s=Bazaar&ss=mk&filter=ma&screen=browseitems',
      '?s=Bazaar&ss=mk&screen=browseitems',
    ];

for (const url of urls) {
      try {
        const html = await fetchText(url);
        parseMarketRows(htmlToDoc(html), result);

if (
          crystalNames.every((n) =>
            result[n]?.itemid ||
            Number.isFinite(result[n]?.ask) ||
            Number.isFinite(result[n]?.bid)
          )
        ) {
          break;
        }
      } catch (e) {
        console.warn('[PL Planner] Market browse failed:', url, e);
      }
    }

return result;
  }

function parseMarketDirectBuyPrice(doc) {
    const infoText = $('#market_iteminfo', doc)?.textContent || '';
    const raw = infoText.match(/Can always be bought for\s+([\d,]+)\s*C/i)?.[1]
      || infoText.match(/(?:direct supply price|直接供貨價|直接供货价)[^\d]*([\d,]+)\s*C/i)?.[1];
    const price = Math.floor(parseNum(raw));
    return Number.isFinite(price) && price > 0 ? price : 0;
  }

function parseMarketBalance(doc) {
    const candidates = [
      ...$all('.credit_balance', doc),
      $('#market_xfer', doc),
      doc.body,
    ].filter(Boolean);

for (const node of candidates) {
      const match = (node.textContent || '').match(/Market Balance[\s\S]*?([\d,]+)\s*C/i);
      const balance = parseNum(match?.[1]);
      if (Number.isFinite(balance)) return Math.max(0, Math.floor(balance));
    }
    return null;
  }

function parseOrderBook(doc, selector) {
    return $all(`${selector} .market_itemorders table tr`, doc).slice(1).map((row) => ({
      crystals: Math.max(0, Math.floor(parseNum(row.cells?.[0]?.textContent) || 0)),
      batchPrice: Math.max(0, Math.round(parseNum(row.cells?.[1]?.textContent) || 0)),
    })).filter((order) => order.crystals > 0 && order.batchPrice > 0);
  }

async function fetchMarketDetailData(itemid) {
    const html = await fetchText(`?s=Bazaar&ss=mk&screen=browseitems&filter=mo&itemid=${encodeURIComponent(itemid)}`);
    const doc = htmlToDoc(html);

const name = canonicalCrystalName($('#market_itemheader', doc)?.children?.[1]?.textContent);
    const batchSize = parseMarketBatchSize(doc);
    const count = $('#buyorder_batchcount, input[name="buyorder_batchcount"]', doc);
    const rows = $('#market_price', doc)?.rows;

if (!name) return null;

const result = {
      batchSize,
      directBuyPrice: parseMarketDirectBuyPrice(doc),
      askOrders: parseOrderBook(doc, '#market_itemsell'),
      bidOrders: parseOrderBook(doc, '#market_itembuy'),
      currentOrder: {
        count: Math.max(0, Math.floor(parseNum(count?.value) || 0)),
      },
    };

if (!batchSize || !rows || rows.length < 5) return result;

function avg(rowIndex) {
      const text = rows[rowIndex]?.cells?.[3]?.textContent || '';
      const v = parseNum(text);
      return v ? v / batchSize : 0;
    }

return Object.assign(result, {
      day: avg(1),
      week: avg(2),
      month: avg(3),
      year: avg(4),
    });
  }

async function enrichCrystalMarketData(data) {
    const targets = crystalNames.filter((name) => data[name]?.itemid);
    let done = 0;

await mapLimit(targets, MARKET_DETAIL_CONCURRENCY, async (name) => {
      let detail = null;
      try {
        detail = await fetchMarketDetailData(data[name].itemid);
      } catch (e) {
        console.warn('[PL Planner] Market crystal detail failed:', name, e);
      }
      done++;
      setStatus(t('statusReadingMarket', { done, total: targets.length }));

if (detail) {
        const row = Object.assign(data[name], detail);
        const batchSize = positiveNumber(row.batchSize);
        row.batchBid = batchSize && positiveNumber(row.unitBid) ? Math.max(1, Math.round(row.unitBid * batchSize)) : 0;
        row.batchAsk = batchSize && positiveNumber(row.unitAsk) ? Math.max(1, Math.round(row.unitAsk * batchSize)) : 0;
      }
    });

}

async function fetchCrystalMarketData() {
    const data = await fetchMarketCrystalIndex();
    await enrichCrystalMarketData(data);

runtime.marketData = Object.assign({}, runtime.marketData, data);
    return data;
  }

function applyPricesByCrystal(priceByCrystal) {
    let updated = 0;
    const failed = [];

displayAll.forEach((a) => {
      const crystal = crystalByAttr[a];
      const v = positiveNumber(priceByCrystal[crystal]);

if (v) {
        state.prices[a] = v;
        updated++;
      } else {
        failed.push(crystalLabel(crystal));
      }
    });

return { updated, failed };
  }

function rebuildLastPlan() {
    if (!runtime.lastPlan?.results?.length) return;
    const monsters = runtime.lastPlan.results.map((result) => ({
      slot: result.monsterSlot,
      name: result.monsterName,
      levels: result.startLevels,
    }));
    runtime.lastPlan = buildBatchPlan(monsters, Number(state.targetPL));
  }

function persistMarketPriceCache(data) {
    const hvutPrices = readHvutPriceStore();
    let updated = 0;
    const failed = [];

all.forEach((attr) => {
      const crystal = crystalByAttr[attr];
      const market = data[crystal] || {};
      const cached = state.priceCache[crystal] || (state.priceCache[crystal] = {});
      marketPriceSources.forEach((source) => {
        const value = positiveNumber(market[source]);
        if (value) cached[source] = value;
      });
      const hvut = positiveNumber(hvutPrices[crystal]);
      if (hvut) cached.hvut = hvut;
      if (positiveNumber(market.batchSize)) cached.batchSize = Math.floor(market.batchSize);

if (marketPriceSources.every((source) => positiveNumber(cached[source]))) updated++;
      else failed.push(crystalLabel(crystal));
    });

return { updated, failed };
  }

function applyCalculationPriceSource(source = state.priceSource) {
    return applyPricesByCrystal(getCrystalPricesForSource(source, state.priceCache));
  }

if (save) saveState();
    if (notify) {
      setStatus(failed.length
        ? t('statusOrderPricesPartial', {
          source: priceSourceLabel(source),
          updated,
          failed: joinList(failed),
        })
        : t('statusOrderPricesComplete', { source: priceSourceLabel(source) }));
    }
    return { updated, failed };
  }

async function refreshMarketSnapshot({ silent = false, rerender = true, applySavedSources = true } = {}) {
    readInputs({ save: false });
    if (!silent) setStatus(t('statusReadingMarket'));
    const data = await fetchCrystalMarketData();
    runtime.inventoryLoaded = true;
    runtime.orderBooksLoaded = true;

if (rerender && runtime.lastPlan) renderPlan(runtime.lastPlan);

function levelsEqual(a, b) {
    return all.every((attr) => Number(a?.[attr]) === Number(b?.[attr]));
  }

function getSelectedLoadedMonsters() {
    const slots = getSelectedMonsterSlots();
    return slots.map((slot) => runtime.monsters.get(String(slot))).filter(Boolean);
  }

const requirements = Object.fromEntries(all.map((attr) => [attr, 0]));
    let totalCost = 0;
    results.forEach((result) => {
      if (!result.ok) return;
      totalCost += result.totalCost;
      all.forEach((attr) => {
        requirements[attr] += Number(result.agg[attr].crystals) || 0;
      });
    });

return {
      ok: results.length > 0 && results.every((result) => result.ok),
      targetPL: target,
      results,
      requirements,
      totalCost,
      monsterCount: results.length,
    };
  }

function buildUpgradeRequests(result, slot) {
    const requests = [];

all.forEach((attr) => {
      let count = result.agg[attr].k;
      const queryName = upgradeQueryByAttr[attr];

while (count > 0) {
        const step = Math.min(10, count);
        requests.push({
          attr,
          count: step,
          slot: String(slot),
          url: `?s=Bazaar&ss=ml&slot=${encodeURIComponent(slot)}`,
          data: `crystal_upgrade=${encodeURIComponent(queryName)}&crystal_count=${step}`,
        });
        count -= step;
      }
    });

return requests;
  }

function requiredTradeBatches(shortage, batchSize) {
    const missing = Math.max(0, Math.ceil(Number(shortage) || 0));
    if (!missing) return 0;
    const size = Math.floor(positiveNumber(batchSize));
    return size ? Math.floor(missing / size) + 1 : null;
  }

function estimateOrderBookPurchase(crystalsToBuy, batchSize, askOrders, directBuyPrice) {
    const size = Math.floor(positiveNumber(batchSize));
    const totalBatches = size ? Math.floor(positiveNumber(crystalsToBuy) / size) : 0;
    if (!size || !totalBatches || !Array.isArray(askOrders)) return null;

let remainingBatches = totalBatches;
    let estimatedCost = 0;
    let lowestBatchPrice = 0;
    let highestBatchPrice = 0;
    const sortedAsks = askOrders.slice().sort((a, b) => a.batchPrice - b.batchPrice);

sortedAsks.forEach((order) => {
      if (!remainingBatches) return;
      const availableBatches = Math.floor(positiveNumber(order.crystals) / size);
      const batchPrice = Math.round(positiveNumber(order.batchPrice));
      if (!availableBatches || !batchPrice) return;
      const matched = Math.min(remainingBatches, availableBatches);
      estimatedCost += matched * batchPrice;
      remainingBatches -= matched;
      if (!lowestBatchPrice) lowestBatchPrice = batchPrice;
      highestBatchPrice = batchPrice;
    });

const guaranteedPrice = Math.round(positiveNumber(directBuyPrice));
    const guaranteedBatches = remainingBatches;
    if (remainingBatches && guaranteedPrice) {
      estimatedCost += remainingBatches * guaranteedPrice;
      if (!lowestBatchPrice) lowestBatchPrice = guaranteedPrice;
      highestBatchPrice = Math.max(highestBatchPrice, guaranteedPrice);
      remainingBatches = 0;
    }

return {
      estimatedCost: remainingBatches ? null : estimatedCost,
      lowestBatchPrice,
      highestBatchPrice,
      guaranteedBatches,
    };
  }

function getPurchaseEstimateSummary(rows) {
    let estimatedCost = 0;
    let requiredStartingBalance = 0;
    const shortages = rows.filter((row) => row.shortage > 0 && row.batches > 0);
    if (!shortages.length || shortages.some((row) => !Number.isFinite(row.estimatedDirectCost))) return null;

shortages.forEach((row) => {
      requiredStartingBalance = Math.max(
        requiredStartingBalance,
        estimatedCost + row.directBalanceRequired
      );
      estimatedCost += row.estimatedDirectCost;
    });
    return { estimatedCost, requiredStartingBalance };
  }

function getCrystalShortages(rows) {
    return rows.filter((row) => row.shortage > 0 && row.batches > 0);
  }

function getUnknownCrystalRows(rows) {
    return rows.filter((row) =>
      row.required > 0
      && (row.stock === null || (row.shortage > 0 && (!row.itemid || !row.batchSize)))
    );
  }

function sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }

function marketResponseError(doc) {
    const messages = $all('#messagebox_inner p', doc).map((node) => node.textContent.trim()).filter(Boolean);
    return messages.find((message) => /(?:error|invalid|cannot|not enough|insufficient|exceed|failed)/i.test(message)) || '';
  }

function orderNotAppliedError(crystal) {
    const error = new Error(t('errorOrderNotApplied', { crystal: crystalLabel(crystal) }));
    error.code = 'ORDER_NOT_APPLIED';
    return error;
  }

function parseCrystalBuyForm(doc, crystal) {
    const section = $('#market_itembuy', doc);
    if (!section) throw new Error(t('errorMarketItemForm', { crystal: crystalLabel(crystal) }));

if (!token || !count || !price || !submit) {
      throw new Error(t('errorMarketItemForm', { crystal: crystalLabel(crystal) }));
    }
    if (!batchSize) {
      throw new Error(t('errorCrystalBatch', { crystal: crystalLabel(crystal) }));
    }

function controlName(node) {
      return node.getAttribute('name') || node.id || '';
    }

const names = {
      token: controlName(token),
      count: controlName(count),
      price: controlName(price),
      submit: controlName(submit),
    };
    if (Object.values(names).some((name) => !name)) {
      throw new Error(t('errorMarketItemForm', { crystal: crystalLabel(crystal) }));
    }

return {
      names,
      token: token.value,
      submitValue: 'Update',
      batchSize,
      directBuyPrice: parseMarketDirectBuyPrice(doc),
      inventoryStock: Number.isFinite(inventoryStock) ? Math.max(0, Math.floor(inventoryStock)) : null,
      currentOrder: {
        count: Math.max(0, Math.floor(parseNum(count.value) || 0)),
        price: Math.max(0, Math.round(parseNum(price.value) || 0)),
      },
      deleteControl: deleteControl ? {
        name: controlName(deleteControl),
        value: deleteControl.value || deleteControl.textContent?.trim() || 'Delete',
      } : null,
    };
  }

async function cancelCrystalBuyOrder(url, responseDoc, form, crystal) {
    if (!form.deleteControl?.name) return false;

const params = new URLSearchParams();
    params.set(form.names.token, form.token);
    params.set(form.deleteControl.name, form.deleteControl.value);
    const cancelDoc = htmlToDoc(await fetchText(url, params.toString()));
    const error = marketResponseError(cancelDoc);
    if (error) throw new Error(error);

try {
      return parseCrystalBuyForm(cancelDoc, crystal).currentOrder.count === 0;
    } catch (e) {
      console.warn('[PL Planner] Could not verify automatic buy-order cancellation:', e);
      return false;
    }
  }

async function placeCrystalBuyOrder(row, mode) {
    const label = crystalLabel(row.crystal);
    if (!row.itemid) throw new Error(t('errorMarketItemForm', { crystal: label }));

const responseDoc = htmlToDoc(await fetchText(url, params.toString()));
    const error = marketResponseError(responseDoc);
    if (error) throw new Error(error);
    const responseForm = parseCrystalBuyForm(responseDoc, row.crystal);
    if (responseForm.batchSize !== row.batchSize) {
      throw new Error(t('errorCrystalBatchChanged', {
        crystal: label,
        expected: row.batchSize,
        actual: responseForm.batchSize,
      }));
    }

if (mode === 'order' && (
      remainingBatches > submittedBatches
      || (remainingBatches > 0 && remainingPrice !== submittedPrice)
    )) {
      throw new Error(t('errorMarketItemForm', { crystal: label }));
    }

if (mode === 'direct' && remainingBatches > 0) {
      const cancelled = await cancelCrystalBuyOrder(url, responseDoc, responseForm, row.crystal);
      if (!cancelled) {
        throw new Error(t('errorDirectRemainder', {
          crystal: label,
          batches: remainingBatches,
        }));
      }
      result.cancelledRemainder = true;
      result.responseStatus = 'remainder-cancelled';
    }

return result;
  }

async function executeCrystalPurchase(mode, button) {
    const plan = runtime.lastPlan;
    if (!plan?.ok) {
      setStatus(t('errorNoValidPlan'));
      return;
    }

setStatus(t('statusCheckingPurchase'));
    await refreshMarketSnapshot({ silent: true, rerender: false, applySavedSources: false });
    const crystalRows = getCrystalPlanRows(plan);
    renderPlan(plan, crystalRows);

const unknown = getUnknownCrystalRows(crystalRows);
    if (unknown.length) {
      throw new Error(t('statusInventoryPartial', { failed: joinList(unknown.map((row) => row.label)) }));
    }

const rows = getCrystalShortages(crystalRows);
    if (!rows.length) {
      setStatus(t('statusNoShortage'));
      return;
    }

if (mode === 'order' && rows.some((row) => !positiveNumber(row.orderBatchPrice))) {
      throw new Error(t('errorNoValidPlan'));
    }

if (mode === 'direct') {
      const missingDirectPrice = rows.find((row) => !positiveNumber(row.directBuyPrice));
      if (missingDirectPrice) {
        throw new Error(t('errorDirectPrice', { crystal: missingDirectPrice.label }));
      }
      const existing = rows.filter((row) => row.currentOrder.count > 0);
      if (existing.length) {
        throw new Error(t('errorExistingBuyOrder', {
          crystals: joinList(existing.map((row) => row.label)),
        }));
      }
    }

for (let i = 0; i < rows.length; i++) {
      const row = rows[i];
      const price = mode === 'direct' ? row.directBuyPrice : row.orderBatchPrice;
      button.textContent = t('buttonBuying', { current: i + 1, total: rows.length });
      setStatus(t('statusExecutingPurchase', {
        current: i + 1,
        total: rows.length,
        crystal: row.label,
        crystals: row.crystalsToBuy.toLocaleString(),
        price: price.toLocaleString(),
      }));
      let ignoredRetries = 0;
      let result;
      while (!result) {
        try {
          result = await placeCrystalBuyOrder(row, mode);
        } catch (error) {
          if (mode !== 'direct' || error?.code !== 'ORDER_NOT_APPLIED' || ignoredRetries >= DIRECT_BUY_MAX_RETRIES) {
            throw error;
          }
          ignoredRetries++;
          setStatus(t('statusRetryingPurchase', {
            crystal: row.label,
            attempt: ignoredRetries,
          }));
          await sleep(DIRECT_BUY_RETRY_DELAY_MS * ignoredRetries);
        }
      }
      if (result.cancelledRemainder) {
        throw new Error(t('errorDirectRemainderCancelled', {
          crystal: row.label,
          batches: result.remainingBatches,
        }));
      }
      if (i + 1 < rows.length) await sleep(REQUEST_DELAY_MS);
    }

if (mode === 'direct') {
      await refreshMarketSnapshot({ silent: true, rerender: false, applySavedSources: false });
      renderPlan(plan);
      setStatus(t('statusDirectBuyComplete', { total: rows.length }));
    } else {
      setStatus(t('statusBuyOrdersComplete', { total: rows.length }));
    }
  }

async function executeBatchUpgradePlan(plan, button) {
    if (!plan?.ok) {
      setStatus(t('errorNoValidPlan'));
      return;
    }

const requests = plan.results.flatMap((result) => buildUpgradeRequests(result, result.monsterSlot));
    if (!requests.length) {
      setStatus(t('statusNoUpgrade'));
      return;
    }

await refreshMarketSnapshot({ silent: true, rerender: false, applySavedSources: false });
    const crystalRows = getCrystalPlanRows(plan);
    renderPlan(plan, crystalRows);
    const unknown = getUnknownCrystalRows(crystalRows);
    if (unknown.length) {
      setStatus(t('statusInventoryPartial', { failed: joinList(unknown.map((row) => row.label)) }));
      return;
    }
    const shortages = getCrystalShortages(crystalRows);
    if (shortages.length) {
      setStatus(t('statusCrystalShortage', {
        failed: joinList(shortages.map((row) => `${row.label} ${row.shortage.toLocaleString()}`)),
      }));
      return;
    }

const totalLevels = requests.reduce((sum, request) => sum + request.count, 0);
    if (!confirm(t('confirmUpgrade', {
      monsters: plan.monsterCount,
      requests: requests.length,
      levels: totalLevels,
    }))) return;

for (let i = 0; i < requests.length; i++) {
      const request = requests[i];
      button.textContent = t('buttonRunningUpgrade', { current: i + 1, total: requests.length });
      setStatus(t('statusExecutingUpgrade', {
        current: i + 1,
        total: requests.length,
        slot: request.slot,
        attr: attrLabel(request.attr),
        count: request.count,
      }));
      await fetchText(request.url, request.data);
      if (i + 1 < requests.length) await sleep(REQUEST_DELAY_MS);
    }

if (finalRecords[0]?.levels) setLevels(finalRecords[0].levels);
    await refreshMarketSnapshot({ silent: true, rerender: false, applySavedSources: false });
    runtime.lastPlan = buildBatchPlan(finalRecords, plan.targetPL);
    renderPlan(runtime.lastPlan);
    setStatus(complete
      ? t('statusUpgradeComplete', { total: finalRecords.length })
      : t('statusUpgradeMismatch'));
  }

function renderPriceSourceSelect(id, selectedValue) {
    const select = elt('select', { id });

priceSourceValues.forEach((value) => {
      select.appendChild(elt('option', {
        value,
        text: priceSourceLabel(value),
        dataset: { source: value },
        selected: selectedValue === value,
      }));
    });

return select;
  }

function renderButton(id, textKey) {
    return elt('button', {
      id,
      type: 'button',
      text: t(textKey),
      dataset: { i18n: textKey },
    });
  }

function setRuntimeBusy(busy) {
    const nextBusy = Boolean(busy);
    const resumeCalculation = !nextBusy && runtime.calculationPending;
    runtime.busy = nextBusy;
    $all('.hvmepp-monster-check, #hvmepp-select-all-monsters, #hvmepp-clear-monsters')
      .forEach((control) => { control.disabled = nextBusy; });
    if (resumeCalculation) scheduleCalculation();
  }

function bindManagedAction(button, textKey, errorKey, action) {
    button.addEventListener('click', async () => {
      if (runtime.busy) return;

setRuntimeBusy(true);
      button.disabled = true;
      try {
        await action(button);
      } catch (error) {
        setStatus(t(errorKey, { message: error.message }));
      } finally {
        button.disabled = false;
        button.textContent = t(textKey);
        setRuntimeBusy(false);
      }
    });
  }

function setStatus(text) {
    const n = $('#hvmepp-status');
    if (n) n.textContent = text || '';
  }

function refreshLanguageButtons() {
    $all('.hvmepp-lang-switch button').forEach((button) => {
      const active = button.dataset.lang === state.language;
      button.classList.toggle('hvmepp-lang-active', active);
      button.setAttribute('aria-pressed', active ? 'true' : 'false');
    });
  }

function refreshPriceSourceOptions() {
    $all('#hvmepp-source option, #hvmepp-order-source option').forEach((option) => {
      const source = option.dataset.source || option.value;
      option.textContent = priceSourceLabel(source);
    });
  }

function refreshLocalizedText({ rerenderResult = true } = {}) {
    $all('[data-i18n]').forEach((node) => {
      node.textContent = t(node.dataset.i18n);
    });

$all('[data-i18n-value]').forEach((node) => {
      node.value = t(node.dataset.i18nValue);
    });

$all('[data-attr]').forEach((node) => {
      node.textContent = attrLabel(node.dataset.attr);
    });

refreshPriceSourceOptions();
    refreshLanguageButtons();
    updateCurrentPL({ save: false });

if (rerenderResult && runtime.lastPlan && $('#hvmepp-result')?.hasChildNodes()) {
      renderPlan(runtime.lastPlan);
    }
  }

function setLanguage(language) {
    const nextLanguage = normalizeLanguage(language);
    readInputs({ save: false });
    state.language = nextLanguage;
    rebuildLastPlan();
    saveState();
    refreshLocalizedText();
    setStatus(t('statusLanguageSaved'));
  }

function renderLanguageSwitcher() {
    const bar = elt('div', { class: 'hvmepp-lang-switch' });

languageOptions.forEach(([value, label]) => {
      const active = value === state.language;
      const button = elt('button', {
        type: 'button',
        text: label,
        class: active ? 'hvmepp-lang-active' : '',
        dataset: { lang: value },
        ariaPressed: active ? 'true' : 'false',
      });

button.addEventListener('click', () => setLanguage(value));
      bar.appendChild(button);
    });

return bar;
  }

if (!result.ok) {
      details.appendChild(elt('div', { class: 'hvmepp-alert', text: result.message }));
      return details;
    }

const table = elt('table', { class: 'hvmepp-table' });
    table.appendChild(elt('tr', {}, [
      t('tableAttr'),
      t('tableCurrentLevel'),
      t('tableTargetLevel'),
      t('tableIncrease'),
      t('tableCost'),
    ].map((heading) => elt('th', { text: heading }))));

if (!upgraded.length) {
      table.appendChild(elt('tr', {}, [
        elt('td', { colspan: 5, text: t('noUpgradeNeeded') }),
      ]));
    }
    details.appendChild(table);
    return details;
  }

function renderCrystalPlan(plan, rows) {
    const card = elt('div', { class: 'hvmepp-card hvmepp-crystal-card' });
    card.appendChild(elt('h3', {
      text: t('headingCrystalNeeds'),
      dataset: { i18n: 'headingCrystalNeeds' },
    }));

if (!plan.ok) {
      card.appendChild(elt('div', { class: 'hvmepp-alert', text: t('crystalPlanUnavailable') }));
      return card;
    }

const table = elt('table', { class: 'hvmepp-table hvmepp-crystal-table' });
    table.appendChild(elt('tr', {}, [
      t('tableCrystal'),
      t('tableRequired'),
      t('tableStock'),
      t('tableShortage'),
      t('tableEstimatedCost'),
      t('tableOrderPrice'),
    ].map((heading) => elt('th', { text: heading }))));

rows.forEach((row) => {
      const shortage = row.shortage === null ? '-' : row.shortage.toLocaleString();
      let estimatedCost = row.shortage > 0 ? t('estimateUnavailable') : formatMoney(0);
      let estimateTitle = '';
      if (Number.isFinite(row.estimatedDirectCost)) {
        estimatedCost = formatMoney(row.estimatedDirectCost);
        const range = row.estimatedLowestBatchPrice === row.estimatedHighestBatchPrice
          ? `${row.estimatedLowestBatchPrice} C`
          : `${row.estimatedLowestBatchPrice}-${row.estimatedHighestBatchPrice} C`;
        estimateTitle = range;
        if (row.guaranteedBatches) {
          estimateTitle += ` / ${t('estimateUsesSupply', { batches: row.guaranteedBatches.toLocaleString() })}`;
        }
      }
      const tr = elt('tr', { class: row.shortage > 0 ? 'hvmepp-shortage' : '' }, [
        elt('td', { text: row.label }),
        elt('td', { text: row.required.toLocaleString() }),
        elt('td', { text: row.stock === null ? t('stockUnknown') : row.stock.toLocaleString() }),
        elt('td', { text: shortage }),
        elt('td', { text: estimatedCost, title: estimateTitle }),
        elt('td', {}, elt('input', {
          id: `hvmepp-order-price-${row.attr}`,
          type: 'number',
          min: 1,
          step: 1,
          value: row.orderBatchPrice || '',
          disabled: !row.batchSize,
          title: row.label,
        })),
      ]);
      table.appendChild(tr);
    });
    card.appendChild(table);

const estimateSummary = getPurchaseEstimateSummary(rows);
    if (estimateSummary) {
      card.appendChild(elt('div', {
        class: 'hvmepp-estimate-summary',
        text: t('estimateSummary', {
          cost: formatMoney(estimateSummary.estimatedCost),
          balance: formatMoney(estimateSummary.requiredStartingBalance),
        }),
      }));
    }

const actions = elt('div', { class: 'hvmepp-controls hvmepp-result-actions' });
    const stockButton = renderButton('hvmepp-load-stock', 'buttonLoadStock');
    const directButton = renderButton('hvmepp-direct-buy', 'buttonDirectBuy');
    const orderButton = renderButton('hvmepp-place-buy-orders', 'buttonPlaceBuyOrders');

bindManagedAction(stockButton, 'buttonLoadStock', 'statusFetchPriceFailed', refreshMarketSnapshot);
    bindManagedAction(directButton, 'buttonDirectBuy', 'statusPurchaseFailed',
      (managedButton) => executeCrystalPurchase('direct', managedButton));
    bindManagedAction(orderButton, 'buttonPlaceBuyOrders', 'statusPurchaseFailed',
      (managedButton) => executeCrystalPurchase('order', managedButton));

actions.append(stockButton, directButton, orderButton);
    card.appendChild(actions);
    return card;
  }

function renderPlan(plan, crystalRows = null) {
    const box = $('#hvmepp-result');
    if (!box) return;
    const fragment = document.createDocumentFragment();

if (!plan || plan.message) {
      fragment.appendChild(elt('div', { class: 'hvmepp-alert', text: plan?.message || t('errorNoValidPlan') }));
      replacePlanContent(box, fragment);
      return;
    }

fragment.appendChild(elt('div', { class: 'hvmepp-total' }, [
      `${t('totalMonsters')} `,
      elt('span', { class: 'hvmepp-good', text: String(plan.monsterCount) }),
      `   ${t('totalCost')} `,
      elt('span', { class: 'hvmepp-good', text: formatMoney(plan.totalCost) }),
    ]));

const rows = crystalRows || getCrystalPlanRows(plan);
    fragment.appendChild(renderCrystalPlan(plan, rows));

if (plan.ok) {
      const requests = plan.results.flatMap((result) => buildUpgradeRequests(result, result.monsterSlot));
      const executable = plan.results.every((result) => /^\d+$/.test(result.monsterSlot));
      if (requests.length && executable) {
        const runButton = renderButton('hvmepp-run-upgrade', 'buttonRunUpgrade');
        bindManagedAction(runButton, 'buttonRunUpgrade', 'statusUpgradeFailed',
          (managedButton) => executeBatchUpgradePlan(plan, managedButton));
        fragment.appendChild(elt('div', { class: 'hvmepp-controls hvmepp-result-actions' }, [runButton]));
      }
    }

plan.results.forEach((result) => {
      fragment.appendChild(renderSingleMonsterResult(result));
    });
    replacePlanContent(box, fragment);
  }

function replacePlanContent(box, fragment = null) {
    const panel = $('#hvmepp-panel');
    const scrollTop = panel?.scrollTop || 0;
    if (fragment) box.replaceChildren(fragment);
    else box.replaceChildren();
    box.removeAttribute('aria-busy');
    if (panel) panel.scrollTop = scrollTop;
  }

function calculate() {
    clearScheduledCalculation();
    readInputs();
    updateCurrentPL({ save: false });

const selected = getSelectedMonsterSlots();
    if (!selected.length) {
      clearCurrentPlan();
      return null;
    }

const monsters = getSelectedLoadedMonsters();
    if (monsters.length !== selected.length) {
      const invalidPlan = { message: t('errorMonstersNotLoaded') };
      runtime.lastPlan = null;
      renderPlan(invalidPlan);
      setStatus(invalidPlan.message);
      return invalidPlan;
    }

const plan = buildBatchPlan(monsters, Number(state.targetPL));
    runtime.lastPlan = plan;
    renderPlan(plan);
    return plan;
  }

function renderMonsterSelection(monsterList) {
    const card = elt('div', { class: 'hvmepp-card hvmepp-monster-select-card' });
    card.appendChild(elt('h3', {
      text: t('headingMonsterSelection'),
      dataset: { i18n: 'headingMonsterSelection' },
    }));

const toolbar = elt('div', { class: 'hvmepp-controls' });
    const selectAllButton = renderButton('hvmepp-select-all-monsters', 'buttonSelectAll');
    const clearButton = renderButton('hvmepp-clear-monsters', 'buttonClearSelection');
    selectAllButton.disabled = runtime.busy;
    clearButton.disabled = runtime.busy;
    toolbar.append(selectAllButton, clearButton, elt('span', { id: 'hvmepp-selection-summary' }));
    card.appendChild(toolbar);

const selected = new Set(state.selectedMonsterSlots.map(String));
    const validSlots = new Set(monsterList.map((monster) => String(monster.index)));
    if (query.slot) selected.add(String(query.slot));
    if (![...selected].some((slot) => validSlots.has(slot)) && validSlots.has(String(state.lastMonsterSlot))) {
      selected.add(String(state.lastMonsterSlot));
    }

selectAllButton.addEventListener('click', () => {
      if (runtime.busy) return;
      $all('.hvmepp-monster-check').forEach((checkbox) => { checkbox.checked = true; });
      syncMonsterSelection();
    });
    clearButton.addEventListener('click', () => {
      if (runtime.busy) return;
      $all('.hvmepp-monster-check').forEach((checkbox) => { checkbox.checked = false; });
      syncMonsterSelection();
    });

queueMicrotask(syncMonsterSelection);
    return card;
  }

function renderPanel() {
    let overlay = $('#hvmepp-overlay');

if (overlay) {
      overlay.classList.remove('hvmepp-hidden');
      const easterEgg = $('#hvmepp-easter-egg');
      if (easterEgg) easterEgg.textContent = randomEasterEgg();
      refreshLocalizedText();
      return;
    }

overlay = elt('div', { id: 'hvmepp-overlay' });

const panel = elt('div', { id: 'hvmepp-panel' });
    overlay.appendChild(panel);

panel.appendChild(renderLanguageSwitcher());

const easterEgg = elt('button', {
      id: 'hvmepp-easter-egg',
      class: 'hvmepp-easter-egg',
      type: 'button',
      text: randomEasterEgg(),
      title: 'Click to refresh',
    });
    easterEgg.addEventListener('click', () => {
      easterEgg.textContent = randomEasterEgg(easterEgg.textContent);
    });

const closeButton = elt('button', { text: '×', class: 'hvmepp-close' });
    const title = elt('div', { class: 'hvmepp-title' }, [
      elt('span', { text: t('plannerTitle'), dataset: { i18n: 'plannerTitle' } }),
      elt('div', { class: 'hvmepp-title-actions' }, [
        easterEgg,
        closeButton,
      ]),
    ]);

closeButton.addEventListener('click', () => {
      overlay.classList.add('hvmepp-hidden');
    });

panel.appendChild(title);

panel.appendChild(elt('div', {
      id: 'hvmepp-live',
      class: 'hvmepp-live',
    }));

const controls = elt('div', { class: 'hvmepp-controls' });

controls.appendChild(elt('label', {}, [
      elt('span', { text: t('labelTargetInput'), dataset: { i18n: 'labelTargetInput' } }),
      ' ',
      elt('input', {
        id: 'hvmepp-target',
        type: 'number',
        step: 0.5,
        value: state.targetPL,
      }),
    ]));

controls.appendChild(elt('label', {}, [
      elt('span', { text: t('labelPriceSource'), dataset: { i18n: 'labelPriceSource' } }),
      ' ',
      renderPriceSourceSelect('hvmepp-source', state.priceSource),
    ]));

controls.appendChild(renderButton('hvmepp-fetch-price', 'buttonFetchPrice'));
    controls.appendChild(renderButton('hvmepp-load-monster', 'buttonLoadMonster'));

panel.appendChild(controls);

runtime.monsterList = parseMonsterList();
    if (query.slot && !runtime.monsterList.some((monster) => String(monster.index) === String(query.slot))) {
      const currentLevels = parseMonsterLevelsFromDoc(document);
      runtime.monsterList.push({
        index: String(query.slot),
        name: $('.msl > div:nth-child(2)')?.textContent?.trim() || t('monsterFallback', { slot: query.slot }),
        pl: currentLevels ? totalPL(currentLevels) : 0,
      });
    }

if (runtime.monsterList.length) {
      panel.appendChild(renderMonsterSelection(runtime.monsterList));
    }

panel.appendChild(elt('div', {
      id: 'hvmepp-status',
      class: 'hvmepp-status',
    }));

panel.appendChild(elt('div', {
      id: 'hvmepp-result',
    }));

document.body.appendChild(overlay);

$('#hvmepp-target').addEventListener('input', () => scheduleCalculation(80));

$('#hvmepp-source').addEventListener('change', () => {
      readInputs({ save: false });
      const result = applyCalculationPriceSource();
      scheduleCalculation();
      setStatus(result.failed.length
        ? t('statusSavedPriceSourcePartial', {
          source: priceSourceLabel(state.priceSource),
          updated: result.updated,
          failed: joinList(result.failed),
        })
        : t('statusSavedPriceSource', { source: priceSourceLabel(state.priceSource) }));
    });

bindManagedAction($('#hvmepp-fetch-price'), 'buttonFetchPrice', 'statusFetchPriceFailed', refreshMarketSnapshot);
    bindManagedAction($('#hvmepp-load-monster'), 'buttonLoadMonster', 'statusLoadMonsterFailed', async () => {
      if (query.slot && readCurrentMonsterIfAny()) return;
      await loadSelectedMonsters();
    });

readCurrentMonsterIfAny({ recalculate: false });
    updateCurrentPL({ save: false });
  }

function findPowerLevelCalculatorButton(side) {
    const nodes = $all('input[type="button"], button', side);

return nodes.find((n) => {
      const label = (n.value || n.textContent || '').trim();
      return label === 'Power Level Calculator';
    });
  }

function createEntryButton() {
    const btn = elt('input', {
      id: 'hvmepp-entry',
      type: 'button',
      value: t('plannerTitle'),
      dataset: { i18nValue: 'plannerTitle' },
    });

btn.addEventListener('click', renderPanel);
    return btn;
  }

function getOrCreateEntrySide(createFallback = false) {
    const hvutSide = $('.hvut-ml-side');
    if (hvutSide) return hvutSide;

if (!createFallback) return null;

const monsterOuter = $('#monster_outer');
    const host = monsterOuter || $('#mainpane') || document.body;
    const side = elt('div', {
      class: monsterOuter
        ? 'hvmepp-side-fallback'
        : 'hvmepp-side-fallback hvmepp-side-fallback-static',
    });

if (monsterOuter) {
      monsterOuter.classList.add('hvmepp-ml-host-fallback');
    } else if (host && getComputedStyle(host).position === 'static') {
      host.style.position = 'relative';
    }

host.appendChild(side);

if (monsterOuter) {
      requestAnimationFrame(() => clampFallbackSide(side));
      window.addEventListener('resize', () => clampFallbackSide(side));
    }

return side;
  }

function clampFallbackSide(side) {
    if (getComputedStyle(side).position !== 'absolute') {
      side.style.left = '';
      return;
    }

side.style.left = '';
    const rect = side.getBoundingClientRect();
    const min = 8;
    const max = window.innerWidth - 8;
    let left = parseFloat(getComputedStyle(side).left) || 0;

if (rect.left < min) {
      left += min - rect.left;
    } else if (rect.right > max) {
      left -= rect.right - max;
    } else {
      return;
    }

side.style.left = `${Math.round(left)}px`;
  }

function mountEntryButton(createFallback = false) {
    if ($('#hvmepp-entry')) return true;

const side = getOrCreateEntrySide(createFallback);
    if (!side) return false;

const btn = createEntryButton();

const plcButton = findPowerLevelCalculatorButton(side);

if (plcButton) {
      plcButton.insertAdjacentElement('afterend', btn);
    } else {
      side.appendChild(btn);
    }

return true;
  }

function scheduleEntryButton() {
    let fallbackTimer = null;
    let observer = null;

function cleanup() {
      if (fallbackTimer) clearTimeout(fallbackTimer);
      if (observer) observer.disconnect();
    }

if (mountEntryButton()) return;

observer = new MutationObserver(() => {
      if (mountEntryButton()) {
        cleanup();
      }
    });

observer.observe(document.body, { childList: true, subtree: true });

fallbackTimer = setTimeout(() => {
      mountEntryButton(true);
      cleanup();
    }, 3000);
  }

GM_addStyle(`
    #hvmepp-entry {
      cursor: pointer;
      display: block;
      box-sizing: border-box;
    }

.hvmepp-ml-host-fallback {
      margin-left: 150px;
      position: relative;
    }

.hvmepp-side-fallback {
      position: absolute;
      top: 38px;
      left: -110px;
      width: 100px;
      display: flex;
      flex-direction: column;
      z-index: 10;
    }

.hvmepp-side-fallback input {
      margin: 3px 0;
      padding: 1px;
      white-space: normal;
    }

.hvmepp-side-fallback-static {
      position: static;
      width: 100px;
      margin: 4px 0;
    }

#hvmepp-overlay {
      position: fixed;
      inset: 0;
      z-index: 9999;
      background: rgba(0,0,0,.45);
      display: flex;
      align-items: flex-start;
      justify-content: center;
      box-sizing: border-box;
      padding: 8px;
      color: #222;
    }

#hvmepp-overlay.hvmepp-hidden {
      display: none;
    }

#hvmepp-panel {
      width: min(1120px, calc(100vw - 16px));
      max-height: calc(100vh - 16px);
      overflow: auto;
      overflow-anchor: none;
      background: #EDEBDF;
      border: 1px solid #5C0D11;
      padding: 8px;
      box-shadow: 0 6px 20px rgba(0,0,0,.35);
      font: 9pt/1.25 Arial, sans-serif;
      text-align: left;
      box-sizing: border-box;
    }

.hvmepp-lang-switch {
      display: flex;
      justify-content: center;
      align-items: center;
      gap: 6px;
      margin: 0 32px 5px;
    }

.hvmepp-lang-switch button {
      min-width: 76px;
      padding: 2px 8px;
      border: 1px solid #8f806c;
      background: #f7f1d9;
      cursor: pointer;
      font: inherit;
    }

.hvmepp-lang-switch button.hvmepp-lang-active {
      border-color: #5C0D11;
      background: #edb;
      font-weight: bold;
    }

.hvmepp-title {
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-weight: bold;
      font-size: 11pt;
      margin-bottom: 4px;
    }

.hvmepp-title-actions {
      display: flex;
      align-items: center;
      gap: 8px;
    }

.hvmepp-easter-egg {
      padding: 0;
      border: 0;
      background: none;
      color: #7a5a3a;
      cursor: pointer;
      font-family: inherit;
      font-size: 9pt;
      font-weight: normal;
      white-space: nowrap;
    }

.hvmepp-close {
      width: 24px;
      height: 22px;
      cursor: pointer;
    }

.hvmepp-live,
    .hvmepp-status {
      margin: 4px 0;
      padding: 4px 6px;
      background: #fff8;
      border: 1px solid #b9aa99;
    }

.hvmepp-controls {
      display: flex;
      flex-wrap: wrap;
      gap: 4px 8px;
      align-items: center;
      margin: 5px 0;
    }

.hvmepp-controls input,
    .hvmepp-controls select {
      font-size: 9pt;
    }

.hvmepp-controls button {
      cursor: pointer;
      font: inherit;
      padding: 2px 6px;
    }

.hvmepp-card {
      border: 1px solid #b9aa99;
      background: #fff8;
      padding: 5px;
    }

.hvmepp-card h3 {
      margin: 0 0 4px;
      font-size: 10pt;
    }

.hvmepp-monster-select-card,
    .hvmepp-crystal-card {
      margin: 6px 0;
    }

.hvmepp-monster-checklist {
      display: grid;
      grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
      gap: 2px 8px;
      max-height: 170px;
      overflow: auto;
      padding: 4px;
      border: 1px solid #b9aa99;
      background: #fff8;
    }

.hvmepp-monster-checklist label {
      display: flex;
      align-items: center;
      gap: 4px;
      min-width: 0;
      white-space: nowrap;
    }

.hvmepp-monster-checklist label span {
      overflow: hidden;
      text-overflow: ellipsis;
    }

.hvmepp-table {
      width: 100%;
      border-collapse: collapse;
      margin: 4px 0;
      table-layout: fixed;
      font-size: 9pt;
    }

.hvmepp-table th,
    .hvmepp-table td {
      border: 1px solid #b9aa99;
      padding: 2px 3px;
      text-align: center;
      word-break: keep-all;
    }

.hvmepp-table th {
      background: #edb;
    }

.hvmepp-table input {
      width: 58px;
      text-align: right;
      box-sizing: border-box;
    }

.hvmepp-total {
      margin: 5px 0;
      padding: 5px 6px;
      border: 1px solid #b9aa99;
      background: #fff;
      line-height: 1.4;
      font-weight: bold;
    }

.hvmepp-monster-result {
      margin: 5px 0;
      border: 1px solid #b9aa99;
      background: #fff8;
    }

.hvmepp-monster-result > summary {
      padding: 5px 6px;
      cursor: pointer;
      font-weight: bold;
      background: #edb;
    }

.hvmepp-monster-result > .hvmepp-table,
    .hvmepp-monster-result > .hvmepp-alert {
      width: calc(100% - 8px);
      margin: 4px;
    }

.hvmepp-crystal-table td:first-child,
    .hvmepp-crystal-table th:first-child {
      width: 230px;
      text-align: left;
    }

.hvmepp-crystal-table td:last-child,
    .hvmepp-crystal-table th:last-child {
      width: 105px;
    }

.hvmepp-crystal-table td:last-child input {
      width: 96px;
    }

.hvmepp-crystal-price-controls {
      margin: 2px 0 4px;
    }

.hvmepp-estimate-summary {
      margin: 4px 0;
      padding: 5px 6px;
      border: 1px solid #8f806c;
      background: #fffbe8;
      line-height: 1.4;
      font-weight: bold;
    }

.hvmepp-shortage {
      color: #b00020;
      background: #fff2f2;
      font-weight: bold;
    }

.hvmepp-good {
      color: #006400;
      font-weight: bold;
    }

.hvmepp-alert {
      margin: 5px 0;
      padding: 5px 6px;
      border: 1px solid #b00020;
      color: #b00020;
      background: #fff2f2;
      font-weight: bold;
    }

.hvmepp-upgraded {
      background: #f4fff4;
    }

@media (max-width: 900px) {
      #hvmepp-panel {
        width: calc(100vw - 10px);
        max-height: calc(100vh - 10px);
        padding: 6px;
      }

.hvmepp-lang-switch {
        margin: 0 28px 4px;
        gap: 4px;
      }

.hvmepp-lang-switch button {
        min-width: 68px;
        padding: 2px 4px;
      }

.hvmepp-table input {
        width: 50px;
      }

.hvmepp-side-fallback {
        position: static;
        margin: 4px 0;
      }

.hvmepp-ml-host-fallback {
        margin-left: 0;
      }
    }
  `);

scheduleEntryButton();
})();