feat(editor): add WACT (Action Bar Layout) open catalog format

Open replacement for the hardcoded per-class default action bar
bindings. Defines which abilities auto-populate which action
button slots when a new character is created or a class is
reset. A Warrior's button 1 binds Heroic Strike, button 2
Charge, button 3 Rend, etc. — new characters of that class get
those buttons pre-populated so the action bar isn't empty on
first login.

Distinct from WKBD (Keybindings) which maps physical keys to
action button slots — WACT maps action button slots to
abilities. The two together complete the default-control
configuration: Key 1 -> Action Slot 1 (WKBD) -> Heroic Strike
(WACT).

Seven barMode values cover the major action bar contexts:
  - Main (slots 0-11, standard 12-button bar)
  - Pet (hunter/warlock pet action bar)
  - Vehicle (mounted/vehicle action bar)
  - Stance1/2/3 (warrior battle/defensive/berserker; druid
    bear/cat/tree)
  - Custom (server-custom bar overlay)

Cross-references back to WCHC (classMask layout), WSPL (spellId
for the bound ability), and WIT (itemId for item-macro bindings
like Hearthstone in slot 12). findByClass(classBit, barMode)
returns the bindings sorted by buttonSlot — used directly by
character creation to populate action bars.

Three preset emitters: --gen-act (10 Warrior starter bindings on
Main bar with canonical 3.3.5a abilities), --gen-act-mage (10
Mage starter bindings including Counterspell + Polymorph),
--gen-act-pet (10 Hunter pet-bar bindings using barMode=Pet for
Attack/Stance/Bite/Claw/Dismiss).

Validation enforces id+name+classMask presence, barMode 0..6,
no duplicate ids; warns on:
  - buttonSlot > 143 (max is 12 bars × 12 slots = 144)
  - both spellId and itemId set (engine prefers spellId, item
    is silently ignored)
  - both spellId=0 AND itemId=0 (button will render empty)
  - (classMask + barMode + buttonSlot) collisions for
    overlapping classes — multiple bindings fighting for the
    same physical slot

Wired through the cross-format table; WACT appears in all 18
cross-format utilities. Format count 94 -> 95; CLI flag count
1083 -> 1088.

src/pipeline/wowee_action_bars.cpp

@@ -0,0 +1,290 @@
+#include "pipeline/wowee_action_bars.hpp"
+
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+
+namespace wowee {
+namespace pipeline {
+
+namespace {
+
+constexpr char kMagic[4] = {'W', 'A', 'C', 'T'};
+constexpr uint32_t kVersion = 1;
+
+template <typename T>
+void writePOD(std::ofstream& os, const T& v) {
+    os.write(reinterpret_cast<const char*>(&v), sizeof(T));
+}
+
+template <typename T>
+bool readPOD(std::ifstream& is, T& v) {
+    is.read(reinterpret_cast<char*>(&v), sizeof(T));
+    return is.gcount() == static_cast<std::streamsize>(sizeof(T));
+}
+
+void writeStr(std::ofstream& os, const std::string& s) {
+    uint32_t n = static_cast<uint32_t>(s.size());
+    writePOD(os, n);
+    if (n > 0) os.write(s.data(), n);
+}
+
+bool readStr(std::ifstream& is, std::string& s) {
+    uint32_t n = 0;
+    if (!readPOD(is, n)) return false;
+    if (n > (1u << 20)) return false;
+    s.resize(n);
+    if (n > 0) {
+        is.read(s.data(), n);
+        if (is.gcount() != static_cast<std::streamsize>(n)) {
+            s.clear();
+            return false;
+        }
+    }
+    return true;
+}
+
+std::string normalizePath(std::string base) {
+    if (base.size() < 5 || base.substr(base.size() - 5) != ".wact") {
+        base += ".wact";
+    }
+    return base;
+}
+
+uint32_t packRgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xFF) {
+    return (static_cast<uint32_t>(a) << 24) |
+           (static_cast<uint32_t>(b) << 16) |
+           (static_cast<uint32_t>(g) << 8)  |
+            static_cast<uint32_t>(r);
+}
+
+constexpr uint32_t CLS_WARRIOR = 1u << 0;
+constexpr uint32_t CLS_HUNTER  = 1u << 2;
+constexpr uint32_t CLS_MAGE    = 1u << 7;
+
+} // namespace
+
+const WoweeActionBar::Entry*
+WoweeActionBar::findById(uint32_t bindingId) const {
+    for (const auto& e : entries)
+        if (e.bindingId == bindingId) return &e;
+    return nullptr;
+}
+
+std::vector<const WoweeActionBar::Entry*>
+WoweeActionBar::findByClass(uint32_t classBit, uint8_t barMode) const {
+    std::vector<const Entry*> out;
+    for (const auto& e : entries) {
+        if ((e.classMask & classBit) == 0) continue;
+        if (e.barMode != barMode) continue;
+        out.push_back(&e);
+    }
+    std::sort(out.begin(), out.end(),
+              [](const Entry* a, const Entry* b) {
+                  return a->buttonSlot < b->buttonSlot;
+              });
+    return out;
+}
+
+const char* WoweeActionBar::barModeName(uint8_t m) {
+    switch (m) {
+        case Main:    return "main";
+        case Pet:     return "pet";
+        case Vehicle: return "vehicle";
+        case Stance1: return "stance1";
+        case Stance2: return "stance2";
+        case Stance3: return "stance3";
+        case Custom:  return "custom";
+        default:      return "unknown";
+    }
+}
+
+bool WoweeActionBarLoader::save(const WoweeActionBar& cat,
+                                 const std::string& basePath) {
+    std::ofstream os(normalizePath(basePath), std::ios::binary);
+    if (!os) return false;
+    os.write(kMagic, 4);
+    writePOD(os, kVersion);
+    writeStr(os, cat.name);
+    uint32_t entryCount = static_cast<uint32_t>(cat.entries.size());
+    writePOD(os, entryCount);
+    for (const auto& e : cat.entries) {
+        writePOD(os, e.bindingId);
+        writeStr(os, e.name);
+        writeStr(os, e.description);
+        writePOD(os, e.classMask);
+        writePOD(os, e.spellId);
+        writePOD(os, e.itemId);
+        writePOD(os, e.buttonSlot);
+        writePOD(os, e.barMode);
+        writePOD(os, e.pad0);
+        writePOD(os, e.pad1);
+        writePOD(os, e.iconColorRGBA);
+    }
+    return os.good();
+}
+
+WoweeActionBar WoweeActionBarLoader::load(const std::string& basePath) {
+    WoweeActionBar out;
+    std::ifstream is(normalizePath(basePath), std::ios::binary);
+    if (!is) return out;
+    char magic[4];
+    is.read(magic, 4);
+    if (std::memcmp(magic, kMagic, 4) != 0) return out;
+    uint32_t version = 0;
+    if (!readPOD(is, version) || version != kVersion) return out;
+    if (!readStr(is, out.name)) return out;
+    uint32_t entryCount = 0;
+    if (!readPOD(is, entryCount)) return out;
+    if (entryCount > (1u << 20)) return out;
+    out.entries.resize(entryCount);
+    for (auto& e : out.entries) {
+        if (!readPOD(is, e.bindingId)) {
+            out.entries.clear(); return out;
+        }
+        if (!readStr(is, e.name) || !readStr(is, e.description)) {
+            out.entries.clear(); return out;
+        }
+        if (!readPOD(is, e.classMask) ||
+            !readPOD(is, e.spellId) ||
+            !readPOD(is, e.itemId) ||
+            !readPOD(is, e.buttonSlot) ||
+            !readPOD(is, e.barMode) ||
+            !readPOD(is, e.pad0) ||
+            !readPOD(is, e.pad1) ||
+            !readPOD(is, e.iconColorRGBA)) {
+            out.entries.clear(); return out;
+        }
+    }
+    return out;
+}
+
+bool WoweeActionBarLoader::exists(const std::string& basePath) {
+    std::ifstream is(normalizePath(basePath), std::ios::binary);
+    return is.good();
+}
+
+WoweeActionBar WoweeActionBarLoader::makeWarrior(
+    const std::string& catalogName) {
+    using A = WoweeActionBar;
+    WoweeActionBar c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t slot,
+                    uint32_t spell, const char* desc) {
+        A::Entry e;
+        e.bindingId = id; e.name = name; e.description = desc;
+        e.classMask = CLS_WARRIOR;
+        e.spellId = spell;
+        e.buttonSlot = slot;
+        e.barMode = A::Main;
+        e.iconColorRGBA = packRgba(220, 60, 60);    // warrior red
+        c.entries.push_back(e);
+    };
+    // Warrior starter bindings — 10 abilities on slots 0-9.
+    add(1,  "WarriorBtn0_HeroicStrike",  0, 78,
+        "Heroic Strike — replaces next melee swing.");
+    add(2,  "WarriorBtn1_Charge",        1, 100,
+        "Charge — close gap from out of combat.");
+    add(3,  "WarriorBtn2_Rend",          2, 772,
+        "Rend — physical bleed DoT.");
+    add(4,  "WarriorBtn3_ThunderClap",   3, 6343,
+        "Thunder Clap — AoE damage + attack speed slow.");
+    add(5,  "WarriorBtn4_BattleShout",   4, 6673,
+        "Battle Shout — party-wide attack power buff.");
+    add(6,  "WarriorBtn5_SunderArmor",   5, 7386,
+        "Sunder Armor — armor reduction stack.");
+    add(7,  "WarriorBtn6_MockingBlow",   6, 694,
+        "Mocking Blow — taunt single target.");
+    add(8,  "WarriorBtn7_Hamstring",     7, 1715,
+        "Hamstring — movement-speed slow.");
+    add(9,  "WarriorBtn8_OverPower",     8, 7384,
+        "Overpower — instant strike after enemy dodge.");
+    add(10, "WarriorBtn9_VictoryRush",   9, 34428,
+        "Victory Rush — instant strike after a kill.");
+    return c;
+}
+
+WoweeActionBar WoweeActionBarLoader::makeMage(
+    const std::string& catalogName) {
+    using A = WoweeActionBar;
+    WoweeActionBar c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t slot,
+                    uint32_t spell, const char* desc) {
+        A::Entry e;
+        e.bindingId = id; e.name = name; e.description = desc;
+        e.classMask = CLS_MAGE;
+        e.spellId = spell;
+        e.buttonSlot = slot;
+        e.barMode = A::Main;
+        e.iconColorRGBA = packRgba(80, 140, 240);   // mage blue
+        c.entries.push_back(e);
+    };
+    add(100, "MageBtn0_Fireball",     0, 133,
+        "Fireball — primary fire-school spell.");
+    add(101, "MageBtn1_Frostbolt",    1, 116,
+        "Frostbolt — primary frost-school spell with chill.");
+    add(102, "MageBtn2_FrostNova",    2, 122,
+        "Frost Nova — AoE root and minor damage.");
+    add(103, "MageBtn3_Polymorph",    3, 118,
+        "Polymorph — single-target sheep CC.");
+    add(104, "MageBtn4_MageArmor",    4, 6117,
+        "Mage Armor — passive resistance + mana regen.");
+    add(105, "MageBtn5_ArcaneIntellect",5, 1459,
+        "Arcane Intellect — party-wide Intellect buff.");
+    add(106, "MageBtn6_Counterspell", 6, 2139,
+        "Counterspell — interrupt + 8s school lockout.");
+    add(107, "MageBtn7_Blink",        7, 1953,
+        "Blink — 20y forward teleport, breaks roots.");
+    add(108, "MageBtn8_FireBlast",    8, 2136,
+        "Fire Blast — instant fire damage, off-GCD trigger.");
+    add(109, "MageBtn9_ConjureWater", 9, 5504,
+        "Conjure Water — create mana-restoring water stack.");
+    return c;
+}
+
+WoweeActionBar WoweeActionBarLoader::makeHunterPet(
+    const std::string& catalogName) {
+    using A = WoweeActionBar;
+    WoweeActionBar c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t slot,
+                    uint32_t spell, const char* desc) {
+        A::Entry e;
+        e.bindingId = id; e.name = name; e.description = desc;
+        e.classMask = CLS_HUNTER;
+        e.spellId = spell;
+        e.buttonSlot = slot;
+        // Pet bar — separate from main bar.
+        e.barMode = A::Pet;
+        e.iconColorRGBA = packRgba(100, 200, 100);   // pet green
+        c.entries.push_back(e);
+    };
+    // Hunter pet bar — 10 standard slots on the dedicated
+    // Pet bar mode (slots 0-9).
+    add(200, "PetBtn0_Attack",        0,  2649,
+        "Attack — sic pet on current target.");
+    add(201, "PetBtn1_Follow",        1, 23110,
+        "Follow — recall pet to stand behind owner.");
+    add(202, "PetBtn2_Stay",          2,  6991,
+        "Stay — hold position, no auto-attack.");
+    add(203, "PetBtn3_Aggressive",    3,  2106,
+        "Aggressive stance — auto-engage nearby hostiles.");
+    add(204, "PetBtn4_Defensive",     4,  2104,
+        "Defensive stance — retaliate when hit.");
+    add(205, "PetBtn5_Passive",       5,  2105,
+        "Passive stance — never auto-engage.");
+    add(206, "PetBtn6_Bite",          6, 17253,
+        "Bite — pet's primary damage ability.");
+    add(207, "PetBtn7_Claw",          7, 16827,
+        "Claw — alt damage ability for cat/raptor families.");
+    add(208, "PetBtn8_Growl",         8,  2649,
+        "Growl — pet's taunt ability.");
+    add(209, "PetBtn9_DismissPet",    9,  2641,
+        "Dismiss Pet — return active pet to the stable.");
+    return c;
+}
+
+} // namespace pipeline
+} // namespace wowee