feat(editor): add WSRG (Spell Range Index) open catalog format

Open replacement for Blizzard's SpellRange.dbc plus the per-spell
range-bucket fields in Spell.dbc. Defines the categorical range
buckets that spells reference instead of carrying their own min/max
yards (every Frostbolt shares one 30y bucket; every Heal shares
one 40y friendly bucket). Each entry carries separate min/max for
hostile vs friendly targets so heals can reach further on allies
than nukes do on enemies, plus an icon color for HUD range
indicators.

Three preset emitters: --gen-srg (3 baseline buckets:
Self/Melee/Spell), --gen-srg-ranged (5 ranged spell buckets:
Short/Medium/Long/VeryLong/Unlimited), --gen-srg-friendly (3
friendly-only buckets where hostile range is 0). --info-wsrg and
--validate-wsrg round out the per-format surface; validation
catches negative ranges, min>max, duplicate ids, out-of-range
rangeKind, and warns on Self+nonzero range or Melee>8y.

Wired through the cross-format table so WSRG appears automatically
in --list-formats, --info-magic, --diff-headers, --summary-dir,
--rename-by-magic, --catalog-grep, --tree-summary-md, and
--touch-tree. Format count 67 -> 68; CLI flag count 885 -> 890.

src/pipeline/wowee_spell_ranges.cpp

@@ -0,0 +1,234 @@
+#include "pipeline/wowee_spell_ranges.hpp"
+
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+
+namespace wowee {
+namespace pipeline {
+
+namespace {
+
+constexpr char kMagic[4] = {'W', 'S', 'R', 'G'};
+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) != ".wsrg") {
+        base += ".wsrg";
+    }
+    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);
+}
+
+} // namespace
+
+const WoweeSpellRange::Entry*
+WoweeSpellRange::findById(uint32_t rangeId) const {
+    for (const auto& e : entries)
+        if (e.rangeId == rangeId) return &e;
+    return nullptr;
+}
+
+const char* WoweeSpellRange::rangeKindName(uint8_t k) {
+    switch (k) {
+        case Self:        return "self";
+        case Melee:       return "melee";
+        case ShortRanged: return "short";
+        case Ranged:      return "ranged";
+        case LongRanged:  return "long";
+        case VeryLong:    return "very-long";
+        case Unlimited:   return "unlimited";
+        default:          return "unknown";
+    }
+}
+
+bool WoweeSpellRangeLoader::save(const WoweeSpellRange& 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.rangeId);
+        writeStr(os, e.name);
+        writeStr(os, e.description);
+        writePOD(os, e.rangeKind);
+        uint8_t pad3[3] = {0, 0, 0};
+        os.write(reinterpret_cast<const char*>(pad3), 3);
+        writePOD(os, e.minRange);
+        writePOD(os, e.maxRange);
+        writePOD(os, e.minRangeFriendly);
+        writePOD(os, e.maxRangeFriendly);
+        writePOD(os, e.iconColorRGBA);
+    }
+    return os.good();
+}
+
+WoweeSpellRange WoweeSpellRangeLoader::load(const std::string& basePath) {
+    WoweeSpellRange 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.rangeId)) {
+            out.entries.clear(); return out;
+        }
+        if (!readStr(is, e.name) || !readStr(is, e.description)) {
+            out.entries.clear(); return out;
+        }
+        if (!readPOD(is, e.rangeKind)) {
+            out.entries.clear(); return out;
+        }
+        uint8_t pad3[3];
+        is.read(reinterpret_cast<char*>(pad3), 3);
+        if (is.gcount() != 3) { out.entries.clear(); return out; }
+        if (!readPOD(is, e.minRange) ||
+            !readPOD(is, e.maxRange) ||
+            !readPOD(is, e.minRangeFriendly) ||
+            !readPOD(is, e.maxRangeFriendly) ||
+            !readPOD(is, e.iconColorRGBA)) {
+            out.entries.clear(); return out;
+        }
+    }
+    return out;
+}
+
+bool WoweeSpellRangeLoader::exists(const std::string& basePath) {
+    std::ifstream is(normalizePath(basePath), std::ios::binary);
+    return is.good();
+}
+
+WoweeSpellRange WoweeSpellRangeLoader::makeStarter(
+    const std::string& catalogName) {
+    WoweeSpellRange c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t kind,
+                    float minR, float maxR, uint8_t r, uint8_t g,
+                    uint8_t b, const char* desc) {
+        WoweeSpellRange::Entry e;
+        e.rangeId = id; e.name = name; e.description = desc;
+        e.rangeKind = kind;
+        e.minRange = minR; e.maxRange = maxR;
+        // Default friendly == hostile.
+        e.minRangeFriendly = minR; e.maxRangeFriendly = maxR;
+        e.iconColorRGBA = packRgba(r, g, b);
+        c.entries.push_back(e);
+    };
+    add(1, "SelfRange",     WoweeSpellRange::Self,
+        0.0f, 0.0f,  240, 240, 240,
+        "Self-only — caster is the only valid target.");
+    add(2, "MeleeRange",    WoweeSpellRange::Melee,
+        0.0f, 5.0f,  220, 80, 80,
+        "Melee — within white-attack range (5y).");
+    add(3, "SpellRange",    WoweeSpellRange::Ranged,
+        0.0f, 30.0f, 100, 180, 240,
+        "Standard spell — 30 yards, common caster range.");
+    return c;
+}
+
+WoweeSpellRange WoweeSpellRangeLoader::makeRanged(
+    const std::string& catalogName) {
+    WoweeSpellRange c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t kind,
+                    float maxR, uint8_t r, uint8_t g, uint8_t b,
+                    const char* desc) {
+        WoweeSpellRange::Entry e;
+        e.rangeId = id; e.name = name; e.description = desc;
+        e.rangeKind = kind;
+        e.maxRange = maxR;
+        e.maxRangeFriendly = maxR;
+        e.iconColorRGBA = packRgba(r, g, b);
+        c.entries.push_back(e);
+    };
+    add(100, "ShortCast",  WoweeSpellRange::ShortRanged,  20.0f,
+        100, 200, 240, "Short-range spell — 20y. Close-up casts.");
+    add(101, "MediumCast", WoweeSpellRange::Ranged,       30.0f,
+        100, 180, 240, "Medium-range spell — 30y. Default caster range.");
+    add(102, "LongCast",   WoweeSpellRange::LongRanged,   40.0f,
+        100, 160, 240, "Long-range spell — 40y. Hunter / sniper range.");
+    add(103, "VeryLong",   WoweeSpellRange::VeryLong,     100.0f,
+        100, 140, 240, "Very-long range — 100y. Vision / aura range.");
+    add(104, "Unlimited",  WoweeSpellRange::Unlimited,    99999.0f,
+        140, 100, 240, "Unlimited range — global server-tracked spell.");
+    return c;
+}
+
+WoweeSpellRange WoweeSpellRangeLoader::makeFriendly(
+    const std::string& catalogName) {
+    WoweeSpellRange c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, float maxFriendly,
+                    float maxHostile, const char* desc) {
+        WoweeSpellRange::Entry e;
+        e.rangeId = id; e.name = name; e.description = desc;
+        e.rangeKind = WoweeSpellRange::Ranged;
+        // Friendly range is the larger of the two.
+        e.maxRange = maxHostile;
+        e.maxRangeFriendly = maxFriendly;
+        e.iconColorRGBA = packRgba(80, 240, 100);   // green for healing
+        c.entries.push_back(e);
+    };
+    add(200, "HealRange",     40.0f,  0.0f,
+        "Heal target — 40y friendly, 0y hostile (heals don't "
+        "reach enemies).");
+    add(201, "CleanseRange",  30.0f,  0.0f,
+        "Cleanse / dispel — 30y friendly only.");
+    add(202, "BuffRange",     30.0f,  0.0f,
+        "Beneficial buff — 30y friendly only (Power Word: "
+        "Fortitude, Mark of the Wild).");
+    return c;
+}
+
+} // namespace pipeline
+} // namespace wowee