@kar-mi/spirit-vale-tools-character 0.5.0

package/dist/index.js

@@ -0,0 +1,1290 @@
+// @bun
+// src/decoder.ts
+import { characterDataParameter, CURRENT_GAME_BUILD_FINGERPRINT, decodeFieldRun } from "@kar-mi/spirit-vale-tools-capture";
+import { readSignedPackedWhole } from "@kar-mi/spirit-vale-tools-capture/wire-reader";
+import { resolveFishNetItem } from "@kar-mi/spirit-vale-tools-items";
+import { resolveFishNetSkill } from "@kar-mi/spirit-vale-tools-skills";
+
+// src/stat-names.ts
+var STAT_NAMES = {
+  0: "STR",
+  1: "VIT",
+  2: "AGI",
+  3: "DEX",
+  4: "INT",
+  5: "LUK",
+  6: "All stats",
+  7: "HP",
+  8: "MP",
+  9: "ATK",
+  10: "MATK",
+  11: "DEF",
+  12: "MDEF",
+  13: "Hit",
+  14: "Flee",
+  15: "Critical chance",
+  16: "Flat DEF",
+  17: "Flat MDEF",
+  18: "Weapon element",
+  19: "Armor element",
+  20: "Health on hit",
+  21: "Mana on hit",
+  22: "Kill leech",
+  23: "Kill MP leech",
+  25: "Range",
+  26: "Status immunity",
+  39: "Autocast on hit",
+  40: "Autocast on attack",
+  41: "Autocast chance",
+  42: "Granted skill",
+  43: "Skill level",
+  44: "Damage to element",
+  45: "Damage to boss",
+  46: "Element damage",
+  47: "Melee damage",
+  48: "Magic damage",
+  49: "Skill damage",
+  50: "Skill cost",
+  51: "Skill cooldown",
+  52: "Critical damage",
+  53: "Element resistance",
+  54: "Weapon ATK",
+  55: "Weapon MATK",
+  56: "Damage from element",
+  57: "Damage from magic",
+  58: "Damage from melee",
+  59: "HP regeneration",
+  60: "Maximum HP regeneration",
+  61: "MP regeneration",
+  62: "Maximum MP regeneration",
+  63: "Attack speed",
+  64: "Cast speed",
+  65: "Move speed",
+  66: "After-cast delay",
+  67: "Healing",
+  69: "ATK multiplier",
+  70: "MATK multiplier",
+  71: "HP multiplier",
+  72: "MP multiplier",
+  73: "DEF multiplier",
+  74: "MDEF multiplier",
+  75: "HP regeneration multiplier",
+  76: "MP regeneration multiplier",
+  77: "Flee multiplier",
+  78: "Hit multiplier",
+  79: "Critical multiplier",
+  80: "Double attack",
+  81: "Energy shield",
+  82: "Cast while moving",
+  83: "Attack while casting",
+  84: "Spell echo",
+  85: "Block",
+  86: "Reflect damage",
+  87: "Dual wield",
+  88: "Experience rate",
+  89: "Drop rate",
+  90: "MP cost",
+  91: "Life bond",
+  92: "Summon stat share",
+  93: "Summon damage share",
+  94: "Spell reflect",
+  95: "Shield block",
+  96: "Wand range",
+  97: "Leech chance",
+  98: "Leech",
+  99: "MP leech chance",
+  100: "MP leech",
+  101: "Weight limit",
+  102: "Ranged damage",
+  103: "Damage from ranged",
+  104: "Skill cooldown",
+  113: "HP regeneration rate",
+  114: "MP regeneration rate",
+  120: "Critical defence",
+  121: "Perfect dodge",
+  142: "Status damage",
+  151: "MATK per STR",
+  152: "ATK per STR",
+  159: "Attack-speed multiplier",
+  160: "Cast-speed multiplier",
+  161: "Move-speed multiplier",
+  162: "Skill charges",
+  163: "Auto fire",
+  164: "Close-range damage",
+  165: "Far-range damage",
+  166: "Damage to summons",
+  167: "Damage from summons",
+  168: "Summon spell echo",
+  169: "Summon damage",
+  170: "Summon damage reduction",
+  171: "Summon leech",
+  172: "Summon cost share",
+  173: "Summon hit",
+  174: "Summon autoattack damage",
+  175: "Summon resistance",
+  176: "HP siphon",
+  177: "MP siphon",
+  178: "Healing share",
+  179: "Death share",
+  180: "Autocast on death",
+  181: "Autocast on kill",
+  182: "Cooldown recovery",
+  183: "Status max stacks",
+  184: "Two-handed stance bonus",
+  185: "Attack-speed limit",
+  186: "Autoattack MATK",
+  187: "Cast-time reduction",
+  188: "Cast-time reduction limit",
+  189: "Cast range",
+  190: "Dodge recovery",
+  191: "Flat attack speed",
+  192: "Threat multiplier",
+  193: "DEF pierce",
+  194: "MDEF pierce",
+  195: "Perfect hit",
+  196: "Healing to barrier",
+  197: "Skill pull",
+  198: "Skill damage at low HP",
+  199: "Skill range",
+  200: "Skill instances",
+  201: "Skill critical chance",
+  202: "Skill leap",
+  203: "Skill threat",
+  204: "Skill cast-time multiplier",
+  205: "Skill-hits multiplier",
+  206: "Skill-duration multiplier",
+  207: "Skill damage received",
+  208: "Skill damage vs. status",
+  209: "Skill replacement",
+  210: "Status replacement",
+  211: "Status duration",
+  212: "Skill max instances",
+  213: "Skill autocast",
+  214: "Skill applies status",
+  215: "Skill consumes status",
+  216: "Skill health recovery",
+  217: "Skill mana recovery",
+  218: "Damage vs. status",
+  219: "Set attack speed"
+};
+var PERCENT_STATS = new Set([44, 45, 46, 47, 48, 49, 52, 56, 57, 58, 63, 64, 65, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 86, 88, 89, 90, 97, 98, 99, 100, 102, 103, 104, 113, 114, 119, 121, 138, 139, 140, 142, 159, 160, 161, 164, 165, 166, 167, 169, 170, 171, 175, 182, 184, 187, 192, 201, 204, 205, 206, 207, 208]);
+
+// src/decoder.ts
+var ARCHETYPES = {
+  [-1]: "Novice",
+  0: "Warrior",
+  1: "Mage",
+  2: "Rogue",
+  3: "Knight",
+  4: "Summoner",
+  5: "Acolyte",
+  6: "Scout",
+  10: "Paladin",
+  11: "Dragon Knight",
+  12: "Berserker",
+  13: "Revenant",
+  14: "Priest",
+  15: "Monk",
+  16: "Wizard",
+  17: "Chronomancer",
+  18: "Druid",
+  19: "Warlock",
+  20: "Assassin",
+  21: "Shinobi",
+  22: "Gunslinger",
+  23: "Ranger",
+  24: "Jester",
+  25: "Nightshade",
+  26: "Necromancer",
+  27: "Spellblade",
+  28: "Blade Master",
+  29: "Mechanist",
+  30: "Alchemist",
+  31: "Weaver"
+};
+var ARCHETYPE_IDS = new Map(Object.entries(ARCHETYPES).map(([id, name]) => [name, Number(id)]));
+var EQUIP_SLOTS = ["Main hand", "Off hand", "Head", "Legs", "Feet", "Chest", "Left accessory", "Right accessory", "Eyewear", "Back"];
+var ARTIFACT_SLOTS = ["Rune", "Jewel", "Scroll", "Relic"];
+var LOADOUTS = ["Normal", "Secondary", "Heavy"];
+function resolveCharacterArchetypeId(name) {
+  return ARCHETYPE_IDS.get(name);
+}
+function decodeCharacterRpcPayload(payload, includesUpdateType, now = new Date) {
+  let startOffset = 0;
+  let updateType = 327417855;
+  if (includesUpdateType) {
+    const decoded = readSignedPackedWhole(payload, 0);
+    updateType = decoded.value;
+    startOffset = decoded.nextOffset;
+  }
+  const run = decodeFieldRun(payload, [characterDataParameter()], startOffset);
+  const tree = buildFieldTree(run.fields);
+  const data = child(tree, "data");
+  if (!data)
+    throw new Error("CharacterData payload is null");
+  const name = leafString(data, "Name") ?? "Unknown character";
+  const title = leafString(data, "Title") || undefined;
+  const archetypeNames = listValues(data, "Archetypes").map((value) => ARCHETYPES[Number(value)] ?? "Unknown");
+  const level = leafNumber(data, "Level", 0);
+  const experience = leafNumber(data, "Exp", 0);
+  const jobLevel = leafNumber(data, "JobLevel", 0);
+  const jobExperience = leafNumber(data, "JobExp", 0);
+  const rawAttributes = listValues(data, "Attributes").map((value) => Number(value));
+  if (rawAttributes.length < 6)
+    throw new Error("CharacterData attributes are incomplete");
+  const attributes = {
+    STR: rawAttributes[0],
+    VIT: rawAttributes[1],
+    AGI: rawAttributes[2],
+    DEX: rawAttributes[3],
+    INT: rawAttributes[4],
+    LUK: rawAttributes[5]
+  };
+  for (const [label, value] of Object.entries(attributes)) {
+    if (!Number.isInteger(value) || value < 0 || value > 1e5)
+      throw new Error(`invalid ${label} attribute`);
+  }
+  const equipped = listItems(data, "Equips", (item) => readEquipmentSlot(item)).filter((value) => value !== undefined);
+  const activeIndex = leafNumber(data, "ActiveLoadout", 0);
+  const loadouts = [
+    listItems(data, "LoadoutNormal", (item) => readEquipmentSlot(item)).filter((value) => value !== undefined),
+    listItems(data, "LoadoutSecondary", (item) => readEquipmentSlot(item)).filter((value) => value !== undefined),
+    listItems(data, "LoadoutHeavy", (item) => readEquipmentSlot(item)).filter((value) => value !== undefined)
+  ];
+  const artifacts = listItems(data, "Artifacts", (item) => readArtifactData(item)).filter((value) => value !== undefined);
+  const equipment = loadouts[activeIndex]?.length ? loadouts[activeIndex] : equipped;
+  const { skills, currentWeight, ...history } = readCharacterHistory(data, run.complete, equipped, artifacts);
+  return {
+    updateType,
+    ...currentWeight === undefined ? {} : { currentWeight },
+    snapshot: {
+      schemaVersion: 1,
+      buildFingerprint: CURRENT_GAME_BUILD_FINGERPRINT,
+      name,
+      ...title ? { title } : {},
+      archetypes: archetypeNames,
+      level,
+      experience,
+      jobLevel,
+      jobExperience,
+      attributes,
+      activeLoadout: LOADOUTS[activeIndex] ?? "Normal",
+      equipment,
+      artifacts,
+      ...loadouts.some((set) => set.length) ? { loadouts } : {},
+      skills,
+      ...history,
+      updatedAt: now.toISOString(),
+      source: "live"
+    }
+  };
+}
+function readEquipmentSlot(node) {
+  if (!node)
+    return;
+  const slotIndex = leafNumber(node, "Slot", -1);
+  return readEquipmentData(child(node, "Equip"), slotIndex);
+}
+function readEquipmentData(node, slotIndex) {
+  if (!node)
+    return;
+  const rawStats = listItems(node, "Substats", (item) => readRawSubstat(item));
+  const cardsBySlot = listValues(node, "Cards").map((value) => typeof value === "string" && value ? value : null);
+  const cards = cardsBySlot.filter((value) => Boolean(value));
+  const chaosType = leafNumber(node, "ChaosType", -1);
+  const refine = leafNumber(node, "Refine", 0);
+  const itemId = leafString(node, "Id") ?? "Unknown equipment";
+  const substatGroup = resolveFishNetItem(2, itemId)?.substatGroup;
+  const substats = rawStats.flatMap((stat, index) => stat ? [convertSubstat(stat.type, stat.roll, slotIndex, false, substatGroup, { index, qualifier: stat.valueStr })] : []);
+  return { slot: EQUIP_SLOTS[slotIndex] ?? `Slot ${slotIndex}`, itemId, refine, cards, substats, chaosType, cardsBySlot };
+}
+function readArtifactData(node) {
+  if (!node)
+    return;
+  const rawStats = listItems(node, "Substats", (item) => readRawSubstat(item));
+  const slotIndex = leafNumber(node, "Slot", -1);
+  const gems = listItems(node, "Gems", (item) => readRefinableItem(item)).filter((value) => value !== undefined);
+  const refine = leafNumber(node, "Refine", 0);
+  const itemId = leafString(node, "Id") ?? "Unknown artifact";
+  const substats = rawStats.flatMap((stat, index) => stat ? [convertSubstat(stat.type, stat.roll, slotIndex, true, undefined, { index, qualifier: stat.valueStr })] : []);
+  return { slot: ARTIFACT_SLOTS[slotIndex] ?? `Artifact ${slotIndex}`, itemId, refine, gems, substats };
+}
+function readCharacterHistory(data, decodeComplete, equipped, artifacts) {
+  if (!decodeComplete)
+    return { skills: [] };
+  const equippedWeight = equipped.reduce((total, item) => total + equipmentWeight(item.itemId), 0) + artifacts.length * 10;
+  try {
+    const { skills, assigned } = readSkillSystem(child(data, "Skills"));
+    const grimoires = listItems(data, "Grimoires", (item) => readEquipmentData(item, -1)).map((item, index) => item ? { ...item, slot: `Grimoire ${index + 1}` } : undefined).filter((item) => item !== undefined);
+    let inventoryWeight = 0;
+    const inventory = child(data, "Inventory");
+    if (inventory) {
+      dictionaryValues(inventory, "Equips", (item) => {
+        const equip = readEquipmentData(item, -1);
+        if (equip)
+          inventoryWeight += equipmentWeight(equip.itemId);
+      });
+      dictionaryValues(inventory, "Artifacts", (item) => {
+        if (readArtifactData(item))
+          inventoryWeight += 10;
+      });
+      dictionaryValues(inventory, "Cards", (item) => {
+        inventoryWeight += readStackableCount(item);
+      });
+      dictionaryValues(inventory, "Gems", (item) => {
+        readRefinableItem(item);
+      });
+      dictionaryValues(inventory, "Junks", (item) => {
+        inventoryWeight += readStackableCount(item);
+      });
+      dictionaryValues(inventory, "Consumables", (item) => {
+        inventoryWeight += readStackableCount(item);
+      });
+      dictionaryValues(inventory, "Cosmetics", () => {
+        return;
+      });
+    }
+    const playtimeSeconds = leafInt64Number(data, "Playtime", 0);
+    const monsterKills = leafNumber(data, "MonsterKills", 0);
+    const bossKills = leafNumber(data, "BossKills", 0);
+    const deaths = leafNumber(data, "Deaths", 0);
+    return {
+      skills,
+      ...assigned.length ? { assignedSkills: assigned } : {},
+      grimoires,
+      currentWeight: equippedWeight + inventoryWeight,
+      playtimeSeconds,
+      monsterKills,
+      bossKills,
+      deaths
+    };
+  } catch {
+    return { skills: [] };
+  }
+}
+function readSkillSystem(node) {
+  if (!node)
+    return { skills: [], assigned: [] };
+  const allocated = listItems(node, "Skills", (item) => readSkill(item));
+  const assigned = listItems(node, "Assigned", (item) => readSkill(item));
+  const copy = readSkill(child(node, "SkillCopy"));
+  if (copy)
+    allocated.push(copy);
+  const unique = new Map;
+  for (const skill of allocated) {
+    if (!skill)
+      continue;
+    const existing = unique.get(skill.id);
+    if (!existing || skill.level > existing.level)
+      unique.set(skill.id, skill);
+  }
+  return {
+    skills: [...unique.values()].sort((left, right) => left.displayName.localeCompare(right.displayName)),
+    assigned: assigned.filter((skill) => skill !== undefined)
+  };
+}
+function readSkill(node) {
+  if (!node)
+    return;
+  const id = leafString(node, "Id");
+  const level = leafNumber(node, "Level", -1);
+  if (!id || level < 0)
+    return;
+  const definition = resolveFishNetSkill(id);
+  return {
+    id,
+    displayName: definition?.displayName ?? id,
+    level,
+    effects: (definition?.effects ?? []).map((effect) => ({
+      type: effect.type,
+      label: effect.label ?? STAT_NAMES[effect.type] ?? `Stat ${effect.type}`,
+      value: effect.value + (effect.valuePerLevel ?? 0) * level,
+      percent: PERCENT_STATS.has(effect.type)
+    }))
+  };
+}
+function readStackableCount(node) {
+  if (!node)
+    return 0;
+  return Math.max(0, leafNumber(node, "Count", 0));
+}
+function readRefinableItem(node) {
+  if (!node)
+    return;
+  const refine = leafNumber(node, "Refine", 0);
+  const id = leafString(node, "Id") ?? undefined;
+  return id ? { id, refine } : undefined;
+}
+function equipmentWeight(itemId) {
+  return resolveFishNetItem(2, itemId)?.weight ?? 10;
+}
+function readRawSubstat(node) {
+  if (!node)
+    return;
+  const type = leafNumber(node, "Type", 0);
+  const roll = leafNumber(node, "Value", 0);
+  const valueStr = leafString(node, "ValueStr") ?? "";
+  return { type, roll, valueStr };
+}
+function rescaleSubstats(snapshot, resolveItem = resolveFishNetItem) {
+  return {
+    ...snapshot,
+    equipment: snapshot.equipment.map((item) => {
+      const substatGroup = resolveItem(2, item.itemId)?.substatGroup;
+      const slotIndex = equipSlotIndex(item.slot);
+      return { ...item, substats: item.substats.map((stat) => convertSubstat(stat.type, stat.roll, slotIndex, false, substatGroup, stat)) };
+    }),
+    artifacts: snapshot.artifacts.map((item) => ({
+      ...item,
+      substats: item.substats.map((stat) => convertSubstat(stat.type, stat.roll, ARTIFACT_SLOTS.indexOf(item.slot), true, undefined, stat))
+    }))
+  };
+}
+function equipSlotIndex(slot) {
+  const index = EQUIP_SLOTS.indexOf(slot);
+  if (index >= 0)
+    return index;
+  const parsed = /^Slot (-?\d+)$/.exec(slot);
+  return parsed ? Number(parsed[1]) : -1;
+}
+function convertSubstat(type, roll, slot, artifact, substatGroup, positional) {
+  const name = STAT_NAMES[type] ?? `Stat ${type}`;
+  const cap = substatCap(type, slot, artifact, substatGroup);
+  const value = cap === undefined ? undefined : roundAwayFromZero(cap * (2 / 3 + roll / 300));
+  return {
+    type,
+    name,
+    roll,
+    ...value === undefined ? {} : { value },
+    percent: PERCENT_STATS.has(type),
+    ...positional?.qualifier ? { qualifier: positional.qualifier } : {},
+    ...positional?.index === undefined ? {} : { index: positional.index }
+  };
+}
+function substatCap(type, slot, artifact, substatGroup) {
+  if (type >= 0 && type <= 5)
+    return 3;
+  if (artifact)
+    return { 69: 2, 70: 2, 71: 2, 72: 2 }[type];
+  const weaponCaps = {
+    Magic: { 69: 5, 70: 5, 47: 5, 48: 5, 64: 10, 90: -10, 63: 10, 9: 5, 10: 5, 182: 10, 67: 10, 189: 1 },
+    Melee: { 69: 5, 70: 5, 47: 5, 48: 5, 15: 10, 13: 20, 63: 10, 9: 5, 10: 5, 52: 10, 98: 5, 130: 1, 80: 20 },
+    Ranged: { 69: 5, 70: 5, 102: 5, 48: 5, 15: 10, 13: 20, 63: 10, 9: 5, 10: 5, 52: 10, 98: 5, 25: 1, 80: 20 }
+  };
+  const weaponCap = substatGroup ? weaponCaps[substatGroup]?.[type] : undefined;
+  if (weaponCap !== undefined)
+    return weaponCap;
+  const caps = {
+    2: { 69: 2, 70: 2, 71: 2, 72: 2, 9: 3, 10: 3, 11: 5, 12: 5 },
+    3: { 75: 25, 76: 25, 98: 5, 64: 10, 14: 15, 121: 5, 90: -10 },
+    4: { 63: 10, 65: 10, 64: 10, 185: 1 },
+    5: { 71: 10, 72: 10, 11: 10, 12: 10, 73: 5, 74: 5, 58: -5, 57: -5, 68: 10, 121: 5 },
+    6: { 71: 2, 72: 2, 69: 2, 70: 2, 15: 5, 13: 10, 63: 5 },
+    7: { 71: 2, 72: 2, 69: 2, 70: 2, 15: 5, 13: 10, 63: 5 },
+    8: { 71: 2, 72: 2, 69: 2, 70: 2, 9: 3, 10: 3, 11: 5, 12: 5 },
+    9: { 71: 2, 72: 2, 69: 2, 70: 2, 15: 5, 13: 10, 63: 5 }
+  };
+  return caps[slot]?.[type];
+}
+function roundAwayFromZero(value) {
+  return value < 0 ? -Math.round(-value) : Math.round(value);
+}
+function buildFieldTree(fields) {
+  const root = {};
+  for (const field of fields) {
+    setFieldPath(root, parseFieldPath(field.name), field.value);
+  }
+  return root;
+}
+function parseFieldPath(name) {
+  const path = [];
+  for (const segment of name.split(".")) {
+    const match = /^(.+)\[(\d+)\]$/.exec(segment);
+    if (match)
+      path.push(match[1], Number(match[2]));
+    else
+      path.push(segment);
+  }
+  return path;
+}
+function setFieldPath(root, path, value) {
+  let node = root;
+  for (let index = 0;index < path.length - 1; index += 1) {
+    const key = String(path[index]);
+    const existing = node[key];
+    if (!existing || typeof existing !== "object")
+      node[key] = {};
+    node = node[key];
+  }
+  node[String(path[path.length - 1])] = value;
+}
+function child(node, key) {
+  const value = node?.[key];
+  return value && typeof value === "object" ? value : undefined;
+}
+function leaf(node, key) {
+  return node?.[key];
+}
+function leafString(node, key) {
+  const value = leaf(node, key);
+  return typeof value === "string" ? value : null;
+}
+function leafNumber(node, key, fallback) {
+  const value = leaf(node, key);
+  return typeof value === "number" ? value : fallback;
+}
+function leafInt64Number(node, key, fallback) {
+  const value = leaf(node, key);
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value))
+    return Number(value);
+  return fallback;
+}
+function listLength(node, key) {
+  const value = child(node, key)?.["length"];
+  return typeof value === "number" ? value : 0;
+}
+function listItems(node, key, map) {
+  const length = listLength(node, key);
+  const container = child(node, key);
+  return Array.from({ length }, (_unused, index) => map(child(container, String(index)), index));
+}
+function listValues(node, key) {
+  const length = listLength(node, key);
+  const container = child(node, key);
+  return Array.from({ length }, (_unused, index) => container?.[String(index)]);
+}
+function dictionaryValues(node, key, visit) {
+  const length = listLength(node, key);
+  const container = child(node, key);
+  for (let index = 0;index < length; index += 1)
+    visit(child(container, String(index)));
+}
+// src/formulas.ts
+import { resolveFishNetItem as resolveFishNetItem2 } from "@kar-mi/spirit-vale-tools-items";
+import { resolveFishNetSkill as resolveFishNetSkill2 } from "@kar-mi/spirit-vale-tools-skills";
+var rounded = Math.round;
+var integer = Math.floor;
+var BASIC_SUBSTAT_TYPES = new Set([0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 13, 14, 15, 52, 65, 69, 70, 71, 72, 77, 78, 79, 120, 121]);
+var BASE_MOVE_SPEED = 7.5;
+function calculateCharacterStats(level, baseAttributes, substats = [], archetypes = []) {
+  const base = calculateBasicStats(level, baseAttributes, [], archetypes);
+  const total = calculateBasicStats(level, baseAttributes, substats, archetypes);
+  return total.map((stat, index) => ({ ...stat, tab: "basic", base: base[index].value, gear: stat.value - base[index].value }));
+}
+function aggregateGearSubstats(equipment, artifacts, resolveItem = resolveFishNetItem2) {
+  const totals = new Map;
+  for (const stat of materializeGearStats(equipment, artifacts, resolveItem)) {
+    const entry = totals.get(stat.type) ?? { type: stat.type, name: STAT_NAMES[stat.type] ?? stat.name, total: 0, percent: stat.percent, unresolvedRolls: 0 };
+    if (stat.value === undefined)
+      entry.unresolvedRolls += 1;
+    else
+      entry.total += stat.value;
+    totals.set(stat.type, entry);
+  }
+  return [...totals.values()].sort((left, right) => left.name.localeCompare(right.name) || left.type - right.type);
+}
+function materializeGearStats(equipment, artifacts, resolveItem = resolveFishNetItem2) {
+  const stats = [...equipment, ...artifacts].flatMap((item) => item.substats);
+  for (const item of equipment) {
+    stats.push(...itemEffects(2, item.itemId, item.refine, undefined, resolveItem));
+    for (const card of item.cards)
+      stats.push(...itemEffects(4, card, item.refine, undefined, resolveItem));
+  }
+  for (const artifact of artifacts) {
+    stats.push(...itemEffects(3, artifact.itemId, artifact.refine, artifact.slot, resolveItem));
+    for (const gem of artifact.gems)
+      stats.push(...itemEffects(5, gem.id, gem.refine, undefined, resolveItem));
+  }
+  const sets = new Map;
+  for (const artifact of artifacts)
+    sets.set(artifact.itemId, (sets.get(artifact.itemId) ?? 0) + 1);
+  for (const [itemId, pieces] of sets) {
+    const set = resolveItem(3, itemId)?.artifactSet;
+    if (!set)
+      continue;
+    stats.push(...effectsToStats(set.perPieceBase, 1), ...effectsToStats(set.perPiece, pieces));
+    if (pieces >= set.requiredPieces)
+      stats.push(...effectsToStats(set.fullSet, 1));
+  }
+  return stats;
+}
+function materializeSkillStats(skills, resolveSkill = resolveFishNetSkill2) {
+  return skills.flatMap((skill) => (resolveSkill(skill.id)?.effects ?? []).map((effect) => ({
+    type: effect.type,
+    name: effect.label ?? STAT_NAMES[effect.type] ?? `Stat ${effect.type}`,
+    roll: 0,
+    value: effect.value + (effect.valuePerLevel ?? 0) * skill.level,
+    percent: PERCENT_STATS.has(effect.type)
+  })));
+}
+function resolveCharacterHealingTraits(snapshot, resolveItem = resolveFishNetItem2, resolveSkill = resolveFishNetSkill2) {
+  const stats = [
+    ...materializeGearStats(snapshot.equipment, snapshot.artifacts, resolveItem),
+    ...materializeSkillStats(snapshot.skills, resolveSkill)
+  ];
+  return {
+    hasSiphonHealth: stats.some((stat) => stat.type === 176 && (stat.value ?? 0) > 0),
+    hasHealthLeech: stats.some((stat) => stat.type === 98 && (stat.value ?? 0) > 0)
+  };
+}
+function calculateWeightLimit(snapshot, resolveItem = resolveFishNetItem2, resolveSkill = resolveFishNetSkill2) {
+  const bonuses = [
+    ...materializeGearStats(snapshot.equipment, snapshot.artifacts, resolveItem),
+    ...materializeSkillStats(snapshot.skills, resolveSkill)
+  ].reduce((total, stat) => total + (stat.type === 101 ? stat.value ?? 0 : 0), 0);
+  return Math.round(2000 + snapshot.level * 30 + bonuses);
+}
+function itemEffects(itemType, itemId, refine, artifactSlot, resolveItem) {
+  const definition = resolveItem(itemType, itemId);
+  const slotEffects = artifactSlot && isArtifactSlot(artifactSlot) ? definition?.artifactSlotEffects?.[artifactSlot] ?? [] : [];
+  const slotRefineEffects = artifactSlot && isArtifactSlot(artifactSlot) ? definition?.artifactSlotRefineEffects?.[artifactSlot] ?? [] : [];
+  return [...effectsToStats(definition?.effects ?? [], 1), ...effectsToStats(slotEffects, 1), ...effectsToStats(definition?.refineEffects ?? [], refine), ...effectsToStats(slotRefineEffects, refine)];
+}
+function isArtifactSlot(value) {
+  return ["Rune", "Jewel", "Scroll", "Relic"].includes(value);
+}
+function effectsToStats(effects, multiplier) {
+  return effects.filter((effect) => effect.target === undefined).map((effect) => ({
+    type: effect.type,
+    name: STAT_NAMES[effect.type] ?? `Stat ${effect.type}`,
+    roll: 0,
+    value: effect.value * multiplier,
+    percent: PERCENT_STATS.has(effect.type)
+  }));
+}
+function calculateAdvancedGearStats(totals) {
+  return totals.filter((stat) => !BASIC_SUBSTAT_TYPES.has(stat.type)).map((stat) => ({
+    id: `gear-stat-${stat.type}`,
+    label: stat.name,
+    category: advancedCategory(stat.type),
+    tab: "advanced",
+    base: 0,
+    gear: stat.total,
+    value: stat.total,
+    ...stat.percent ? { unit: "%" } : {},
+    formula: "Gear-granted value (no base formula known)",
+    inputs: { Gear: stat.total, UnresolvedRolls: stat.unresolvedRolls }
+  }));
+}
+function calculateBasicStats(level, baseAttributes, substats, archetypes) {
+  const bonus = (type) => substats.reduce((total, stat) => total + (stat.type === type ? stat.value ?? 0 : 0), 0);
+  const STR = baseAttributes.STR + bonus(0), VIT = baseAttributes.VIT + bonus(1), AGI = baseAttributes.AGI + bonus(2);
+  const DEX = baseAttributes.DEX + bonus(3), INT = baseAttributes.INT + bonus(4), LUK = baseAttributes.LUK + bonus(5);
+  const meleeBase = STR * 1.5 + integer(DEX / 5) + integer(LUK / 5);
+  const rangedBase = DEX + integer(STR / 5) + integer(LUK / 5);
+  const magicBase = INT * 1.5 + integer(DEX / 5) + integer(LUK / 5);
+  const meleeAttack = rounded((meleeBase * (1 + integer(STR / 10) / 100) + bonus(9)) * (1 + bonus(69) / 100));
+  const rangedAttack = rounded((rangedBase * (1 + integer(DEX / 10) / 100) + bonus(9)) * (1 + bonus(69) / 100));
+  const magicAttack = rounded((magicBase * (1 + integer(INT / 10) / 100) + bonus(10)) * (1 + bonus(70) / 100));
+  const hit = rounded((level + DEX * 2 + integer(LUK / 3) + 25 + bonus(13)) * (1 + bonus(78) / 100));
+  const flee = rounded((20 + level + AGI + integer(LUK / 5) + integer(AGI / 10) * 3 + bonus(14)) * (1 + bonus(77) / 100));
+  const critChance = rounded((LUK / 3 + integer(LUK / 10) + bonus(15)) * (1 + bonus(79) / 100));
+  const critDamage = 120 + integer(LUK / 5) + bonus(52);
+  const critDefence = integer(LUK / 5) + bonus(120);
+  const perfectDodge = clamp(rounded(LUK / 10) + bonus(121), 0, 100);
+  const healthGrowth = ARCHETYPE_HEALTH_GROWTH[archetypes[0] ?? ""] ?? 0;
+  const cappedLevel = Math.min(level, 130);
+  const levelSum = cappedLevel * (cappedLevel + 1) / 2;
+  const maxHealth = Math.max(1, rounded(((200 + level * 10 + levelSum * healthGrowth) * (1 + VIT / 100) + bonus(7)) * (1 + bonus(71) / 100)));
+  const maxMana = Math.max(1, rounded(((45 + level * 5) * (1 + INT / 100) + bonus(8)) * (1 + bonus(72) / 100)));
+  const healthRegen = rounded(0.5 * (maxHealth / 200 + VIT / 5) * (2 + VIT / 100));
+  const manaRegen = rounded(0.5 * (maxMana / 100 + INT / 5) * (2 + INT / 100));
+  const moveSpeed = Math.round(BASE_MOVE_SPEED * (1 + bonus(65) / 100) * 1000) / 1000;
+  const statusResist = (label, value) => stat(`resist-${label.toLowerCase()}`, `${label} resistance`, "Defense", clamp(rounded(value * 2 / 3), 0, 100), "%", "clamp(round(attribute \xD7 2 / 3), 0, 100)", { attribute: value });
+  return [
+    stat("melee-attack", "Melee attack scaling", "Offense", meleeAttack, undefined, "round((attribute scaling + ATK) \xD7 (1 + ATK multiplier / 100))", { STR, DEX, LUK, ATK: bonus(9), AtkMult: bonus(69) }),
+    stat("ranged-attack", "Ranged attack scaling", "Offense", rangedAttack, undefined, "round((attribute scaling + ATK) \xD7 (1 + ATK multiplier / 100))", { STR, DEX, LUK, ATK: bonus(9), AtkMult: bonus(69) }),
+    stat("magic-attack", "Magic attack scaling", "Offense", magicAttack, undefined, "round((attribute scaling + MATK) \xD7 (1 + MATK multiplier / 100))", { INT, DEX, LUK, MATK: bonus(10), MatkMult: bonus(70) }),
+    stat("hit", "Hit", "Accuracy", hit, undefined, "round((level + DEX \xD7 2 + floor(LUK / 3) + 25 + Hit) \xD7 Hit multiplier)", { level, DEX, LUK, Hit: bonus(13), HitMult: bonus(78) }),
+    stat("flee", "Flee", "Accuracy", flee, undefined, "round((20 + level + AGI + floor(LUK / 5) + floor(AGI / 10) \xD7 3 + Flee) \xD7 Flee multiplier)", { level, AGI, LUK, Flee: bonus(14), FleeMult: bonus(77) }),
+    stat("crit-chance", "Critical chance", "Accuracy", critChance, "%", "round(LUK / 3 + floor(LUK / 10))", { LUK }),
+    stat("crit-damage", "Critical damage", "Accuracy", critDamage, "%", "120 + floor(LUK / 5)", { LUK }),
+    stat("crit-defence", "Critical defence", "Defense", critDefence, "%", "floor(LUK / 5)", { LUK }),
+    stat("perfect-dodge", "Perfect dodge", "Defense", perfectDodge, "%", "clamp(round(LUK / 10), 0, 100)", { LUK }),
+    statusResist("STR", STR),
+    statusResist("VIT", VIT),
+    statusResist("AGI", AGI),
+    statusResist("DEX", DEX),
+    statusResist("INT", INT),
+    statusResist("LUK", LUK),
+    stat("max-health", "Maximum HP", "Resources", maxHealth, undefined, "round(((200 + level \xD7 10 + capped level sum \xD7 archetype growth) \xD7 (1 + VIT / 100) + HP) \xD7 HP multiplier)", { level, VIT, LevelSum: levelSum, ArchetypeGrowth: healthGrowth, HP: bonus(7), HpMult: bonus(71) }),
+    stat("max-mana", "Maximum MP", "Resources", maxMana, undefined, "round((45 + level \xD7 5) \xD7 (1 + INT / 100))", { level, INT }),
+    stat("health-regen", "Base HP regeneration", "Recovery", healthRegen, undefined, "round(0.5 \xD7 (MaxHP / 200 + VIT / 5) \xD7 (2 + VIT / 100))", { MaxHP: maxHealth, VIT }),
+    stat("mana-regen", "Base MP regeneration", "Recovery", manaRegen, undefined, "round(0.5 \xD7 (MaxMP / 100 + INT / 5) \xD7 (2 + INT / 100))", { MaxMP: maxMana, INT }),
+    stat("move-speed", "Move speed", "Speed", moveSpeed, undefined, "7.5 \xD7 (1 + Move speed % / 100)", { MoveSpeedPct: bonus(65) })
+  ];
+}
+function advancedCategory(type) {
+  if ([63, 64, 65, 66, 104, 159, 160, 185, 187, 188].includes(type))
+    return "Speed";
+  if ([20, 21, 22, 23, 59, 60, 61, 62, 67, 75, 76, 97, 98, 99, 100, 113, 114, 176, 177].includes(type))
+    return "Sustain";
+  if ([11, 12, 16, 17, 26, 58, 73, 74, 86, 103].includes(type))
+    return "Mitigation";
+  return "Utility";
+}
+var ARCHETYPE_HEALTH_GROWTH = { Warrior: 1.3, Knight: 1, Rogue: 0.85, Scout: 0.75, Acolyte: 0.75, Summoner: 0.7, Mage: 0.5, Weaver: 0.5 };
+function stat(id, label, category, value, unit, formula, inputs) {
+  return { id, label, category, value, ...unit ? { unit } : {}, formula, inputs };
+}
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+// src/record-decoder.ts
+function decodeCharacterRecordSync(packet) {
+  if (packet.packetName !== "syncType" || packet.payload.length === 0)
+    return;
+  switch (packet.networkBehaviourType) {
+    case "HealthComponent": {
+      const values = readPackedPairs(packet.payload);
+      return recordUpdate({ currentHealth: values.get(0), maxHealth: values.get(1) });
+    }
+    case "SkillsComponent": {
+      const values = readPackedPairs(packet.payload);
+      return recordUpdate({ currentMana: values.get(0), maxMana: values.get(1) });
+    }
+    case "MoveComponent":
+      return recordUpdate({ moveSpeed: readMoveSpeed(packet.payload) });
+    default:
+      return;
+  }
+}
+function decodeCharacterSpawnRecords(entries) {
+  if (!entries)
+    return;
+  const update = {};
+  for (const entry of entries) {
+    const value = entry.fields.find((field) => field.name === entry.name)?.value;
+    if (typeof value !== "number")
+      continue;
+    if (entry.networkBehaviourType === "HealthComponent") {
+      if (entry.name === "healthSync")
+        update.currentHealth = value;
+      else if (entry.name === "maxHealthSync")
+        update.maxHealth = value;
+    } else if (entry.networkBehaviourType === "SkillsComponent") {
+      if (entry.name === "manaSync")
+        update.currentMana = value;
+      else if (entry.name === "maxManaSync")
+        update.maxMana = value;
+    } else if (entry.networkBehaviourType === "MoveComponent" && entry.name === "MoveSpeed") {
+      update.moveSpeed = value;
+    }
+  }
+  return recordUpdate(update);
+}
+function recordUpdate(update) {
+  const entries = Object.entries(update).filter(([, value]) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1e8);
+  return entries.length === 0 ? undefined : Object.fromEntries(entries);
+}
+function readPackedPairs(payload) {
+  const values = new Map;
+  let offset = 0;
+  try {
+    while (offset < payload.length) {
+      const index = payload.readUInt8(offset);
+      offset += 1;
+      const { value, next } = readPacked(payload, offset);
+      offset = next;
+      values.set(index, value);
+    }
+  } catch {}
+  return values;
+}
+function readMoveSpeed(payload) {
+  let offset = 0;
+  while (offset < payload.length) {
+    const index = payload.readUInt8(offset);
+    offset += 1;
+    if (index === 1) {
+      if (offset + 4 > payload.length)
+        return;
+      return payload.readFloatLE(offset);
+    }
+    if (index === 0)
+      offset += 1;
+    else
+      return;
+  }
+  return;
+}
+function readPacked(payload, start) {
+  let raw = 0n;
+  let shift = 0n;
+  let offset = start;
+  for (let count = 0;count < 10; count += 1) {
+    if (offset >= payload.length)
+      throw new Error("truncated packed integer");
+    const byte = payload[offset++];
+    raw |= BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0) {
+      const value = Number(raw >> 1n ^ -(raw & 1n));
+      if (!Number.isSafeInteger(value))
+        throw new Error("packed integer exceeds safe range");
+      return { value, next: offset };
+    }
+    shift += 7n;
+  }
+  throw new Error("invalid packed integer");
+}
+// src/tracker.ts
+var CHARACTER_RPCS = new Set(["LoadCharacter_T", "CharacterCallback_T"]);
+var MAX_PENDING_RECORD_OBJECTS = 4096;
+var REGEN_CADENCE_MAX_GAP_MS = 1750;
+var REGEN_SETTLE_QUIET_MS = 2250;
+var RECORDED_STATS = [
+  ["max-health", ["maxHealth", "normalizedMaxHp"]],
+  ["max-mana", ["maxMana", "normalizedMaxMp"]],
+  ["move-speed", ["moveSpeed"]]
+];
+
+class FishNetCharacterTracker {
+  snapshot;
+  identity;
+  unsupportedDetail;
+  currentWeight;
+  localObjectId;
+  localConnectionId;
+  records = {};
+  pendingRecords = new Map;
+  listeners = new Set;
+  healthRegen;
+  manaRegen;
+  now;
+  schedule;
+  cancel;
+  constructor(initial, timing = {}) {
+    this.now = timing.now ?? Date.now;
+    this.schedule = timing.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+    this.cancel = timing.cancel ?? ((handle) => clearTimeout(handle));
+    if (initial)
+      this.snapshot = { ...initial, source: "cached" };
+  }
+  consume(packet) {
+    if (packet.packetName === "authenticated" || packet.packetName === "disconnect") {
+      if (this.localConnectionId === undefined || packet.connectionId === this.localConnectionId) {
+        this.releaseLocalObject();
+      }
+      return false;
+    }
+    if (packet.packetName === "objectDespawn" && packet.objectId !== undefined) {
+      this.pendingRecords.delete(pendingKey(packet.connectionId, packet.objectId));
+      if (this.isLocalObject(packet))
+        this.releaseLocalObject();
+      return false;
+    }
+    if (packet.packetName === "objectSpawn" && packet.objectId !== undefined) {
+      const key = pendingKey(packet.connectionId, packet.objectId);
+      this.pendingRecords.delete(key);
+      const update = decodeCharacterSpawnRecords(packet.spawnSyncEntries);
+      if (update)
+        Object.assign(this.pendingRecordsFor(key), update, { updatedAt: new Date().toISOString() });
+    }
+    if (packet.packetName === "serverRpc" && packet.objectId !== undefined) {
+      const objectChanged = this.localObjectId !== packet.objectId || this.localConnectionId !== packet.connectionId;
+      this.localObjectId = packet.objectId;
+      this.localConnectionId = packet.connectionId;
+      const pending = this.pendingRecords.get(pendingKey(packet.connectionId, packet.objectId));
+      if (pending) {
+        this.resetRegenSequences();
+        this.records = { ...pending };
+        this.applyAuthoritativeMaxima();
+      } else if (objectChanged) {
+        this.resetRegenSequences();
+        this.records = {};
+      }
+      this.pendingRecords.clear();
+      if (objectChanged || pending)
+        this.publish();
+      return false;
+    }
+    if (packet.packetName === "syncType") {
+      const identityChanged = this.consumeIdentitySync(packet);
+      const recordChanged = this.consumeRecordSync(packet);
+      return identityChanged || recordChanged;
+    }
+    if (packet.rpcName === undefined || !CHARACTER_RPCS.has(packet.rpcName))
+      return false;
+    try {
+      const decoded = decodeCharacterRpcPayload(packet.payload, packet.rpcName === "CharacterCallback_T");
+      if (this.snapshot && this.snapshot.name !== decoded.snapshot.name) {
+        this.currentWeight = undefined;
+        this.records = {};
+        this.resetRegenSequences();
+      }
+      this.snapshot = mergeSnapshot(this.snapshot, decoded.snapshot, decoded.updateType);
+      if (decoded.currentWeight !== undefined)
+        this.currentWeight = decoded.currentWeight;
+      this.unsupportedDetail = undefined;
+    } catch (error) {
+      this.unsupportedDetail = `Character data isn't recognized: ${errorMessage(error)}. Change maps or channels to request a fresh update.`.slice(0, 240);
+    }
+    this.publish();
+    return true;
+  }
+  consumeIdentitySync(packet) {
+    if (packet.networkBehaviourType !== "StatusComponent" || !this.isLocalObject(packet) || !packet.decodedFields)
+      return false;
+    let name;
+    let level;
+    let jobLevel;
+    for (const field of packet.decodedFields) {
+      if (field.name === "DisplayName" && typeof field.value === "string")
+        name = field.value;
+      else if (field.name === "Level" && typeof field.value === "number")
+        level = field.value;
+      else if (field.name === "JobLevel" && typeof field.value === "number")
+        jobLevel = field.value;
+    }
+    if (name === undefined && level === undefined && jobLevel === undefined)
+      return false;
+    this.identity = {
+      name: name ?? this.identity?.name ?? "",
+      level: level ?? this.identity?.level,
+      jobLevel: jobLevel ?? this.identity?.jobLevel
+    };
+    if (!this.identity.name)
+      return false;
+    this.publish();
+    return true;
+  }
+  consumeRecordSync(packet) {
+    if (packet.objectId === undefined)
+      return false;
+    const update = decodeCharacterRecordSync(packet);
+    if (!update)
+      return false;
+    if (!this.isLocalObject(packet)) {
+      const key = pendingKey(packet.connectionId, packet.objectId);
+      Object.assign(this.pendingRecordsFor(key), update, { updatedAt: new Date().toISOString() });
+      return false;
+    }
+    this.applyLocalRecordUpdate(update);
+    this.publish();
+    return true;
+  }
+  pendingRecordsFor(key) {
+    let records = this.pendingRecords.get(key);
+    if (!records) {
+      if (this.pendingRecords.size >= MAX_PENDING_RECORD_OBJECTS) {
+        const oldestKey = this.pendingRecords.keys().next().value;
+        if (oldestKey !== undefined)
+          this.pendingRecords.delete(oldestKey);
+      }
+      records = {};
+      this.pendingRecords.set(key, records);
+    }
+    return records;
+  }
+  isLocalObject(packet) {
+    return this.localObjectId !== undefined && packet.objectId === this.localObjectId && packet.connectionId === this.localConnectionId;
+  }
+  releaseLocalObject() {
+    this.localObjectId = undefined;
+    this.localConnectionId = undefined;
+    this.pendingRecords.clear();
+    this.resetRegenSequences();
+    this.identity = undefined;
+  }
+  setCached(snapshot) {
+    this.snapshot = snapshot ? { ...snapshot, source: "cached" } : undefined;
+    this.currentWeight = undefined;
+    this.records = {};
+    this.pendingRecords.clear();
+    this.resetRegenSequences();
+    this.unsupportedDetail = undefined;
+    this.publish();
+  }
+  current() {
+    return this.snapshot ? structuredClone(this.snapshot) : undefined;
+  }
+  currentObjectId() {
+    return this.localObjectId;
+  }
+  rekeyPendingObject(connectionId, fromObjectId, toObjectId) {
+    if (fromObjectId === toObjectId)
+      return;
+    const fromKey = pendingKey(connectionId, fromObjectId);
+    const candidate = this.pendingRecords.get(fromKey);
+    if (!candidate)
+      return;
+    this.pendingRecords.delete(fromKey);
+    Object.assign(this.pendingRecordsFor(pendingKey(connectionId, toObjectId)), candidate);
+  }
+  applyLocalRecordUpdate(update) {
+    const previousHealth = this.records.currentHealth;
+    const previousMana = this.records.currentMana;
+    Object.assign(this.records, update, { updatedAt: new Date().toISOString() });
+    this.applyAuthoritativeMaxima();
+    if (update.maxHealth === undefined && update.currentHealth !== undefined && this.records.maxHealth === undefined) {
+      this.observeRegen("health", previousHealth, update.currentHealth);
+    }
+    if (update.maxMana === undefined && update.currentMana !== undefined && this.records.maxMana === undefined) {
+      this.observeRegen("mana", previousMana, update.currentMana);
+    }
+  }
+  applyAuthoritativeMaxima() {
+    if (this.records.maxHealth !== undefined) {
+      this.records.normalizedMaxHp = this.records.maxHealth;
+      this.clearRegen("health");
+    }
+    if (this.records.maxMana !== undefined) {
+      this.records.normalizedMaxMp = this.records.maxMana;
+      this.clearRegen("mana");
+    }
+  }
+  observeRegen(kind, previous, current) {
+    const normalizedKey = kind === "health" ? "normalizedMaxHp" : "normalizedMaxMp";
+    const knownMaximum = this.records[normalizedKey];
+    if (knownMaximum !== undefined && current <= knownMaximum)
+      return;
+    if (knownMaximum !== undefined)
+      delete this.records[normalizedKey];
+    if (previous === undefined || current < previous) {
+      this.clearRegen(kind);
+      return;
+    }
+    const now = this.now();
+    let sequence = kind === "health" ? this.healthRegen : this.manaRegen;
+    if (current > previous) {
+      const continues = sequence !== undefined && now - sequence.lastObservedAtMs <= REGEN_CADENCE_MAX_GAP_MS;
+      this.clearRegenTimer(sequence);
+      sequence = {
+        lastValue: current,
+        lastObservedAtMs: now,
+        consecutiveIncreases: continues ? sequence.consecutiveIncreases + 1 : 1
+      };
+      if (kind === "health")
+        this.healthRegen = sequence;
+      else
+        this.manaRegen = sequence;
+    } else if (sequence) {
+      this.clearRegenTimer(sequence);
+      sequence.lastObservedAtMs = now;
+      sequence.lastValue = current;
+    } else {
+      return;
+    }
+    if (sequence.consecutiveIncreases < 2)
+      return;
+    sequence.timer = this.schedule(() => this.settleRegen(kind, sequence), REGEN_SETTLE_QUIET_MS);
+  }
+  settleRegen(kind, sequence) {
+    if ((kind === "health" ? this.healthRegen : this.manaRegen) !== sequence)
+      return;
+    const currentKey = kind === "health" ? "currentHealth" : "currentMana";
+    const maxKey = kind === "health" ? "maxHealth" : "maxMana";
+    const normalizedKey = kind === "health" ? "normalizedMaxHp" : "normalizedMaxMp";
+    if (this.records[maxKey] !== undefined || this.records[currentKey] !== sequence.lastValue)
+      return;
+    this.records[normalizedKey] = sequence.lastValue;
+    this.records.updatedAt = new Date().toISOString();
+    this.clearRegen(kind);
+    this.publish();
+  }
+  clearRegen(kind) {
+    const sequence = kind === "health" ? this.healthRegen : this.manaRegen;
+    this.clearRegenTimer(sequence);
+    if (kind === "health")
+      this.healthRegen = undefined;
+    else
+      this.manaRegen = undefined;
+  }
+  clearRegenTimer(sequence) {
+    if (sequence?.timer !== undefined)
+      this.cancel(sequence.timer);
+  }
+  resetRegenSequences() {
+    this.clearRegen("health");
+    this.clearRegen("mana");
+  }
+  currentArchetypeId() {
+    const archetype = this.snapshot?.archetypes.at(-1);
+    return archetype === undefined ? undefined : resolveCharacterArchetypeId(archetype);
+  }
+  state() {
+    const snapshot = this.snapshot ? rescaleSubstats(structuredClone(this.snapshot)) : undefined;
+    const records = Object.keys(this.records).length > 0 ? { records: { ...this.records } } : {};
+    const weight = snapshot && this.currentWeight !== undefined ? { weight: { current: this.currentWeight, maximum: calculateWeightLimit(snapshot) } } : {};
+    const identity = this.identity ? { identity: { ...this.identity } } : {};
+    if (this.unsupportedDetail)
+      return {
+        ...snapshot ? { snapshot } : {},
+        ...identity,
+        stats: snapshot ? this.applyRecords(calculateStats(snapshot)) : [],
+        gearTotals: snapshot ? calculateGearTotals(snapshot) : [],
+        ...records,
+        ...weight,
+        status: "unsupported",
+        statusDetail: this.unsupportedDetail
+      };
+    if (!snapshot)
+      return {
+        ...identity,
+        status: "waiting",
+        statusDetail: "Waiting for the game to send your character\u2026 Change maps or channels to request an update.",
+        stats: [],
+        gearTotals: [],
+        ...records,
+        ...weight
+      };
+    return {
+      snapshot,
+      ...identity,
+      stats: this.applyRecords(calculateStats(snapshot)),
+      gearTotals: calculateGearTotals(snapshot),
+      ...records,
+      ...weight,
+      status: snapshot.source,
+      statusDetail: snapshot.source === "live" ? "Live character data" : "Last known character"
+    };
+  }
+  applyRecords(stats) {
+    for (const [statId, recordKeys] of RECORDED_STATS) {
+      const value = recordKeys.map((key) => this.records[key]).find((candidate) => typeof candidate === "number");
+      if (typeof value !== "number")
+        continue;
+      const stat2 = stats.find((entry) => entry.id === statId);
+      if (stat2)
+        stat2.record = value;
+    }
+    return stats;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  publish() {
+    const state = this.state();
+    for (const listener of this.listeners)
+      listener(state);
+  }
+}
+function pendingKey(connectionId, objectId) {
+  return `${connectionId} ${objectId}`;
+}
+function calculateStats(snapshot) {
+  const gearTotals = calculateGearTotals(snapshot);
+  return calculateCharacterStats(snapshot.level, snapshot.attributes, [...materializeGearStats(snapshot.equipment, snapshot.artifacts), ...materializeSkillStats(snapshot.skills)], snapshot.archetypes).concat(calculateAdvancedGearStats(gearTotals));
+}
+function calculateGearTotals(snapshot) {
+  return aggregateGearSubstats(snapshot.equipment, snapshot.artifacts);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function mergeSnapshot(previous, next, updateType) {
+  if (!previous || previous.name !== next.name || updateType === 327417855)
+    return next;
+  const merged = { ...previous, updatedAt: next.updatedAt, source: "live" };
+  if (updateType & (1 | 2))
+    Object.assign(merged, { level: next.level, experience: next.experience, jobLevel: next.jobLevel, jobExperience: next.jobExperience });
+  if (updateType & 4)
+    merged.attributes = next.attributes;
+  if (updateType & (32 | 64 | 4194304 | 33554528)) {
+    merged.activeLoadout = next.activeLoadout;
+    merged.equipment = next.equipment;
+    merged.artifacts = next.artifacts;
+  }
+  if (updateType & 131072)
+    merged.archetypes = next.archetypes;
+  if (updateType & 8388608)
+    merged.title = next.title;
+  if (updateType & 16777216)
+    merged.name = next.name;
+  if (next.playtimeSeconds !== undefined)
+    merged.playtimeSeconds = next.playtimeSeconds;
+  if (next.monsterKills !== undefined)
+    merged.monsterKills = next.monsterKills;
+  if (next.bossKills !== undefined)
+    merged.bossKills = next.bossKills;
+  if (next.deaths !== undefined)
+    merged.deaths = next.deaths;
+  return merged;
+}
+// src/inspect-roster.ts
+var INSPECT_RPC = "Inspect_T";
+var DEFAULT_LIMIT = 24;
+
+class FishNetInspectRoster {
+  limit;
+  characters = new Map;
+  listeners = new Set;
+  localName;
+  constructor(limit = DEFAULT_LIMIT) {
+    this.limit = limit;
+  }
+  setLocalName(name) {
+    this.localName = name;
+  }
+  consume(packet, now = new Date) {
+    if (packet.rpcName !== INSPECT_RPC)
+      return false;
+    let snapshot;
+    try {
+      ({ snapshot } = decodeCharacterRpcPayload(packet.payload, false, now));
+    } catch {
+      return false;
+    }
+    if (!snapshot.name)
+      return false;
+    if (snapshot.name === this.localName)
+      return false;
+    this.characters.delete(snapshot.name);
+    this.characters.set(snapshot.name, { snapshot, inspectedAt: now.toISOString() });
+    while (this.characters.size > this.limit) {
+      const oldest = this.characters.keys().next();
+      if (oldest.done)
+        break;
+      this.characters.delete(oldest.value);
+    }
+    this.publish();
+    return true;
+  }
+  list() {
+    return [...this.characters.values()].sort((left, right) => right.inspectedAt.localeCompare(left.inspectedAt)).map((entry) => structuredClone(entry));
+  }
+  get(name) {
+    const entry = this.characters.get(name);
+    return entry ? structuredClone(entry.snapshot) : undefined;
+  }
+  clear() {
+    if (!this.characters.size)
+      return;
+    this.characters.clear();
+    this.publish();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  publish() {
+    const roster = this.list();
+    for (const listener of this.listeners)
+      listener(roster);
+  }
+}
+// src/types.ts
+var ATTRIBUTE_NAMES = ["STR", "VIT", "AGI", "DEX", "INT", "LUK"];
+export {
+  ATTRIBUTE_NAMES,
+  FishNetCharacterTracker,
+  FishNetInspectRoster,
+  PERCENT_STATS,
+  STAT_NAMES,
+  aggregateGearSubstats,
+  calculateCharacterStats,
+  calculateWeightLimit,
+  decodeCharacterRecordSync,
+  decodeCharacterRpcPayload,
+  decodeCharacterSpawnRecords,
+  materializeGearStats,
+  materializeSkillStats,
+  rescaleSubstats,
+  resolveCharacterArchetypeId,
+  resolveCharacterHealingTraits
+};