Closes the editing loop on the spell-cooldown bucket catalog: dump
a .wscd to JSON, hand-edit cooldownMs / bucketKind / category
flags (e.g. retune the global cooldown from 1.5s to 1.0s, mark a
bucket as IgnoresCooldownReduction, add Polymorph variants to the
class family bucket), re-import to a byte-identical binary.
The exporter emits both bucketKind (int 0..4) and the human-
readable bucketKindName ("spell", "item", "class", "global",
"misc"); same dual form for categoryFlags (int bitfield AND
"AffectedByHaste|OnGCDStart" pipe-separated label string). The
importer prefers the int form for categoryFlags when both are
present so unknown flag bits round-trip losslessly, falling back
to the label form for hand-edited sidecars.
Verified byte-identical round-trip on all three presets
(starter / class / items). CLI flag count 912 -> 914.
Open replacement for SpellCooldown.dbc plus the per-spell
category-cooldown fields in Spell.dbc. Defines the shared-cooldown
buckets that related spells reference: casting one spell triggers
a cooldown on every other spell in the same bucket. Mage Polymorph
variants (Sheep / Pig / Turtle / Cat) all share one bucket so
morphing a target locks all variants at once. Healing potions and
mana potions share the SharedWithItems bucket so consuming one
locks the other.
Distinct from WSDR (which times how long an aura stays on a
target) — WSCD times how long before a spell can be cast again.
The global cooldown (GCD) is itself just one bucket of this kind,
flagged with OnGCDStart so the engine triggers it at cast start
rather than cast finish.
Three preset emitters: --gen-cdb (4 baseline buckets including
GCD), --gen-cdb-class (5 mage-specific class cooldowns including
the Polymorph family), --gen-cdb-items (5 item cooldowns
including the heal/mana potion shared bucket and the 60min
Hearthstone family). Validation enforces id+name presence,
bucketKind 0..4, no duplicate ids, and warns on Global without
OnGCDStart (engine wouldn't trigger on cast start) and Spell
kind with SharedWithItems (contradictory).
categoryFlags is a bitfield (AffectedByHaste / SharedWithItems /
OnGCDStart / IgnoresCooldownReduction); --info-wscd decodes the
bits to label list. Wired through the cross-format table; WSCD
appears automatically in all 9 cross-format utilities. Format
count 70 -> 71; CLI flag count 907 -> 912.
Walks a directory recursively and groups problems by category:
too-small (file under 16 bytes — can't hold a header),
unknown-magic (.w* file whose magic is not in the format table),
ext-mismatch (extension says one format but the magic says
another — usually from a renamed file), magic-no-ext (file with
recognized Wowee magic but no .w* extension), and header-trunc
(magic matches but the rest of the header is truncated). Returns
exit 1 if any issue is found, so it composes into shell pipelines
and CI checks. JSON sidecar via --json.
Catches the kinds of breakage that --summary-dir silently rolls
into the "unrecognized" bucket — a renamed .wsrg file masquerading
as .wsct shows up cleanly here but would otherwise be invisible.
Like every cross-format utility this reuses cli_format_table.cpp,
so new formats are audited automatically. CLI flag count
906 -> 907.
Closes the editing loop on the spell-duration bucket catalog: dump
a .wsdr to JSON, hand-edit baseDurationMs / perLevelMs / clamp /
durationKind (e.g. retune Renew from 9s to 10s base across every
spell that references the HoT5Tick bucket), re-import to a
byte-identical binary. The exporter emits both durationKind (int
0..4) and the human-readable durationKindName ("instant", "timed",
"tick", "until-cancelled", "until-death"); the importer accepts
either, so JSON sidecars stay readable without losing the
canonical binary encoding.
Verified byte-identical round-trip on all three presets
(starter / buffs / dot). CLI flag count 904 -> 906.
Open replacement for SpellDuration.dbc plus per-spell duration
fields in Spell.dbc. Defines the categorical duration buckets
that auras / DoTs / HoTs / buffs reference (5s / 30s / 5min / 1hr
/ UntilCancelled / UntilDeath).
Together with WSRG (range) and WSCT (cast time), this completes a
small triplet of spell-metadata catalogs: instead of every
Frostbolt rank embedding its own range, cast time, and
chill-debuff duration as duplicate fields, each spell holds three
small integer ids that resolve through these three tables. The
engine retunes thousands of spells at once by editing one bucket.
Duration scales with caster level via perLevelMs (a rank-1 Renew
at 9s grows to 12s at lvl 60), then is clamped to maxDurationMs.
Negative baseDurationMs is the canonical sentinel for "no timer"
(UntilCancelled / UntilDeath); resolveAtLevel returns -1 for
those so HUD code can render the indefinite-duration glyph.
Three preset emitters: --gen-sdr (5 baseline tiers from instant
to one-hour), --gen-sdr-buffs (4 long-duration buffs including
UntilDeath), --gen-sdr-dot (4 tick-based DoT/HoT buckets at 3s
ticks). Validation enforces base>0 for Timed/TickBased, base<0
for permanent kinds, max>=base, durationKind 0..4, no duplicate
ids, and warns on Instant+nonzero base.
Wired through the cross-format table; WSDR appears automatically
in all 9 cross-format utilities. Format count 69 -> 70; CLI flag
count 899 -> 904.
Closes the editing loop on the spell-cast-time bucket catalog:
dump a .wsct to JSON, hand-edit baseCastMs / perLevelMs / clamp
bounds (retune a Pyroblast bucket from 3000ms to 2800ms across
every spell that references it), re-import to a byte-identical
binary. The exporter emits both castKind (int 0..4) and the
human-readable castKindName ("instant", "cast", "channel",
"delayed", "charge"); the importer accepts either.
Verified byte-identical round-trip on all three presets
(starter / channel / ramp). CLI flag count 897 -> 899.
Companion to WSRG: open replacement for SpellCastTimes.dbc plus
the per-spell castTime fields in Spell.dbc. Defines categorical
cast-time buckets (Instant 0ms / FastCast 1s / MediumCast 1.5s /
LongCast 3s) that thousands of spells reference instead of each
embedding their own ms count. Together WSRG and WSCT let the
spell engine resolve "Frostbolt's range bucket = id 3" and
"Frostbolt's cast time bucket = id 5" with two table reads
instead of duplicating per-rank data.
Cast time can scale with character level via perLevelMs (a rank-1
spell at 1000ms can grow to 2200ms at lvl 60), then the bucket
result is clamped to [minCastMs, maxCastMs] before haste is
applied. resolveAtLevel() does the math for engine consumers.
Three preset emitters: --gen-sct (4 baseline buckets),
--gen-sct-channel (3 channeled-spell durations), --gen-sct-ramp
(4 level-scaled buckets with non-zero perLevelMs). Validation
catches negative baseCastMs, min>max, duplicate ids, warns on
Instant kind with non-zero base (cast bar would still show), and
errors on Channel kind with zero base (would tick once and end).
Wired through the cross-format table; WSCT appears automatically
in all 9 cross-format utilities. Format count 68 -> 69; CLI flag
count 892 -> 897.
Closes the editing loop on the spell-range bucket catalog: dump a
.wsrg to a JSON sidecar, hand-edit the buckets (rename, retune
yards, recolor HUD indicator), re-import to a byte-identical
binary. The exporter emits both the int rangeKind (0..6) and the
human-readable rangeKindName ("self", "melee", "short", "ranged",
"long", "very-long", "unlimited"); the importer accepts either,
so JSON sidecars stay readable without losing the canonical binary
encoding.
Verified byte-identical round-trip on all three presets (starter,
ranged, friendly). CLI flag count 890 -> 892.
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.
Compares two .w* files at the standard catalog header level:
4-byte magic, version, catalog name, entry count, total file
bytes. Useful for confirming a JSON round-trip didn't drift,
checking whether two preset emissions produced equivalent
output, or quickly diagnosing when a content snapshot has
silently shifted (entry count up means content was added,
file bytes up but everything else same means entry payloads
got fatter).
Output uses = / ≠ markers per field so visual scanning is
fast. Three diagnostic summary cases: identical headers (and
same bytes — possibly byte-equal, run cmp(1) to confirm),
same shape but bytes differ (entry payloads diverged), and
different formats entirely (files are unrelated).
Returns exit 1 if any field differs, so the flag composes
into shell pipelines (`if diff-headers a.wcms b.wcms; then ...`).
World/asset formats stop after magic since their layouts
diverge from the standard catalog header.
Supports --json variant for tooling integration.
Closes the JSON round-trip gap on the quest sort catalog
format shipped last batch. --export-wqso-json emits all 9
scalar fields plus a dual int + name form for sortKind (12
values) so hand-edits can use either representation.
--import-wqso-json accepts either form. Verified byte-
identical round-trip on all three preset emitters (starter
3-sort generic / 10-class with WCHC bit masks / 8-profession
with WTSK enum cross-refs). 884 documented CLI flags.
67th open format — replaces QuestSort.dbc plus the quest-log
categorization fields in QuestInfo.dbc. Defines the
categories that quests fall into for the quest-log UI:
class quests (Warrior trial, etc), profession quests, daily
quests, holiday events, reputation grinds, dungeon /
heroic / raid quests, repeatables, PvP, tournament.
12 sort kinds (General / ClassQuest / Profession / Daily /
Holiday / Reputation / Dungeon / Raid / Heroic / Repeatable
/ PvP / Tournament). Each WQT (quest) entry can reference
a sortId here to be grouped under the right header in the
quest log. Sorts can be class-restricted (Warrior quests
only show for warriors), profession-restricted, or
faction-reputation-gated.
Cross-references with prior formats — targetClassMask uses
WCHC.classId bit positions (matches WGLY/WSET/WGTP
convention), targetProfessionId points at WTSK.profession
enum, targetFactionId points at WFAC.factionId.
CLI: --gen-qso (3 generic sorts — General catch-all, Daily
reset, Repeatable non-daily), --gen-qso-class (10 class-
specific sorts with proper bit masks for Warrior 0x02
through Druid 0x800), --gen-qso-profession (8 profession
sorts with WTSK profession enum cross-refs), --info-wqso,
--validate-wqso with --json variants. Validator catches
id+name+displayName required, kind 0..11, ClassQuest with
classMask=0 (not actually class-restricted), Profession
with profId=0 + non-Blacksmithing-name (likely typo since
0=Blacksmithing in WTSK), and Reputation with factionId=0
(no faction to grind).
Format graph: 66 → 67 binary formats. CLI flag count: 877
→ 882.
Closes the JSON round-trip gap on the unit movement catalog
format shipped this batch. --export-wumv-json emits all 11
scalar fields plus a dual int + name form for
movementCategory (12 values) so hand-edits can use either
representation. --import-wumv-json defaults baseMultiplier
to 1.0 and maxMultiplier to 1.4 (canonical Sprint cap)
when omitted. Verified byte-identical round-trip on all
three preset emitters (starter / flight / buffs). 877
documented CLI flags.
66th open format — replaces UnitMovement.dbc plus the
movement-modifier portions of CreatureModelData.dbc. Defines
movement speed types (walk / run / swim / flight / fly /
pitch) with their canonical baseline speeds in yards-per-
second, plus the temp speed buffs that stack on top
(Sprint, Aspect of the Cheetah, Travel Form).
12 movement categories cover the canonical surface (Walk /
Run / Backward / Swim / SwimBack / Turn / Flight /
FlightBack / Pitch / Fly / FlyBack / TempBuff). baseSpeed
is yards/second for baseline categories and ignored for
TempBuff entries (which use baseMultiplier instead).
maxMultiplier caps stacking — Sprint capped at 1.4 means
Sprint + Aspect of Cheetah doesn't exceed 1.4× run speed.
stackingPriority resolves conflicts when multiple buffs
of equal multiplier compete (higher wins).
CLI: --gen-umv (4 baseline at canonical WoW vanilla speeds:
Walk 2.5y/s, Run 7.0y/s, Swim 4.7y/s, Turn π rad/s),
--gen-umv-flight (5 flight entries — ground-rail Flight
7y/s, free Fly 14y/s, Pitch 1.5 rad/s, backward variants
at slower 4.5y/s), --gen-umv-buffs (5 temp speed buffs
matching real WoW spell auras with proper durations and
stacking priorities), --info-wumv, --validate-wumv with
--json variants. Validator catches id+name required,
category 0..11, baseMultiplier > 0 (otherwise unit freezes
in place), maxMultiplier >= baseMultiplier (cap below
floor would clamp the base down), baseline categories
need baseSpeed > 0, and Run < 3.0y/s warning (canonical
is 7.0y/s).
Format graph: 65 → 66 binary formats. CLI flag count: 870
→ 875.
Closes the JSON round-trip gap on the combat rating
conversion catalog format shipped last batch.
--export-wcrr-json emits all 10 scalar fields plus a dual
int + name form for ratingKind so hand-edits can use
either representation. --import-wcrr-json defaults
pointsAtL1/L60/L70/L80 to canonical WoW WotLK starter
values when omitted (1 / 14 / 22 / 45) — matches typical
combat rating curves so a sparse sidecar still produces a
working catalog. Verified byte-identical round-trip on all
three preset emitters (starter Hit/Crit/Haste / defensive
Defense+Dodge+Parry+Block / spell SpellPower+Pen+MP5).
870 documented CLI flags.
65th open format — replaces gtCombatRatings.dbc plus the
per-level rating-to-percentage tables in gtRegenHPPerSpt.dbc
and related stat-curve DBCs. Defines per-rating-type
conversion factors at canonical level breakpoints (1 / 60
/ 70 / 80) — the runtime linearly interpolates between
breakpoints for intermediate levels.
pointsAtLevelN is "how many rating points equal 1% of the
benefit at that level." Higher level = more rating needed
for the same %. Standard WoW WotLK example: 14 crit rating
= 1% crit at L60, but 45.91 = 1% at L80.
5 rating kinds (Combat / Defense / Spell / Resilience /
Other) classify what stat resolver category each rating
belongs to.
CLI: --gen-crr (3 essential combat ratings — Hit/Crit/Haste
at canonical WoW WotLK conversion values), --gen-crr-defensive
(4 defensive — Defense/Dodge/Parry/Block with diminishing-
returns soft-cap percentages), --gen-crr-spell (3 spell —
SpellPower direct 1:1, SpellPenetration flat, MP5 mana
regen), --info-wcrr, --validate-wcrr with --json variants.
Validator catches id+name required, kind 0..4, all
pointsAtLN > 0 (otherwise stat resolver would div-by-zero),
maxBenefitPercent > 0 (rating would never grant any
benefit), and non-monotonic conversion curve warning
(rating cost typically ascends with level for non-flat
ratings like SpellPower).
Format graph: 64 → 65 binary formats. CLI flag count: 861
→ 868.
Closes the JSON round-trip gap on the item-suffix catalog
format shipped this batch. --export-wsuf-json emits all 5
scalar fields plus a dual int + name form for suffixCategory
and a nested stats[] array — only populated stat slots are
emitted to keep hand-edits compact. --import-wsuf-json
clears the trailing stat slots before parsing (so a 2-stat
sidecar correctly leaves slots 2-4 zero) and accepts
suffixCategory by either int or name. Verified byte-
identical round-trip on all three preset emitters (starter
2-stat / magical 1-stat / PvP 3-stat). 863 documented CLI
flags.
64th open format — replaces ItemRandomProperties.dbc +
ItemRandomSuffix.dbc plus the AzerothCore-style suffix-roll
tables. Defines random "of the X" suffixes that roll on
green and blue items at world drop ("Sturdy Cloth Cap of
the Bear" = base item + STR + STA suffix).
5 suffix categories (Generic / Elemental / Defensive /
PvPSuffix / Crafted), per-suffix item-quality bracket gating
(only blue+ items can roll PvPSuffix), restricted-slot mask
that limits which equipment slots a suffix can apply to (15
slot bits matching WCEQ slot enum), and up to 5 stat bonus
slots per suffix matching WoW canonical max.
statValuePoints isn't an absolute number — it's a scaling
base that the runtime multiplies by an item-level
coefficient to compute the final per-item bonus, so "of the
Bear" gives proportionally more strength on a level-60 item
than on a level-20 item.
Cross-references with prior formats — statKind values match
WIT.statType enum (STR=4, AGI=3, INT=5, SPI=6, STA=7) so
item generators roll consistent stats with base items.
CLI: --gen-suf (3 generic stat triads — Bear STR+STA, Eagle
INT+SPI, Tiger STR+AGI), --gen-suf-magical (4 elemental
spell-power suffixes restricted to caster-eligible slots),
--gen-suf-pvp (3 PvPSuffix entries with resilience + offensive
stats, blue+ quality only), --info-wsuf, --validate-wsuf with
--json variants. Validator catches id+name required, category
0..4, quality range valid (0..7 covers heirloom), itemQuality
floor<=ceiling, stat-kind/value pairing (kind=0 with value!=0
is a typo, vice versa), and no-stats warning (suffix renames
item without changing it).
Format graph: 63 → 64 binary formats. CLI flag count: 854
→ 861.
Closes the JSON round-trip gap on the loading screen catalog
format shipped last batch. --export-wlds-json emits all 11
scalar fields plus a dual int + name form for
expansionRequired so hand-edits can use either representation.
--import-wlds-json accepts either form, defaulting minLevel
to 1 and maxLevel to 80 when omitted (full level range).
Verified byte-identical round-trip on all three preset
emitters (starter / WotLK instances / raid intros with
isWideAspect=1). 856 documented CLI flags.
63rd open format — replaces LoadingScreens.dbc plus the
per-zone background-image tables. Defines the loading-screen
images shown when the client crosses into a new map /
instance, with optional level-bracket gating and expansion
gating (TBC art only shown if expansion installed).
When multiple screens match the player's current map + level
+ expansion, displayWeight selects randomly between them — a
zone with 3 weighted variants gets a different image roughly
proportional to weight.
4 expansion gates (Classic / TBC / WotLK / TurtleWoW),
isAnimated flag for screens with subtle animation,
isWideAspect flag for 16:9 raid intro art (vs 4:3 standard).
Cross-references with prior formats — mapId points at
WMS.map.mapId (which map triggers this loading screen);
mapId=0 is the catch-all sentinel for screens shown when
no map-specific screen matches.
CLI: --gen-lds (3 base screens — Elwynn level 1-30, Orgrimmar,
GenericFallback level 31-80 catch-all), --gen-lds-instances
(5 WotLK dungeon screens with mapId+expansion cross-refs:
Halls of Lightning/Stone, Utgarde Pinnacle, Violet Hold,
Old Kingdom), --gen-lds-raid (3 raid intro screens —
Naxxramas/Ulduar/ToC at isWideAspect=1 with weight=3),
--info-wlds, --validate-wlds with --json variants. Validator
catches id+name+texture required, expansion 0..3, level range
valid, weight=0 (in pool but never picked), and the practical
catch-all overlap warning when multiple mapId=0 screens share
overlapping level brackets (random pick becomes
non-deterministic).
Format graph: 62 → 63 binary formats. CLI flag count: 847
→ 854.
Closes the JSON round-trip gap on the DK rune cost catalog
format shipped this batch. --export-wrun-json emits all 9
scalar fields plus a dual int + name form for spellTreeBranch
(4 values) so hand-edits can use either representation.
--import-wrun-json accepts either form. Verified byte-
identical round-trip on all three preset emitters (starter
3-cost / blood-tree 4-cost / frost-tree 4-cost).
849 documented CLI flags.
62nd open format — replaces RuneCost.dbc plus the DK-specific
portions of ChrPowerType. Defines per-spell rune costs (Blood
/ Frost / Unholy) and runic-power generation / consumption
for the Death Knight class.
4 spell tree branches (BloodTree / FrostTree / UnholyTree /
Generic) classify which spec uses each rune cost. Each entry
binds a spell to its rune cost (how many of each rune kind
the spell consumes), an optional anyDeathConvertCost (extra
Death-rune-acceptable cost for procced abilities), and a
runicPowerCost (negative = generator, positive = spender).
Cross-references with prior formats — spellId points at
WSPL.spellId (the spell that uses this rune cost).
CLI: --gen-rune (3 baseline DK abilities — Death Strike
1F+1U + 20RP gen, Frost Strike pure 40 RP spender, Heart
Strike 1B + 10RP gen), --gen-rune-blood (4 blood-tree DK
abilities — Heart Strike, Death and Decay AoE, Vampiric
Blood tank cooldown, Rune Tap self-heal), --gen-rune-frost
(4 frost-tree — Frost Strike, Howling Blast AoE, Obliterate
finisher, Icy Touch ranged opener applying Frost Fever),
--info-wrun, --validate-wrun with --json variants. Validator
catches id+name+spellId required, branch 0..3, no rune cost
> 2 (DK only has 2 of each rune type so a higher cost can
never be paid), runicPowerCost > 100 (DK RP cap), no-cost
warning (spell consumes nothing — verify it's a
passive/stance/form), and high-RP-generator warning (> 25
RP per cast is unusual).
Format graph: 61 → 62 binary formats. CLI flag count: 840
→ 847.
Closes the JSON round-trip gap on the bag/bank catalog format
shipped last batch. --export-wbnk-json emits all 8 scalar
fields plus a dual int + name form for bagKind so hand-edits
can use either representation. --import-wbnk-json defaults
isUnlocked to 1 and acceptsBagSubclassMask to kAcceptsAny
Container when omitted — matches the typical case for
inventory and bank slots so a sparse sidecar still produces
a working catalog. Verified byte-identical round-trip on all
three preset emitters (starter inventory / 8-slot bank with
gold cost ramp / 4 special slots covering keyring + soul
shard + quiver + stable). 842 documented CLI flags.
61st open format — replaces ItemBag.dbc plus the bank-storage
and special-purpose container tables. Defines every slot the
player has access to: equipped bags, bank bags, keyring, soul
shard bag, quiver, reagent bag, hunter pet stable.
8 bag kinds (Inventory / Bank / Keyring / Quiver / SoulShard /
Stable / Reagent / Wallet) cover the canonical container
surface. Each entry has a fixed capacity (or 0 = variable,
size set by equipped bag), a display order in the inventory
UI, an unlock state with optional gold cost (bank bags ramp
through 10s / 1g / 10g / 25g / 50g / 100g matching canonical
WoW prices), and an accepts-bag-subclass mask gating which
container kinds may be equipped (generic / herb / enchanting
/ engineer / gem / mining / leather / inscription / quiver /
ammo pouch).
Cross-references with prior formats — fixedBagItemId points
at WIT.itemId for the bag item that always occupies a fixed
slot (0 = player-equipable variable slot).
CLI: --gen-bnk (5 inventory slots — 16-slot fixed main
backpack + 4 player-equippable bag slots accepting generic
containers + herb + enchanting bags), --gen-bnk-bank (8 bank
bag slots with the canonical WoW unlock cost ramp),
--gen-bnk-special (4 special-purpose: 32-slot Keyring fixed,
warlock SoulShardBag, hunter ArrowQuiver, hunter
HuntersStable for 5 pets), --info-wbnk, --validate-wbnk with
--json variants. Validator catches id+name required, kind
0..7, locked-with-zero-cost (slot can never be unlocked),
fixed-slot-with-non-zero-mask (equippable bag would be
ignored), variable slot with empty mask (no bag can fit),
and ambiguous (bagKind, displayOrder) tuples (UI sort would
flicker).
Format graph: 60 → 61 binary formats. CLI flag count: 833
→ 840.
Closes the JSON round-trip gap on the PvP rank catalog
format shipped this batch. --export-wpvp-json emits all 12
scalar fields plus a dual int + name form for rankKind (5
values) so hand-edits can use either representation.
--import-wpvp-json defaults bracket level to 1..80 (no level
gate) when omitted — matches the typical case for vanilla
honor ranks which weren't level-gated beyond the cap.
Verified byte-identical round-trip on all three preset
emitters (starter / alliance vanilla 9-rank ladder / arena
5-tier ladder). 835 documented CLI flags.
60th open format milestone — replaces the AzerothCore-style
PvP rank tables plus the vanilla honor-rank reward chains.
Defines PvP progression rungs: vanilla honor ranks (Private
through Grand Marshal / High Warlord), arena rating brackets
(Combatant / Challenger / Rival / Duelist / Gladiator), and
battleground rated tiers.
5 rank kinds (VanillaHonor / ArenaRating / BattlegroundRated /
WorldPvP / ConquestPoint) cover the canonical PvP progression
surface. Each entry carries an alliance-specific name and a
horde-specific name (Grand Marshal = High Warlord; arena tiers
share the same name on both factions), an honor or rating
threshold, and optional gear cross-refs (chest, gloves,
shoulders) into WIT.
Cross-references with prior formats — titleId points at
WTTL.titleId (the unlock title), chest/gloves/shoulders point
at WIT.itemId for the matching PvP set, bracketBgId points at
WBGD.bgId for battleground-bracket gating.
CLI: --gen-pvp (3 vanilla entry tiers Rank2-4 with alliance
vs horde alternate names), --gen-pvp-alliance (9 vanilla
ranks 6-14 with WTTL+WIT cross-refs and ramping honor
thresholds 50k → 260k), --gen-pvp-arena (5 arena rating
brackets 1500/1750/2000/2200/2400 with 10/20/40/80/160 emblem
rewards), --info-wpvp, --validate-wpvp with --json variants.
Validator catches id+name required, kind 0..4, level range
valid, faction-name pairing (one set without the other is a
typo), threshold monotonicity within a rankKind, arena rating
below 1500 floor, and VanillaHonor with minHonor=0 baseline
warning.
Format graph: 59 → 60 binary formats (milestone). CLI flag
count: 826 → 833.
Closes the JSON round-trip gap on the character customization
feature catalog format shipped last batch. --export-wchf-json
emits all 9 scalar fields plus dual int + name forms for
featureKind (9 values) / sexId (2 values) /
requiresExpansion (4 values) so hand-edits can use either
representation. --import-wchf-json accepts either form.
Verified byte-identical round-trip on all three preset
emitters (starter Human Male / Blood Elf Female hair / Tauren
Male horns + facial hair). 828 documented CLI flags.
59th open format — replaces CharHairGeosets.dbc +
CharFacialHairStyles.dbc plus the variation portions of
CharSections.dbc. Defines per-(race, sex) customization
options the character creation screen exposes: skin colors,
face variations, hair styles, hair colors, facial hair
(beards / mustaches), and race-specific markings (Tauren
horns, Draenei tendrils, Blood Elf ears).
9 feature kinds (SkinColor / FaceVariation / HairStyle /
HairColor / FacialHair / FacialColor / EarStyle / Horns /
Markings) cover the full canonical customization surface.
Each entry is one selectable carousel choice for one
(race, sex, kind) tuple — variationIndex disambiguates.
expansionGate enum gates Blood Elf / Draenei (TBC) and DK
features (WotLK) behind the right expansion unlock.
Cross-references with prior formats — raceId points at
WCHC.race.raceId. requiresExpansion bit positions match
the WLFG expansion enum (Classic=0, TBC=1, WotLK=2,
Turtle=3) for consistency.
CLI: --gen-chf (5 Human Male starter — skin / face / 2
hair styles / facial hair), --gen-chf-bloodelf (8 Blood
Elf Female hair styles, requiresExpansion=TBC — the
iconic TBC race feature), --gen-chf-tauren (6 Tauren Male
features using race-specific Horns kind + 3 facial hair
variations), --info-wchf, --validate-wchf with --json
variants. Validator catches id+name+raceId+texturePath
required, kind 0..8 / sex 0..1 / expansion 0..3, and the
critical (race, sex, kind, variation) tuple-uniqueness
check — duplicates would shadow each other in the create-
character carousel.
Format graph: 58 → 59 binary formats. CLI flag count: 819
→ 826.
Closes the JSON round-trip gap on the macro catalog format
shipped this batch. --export-wmac-json emits all 8 scalar
fields plus a dual int + name form for macroKind. The
macroBody string is dumped verbatim — multi-line bodies
preserve embedded '\n' as JSON-escape sequences which most
editors render readably (e.g. nlohmann pretty-print expands
\n to actual newlines in the rendered output).
--import-wmac-json defaults maxLength to 255 (the WoW
canonical UI cap) when omitted. Verified byte-identical
round-trip on all three preset emitters (starter / combat
multi-line bodies / utility). 821 documented CLI flags.
58th open format — novel format with no direct DBC equivalent.
WoW historically stored player macros client-side in the user
profile and system slash commands as hardcoded engine handlers;
WMAC unifies both into a single structured catalog so default
macros, system slash commands, and shipped player presets can
be authored, validated, and shipped as content alongside the
rest of the open-format graph.
5 macro kinds (SystemSlash for engine /sit /dance handlers,
DefaultMacro for shipped presets, PlayerTemplate for user
templates, GuildMacro for guild-shared, SharedMacro for
account-wide). Multi-line macro bodies are stored verbatim
with literal '\n' separators — the client parses /cast /
/target / /run lines at runtime.
Cross-references with prior formats — requiredClassMask uses
WCHC.classId bit positions (Warrior=0x02, etc, same as WGLY/
WSET/WGTP).
CLI: --gen-mac (3 system slash — /sit, /dance, /target with
[@mouseover] modifier), --gen-mac-combat (4 warrior combat
templates — heroic strike spam, charge/intercept stance dance,
intercept stance switch, victory rush+bloodthirst fallback —
each with default key bindings), --gen-mac-utility (3 universal
utility — /follow target, mass /inv with %targetN tokens,
/releasecorpse via RepopMe()), --info-wmac, --validate-wmac
with --json variants. Validator catches id+name+body required,
kind 0..4, body within maxLength cap, body starting with '/'
or '#' (slash command or showtooltip annotation), and
SystemSlash + classMask warning (slash commands are class-
agnostic — restricting them to a class makes no sense).
Format graph: 57 → 58 binary formats. CLI flag count: 814
→ 819.
Recursively walks a directory, parses the standard catalog
header (magic + version + name + entryCount) of every
recognized catalog format, and reports files whose internal
catalog NAME field matches a pattern. Useful when you've
got a content bundle and need to find "where is the catalog
named WintergraspUI?" or "list every Starter* preset in
this directory" without per-format parsing.
Case-insensitive substring match by default (--case-sensitive
opts in to literal match). Returns exit 1 when no match —
designed for shell composition (`if catalog-grep ... ; then ...`).
World/asset formats (.wom/.wob/.whm/.wot/.wow) are skipped
since they don't follow the catalog-header layout.
Supports --json variant for tooling integration. Reuses
cli_format_table.cpp so any new catalog format is searchable
automatically.
Closes the JSON round-trip gap on the LFG dungeon catalog
format shipped this batch. --export-wlfg-json emits all 13
scalar fields plus dual int + name forms for difficulty
(4 values) and expansionRequired (4 values) so hand-edits
can use either representation. --import-wlfg-json defaults
groupSize to 5 (dungeon) and requiredRolesMask to kRoleAll
(all three role types) when omitted — matches the typical
queue setup for cross-realm dungeon finder. Verified
byte-identical round-trip on all three preset emitters
(starter classic dungeons / heroic 5-mans / 25-man raids).
813 documented CLI flags.
57th open format — replaces LFGDungeons.dbc plus the
AzerothCore-style dungeon-finder reward tables. Defines the
dungeons / raids that the Dungeon Finder / Raid Browser
presents to players, with their level brackets, group-size
requirements, role requirements (tank / heal / DPS), and
queue-completion rewards.
4 difficulty levels (Normal / Heroic / Mythic / Hardmode —
the latter for Ulduar-style toggleable boss difficulty),
4 expansion gates (Classic / TBC / WotLK / TurtleWoW), and
3 role-requirement bits (Tank / Heal / DPS — typically all
three for queue-formed groups).
Cross-references with prior formats — mapId points at
WMS.mapId (the instance map), queueRewardItemId points at
WIT.itemId (the random reward bag), firstClearAchievement
points at WACH.achievementId.
CLI: --gen-lfg (3 classic 5-mans Ragefire/Wailing/Deadmines
with real WoW mapIds + level brackets), --gen-lfg-heroic
(5 WotLK 80-level heroic 5-mans with emblem rewards +
real first-clear achievement IDs from Halls of Lightning
through Old Kingdom), --gen-lfg-raid (3 raid entries —
Naxx-25, Ulduar-25 Hardmode, ToC-25 Mythic), --info-wlfg,
--validate-wlfg with --json variants. Validator catches
id+name+mapId required, difficulty 0..3, expansion 0..3,
minLevel<=maxLevel, recommended-level outside range
warning, unusual groupSize warning (5/10/25/40 are
canonical), and zero role mask (queue can't form a
balanced group).
Format graph: 56 → 57 binary formats. CLI flag count: 804
→ 811.
Closes the JSON round-trip gap on the spell school catalog
format shipped last batch. WSCH has no enum fields with
name forms — just raw numeric school bits and flag bytes —
so the JSON mapping is a direct dump. --import-wsch-json
defaults canBeImmune/Absorbed/Crit to 1 and canBeReflected
to 0 when omitted, matching the WoW canonical behavior for
most schools (only Holy is non-immune, only Physical isn't
reflectable). Verified byte-identical round-trip on all
three preset emitters (starter / magical / combined). 806
documented CLI flags.
56th open format — replaces SpellSchools.dbc plus the
Resistances.dbc resistance-cap tables. Defines damage
schools spells use: Physical, Holy, Fire, Nature, Frost,
Shadow, Arcane, plus combined / hybrid schools that count
as multiple types simultaneously (Spellfire, Spellshadow,
Spellfrost — relevant for resistance-bypass mechanics).
7 canonical schools with single-bit IDs (1, 2, 4, 8, 16,
32, 64) so combinedSchoolMask values line up directly with
the spell engine's school-bit enum. Hybrid schools use
high-bit IDs (0x80000001+) and their combinedSchoolMask
references the canonical bits they qualify as. Each school
carries visual identity (color tint, icon), gameplay rules
(canBeImmune / canBeAbsorbed / canBeReflected / canCrit),
resistance cap at max level, and cast / impact sound IDs.
Cross-references with prior formats — castSoundId and
impactSoundId point at WSND.soundId; combinedSchoolMask
is a bitmask of OTHER WSCH.schoolId values within the same
catalog.
CLI: --gen-sch (3 base — Physical / Fire / Holy showing
non-resistable Holy + non-reflectable Physical), --gen-sch-
magical (6 canonical magical schools with proper colors
+ 365 max-level resistance caps), --gen-sch-combined (3
hybrids — Spellfire / Spellshadow / Spellfrost with
multi-bit combinedSchoolMask), --info-wsch, --validate-wsch
with --json variants. Validator catches id+name required,
reflected-without-absorbed warning (reflected damage
should be absorbable), self-referential combinedSchoolMask
(school qualifying as itself), and combined-mask references
to bits not defined in the same catalog (resolved at runtime
across catalogs).
Format graph: 55 → 56 binary formats. CLI flag count: 798
→ 804.
Walks a directory recursively, identifies every Wowee
open-format file by 4-byte magic, parses the standard
catalog header, and emits a Markdown report. Useful for
content-bundle distributions to ship with a README of
what's inside, and for change-log generation when
diffing two content snapshots manually.
The report has three sections: a summary table (total
files / recognized / bytes), a per-format breakdown
(magic / ext / file count / total entries / description),
and a per-file detail table (path / magic / version /
catalog name / entries / bytes). Output to stdout if no
out path is given, otherwise written to a file.
Reuses cli_format_table.cpp so any new format added in
the future appears automatically without touching this
tool.
Closes the JSON round-trip gap on the keybinding catalog
format shipped last batch. --export-wkbd-json emits all 7
scalar fields plus a dual int + name form for category (9
values) so hand-edits can use either representation.
--import-wkbd-json defaults isUserOverridable to 1 when
omitted (matches typical case for game-action bindings;
hardcoded engine bindings must explicitly set it to 0).
Verified byte-identical round-trip on all three preset
emitters (starter / movement with primary+alt keys / UI
panels). 798 documented CLI flags.
55th open format — replaces KeyBinding.dbc plus the
AzerothCore-style default-keybind SQL data. Defines the key
bindings shipped with the game: movement (W/A/S/D),
targeting (Tab), action bars (1-9, 0, -, =), UI panels
(C/I/B/P/N/L), chat (Enter), camera (Insert/Delete).
Each binding has an internal action name (SCREAMING_SNAKE
convention — "MOVE_FORWARD"), a primary key, an optional
alternate key, a category for the keybindings UI grouping,
and a flag indicating whether the user can override it.
Hardcoded engine bindings (alt-F4, ESC) set
isUserOverridable=0 so the rebind dialog can't accidentally
break them.
9 categories (Movement / Combat / Targeting / Camera /
UIPanels / Chat / Macro / Bar / Other) for the rebind
dialog grouping.
CLI: --gen-kbd (3 essential WASD/Tab/C bindings), --gen-kbd-
movement (8 movement: WASD + arrow alternates + jump +
autorun), --gen-kbd-ui (10 UI panel bindings covering all
the standard interface windows), --info-wkbd, --validate-wkbd
with --json variants. Validator catches id+actionName+
defaultKey required, category 0..8, alternateKey ==
defaultKey (no point in alt), action-name lowercase warning
(should be SCREAMING_SNAKE), duplicate primary keys (would
silently shadow earlier binding), and duplicate action names.
Format graph: 54 → 55 binary formats. CLI flag count: 791
→ 796.
Closes the JSON round-trip gap on the spell mechanic catalog
format shipped this batch. --export-wsmc-json emits all 9
scalar fields plus dual int + name forms for drCategory (8
values) and dispelType (7 values). --import-wsmc-json accepts
either form. conflictsMask is dumped/parsed as a raw uint32
since it's a free-form bitmask of OTHER mechanic IDs (no
enum to widen). Verified byte-identical round-trip on all
three preset emitters (starter / hard-CC with conflictsMask
bits set / roots with stacking flag). 791 documented CLI flags.
54th open format — replaces SpellMechanic.dbc plus the
AzerothCore-style diminishing-returns (DR) tables. Defines
crowd-control mechanic categories that spells reference:
Stun, Silence, Polymorph, Sleep, Fear, Root, Snare, Slow,
Knockback, etc. Each mechanic carries gameplay metadata
(breaks-on-damage, can-be-dispelled, default duration, max
stacks) plus DR category and dispel type.
8 DR categories (DRNone / DRStun / DRDisorient / DRSilence
/ DRRoot / DRPolymorph / DRControlled / DRMisc) — the
runtime uses these to gate repeated CC on the same target.
7 dispel types (DispelNone / Magic / Curse / Disease /
Poison / Enrage / Stealth) bind which dispel spells can
remove the mechanic. conflictsMask is a bitmask of OTHER
mechanic IDs — only one mechanic from a conflict-group can
apply to a target simultaneously.
Cross-references with prior formats — mechanicId is
referenced by WSPL.spellId entries that apply this CC; this
catalog is referenced from spell tags rather than referencing
out.
CLI: --gen-smc (3 baseline Stun/Silence/Snare), --gen-smc-
hard (5 hard-CC: Stun/Polymorph/Sleep/Fear/Knockback with
conflictsMask wiring), --gen-smc-roots (4 movement-impair:
Root/Snare/Slow stacking 5x/GroundPin breaks-on-damage),
--info-wsmc, --validate-wsmc with --json variants. Validator
catches id+name required, DR category 0..7, dispel type
0..6, maxStacks=0 (mechanic could never apply),
canBeDispelled+DispelNone inconsistency, and self-conflict
bit set in conflictsMask (mechanic blocking itself).
Format graph: 53 → 54 binary formats. CLI flag count: 784
→ 789.
Closes the JSON round-trip gap on the companion pet catalog
format shipped last batch. --export-wcmp-json emits all 9
scalar fields plus dual int + name forms for companionKind
(8 values) / rarity (4 values) / factionRestriction (3 values)
so hand-edits can use either representation.
--import-wcmp-json accepts either form, falling back to the
int when both are present. Verified byte-identical round-trip
on all three preset emitters (starter / rare / faction). 784
documented CLI flags.
53rd open format — replaces the companion-pet portions of
CreatureFamily.dbc plus the AzerothCore-style critter / vanity-
pet SQL data. Distinct from WPET (which covers hunter combat
pets and warlock minions); WCMP covers non-combat "vanity" pets
that follow the player around for cosmetic reasons —
Mechanical Squirrel, Mini Diablo, Panda Cub, dragon hatchlings.
8 companion kinds (Critter, Mechanical, DragonHatchling,
Demonic, Spectral, Elemental, Plush, UndeadCritter), 4
rarity tiers (Common / Uncommon / Rare / Epic), and 3
faction restrictions (AnyFaction / AllianceOnly / HordeOnly).
Cross-references with prior formats — creatureId points at
WCRT.creatureId (the rendered model), learnSpellId at
WSPL.spellId (the spell that summons the pet), itemId at
WIT.itemId (the item that teaches the spell), and
idleSoundId at WSND.soundId (idle ambient noise).
CLI: --gen-cmp (3 common vendor pets), --gen-cmp-rare (4
promo / collector pets at Epic rarity — Mini Diablo,
Panda Cub, Zergling, Murky), --gen-cmp-faction (3 faction-
restricted Alliance Lion Cub / Horde Mottled Boar /
neutral Argent Squire), --info-wcmp, --validate-wcmp with
--json variants. Validator catches id+name+creatureId+
learnSpellId required, kind 0..7 / rarity 0..3 / faction
0..2 range, and Epic-rarity-no-itemId warning (most promo
pets need a redemption-code item).
Format graph: 52 → 53 binary formats. CLI flag count: 777
→ 782.
Closes the JSON round-trip gap on the game tips catalog format
shipped this batch. --export-wgtp-json emits all 11 scalar
fields plus a dual int + name form for displayKind so
hand-edits can use either representation. --import-wgtp-json
defaults audienceFilter to kAudienceAll when omitted (so a
sidecar without that field doesn't accidentally produce a tip
that is never shown). Verified byte-identical round-trip on
all three preset emitters (starter / new-player / advanced).
777 documented CLI flags.
52nd open format — replaces GameTips.dbc plus loading-screen
tutorial hint tables. Defines the rotating tips shown during
world loads, the contextual tutorial hints that fire on first
gameplay events (first quest accept, first death, first
dungeon entry), and the persistent tooltip-help strings that
explain UI elements.
4 display kinds (LoadingScreen / Tutorial / TooltipHelp /
Hint), 7 audience-filter bits (Alliance / Horde / NewPlayer /
Hardcore / PvE / PvP / Roleplay) for pool selection, level
range gating (minLevel + maxLevel), displayWeight for
relative frequency within the pool, optional WPCN condition
cross-ref for further gating, and class-mask restriction
matching WCHC bit positions.
Cross-references with prior formats — conditionId points at
WPCN.conditionId for advanced gating; requiredClassMask uses
the same WCHC.classId bit layout as WGLY/WSET.
CLI: --gen-tips (3 generic loading-screen tips), --gen-tips-
new-player (5 onboarding Tutorial-kind tips for level 1-15,
weighted higher for new players), --gen-tips-advanced (4
endgame tips for level 70+ covering raid mechanics / arena /
daily professions / dungeon finder), --info-wgtp,
--validate-wgtp with --json variants. Validator catches
id/name/text required, kind 0..3, audienceFilter=0 (tip
never shown), invalid level range, displayWeight=0 (in pool
but never picked) warning, and brevity check (>280 chars)
on Tutorial / Hint kinds that need to fit on screen.
Format graph: 51 → 52 binary formats. CLI flag count: 770
→ 775.
Recursively walks a directory, identifies every recognized .w*
file by 4-byte magic, and parses the standard catalog header
(magic + version + length-prefixed name + entryCount) to
confirm the file isn't truncated, corrupted, or otherwise
malformed at the header level. Reports per-file PASS/FAIL +
extension-mismatch warnings (when a file's actual extension
doesn't match what its magic says it should be).
Exits 1 on any FAIL — designed as a CI gate that runs after
content build to catch truncations / write-failures /
disk-full mid-emit. World/asset formats (WOM/WOB/WHM/WOT/WOW)
are recognized by magic but the catalog-header probe is
skipped since their layouts differ.
Implausibility caps: catalog-name length > 1MB or
entryCount > 1M trigger failure as likely corruption signals.
--quiet hides the per-file PASS/FAIL list (summary line only);
--json variant for tooling integration.
Closes the JSON round-trip gap on the item set catalog format
shipped this batch. --export-wset-json emits all 8 scalar
fields plus two nested arrays — itemIds[] (only the populated
slots) and bonuses[{threshold, spellId}] (only the populated
bonus pairs). --import-wset-json derives pieceCount and
bonusCount from the array sizes (the explicit count fields
in the binary header are recomputed on import) and clears any
trailing slots so a 5-piece PvP set imported from JSON
correctly leaves slots 5-7 zero. requiredClassMask is dumped
as a raw uint32 — users hand-edit using WCHC bit positions
(Druid=0x800, Mage=0x100, Paladin=0x04 etc).
Verified byte-identical round-trip on all three preset
emitters (starter / tier / PvP — including the 5-piece PvP
variant with 2/4-piece bonuses). 769 documented CLI flags.
51st open format — replaces ItemSet.dbc + ItemSetSpell.dbc
plus the AzerothCore-style item_set_spell SQL data. Closes
the tier-bonus gap left by WIT (which describes individual
items but not the set bonuses they grant when worn together).
Each entry binds up to 8 piece item IDs to up to 4 bonus
thresholds — at N pieces worn, the matching bonus spell
activates as an aura. Standard 2/4/6/8-piece tier set pattern
is the canonical case; 5-piece PvP sets with 2/4 bonuses are
also supported.
Cross-references with prior formats — itemIds[] point at
WIT.itemId, bonusSpellIds[] point at WSPL.spellId, and
requiredSkillId points at WSKL.skillId. requiredClassMask
is a 32-bit field (uint32_t) so bit positions match WCHC's
classId enum directly — Druid (bit 11 = 0x800) and Mage
(bit 8 = 0x100) wouldn't fit in a uint8_t.
CLI: --gen-itset (2 raid sets — Battlegear of Wrath +
Stormrage Raiment, real WoW item/spell IDs), --gen-itset-tier
(4 tier-1 progression sets covering plate / cloth / leather /
holy plate), --gen-itset-pvp (3 PvP gladiator 5-piece sets
with honor-rank skill thresholds), --info-wset, --validate-wset
with --json variants. Validator catches id+name+pieceCount
required, pieceCount/bonusCount within array bounds, piece-
slot drift (0 IDs within count or non-0 IDs past count),
bonus thresholds strictly ascending, no bonus threshold
exceeding pieceCount (would never trigger), and spellId=0
in any populated bonus slot.
Format graph: 50 → 51 binary formats. CLI flag count: 762
→ 767.
Closes the JSON round-trip gap on the creature equipment
catalog format shipped last batch (50th open format). All
fields are scalar — no enum widening — so the JSON mapping
is a direct dump. Slot fields default to the canonical
attachment-table values (mainhand=16, offhand=17,
ranged=18) when omitted from a sidecar, so hand-edits don't
need to spell out the slot numbers for typical loadouts.
Verified byte-identical round-trip on all three preset
emitters (starter / bosses / ranged). 762 documented CLI
flags.
Replaces the AzerothCore-style creature_equip_template SQL
tables plus the visible-weapon / shield / ranged-slot data
that was traditionally embedded in creature templates. Closes
a long-standing gap in the creature subsystem: until now WCRT
defined a creature's stats, WSPN placed it in the world, and
WLOT defined what it drops — but nothing defined what items
it visibly equips.
Each entry binds a creatureId to up to three equipped items
(main hand / off hand / ranged) plus the visual kit that
fires when the main-hand weapon is brandished. equipFlags
bits encode hidden / dual-wield / shield-offhand /
thrown-ranged / 2H polearm to drive the renderer's
attachment-point selection.
Cross-references with prior formats — creatureId points at
WCRT.creatureId, mainHandItemId / offHandItemId / rangedItemId
all point at WIT.itemId, and mainHandVisualId points at
WSVK.visualKitId so brandished weapons can play their
signature glow / aura.
CLI: --gen-ceq (3 generic guard/hunter/rogue starters),
--gen-ceq-bosses (4 iconic loadouts incl. Frostmourne and
Illidan's warglaives, with WSVK visual cross-refs),
--gen-ceq-ranged (3 ranged-only rifle/bow/crossbow loadouts),
--info-wceq, --validate-wceq with --json variants. Validator
catches id=0/duplicates, missing creatureId, all-empty-slots
warning, kFlagDualWield without both hand items, kFlagShield
without offhand item, mutually-exclusive dual-wield + shield,
and 2H polearm with offhand item filled.
Format graph milestone: 50 distinct binary formats. CLI flag
count: 754 → 760.
Walks a directory tree, identifies every file by 4-byte magic,
and renames each one to use the correct .w* extension.
Counterpart to single-file --rename-by-magic for the case
where a whole asset bundle came in with mangled extensions
(extracted from a tarball that lost suffixes, downloaded with
CDN-rewritten names, dumped from a database BLOB column).
Same safety semantics as the single-file flag: conflicts are
skipped without --force, --dry-run prints the planned moves
without touching the filesystem. Reports per-file PASS/FAIL/
CONFLICT and a final summary (renamed / skipped-conflict /
already-correct / unrecognized counts). Exits 1 if any
rename failed (e.g. permission errors) so it can be wired
into CI as a gate.
