@mks.haro/axicode 1.0.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@mks.haro/axicode",
+  "version": "1.0.0",
+  "description": "Compact binary build code encoder/decoder for Guild Wars 2 builds (AxiCode format)",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [
+    "guild-wars-2",
+    "gw2",
+    "build-code",
+    "encoder",
+    "decoder",
+    "axiforge"
+  ],
+  "author": "darkharasho",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

package/src/bitBuffer.js

@@ -0,0 +1,70 @@
+"use strict";
+
+class BitWriter {
+  constructor() {
+    this._bytes = [];
+    this._currentByte = 0;
+    this._bitPos = 7; // MSB first, counts down from 7 to 0
+  }
+
+  write(value, numBits) {
+    for (let i = numBits - 1; i >= 0; i--) {
+      const bit = (value >> i) & 1;
+      this._currentByte |= bit << this._bitPos;
+      this._bitPos--;
+      if (this._bitPos < 0) {
+        this._bytes.push(this._currentByte);
+        this._currentByte = 0;
+        this._bitPos = 7;
+      }
+    }
+  }
+
+  toBytes() {
+    const out = [...this._bytes];
+    if (this._bitPos < 7) out.push(this._currentByte); // flush partial byte
+    return new Uint8Array(out);
+  }
+
+  toPaddedBytes(alignment) {
+    const bytes = this.toBytes();
+    const remainder = bytes.length % alignment;
+    if (remainder === 0) return bytes;
+    const padded = new Uint8Array(bytes.length + (alignment - remainder));
+    padded.set(bytes);
+    return padded;
+  }
+}
+
+class BitReader {
+  constructor(buffer) {
+    this._buffer = buffer;
+    this._bytePos = 0;
+    this._bitPos = 7;
+  }
+
+  read(numBits) {
+    let value = 0;
+    for (let i = 0; i < numBits; i++) {
+      if (this._bytePos >= this._buffer.length) {
+        throw new Error("Read past end of buffer");
+      }
+      const bit = (this._buffer[this._bytePos] >> this._bitPos) & 1;
+      value = (value << 1) | bit;
+      this._bitPos--;
+      if (this._bitPos < 0) {
+        this._bytePos++;
+        this._bitPos = 7;
+      }
+    }
+    return value;
+  }
+
+  bitsRemaining() {
+    const totalBits = this._buffer.length * 8;
+    const consumed = this._bytePos * 8 + (7 - this._bitPos);
+    return totalBits - consumed;
+  }
+}
+
+module.exports = { BitWriter, BitReader };

package/src/index.js

@@ -0,0 +1,609 @@
+"use strict";
+
+const { BitWriter, BitReader } = require("./bitBuffer");
+const { z85Encode, z85Decode } = require("./z85");
+const {
+  professionToIndex, indexToProfession,
+  weaponToIndex, indexToWeapon, isWeaponTwoHanded,
+  statToIndex, indexToStat,
+  relicToIndex, indexToRelic,
+  foodToIndex, indexToFood,
+  utilityToIndex, indexToUtility,
+  legendStringToIndex, indexToLegendString,
+} = require("./tables");
+
+const SHARE_CODE_PREFIX = "<AxiForge:";
+const CURRENT_VERSION = 1;
+
+const GAME_MODES = ["pve", "pvp", "wvw"];
+const ATTUNEMENTS = ["Fire", "Water", "Air", "Earth"];
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function skillId(skill) {
+  return (skill && skill.id) ? skill.id : 0;
+}
+
+function parseIntOrZero(v) {
+  const n = parseInt(v, 10);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/** Determine trait position (1=top, 2=mid, 3=bottom, 0=none) */
+function traitPosition(spec, tier) {
+  const chosen = spec.majorChoices && spec.majorChoices[tier];
+  if (!chosen) return 0;
+  const tierTraits = spec.majorTraitsByTier && spec.majorTraitsByTier[tier];
+  if (!tierTraits) return 0;
+  const idx = tierTraits.findIndex(t => t.id === chosen);
+  return idx >= 0 ? idx + 1 : 0;
+}
+
+/** Check if all values in an array of strings are the same */
+function allSame(arr) {
+  if (arr.length === 0) return true;
+  return arr.every(v => v === arr[0]);
+}
+
+/** Collect all infusion values into a flat array for uniformity check */
+function collectInfusionValues(infusions) {
+  const vals = [];
+  for (const key of ["head", "shoulders", "chest", "hands", "legs", "feet", "accessory1", "accessory2"]) {
+    if (infusions[key]) vals.push(String(infusions[key]));
+  }
+  for (const key of ["back", "ring1", "ring2", "mainhand1", "offhand1", "mainhand2", "offhand2"]) {
+    const v = infusions[key];
+    if (Array.isArray(v)) {
+      v.forEach(x => { if (x) vals.push(String(x)); });
+    } else if (v) {
+      vals.push(String(v));
+    }
+  }
+  return vals;
+}
+
+/** Determine if profession has non-default specific data */
+function hasProfessionData(build) {
+  const prof = build.profession;
+  if (prof === "Revenant") {
+    return (build.selectedLegends && (build.selectedLegends[0] || build.selectedLegends[1]));
+  }
+  if (prof === "Ranger") {
+    const p = build.selectedPets;
+    return p && (p.terrestrial1 || p.terrestrial2);
+  }
+  if (prof === "Elementalist") {
+    return !!build.activeAttunement;
+  }
+  if (prof === "Engineer") {
+    return !!build.activeKit;
+  }
+  if (prof === "Warrior") {
+    return build.activeWeaponSet && build.activeWeaponSet !== 1;
+  }
+  if (prof === "Thief") {
+    const a = build.antiquaryArtifacts;
+    return a && (a.f2 || a.f3 || a.f4);
+  }
+  return false;
+}
+
+// ── Encoder ──────────────────────────────────────────────────────────────────
+
+function encodeShareCode(build) {
+  const w = new BitWriter();
+
+  const weapons = build.equipment.weapons;
+  const runes = build.equipment.runes;
+  const infusions = build.equipment.infusions;
+
+  // Determine flags
+  const hasUnderwater = !!(
+    skillId(build.underwaterSkills && build.underwaterSkills.heal) ||
+    (build.underwaterSkills && build.underwaterSkills.utility &&
+      build.underwaterSkills.utility.some(s => skillId(s))) ||
+    skillId(build.underwaterSkills && build.underwaterSkills.elite) ||
+    weapons.aquatic1 || weapons.aquatic2
+  );
+  const hasOffhand1 = !!weapons.offhand1;
+  const hasOffhand2 = !!weapons.offhand2;
+  const hasWeaponSet2 = !!weapons.mainhand2;
+  const hasProfData = hasProfessionData(build);
+
+  // Per-slot stats: always 0 for v1 (uniform statPackage)
+  const perSlotStats = false;
+
+  // Per-slot runes: check if all 6 armor rune slots are the same
+  const runeSlots = [runes.head, runes.shoulders, runes.chest, runes.hands, runes.legs, runes.feet];
+  const perSlotRunes = !allSame(runeSlots.map(String));
+
+  // Per-slot infusions
+  const infValues = collectInfusionValues(infusions);
+  const perSlotInfusions = infValues.length > 0 && !allSame(infValues);
+
+  const flags =
+    (hasUnderwater ? 1 : 0) |
+    (hasOffhand1 ? 2 : 0) |
+    (hasOffhand2 ? 4 : 0) |
+    (hasWeaponSet2 ? 8 : 0) |
+    (hasProfData ? 16 : 0) |
+    (perSlotStats ? 32 : 0) |
+    (perSlotRunes ? 64 : 0) |
+    (perSlotInfusions ? 128 : 0);
+
+  // Header
+  w.write(CURRENT_VERSION, 4);
+  w.write(flags, 8);
+
+  // Core build
+  w.write(professionToIndex(build.profession), 4);
+  w.write(GAME_MODES.indexOf(build.gameMode), 2);
+
+  for (let i = 0; i < 3; i++) {
+    const spec = build.specializations[i];
+    if (spec && spec.id) {
+      w.write(spec.id, 7);
+      for (let tier = 1; tier <= 3; tier++) {
+        w.write(traitPosition(spec, tier), 2);
+      }
+    } else {
+      w.write(0, 7);
+      w.write(0, 6);
+    }
+  }
+
+  // Skills
+  w.write(skillId(build.skills.heal), 17);
+  for (let i = 0; i < 3; i++) {
+    w.write(skillId(build.skills.utility[i]), 17);
+  }
+  w.write(skillId(build.skills.elite), 17);
+
+  // Equipment - Weapons
+  const mh1Idx = weaponToIndex(weapons.mainhand1);
+  w.write(mh1Idx, 5);
+  if (hasOffhand1) w.write(weaponToIndex(weapons.offhand1), 5);
+  if (hasWeaponSet2) {
+    const mh2Idx = weaponToIndex(weapons.mainhand2);
+    w.write(mh2Idx, 5);
+    if (hasOffhand2) w.write(weaponToIndex(weapons.offhand2), 5);
+  }
+
+  // Equipment - Stats
+  if (!perSlotStats) {
+    w.write(statToIndex(build.equipment.statPackage), 5);
+  }
+
+  // Equipment - Runes
+  if (!perSlotRunes) {
+    w.write(parseIntOrZero(runes.head), 17);
+  } else {
+    for (const slot of ["head", "shoulders", "chest", "hands", "legs", "feet"]) {
+      w.write(parseIntOrZero(runes[slot]), 17);
+    }
+  }
+
+  // Equipment - Sigils
+  const mh1TwoHanded = isWeaponTwoHanded(mh1Idx);
+  const mh1Sigils = build.equipment.sigils.mainhand1 || [];
+  if (mh1TwoHanded) {
+    w.write(parseIntOrZero(mh1Sigils[0]), 17);
+    w.write(parseIntOrZero(mh1Sigils[1]), 17);
+  } else {
+    w.write(parseIntOrZero(mh1Sigils[0]), 17);
+  }
+  if (hasOffhand1) {
+    const oh1Sigils = build.equipment.sigils.offhand1 || [];
+    w.write(parseIntOrZero(oh1Sigils[0]), 17);
+  }
+  if (hasWeaponSet2) {
+    const mh2Idx = weaponToIndex(weapons.mainhand2);
+    const mh2TwoHanded = isWeaponTwoHanded(mh2Idx);
+    const mh2Sigils = build.equipment.sigils.mainhand2 || [];
+    if (mh2TwoHanded) {
+      w.write(parseIntOrZero(mh2Sigils[0]), 17);
+      w.write(parseIntOrZero(mh2Sigils[1]), 17);
+    } else {
+      w.write(parseIntOrZero(mh2Sigils[0]), 17);
+    }
+    if (hasOffhand2) {
+      const oh2Sigils = build.equipment.sigils.offhand2 || [];
+      w.write(parseIntOrZero(oh2Sigils[0]), 17);
+    }
+  }
+
+  // Relic, Food, Utility, Enrichment
+  w.write(relicToIndex(build.equipment.relic), 7);
+  w.write(foodToIndex(build.equipment.food), 4);
+  w.write(utilityToIndex(build.equipment.utility), 3);
+  w.write(parseIntOrZero(build.equipment.enrichment), 17);
+
+  // Infusions
+  if (!perSlotInfusions) {
+    const uniformVal = infValues.length > 0 ? parseIntOrZero(infValues[0]) : 0;
+    w.write(uniformVal, 17);
+  } else {
+    const writeInfSlot = (val) => w.write(parseIntOrZero(val), 17);
+    const writeArraySlots = (arr, count) => {
+      for (let i = 0; i < count; i++) writeInfSlot(Array.isArray(arr) ? arr[i] : arr);
+    };
+
+    for (const slot of ["head", "shoulders", "chest", "hands", "legs", "feet"]) {
+      writeInfSlot(infusions[slot]);
+    }
+    writeArraySlots(infusions.back, 2);
+    writeArraySlots(infusions.ring1, 3);
+    writeArraySlots(infusions.ring2, 3);
+    writeInfSlot(infusions.accessory1);
+    writeInfSlot(infusions.accessory2);
+    writeArraySlots(infusions.mainhand1, 2);
+    if (hasOffhand1) {
+      const oh1Inf = infusions.offhand1;
+      writeInfSlot(Array.isArray(oh1Inf) ? oh1Inf[0] : oh1Inf);
+    }
+    if (hasWeaponSet2) {
+      writeArraySlots(infusions.mainhand2, 2);
+      if (hasOffhand2) {
+        const oh2Inf = infusions.offhand2;
+        writeInfSlot(Array.isArray(oh2Inf) ? oh2Inf[0] : oh2Inf);
+      }
+    }
+    if (hasUnderwater) {
+      writeInfSlot(infusions.breather || 0);
+      writeArraySlots(infusions.aquatic1 || [0, 0], 2);
+      writeArraySlots(infusions.aquatic2 || [0, 0], 2);
+    }
+  }
+
+  // Underwater section
+  if (hasUnderwater) {
+    const uw = build.underwaterSkills || {};
+    w.write(skillId(uw.heal), 17);
+    const uwUtil = uw.utility || [null, null, null];
+    for (let i = 0; i < 3; i++) w.write(skillId(uwUtil[i]), 17);
+    w.write(skillId(uw.elite), 17);
+
+    const aq1Idx = weaponToIndex(weapons.aquatic1);
+    const aq2Idx = weaponToIndex(weapons.aquatic2);
+    w.write(aq1Idx, 5);
+    w.write(aq2Idx, 5);
+
+    const aq1Sigils = build.equipment.sigils.aquatic1 || [];
+    w.write(parseIntOrZero(aq1Sigils[0]), 17);
+    w.write(parseIntOrZero(aq1Sigils[1]), 17);
+
+    if (aq2Idx) {
+      const aq2Sigils = build.equipment.sigils.aquatic2 || [];
+      w.write(parseIntOrZero(aq2Sigils[0]), 17);
+      w.write(parseIntOrZero(aq2Sigils[1]), 17);
+    }
+  }
+
+  // Profession-specific section
+  if (hasProfData) {
+    const prof = build.profession;
+    if (prof === "Revenant") {
+      const legs = build.selectedLegends || ["", ""];
+      w.write(legendStringToIndex(legs[0]), 3);
+      w.write(legendStringToIndex(legs[1]), 3);
+      w.write(0, 1);
+      w.write(build.allianceTacticsForm || 0, 1);
+      if (hasUnderwater) {
+        const uwLegs = build.selectedUnderwaterLegends || ["", ""];
+        w.write(legendStringToIndex(uwLegs[0]), 3);
+        w.write(legendStringToIndex(uwLegs[1]), 3);
+      }
+    } else if (prof === "Ranger") {
+      const pets = build.selectedPets || {};
+      w.write(pets.terrestrial1 || 0, 7);
+      w.write(pets.terrestrial2 || 0, 7);
+      if (hasUnderwater) {
+        w.write(pets.aquatic1 || 0, 7);
+        w.write(pets.aquatic2 || 0, 7);
+      }
+    } else if (prof === "Elementalist") {
+      const att1 = ATTUNEMENTS.indexOf(build.activeAttunement);
+      w.write(att1 >= 0 ? att1 : 0, 2);
+      const att2 = ATTUNEMENTS.indexOf(build.activeAttunement2);
+      w.write(att2 >= 0 ? att2 : 0, 2);
+    } else if (prof === "Engineer") {
+      w.write(build.activeKit || 0, 17);
+    } else if (prof === "Warrior") {
+      w.write(build.activeWeaponSet === 2 ? 1 : 0, 1);
+    } else if (prof === "Thief") {
+      const art = build.antiquaryArtifacts || {};
+      w.write(art.f2 || 0, 17);
+      w.write(art.f3 || 0, 17);
+      w.write(art.f4 || 0, 17);
+    }
+  }
+
+  // Pad to 4-byte boundary for Z85, encode
+  const bytes = w.toPaddedBytes(4);
+  const payload = z85Encode(bytes);
+
+  // Label: elite spec name or profession name
+  let label = build.profession;
+  const eliteSpec = build.specializations.find(s => s && s.elite);
+  if (eliteSpec) label = eliteSpec.name;
+
+  return `<AxiForge:${label}:${payload}>`;
+}
+
+// ── Decoder ──────────────────────────────────────────────────────────────────
+
+function parseShareCodeWrapper(code) {
+  if (!code.startsWith(SHARE_CODE_PREFIX) || !code.endsWith(">")) return null;
+  const inner = code.slice(SHARE_CODE_PREFIX.length, -1);
+  const colonIdx = inner.indexOf(":");
+  if (colonIdx < 1) return null;
+  const label = inner.slice(0, colonIdx);
+  const payload = inner.slice(colonIdx + 1);
+  if (!payload) return null;
+  return { label, payload };
+}
+
+function decodeShareCode(code) {
+  const parsed = parseShareCodeWrapper(code);
+  if (!parsed) throw new Error("Invalid build code format");
+
+  const payload = parsed.payload;
+  let bytes;
+  try {
+    bytes = z85Decode(payload);
+  } catch (e) {
+    throw new Error("Corrupted build code");
+  }
+
+  const r = new BitReader(bytes);
+
+  const version = r.read(4);
+  if (version !== 1) {
+    throw new Error("This build code requires a newer version of AxiForge");
+  }
+
+  const flags = r.read(8);
+  const hasUnderwater = !!(flags & 1);
+  const hasOffhand1 = !!(flags & 2);
+  const hasOffhand2 = !!(flags & 4);
+  const hasWeaponSet2 = !!(flags & 8);
+  const hasProfData = !!(flags & 16);
+  const perSlotStats = !!(flags & 32);
+  const perSlotRunes = !!(flags & 64);
+  const perSlotInfusions = !!(flags & 128);
+
+  // Core build
+  const profIdx = r.read(4);
+  const profession = indexToProfession(profIdx);
+  const gameModeIdx = r.read(2);
+  const gameMode = GAME_MODES[gameModeIdx] || "pve";
+
+  const specializations = [];
+  for (let i = 0; i < 3; i++) {
+    const id = r.read(7);
+    const t1 = r.read(2);
+    const t2 = r.read(2);
+    const t3 = r.read(2);
+    specializations.push({ id, traitChoices: [t1, t2, t3] });
+  }
+
+  // Skills
+  const healId = r.read(17);
+  const utilityIds = [r.read(17), r.read(17), r.read(17)];
+  const eliteId = r.read(17);
+
+  // Weapons
+  const mh1Idx = r.read(5);
+  const weaponsOut = {
+    mainhand1: indexToWeapon(mh1Idx),
+    offhand1: "",
+    mainhand2: "",
+    offhand2: "",
+    aquatic1: "",
+    aquatic2: "",
+  };
+  let oh1Idx = 0;
+  if (hasOffhand1) {
+    oh1Idx = r.read(5);
+    weaponsOut.offhand1 = indexToWeapon(oh1Idx);
+  }
+  let mh2Idx = 0;
+  let oh2Idx = 0;
+  if (hasWeaponSet2) {
+    mh2Idx = r.read(5);
+    weaponsOut.mainhand2 = indexToWeapon(mh2Idx);
+    if (hasOffhand2) {
+      oh2Idx = r.read(5);
+      weaponsOut.offhand2 = indexToWeapon(oh2Idx);
+    }
+  }
+
+  // Stats
+  let statPackage = "";
+  if (!perSlotStats) {
+    statPackage = indexToStat(r.read(5));
+  }
+
+  // Runes
+  const runesOut = {};
+  const RUNE_SLOTS = ["head", "shoulders", "chest", "hands", "legs", "feet"];
+  if (!perSlotRunes) {
+    const runeId = String(r.read(17));
+    for (const slot of RUNE_SLOTS) runesOut[slot] = runeId;
+  } else {
+    for (const slot of RUNE_SLOTS) runesOut[slot] = String(r.read(17));
+  }
+
+  // Sigils
+  const sigilsOut = { mainhand1: [], offhand1: [], mainhand2: [], offhand2: [], aquatic1: [], aquatic2: [] };
+  const mh1TwoHanded = isWeaponTwoHanded(mh1Idx);
+  if (mh1TwoHanded) {
+    sigilsOut.mainhand1 = [String(r.read(17)), String(r.read(17))];
+  } else {
+    sigilsOut.mainhand1 = [String(r.read(17))];
+  }
+  if (hasOffhand1) {
+    sigilsOut.offhand1 = [String(r.read(17))];
+  }
+  if (hasWeaponSet2) {
+    const mh2TwoHanded = isWeaponTwoHanded(mh2Idx);
+    if (mh2TwoHanded) {
+      sigilsOut.mainhand2 = [String(r.read(17)), String(r.read(17))];
+    } else {
+      sigilsOut.mainhand2 = [String(r.read(17))];
+    }
+    if (hasOffhand2) {
+      sigilsOut.offhand2 = [String(r.read(17))];
+    }
+  }
+
+  // Relic, Food, Utility, Enrichment
+  const relic = indexToRelic(r.read(7));
+  const foodEntry = indexToFood(r.read(4));
+  const food = foodEntry.label;
+  const utilEntry = indexToUtility(r.read(3));
+  const utility = utilEntry.label;
+  const enrichment = String(r.read(17));
+
+  // Infusions
+  const infusionsOut = {};
+  if (!perSlotInfusions) {
+    const infId = String(r.read(17));
+    for (const slot of ["head", "shoulders", "chest", "hands", "legs", "feet"]) {
+      infusionsOut[slot] = infId;
+    }
+    infusionsOut.back = [infId, infId];
+    infusionsOut.ring1 = [infId, infId, infId];
+    infusionsOut.ring2 = [infId, infId, infId];
+    infusionsOut.accessory1 = infId;
+    infusionsOut.accessory2 = infId;
+    infusionsOut.mainhand1 = [infId, infId];
+    infusionsOut.offhand1 = hasOffhand1 ? [infId] : [];
+    infusionsOut.mainhand2 = hasWeaponSet2 ? [infId, infId] : [];
+    infusionsOut.offhand2 = (hasWeaponSet2 && hasOffhand2) ? [infId] : [];
+  } else {
+    for (const slot of ["head", "shoulders", "chest", "hands", "legs", "feet"]) {
+      infusionsOut[slot] = String(r.read(17));
+    }
+    infusionsOut.back = [String(r.read(17)), String(r.read(17))];
+    infusionsOut.ring1 = [String(r.read(17)), String(r.read(17)), String(r.read(17))];
+    infusionsOut.ring2 = [String(r.read(17)), String(r.read(17)), String(r.read(17))];
+    infusionsOut.accessory1 = String(r.read(17));
+    infusionsOut.accessory2 = String(r.read(17));
+    infusionsOut.mainhand1 = [String(r.read(17)), String(r.read(17))];
+    if (hasOffhand1) infusionsOut.offhand1 = [String(r.read(17))];
+    else infusionsOut.offhand1 = [];
+    if (hasWeaponSet2) {
+      infusionsOut.mainhand2 = [String(r.read(17)), String(r.read(17))];
+      if (hasOffhand2) infusionsOut.offhand2 = [String(r.read(17))];
+      else infusionsOut.offhand2 = [];
+    } else {
+      infusionsOut.mainhand2 = [];
+      infusionsOut.offhand2 = [];
+    }
+    if (hasUnderwater) {
+      infusionsOut.breather = String(r.read(17));
+      infusionsOut.aquatic1 = [String(r.read(17)), String(r.read(17))];
+      infusionsOut.aquatic2 = [String(r.read(17)), String(r.read(17))];
+    }
+  }
+
+  // Underwater section
+  let underwaterSkills = { healId: 0, utilityIds: [0, 0, 0], eliteId: 0 };
+  if (hasUnderwater) {
+    const uwHealId = r.read(17);
+    const uwUtilIds = [r.read(17), r.read(17), r.read(17)];
+    const uwEliteId = r.read(17);
+    underwaterSkills = { healId: uwHealId, utilityIds: uwUtilIds, eliteId: uwEliteId };
+
+    const aq1Idx = r.read(5);
+    const aq2Idx = r.read(5);
+    weaponsOut.aquatic1 = indexToWeapon(aq1Idx);
+    weaponsOut.aquatic2 = indexToWeapon(aq2Idx);
+
+    sigilsOut.aquatic1 = [String(r.read(17)), String(r.read(17))];
+    if (aq2Idx) {
+      sigilsOut.aquatic2 = [String(r.read(17)), String(r.read(17))];
+    }
+  }
+
+  // Profession-specific
+  let selectedLegends = ["", ""];
+  let selectedUnderwaterLegends = ["", ""];
+  let selectedPets = { terrestrial1: 0, terrestrial2: 0, aquatic1: 0, aquatic2: 0 };
+  let activeAttunement = "";
+  let activeAttunement2 = "";
+  let activeKit = 0;
+  let activeWeaponSet = 1;
+  let allianceTacticsForm = 0;
+  let antiquaryArtifacts = { f2: 0, f3: 0, f4: 0 };
+
+  if (hasProfData) {
+    if (profession === "Revenant") {
+      selectedLegends = [indexToLegendString(r.read(3)), indexToLegendString(r.read(3))];
+      r.read(1);
+      allianceTacticsForm = r.read(1);
+      if (hasUnderwater) {
+        selectedUnderwaterLegends = [indexToLegendString(r.read(3)), indexToLegendString(r.read(3))];
+      }
+    } else if (profession === "Ranger") {
+      selectedPets = {
+        terrestrial1: r.read(7),
+        terrestrial2: r.read(7),
+        aquatic1: hasUnderwater ? r.read(7) : 0,
+        aquatic2: hasUnderwater ? r.read(7) : 0,
+      };
+    } else if (profession === "Elementalist") {
+      const att1Idx = r.read(2);
+      activeAttunement = ATTUNEMENTS[att1Idx] || "";
+      const att2Idx = r.read(2);
+      activeAttunement2 = ATTUNEMENTS[att2Idx] || "";
+    } else if (profession === "Engineer") {
+      activeKit = r.read(17);
+    } else if (profession === "Warrior") {
+      activeWeaponSet = r.read(1) === 1 ? 2 : 1;
+    } else if (profession === "Thief") {
+      antiquaryArtifacts = {
+        f2: r.read(17),
+        f3: r.read(17),
+        f4: r.read(17),
+      };
+    }
+  }
+
+  return {
+    profession,
+    gameMode,
+    specializations,
+    skills: { healId, utilityIds, eliteId },
+    underwaterSkills,
+    equipment: {
+      statPackage,
+      relic,
+      food,
+      utility,
+      enrichment: enrichment === "0" ? "" : enrichment,
+      weapons: weaponsOut,
+      runes: runesOut,
+      sigils: sigilsOut,
+      infusions: infusionsOut,
+    },
+    selectedLegends,
+    selectedUnderwaterLegends,
+    selectedPets,
+    activeAttunement,
+    activeAttunement2,
+    activeKit,
+    activeWeaponSet,
+    allianceTacticsForm,
+    antiquaryArtifacts,
+  };
+}
+
+// ── Validator ────────────────────────────────────────────────────────────────
+
+function isValidShareCode(text) {
+  return parseShareCodeWrapper(text) !== null;
+}
+
+module.exports = { encodeShareCode, decodeShareCode, isValidShareCode };

package/src/relics.js

@@ -0,0 +1,112 @@
+"use strict";
+// Alphabetically sorted relic labels.
+// Source: GW2 in-game relics list
+// MUST be kept in sync when relics are added/removed.
+module.exports = [
+  "Relic of Agony",
+  "Relic of Akeem",
+  "Relic of Altruism",
+  "Relic of Antitoxin",
+  "Relic of Atrocity",
+  "Relic of Bava Nisos",
+  "Relic of Bloodstone",
+  "Relic of Castora",
+  "Relic of Cerus",
+  "Relic of Dagda",
+  "Relic of Durability",
+  "Relic of Dwayna",
+  "Relic of Evasion",
+  "Relic of Febe",
+  "Relic of Fire",
+  "Relic of Fireworks",
+  "Relic of Fog",
+  "Relic of Geysers",
+  "Relic of Isgarren",
+  "Relic of Karakosa",
+  "Relic of Leadership",
+  "Relic of Lyhr",
+  "Relic of Mabon",
+  "Relic of Mercy",
+  "Relic of Mistburn",
+  "Relic of Mosyn",
+  "Relic of Mount Balrior",
+  "Relic of Nayos",
+  "Relic of Nourys",
+  "Relic of Peitha",
+  "Relic of Resistance",
+  "Relic of Reunification",
+  "Relic of Rivers",
+  "Relic of Shackles",
+  "Relic of Sorrow",
+  "Relic of Speed",
+  "Relic of Surging",
+  "Relic of Thorns",
+  "Relic of Vampirism",
+  "Relic of Vass",
+  "Relic of Zakiros",
+  "Relic of the Adventurer",
+  "Relic of the Afflicted",
+  "Relic of the Alliance",
+  "Relic of the Aristocracy",
+  "Relic of the Astral Ward",
+  "Relic of the Beehive",
+  "Relic of the Biomancer",
+  "Relic of the Blightbringer",
+  "Relic of the Brawler",
+  "Relic of the Cavalier",
+  "Relic of the Centaur",
+  "Relic of the Chronomancer",
+  "Relic of the Citadel",
+  "Relic of the Claw",
+  "Relic of the Coral Heart",
+  "Relic of the Daredevil",
+  "Relic of the Deadeye",
+  "Relic of the Defender",
+  "Relic of the Demon Queen",
+  "Relic of the Dragonhunter",
+  "Relic of the Eagle",
+  "Relic of the Earth",
+  "Relic of the Firebrand",
+  "Relic of the First Revenant",
+  "Relic of the Flock",
+  "Relic of the Forest Dweller",
+  "Relic of the Founding",
+  "Relic of the Fractal",
+  "Relic of the Golemancer",
+  "Relic of the Herald",
+  "Relic of the Holosmith",
+  "Relic of the Ice",
+  "Relic of the Krait",
+  "Relic of the Lich",
+  "Relic of the Living City",
+  "Relic of the Midnight King",
+  "Relic of the Mirage",
+  "Relic of the Mist Stranger",
+  "Relic of the Mists Tide",
+  "Relic of the Monk",
+  "Relic of the Nautical Beast",
+  "Relic of the Necromancer",
+  "Relic of the Nightmare",
+  "Relic of the Ogre",
+  "Relic of the Pack",
+  "Relic of the Phenom",
+  "Relic of the Pirate Queen",
+  "Relic of the Privateer",
+  "Relic of the Reaper",
+  "Relic of the Scoundrel",
+  "Relic of the Scourge",
+  "Relic of the Sorcerer",
+  "Relic of the Steamshrieker",
+  "Relic of the Stormsinger",
+  "Relic of the Sunless",
+  "Relic of the Thief",
+  "Relic of the Trooper",
+  "Relic of the Twin Generals",
+  "Relic of the Unseen Invasion",
+  "Relic of the Warrior",
+  "Relic of the Water",
+  "Relic of the Wayfinder",
+  "Relic of the Weaver",
+  "Relic of the Wizard's Tower",
+  "Relic of the Zephyrite",
+];

package/src/tables.js

@@ -0,0 +1,94 @@
+"use strict";
+
+// Canonical profession order — matches spec profession table.
+const PROFESSIONS = [
+  "Guardian", "Warrior", "Engineer", "Ranger", "Thief",
+  "Elementalist", "Mesmer", "Necromancer", "Revenant",
+];
+const _profIdx = new Map(PROFESSIONS.map((p, i) => [p, i]));
+function professionToIndex(name) { return _profIdx.get(name) ?? -1; }
+function indexToProfession(idx) { return PROFESSIONS[idx] || ""; }
+
+// Weapon type table — index 0 = empty, 1-19 = weapons.
+const WEAPONS = [
+  "",
+  "axe", "dagger", "mace", "pistol", "sword", "scepter",
+  "focus", "shield", "torch", "warhorn",
+  "greatsword", "hammer", "longbow", "rifle", "shortbow", "staff",
+  "harpoon", "spear", "trident",
+];
+const _weapIdx = new Map(WEAPONS.map((w, i) => [w, i]));
+function weaponToIndex(id) { return _weapIdx.get(id) ?? 0; }
+function indexToWeapon(idx) { return WEAPONS[idx] || ""; }
+const TWO_HANDED = new Set([11, 12, 13, 14, 15, 16, 18]);
+function isWeaponTwoHanded(idx) { return TWO_HANDED.has(idx); }
+
+// Stat combo table — index 0 = empty, 1-21 = stats.
+const STAT_COMBOS_ORDERED = [
+  "",
+  "Berserker's", "Marauder's", "Assassin's", "Valkyrie", "Dragon's",
+  "Viper's", "Grieving", "Sinister", "Dire", "Rabid", "Carrion",
+  "Trailblazer's", "Knight's", "Soldier's", "Cleric's", "Minstrel's",
+  "Harrier's", "Ritualist's", "Seraph", "Zealot's", "Celestial",
+];
+const _statIdx = new Map(STAT_COMBOS_ORDERED.map((s, i) => [s, i]));
+function statToIndex(label) { return _statIdx.get(label) ?? 0; }
+function indexToStat(idx) { return STAT_COMBOS_ORDERED[idx] || ""; }
+
+// Relic table — sorted alphabetically per spec.
+const _relicLabels = require("./relics");
+const RELICS_SORTED = ["", ..._relicLabels];
+const _relicIdx = new Map(RELICS_SORTED.map((r, i) => [r, i]));
+function relicToIndex(label) { return _relicIdx.get(label) ?? 0; }
+function indexToRelic(idx) { return RELICS_SORTED[idx] || ""; }
+
+// Food table — ordered by array position in constants.js GW2_FOOD.
+const FOOD_ORDERED = [
+  { label: "", id: 0 },
+  { label: "Peppercorn-Crusted Sous-Vide Steak", id: 91734 },
+  { label: "Cilantro Lime Sous-Vide Steak", id: 91805 },
+  { label: "Bowl of Sweet and Spicy Butternut Squash Soup", id: 41569 },
+  { label: "Plate of Truffle Steak Dinner", id: 12469 },
+  { label: "Bowl of Fancy Potato and Leek Soup", id: 12485 },
+  { label: "Plate of Beef Rendang", id: 86997 },
+  { label: "Plate of Kimchi Pancakes", id: 96578 },
+  { label: "Mint-Pear Cured Meat Flatbread", id: 91703 },
+  { label: "Clove-Spiced Pear and Cured Meat Flatbread", id: 91784 },
+  { label: "Mint and Veggie Flatbread", id: 91727 },
+  { label: "Delicious Rice Ball", id: 68634 },
+  { label: "Eggs Benedict with Mint-Parsley Sauce", id: 91758 },
+  { label: "Bowl of Fruit Salad with Mint Garnish", id: 91690 },
+  { label: "Bowl of Seaweed Salad", id: 12471 },
+];
+const _foodIdx = new Map(FOOD_ORDERED.map((f, i) => [f.label, i]));
+function foodToIndex(label) { return _foodIdx.get(label) ?? 0; }
+function indexToFood(idx) { return FOOD_ORDERED[idx] || FOOD_ORDERED[0]; }
+
+// Utility buff table
+const UTILITY_ORDERED = [
+  { label: "", id: 0 },
+  { label: "Superior Sharpening Stone", id: 78305 },
+  { label: "Furious Sharpening Stone", id: 67530 },
+  { label: "Bountiful Sharpening Stone", id: 67531 },
+  { label: "Bountiful Maintenance Oil", id: 67528 },
+  { label: "Furious Maintenance Oil", id: 67529 },
+];
+const _utilIdx = new Map(UTILITY_ORDERED.map((u, i) => [u.label, i]));
+function utilityToIndex(label) { return _utilIdx.get(label) ?? 0; }
+function indexToUtility(idx) { return UTILITY_ORDERED[idx] || UTILITY_ORDERED[0]; }
+
+// Revenant legend string → index mapping.
+const LEGEND_STRINGS = ["", "Legend1", "Legend2", "Legend3", "Legend4", "Legend5", "Legend6", "Legend7"];
+const _legIdx = new Map(LEGEND_STRINGS.map((l, i) => [l, i]));
+function legendStringToIndex(str) { return _legIdx.get(str) ?? 0; }
+function indexToLegendString(idx) { return LEGEND_STRINGS[idx] || ""; }
+
+module.exports = {
+  PROFESSIONS, professionToIndex, indexToProfession,
+  WEAPONS, weaponToIndex, indexToWeapon, isWeaponTwoHanded,
+  STAT_COMBOS_ORDERED, statToIndex, indexToStat,
+  relicToIndex, indexToRelic,
+  FOOD_ORDERED, foodToIndex, indexToFood,
+  UTILITY_ORDERED, utilityToIndex, indexToUtility,
+  LEGEND_STRINGS, legendStringToIndex, indexToLegendString,
+};

package/src/z85.js

@@ -0,0 +1,44 @@
+"use strict";
+
+// Z85 alphabet per ZeroMQ RFC 32
+const Z85_CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+const Z85_DECODE = new Uint8Array(128);
+for (let i = 0; i < 85; i++) Z85_DECODE[Z85_CHARS.charCodeAt(i)] = i;
+
+// Divisors for base-85 encoding of a 32-bit value
+const DIVISORS = [85 * 85 * 85 * 85, 85 * 85 * 85, 85 * 85, 85, 1];
+
+function z85Encode(buffer) {
+  if (buffer.length % 4 !== 0) {
+    throw new Error("Z85 input must be a multiple of 4 bytes");
+  }
+  let out = "";
+  for (let i = 0; i < buffer.length; i += 4) {
+    let value = ((buffer[i] << 24) | (buffer[i + 1] << 16) | (buffer[i + 2] << 8) | buffer[i + 3]) >>> 0;
+    for (let j = 0; j < 5; j++) {
+      const idx = Math.floor(value / DIVISORS[j]) % 85;
+      out += Z85_CHARS[idx];
+    }
+  }
+  return out;
+}
+
+function z85Decode(str) {
+  if (str.length % 5 !== 0) {
+    throw new Error("Z85 string must be a multiple of 5 characters");
+  }
+  const out = new Uint8Array((str.length / 5) * 4);
+  for (let i = 0, byteIdx = 0; i < str.length; i += 5, byteIdx += 4) {
+    let value = 0;
+    for (let j = 0; j < 5; j++) {
+      value = value * 85 + Z85_DECODE[str.charCodeAt(i + j)];
+    }
+    out[byteIdx]     = (value >>> 24) & 0xFF;
+    out[byteIdx + 1] = (value >>> 16) & 0xFF;
+    out[byteIdx + 2] = (value >>> 8)  & 0xFF;
+    out[byteIdx + 3] =  value         & 0xFF;
+  }
+  return out;
+}
+
+module.exports = { z85Encode, z85Decode };

package/tests/axicode.test.js

@@ -0,0 +1,349 @@
+"use strict";
+const { encodeShareCode, decodeShareCode, isValidShareCode } = require("../src/index");
+
+// Minimal Warrior/Berserker build fixture
+const BERSERKER_BUILD = {
+  profession: "Warrior",
+  gameMode: "pve",
+  specializations: [
+    { id: 4, name: "Strength", elite: false, majorChoices: { 1: 1444, 2: 1449, 3: 1437 },
+      majorTraitsByTier: { 1: [{ id: 1444 }, { id: 1447 }, { id: 2000 }], 2: [{ id: 1449 }, { id: 1448 }, { id: 1453 }], 3: [{ id: 1437 }, { id: 1440 }, { id: 1454 }] } },
+    { id: 36, name: "Discipline", elite: false, majorChoices: { 1: 1413, 2: 1489, 3: 1369 },
+      majorTraitsByTier: { 1: [{ id: 1413 }, { id: 1381 }, { id: 1415 }], 2: [{ id: 1489 }, { id: 1484 }, { id: 1709 }], 3: [{ id: 1369 }, { id: 1317 }, { id: 1657 }] } },
+    { id: 18, name: "Berserker", elite: true, majorChoices: { 1: 2049, 2: 2039, 3: 2043 },
+      majorTraitsByTier: { 1: [{ id: 2049 }, { id: 2042 }, { id: 1928 }], 2: [{ id: 2039 }, { id: 2011 }, { id: 1977 }], 3: [{ id: 2043 }, { id: 2038 }, { id: 2060 }] } },
+  ],
+  skills: {
+    heal: { id: 14402 }, utility: [{ id: 14404 }, { id: 14410 }, { id: 14405 }], elite: { id: 14355 },
+  },
+  underwaterSkills: { heal: null, utility: [null, null, null], elite: null },
+  equipment: {
+    statPackage: "Berserker's",
+    relic: "Relic of the Thief",
+    food: "Bowl of Sweet and Spicy Butternut Squash Soup",
+    utility: "Superior Sharpening Stone",
+    enrichment: "",
+    weapons: { mainhand1: "greatsword", offhand1: "", mainhand2: "axe", offhand2: "", aquatic1: "", aquatic2: "" },
+    runes: { head: "24836", shoulders: "24836", chest: "24836", hands: "24836", legs: "24836", feet: "24836" },
+    sigils: { mainhand1: ["24615", "24868"], offhand1: [], mainhand2: ["24615", ""], offhand2: [], aquatic1: [], aquatic2: [] },
+    infusions: { head: "49432", shoulders: "49432", chest: "49432", hands: "49432", legs: "49432", feet: "49432",
+      back: ["49432", "49432"], ring1: ["49432", "49432", "49432"], ring2: ["49432", "49432", "49432"],
+      accessory1: "49432", accessory2: "49432",
+      mainhand1: ["49432", "49432"], offhand1: [], mainhand2: ["49432", "49432"], offhand2: [] },
+  },
+  selectedLegends: ["", ""],
+  selectedPets: { terrestrial1: 0, terrestrial2: 0, aquatic1: 0, aquatic2: 0 },
+  activeAttunement: "",
+  activeAttunement2: "",
+  activeKit: 0,
+  activeWeaponSet: 1,
+  allianceTacticsForm: 0,
+  antiquaryArtifacts: { f2: 0, f3: 0, f4: 0 },
+  selectedUnderwaterLegends: ["", ""],
+};
+
+describe("encodeShareCode", () => {
+  test("produces valid wrapper format", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    expect(code).toMatch(/^<AxiForge:[A-Za-z]+:.+>$/);
+  });
+
+  test("label is elite spec name", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    expect(code.startsWith("<AxiForge:Berserker:")).toBe(true);
+  });
+
+  test("label is profession name for core build", () => {
+    const coreBuild = {
+      ...BERSERKER_BUILD,
+      specializations: BERSERKER_BUILD.specializations.map(s => ({ ...s, elite: false, name: s.elite ? "Arms" : s.name })),
+    };
+    const code = encodeShareCode(coreBuild);
+    expect(code.startsWith("<AxiForge:Warrior:")).toBe(true);
+  });
+});
+
+describe("isValidShareCode", () => {
+  test("returns true for valid code", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    expect(isValidShareCode(code)).toBe(true);
+  });
+  test("returns false for random text", () => {
+    expect(isValidShareCode("not a share code")).toBe(false);
+  });
+  test("returns false for GW2 chat link", () => {
+    expect(isValidShareCode("[&DQYlPSkvMBc=]")).toBe(false);
+  });
+});
+
+describe("decodeShareCode", () => {
+  test("round-trip: preserves profession", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.profession).toBe("Warrior");
+  });
+
+  test("round-trip: preserves game mode", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.gameMode).toBe("pve");
+  });
+
+  test("round-trip: preserves specialization IDs", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.specializations[0].id).toBe(4);
+    expect(decoded.specializations[1].id).toBe(36);
+    expect(decoded.specializations[2].id).toBe(18);
+  });
+
+  test("round-trip: preserves trait choices", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.specializations[0].traitChoices).toEqual([1, 1, 1]);
+    expect(decoded.specializations[2].traitChoices).toEqual([1, 1, 1]);
+  });
+
+  test("round-trip: preserves skill IDs", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.skills.healId).toBe(14402);
+    expect(decoded.skills.utilityIds).toEqual([14404, 14410, 14405]);
+    expect(decoded.skills.eliteId).toBe(14355);
+  });
+
+  test("round-trip: preserves stat package", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.statPackage).toBe("Berserker's");
+  });
+
+  test("round-trip: preserves weapon types", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.weapons.mainhand1).toBe("greatsword");
+    expect(decoded.equipment.weapons.mainhand2).toBe("axe");
+  });
+
+  test("round-trip: preserves relic", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.relic).toBe("Relic of the Thief");
+  });
+
+  test("round-trip: preserves food", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.food).toBe("Bowl of Sweet and Spicy Butternut Squash Soup");
+  });
+
+  test("round-trip: preserves rune IDs", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.runes.head).toBe("24836");
+  });
+
+  test("round-trip: preserves sigils", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.sigils.mainhand1).toEqual(["24615", "24868"]);
+    expect(decoded.equipment.sigils.mainhand2[0]).toBe("24615");
+  });
+
+  test("round-trip: preserves infusions (uniform)", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.infusions.head).toBe("49432");
+  });
+
+  test("throws on invalid format", () => {
+    expect(() => decodeShareCode("not valid")).toThrow("Invalid build code format");
+  });
+
+  test("throws on unknown version", () => {
+    expect(() => decodeShareCode("<AxiForge:Test:00000>")).toThrow();
+  });
+});
+
+// ── Profession-Specific Encoding Tests ───────────────────────────────────────
+
+describe("profession-specific round-trips", () => {
+  function makeBuild(overrides) {
+    const base = JSON.parse(JSON.stringify(BERSERKER_BUILD));
+    return Object.assign(base, overrides);
+  }
+
+  test("Revenant (Vindicator) round-trip", () => {
+    const build = makeBuild({
+      profession: "Revenant",
+      specializations: [
+        BERSERKER_BUILD.specializations[0],
+        BERSERKER_BUILD.specializations[1],
+        { id: 62, name: "Vindicator", elite: true, majorChoices: { 1: 2049, 2: 2039, 3: 2043 },
+          majorTraitsByTier: BERSERKER_BUILD.specializations[2].majorTraitsByTier },
+      ],
+      selectedLegends: ["Legend2", "Legend7"],
+      selectedUnderwaterLegends: ["Legend3", "Legend4"],
+      allianceTacticsForm: 1,
+    });
+    const code = encodeShareCode(build);
+    expect(code.startsWith("<AxiForge:Vindicator:")).toBe(true);
+
+    const decoded = decodeShareCode(code);
+    expect(decoded.profession).toBe("Revenant");
+    expect(decoded.selectedLegends).toEqual(["Legend2", "Legend7"]);
+    expect(decoded.allianceTacticsForm).toBe(1);
+  });
+
+  test("Ranger (Druid) round-trip", () => {
+    const build = makeBuild({
+      profession: "Ranger",
+      specializations: [
+        BERSERKER_BUILD.specializations[0],
+        BERSERKER_BUILD.specializations[1],
+        { id: 5, name: "Druid", elite: true, majorChoices: { 1: 2049, 2: 2039, 3: 2043 },
+          majorTraitsByTier: BERSERKER_BUILD.specializations[2].majorTraitsByTier },
+      ],
+      selectedPets: { terrestrial1: 46, terrestrial2: 59, aquatic1: 21, aquatic2: 40 },
+    });
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.selectedPets.terrestrial1).toBe(46);
+    expect(decoded.selectedPets.terrestrial2).toBe(59);
+  });
+
+  test("Elementalist (Weaver) round-trip", () => {
+    const build = makeBuild({
+      profession: "Elementalist",
+      specializations: [
+        BERSERKER_BUILD.specializations[0],
+        BERSERKER_BUILD.specializations[1],
+        { id: 56, name: "Weaver", elite: true, majorChoices: { 1: 2049, 2: 2039, 3: 2043 },
+          majorTraitsByTier: BERSERKER_BUILD.specializations[2].majorTraitsByTier },
+      ],
+      activeAttunement: "Fire",
+      activeAttunement2: "Water",
+    });
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.activeAttunement).toBe("Fire");
+    expect(decoded.activeAttunement2).toBe("Water");
+  });
+
+  test("Thief (Antiquary) round-trip", () => {
+    const build = makeBuild({
+      profession: "Thief",
+      specializations: [
+        BERSERKER_BUILD.specializations[0],
+        BERSERKER_BUILD.specializations[1],
+        { id: 77, name: "Antiquary", elite: true, majorChoices: { 1: 2049, 2: 2039, 3: 2043 },
+          majorTraitsByTier: BERSERKER_BUILD.specializations[2].majorTraitsByTier },
+      ],
+      antiquaryArtifacts: { f2: 76582, f3: 76702, f4: 77288 },
+    });
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.antiquaryArtifacts).toEqual({ f2: 76582, f3: 76702, f4: 77288 });
+  });
+
+  test("Engineer (Scrapper) round-trip", () => {
+    const build = makeBuild({
+      profession: "Engineer",
+      specializations: [
+        BERSERKER_BUILD.specializations[0],
+        BERSERKER_BUILD.specializations[1],
+        { id: 43, name: "Scrapper", elite: true, majorChoices: { 1: 2049, 2: 2039, 3: 2043 },
+          majorTraitsByTier: BERSERKER_BUILD.specializations[2].majorTraitsByTier },
+      ],
+      activeKit: 5812,
+    });
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.activeKit).toBe(5812);
+  });
+
+  test("Warrior active weapon set round-trip", () => {
+    const build = makeBuild({ activeWeaponSet: 2 });
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.activeWeaponSet).toBe(2);
+  });
+});
+
+// ── Per-Slot Mode Tests ──────────────────────────────────────────────────────
+
+describe("per-slot mode round-trips", () => {
+  function makeBuild(overrides) {
+    const base = JSON.parse(JSON.stringify(BERSERKER_BUILD));
+    return Object.assign(base, overrides);
+  }
+
+  test("uniform runes round-trip", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    for (const slot of ["head", "shoulders", "chest", "hands", "legs", "feet"]) {
+      expect(decoded.equipment.runes[slot]).toBe("24836");
+    }
+  });
+
+  test("per-slot runes (mixed) round-trip", () => {
+    const build = makeBuild({});
+    build.equipment.runes = {
+      head: "24836", shoulders: "24836", chest: "24836",
+      hands: "24836", legs: "24836", feet: "24691",
+    };
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.runes.head).toBe("24836");
+    expect(decoded.equipment.runes.feet).toBe("24691");
+  });
+
+  test("uniform infusions round-trip", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.infusions.head).toBe("49432");
+    expect(decoded.equipment.infusions.accessory1).toBe("49432");
+  });
+
+  test("per-slot infusions (mixed) round-trip", () => {
+    const build = makeBuild({});
+    build.equipment.infusions.shoulders = "37131";
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.equipment.infusions.head).toBe("49432");
+    expect(decoded.equipment.infusions.shoulders).toBe("37131");
+  });
+
+  test("underwater skills and weapons round-trip", () => {
+    const build = makeBuild({
+      underwaterSkills: {
+        heal: { id: 14402 },
+        utility: [{ id: 14404 }, { id: 14410 }, { id: 14405 }],
+        elite: { id: 14355 },
+      },
+    });
+    build.equipment.weapons.aquatic1 = "spear";
+    build.equipment.sigils.aquatic1 = ["24615", "24868"];
+    const code = encodeShareCode(build);
+    const decoded = decodeShareCode(code);
+    expect(decoded.underwaterSkills.healId).toBe(14402);
+    expect(decoded.underwaterSkills.utilityIds).toEqual([14404, 14410, 14405]);
+    expect(decoded.underwaterSkills.eliteId).toBe(14355);
+    expect(decoded.equipment.weapons.aquatic1).toBe("spear");
+    expect(decoded.equipment.sigils.aquatic1).toEqual(["24615", "24868"]);
+  });
+});
+
+// ── Error handling ───────────────────────────────────────────────────────────
+
+describe("error handling", () => {
+  test("truncated payload throws", () => {
+    const code = encodeShareCode(BERSERKER_BUILD);
+    const truncated = code.slice(0, code.length - 10) + ">";
+    expect(() => decodeShareCode(truncated)).toThrow();
+  });
+
+  test("invalid Z85 characters throws", () => {
+    expect(() => decodeShareCode("<AxiForge:Test:!!!invalid z85 chars!!!>")).toThrow();
+  });
+});