phaneron/Kelsidavis-WoWee
1
0
Fork 0
mirror of https://github.com/Kelsidavis/WoWee.git synced 2026-05-10 19:13:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2
Kelsidavis-WoWee/tools/editor/cli_help.cpp
Kelsi 4be543a2ed feat(editor): add WWFL JSON round-trip (--export/--import-wwfl-json) 
Dual encoding for both WWFL enums via the readEnumField
template: filterKind (int 0..5 OR 255 OR token "spam"/
"goldseller"/"allcaps"/"repeatchar"/"url"/"advertreward"/
"misc") and severity (int 0..3 OR token "warn"/"replace"/
"drop"/"mute"). caseSensitive accepts bool or int.

pattern and replacement serialize as plain JSON strings —
operators editing the JSON sidecar can hand-craft new
moderation patterns without binary tooling. Strings are
nlohmann::json-escaped on export and unescaped on import,
preserving literal special characters byte-identically.

All 3 presets (spam/caps/url) byte-identical roundtrip
OK. CLI flag count 1239 -> 1241.
2026-05-10 02:36:32 -07:00

2528 lines
267 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include "cli_help.hpp"
#include <cstdio>
namespace wowee {
namespace editor {
namespace cli {
void printUsage(const char* argv0) {
std::printf("Usage: %s --data <path> [options]\n\n", argv0);
std::printf("Options:\n");
std::printf(" --data <path> Path to extracted WoW data (manifest.json)\n");
std::printf(" --adt <map> <x> <y> Load an ADT tile on startup\n");
std::printf(" --convert-m2 <path> Convert M2 model to WOM open format (no GUI)\n");
std::printf(" --convert-m2-batch <srcDir>\n");
std::printf(" Bulk M2→WOM conversion across every .m2 in <srcDir> (per-file pass/fail summary)\n");
std::printf(" --convert-wmo <path> Convert WMO building to WOB open format (no GUI)\n");
std::printf(" --convert-wmo-batch <srcDir>\n");
std::printf(" Bulk WMO→WOB conversion across every .wmo in <srcDir> (skips _NNN group files)\n");
std::printf(" --convert-dbc-batch <srcDir>\n");
std::printf(" Bulk DBC→JSON conversion across every .dbc in <srcDir> (sidecars next to source)\n");
std::printf(" --migrate-data-tree <srcDir>\n");
std::printf(" Run all four bulk converters (m2/wmo/blp/dbc) end-to-end on an extracted Data tree\n");
std::printf(" --info-data-tree <srcDir> [--json]\n");
std::printf(" Per-format migration-progress report (m2 vs wom, wmo vs wob, blp vs png, dbc vs json)\n");
std::printf(" --strip-data-tree <srcDir> [--dry-run]\n");
std::printf(" Delete proprietary files (.m2/.wmo/.blp/.dbc) that already have an open sidecar\n");
std::printf(" --audit-data-tree <srcDir>\n");
std::printf(" CI gate: exit 1 if any proprietary file lacks an open sidecar (100%% migration check)\n");
std::printf(" --bench-migrate-data-tree <srcDir> [--json]\n");
std::printf(" Time each step of --migrate-data-tree (m2/wmo/blp/dbc) and report wall-clock per step\n");
std::printf(" --list-data-tree-largest <srcDir> [N]\n");
std::printf(" Top-N largest proprietary files (.m2/.wmo/.blp/.dbc) for migration prioritization\n");
std::printf(" --export-data-tree-md <srcDir> [out.md]\n");
std::printf(" Markdown migration-progress report (per-pair table, share %%, recommended next steps)\n");
std::printf(" --gen-texture <out.png> <colorHex|pattern> [W H]\n");
std::printf(" Synthesize a placeholder texture (solid hex color or 'checker'/'grid'); default 256x256\n");
std::printf(" --gen-texture-gradient <out.png> <fromHex> <toHex> [vertical|horizontal] [W H]\n");
std::printf(" Synthesize a linear gradient PNG (default vertical, 256x256)\n");
std::printf(" --gen-texture-noise <out.png> [seed] [W H]\n");
std::printf(" Synthesize a smooth value-noise PNG (deterministic from seed; default 256x256)\n");
std::printf(" --gen-texture-noise-color <out.png> <colorAHex> <colorBHex> [seed] [W H]\n");
std::printf(" Same noise pattern but blended between two colors instead of grayscale\n");
std::printf(" --gen-texture-radial <out.png> <centerHex> <edgeHex> [W H]\n");
std::printf(" Synthesize a radial gradient PNG (center→edge, smooth distance-based blend)\n");
std::printf(" --gen-texture-stripes <out.png> <colorAHex> <colorBHex> [stripePx] [diagonal|horizontal|vertical] [W H]\n");
std::printf(" Synthesize a two-color stripe pattern (default 16px diagonal, 256x256)\n");
std::printf(" --gen-texture-dots <out.png> <bgHex> <dotHex> [dotRadius] [spacing] [W H]\n");
std::printf(" Synthesize a polka-dot pattern (default radius 8, spacing 32, 256x256)\n");
std::printf(" --gen-texture-rings <out.png> <colorAHex> <colorBHex> [ringPx] [W H]\n");
std::printf(" Synthesize concentric ring pattern (target/seal style; default 16px rings, 256x256)\n");
std::printf(" --gen-texture-checker <out.png> <colorAHex> <colorBHex> [cellPx] [W H]\n");
std::printf(" Synthesize checkerboard with custom colors (gen-texture's checker is BW only)\n");
std::printf(" --gen-texture-brick <out.png> <brickHex> <mortarHex> [brickW] [brickH] [mortarPx] [W H]\n");
std::printf(" Brick wall pattern with offset rows + mortar lines (default 64×24, 4px mortar)\n");
std::printf(" --gen-texture-wood <out.png> <lightHex> <darkHex> [grainSpacing] [seed] [W H]\n");
std::printf(" Wood grain pattern with vertical streaks + knots (default spacing 12px, seed 1)\n");
std::printf(" --gen-texture-grass <out.png> <baseHex> <bladeHex> [density] [seed] [W H]\n");
std::printf(" Tiling grass texture with random blade highlights (default density=0.15, seed=1)\n");
std::printf(" --gen-texture-fabric <out.png> <warpHex> <weftHex> [threadPx] [W H]\n");
std::printf(" Woven fabric pattern with alternating warp/weft threads (default thread=4px)\n");
std::printf(" --gen-texture-cobble <out.png> <stoneHex> <mortarHex> [stonePx] [seed] [W H]\n");
std::printf(" Cobblestone street pattern: irregular packed stones (default stone=24px, seed 1)\n");
std::printf(" --gen-texture-marble <out.png> <baseHex> <veinHex> [seed] [veinSharpness] [W H]\n");
std::printf(" Marble pattern with sinusoidal veining (default seed 1, sharpness 8)\n");
std::printf(" --gen-texture-metal <out.png> <baseHex> [seed] [orientation] [W H]\n");
std::printf(" Brushed metal: directional anisotropic noise (orientation: horizontal|vertical)\n");
std::printf(" --gen-texture-leather <out.png> <baseHex> [seed] [grainSize] [W H]\n");
std::printf(" Leather grain: irregular pebbled bumps via cellular noise (default grain=4px)\n");
std::printf(" --gen-texture-sand <out.png> <baseHex> [seed] [rippleSpacing] [W H]\n");
std::printf(" Sand dunes: per-pixel grain noise + sinusoidal ripple bands (default ripple=24px)\n");
std::printf(" --gen-texture-snow <out.png> <baseHex> [seed] [sparkleDensity] [W H]\n");
std::printf(" Snow: soft cool-white base + scattered bright sparkle pixels (default density=0.005)\n");
std::printf(" --gen-texture-lava <out.png> <darkHex> <hotHex> [seed] [crackScale] [W H]\n");
std::printf(" Lava: dark cooled crust with bright glowing cracks via Worley cell boundaries\n");
std::printf(" --gen-texture-tile <out.png> <tileHex> <groutHex> [tilePx] [groutPx] [W H]\n");
std::printf(" Square stone tiles with grout grid (default 32px tiles, 2px grout)\n");
std::printf(" --gen-texture-bark <out.png> <baseHex> <crackHex> [seed] [crackDensity] [W H]\n");
std::printf(" Tree bark: vertical wavy streaks + dark vertical cracks (default density=0.04)\n");
std::printf(" --gen-texture-clouds <out.png> <skyHex> <cloudHex> [seed] [coverage] [W H]\n");
std::printf(" Sky with puffy clouds: multi-octave noise thresholded by coverage (default 0.5)\n");
std::printf(" --gen-texture-stars <out.png> <bgHex> <starHex> [seed] [density] [W H]\n");
std::printf(" Night sky with scattered stars (varied brightness, density 0..1, default 0.005)\n");
std::printf(" --gen-texture-vines <out.png> <wallHex> <vineHex> [seed] [vineCount] [W H]\n");
std::printf(" Wall with climbing vines: meandering vertical paths via random walk (default 8 vines)\n");
std::printf(" --gen-texture-mosaic <out.png> <colorAHex> <colorBHex> <colorCHex> [tilePx] [seed] [W H]\n");
std::printf(" 3-color mosaic: small square tiles with random color picks + grout (default 16px)\n");
std::printf(" --gen-texture-rust <out.png> <metalHex> <rustHex> [seed] [coverage] [W H]\n");
std::printf(" Metal with rust patches: noise blob threshold + per-pixel grain (default coverage=0.4)\n");
std::printf(" --gen-texture-circuit <out.png> <pcbHex> <traceHex> [seed] [traceCount] [W H]\n");
std::printf(" Sci-fi PCB pattern: orthogonal traces with right-angle turns + via dots (default 24 traces)\n");
std::printf(" --gen-texture-coral <out.png> <waterHex> <coralHex> [seed] [branchCount] [W H]\n");
std::printf(" Coral reef: branching tree shapes via random angle walks (default 12 branches)\n");
std::printf(" --gen-texture-flame <out.png> <darkHex> <hotHex> [seed] [W H]\n");
std::printf(" Flame: vertical color gradient from dark base to hot top with noise flicker\n");
std::printf(" --gen-texture-tartan <out.png> <colorAHex> <colorBHex> <colorCHex> [bandPx] [W H]\n");
std::printf(" Tartan plaid: 3-color crossing bands forming Scottish-style overlap pattern\n");
std::printf(" --gen-texture-argyle <out.png> <colorAHex> <colorBHex> <stitchHex> [cellPx] [W H]\n");
std::printf(" Argyle: 45-rotated lozenge checkerboard with diagonal stitch lines (sweater knit)\n");
std::printf(" --gen-texture-herringbone <out.png> <bgHex> <lineHex> [stripH] [lineSpacing] [lineWidth] [W H]\n");
std::printf(" Herringbone: slanted parallel lines that flip direction every strip (chevron / fish-bone)\n");
std::printf(" --gen-texture-scales <out.png> <bgHex> <scaleHex> <rimHex> [cellW] [cellH] [W H]\n");
std::printf(" Scales: half-row-staggered overlapping circles forming fish/dragon/chain-mail look\n");
std::printf(" --gen-texture-stained-glass <out.png> <leadHex> <colorAHex> <colorBHex> <colorCHex> [cells] [W H]\n");
std::printf(" Stained glass: Voronoi cells in 3-color rotation, separated by dark lead lines\n");
std::printf(" --gen-texture-shingles <out.png> <baseHex> <shadowHex> <seamHex> [shingleW] [shingleH] [shadowH] [W H]\n");
std::printf(" Roof shingles: half-offset rows of rectangular tiles with shadow band + vertical seams\n");
std::printf(" --gen-texture-frost <out.png> <bgHex> <iceHex> [seeds] [rayLen] [W H]\n");
std::printf(" Frost: scattered crystal nuclei with 6-spike rosettes that fade with distance\n");
std::printf(" --gen-texture-parquet <out.png> <woodAHex> <woodBHex> <gapHex> [cellSize] [gapW] [W H]\n");
std::printf(" Parquet: basket-weave wood floor pattern with checkered horizontal/vertical plank pairs\n");
std::printf(" --gen-texture-bubbles <out.png> <bgHex> <fillHex> <rimHex> [count] [minR] [maxR] [rimW] [W H]\n");
std::printf(" Bubbles: scattered overlapping circles with bright rims (foam, water, magic)\n");
std::printf(" --gen-texture-spider-web <out.png> <bgHex> <webHex> [spokes] [rings] [W H]\n");
std::printf(" Spider web: N radial spokes + M concentric polygonal rings centered on the image\n");
std::printf(" --gen-texture-gingham <out.png> <bgHex> <stripeHex> <crossHex> [spacing] [width] [W H]\n");
std::printf(" Gingham: 3-tone fabric — bg + perpendicular stripes + darker color where they cross\n");
std::printf(" --gen-texture-lattice <out.png> <bgHex> <lineHex> [spacing] [width] [W H]\n");
std::printf(" Lattice: ±45° diagonal grid forming diamond openings (garden trellis / mesh fence)\n");
std::printf(" --gen-texture-honeycomb <out.png> <fillHex> <borderHex> [hexSide] [W H]\n");
std::printf(" Honeycomb: hexagonal cells via Voronoi over a triangular seed lattice\n");
std::printf(" --gen-texture-cracked <out.png> <bgHex> <crackHex> [seeds] [maxLength] [W H]\n");
std::printf(" Cracked: branching random walks form fissures (mud / glass / dry earth)\n");
std::printf(" --gen-texture-runes <out.png> <bgHex> <runeHex> [gridSpacing] [W H]\n");
std::printf(" Runes: scattered angular glyphs of 3-5 strokes each (8 cardinal/diagonal angles)\n");
std::printf(" --gen-texture-leopard <out.png> <bgHex> <spotHex> [count] [radius] [W H]\n");
std::printf(" Leopard: irregular spots (4 sub-circles each) for animal-print fabric/fur\n");
std::printf(" --gen-texture-zebra <out.png> <bgHex> <stripeHex> [period] [amplitude] [wavelength] [W H]\n");
std::printf(" Zebra: wavy parallel stripes via sinusoidal y-shift (animal-print stripes)\n");
std::printf(" --gen-texture-knit <out.png> <bgHex> <stitchHex> [cellW] [cellH] [strokeW] [W H]\n");
std::printf(" Knit: V-stitch chevron-zigzag pattern reading as knitted fabric stitches\n");
std::printf(" --gen-texture-chainmail <out.png> <bgHex> <ringHex> [cellW] [cellH] [ringR] [strokeW] [W H]\n");
std::printf(" Chainmail: brick-offset ring outlines for armor/mail textures (interlocking metal rings)\n");
std::printf(" --gen-texture-planks <out.png> <bgHex> <seamHex> [plankH] [grains/plank] [seed] [W H]\n");
std::printf(" Planks: horizontal floor boards with per-plank tint, grain streaks, and stagger seams\n");
std::printf(" --gen-texture-corrugated <out.png> <bgHex> <hiHex> [period] [v|h] [W H]\n");
std::printf(" Corrugated: smooth cosine ridges between bg and hi (sheet-metal roofing / siding)\n");
std::printf(" --gen-texture-rope <out.png> <bgHex> <ropeHex> [period] [strandW] [W H]\n");
std::printf(" Rope: two interleaved sinusoidal strands with cylindrical highlight (twisted cordage)\n");
std::printf(" --gen-texture-caustics <out.png> <bgHex> <hiHex> [period] [W H]\n");
std::printf(" Caustics: 4 superimposed sine waves (x/y/x+y/x-y) producing diamond-mesh water shimmer\n");
std::printf(" --gen-texture-starburst <out.png> <bgHex> <rayHex> [rays] [beamWidth] [W H]\n");
std::printf(" Starburst: N rays radiating from center with linear falloff (sun / holy symbol / mosaic hub)\n");
std::printf(" --gen-texture-studs <out.png> <bgHex> <studHex> [stride] [studR] [W H]\n");
std::printf(" Studs: rivet grid with derived inner highlight (3D rivet/stud appearance for armor + leather)\n");
std::printf(" --gen-texture-moss <out.png> <bgHex> <mossHex> [stride] [density 0-100] [seed] [W H]\n");
std::printf(" Moss: irregular spots scattered on a hash-jittered grid (forest floor / weathered stone / swamp)\n");
std::printf(" --gen-texture-woodgrain <out.png> <lightHex> <darkHex> [spacing] [seed] [W H]\n");
std::printf(" Woodgrain: concentric annual rings centered off-image with per-ring jitter (end-cut wood)\n");
std::printf(" --gen-texture-carbon <out.png> <bgHex> <fiberHex> [cellSize] [W H]\n");
std::printf(" Carbon-fiber: 2x2 alternating-orientation weave with sin² fiber highlights (sci-fi/tech panels)\n");
std::printf(" --gen-texture-pinstripe <out.png> <bgHex> <lineHex> [stride] [lineW] [featureEvery] [W H]\n");
std::printf(" Pinstripe: thin vertical lines at every stride; every Nth stripe is doubled-thick feature line\n");
std::printf(" --gen-texture-camo <out.png> <aHex> <bHex> [cellSize] [threshold] [seed] [W H]\n");
std::printf(" Camouflage: 2-octave value noise thresholded into hard bg/fg blobs (woodland disruption pattern)\n");
std::printf(" --gen-texture-snake-skin <out.png> <bgHex> <scaleHex> [cellW] [cellH] [outlineW] [W H]\n");
std::printf(" Snake skin: brick-offset diamond scales (L1 metric) with derived dark outline (reptile / dragon hide)\n");
std::printf(" --gen-texture-mesh-screen <out.png> <bgHex> <wireHex> [stride] [wireW] [W H]\n");
std::printf(" Mesh-screen: orthogonal H+V wire grid (window screen / chain-link / sci-fi grille)\n");
std::printf(" --gen-texture-bamboo <out.png> <bgHex> <bambooHex> [stalkW] [nodeY] [nodeBand] [seed] [W H]\n");
std::printf(" Bamboo: vertical stalks with sin² shading + horizontal node bands (jungle / asian-themed)\n");
std::printf(" --gen-texture-blueprint <out.png> <bgHex> <lineHex> [minorStride] [majorEvery] [minorW] [majorW] [W H]\n");
std::printf(" Blueprint: minor + major grid lines (technical drawing / drafting paper / engineer's table)\n");
std::printf(" --gen-texture-rust-streaks <out.png> <bgHex> <rustHex> [streakCount] [seed] [W H]\n");
std::printf(" Rust streaks: vertical drip bands fading down from hash-jittered tops (weathered metal / hull stains)\n");
std::printf(" --gen-texture-plaid <out.png> <bgHex> <bandHex> [stride] [bandW] [W H]\n");
std::printf(" Plaid: 2 sets of crossed translucent bands; intersections darken via combined half-alpha\n");
std::printf(" --gen-texture-diamond-grid <out.png> <bgHex> <fillHex> [cellW] [cellH] [fillFrac] [W H]\n");
std::printf(" Diamond grid: axis-aligned solid diamonds in cells with bg gaps (clean tile / mosaic / floor inlay)\n");
std::printf(" --gen-texture-houndstooth <out.png> <toothHex> <bgHex> [cellSize] [W H]\n");
std::printf(" Houndstooth: classic textile broken-check pattern via seamless 8x8 motif (Scottish weave)\n");
std::printf(" --gen-texture-chevron <out.png> <bgHex> <lineHex> [period] [stride] [lineW] [W H]\n");
std::printf(" Chevron: stack of V-shape stripes with sharp seams (military / sportswear / heraldic banners)\n");
std::printf(" --gen-texture-dunes <out.png> <bgHex> <lineHex> [verticalSpacing] [period] [amp] [lineW] [W H]\n");
std::printf(" Dunes: stack of parallel sinusoidal curves (desert ground / shallow-water sand / wave ripples)\n");
std::printf(" --gen-texture-swirl <out.png> <bgHex> <armHex> [armCount] [spiralFactor] [armWidth] [W H]\n");
std::printf(" Swirl: N-arm logarithmic spiral (magic sigils / summoning circles / ritual floor markings)\n");
std::printf(" --gen-texture-ironbark <out.png> <baseHex> <crackHex> [streakSpacing] [plateY] [crackW] [seed] [W H]\n");
std::printf(" Ironbark: vertical wood streaks + horizontal plate bands (mature hardwood / sycamore / ironwood)\n");
std::printf(" --gen-texture-mold <out.png> <bgHex> <moldHex> [stride] [thresholdFrac] [seed] [W H]\n");
std::printf(" Mold: Worley-noise field patches (cellars / dungeon walls / sewer overflow / fungal growth)\n");
std::printf(" --gen-texture-embroidery <out.png> <bgHex> <threadHex> [cellSize] [strokeW] [W H]\n");
std::printf(" Embroidery: grid of cross-stitch X marks (counted-thread textile / sampler / folk-art trim)\n");
std::printf(" --gen-texture-lightbeam <out.png> <bgHex> <beamHex> [beamHalfW] [vFadeFrac] [u|d] [W H]\n");
std::printf(" Lightbeam: vertical sun-ray gradient fading horizontally + vertically (sunbeam / holy radiance)\n");
std::printf(" --gen-texture-dewdrops <out.png> <bgHex> <dropHex> [dropCount] [maxR] [seed] [W H]\n");
std::printf(" Dewdrops: scattered translucent water drops with radial brightness (grass / glass / leaf surfaces)\n");
std::printf(" --gen-texture-pinwheel <out.png> <aHex> <bHex> [sectors] [W H]\n");
std::printf(" Pinwheel: alternating colored triangular wedges radiating from center (mandala / wind-rose / wheel inlay)\n");
std::printf(" --gen-texture-scratched-metal <out.png> <baseHex> <scratchHex> [scratchCount] [maxLen] [seed] [W H]\n");
std::printf(" Scratched metal: base color overlaid with N angled hash-derived line segments (worn armor / blades)\n");
std::printf(" --gen-texture-crackle <out.png> <baseHex> <crackHex> [stride] [crackW] [seed] [W H]\n");
std::printf(" Crackle: fine Voronoi cell-boundary cracks (dried mud / parched earth / aged leather)\n");
std::printf(" --gen-texture-star <out.png> <bgHex> <starHex> [points] [innerFrac] [W H]\n");
std::printf(" Star: solid N-pointed star polygon centered (medallions / shields / religious symbols)\n");
std::printf(" --gen-texture-halftone <out.png> <bgHex> <dotHex> [stride] [maxR] [v|h|r] [W H]\n");
std::printf(" Halftone: grid of dots whose radii grow with a v/h/r gradient (comic / newspaper print look)\n");
std::printf(" --gen-texture-bayer <out.png> <aHex> <bHex> [cellSize] [W H]\n");
std::printf(" Bayer: 4x4 ordered-dither matrix tiled (retro / 8-bit / monochrome-CRT effects)\n");
std::printf(" --gen-texture-moon <out.png> <bgHex> <moonHex> [moonR] [phase] [W H]\n");
std::printf(" Moon disc with optional crescent shadow (phase 0=full, =moonR=half, >moonR=crescent)\n");
std::printf(" --gen-texture-damask <out.png> <bgHex> <fgHex> [cell] [W H]\n");
std::printf(" Damask: 4-petal floral motif tiled per cell (palace wallpaper / noble-faction tapestry)\n");
std::printf(" --gen-texture-snowflake <out.png> <bgHex> <fgHex> [cell] [W H]\n");
std::printf(" Snowflake: 6-fold symmetric ice crystal stamped per cell (winter zones / frost spell effects)\n");
std::printf(" --gen-texture-gear-cog <out.png> <bgHex> <fgHex> [cell] [teeth] [W H]\n");
std::printf(" Gear cog: mechanical wheel with N alternating teeth + center axle hole (engineering / clockwork themes)\n");
std::printf(" --add-texture-to-zone <zoneDir> <png-path> [renameTo]\n");
std::printf(" Copy an existing PNG into <zoneDir> (optionally renaming it on the way in)\n");
std::printf(" --gen-mesh <wom-base> <cube|plane|sphere|cylinder|torus|cone|ramp> [size]\n");
std::printf(" Synthesize a procedural WOM primitive with proper normals, UVs, and bounds\n");
std::printf(" --gen-mesh-textured <wom-base> <cube|plane|sphere|cylinder|torus|cone|ramp> <colorHex|pattern> [size]\n");
std::printf(" Compose a procedural mesh + matching PNG texture wired into the WOM's batch\n");
std::printf(" --gen-mesh-stairs <wom-base> <steps> [stepHeight] [stepDepth] [width]\n");
std::printf(" Procedural straight staircase along +X with N steps (default 5 / 0.2 / 0.3 / 1.0)\n");
std::printf(" --gen-mesh-grid <wom-base> <subdivisions> [size]\n");
std::printf(" Subdivided flat plane on XY (NxN cells, 2N² triangles); useful for LOD demos\n");
std::printf(" --gen-mesh-disc <wom-base> [radius] [segments]\n");
std::printf(" Flat circular disc on XY centered at origin (default radius 1.0, 32 segments)\n");
std::printf(" --gen-mesh-tube <wom-base> [outerRadius] [innerRadius] [height] [segments]\n");
std::printf(" Hollow cylinder/pipe along Y axis (default 1.0/0.7/2.0, 24 segments)\n");
std::printf(" --gen-mesh-capsule <wom-base> [radius] [cylHeight] [segments] [stacks]\n");
std::printf(" Capsule along Y axis: cylinder body with hemispherical caps (default 0.5/1.0/16/8)\n");
std::printf(" --gen-mesh-arch <wom-base> [openingWidth] [openingHeight] [thickness] [depth] [segments]\n");
std::printf(" Doorway arch: two columns + semicircular top (default 1.0/1.5/0.2/0.3, 12 segs)\n");
std::printf(" --gen-mesh-pyramid <wom-base> [sides] [baseRadius] [height]\n");
std::printf(" N-sided polygonal pyramid with apex at +Y (default 4 sides, 1.0/1.0)\n");
std::printf(" --gen-mesh-fence <wom-base> [posts] [postSpacing] [postHeight] [railThick]\n");
std::printf(" Repeating fence: N posts along +X with two horizontal rails between\n");
std::printf(" --gen-mesh-tree <wom-base> [trunkRadius] [trunkHeight] [foliageRadius]\n");
std::printf(" --gen-mesh-rock <wom-base> [radius] [roughness] [subdiv] [seed]\n");
std::printf(" Procedural boulder via subdivided octahedron + smooth noise displacement\n");
std::printf(" --gen-mesh-pillar <wom-base> [radius] [height] [flutes] [capScale]\n");
std::printf(" Fluted classical column with concave flutes + flared cap/base (default 12 flutes)\n");
std::printf(" --gen-mesh-bridge <wom-base> [length] [width] [planks] [railHeight]\n");
std::printf(" Plank bridge with two side rails (default 6 planks across, rails on)\n");
std::printf(" --gen-mesh-tower <wom-base> [radius] [height] [battlements] [battlementH]\n");
std::printf(" Round castle tower with crenellated battlements (default 8 teeth, 0.5m tall)\n");
std::printf(" --gen-mesh-house <wom-base> [width] [depth] [height] [roofHeight]\n");
std::printf(" Simple house: cube body + pyramid roof (default 4×4×3 with 2m roof)\n");
std::printf(" --gen-mesh-fountain <wom-base> [basinRadius] [basinHeight] [spoutRadius] [spoutHeight]\n");
std::printf(" Round basin + center spout column (default 1.5/0.5 basin, 0.2/1.5 spout)\n");
std::printf(" --gen-mesh-statue <wom-base> [pedestalSize] [bodyHeight] [headRadius]\n");
std::printf(" Humanoid placeholder: pedestal block + tall body cylinder + head sphere\n");
std::printf(" --gen-mesh-altar <wom-base> [topRadius] [topHeight] [steps] [stepStride]\n");
std::printf(" Round altar: stacked stepped discs descending from a flat top (default 3 steps)\n");
std::printf(" --gen-mesh-portal <wom-base> [width] [height] [postThickness] [lintelHeight]\n");
std::printf(" Doorway frame: two side posts + top lintel (default 2.5w × 4h)\n");
std::printf(" --gen-mesh-archway <wom-base> [width] [pillarHeight] [thickness] [archSegs]\n");
std::printf(" Semicircular arched doorway: two pillars + curved keystone vault (default 12 segs)\n");
std::printf(" --gen-mesh-barrel <wom-base> [topRadius] [midRadius] [height] [hoopThickness]\n");
std::printf(" Tapered barrel: bulges in middle + 2 rim hoops (default 0.4/0.5/1.0/0.06)\n");
std::printf(" --gen-mesh-chest <wom-base> [width] [depth] [bodyHeight] [lidHeight]\n");
std::printf(" Treasure chest: body box + lid box + 3 iron bands + lock plate (default 1.4×0.9×0.9)\n");
std::printf(" --gen-mesh-anvil <wom-base> [length] [width] [hornLength] [bodyHeight]\n");
std::printf(" Blacksmith anvil: stepped pedestal + flat work surface + horn taper (default 1.0×0.4×0.5×0.5)\n");
std::printf(" --gen-mesh-mushroom <wom-base> [stalkRadius] [stalkHeight] [capRadius]\n");
std::printf(" Mushroom: cylindrical stalk + hemispherical cap (default 0.1/0.6/0.4)\n");
std::printf(" --gen-mesh-cart <wom-base> [bedLength] [bedWidth] [bedHeight] [wheelRadius]\n");
std::printf(" Wooden cart: rectangular bed + 2 cylindrical wheels (default 1.6/0.8/0.5/0.35)\n");
std::printf(" --gen-mesh-banner <wom-base> [poleHeight] [poleRadius] [flagWidth] [flagHeight]\n");
std::printf(" Banner: vertical pole + rectangular hanging flag (default 3.0/0.05/0.8/1.2)\n");
std::printf(" --gen-mesh-grave <wom-base> [tabletWidth] [tabletHeight] [tabletThickness] [baseWidth]\n");
std::printf(" Tombstone: low rectangular base + vertical tablet (default 0.6/1.0/0.15/0.8)\n");
std::printf(" --gen-mesh-bench <wom-base> [length] [seatHeight] [seatThickness] [seatWidth]\n");
std::printf(" Wooden bench: seat plank + 2 leg slabs (default 1.5/0.5/0.06/0.4)\n");
std::printf(" --gen-mesh-shrine <wom-base> [size] [pillarHeight] [pillarRadius] [roofThickness]\n");
std::printf(" Small canopy: square base + 4 corner pillars + flat roof slab (default 1.5/2/0.1/0.15)\n");
std::printf(" --gen-mesh-totem <wom-base> [width] [segments] [segmentHeight]\n");
std::printf(" Tribal totem: stack of N alternating-width carved blocks (default w=0.5, 5 segs, h=0.5)\n");
std::printf(" --gen-mesh-cage <wom-base> [width] [height] [barsPerSide] [barRadius]\n");
std::printf(" Cage: top/bottom frames + 4 corner posts + N bars per side (default 1.5×2.0, 5 bars)\n");
std::printf(" --gen-mesh-throne <wom-base> [seatWidth] [seatHeight] [backHeight] [pedestalSize]\n");
std::printf(" Throne: pedestal + seat + backrest + 2 armrests (default 0.8/0.5/1.5/1.2)\n");
std::printf(" --gen-mesh-coffin <wom-base> [length] [width] [height]\n");
std::printf(" Hexagonal coffin: narrow head + wide shoulder + tapered foot prism (default 2.0/0.8/0.6)\n");
std::printf(" --gen-mesh-bookshelf <wom-base> [width] [height] [depth] [shelves]\n");
std::printf(" Bookshelf: 5-panel cabinet with N-1 shelves and rows of varied book boxes (default 1.5/2.0/0.4/4)\n");
std::printf(" --gen-mesh-tent <wom-base> [length] [width] [height] [doorH] [doorW]\n");
std::printf(" Tent: A-frame canvas tent — ridge along X, two sloped roof panels, two gables, door notch on +X (default 1.6/1.0/0.9/0.5/0.4)\n");
std::printf(" --gen-mesh-firepit <wom-base> [ringR] [stones] [stoneSize] [logLen] [logThick]\n");
std::printf(" Firepit: ring of N stone cubes around 2 crossed log boxes (default 0.5/8/0.10/0.45/0.05)\n");
std::printf(" --gen-mesh-woodpile <wom-base> [logR] [logLen] [sides]\n");
std::printf(" Woodpile: 6 cylindrical logs in a 3-2-1 pyramid stack along Z axis (default 0.10/0.80/12)\n");
std::printf(" --gen-mesh-canopy <wom-base> [width] [depth] [height] [postR] [panelT] [drape]\n");
std::printf(" Canopy: 4-post awning with flat top panel and optional drape lips (default 1.6/1.2/2.0/0.05/0.03/0.15)\n");
std::printf(" --gen-mesh-haystack <wom-base> [baseR] [height] [layers] [sides]\n");
std::printf(" Haystack: terraced stack of N frustums tapering to an apex point (default 0.6/0.9/3/12)\n");
std::printf(" --gen-mesh-dock <wom-base> [length] [width] [height] [pilings/side] [pilingW] [deckT]\n");
std::printf(" Dock: flat plank deck on N pairs of square pilings (default 3.0/1.0/0.6/3/0.10/0.10)\n");
std::printf(" --gen-mesh-pergola <wom-base> [length] [width] [height] [postR] [beamT] [crossbeams]\n");
std::printf(" Pergola: 4 corner posts + 2 perimeter beams + N cross beams (open lattice top, no panel)\n");
std::printf(" --gen-mesh-chimney <wom-base> [width] [depth] [height] [capH] [capExtra]\n");
std::printf(" Chimney: rectangular brick shaft topped by a slightly wider rain-cap (default 0.45/0.45/1.8/0.10/0.05)\n");
std::printf(" --gen-mesh-bedroll <wom-base> [length] [radius] [sides] [pillowSize]\n");
std::printf(" Bedroll: horizontal closed cylinder along Z axis with optional pillow box at +Z (camp set dressing)\n");
std::printf(" --gen-mesh-workbench <wom-base> [length] [depth] [height] [legR] [topT] [viseSize] [trayH]\n");
std::printf(" Workbench: 4-legged top slab with optional vise at +X end and back tool tray (blacksmith / crafter)\n");
std::printf(" --gen-mesh-crate-stack <wom-base> [crateSize] [columns] [rows] [layers] [gap]\n");
std::printf(" Crate stack: N×M×K cube grid with small gap between crates (warehouses, cargo holds, dockyards)\n");
std::printf(" --gen-mesh-watchpost <wom-base> [postH] [postW] [platformSize] [platformT] [railingH] [railingW]\n");
std::printf(" Watchpost: tall pole + square platform + 4 corner railing posts (sentry / scout outpost)\n");
std::printf(" --gen-mesh-water-trough <wom-base> [length] [width] [height] [wallT]\n");
std::printf(" Water trough: 4-walled rectangular basin with flat floor (stable / farm / tavern set dressing)\n");
std::printf(" --gen-mesh-training-dummy <wom-base> [baseH] [postW] [torsoSize] [armSpan] [armT] [headSize]\n");
std::printf(" Training dummy: post + cubic torso + cross-bar arms + optional head (sparring / drill yard)\n");
std::printf(" --gen-mesh-hitching-post <wom-base> [span] [height] [postW] [barT] [capH]\n");
std::printf(" Hitching post: 2 vertical posts + horizontal cross-bar + optional decorative caps (stable / town square)\n");
std::printf(" --gen-mesh-outhouse <wom-base> [width] [depth] [height] [doorH] [doorW] [roofOverhang] [roofT]\n");
std::printf(" Outhouse: solid body + inset door slab on +Z + overhanging roof slab (privy / tool shed)\n");
std::printf(" --gen-mesh-forge <wom-base> [width] [depth] [baseH] [hoodH] [hoodInset] [chimneyH] [chimneyW]\n");
std::printf(" Blacksmith forge: stone hearth + smaller hood + optional chimney (smithy / armorer set dressing)\n");
std::printf(" --gen-mesh-archery-target <wom-base> [faceR] [faceT] [sides] [postH] [postW] [beamT]\n");
std::printf(" Archery target: round face cylinder on a 2-post stand with cross-beam (training yard / fair scene)\n");
std::printf(" --gen-mesh-gravel-pile <wom-base> [stoneCount] [baseR] [pileH] [maxStoneSize] [seed]\n");
std::printf(" Gravel pile: hash-distributed stone cubes in a conical heap (mining / construction / rubble)\n");
std::printf(" --gen-mesh-stone-bench <wom-base> [length] [depth] [seatH] [seatT] [supportW] [supportInset]\n");
std::printf(" Stone bench: long seat slab on 2 block supports near the ends (park / temple / ruined city)\n");
std::printf(" --gen-mesh-mine-cart <wom-base> [length] [width] [bodyH] [wallT] [wheelR] [wheelInset]\n");
std::printf(" Mine cart: open-top bin (5-piece basin) on 4 wheel boxes (mines / dwarven forges / junk yards)\n");
std::printf(" --gen-mesh-hitching-rail <wom-base> [length] [height] [posts] [postW] [barT]\n");
std::printf(" Hitching rail: long horizontal bar on N evenly-spaced posts (taverns / stockyards / market days)\n");
std::printf(" --gen-mesh-pillar-row <wom-base> [count] [span] [height] [pillarW] [capH] [capExtra]\n");
std::printf(" Pillar row: N evenly-spaced rectangular pillars with optional square caps (colonnade / temple ruin)\n");
std::printf(" --gen-mesh-statue-base <wom-base> [bodyW] [bodyH] [plinthExtra] [plinthH] [capitalExtra] [capitalH]\n");
std::printf(" Statue base: 3-tier pedestal (plinth + body + capital) for monuments / hero memorials\n");
std::printf(" --gen-mesh-bird-bath <wom-base> [stemR] [stemH] [basinR] [basinH] [sides]\n");
std::printf(" Bird bath: thin cylindrical stem topped by a wide shallow basin disc (small garden water feature)\n");
std::printf(" --gen-mesh-planter-box <wom-base> [length] [width] [height] [wallT] [soilTopFrac]\n");
std::printf(" Planter box: long open-top wood basin + visible soil-fill block (window sills / kitchen / balcony)\n");
std::printf(" --gen-mesh-urn <wom-base> [bodyR] [bodyH] [footR] [footH] [neckR] [neckH] [lipR] [lipH] [sides]\n");
std::printf(" Urn: 4-tier vertical pottery vessel (foot + body + neck + lip) — temple / mausoleum / kitchen storage\n");
std::printf(" --gen-mesh-candle <wom-base> [waxR] [waxH] [saucerR] [saucerH] [sides]\n");
std::printf(" Candle: thin wax pillar on optional saucer base (set saucerR=0 to skip) — chapels / vigil scenes\n");
std::printf(" --gen-mesh-lantern <wom-base> [baseR] [baseH] [globeR] [globeH] [neckR] [neckH] [capR] [capH] [sides]\n");
std::printf(" Lantern: 4-tier base + glass-globe + neck + cap stack (hand lantern / oil lamp silhouette)\n");
std::printf(" --gen-mesh-chalice <wom-base> [footR] [footH] [stemR] [stemH] [bowlR] [bowlH] [sides]\n");
std::printf(" Chalice: ceremonial 3-tier foot + stem + bowl goblet (chapel / treasure / ritual scene)\n");
std::printf(" --gen-mesh-standing-torch <wom-base> [postR] [postH] [bowlR] [bowlH] [sides]\n");
std::printf(" Standing torch: tall thin post + wider fire-bowl on top (hall lining / dungeon entry / ceremony path)\n");
std::printf(" --gen-mesh-scroll-case <wom-base> [bodyR] [bodyH] [capR] [capH] [sides]\n");
std::printf(" Scroll case: thin tall cylinder + optional wider cap (set capR=0 to skip) — libraries / mage scenes\n");
std::printf(" --gen-mesh-stove <wom-base> [bodyR] [bodyH] [chimneyR] [chimneyH] [sides]\n");
std::printf(" Pot-bellied stove: round cylindrical body + thin chimney column on top (cottage / workshop heating)\n");
std::printf(" --gen-mesh-well-pail <wom-base> [bodyR] [bodyH] [handleW] [handleT] [handleArc] [sides]\n");
std::printf(" Wooden well-pail: closed cylindrical body + thin horizontal handle bar above (water-haul / mop-bucket prop)\n");
std::printf(" --gen-mesh-mug <wom-base> [bodyR] [bodyH] [handleW] [handleH] [handleArm] [sides]\n");
std::printf(" Drinking mug / tankard: closed cylinder body + side handle slab (tavern / banquet / inn dressing)\n");
std::printf(" --gen-mesh-mortar-pestle <wom-base> [bowlR] [bowlH] [pestleR] [pestleH] [sides]\n");
std::printf(" Mortar + pestle: wide squat cylinder (bowl) + thin tall cylinder rising from inside (alchemy / kitchen)\n");
std::printf(" --gen-mesh-rune-stone <wom-base> [baseW] [baseD] [baseH] [stoneW] [stoneD] [stoneH]\n");
std::printf(" Rune stone: wide flat base block + tall narrow monolith (druid grove / witch shrine / ancient ruins)\n");
std::printf(" --gen-camp-pack <outDir>\n");
std::printf(" Convenience: emit tent + firepit + bedroll + canopy + woodpile + haystack into outDir as 6 .wom files\n");
std::printf(" --gen-blacksmith-pack <outDir>\n");
std::printf(" Convenience: emit forge + anvil + workbench + water-trough + crate-stack + hitching-post into outDir\n");
std::printf(" --gen-village-pack <outDir>\n");
std::printf(" Convenience: emit house + outhouse + chimney + hitching-post + well + signpost + haystack into outDir\n");
std::printf(" --gen-temple-pack <outDir>\n");
std::printf(" Convenience: emit altar + shrine + brazier + pillar + statue + portal + podium into outDir\n");
std::printf(" --gen-graveyard-pack <outDir>\n");
std::printf(" Convenience: emit grave + tombstone + coffin + statue + stone-bench + gravel-pile + cage into outDir\n");
std::printf(" --gen-garden-pack <outDir>\n");
std::printf(" Convenience: emit pergola + fountain + stone-bench + shrine + beehive + scarecrow + well into outDir\n");
std::printf(" --gen-dock-pack <outDir>\n");
std::printf(" Convenience: emit dock + crate-stack + barrel + canopy + bench + signpost + hitching-post into outDir\n");
std::printf(" --gen-tavern-pack <outDir>\n");
std::printf(" Convenience: emit house + chimney + table + bench + barrel + bookshelf + signpost into outDir\n");
std::printf(" --gen-mining-pack <outDir>\n");
std::printf(" Convenience: emit gravel-pile + crate-stack + mine-cart + pillar-row + lantern + workbench + hitching-post\n");
std::printf(" --gen-arena-pack <outDir>\n");
std::printf(" Convenience: emit training-dummy + archery-target + workbench + crate-stack + bench + water-trough + hitching-rail\n");
std::printf(" --gen-kitchen-pack <outDir>\n");
std::printf(" Convenience: emit stove + cauldron + prep-table + stool + barrel + mug + mortar (tavern back-of-house)\n");
std::printf(" --gen-mesh-table <wom-base> [width] [depth] [height] [legThick] [topThick]\n");
std::printf(" Table: flat top slab on 4 corner legs (default 1.6/1.0/0.85/0.10/0.06)\n");
std::printf(" --gen-mesh-lamppost <wom-base> [poleH] [poleT] [baseSize] [lanternSize] [lanternH]\n");
std::printf(" Lamppost: square base + tall pole + lantern body + cap (default 3.0/0.12/0.4/0.35/0.5)\n");
std::printf(" --gen-mesh-bed <wom-base> [length] [width] [legH] [matThick] [headH] [footH]\n");
std::printf(" Bed: 4 legs + mattress + headboard + footboard + pillow (default 2.0/1.2/0.30/0.20/1.0/0.4)\n");
std::printf(" --gen-mesh-ladder <wom-base> [height] [width] [rungs] [railThick] [rungThick]\n");
std::printf(" Ladder: 2 vertical rails + N evenly-spaced horizontal rungs (default 3.0/0.6/8/0.06/0.04)\n");
std::printf(" --gen-mesh-well <wom-base> [outerSize] [wallH] [wallT] [postH] [postT]\n");
std::printf(" Well: 4 stone walls in a hollow square + 2 roof posts + cross beam (default 1.4/0.8/0.15/1.6/0.12)\n");
std::printf(" --gen-mesh-signpost <wom-base> [poleH] [poleT] [baseSize] [signWidth] [signHeight]\n");
std::printf(" Signpost: base + pole + sign board + cap (default 2.5/0.10/0.30/0.80/0.35)\n");
std::printf(" --gen-mesh-mailbox <wom-base> [postH] [postT] [boxL] [boxW] [boxH]\n");
std::printf(" Mailbox: post + horizontal box + side flag (default 1.10/0.08/0.45/0.20/0.20)\n");
std::printf(" --gen-mesh-tombstone <wom-base> [width] [height] [depth] [baseScale]\n");
std::printf(" Tombstone: base plinth + tall slab + decorative crown (default 0.60/1.10/0.18/1.45)\n");
std::printf(" --gen-mesh-crate <wom-base> [size] [postRadius]\n");
std::printf(" Crate: cube body + 4 corner reinforcement posts (default 0.80/0.05)\n");
std::printf(" --gen-mesh-stool <wom-base> [seatSize] [seatThick] [legHeight] [legThick]\n");
std::printf(" Stool: small backless seat on 4 corner legs (default 0.36/0.04/0.45/0.04)\n");
std::printf(" --gen-mesh-cauldron <wom-base> [rimWidth] [bodyHeight] [legHeight]\n");
std::printf(" Cauldron: 4 legs + narrow bottom + wider mid + widest rim tiers (default 0.80/0.70/0.10)\n");
std::printf(" --gen-mesh-gate <wom-base> [openingWidth] [postHeight] [postT] [railT]\n");
std::printf(" Gate: 2 vertical posts + 3 horizontal rails (default 1.80/1.30/0.10/0.06)\n");
std::printf(" --gen-mesh-beehive <wom-base> [baseWidth] [height] [plateH]\n");
std::printf(" Beehive (skep): 4 tapered tiers + entrance notch on +Z face (default 0.70/0.85/0.05)\n");
std::printf(" --gen-mesh-weathervane <wom-base> [postH] [postT] [baseSize] [armLen] [arrowLen]\n");
std::printf(" Weathervane: base + post + N-S/E-W cross arms + arrow with tail (default 1.50/0.05/0.30/0.40/0.55)\n");
std::printf(" --gen-mesh-scarecrow <wom-base> [bodyH] [armSpan] [postT] [headSize] [hatSize]\n");
std::printf(" Scarecrow: cruciform body + cross arms + head + brimmed hat (default 1.80/1.40/0.06/0.22/0.32)\n");
std::printf(" --gen-mesh-sundial <wom-base> [baseSize] [baseH] [gnomonH] [gnomonT]\n");
std::printf(" Sundial: square base + central gnomon slab + 4 cardinal hour markers (default 0.80/0.06/0.35/0.04)\n");
std::printf(" --gen-mesh-podium <wom-base> [baseSize] [stepH] [steps] [lecternSize]\n");
std::printf(" Podium: stepped pyramid + lectern at back of top platform (default 1.60/0.20/3/0.30)\n");
std::printf(" --gen-mesh-brazier <wom-base> [bowlSize] [stemH] [stemT] [baseSize]\n");
std::printf(" Brazier: base + stem + bowl + 3 flame boxes for fire-pit lighting (default 0.55/0.80/0.10/0.35)\n");
std::printf(" --gen-mesh-archway-double <wom-base> [openingW] [openingH] [postT] [lintelT]\n");
std::printf(" Double archway: 3 posts + 2 lintels for twin-opening passages (default 1.40/2.40/0.18/0.20)\n");
std::printf(" Procedural tree: cylindrical trunk + spherical foliage (default 0.1/2.0/0.7)\n");
std::printf(" --displace-mesh <wom-base> <heightmap.png> [scale]\n");
std::printf(" Offset each vertex along its normal by heightmap brightness × scale (default 1.0)\n");
std::printf(" --gen-mesh-from-heightmap <wom-base> <heightmap.png> [scaleXZ] [scaleY]\n");
std::printf(" Convert a grayscale PNG into a heightmap mesh (W×H verts, 2(W-1)(H-1) tris)\n");
std::printf(" --export-mesh-heightmap <wom-base> <out.png> <W> <H>\n");
std::printf(" Extract a grayscale heightmap PNG from a row-major W×H heightmap mesh\n");
std::printf(" --add-texture-to-mesh <wom-base> <png-path> [batchIdx]\n");
std::printf(" Bind an existing PNG into a WOM's texturePaths and point batchIdx (default 0) at it\n");
std::printf(" --scale-mesh <wom-base> <factor>\n");
std::printf(" Uniformly scale every vertex and bounds by <factor> (factor > 0)\n");
std::printf(" --translate-mesh <wom-base> <dx> <dy> <dz>\n");
std::printf(" Offset every vertex and bounds by (dx, dy, dz)\n");
std::printf(" --strip-mesh <wom-base> [--bones] [--anims] [--all]\n");
std::printf(" Drop bones / animations from a WOM in place (smaller file, static-only use)\n");
std::printf(" --rotate-mesh <wom-base> <x|y|z> <degrees>\n");
std::printf(" Rotate every vertex + normal around the chosen axis by <degrees>\n");
std::printf(" --center-mesh <wom-base>\n");
std::printf(" Translate so the bounds center lands at origin (no scale/rotation change)\n");
std::printf(" --flip-mesh-normals <wom-base>\n");
std::printf(" Invert every vertex normal (use for inside-out meshes or two-sided pre-flip)\n");
std::printf(" --mirror-mesh <wom-base> <x|y|z>\n");
std::printf(" Mirror every vertex + normal across the chosen axis (also flips winding)\n");
std::printf(" --smooth-mesh-normals <wom-base>\n");
std::printf(" Recompute per-vertex normals as area-weighted averages of incident face normals\n");
std::printf(" --merge-meshes <a-base> <b-base> <out-base>\n");
std::printf(" Combine two WOMs into one (vertex/index buffers concatenated, batches preserved)\n");
std::printf(" --add-item <zoneDir> <name> [id] [quality] [displayId] [itemLevel]\n");
std::printf(" Append one item entry to <zoneDir>/items.json (auto-creates the file)\n");
std::printf(" --random-populate-zone <zoneDir> [--seed N] [--creatures N] [--objects N]\n");
std::printf(" Add random creatures/objects to a zone (seeded for reproducibility)\n");
std::printf(" --random-populate-items <zoneDir> [--seed N] [--count N] [--max-quality Q]\n");
std::printf(" Generate random items.json entries (seeded; quality cap defaults to epic=4)\n");
std::printf(" --gen-zone-texture-pack <zoneDir> [--seed N]\n");
std::printf(" Drop a starter texture pack (grass/dirt/stone/brick/wood/water) into <zoneDir>/textures/\n");
std::printf(" --gen-zone-mesh-pack <zoneDir> [--seed N]\n");
std::printf(" Drop a starter WOM mesh pack (rock/tree/fence) into <zoneDir>/meshes/\n");
std::printf(" --gen-zone-starter-pack <zoneDir> [--seed N]\n");
std::printf(" Run both texture-pack + mesh-pack in one pass — full open-format bootstrap\n");
std::printf(" --gen-project-starter-pack <projectDir> [--seed N]\n");
std::printf(" Run starter-pack + audio-pack across every zone — full project-scope bootstrap\n");
std::printf(" --info-zone-summary <zoneDir> [--json]\n");
std::printf(" One-glance health digest for a zone: pack counts/bytes + audit pass/fail\n");
std::printf(" --info-zone-deps <zoneDir> [--json]\n");
std::printf(" Find textures referenced by WOMs but missing from <zoneDir>/textures/ (broken-ref audit)\n");
std::printf(" --info-project-deps <projectDir>\n");
std::printf(" Run --info-zone-deps across every zone; reports per-zone PASS/FAIL + grand total\n");
std::printf(" --info-project-summary <projectDir> [--json]\n");
std::printf(" One-glance status table per zone in a project (BOOTSTRAPPED/PARTIAL/EMPTY)\n");
std::printf(" --gen-zone-readme <zoneDir> [--out <path>]\n");
std::printf(" Auto-generate README.md from zone.json + asset inventory (writes README.md by default)\n");
std::printf(" --gen-project-readme <projectDir> [--out <path>]\n");
std::printf(" Auto-generate PROJECT.md with per-zone status + asset count rollup\n");
std::printf(" --validate-zone-pack <zoneDir> [--json]\n");
std::printf(" Audit a zone's open-format asset pack: textures/meshes/audio counts + WOM validity\n");
std::printf(" --validate-project-packs <projectDir>\n");
std::printf(" Run validate-zone-pack across every zone in a project; exits 1 if any fails\n");
std::printf(" --gen-audio-tone <out.wav> <freqHz> <durationSec> [sampleRate] [waveform]\n");
std::printf(" Synthesize a procedural WAV (PCM-16 mono). Waveform: sine|square|triangle|saw\n");
std::printf(" --gen-audio-noise <out.wav> <durationSec> [sampleRate] [color] [seed] [amplitude]\n");
std::printf(" Synthesize procedural noise WAV. Color: white|pink|brown (default white, amp 0.5)\n");
std::printf(" --gen-audio-sweep <out.wav> <startHz> <endHz> <durationSec> [sampleRate] [shape]\n");
std::printf(" Synthesize frequency sweep (chirp) WAV. Shape: linear|exp (default linear)\n");
std::printf(" --gen-zone-audio-pack <zoneDir>\n");
std::printf(" Drop a starter WAV pack (drone/chime/click/alert) into <zoneDir>/audio/\n");
std::printf(" --gen-random-zone <name> [tx ty] [--seed N] [--creatures N] [--objects N] [--items N]\n");
std::printf(" End-to-end: scaffold-zone + random-populate-zone + random-populate-items\n");
std::printf(" --gen-random-project <count> [--prefix N] [--seed N] [--creatures N] [--objects N] [--items N]\n");
std::printf(" Generate <count> random zones at once (names like Zone1, Zone2...; tile coords step)\n");
std::printf(" --info-zone-audio <zoneDir> [--json]\n");
std::printf(" Print zone audio config (music + ambience tracks, volumes)\n");
std::printf(" --info-project-audio <projectDir> [--json]\n");
std::printf(" Audio config table across every zone (which zones have music/ambience set)\n");
std::printf(" --snap-zone-to-ground <zoneDir>\n");
std::printf(" Re-snap every creature/object in a zone to actual terrain height\n");
std::printf(" --audit-zone-spawns <zoneDir> [--threshold yards]\n");
std::printf(" List spawns whose Z is more than <threshold> yards off from the terrain (default 5)\n");
std::printf(" --list-zone-spawns <zoneDir> [--json]\n");
std::printf(" Combined creature+object listing for a zone (kind, name, position, key fields)\n");
std::printf(" --diff-zone-spawns <aZoneDir> <bZoneDir>\n");
std::printf(" Compare two zones' creature+object lists (added/removed/moved)\n");
std::printf(" --info-spawn <zoneDir> <creature|object> <index> [--json]\n");
std::printf(" Detailed view of a single creature/object spawn by index\n");
std::printf(" --list-project-spawns <projectDir> [--json]\n");
std::printf(" Combined creature+object listing across every zone (zone column added)\n");
std::printf(" --audit-project-spawns <projectDir> [--threshold yards]\n");
std::printf(" Run --audit-zone-spawns across every zone (per-zone summary + total)\n");
std::printf(" --snap-project-to-ground <projectDir>\n");
std::printf(" Run --snap-zone-to-ground across every zone (per-zone summary + totals)\n");
std::printf(" --list-items <zoneDir> [--json]\n");
std::printf(" Print every item in <zoneDir>/items.json with quality colors and key fields\n");
std::printf(" --export-zone-items-md <zoneDir> [out.md]\n");
std::printf(" Render items.json as a Markdown table grouped by quality (rare/epic/etc.)\n");
std::printf(" --export-project-items-md <projectDir> [out.md]\n");
std::printf(" Project-wide items markdown: per-zone sections, project quality histogram\n");
std::printf(" --export-project-items-csv <projectDir> [out.csv]\n");
std::printf(" Single CSV with every item across every zone (zone column added for grouping)\n");
std::printf(" --info-item <zoneDir> <id|index> [--json]\n");
std::printf(" Detail view for one item (lookup by id, or by index if prefixed with '#')\n");
std::printf(" --set-item <zoneDir> <id|#index> [--name S] [--quality N] [--displayId N] [--itemLevel N] [--stackable N]\n");
std::printf(" Edit fields on an existing item in place; only specified flags are changed\n");
std::printf(" --remove-item <zoneDir> <index>\n");
std::printf(" Remove item at given 0-based index from <zoneDir>/items.json\n");
std::printf(" --copy-zone-items <fromZoneDir> <toZoneDir> [--merge]\n");
std::printf(" Copy items from one zone to another (default replaces; --merge appends with re-id)\n");
std::printf(" --clone-item <zoneDir> <index> [newName]\n");
std::printf(" Duplicate the item at index, assign next free id (and optional name override)\n");
std::printf(" --validate-items <zoneDir>\n");
std::printf(" Schema check on items.json: duplicate ids, quality range, required fields\n");
std::printf(" --validate-project-items <projectDir>\n");
std::printf(" Run --validate-items across every zone (per-zone PASS/FAIL + aggregate)\n");
std::printf(" --info-project-items <projectDir> [--json]\n");
std::printf(" Aggregate item counts and quality histogram across every zone in a project\n");
std::printf(" --convert-dbc-json <dbc-path> [out.json]\n");
std::printf(" Convert one DBC file to wowee JSON sidecar format\n");
std::printf(" --convert-json-dbc <json-path> [out.dbc]\n");
std::printf(" Convert a wowee JSON DBC back to binary DBC for private-server compat\n");
std::printf(" --convert-blp-png <blp-path> [out.png]\n");
std::printf(" Convert one BLP texture to PNG sidecar\n");
std::printf(" --convert-blp-batch <srcDir>\n");
std::printf(" Bulk BLP→PNG conversion across every .blp in <srcDir> (sidecars next to source)\n");
std::printf(" --migrate-wom <wom-base> [out-base]\n");
std::printf(" Upgrade an older WOM (v1/v2) to WOM3 with a default single-batch entry\n");
std::printf(" --migrate-zone <zoneDir>\n");
std::printf(" Run --migrate-wom in-place on every WOM under <zoneDir>\n");
std::printf(" --migrate-project <projectDir>\n");
std::printf(" Run --migrate-zone across every zone in <projectDir>\n");
std::printf(" --migrate-jsondbc <path> [out.json]\n");
std::printf(" Auto-fix a JSON DBC sidecar: add missing format/source, sync recordCount\n");
std::printf(" --list-zones [--json] List discovered custom zones and exit\n");
std::printf(" --zone-stats <projectDir> [--json]\n");
std::printf(" Aggregate counts across every zone in <projectDir>\n");
std::printf(" --info-tilemap <projectDir> [--json]\n");
std::printf(" ASCII-render the 64x64 WoW ADT grid showing tile claims by zone\n");
std::printf(" --list-project-orphans <projectDir> [--json]\n");
std::printf(" Find .wom/.wob files in zones not referenced by any objects.json or doodad list\n");
std::printf(" --remove-project-orphans <projectDir> [--dry-run]\n");
std::printf(" Delete the orphan .wom/.wob files surfaced by --list-project-orphans\n");
std::printf(" --list-zone-deps <zoneDir> [--json]\n");
std::printf(" List external M2/WMO model paths a zone references (objects + WOB doodads)\n");
std::printf(" --export-zone-deps-md <zoneDir> [out.md]\n");
std::printf(" Markdown dep table for a zone (with on-disk presence column)\n");
std::printf(" --export-zone-spawn-png <zoneDir> [out.png]\n");
std::printf(" Top-down PNG of creature + object spawn positions (per-tile-bounded)\n");
std::printf(" --check-zone-refs <zoneDir> [--json]\n");
std::printf(" Verify every referenced model/quest NPC actually exists; exit 1 on missing refs\n");
std::printf(" --check-project-refs <projectDir> [--json]\n");
std::printf(" Run --check-zone-refs across every zone in <projectDir>\n");
std::printf(" --check-zone-content <zoneDir> [--json]\n");
std::printf(" Sanity-check creature/object/quest fields for plausible values\n");
std::printf(" --check-project-content <projectDir> [--json]\n");
std::printf(" Run --check-zone-content across every zone in <projectDir>\n");
std::printf(" --for-each-zone <projectDir> -- <cmd...>\n");
std::printf(" Run <cmd...> for every zone in <projectDir>; '{}' in cmd is replaced with the zone path\n");
std::printf(" --for-each-tile <zoneDir> -- <cmd...>\n");
std::printf(" Run <cmd...> for every tile in <zoneDir>; '{}' replaced with the tile-base path\n");
std::printf(" --scaffold-zone <name> [tx ty] Create a blank zone in custom_zones/<name>/ and exit\n");
std::printf(" --mvp-zone <name> [tx ty]\n");
std::printf(" Scaffold + add a creature + object + quest (with objective+reward) for quick demos\n");
std::printf(" --add-tile <zoneDir> <tx> <ty> [baseHeight]\n");
std::printf(" Add a new ADT tile to an existing zone (extends the manifest's tiles list)\n");
std::printf(" --remove-tile <zoneDir> <tx> <ty>\n");
std::printf(" Remove a tile from a zone (drops manifest entry + deletes WHM/WOT/WOC files)\n");
std::printf(" --list-tiles <zoneDir> [--json]\n");
std::printf(" List every tile in a zone manifest with on-disk file presence\n");
std::printf(" --add-creature <zoneDir> <name> <x> <y> <z> [displayId] [level]\n");
std::printf(" Append one creature spawn to <zoneDir>/creatures.json and exit\n");
std::printf(" --add-object <zoneDir> <m2|wmo> <gamePath> <x> <y> <z> [scale]\n");
std::printf(" Append one object placement to <zoneDir>/objects.json and exit\n");
std::printf(" --add-quest <zoneDir> <title> [giverId] [turnInId] [xp] [level]\n");
std::printf(" Append one quest to <zoneDir>/quests.json and exit\n");
std::printf(" --add-quest-objective <zoneDir> <questIdx> <kill|collect|talk|explore|escort|use> <targetName> [count]\n");
std::printf(" Append one objective to a quest by index\n");
std::printf(" --remove-quest-objective <zoneDir> <questIdx> <objIdx>\n");
std::printf(" Remove the objective at given 0-based index from a quest\n");
std::printf(" --clone-quest <zoneDir> <questIdx> [newTitle]\n");
std::printf(" Duplicate a quest (with all objectives + rewards) and append it\n");
std::printf(" --clone-creature <zoneDir> <idx> [newName] [dx dy dz]\n");
std::printf(" Duplicate a creature spawn (defaults: '<orig> (copy)' offset by 5 yards)\n");
std::printf(" --clone-object <zoneDir> <idx> [dx dy dz]\n");
std::printf(" Duplicate an object placement (defaults: offset by 5 yards X)\n");
std::printf(" --add-quest-reward-item <zoneDir> <questIdx> <itemPath> [more...]\n");
std::printf(" Append item reward(s) to a quest's reward.itemRewards list\n");
std::printf(" --set-quest-reward <zoneDir> <questIdx> [--xp N] [--gold N] [--silver N] [--copper N]\n");
std::printf(" Update XP/coin reward fields on a quest by index\n");
std::printf(" --remove-creature <zoneDir> <index>\n");
std::printf(" Remove creature at given 0-based index from <zoneDir>/creatures.json\n");
std::printf(" --remove-object <zoneDir> <index>\n");
std::printf(" Remove object at given 0-based index from <zoneDir>/objects.json\n");
std::printf(" --remove-quest <zoneDir> <index>\n");
std::printf(" Remove quest at given 0-based index from <zoneDir>/quests.json\n");
std::printf(" --copy-zone <srcDir> <newName>\n");
std::printf(" Duplicate a zone to custom_zones/<slug>/ with renamed slug-prefixed files\n");
std::printf(" --rename-zone <srcDir> <newName>\n");
std::printf(" In-place rename (zone.json + slug-prefixed files + dir); no copy\n");
std::printf(" --remove-zone <zoneDir> [--confirm]\n");
std::printf(" Delete a zone directory entirely (requires --confirm to actually delete)\n");
std::printf(" --clear-zone-content <zoneDir> [--creatures] [--objects] [--quests] [--all]\n");
std::printf(" Wipe one or more content files (terrain + manifest preserved)\n");
std::printf(" --strip-zone <zoneDir> [--dry-run]\n");
std::printf(" Remove derived outputs (.glb/.obj/.stl/.html/.dot/.csv/ZONE.md/DEPS.md)\n");
std::printf(" --strip-project <projectDir> [--dry-run]\n");
std::printf(" Run --strip-zone across every zone (per-zone counts + aggregate freed bytes)\n");
std::printf(" --gen-makefile <zoneDir> [out.mk]\n");
std::printf(" Generate a Makefile that rebuilds every derived output for a zone\n");
std::printf(" --gen-project-makefile <projectDir> [out.mk]\n");
std::printf(" Generate a top-level Makefile that delegates to each zone's per-zone Makefile\n");
std::printf(" --repair-project <projectDir> [--dry-run]\n");
std::printf(" Run --repair-zone across every zone (manifest drift fixes, per-zone summary)\n");
std::printf(" --repair-zone <zoneDir> [--dry-run]\n");
std::printf(" Auto-fix manifest/disk drift (missing tiles in manifest, hasCreatures flag)\n");
std::printf(" --build-woc <wot-base> Generate a WOC collision mesh from WHM/WOT and exit\n");
std::printf(" --regen-collision <zoneDir> Rebuild every WOC under a zone dir and exit\n");
std::printf(" --fix-zone <zoneDir> Re-parse + re-save zone JSONs to apply latest scrubs/caps and exit\n");
std::printf(" --export-png <wot-base> Render heightmap, normal-map, and zone-map PNG previews\n");
std::printf(" --export-obj <wom-base> [out.obj]\n");
std::printf(" Convert a WOM model to Wavefront OBJ for use in Blender/MeshLab\n");
std::printf(" --export-glb <wom-base> [out.glb]\n");
std::printf(" Convert a WOM model to glTF 2.0 binary (.glb) — modern industry standard\n");
std::printf(" --export-stl <wom-base> [out.stl]\n");
std::printf(" Convert a WOM model to ASCII STL — works with any 3D printer slicer\n");
std::printf(" --import-stl <stl-path> [wom-base]\n");
std::printf(" Convert an ASCII STL back into WOM (round-trips with --export-stl)\n");
std::printf(" --export-wob-glb <wob-base> [out.glb]\n");
std::printf(" Convert a WOB building to glTF 2.0 binary (one mesh, per-group primitives)\n");
std::printf(" --export-whm-glb <wot-base> [out.glb]\n");
std::printf(" Convert WHM heightmap to glTF 2.0 binary terrain mesh (per-chunk primitives)\n");
std::printf(" --bake-zone-glb <zoneDir> [out.glb]\n");
std::printf(" Bake every WHM tile in a zone into one glTF (one node per tile)\n");
std::printf(" --bake-zone-stl <zoneDir> [out.stl]\n");
std::printf(" Bake every WHM tile in a zone into one STL for 3D-printing the terrain\n");
std::printf(" --bake-zone-obj <zoneDir> [out.obj]\n");
std::printf(" Bake every WHM tile in a zone into one Wavefront OBJ (one g-block per tile)\n");
std::printf(" --bake-project-obj <projectDir> [out.obj]\n");
std::printf(" Bake every zone in a project into one Wavefront OBJ (one g-block per zone)\n");
std::printf(" --bake-project-stl <projectDir> [out.stl]\n");
std::printf(" Bake every zone in a project into one ASCII STL for full-project printing\n");
std::printf(" --bake-project-glb <projectDir> [out.glb]\n");
std::printf(" Bake every zone in a project into one glTF 2.0 (one mesh per zone)\n");
std::printf(" --bake-wom-collision <wom-base> [out.woc] [--weld <eps>] [--steep <deg>]\n");
std::printf(" Convert a WOM into a WOC collision file (raycast / walkability mesh) with optional vertex weld\n");
std::printf(" --bake-wob-collision <wob-base> [out.woc] [--weld <eps>] [--steep <deg>]\n");
std::printf(" Convert a multi-group WOB building into a single WOC collision file (weld is per-group)\n");
std::printf(" --bake-zone-collision <zoneDir> [out.woc] [--weld <eps>] [--steep <deg>]\n");
std::printf(" Walk every .wom + .wob under zoneDir, weld each independently, append to one shared WOC\n");
std::printf(" --audit-watertight <zoneDir|projectDir> [--weld <eps>] [--json] [--summary]\n");
std::printf(" Walk every .wom under root, run welded watertight check; --summary prints a one-line rollup\n");
std::printf(" --audit-watertight-wob <zoneDir|projectDir> [--weld <eps>] [--json] [--summary]\n");
std::printf(" Walk every .wob, check that EVERY group is closed (per-group weld); --summary prints one-line rollup\n");
std::printf(" --import-obj <obj-path> [wom-base]\n");
std::printf(" Convert a Wavefront OBJ back into WOM (round-trips with --export-obj)\n");
std::printf(" --export-wob-obj <wob-base> [out.obj]\n");
std::printf(" Convert a WOB building to Wavefront OBJ (one group per WOB group)\n");
std::printf(" --import-wob-obj <obj-path> [wob-base]\n");
std::printf(" Convert a Wavefront OBJ back into WOB (round-trips with --export-wob-obj)\n");
std::printf(" --export-woc-obj <woc-path> [out.obj]\n");
std::printf(" Convert a WOC collision mesh to OBJ for visualization (per-flag color groups)\n");
std::printf(" --export-whm-obj <wot-base> [out.obj]\n");
std::printf(" Convert a WHM heightmap to OBJ terrain mesh (9x9 outer grid per chunk)\n");
std::printf(" --validate <zoneDir> [--json]\n");
std::printf(" Score zone open-format completeness and exit\n");
std::printf(" --validate-wom <wom-base> [--json]\n");
std::printf(" Deep-check a WOM file for index/bone/batch/bound invariants\n");
std::printf(" --validate-wob <wob-base> [--json]\n");
std::printf(" Deep-check a WOB file for group/portal/doodad invariants\n");
std::printf(" --validate-woc <woc-path> [--json]\n");
std::printf(" Deep-check a WOC collision mesh for finite verts and degeneracy\n");
std::printf(" --validate-whm <wot-base> [--json]\n");
std::printf(" Deep-check a WHM/WOT terrain pair for NaN heights and bad placements\n");
std::printf(" --validate-all <dir> [--json]\n");
std::printf(" Recursively run all per-format validators on every file\n");
std::printf(" --validate-project <projectDir> [--json]\n");
std::printf(" Run --validate-all on every zone in <projectDir>; exit 1 if any zone fails\n");
std::printf(" --bench-validate-project <projectDir> [--json]\n");
std::printf(" Time --validate-project per zone; report avg/min/max latency\n");
std::printf(" --bench-bake-project <projectDir> [--json]\n");
std::printf(" Time WHM/WOT load per zone (proxy for bake cost); report timings\n");
std::printf(" --validate-glb <path> [--json]\n");
std::printf(" Verify a glTF 2.0 binary's structure (magic, chunks, JSON, accessors)\n");
std::printf(" --check-glb-bounds <path> [--json]\n");
std::printf(" Verify position accessor min/max in a .glb actually matches the data\n");
std::printf(" --validate-stl <path> [--json]\n");
std::printf(" Verify an ASCII STL's structure (solid framing, facet/vertex shape, no NaN)\n");
std::printf(" --validate-png <path> [--json]\n");
std::printf(" Verify a PNG's structure (signature, chunks, CRC, IHDR/IDAT/IEND order)\n");
std::printf(" --validate-blp <path> [--json]\n");
std::printf(" Verify a BLP texture (magic, dimensions, mip offsets within file)\n");
std::printf(" --validate-jsondbc <path> [--json]\n");
std::printf(" Verify a JSON DBC sidecar's full schema (per-cell types, row width, format tag)\n");
std::printf(" --info-glb <path> [--json]\n");
std::printf(" Print glTF 2.0 binary metadata (chunks, mesh/primitive counts, accessors)\n");
std::printf(" --info-glb-bytes <path> [--json]\n");
std::printf(" Per-section + per-bufferView byte breakdown of a .glb file\n");
std::printf(" --info-glb-tree <path>\n");
std::printf(" Render glTF structure as a tree (scenes/nodes/meshes/primitives)\n");
std::printf(" --zone-summary <zoneDir> [--json]\n");
std::printf(" One-shot validate + creature/object/quest counts and exit\n");
std::printf(" --info-zone-tree <zoneDir>\n");
std::printf(" Render a hierarchical tree view of a zone's contents (no --json)\n");
std::printf(" --info-project-tree <projectDir>\n");
std::printf(" Tree view of every zone in a project with quick counts (no --json)\n");
std::printf(" --info-project-bytes <projectDir> [--json]\n");
std::printf(" Per-zone byte rollup with proprietary-vs-open category split (size audit)\n");
std::printf(" --validate-project-open-only <projectDir>\n");
std::printf(" Exit 1 if any proprietary Blizzard assets (.m2/.wmo/.blp/.dbc) remain — release gate\n");
std::printf(" --audit-project <projectDir>\n");
std::printf(" Run validate-project + open-only + check-project-refs together; one PASS/FAIL\n");
std::printf(" --bench-audit-project <projectDir>\n");
std::printf(" Time each --audit-project sub-step; shows where the slow ones are\n");
std::printf(" --info-zone-bytes <zoneDir> [--json]\n");
std::printf(" Per-file size breakdown grouped by category, sorted largest-first\n");
std::printf(" --info-project-extents <projectDir> [--json]\n");
std::printf(" Combined spatial bounding box across every zone (per-zone table + project union)\n");
std::printf(" --info-zone-extents <zoneDir> [--json]\n");
std::printf(" Compute the zone's bounding box (XY tile range, Z height min/max)\n");
std::printf(" --info-project-water <projectDir> [--json]\n");
std::printf(" Aggregate water-layer stats across every zone (per-zone breakdown + project totals)\n");
std::printf(" --info-zone-water <zoneDir> [--json]\n");
std::printf(" Aggregate water-layer stats across all tiles (layer count, types, area)\n");
std::printf(" --info-project-density <projectDir> [--json]\n");
std::printf(" Per-zone content density rollup (creatures/objects/quests per tile, project totals)\n");
std::printf(" --info-zone-density <zoneDir> [--json]\n");
std::printf(" Per-tile density (creatures/objects/quests per tile + overall avg)\n");
std::printf(" --export-zone-summary-md <zoneDir> [out.md]\n");
std::printf(" Render a markdown documentation page for a zone (manifest + content)\n");
std::printf(" --export-zone-csv <zoneDir> [outDir]\n");
std::printf(" Emit creatures.csv / objects.csv / quests.csv / items.csv for spreadsheet workflows\n");
std::printf(" --export-zone-checksum <zoneDir> [out.sha256]\n");
std::printf(" Emit a SHA-256 manifest of every source file in a zone (for integrity checks)\n");
std::printf(" --export-project-checksum <projectDir> [out.sha256]\n");
std::printf(" Project-wide SHA-256 manifest (paths are zone-relative) + single project fingerprint\n");
std::printf(" --validate-project-checksum <projectDir> [in.sha256]\n");
std::printf(" Verify PROJECT_SHA256SUMS in-tool (cross-platform, no sha256sum dependency)\n");
std::printf(" --export-zone-html <zoneDir> [out.html]\n");
std::printf(" Emit a single-file HTML viewer next to the zone .glb (model-viewer based)\n");
std::printf(" --export-project-html <projectDir> [out.html]\n");
std::printf(" Generate an index.html linking to every zone's HTML viewer in <projectDir>\n");
std::printf(" --export-project-md <projectDir> [out.md]\n");
std::printf(" Generate a README.md indexing every zone with counts + viewer/bake status\n");
std::printf(" --export-quest-graph <zoneDir> [out.dot]\n");
std::printf(" Render quest-chain DAG as Graphviz DOT (pipe to `dot -Tpng -o quests.png`)\n");
std::printf(" --info <wom-base> [--json]\n");
std::printf(" Print WOM file metadata (version, counts) and exit\n");
std::printf(" --info-batches <wom-base> [--json]\n");
std::printf(" Per-batch breakdown of a WOM3 (index range, texture, blend mode, flags)\n");
std::printf(" --info-textures <wom-base> [--json]\n");
std::printf(" List every texture path referenced by a WOM (with on-disk presence)\n");
std::printf(" --info-doodads <wob-base> [--json]\n");
std::printf(" List every doodad placement in a WOB (model path, position, rotation, scale)\n");
std::printf(" --info-attachments <m2-path> [--json]\n");
std::printf(" List M2 attachment points (weapon mounts, etc.) with bone + offset\n");
std::printf(" --info-particles <m2-path> [--json]\n");
std::printf(" List M2 particle + ribbon emitters (texture, blend, bone)\n");
std::printf(" --info-sequences <m2-path> [--json]\n");
std::printf(" List M2 animation sequences (id, duration, flags)\n");
std::printf(" --info-bones <m2-path> [--json]\n");
std::printf(" List M2 bones with parent tree, key-bone IDs, pivot offsets\n");
std::printf(" --export-bones-dot <wom-base> [out.dot]\n");
std::printf(" Render WOM bone hierarchy as Graphviz DOT (pipe to `dot -Tpng -o bones.png`)\n");
std::printf(" --list-project-meshes <projectDir> [--json]\n");
std::printf(" Project-wide WOM inventory across every zone (vert/tri totals + per-zone breakdown)\n");
std::printf(" --list-project-audio <projectDir> [--json]\n");
std::printf(" Project-wide WAV inventory across every zone (duration/bytes per zone + grand total)\n");
std::printf(" --list-project-textures <projectDir> [--json]\n");
std::printf(" Aggregate texture refs across every WOM in a project (deduped, with zone breakdown)\n");
std::printf(" --list-zone-meshes <zoneDir> [--json]\n");
std::printf(" List every WOM in <zoneDir> with vert/tri/bone/anim/batch counts and file size\n");
std::printf(" --list-zone-audio <zoneDir> [--json]\n");
std::printf(" List every WAV under <zoneDir>/audio/ with format/duration/sample-rate/size\n");
std::printf(" --list-zone-textures <zoneDir> [--json]\n");
std::printf(" Aggregate texture refs across all WOM models in a zone (deduped)\n");
std::printf(" --info-zone-models-total <zoneDir> [--json]\n");
std::printf(" Aggregate WOM/WOB stats across a zone (verts, tris, bones, batches, doodads)\n");
std::printf(" --list-zone-meshes-detail <zoneDir> [--json]\n");
std::printf(" Per-mesh listing of every .wom in a zone, sorted by triangle count\n");
std::printf(" --info-mesh <wom-base> [--json]\n");
std::printf(" Single-mesh detail: bounds, version, batches, bones, textures, attachments in one view\n");
std::printf(" --info-mesh-storage-budget <wom-base> [--json]\n");
std::printf(" Estimated bytes-per-category breakdown for a single WOM (vertices/indices/bones/...)\n");
std::printf(" --info-mesh-stats <wom-base> [--json]\n");
std::printf(" Geometric stats: total surface area, triangle area histogram, edge use, watertight check\n");
std::printf(" --list-project-meshes-detail <projectDir> [--json]\n");
std::printf(" Per-mesh listing across every zone in a project (sorted by triangle count)\n");
std::printf(" --info-project-models-total <projectDir> [--json]\n");
std::printf(" Aggregate WOM/WOB stats across an entire project (per-zone breakdown + totals)\n");
std::printf(" --info-wob <wob-base> [--json]\n");
std::printf(" Print WOB building metadata (groups, portals, doodads) and exit\n");
std::printf(" --info-wob-stats <wob-base> [--weld <eps>] [--json]\n");
std::printf(" Per-group + aggregate geometric stats (surface area, edges, watertight) for a WOB building\n");
std::printf(" --info-woc <woc-path> [--json]\n");
std::printf(" Print WOC collision metadata (triangle counts, bounds) and exit\n");
std::printf(" --info-wol <wol-base> [--json]\n");
std::printf(" Print WOL lighting keyframes (zone name + per-time-of-day ambient/directional/fog) and exit\n");
std::printf(" --info-wol-at <wol-base> <HH:MM|minutes>\n");
std::printf(" Sample the WOL's interpolated lighting at a specific time-of-day (linear blend between keyframes)\n");
std::printf(" --validate-wol <wol-base> [--json]\n");
std::printf(" Walk every keyframe; check time bounds + sort order + fogEnd > fogStart + finite color components\n");
std::printf(" --gen-light <wol-base> [zoneName]\n");
std::printf(" Emit a starter .wol with the canonical 4-keyframe day/night cycle (midnight + dawn + noon + dusk)\n");
std::printf(" --gen-light-cave <wol-base> [zoneName]\n");
std::printf(" Emit a single-keyframe .wol with dim cool ambient + heavy short-range fog (cave / mine interior)\n");
std::printf(" --gen-light-dungeon <wol-base> [zoneName]\n");
std::printf(" Emit a single-keyframe .wol with warm torchlit ambient + medium fog (dungeon / crypt interior)\n");
std::printf(" --gen-light-night <wol-base> [zoneName]\n");
std::printf(" Emit a single-keyframe .wol with moonlit directional + far fog (always-night zone / shadow realm)\n");
std::printf(" --export-wol-json <wol-base> [out.json]\n");
std::printf(" Export binary .wol to a human-editable JSON sidecar (defaults to <base>.wol.json)\n");
std::printf(" --import-wol-json <json-path> [out-base]\n");
std::printf(" Import a .wol.json sidecar back into binary .wol (round-trip with --export-wol-json)\n");
std::printf(" --export-wow-json <wow-base> [out.json]\n");
std::printf(" Export binary .wow to a human-editable JSON sidecar (defaults to <base>.wow.json)\n");
std::printf(" --import-wow-json <json-path> [out-base]\n");
std::printf(" Import a .wow.json sidecar back into binary .wow (accepts type-name string OR typeId int)\n");
std::printf(" --info-wow <wow-base> [--json]\n");
std::printf(" Print WOW weather entries (zone + per-state type / intensity / weight / duration) and exit\n");
std::printf(" --validate-wow <wow-base> [--json]\n");
std::printf(" Walk every WOW entry; check typeId / intensity bounds [0,1] / weight > 0 / duration min ≤ max\n");
std::printf(" --validate-wom <wom-base> [--json]\n");
std::printf(" Static sanity checks on .wom: index range, bone refs, bound box, batch coverage, animation track count\n");
std::printf(" --gen-world-map <womx-base> [mapName]\n");
std::printf(" Emit .womx world-tile manifest: 64x64 continent grid with all tiles present (open WDT replacement)\n");
std::printf(" --gen-world-map-instance <womx-base> [mapName]\n");
std::printf(" Emit .womx world-tile manifest: 4x4 instance grid (small-world / dungeon scale)\n");
std::printf(" --gen-world-map-arena <womx-base> [mapName]\n");
std::printf(" Emit .womx world-tile manifest: 1x1 single-tile arena (smallest valid world)\n");
std::printf(" --info-womx <womx-base> [--json]\n");
std::printf(" Print WOMX manifest (worldType / gridSize / tilesPresent / defaultLightId / defaultWeatherId)\n");
std::printf(" --validate-womx <womx-base> [--json]\n");
std::printf(" Static checks on .womx: gridSize 1..128, worldType in range, tileBitmap matches expected size\n");
std::printf(" --export-womx-json <womx-base> [out.json]\n");
std::printf(" Export binary .womx to a human-editable JSON sidecar (rows of '1'/'0' strings, easy to hand-edit)\n");
std::printf(" --import-womx-json <json-path> [out-base]\n");
std::printf(" Import a .womx.json sidecar back into binary .womx (round-trip with --export-womx-json)\n");
std::printf(" --gen-sound-catalog <wsnd-base> [name]\n");
std::printf(" Emit .wsnd starter catalog (one entry per kind: sfx/music/ambient/ui/voice/spell/combat)\n");
std::printf(" --gen-sound-catalog-ambient <wsnd-base> [name]\n");
std::printf(" Emit .wsnd wilderness catalog: looped birds + wind + 3 footstep variants\n");
std::printf(" --gen-sound-catalog-tavern <wsnd-base> [name]\n");
std::printf(" Emit .wsnd tavern catalog: fire-crackle + crowd murmur + drink-clink + door-creak + lute music\n");
std::printf(" --info-wsnd <wsnd-base> [--json]\n");
std::printf(" Print WSND catalog entries (id / kind / flags / volume / 3D distances / file path / label)\n");
std::printf(" --validate-wsnd <wsnd-base> [--json]\n");
std::printf(" Static checks: kind in 0..6, finite distances, 3D needs max>min>=0, no duplicate sound IDs\n");
std::printf(" --export-wsnd-json <wsnd-base> [out.json]\n");
std::printf(" Export binary .wsnd to a human-editable JSON sidecar (defaults to <base>.wsnd.json)\n");
std::printf(" --import-wsnd-json <json-path> [out-base]\n");
std::printf(" Import a .wsnd.json sidecar back into binary .wsnd (accepts either kind int OR kindName string)\n");
std::printf(" --gen-spawns <wspn-base> [name]\n");
std::printf(" Emit .wspn starter spawn catalog: 1 creature + 1 game object + 1 doodad near origin\n");
std::printf(" --gen-spawns-camp <wspn-base> [name]\n");
std::printf(" Emit .wspn bandit-camp catalog: 4 creatures around a wander ring + 1 chest + 2 tents\n");
std::printf(" --gen-spawns-village <wspn-base> [name]\n");
std::printf(" Emit .wspn village catalog: 6 friendly NPCs (mixed roles) + 2 signs + 4 corner trees\n");
std::printf(" --info-wspn <wspn-base> [--json]\n");
std::printf(" Print WSPN spawn entries (kind / entryId / position / respawn / wander radius / label)\n");
std::printf(" --validate-wspn <wspn-base> [--json]\n");
std::printf(" Static checks: kind 0..2, finite position/scale/wander, doodads have respawn=0, no orphan entryId=0\n");
std::printf(" --export-wspn-json <wspn-base> [out.json]\n");
std::printf(" Export binary .wspn to a human-editable JSON sidecar (defaults to <base>.wspn.json)\n");
std::printf(" --import-wspn-json <json-path> [out-base]\n");
std::printf(" Import a .wspn.json sidecar back into binary .wspn (accepts either kind int OR kindName string)\n");
std::printf(" --gen-items <wit-base> [name]\n");
std::printf(" Emit .wit starter item catalog: 1 weapon + 1 chest + 1 potion + 1 quest item\n");
std::printf(" --gen-items-weapons <wit-base> [name]\n");
std::printf(" Emit .wit weapon catalog: 5 entries spanning common -> legendary, both 1H and 2H\n");
std::printf(" --gen-items-armor <wit-base> [name]\n");
std::printf(" Emit .wit full mail-armor set: head + chest + legs + feet + hands + cloak (BoE)\n");
std::printf(" --info-wit <wit-base> [--json]\n");
std::printf(" Print WIT item entries (id / ilvl / quality / class / slot / buy price / name)\n");
std::printf(" --validate-wit <wit-base> [--json]\n");
std::printf(" Static checks: itemId>0 + unique, weapon damage>0 + min<=max, equippable durability>0, sell<buy\n");
std::printf(" --export-wit-json <wit-base> [out.json]\n");
std::printf(" Export binary .wit to a human-editable JSON sidecar (defaults to <base>.wit.json)\n");
std::printf(" --import-wit-json <json-path> [out-base]\n");
std::printf(" Import a .wit.json sidecar back into binary .wit (accepts quality/class/slot int OR name string)\n");
std::printf(" --gen-loot <wlot-base> [name]\n");
std::printf(" Emit .wlot starter loot catalog: 1 creature with 1 drop slot, 1 item @ 50%%, 0..50 copper\n");
std::printf(" --gen-loot-bandit <wlot-base> [name]\n");
std::printf(" Emit .wlot bandit loot table: dropCount=2, 4 candidate items, 5..50 copper\n");
std::printf(" --gen-loot-boss <wlot-base> [name]\n");
std::printf(" Emit .wlot elite boss table: dropCount=4, 6 candidates incl. quest item + group-only epic, 50..200 silver\n");
std::printf(" --info-wlot <wlot-base> [--json]\n");
std::printf(" Print WLOT loot tables (creatureId / dropCount / money range / per-drop chance + qty + flags)\n");
std::printf(" --validate-wlot <wlot-base> [--json]\n");
std::printf(" Static checks: creatureId>0 + unique, chance in 0..100, minQty<=maxQty, money min<=max\n");
std::printf(" --export-wlot-json <wlot-base> [out.json]\n");
std::printf(" Export binary .wlot to a human-editable JSON sidecar (defaults to <base>.wlot.json)\n");
std::printf(" --import-wlot-json <json-path> [out-base]\n");
std::printf(" Import a .wlot.json sidecar back into binary .wlot (accepts flag int OR flagsList strings)\n");
std::printf(" --gen-creatures <wcrt-base> [name]\n");
std::printf(" Emit .wcrt starter creature template: 1 friendly innkeeper (vendor + repair flags)\n");
std::printf(" --gen-creatures-bandit <wcrt-base> [name]\n");
std::printf(" Emit .wcrt bandit (creatureId=1000, matches WSPN camp + WLOT bandit table, equips WIT sword)\n");
std::printf(" --gen-creatures-merchants <wcrt-base> [name]\n");
std::printf(" Emit .wcrt 3-NPC village set (innkeeper / smith / alchemist, matches WSPN village creatureIds)\n");
std::printf(" --info-wcrt <wcrt-base> [--json]\n");
std::printf(" Print WCRT entries (id / level / hp / type / faction / npc-flags / name + subname)\n");
std::printf(" --validate-wcrt <wcrt-base> [--json]\n");
std::printf(" Static checks: creatureId>0+unique, level/hp>0, min<=max, attackSpeed>0, behavior flag conflicts\n");
std::printf(" --export-wcrt-json <wcrt-base> [out.json]\n");
std::printf(" Export binary .wcrt to a human-editable JSON sidecar (defaults to <base>.wcrt.json)\n");
std::printf(" --import-wcrt-json <json-path> [out-base]\n");
std::printf(" Import a .wcrt.json sidecar back into binary .wcrt (accepts type/family/flag int OR name forms)\n");
std::printf(" --gen-quests <wqt-base> [name]\n");
std::printf(" Emit .wqt starter quest: 'Kill 10 Defias Bandits' giver=4001 (matches WCRT village innkeeper)\n");
std::printf(" --gen-quests-chain <wqt-base> [name]\n");
std::printf(" Emit .wqt 3-quest chain: Investigate -> Recover -> Report (chained via prev/next questId)\n");
std::printf(" --gen-quests-daily <wqt-base> [name]\n");
std::printf(" Emit .wqt daily repeatable quest with the Daily + Repeatable + AutoAccept flag combo\n");
std::printf(" --info-wqt <wqt-base> [--json]\n");
std::printf(" Print WQT entries (questId / level / giver / objectives / rewards / chain links)\n");
std::printf(" --validate-wqt <wqt-base> [--json]\n");
std::printf(" Static checks: questId>0+unique, level>0+min<=max, title not empty, no rewards warning, daily needs repeatable\n");
std::printf(" --export-wqt-json <wqt-base> [out.json]\n");
std::printf(" Export binary .wqt to a human-editable JSON sidecar (defaults to <base>.wqt.json)\n");
std::printf(" --import-wqt-json <json-path> [out-base]\n");
std::printf(" Import a .wqt.json sidecar back into binary .wqt (accepts kind/flag int OR name forms)\n");
std::printf(" --gen-objects <wgot-base> [name]\n");
std::printf(" Emit .wgot starter object catalog: 1 chest + 1 mailbox + 1 sign\n");
std::printf(" --gen-objects-dungeon <wgot-base> [name]\n");
std::printf(" Emit .wgot dungeon set: door + button + 2 chests (bandit + boss) + spike trap (cross-refs WLOT)\n");
std::printf(" --gen-objects-gather <wgot-base> [name]\n");
std::printf(" Emit .wgot gathering nodes: Peacebloom (herb) + Tin Vein (ore) + Schools of Fish, with skill reqs\n");
std::printf(" --info-wgot <wgot-base> [--json]\n");
std::printf(" Print WGOT entries (objectId / type / lock / loot / required skill / name)\n");
std::printf(" --validate-wgot <wgot-base> [--json]\n");
std::printf(" Static checks: objectId>0+unique, size>0, time min<=max, gathering needs skill, chest warns on no loot\n");
std::printf(" --export-wgot-json <wgot-base> [out.json]\n");
std::printf(" Export binary .wgot to a human-editable JSON sidecar (defaults to <base>.wgot.json)\n");
std::printf(" --import-wgot-json <json-path> [out-base]\n");
std::printf(" Import a .wgot.json sidecar back into binary .wgot (accepts type/flag int OR name forms)\n");
std::printf(" --gen-factions <wfac-base> [name]\n");
std::printf(" Emit .wfac starter: 3 factions (Friendly id=35 / Hostile id=14 / Player id=1) matching WCRT defaults\n");
std::printf(" --gen-factions-alliance <wfac-base> [name]\n");
std::printf(" Emit .wfac Alliance set: header + Stormwind + Darnassus + Ironforge (reciprocal friends) + Defias enemy\n");
std::printf(" --gen-factions-wildlife <wfac-base> [name]\n");
std::printf(" Emit .wfac wildlife: wolves + bears + spiders + kobolds (each hostile to player, ignores other beasts)\n");
std::printf(" --info-wfac <wfac-base> [--json]\n");
std::printf(" Print WFAC entries (id / parent / flags / enemy + friend counts / name)\n");
std::printf(" --validate-wfac <wfac-base> [--json]\n");
std::printf(" Static checks: factionId>0+unique, name not empty, threshold ordering, no self-enemy, no enemy/friend overlap\n");
std::printf(" --export-wfac-json <wfac-base> [out.json]\n");
std::printf(" Export binary .wfac to a human-editable JSON sidecar (defaults to <base>.wfac.json)\n");
std::printf(" --import-wfac-json <json-path> [out-base]\n");
std::printf(" Import a .wfac.json sidecar back into binary .wfac (accepts flag int OR flagsList strings)\n");
std::printf(" --gen-locks <wlck-base> [name]\n");
std::printf(" Emit .wlck starter: 2 locks (Iron Door key+force, Wooden Chest force-only) — lockId=1 matches WGOT\n");
std::printf(" --gen-locks-dungeon <wlck-base> [name]\n");
std::printf(" Emit .wlck dungeon set: light/heavy lockpicks (lockId=2 matches WGOT bandit chest), boss-key seal\n");
std::printf(" --gen-locks-professions <wlck-base> [name]\n");
std::printf(" Emit .wlck profession-keyed locks at lockpick rank 1/100/175/250 (junkbox tier progression)\n");
std::printf(" --info-wlck <wlck-base> [--json]\n");
std::printf(" Print WLCK lock entries with per-channel detail (kind / target / required skill rank)\n");
std::printf(" --validate-wlck <wlck-base> [--json]\n");
std::printf(" Static checks: lockId>0+unique, at least 1 active channel, item/spell/lockpick need targetId\n");
std::printf(" --export-wlck-json <wlck-base> [out.json]\n");
std::printf(" Export binary .wlck to a human-editable JSON sidecar (defaults to <base>.wlck.json)\n");
std::printf(" --import-wlck-json <json-path> [out-base]\n");
std::printf(" Import a .wlck.json sidecar back into binary .wlck (accepts kind/flag int OR name forms)\n");
std::printf(" --gen-skills <wskl-base> [name]\n");
std::printf(" Emit .wskl starter: Swords + Common + First Aid + Mining (id=186) + Lockpicking (id=633) — matches WGOT/WLCK\n");
std::printf(" --gen-skills-professions <wskl-base> [name]\n");
std::printf(" Emit .wskl 12 classic professions (9 primary + 3 secondary) with canonical SkillLine IDs\n");
std::printf(" --gen-skills-weapons <wskl-base> [name]\n");
std::printf(" Emit .wskl all 16 weapon skills with rankPerLevel=5 auto-grow (use-trained, not trainer-trained)\n");
std::printf(" --info-wskl <wskl-base> [--json]\n");
std::printf(" Print WSKL entries (id / category / max rank / per-level grow / trainer-required / name)\n");
std::printf(" --validate-wskl <wskl-base> [--json]\n");
std::printf(" Static checks: skillId>0+unique, name not empty, maxRank>0, weapon needs rankPerLevel>0\n");
std::printf(" --export-wskl-json <wskl-base> [out.json]\n");
std::printf(" Export binary .wskl to a human-editable JSON sidecar (defaults to <base>.wskl.json)\n");
std::printf(" --import-wskl-json <json-path> [out-base]\n");
std::printf(" Import a .wskl.json sidecar back into binary .wskl (accepts category int OR categoryName string)\n");
std::printf(" --gen-spells <wspl-base> [name]\n");
std::printf(" Emit .wspl starter spell catalog: 4 spells covering damage / heal / buff / teleport effect kinds\n");
std::printf(" --gen-spells-mage <wspl-base> [name]\n");
std::printf(" Emit .wspl mage spell set: Frostbolt + Fireball + Arcane Intellect + Blink (canonical IDs 116/133/1459/1953)\n");
std::printf(" --gen-spells-warrior <wspl-base> [name]\n");
std::printf(" Emit .wspl warrior spell set: Heroic Strike + Thunder Clap + Battle Shout + Mortal Strike\n");
std::printf(" --info-wspl <wspl-base> [--json]\n");
std::printf(" Print WSPL spell entries (id / school / effect / cast/cd / mana / range / damage range / name)\n");
std::printf(" --validate-wspl <wspl-base> [--json]\n");
std::printf(" Static checks: spellId>0+unique, name not empty, school 0..6, range/value min<=max, friendly+hostile incoherent\n");
std::printf(" --export-wspl-json <wspl-base> [out.json]\n");
std::printf(" Export binary .wspl to a human-editable JSON sidecar (defaults to <base>.wspl.json)\n");
std::printf(" --import-wspl-json <json-path> [out-base]\n");
std::printf(" Import a .wspl.json sidecar back into binary .wspl (accepts school/target/effect/flag int OR name forms)\n");
std::printf(" --gen-achievements <wach-base> [name]\n");
std::printf(" Emit .wach starter: 3 achievements (First Blood / Helping Hand / Coming of Age)\n");
std::printf(" --gen-achievements-bandit <wach-base> [name]\n");
std::printf(" Emit .wach bandit-themed: 3 achievements with cross-refs to WCRT/WGOT/WQT bandit IDs\n");
std::printf(" --gen-achievements-meta <wach-base> [name]\n");
std::printf(" Emit .wach 3 base achievements + 1 meta-achievement (Jack of All Trades, title 'the Versatile')\n");
std::printf(" --info-wach <wach-base> [--json]\n");
std::printf(" Print WACH entries (id / points / faction / flags / criteria with kind+target+qty)\n");
std::printf(" --validate-wach <wach-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, faction 0..2, criteria need targetId+quantity>0\n");
std::printf(" --export-wach-json <wach-base> [out.json]\n");
std::printf(" Export binary .wach to a human-editable JSON sidecar (defaults to <base>.wach.json)\n");
std::printf(" --import-wach-json <json-path> [out-base]\n");
std::printf(" Import a .wach.json sidecar back into binary .wach (accepts kind/faction/flag int OR name forms)\n");
std::printf(" --gen-trainers <wtrn-base> [name]\n");
std::printf(" Emit .wtrn starter: 1 NPC (innkeeper 4001) acting as both vendor + trainer with WSKL/WIT cross-refs\n");
std::printf(" --gen-trainers-mage <wtrn-base> [name]\n");
std::printf(" Emit .wtrn mage trainer (npcId=4003): teaches Frostbolt/Fireball/Arcane Intellect/Blink at scaling cost\n");
std::printf(" --gen-trainers-weapons <wtrn-base> [name]\n");
std::printf(" Emit .wtrn weapon vendor (npcId=4002): 5 weapons with mixed unlimited/finite stock + restock timers\n");
std::printf(" --info-wtrn <wtrn-base> [--json]\n");
std::printf(" Print WTRN entries (npc / kind / spells with skill+level reqs / items with stock + restock)\n");
std::printf(" --validate-wtrn <wtrn-base> [--json]\n");
std::printf(" Static checks: npcId>0+unique, kindMask>0, Trainer needs spells, Vendor needs items, no orphan offers\n");
std::printf(" --export-wtrn-json <wtrn-base> [out.json]\n");
std::printf(" Export binary .wtrn to a human-editable JSON sidecar (defaults to <base>.wtrn.json)\n");
std::printf(" --import-wtrn-json <json-path> [out-base]\n");
std::printf(" Import a .wtrn.json sidecar back into binary .wtrn (accepts kindMask int OR kindList string array)\n");
std::printf(" --gen-gossip <wgsp-base> [name]\n");
std::printf(" Emit .wgsp starter: 1 menu with greeting + 3 options (vendor / trainer / close)\n");
std::printf(" --gen-gossip-innkeeper <wgsp-base> [name]\n");
std::printf(" Emit .wgsp 2-menu innkeeper tree (menuId=4001 closes WCRT.gossipId gap; submenu 4002 area lore)\n");
std::printf(" --gen-gossip-questgiver <wgsp-base> [name]\n");
std::printf(" Emit .wgsp questgiver menu: 2 quest options + bank + paid respec (Coinpouch flag, 10g)\n");
std::printf(" --info-wgsp <wgsp-base> [--json]\n");
std::printf(" Print WGSP entries (menuId / title / per-option kind / target / cost / flags)\n");
std::printf(" --validate-wgsp <wgsp-base> [--json]\n");
std::printf(" Static checks: menuId>0+unique, options non-empty, Submenu actionTarget exists, Coinpouch needs cost, faction conflict\n");
std::printf(" --export-wgsp-json <wgsp-base> [out.json]\n");
std::printf(" Export binary .wgsp to a human-editable JSON sidecar (defaults to <base>.wgsp.json)\n");
std::printf(" --import-wgsp-json <json-path> [out-base]\n");
std::printf(" Import a .wgsp.json sidecar back into binary .wgsp (accepts kind/flag int OR name forms)\n");
std::printf(" --gen-taxi <wtax-base> [name]\n");
std::printf(" Emit .wtax starter: 2 nodes (Stormwind / Goldshire) + 2 paths (round-trip, 50s each, 3 waypoints)\n");
std::printf(" --gen-taxi-region <wtax-base> [name]\n");
std::printf(" Emit .wtax 4-node region: NW/NE/SE/SW outposts on a 500m square + 4-path directed ring\n");
std::printf(" --gen-taxi-continent <wtax-base> [name]\n");
std::printf(" Emit .wtax 6-node hub-spoke continent: central crossroads + 5 outliers + 3 perimeter shortcuts (8 paths)\n");
std::printf(" --info-wtax <wtax-base> [--json]\n");
std::printf(" Print WTAX nodes (id / map / position / name) + paths (id / from->to / cost / waypoint count)\n");
std::printf(" --validate-wtax <wtax-base> [--json]\n");
std::printf(" Static checks: ids>0+unique, finite positions, paths reference real nodes, no self-loop, non-negative delays\n");
std::printf(" --export-wtax-json <wtax-base> [out.json]\n");
std::printf(" Export binary .wtax to a human-editable JSON sidecar (defaults to <base>.wtax.json)\n");
std::printf(" --import-wtax-json <json-path> [out-base]\n");
std::printf(" Import a .wtax.json sidecar back into binary .wtax (round-trip with --export-wtax-json)\n");
std::printf(" --gen-talents <wtal-base> [name]\n");
std::printf(" Emit .wtal starter: 1 small tree (3 talents in chain) for class warrior\n");
std::printf(" --gen-talents-warrior <wtal-base> [name]\n");
std::printf(" Emit .wtal warrior trees: Arms (4 talents) + Fury (4) + Protection (3) with WSPL spell cross-refs\n");
std::printf(" --gen-talents-mage <wtal-base> [name]\n");
std::printf(" Emit .wtal mage trees: Arcane (3 talents) + Fire (3) + Frost (3) with WSPL Frostbolt/Fireball/Blink refs\n");
std::printf(" --info-wtal <wtal-base> [--json]\n");
std::printf(" Print WTAL trees + per-talent grid position / max rank / prereq chain / rank-1 spellId\n");
std::printf(" --validate-wtal <wtal-base> [--json]\n");
std::printf(" Static checks: tree+talent ids>0+unique, maxRank 1..5, prereq references resolve, no self-prereq\n");
std::printf(" --export-wtal-json <wtal-base> [out.json]\n");
std::printf(" Export binary .wtal to a human-editable JSON sidecar (defaults to <base>.wtal.json)\n");
std::printf(" --import-wtal-json <json-path> [out-base]\n");
std::printf(" Import a .wtal.json sidecar back into binary .wtal (round-trip with --export-wtal-json)\n");
std::printf(" --gen-maps <wms-base> [name]\n");
std::printf(" Emit .wms starter: 1 map (Eastern Kingdoms) + 3 areas (Stormwind / Elwynn / Goldshire) with parent chain\n");
std::printf(" --gen-maps-classic <wms-base> [name]\n");
std::printf(" Emit .wms classic set: 2 continents + Deadmines instance + 6 areas with sub-zone parent chains + WSND refs\n");
std::printf(" --gen-maps-bgarena <wms-base> [name]\n");
std::printf(" Emit .wms PvP maps: Alterac Valley (40-player BG) + Nagrand Arena (5v5)\n");
std::printf(" --info-wms <wms-base> [--json]\n");
std::printf(" Print WMS maps (id / type / expansion / max players) + areas (id / map / parent / level / faction / xp)\n");
std::printf(" --validate-wms <wms-base> [--json]\n");
std::printf(" Static checks: ids unique, areas reference real maps, parent areas exist + same map, BG/Arena needs maxPlayers\n");
std::printf(" --export-wms-json <wms-base> [out.json]\n");
std::printf(" Export binary .wms to a human-editable JSON sidecar (defaults to <base>.wms.json)\n");
std::printf(" --import-wms-json <json-path> [out-base]\n");
std::printf(" Import a .wms.json sidecar back into binary .wms (accepts mapType/expansion/faction int OR name forms)\n");
std::printf(" --gen-chars <wchc-base> [name]\n");
std::printf(" Emit .wchc starter: 2 classes (Warrior + Mage) + 2 races (Human + Orc) + 4 outfits with WIT cross-refs\n");
std::printf(" --gen-chars-alliance <wchc-base> [name]\n");
std::printf(" Emit .wchc Alliance set: 4 classes (Warrior/Paladin/Rogue/Mage) + 4 races (Human/Dwarf/NightElf/Gnome)\n");
std::printf(" --gen-chars-allraces <wchc-base> [name]\n");
std::printf(" Emit .wchc all 8 classic races (4 Alliance + 4 Horde) + 9 classes (no DK)\n");
std::printf(" --info-wchc <wchc-base> [--json]\n");
std::printf(" Print WCHC classes (id / power / hp scaling) + races (faction / starting zone) + outfit item lists\n");
std::printf(" --validate-wchc <wchc-base> [--json]\n");
std::printf(" Static checks: class+race ids unique, baseHealth>0, faction availability set, outfit refs resolve\n");
std::printf(" --export-wchc-json <wchc-base> [out.json]\n");
std::printf(" Export binary .wchc to a human-editable JSON sidecar (defaults to <base>.wchc.json)\n");
std::printf(" --import-wchc-json <json-path> [out-base]\n");
std::printf(" Import a .wchc.json sidecar back into binary .wchc (accepts power/faction/gender int OR name forms)\n");
std::printf(" --gen-tokens <wtkn-base> [name]\n");
std::printf(" Emit .wtkn starter: 3 tokens (Honor / Marks / Stormwind Guard) covering Pvp + Reputation categories\n");
std::printf(" --gen-tokens-pvp <wtkn-base> [name]\n");
std::printf(" Emit .wtkn full PvP set: Honor (75k cap) + Arena (5k cap, weekly 1500) + 6 BG marks of honor\n");
std::printf(" --gen-tokens-seasonal <wtkn-base> [name]\n");
std::printf(" Emit .wtkn 4 holiday tokens (Tricky Treats / Brewfest / Coin of Ancestry / Stranger's Gift) — ResetsOnLogout\n");
std::printf(" --info-wtkn <wtkn-base> [--json]\n");
std::printf(" Print WTKN entries (id / category / max balance / weekly cap / flags / name)\n");
std::printf(" --validate-wtkn <wtkn-base> [--json]\n");
std::printf(" Static checks: tokenId>0+unique, name not empty, weeklyCap<=maxBalance, no Resets+AccountWide conflict\n");
std::printf(" --export-wtkn-json <wtkn-base> [out.json]\n");
std::printf(" Export binary .wtkn to a human-editable JSON sidecar (defaults to <base>.wtkn.json)\n");
std::printf(" --import-wtkn-json <json-path> [out-base]\n");
std::printf(" Import a .wtkn.json sidecar back into binary .wtkn (accepts category/flag int OR name forms)\n");
std::printf(" --gen-triggers <wtrg-base> [name]\n");
std::printf(" Emit .wtrg starter: 2 triggers (Goldshire area-name + bandit-camp quest exploration ref WQT 100)\n");
std::printf(" --gen-triggers-dungeon <wtrg-base> [name]\n");
std::printf(" Emit .wtrg dungeon set: outdoor area-name + Deadmines portal (key-gated) + interior exit teleport\n");
std::printf(" --gen-triggers-flightpath <wtrg-base> [name]\n");
std::printf(" Emit .wtrg flight-master proximity waypoints (Stormwind / Goldshire) for auto-open flight UI\n");
std::printf(" --info-wtrg <wtrg-base> [--json]\n");
std::printf(" Print WTRG triggers (id / map / area / kind / shape + dims / dest + facing / quest+key gates)\n");
std::printf(" --validate-wtrg <wtrg-base> [--json]\n");
std::printf(" Static checks: id>0+unique, finite center, sphere needs radius>0, box needs >=1 nonzero half-extent, quest-explore needs target\n");
std::printf(" --export-wtrg-json <wtrg-base> [out.json]\n");
std::printf(" Export binary .wtrg to a human-editable JSON sidecar (defaults to <base>.wtrg.json)\n");
std::printf(" --import-wtrg-json <json-path> [out-base]\n");
std::printf(" Import a .wtrg.json sidecar back into binary .wtrg (accepts shape/kind int OR name forms)\n");
std::printf(" --gen-titles <wtit-base> [name]\n");
std::printf(" Emit .wtit starter: 4 titles covering Achievement / Pvp / Raid / Event categories\n");
std::printf(" --gen-titles-pvp <wtit-base> [name]\n");
std::printf(" Emit .wtit Honor System ladder: 14 Alliance + 14 Horde rank titles (Private..Grand Marshal / Scout..High Warlord)\n");
std::printf(" --gen-titles-achievement <wtit-base> [name]\n");
std::printf(" Emit .wtit achievement titles incl. 'the Versatile' (matches WACH meta-achievement 250 titleReward)\n");
std::printf(" --info-wtit <wtit-base> [--json]\n");
std::printf(" Print WTIT entries (id / sort / prefix vs suffix / category / canonical name)\n");
std::printf(" --validate-wtit <wtit-base> [--json]\n");
std::printf(" Static checks: titleId>0+unique, name not empty, category in 0..7, gender variants paired\n");
std::printf(" --export-wtit-json <wtit-base> [out.json]\n");
std::printf(" Export binary .wtit to a human-editable JSON sidecar (defaults to <base>.wtit.json)\n");
std::printf(" --import-wtit-json <json-path> [out-base]\n");
std::printf(" Import a .wtit.json sidecar back into binary .wtit (accepts category/prefix int OR name forms)\n");
std::printf(" --gen-events <wsea-base> [name]\n");
std::printf(" Emit .wsea starter: 3 events (Brawl Week / Fishing Extravaganza / Anniversary) covering kind categories\n");
std::printf(" --gen-events-yearly <wsea-base> [name]\n");
std::printf(" Emit .wsea 4 yearly holidays (Hallow's End / Brewfest / Lunar Festival / Winter's Veil) with WTKN reward refs\n");
std::printf(" --gen-events-weekends <wsea-base> [name]\n");
std::printf(" Emit .wsea 3 monthly XP-bonus weekends (50%% / 100%% / 200%% RAF tiers)\n");
std::printf(" --info-wsea <wsea-base> [--json]\n");
std::printf(" Print WSEA entries (id / kind / duration / recurrence / xp bonus / token reward / name)\n");
std::printf(" --validate-wsea <wsea-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, kind in 0..6, duration>0, no overlapping recurrence\n");
std::printf(" --export-wsea-json <wsea-base> [out.json]\n");
std::printf(" Export binary .wsea to a human-editable JSON sidecar (defaults to <base>.wsea.json)\n");
std::printf(" --import-wsea-json <json-path> [out-base]\n");
std::printf(" Import a .wsea.json sidecar back into binary .wsea (accepts kind/faction int OR name forms)\n");
std::printf(" --gen-mounts <wmou-base> [name]\n");
std::printf(" Emit .wmou starter: 3 mounts (Brown Horse / Swift Gryphon / Riding Turtle) covering ground/flying/aquatic\n");
std::printf(" --gen-mounts-racial <wmou-base> [name]\n");
std::printf(" Emit .wmou 6 racial mounts (4 Alliance + 2 Horde) with raceMask gating\n");
std::printf(" --gen-mounts-flying <wmou-base> [name]\n");
std::printf(" Emit .wmou 4 flying mounts spanning common/epic/achievement/pvp tiers (60%%/100%%/280%%/310%% speed)\n");
std::printf(" --info-wmou <wmou-base> [--json]\n");
std::printf(" Print WMOU entries (id / kind / speed / required riding rank / faction / category / name)\n");
std::printf(" --validate-wmou <wmou-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, summonSpellId>0, flying needs rank>=150, racial needs raceMask\n");
std::printf(" --export-wmou-json <wmou-base> [out.json]\n");
std::printf(" Export binary .wmou to a human-editable JSON sidecar (defaults to <base>.wmou.json)\n");
std::printf(" --import-wmou-json <json-path> [out-base]\n");
std::printf(" Import a .wmou.json sidecar back into binary .wmou (accepts kind/faction/category int OR name forms)\n");
std::printf(" --gen-bg <wbgd-base> [name]\n");
std::printf(" Emit .wbgd starter: 1 king-of-hill BG (10v10, 3-cap to win, 30 min limit)\n");
std::printf(" --gen-bg-classic <wbgd-base> [name]\n");
std::printf(" Emit .wbgd 3 classic BGs: Warsong Gulch (CTF) + Arathi Basin (nodes) + Alterac Valley (resource race)\n");
std::printf(" --gen-bg-arena <wbgd-base> [name]\n");
std::printf(" Emit .wbgd 3 arena formats: Nagrand 2v2 + Blade's Edge 3v3 + Lordaeron 5v5 (annihilation)\n");
std::printf(" --info-wbgd <wbgd-base> [--json]\n");
std::printf(" Print WBGD entries (id / map / objective / player counts / level range / score / token reward)\n");
std::printf(" --validate-wbgd <wbgd-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, player counts>0+min<=max, level range valid, scoreToWin>0\n");
std::printf(" --export-wbgd-json <wbgd-base> [out.json]\n");
std::printf(" Export binary .wbgd to a human-editable JSON sidecar (defaults to <base>.wbgd.json)\n");
std::printf(" --import-wbgd-json <json-path> [out-base]\n");
std::printf(" Import a .wbgd.json sidecar back into binary .wbgd (accepts objectiveKind int OR name string)\n");
std::printf(" --gen-mail <wmal-base> [name]\n");
std::printf(" Emit .wmal starter: 3 templates (quest overflow / auction won / GM gift) covering main mail categories\n");
std::printf(" --gen-mail-holiday <wmal-base> [name]\n");
std::printf(" Emit .wmal 4 holiday samples (Tricky Treats / Brewfest / Lunar / Winter's Veil) with WTKN cross-refs\n");
std::printf(" --gen-mail-auction <wmal-base> [name]\n");
std::printf(" Emit .wmal 5-template auction-house family (outbid / won / sold / expired / cancelled)\n");
std::printf(" --info-wmal <wmal-base> [--json]\n");
std::printf(" Print WMAL templates (id / category / sender / subject + body / money + items / cod / expiry)\n");
std::printf(" --validate-wmal <wmal-base> [--json]\n");
std::printf(" Static checks: id>0+unique, subject not empty, sender set, attachments valid, no money+no items info-only\n");
std::printf(" --export-wmal-json <wmal-base> [out.json]\n");
std::printf(" Export binary .wmal to a human-editable JSON sidecar (defaults to <base>.wmal.json)\n");
std::printf(" --import-wmal-json <json-path> [out-base]\n");
std::printf(" Import a .wmal.json sidecar back into binary .wmal (accepts category int OR name string)\n");
std::printf(" --gen-gems <wgem-base> [name]\n");
std::printf(" Emit .wgem starter: 3 gems (red/yellow/blue) + 2 enchantments (Crusader proc + Greater Stats)\n");
std::printf(" --gen-gems-set <wgem-base> [name]\n");
std::printf(" Emit .wgem 6-gem full color set (3 primary + 3 secondary purple/green/orange)\n");
std::printf(" --gen-gems-enchants <wgem-base> [name]\n");
std::printf(" Emit .wgem 5 enchant variants (Mongoose / Deadly Poison / stats ring / cloak / Berserking proc)\n");
std::printf(" --info-wgem <wgem-base> [--json]\n");
std::printf(" Print WGEM gems (id / color / stat / item) + enchantments (id / slot / stat / duration / charges)\n");
std::printf(" --validate-wgem <wgem-base> [--json]\n");
std::printf(" Static checks: ids>0+unique, name not empty, color/slot in range, stat-only entries need non-zero value\n");
std::printf(" --export-wgem-json <wgem-base> [out.json]\n");
std::printf(" Export binary .wgem to a human-editable JSON sidecar (defaults to <base>.wgem.json)\n");
std::printf(" --import-wgem-json <json-path> [out-base]\n");
std::printf(" Import a .wgem.json sidecar back into binary .wgem (accepts color/slot int OR name strings)\n");
std::printf(" --gen-guilds <wgld-base> [name]\n");
std::printf(" Emit .wgld starter: 1 guild (Sentinels of Dawn) with default 5-rank ladder + 3 members\n");
std::printf(" --gen-guilds-full <wgld-base> [name]\n");
std::printf(" Emit .wgld fleshed-out guild: 6 ranks + 8 members + 4 bank tabs (officer-only on tabs 3+4) + 3 perks\n");
std::printf(" --gen-guilds-pair <wgld-base> [name]\n");
std::printf(" Emit .wgld 2 guilds: 1 Alliance (Light's Vanguard) + 1 Horde (Bloodfang Warband) with parallel ranks\n");
std::printf(" --info-wgld <wgld-base> [--json]\n");
std::printf(" Print WGLD entries (id / faction / level / leader + motd / rank+member+tab+perk counts)\n");
std::printf(" --validate-wgld <wgld-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+leader not empty, faction 0..1, members reference valid ranks, unique tab indices\n");
std::printf(" --export-wgld-json <wgld-base> [out.json]\n");
std::printf(" Export binary .wgld to a human-editable JSON sidecar (defaults to <base>.wgld.json)\n");
std::printf(" --import-wgld-json <json-path> [out-base]\n");
std::printf(" Import a .wgld.json sidecar back into binary .wgld (accepts faction int OR name string)\n");
std::printf(" --gen-conditions <wpcd-base> [name]\n");
std::printf(" Emit .wpcd starter: 4 conditions covering quest-done / has-item / min-level / class kinds\n");
std::printf(" --gen-conditions-gated <wpcd-base> [name]\n");
std::printf(" Emit .wpcd 5 conditions in 2 groups (group 100 AND alliance+mage+lvl60; group 200 OR did-quest-1/100)\n");
std::printf(" --gen-conditions-event <wpcd-base> [name]\n");
std::printf(" Emit .wpcd 3 event-gated conditions referencing WSEA event IDs (Hallow's End / Brewfest / Winter's Veil)\n");
std::printf(" --info-wpcd <wpcd-base> [--json]\n");
std::printf(" Print WPCD entries (id / group / kind / aggregator / negated / target / min..max value / name)\n");
std::printf(" --validate-wpcd <wpcd-base> [--json]\n");
std::printf(" Static checks: id>0+unique, kind in 0..16, aggregator 0..1, kinds that need targetId have non-zero target\n");
std::printf(" --export-wpcd-json <wpcd-base> [out.json]\n");
std::printf(" Export binary .wpcd to a human-editable JSON sidecar (defaults to <base>.wpcd.json)\n");
std::printf(" --import-wpcd-json <json-path> [out-base]\n");
std::printf(" Import a .wpcd.json sidecar back into binary .wpcd (accepts kind/aggregator int OR name forms)\n");
std::printf(" --gen-pets <wpet-base> [name]\n");
std::printf(" Emit .wpet starter: 2 hunter families (Wolf + Cat) + 1 warlock minion (Imp) with WSPL ability refs\n");
std::printf(" --gen-pets-hunter <wpet-base> [name]\n");
std::printf(" Emit .wpet 8 classic hunter families (Wolf/Cat/Bear/Boar/Raptor/Hyena/Spider/Crab) with diet+petType\n");
std::printf(" --gen-pets-warlock <wpet-base> [name]\n");
std::printf(" Emit .wpet 5 warlock minions (Imp/Voidwalker/Succubus/Felhunter/Felguard) with summon spell + WCRT ref\n");
std::printf(" --info-wpet <wpet-base> [--json]\n");
std::printf(" Print WPET families (id / petType / atkSpd / dmg+arm mult / diet) + minions (id / summon / creatureId)\n");
std::printf(" --validate-wpet <wpet-base> [--json]\n");
std::printf(" Static checks: ids>0+unique, name not empty, petType 0..2, atkSpeed>0, minion needs summon+creatureId\n");
std::printf(" --export-wpet-json <wpet-base> [out.json]\n");
std::printf(" Export binary .wpet to a human-editable JSON sidecar (defaults to <base>.wpet.json)\n");
std::printf(" --import-wpet-json <json-path> [out-base]\n");
std::printf(" Import a .wpet.json sidecar back into binary .wpet (accepts petType int OR name string)\n");
std::printf(" --gen-auction <wauc-base> [name]\n");
std::printf(" Emit .wauc starter: 1 neutral house with stock 12h/24h/48h tiers and 5%% house cut\n");
std::printf(" --gen-auction-pair <wauc-base> [name]\n");
std::printf(" Emit .wauc 3 houses (Stormwind / Orgrimmar / Booty Bay) — faction 5%% cut vs neutral 15%% asymmetry\n");
std::printf(" --gen-auction-restricted <wauc-base> [name]\n");
std::printf(" Emit .wauc 1 house with disallowedClassMask (no Containers/Quest/Keys) + tighter durations + bid cap\n");
std::printf(" --info-wauc <wauc-base> [--json]\n");
std::printf(" Print WAUC houses (id / faction / deposit + cut percent / 3 duration tiers / disallow mask / npc)\n");
std::printf(" --validate-wauc <wauc-base> [--json]\n");
std::printf(" Static checks: id>0+unique, faction 0..3, durations short<=medium<=long, cut < 100%%\n");
std::printf(" --export-wauc-json <wauc-base> [out.json]\n");
std::printf(" Export binary .wauc to a human-editable JSON sidecar (defaults to <base>.wauc.json)\n");
std::printf(" --import-wauc-json <json-path> [out-base]\n");
std::printf(" Import a .wauc.json sidecar back into binary .wauc (accepts factionAccess int OR name string)\n");
std::printf(" --gen-channels <wchn-base> [name]\n");
std::printf(" Emit .wchn starter: 4 stock channels (General / Trade / LFG / GuildRecruit) with autoJoin defaults\n");
std::printf(" --gen-channels-city <wchn-base> [name]\n");
std::printf(" Emit .wchn 5 city channels (Stormwind General/Trade/LFG + Orgrimmar General/Trade) with map+area gates\n");
std::printf(" --gen-channels-moderated <wchn-base> [name]\n");
std::printf(" Emit .wchn 3 moderated channels (LocalDefense / WorldDefense moderated / RaidCoordination level 60+)\n");
std::printf(" --info-wchn <wchn-base> [--json]\n");
std::printf(" Print WCHN entries (id / type / faction / autoJoin/announce/moderated / level / map+area gates / name)\n");
std::printf(" --validate-wchn <wchn-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, type 0..9, faction 0..2, world+area-gate combo warning\n");
std::printf(" --export-wchn-json <wchn-base> [out.json]\n");
std::printf(" Export binary .wchn to a human-editable JSON sidecar (defaults to <base>.wchn.json)\n");
std::printf(" --import-wchn-json <json-path> [out-base]\n");
std::printf(" Import a .wchn.json sidecar back into binary .wchn (accepts channelType/factionAccess int OR name string)\n");
std::printf(" --gen-cinematics <wcms-base> [name]\n");
std::printf(" Emit .wcms starter: 3 cinematics (pre-rendered intro / quest cutscene / login splash)\n");
std::printf(" --gen-cinematics-intros <wcms-base> [name]\n");
std::printf(" Emit .wcms 4 class intros (Warrior / Hunter / Rogue / Mage) triggered on first ClassStart\n");
std::printf(" --gen-cinematics-quests <wcms-base> [name]\n");
std::printf(" Emit .wcms 3 quest-bound cinematics referencing WQT questIds 1 / 100 / 102 (start / start / end)\n");
std::printf(" --info-wcms <wcms-base> [--json]\n");
std::printf(" Print WCMS entries (id / kind / trigger / target / duration / skippable / soundtrackId / name)\n");
std::printf(" --validate-wcms <wcms-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+mediaPath not empty, kind 0..4, trigger 0..8, target required for non-Manual triggers\n");
std::printf(" --export-wcms-json <wcms-base> [out.json]\n");
std::printf(" Export binary .wcms to a human-editable JSON sidecar (defaults to <base>.wcms.json)\n");
std::printf(" --import-wcms-json <json-path> [out-base]\n");
std::printf(" Import a .wcms.json sidecar back into binary .wcms (accepts kind/triggerKind int OR name string)\n");
std::printf(" --gen-glyphs <wgly-base> [name]\n");
std::printf(" Emit .wgly starter: 3 glyphs (1 warrior + 1 mage + 1 rogue) showing per-class Major slot picks\n");
std::printf(" --gen-glyphs-warrior <wgly-base> [name]\n");
std::printf(" Emit .wgly 6 warrior glyphs (3 major + 3 minor) demonstrating per-class allotment\n");
std::printf(" --gen-glyphs-universal <wgly-base> [name]\n");
std::printf(" Emit .wgly 4 universal glyphs (classMask=All) covering hearthstone/levitate/mounting/salvation\n");
std::printf(" --info-wgly <wgly-base> [--json]\n");
std::printf(" Print WGLY entries (id / type / spellId / itemId / classMask / requiredLevel / name)\n");
std::printf(" --validate-wgly <wgly-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+spellId not empty, type 0..2, classMask>0, level<25 warning, missing-itemId warning\n");
std::printf(" --export-wgly-json <wgly-base> [out.json]\n");
std::printf(" Export binary .wgly to a human-editable JSON sidecar (defaults to <base>.wgly.json)\n");
std::printf(" --import-wgly-json <json-path> [out-base]\n");
std::printf(" Import a .wgly.json sidecar back into binary .wgly (accepts glyphType int OR name string)\n");
std::printf(" --gen-vehicles <wvhc-base> [name]\n");
std::printf(" Emit .wvhc starter: 3 vehicles (chopper / wind rider / salvaged tank) covering ground+air+siege roles\n");
std::printf(" --gen-vehicles-siege <wvhc-base> [name]\n");
std::printf(" Emit .wvhc 3 siege weapons (Demolisher 2-seat / Glaive Thrower / Salvaged Cannon) with control spellIds\n");
std::printf(" --gen-vehicles-flying <wvhc-base> [name]\n");
std::printf(" Emit .wvhc 3 flying mounts (Wind Rider / Storm Gryphon / Twilight Drake) cross-ref WMNT flightCapabilityIds\n");
std::printf(" --info-wvhc <wvhc-base> [--json]\n");
std::printf(" Print WVHC entries with seat layout (id / creature / kind / movement / power / seat count / name)\n");
std::printf(" --validate-wvhc <wvhc-base> [--json]\n");
std::printf(" Static checks: id>0+unique, creatureId>0, kind/movement/power in range, exactly 1 driver seat, no duplicate seatIndex\n");
std::printf(" --export-wvhc-json <wvhc-base> [out.json]\n");
std::printf(" Export binary .wvhc to a human-editable JSON sidecar with nested seat arrays (defaults to <base>.wvhc.json)\n");
std::printf(" --import-wvhc-json <json-path> [out-base]\n");
std::printf(" Import a .wvhc.json sidecar back into binary .wvhc (accepts vehicleKind/movementKind/powerType int OR name string)\n");
std::printf(" --gen-holidays <whol-base> [name]\n");
std::printf(" Emit .whol starter: 3 seasonal holidays (Hallow's End / Brewfest / Winter Veil) with boss+reward+quest cross-refs\n");
std::printf(" --gen-holidays-weekly <whol-base> [name]\n");
std::printf(" Emit .whol 3 weekly call-to-arms BG bonus windows (Warsong Gulch / Arathi Basin / Eye of the Storm)\n");
std::printf(" --gen-holidays-special <whol-base> [name]\n");
std::printf(" Emit .whol 3 special events (Wintergrasp world-PvP / Lunar Festival / Children's Week)\n");
std::printf(" --info-whol <whol-base> [--json]\n");
std::printf(" Print WHOL entries (id / kind / recurrence / start MM/DD / duration / quest+boss+reward IDs / name)\n");
std::printf(" --validate-whol <whol-base> [--json]\n");
std::printf(" Static checks: id>0+unique, kind 0..5, recurrence 0..3, duration>0, valid month/day for non-weekly, calendar-only warning\n");
std::printf(" --export-whol-json <whol-base> [out.json]\n");
std::printf(" Export binary .whol to a human-editable JSON sidecar (defaults to <base>.whol.json)\n");
std::printf(" --import-whol-json <json-path> [out-base]\n");
std::printf(" Import a .whol.json sidecar back into binary .whol (accepts holidayKind/recurrence int OR name string)\n");
std::printf(" --gen-liquids <wliq-base> [name]\n");
std::printf(" Emit .wliq starter: 3 stock liquids (Fresh Water / Lava / Sludge Slime) with shaders+sounds+DPS\n");
std::printf(" --gen-liquids-magical <wliq-base> [name]\n");
std::printf(" Emit .wliq 4 magical liquids (Fel Fire / Holy Light / Underworld / Cosmic) with damage spell IDs\n");
std::printf(" --gen-liquids-hazardous <wliq-base> [name]\n");
std::printf(" Emit .wliq 3 high-damage liquids (Naxx Slime / Acid Bog / Fel Lava) with WSPL cross-refs\n");
std::printf(" --info-wliq <wliq-base> [--json]\n");
std::printf(" Print WLIQ entries (id / kind / fog RGB / density / viscosity / DPS / spell+sound IDs / name)\n");
std::printf(" --validate-wliq <wliq-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+shader+material not empty, kind 0..9, fog/visc 0..1, hazardous-no-damage warning\n");
std::printf(" --export-wliq-json <wliq-base> [out.json]\n");
std::printf(" Export binary .wliq to a human-editable JSON sidecar (defaults to <base>.wliq.json)\n");
std::printf(" --import-wliq-json <json-path> [out-base]\n");
std::printf(" Import a .wliq.json sidecar back into binary .wliq (accepts liquidKind int OR name string)\n");
std::printf(" --list-formats [--json]\n");
std::printf(" Print the catalog of all novel open formats (magic / extension / category / replaces / description)\n");
std::printf(" --info-magic <path> [--json]\n");
std::printf(" Auto-detect any .w* file by 4-byte magic; report format / version / catalog name / entry count + suggest --info-* flag\n");
std::printf(" --summary-dir <dir> [--json]\n");
std::printf(" Recursively walk a directory; report per-format file count, total entries, and bytes for every Wowee open format found\n");
std::printf(" --rename-by-magic <file> [--dry-run] [--force]\n");
std::printf(" Recover the correct .w* extension on a file by reading its 4-byte magic. --dry-run prints the planned move; --force overwrites\n");
std::printf(" --bulk-rename-by-magic <dir> [--dry-run] [--force]\n");
std::printf(" Apply --rename-by-magic recursively to every file in <dir>. Conflicts are skipped without --force; exits 1 if any rename failed\n");
std::printf(" --touch-tree <dir> [--json] [--quiet]\n");
std::printf(" CI integrity check: open every recognized .w* file in <dir>, parse standard header, report PASS/FAIL + extension mismatches. Exit 1 on any failure\n");
std::printf(" --tree-summary-md <dir> [out.md]\n");
std::printf(" Emit a Markdown report of a content tree (per-format counts + per-file detail with catalog name + entry count). Stdout if no out path\n");
std::printf(" --catalog-grep <pattern> <dir> [--case-sensitive] [--json]\n");
std::printf(" Recursively search catalog NAMES (the internal name field) across .w* files in <dir>. Case-insensitive by default. Exit 1 if no match\n");
std::printf(" --diff-headers <fileA> <fileB> [--json]\n");
std::printf(" Compare two .w* files at the standard catalog header level (magic / version / name / entry count / file size). Exit 1 if any field differs\n");
std::printf(" --audit-tree <dir> [--json]\n");
std::printf(" Walk directory recursively and flag corrupted/misnamed Wowee files: too-small, unknown-magic, ext/magic mismatch, magic-without-ext, truncated headers. Exit 1 on any issue\n");
std::printf(" --magic-fix <dir> [--apply] [--json]\n");
std::printf(" Auto-rename files whose extension doesn't match their magic to the canonical extension. Default is dry-run; pass --apply to commit. Skips collisions where the target already exists. Natural follow-up to --audit-tree\n");
std::printf(" --bulk-validate <dir> [--json]\n");
std::printf(" Recursively run each format's --validate-X validator across every recognized .w* file. Reports per-file pass/fail counts; lists failure paths. Asset formats with no validator are skipped. Exit 1 if any failure\n");
std::printf(" --bulk-export-json <dir> [--json]\n");
std::printf(" Recursively export every recognized .w* file to its JSON sidecar via the per-format --export-X-json flag. Useful for git-friendly diffs of binary catalogs. Exit 1 if any failure\n");
std::printf(" --bulk-import-json <dir> [--json]\n");
std::printf(" Recursively import every .wXXX.json sidecar back to its binary .w* form via the per-format --import-X-json flag. Inverse of --bulk-export-json. Exit 1 if any failure\n");
std::printf(" --diff-tree <dirA> <dirB> [--json]\n");
std::printf(" Compare two directory trees of .w* catalogs at the magic+size level. Reports only-in-A / only-in-B / magic-changed / size-changed / identical counts and lists changed paths. Exit 1 if any difference\n");
std::printf(" --orphan-jsons <dir> [--json]\n");
std::printf(" Find .wXXX.json sidecars whose binary .wXXX is missing. Useful after deleting/moving binaries — orphan JSONs accumulate noise and may shadow re-imports. Exit 1 if any orphans found\n");
std::printf(" --list-by-magic <dir> <magic> [--json]\n");
std::printf(" List every file in a directory tree matching a 4-char magic (e.g. WSPL). Reports per-file size + entry count + catalog name + relative path. Exit 1 if no matches\n");
std::printf(" --catalog-stats <file> [--json]\n");
std::printf(" Single-file deep stats — header bytes vs entry-section bytes, average entry size, sampled entry IDs. Useful for sizing analysis (which catalogs are biggest, where do the bytes go)\n");
std::printf(" --gen-animations <wani-base> [name]\n");
std::printf(" Emit .wani starter: 5 essential animations (Stand / Walk / Run / Death / AttackUnarmed) with fallback chains\n");
std::printf(" --gen-animations-combat <wani-base> [name]\n");
std::printf(" Emit .wani 8 combat anims (1H/2H/dual-wield/bow/rifle/thrown + parry + channel) with weapon-flag bitmasks\n");
std::printf(" --gen-animations-movement <wani-base> [name]\n");
std::printf(" Emit .wani 6 movement anims (Walk/Run/Sprint/Swim/Mount/Fly) with behavior-tier transitions (default/aerial/swim)\n");
std::printf(" --info-wani <wani-base> [--json]\n");
std::printf(" Print WANI entries (id / tier / flags / weapon mask / loop duration / fallback / name)\n");
std::printf(" --validate-wani <wani-base> [--json]\n");
std::printf(" Static checks: id-unique, name not empty, tier 0..4, fallback != self, loop+oneshot exclusivity, looped requires duration\n");
std::printf(" --export-wani-json <wani-base> [out.json]\n");
std::printf(" Export binary .wani to a human-editable JSON sidecar (defaults to <base>.wani.json)\n");
std::printf(" --import-wani-json <json-path> [out-base]\n");
std::printf(" Import a .wani.json sidecar back into binary .wani (accepts behaviorTier int OR name string)\n");
std::printf(" --gen-svk <wsvk-base> [name]\n");
std::printf(" Emit .wsvk starter: 3 visual kits (Frostbolt / Fireball / HealingTouch) with projectile + impact + hand effects\n");
std::printf(" --gen-svk-combat <wsvk-base> [name]\n");
std::printf(" Emit .wsvk 5 combat visuals (sword/arrow/groundpound/parry/deflect) with WANI animation cross-refs\n");
std::printf(" --gen-svk-utility <wsvk-base> [name]\n");
std::printf(" Emit .wsvk 4 utility visuals (portal/hearthstone/mount-summon/resurrect) with no projectile\n");
std::printf(" --info-wsvk <wsvk-base> [--json]\n");
std::printf(" Print WSVK entries (id / cast+impact anim IDs / projectile speed+gravity / cast duration / AoE radius / sounds / name)\n");
std::printf(" --validate-wsvk <wsvk-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, no negative speeds/radii, projectile-model + speed coherence, no-effect warning\n");
std::printf(" --export-wsvk-json <wsvk-base> [out.json]\n");
std::printf(" Export binary .wsvk to a human-editable JSON sidecar (defaults to <base>.wsvk.json)\n");
std::printf(" --import-wsvk-json <json-path> [out-base]\n");
std::printf(" Import a .wsvk.json sidecar back into binary .wsvk\n");
std::printf(" --gen-wsui <wwui-base> [name]\n");
std::printf(" Emit .wwui starter: 3 BG scoreboards (WSG flag captures, AB resources, EotS flag carrier)\n");
std::printf(" --gen-wsui-wintergrasp <wwui-base> [name]\n");
std::printf(" Emit .wwui 4 Wintergrasp UI (alliance+horde tank counts, time remaining, towers controlled)\n");
std::printf(" --gen-wsui-dungeon <wwui-base> [name]\n");
std::printf(" Emit .wwui 3 dungeon UI (boss progress bar, key fragments collected, treasure hunt counter)\n");
std::printf(" --info-wwui <wwui-base> [--json]\n");
std::printf(" Print WWUI entries (id / kind / panel position / always-visible / hide-when-zero / map+area / variableIndex / default / name)\n");
std::printf(" --validate-wwui <wwui-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, kind 0..5, position 0..4, alwaysVis+hideZero conflict, (mapId, varIdx) collision warning\n");
std::printf(" --export-wwui-json <wwui-base> [out.json]\n");
std::printf(" Export binary .wwui to a human-editable JSON sidecar (defaults to <base>.wwui.json)\n");
std::printf(" --import-wwui-json <json-path> [out-base]\n");
std::printf(" Import a .wwui.json sidecar back into binary .wwui (accepts displayKind/panelPosition int OR name string)\n");
std::printf(" --gen-pcn <wpcn-base> [name]\n");
std::printf(" Emit .wpcn starter: 3 single-check conditions (level>=60 / race=Human / class=Warrior)\n");
std::printf(" --gen-pcn-quest-gates <wpcn-base> [name]\n");
std::printf(" Emit .wpcn 4 quest-style gates (quest complete, reputation, achievement, zone presence) with cross-refs\n");
std::printf(" --gen-pcn-composite <wpcn-base> [name]\n");
std::printf(" Emit .wpcn 6 entries (3 leaves + 3 chained roots) exercising AND/OR/NOT chainOps for boolean trees\n");
std::printf(" --info-wpcn <wpcn-base> [--json]\n");
std::printf(" Print WPCN entries (id / kind / op / target IDs / int values / chainOp / chainNextId / name)\n");
std::printf(" --validate-wpcn <wpcn-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, kind 0..15, op 0..7, chainOp 0..3, chain self-loop, dangling chainNextId warning\n");
std::printf(" --export-wpcn-json <wpcn-base> [out.json]\n");
std::printf(" Export binary .wpcn to a human-editable JSON sidecar (defaults to <base>.wpcn.json)\n");
std::printf(" --import-wpcn-json <json-path> [out-base]\n");
std::printf(" Import a .wpcn.json sidecar back into binary .wpcn (accepts conditionKind/comparisonOp/chainOp int OR name string)\n");
std::printf(" --gen-tsk <wtsk-base> [name]\n");
std::printf(" Emit .wtsk starter: 3 entry-tier recipes (Coarse Sharpening Stone / Linen Bandage / Minor Healing Potion)\n");
std::printf(" --gen-tsk-blacksmithing <wtsk-base> [name]\n");
std::printf(" Emit .wtsk 5-recipe Blacksmithing progression (rough sharpening → truesilver champion plate)\n");
std::printf(" --gen-tsk-alchemy <wtsk-base> [name]\n");
std::printf(" Emit .wtsk 5-recipe Alchemy progression (minor healing → flask of titans) with reagent slots\n");
std::printf(" --info-wtsk <wtsk-base> [--json]\n");
std::printf(" Print WTSK entries (id / profession / 4 skill brackets / craft spell / produced item / qty / tool / reagent count / name)\n");
std::printf(" --validate-wtsk <wtsk-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, profession 0..13, craft spell + produced item required, monotonic skill brackets\n");
std::printf(" --export-wtsk-json <wtsk-base> [out.json]\n");
std::printf(" Export binary .wtsk to a human-editable JSON sidecar with nested reagents (defaults to <base>.wtsk.json)\n");
std::printf(" --import-wtsk-json <json-path> [out-base]\n");
std::printf(" Import a .wtsk.json sidecar back into binary .wtsk (accepts profession int OR name string, reagents array up to 4 slots)\n");
std::printf(" --gen-ceq <wceq-base> [name]\n");
std::printf(" Emit .wceq starter: 3 generic creature loadouts (guard 1H+shield, hunter bow, rogue dual-dagger)\n");
std::printf(" --gen-ceq-bosses <wceq-base> [name]\n");
std::printf(" Emit .wceq 4 iconic boss loadouts (Onyxia 2H, Lich King Frostmourne, Sylvanas bow, Illidan dual warglaives) with WSVK refs\n");
std::printf(" --gen-ceq-ranged <wceq-base> [name]\n");
std::printf(" Emit .wceq 3 ranged-only loadouts (rifle / bow / crossbow) — ranged slot only, no melee\n");
std::printf(" --info-wceq <wceq-base> [--json]\n");
std::printf(" Print WCEQ entries (id / creatureId / mainhand+offhand+ranged item IDs / equipFlags / visualKitId / name)\n");
std::printf(" --validate-wceq <wceq-base> [--json]\n");
std::printf(" Static checks: id+creatureId>0+unique, dual-wield/shield/2H polearm flag coherence, mutually-exclusive flag combos\n");
std::printf(" --export-wceq-json <wceq-base> [out.json]\n");
std::printf(" Export binary .wceq to a human-editable JSON sidecar (defaults to <base>.wceq.json)\n");
std::printf(" --import-wceq-json <json-path> [out-base]\n");
std::printf(" Import a .wceq.json sidecar back into binary .wceq (slot fields default to canonical 16/17/18 if omitted)\n");
std::printf(" --gen-itset <wset-base> [name]\n");
std::printf(" Emit .wset starter: 2 raid sets (Battlegear of Wrath / Stormrage Raiment) — 8-piece tier-2 layouts\n");
std::printf(" --gen-itset-tier <wset-base> [name]\n");
std::printf(" Emit .wset 4 progression tier-1 sets (warrior plate / mage cloth / rogue leather / paladin holy plate) with 2/4/6 bonuses\n");
std::printf(" --gen-itset-pvp <wset-base> [name]\n");
std::printf(" Emit .wset 3 PvP gladiator sets (5-piece) with 2/4 bonuses and honor-rank skill thresholds\n");
std::printf(" --info-wset <wset-base> [--json]\n");
std::printf(" Print WSET entries (id / pieces / bonuses / classMask / skill+rank gates / first item ID / name)\n");
std::printf(" --validate-wset <wset-base> [--json]\n");
std::printf(" Static checks: id+name+pieceCount required, piece/bonus arrays match counts, monotonic bonus thresholds within pieceCount\n");
std::printf(" --export-wset-json <wset-base> [out.json]\n");
std::printf(" Export binary .wset to a human-editable JSON sidecar with nested itemIds[] + bonuses[] arrays\n");
std::printf(" --import-wset-json <json-path> [out-base]\n");
std::printf(" Import a .wset.json sidecar back into binary .wset (pieceCount/bonusCount derived from array sizes; missing slots cleared)\n");
std::printf(" --gen-tips <wgtp-base> [name]\n");
std::printf(" Emit .wgtp starter: 3 generic loading-screen tips (combat / movement / quest hints) for kAudienceAll\n");
std::printf(" --gen-tips-new-player <wgtp-base> [name]\n");
std::printf(" Emit .wgtp 5 onboarding tutorial tips (hearthstone / talents / mount / quest log / professions) for level 1-15\n");
std::printf(" --gen-tips-advanced <wgtp-base> [name]\n");
std::printf(" Emit .wgtp 4 endgame tips (raid mechanics / arena / daily professions / dungeon finder) for level 70+\n");
std::printf(" --info-wgtp <wgtp-base> [--json]\n");
std::printf(" Print WGTP entries (id / kind / audience mask / level range / weight / condition / classMask / name)\n");
std::printf(" --validate-wgtp <wgtp-base> [--json]\n");
std::printf(" Static checks: id+name+text required, kind 0..3, audienceFilter>0, valid level range, brevity check on tutorial/hint kinds\n");
std::printf(" --export-wgtp-json <wgtp-base> [out.json]\n");
std::printf(" Export binary .wgtp to a human-editable JSON sidecar (defaults to <base>.wgtp.json)\n");
std::printf(" --import-wgtp-json <json-path> [out-base]\n");
std::printf(" Import a .wgtp.json sidecar back into binary .wgtp (accepts displayKind int OR name string)\n");
std::printf(" --gen-cmp <wcmp-base> [name]\n");
std::printf(" Emit .wcmp starter: 3 common vendor companions (Mechanical Squirrel / Cat / Prairie Dog)\n");
std::printf(" --gen-cmp-rare <wcmp-base> [name]\n");
std::printf(" Emit .wcmp 4 promo / collector pets (Mini Diablo / Panda Cub / Zergling / Murky) at Epic rarity\n");
std::printf(" --gen-cmp-faction <wcmp-base> [name]\n");
std::printf(" Emit .wcmp 3 faction-restricted pets (Alliance Lion Cub / Horde Mottled Boar / Argent Squire any-faction)\n");
std::printf(" --info-wcmp <wcmp-base> [--json]\n");
std::printf(" Print WCMP entries (id / creature / kind / rarity / faction / learn spell+item / idle sound / name)\n");
std::printf(" --validate-wcmp <wcmp-base> [--json]\n");
std::printf(" Static checks: id+name+creatureId+learnSpellId required, kind 0..7, rarity 0..3, faction 0..2, Epic-no-itemId warning\n");
std::printf(" --export-wcmp-json <wcmp-base> [out.json]\n");
std::printf(" Export binary .wcmp to a human-editable JSON sidecar (defaults to <base>.wcmp.json)\n");
std::printf(" --import-wcmp-json <json-path> [out-base]\n");
std::printf(" Import a .wcmp.json sidecar back into binary .wcmp (accepts companionKind/rarity/factionRestriction int OR name string)\n");
std::printf(" --gen-smc <wsmc-base> [name]\n");
std::printf(" Emit .wsmc starter: 3 baseline mechanics (Stun / Silence / Snare) covering the most common DR categories\n");
std::printf(" --gen-smc-hard <wsmc-base> [name]\n");
std::printf(" Emit .wsmc 5 hard-CC mechanics (Stun / Polymorph / Sleep / Fear / Knockback) with conflictsMask DR wiring\n");
std::printf(" --gen-smc-roots <wsmc-base> [name]\n");
std::printf(" Emit .wsmc 4 movement-impair mechanics (Root / Snare / Slow stacking / GroundPin breaks-on-damage)\n");
std::printf(" --info-wsmc <wsmc-base> [--json]\n");
std::printf(" Print WSMC entries (id / DR category / dispel type / breaks / dispellable / duration / max stacks / conflicts mask / name)\n");
std::printf(" --validate-wsmc <wsmc-base> [--json]\n");
std::printf(" Static checks: id+name required, DR 0..7 / dispel 0..6, maxStacks>0, dispellable+none-dispel inconsistency, self-conflict bit\n");
std::printf(" --export-wsmc-json <wsmc-base> [out.json]\n");
std::printf(" Export binary .wsmc to a human-editable JSON sidecar (defaults to <base>.wsmc.json)\n");
std::printf(" --import-wsmc-json <json-path> [out-base]\n");
std::printf(" Import a .wsmc.json sidecar back into binary .wsmc (accepts drCategory/dispelType int OR name string)\n");
std::printf(" --gen-kbd <wkbd-base> [name]\n");
std::printf(" Emit .wkbd starter: 3 essential bindings (MOVE_FORWARD / TARGET_NEAREST_ENEMY / TOGGLE_CHARACTER)\n");
std::printf(" --gen-kbd-movement <wkbd-base> [name]\n");
std::printf(" Emit .wkbd 8 movement bindings (WASD / arrow keys / jump / autorun) with primary+alternate keys\n");
std::printf(" --gen-kbd-ui <wkbd-base> [name]\n");
std::printf(" Emit .wkbd 10 UI panel bindings (Character C / Inventory I / Bags B / Spellbook P / Talents N / etc)\n");
std::printf(" --info-wkbd <wkbd-base> [--json]\n");
std::printf(" Print WKBD entries (id / category / user-overridable / sort / default key + alt / actionName)\n");
std::printf(" --validate-wkbd <wkbd-base> [--json]\n");
std::printf(" Static checks: id+actionName+defaultKey required, category 0..8, alt!=default, unique action names + primary keys\n");
std::printf(" --export-wkbd-json <wkbd-base> [out.json]\n");
std::printf(" Export binary .wkbd to a human-editable JSON sidecar (defaults to <base>.wkbd.json)\n");
std::printf(" --import-wkbd-json <json-path> [out-base]\n");
std::printf(" Import a .wkbd.json sidecar back into binary .wkbd (accepts category int OR name string; isUserOverridable defaults to 1)\n");
std::printf(" --gen-sch <wsch-base> [name]\n");
std::printf(" Emit .wsch starter: 3 base schools (Physical / Fire / Holy) with proper colors+resistance caps\n");
std::printf(" --gen-sch-magical <wsch-base> [name]\n");
std::printf(" Emit .wsch 6 magical schools (Holy / Fire / Nature / Frost / Shadow / Arcane) with canonical schoolId bits\n");
std::printf(" --gen-sch-combined <wsch-base> [name]\n");
std::printf(" Emit .wsch 3 hybrid schools (Spellfire / Spellshadow / Spellfrost) with combinedSchoolMask wiring\n");
std::printf(" --info-wsch <wsch-base> [--json]\n");
std::printf(" Print WSCH entries (schoolId / immune+absorb+reflect+crit flags / resistance cap / combined-mask / name)\n");
std::printf(" --validate-wsch <wsch-base> [--json]\n");
std::printf(" Static checks: id+name required, reflected-without-absorbed warning, combined-mask references defined schools, no self-reference\n");
std::printf(" --export-wsch-json <wsch-base> [out.json]\n");
std::printf(" Export binary .wsch to a human-editable JSON sidecar (defaults to <base>.wsch.json)\n");
std::printf(" --import-wsch-json <json-path> [out-base]\n");
std::printf(" Import a .wsch.json sidecar back into binary .wsch (canBeImmune/Absorbed/Crit default to 1, canBeReflected to 0)\n");
std::printf(" --gen-lfg <wlfg-base> [name]\n");
std::printf(" Emit .wlfg starter: 3 classic 5-man dungeons (Ragefire Chasm / Wailing Caverns / Deadmines) with level brackets\n");
std::printf(" --gen-lfg-heroic <wlfg-base> [name]\n");
std::printf(" Emit .wlfg 5 WotLK 80-level heroic 5-mans with emblem rewards + first-clear achievement IDs\n");
std::printf(" --gen-lfg-raid <wlfg-base> [name]\n");
std::printf(" Emit .wlfg 3 raid entries (Naxxramas-25 / Ulduar-25 Hardmode / ToC-25 Mythic) with larger groupSize\n");
std::printf(" --info-wlfg <wlfg-base> [--json]\n");
std::printf(" Print WLFG entries (id / map / level range / minIlvl / difficulty / groupSize / role mask / expansion / rewards / name)\n");
std::printf(" --validate-wlfg <wlfg-base> [--json]\n");
std::printf(" Static checks: id+name+mapId required, difficulty 0..3 / expansion 0..3, minLevel<=maxLevel, recommended within range, role mask>0\n");
std::printf(" --export-wlfg-json <wlfg-base> [out.json]\n");
std::printf(" Export binary .wlfg to a human-editable JSON sidecar (defaults to <base>.wlfg.json)\n");
std::printf(" --import-wlfg-json <json-path> [out-base]\n");
std::printf(" Import a .wlfg.json sidecar back into binary .wlfg (accepts difficulty/expansion int OR name string; groupSize defaults to 5, role mask to kRoleAll)\n");
std::printf(" --gen-mac <wmac-base> [name]\n");
std::printf(" Emit .wmac starter: 3 system slash commands (/sit, /dance, /target with [@mouseover])\n");
std::printf(" --gen-mac-combat <wmac-base> [name]\n");
std::printf(" Emit .wmac 4 warrior combat macros (Heroic Strike spam, Charge/Intercept stance dance, Victory Rush) with bind keys + classMask\n");
std::printf(" --gen-mac-utility <wmac-base> [name]\n");
std::printf(" Emit .wmac 3 utility macros (/follow target, mass /inv with %%targetN, /releasecorpse via RepopMe)\n");
std::printf(" --info-wmac <wmac-base> [--json]\n");
std::printf(" Print WMAC entries (id / kind / classMask / bindKey / maxLen / body length / name)\n");
std::printf(" --validate-wmac <wmac-base> [--json]\n");
std::printf(" Static checks: id+name+body required, kind 0..4, body within maxLength, body starts with '/' or '#', SystemSlash + classMask warning\n");
std::printf(" --export-wmac-json <wmac-base> [out.json]\n");
std::printf(" Export binary .wmac to a human-editable JSON sidecar (defaults to <base>.wmac.json; multi-line bodies escape \\n)\n");
std::printf(" --import-wmac-json <json-path> [out-base]\n");
std::printf(" Import a .wmac.json sidecar back into binary .wmac (accepts macroKind int OR name string; maxLength defaults to 255)\n");
std::printf(" --gen-chf <wchf-base> [name]\n");
std::printf(" Emit .wchf starter: 5 Human Male features (1 skin / 1 face / 2 hair styles / 1 facial hair)\n");
std::printf(" --gen-chf-bloodelf <wchf-base> [name]\n");
std::printf(" Emit .wchf 8 Blood Elf Female hair styles (TBC iconic feature, requiresExpansion=TBC)\n");
std::printf(" --gen-chf-tauren <wchf-base> [name]\n");
std::printf(" Emit .wchf 6 Tauren Male features (3 horn variants + 3 facial hair) using race-specific kinds\n");
std::printf(" --info-wchf <wchf-base> [--json]\n");
std::printf(" Print WCHF entries (id / race / sex / kind / variation / geoset bits / expansion / name)\n");
std::printf(" --validate-wchf <wchf-base> [--json]\n");
std::printf(" Static checks: id+name+raceId+texturePath required, kind 0..8 / sex 0..1 / expansion 0..3, unique (race,sex,kind,variation) tuples\n");
std::printf(" --export-wchf-json <wchf-base> [out.json]\n");
std::printf(" Export binary .wchf to a human-editable JSON sidecar (defaults to <base>.wchf.json)\n");
std::printf(" --import-wchf-json <json-path> [out-base]\n");
std::printf(" Import a .wchf.json sidecar back into binary .wchf (accepts featureKind/sexId/requiresExpansion int OR name string)\n");
std::printf(" --gen-pvp <wpvp-base> [name]\n");
std::printf(" Emit .wpvp starter: 3 vanilla honor entry tiers (Rank2-4 — Private/Scout, Corporal/Grunt, Sergeant)\n");
std::printf(" --gen-pvp-alliance <wpvp-base> [name]\n");
std::printf(" Emit .wpvp 9 vanilla ranks 6-14 (Knight through Grand Marshal) with WTTL+WIT cross-refs for chest/gloves/shoulders\n");
std::printf(" --gen-pvp-arena <wpvp-base> [name]\n");
std::printf(" Emit .wpvp 5 arena rating brackets (Combatant 1500 / Challenger 1750 / Rival 2000 / Duelist 2200 / Gladiator 2400)\n");
std::printf(" --info-wpvp <wpvp-base> [--json]\n");
std::printf(" Print WPVP entries (id / kind / threshold / emblem reward / title+chest cross-refs / alliance / horde names)\n");
std::printf(" --validate-wpvp <wpvp-base> [--json]\n");
std::printf(" Static checks: id+name required, kind 0..4, level range valid, faction alt names paired, threshold monotonic within kind, arena>=1500\n");
std::printf(" --export-wpvp-json <wpvp-base> [out.json]\n");
std::printf(" Export binary .wpvp to a human-editable JSON sidecar (defaults to <base>.wpvp.json)\n");
std::printf(" --import-wpvp-json <json-path> [out-base]\n");
std::printf(" Import a .wpvp.json sidecar back into binary .wpvp (accepts rankKind int OR name string; bracket level defaults to 1..80)\n");
std::printf(" --gen-bnk <wbnk-base> [name]\n");
std::printf(" Emit .wbnk starter: 5 inventory slots (16-slot main backpack + 4 player-equippable bag slots)\n");
std::printf(" --gen-bnk-bank <wbnk-base> [name]\n");
std::printf(" Emit .wbnk 8 bank bag slots — first 2 free, then 6 with ascending gold costs (10s/1g/10g/25g/50g/100g)\n");
std::printf(" --gen-bnk-special <wbnk-base> [name]\n");
std::printf(" Emit .wbnk 4 special slots (Keyring fixed, Soul Shard warlock-only, Quiver hunter-only, Hunters Stable for pets)\n");
std::printf(" --info-wbnk <wbnk-base> [--json]\n");
std::printf(" Print WBNK entries (id / kind / size / display order / unlock status + cost / accept-mask / fixed bag item / name)\n");
std::printf(" --validate-wbnk <wbnk-base> [--json]\n");
std::printf(" Static checks: id+name required, kind 0..7, locked-with-zero-cost warning, fixed-slot-with-mask conflict, ambiguous (kind,order)\n");
std::printf(" --export-wbnk-json <wbnk-base> [out.json]\n");
std::printf(" Export binary .wbnk to a human-editable JSON sidecar (defaults to <base>.wbnk.json)\n");
std::printf(" --import-wbnk-json <json-path> [out-base]\n");
std::printf(" Import a .wbnk.json sidecar back into binary .wbnk (accepts bagKind int OR name string; isUnlocked defaults to 1, mask to AnyContainer)\n");
std::printf(" --gen-rune <wrun-base> [name]\n");
std::printf(" Emit .wrun starter: 3 baseline DK rune costs (Death Strike 1F+1U, Frost Strike 40RP spender, Heart Strike 1B)\n");
std::printf(" --gen-rune-blood <wrun-base> [name]\n");
std::printf(" Emit .wrun 4 blood-tree DK rune costs (Heart Strike, Death and Decay AoE, Vampiric Blood, Rune Tap self-heal)\n");
std::printf(" --gen-rune-frost <wrun-base> [name]\n");
std::printf(" Emit .wrun 4 frost-tree DK rune costs (Frost Strike, Howling Blast AoE, Obliterate finisher, Icy Touch opener)\n");
std::printf(" --info-wrun <wrun-base> [--json]\n");
std::printf(" Print WRUN entries (id / spell / B/F/U costs / death-convertible / RP cost+arrow / branch / name)\n");
std::printf(" --validate-wrun <wrun-base> [--json]\n");
std::printf(" Static checks: id+name+spellId required, branch 0..3, no rune cost > 2 (DK has only 2 of each), runicPower > 100 cap, no-cost warning\n");
std::printf(" --export-wrun-json <wrun-base> [out.json]\n");
std::printf(" Export binary .wrun to a human-editable JSON sidecar (defaults to <base>.wrun.json)\n");
std::printf(" --import-wrun-json <json-path> [out-base]\n");
std::printf(" Import a .wrun.json sidecar back into binary .wrun (accepts spellTreeBranch int OR name string)\n");
std::printf(" --gen-lds <wlds-base> [name]\n");
std::printf(" Emit .wlds starter: 3 base loading screens (Elwynn / Orgrimmar / GenericFallback catch-all)\n");
std::printf(" --gen-lds-instances <wlds-base> [name]\n");
std::printf(" Emit .wlds 5 WotLK dungeon loading screens (Halls of Lightning / Stone / UP / Violet Hold / Old Kingdom)\n");
std::printf(" --gen-lds-raid <wlds-base> [name]\n");
std::printf(" Emit .wlds 3 raid intro screens (Naxxramas / Ulduar / Trial of the Crusader) with isWideAspect=1\n");
std::printf(" --info-wlds <wlds-base> [--json]\n");
std::printf(" Print WLDS entries (id / mapId / level range / display weight / expansion / animated+wide flags / name)\n");
std::printf(" --validate-wlds <wlds-base> [--json]\n");
std::printf(" Static checks: id+name+texture required, expansion 0..3, level range valid, weight=0 warning, catch-all overlap\n");
std::printf(" --export-wlds-json <wlds-base> [out.json]\n");
std::printf(" Export binary .wlds to a human-editable JSON sidecar (defaults to <base>.wlds.json)\n");
std::printf(" --import-wlds-json <json-path> [out-base]\n");
std::printf(" Import a .wlds.json sidecar back into binary .wlds (accepts expansionRequired int OR name string)\n");
std::printf(" --gen-suf <wsuf-base> [name]\n");
std::printf(" Emit .wsuf starter: 3 stat-suffix entries (of the Bear STR+STA / of the Eagle INT+SPI / of the Tiger STR+AGI)\n");
std::printf(" --gen-suf-magical <wsuf-base> [name]\n");
std::printf(" Emit .wsuf 4 elemental suffixes (of Fire / of Frost / of Shadow / of Arcane) — flat per-school spell power\n");
std::printf(" --gen-suf-pvp <wsuf-base> [name]\n");
std::printf(" Emit .wsuf 3 PvPSuffix-category entries (of the Champion / of the Gladiator / of Resilience) blue+ only\n");
std::printf(" --info-wsuf <wsuf-base> [--json]\n");
std::printf(" Print WSUF entries (id / category / quality range / restricted slot mask / # populated stat slots / name)\n");
std::printf(" --validate-wsuf <wsuf-base> [--json]\n");
std::printf(" Static checks: id+name required, category 0..4, quality range valid (0..7), stat-kind/value pairing, no-stats warning\n");
std::printf(" --export-wsuf-json <wsuf-base> [out.json]\n");
std::printf(" Export binary .wsuf to a human-editable JSON sidecar with nested stats[] arrays (defaults to <base>.wsuf.json)\n");
std::printf(" --import-wsuf-json <json-path> [out-base]\n");
std::printf(" Import a .wsuf.json sidecar back into binary .wsuf (accepts suffixCategory int OR name string; missing stat slots cleared)\n");
std::printf(" --gen-crr <wcrr-base> [name]\n");
std::printf(" Emit .wcrr starter: 3 essential combat ratings (Hit / Crit / Haste) at canonical L80 conversion values\n");
std::printf(" --gen-crr-defensive <wcrr-base> [name]\n");
std::printf(" Emit .wcrr 4 defensive ratings (Defense / Dodge / Parry / Block) for tank stat scaling with diminishing returns caps\n");
std::printf(" --gen-crr-spell <wcrr-base> [name]\n");
std::printf(" Emit .wcrr 3 spell ratings (SpellPower direct / SpellPenetration flat / MP5 mana regen) for caster stat scaling\n");
std::printf(" --info-wcrr <wcrr-base> [--json]\n");
std::printf(" Print WCRR entries (id / kind / pointsAtL1/L60/L70/L80 conversion floors / max benefit pct / name)\n");
std::printf(" --validate-wcrr <wcrr-base> [--json]\n");
std::printf(" Static checks: id+name required, kind 0..4, all pointsAtLN > 0 (div-by-zero risk), maxPct > 0, monotonic ascending curve\n");
std::printf(" --export-wcrr-json <wcrr-base> [out.json]\n");
std::printf(" Export binary .wcrr to a human-editable JSON sidecar (defaults to <base>.wcrr.json)\n");
std::printf(" --import-wcrr-json <json-path> [out-base]\n");
std::printf(" Import a .wcrr.json sidecar back into binary .wcrr (accepts ratingKind int OR name string; pointsAtLN default to canonical WoW values)\n");
std::printf(" --gen-umv <wumv-base> [name]\n");
std::printf(" Emit .wumv starter: 4 baseline movement types (Walk 2.5y/s / Run 7.0y/s / Swim 4.7y/s / Turn π rad/s)\n");
std::printf(" --gen-umv-flight <wumv-base> [name]\n");
std::printf(" Emit .wumv 5 flight entries (Flight ground-rail / Fly free / FlyBack / FlightBack / Pitch rate) requiring flight skill\n");
std::printf(" --gen-umv-buffs <wumv-base> [name]\n");
std::printf(" Emit .wumv 5 temp speed buffs (Sprint 1.4× / Aspect Cheetah 1.3× / Travel 1.4× / Crusader 1.2× / Wind Walk 1.5×)\n");
std::printf(" --info-wumv <wumv-base> [--json]\n");
std::printf(" Print WUMV entries (id / category / baseSpeed / multipliers / duration / priority / flight+stack flags / name)\n");
std::printf(" --validate-wumv <wumv-base> [--json]\n");
std::printf(" Static checks: id+name required, category 0..11, baseMultiplier > 0, max >= base, baseline categories need baseSpeed > 0\n");
std::printf(" --export-wumv-json <wumv-base> [out.json]\n");
std::printf(" Export binary .wumv to a human-editable JSON sidecar (defaults to <base>.wumv.json)\n");
std::printf(" --import-wumv-json <json-path> [out-base]\n");
std::printf(" Import a .wumv.json sidecar back into binary .wumv (accepts movementCategory int OR name string; multipliers default to 1.0/1.4)\n");
std::printf(" --gen-qso <wqso-base> [name]\n");
std::printf(" Emit .wqso starter: 3 generic sorts (General catch-all / Daily reset / Repeatable non-daily)\n");
std::printf(" --gen-qso-class <wqso-base> [name]\n");
std::printf(" Emit .wqso 10 class-specific sorts (Warrior / Paladin / Hunter / Rogue / Priest / DK / Shaman / Mage / Warlock / Druid)\n");
std::printf(" --gen-qso-profession <wqso-base> [name]\n");
std::printf(" Emit .wqso 8 profession sorts (Blacksmithing / Tailoring / Engineering / Alchemy / Enchanting / Leatherworking / Jewelcrafting / Inscription)\n");
std::printf(" --info-wqso <wqso-base> [--json]\n");
std::printf(" Print WQSO entries (id / kind / display priority / classMask / profession / faction / displayName)\n");
std::printf(" --validate-wqso <wqso-base> [--json]\n");
std::printf(" Static checks: id+name+displayName required, kind 0..11, ClassQuest needs classMask>0, Reputation needs factionId>0\n");
std::printf(" --export-wqso-json <wqso-base> [out.json]\n");
std::printf(" Export binary .wqso to a human-editable JSON sidecar (defaults to <base>.wqso.json)\n");
std::printf(" --import-wqso-json <json-path> [out-base]\n");
std::printf(" Import a .wqso.json sidecar back into binary .wqso (accepts sortKind int OR name string)\n");
std::printf(" --gen-srg <wsrg-base> [name]\n");
std::printf(" Emit .wsrg starter: 3 baseline range buckets (Self 0-0 / Melee 0-5 / Spell 0-30)\n");
std::printf(" --gen-srg-ranged <wsrg-base> [name]\n");
std::printf(" Emit .wsrg 5 ranged spell buckets (Short 20y / Medium 30y / Long 40y / VeryLong 100y / Unlimited)\n");
std::printf(" --gen-srg-friendly <wsrg-base> [name]\n");
std::printf(" Emit .wsrg 3 friendly-only buckets (Heal 40y / Cleanse 30y / Buff 30y) where hostile range = 0\n");
std::printf(" --info-wsrg <wsrg-base> [--json]\n");
std::printf(" Print WSRG entries (id / kind / hostile + friendly min-max yards / icon color / name)\n");
std::printf(" --validate-wsrg <wsrg-base> [--json]\n");
std::printf(" Static checks: id+name required, rangeKind 0..6, min<=max, no negatives, no duplicate ids; warns on Self+nonzero range and Melee>8y\n");
std::printf(" --export-wsrg-json <wsrg-base> [out.json]\n");
std::printf(" Export binary .wsrg to a human-editable JSON sidecar (defaults to <base>.wsrg.json)\n");
std::printf(" --import-wsrg-json <json-path> [out-base]\n");
std::printf(" Import a .wsrg.json sidecar back into binary .wsrg (accepts rangeKind int OR rangeKindName string)\n");
std::printf(" --gen-sct <wsct-base> [name]\n");
std::printf(" Emit .wsct starter: 4 baseline cast time buckets (Instant 0ms / FastCast 1s / MediumCast 1.5s / LongCast 3s)\n");
std::printf(" --gen-sct-channel <wsct-base> [name]\n");
std::printf(" Emit .wsct 3 channeled-spell buckets (TickEvery1s 3s total / TickEvery2s 6s / TickEvery3s 9s)\n");
std::printf(" --gen-sct-ramp <wsct-base> [name]\n");
std::printf(" Emit .wsct 4 level-scaled buckets (perLevelMs > 0; baseMs grows with level, clamped to min/max)\n");
std::printf(" --info-wsct <wsct-base> [--json]\n");
std::printf(" Print WSCT entries (id / kind / baseMs / perLevelMs / minMs / maxMs / iconColor / name)\n");
std::printf(" --validate-wsct <wsct-base> [--json]\n");
std::printf(" Static checks: id+name required, castKind 0..4, baseMs>=0, min<=max, no duplicate ids; warns on Instant+nonzero base, errors on Channel+0 base\n");
std::printf(" --export-wsct-json <wsct-base> [out.json]\n");
std::printf(" Export binary .wsct to a human-editable JSON sidecar (defaults to <base>.wsct.json)\n");
std::printf(" --import-wsct-json <json-path> [out-base]\n");
std::printf(" Import a .wsct.json sidecar back into binary .wsct (accepts castKind int OR castKindName string)\n");
std::printf(" --gen-sdr <wsdr-base> [name]\n");
std::printf(" Emit .wsdr starter: 5 baseline duration buckets (Instant 0 / Short 5s / Medium 30s / Long 5min / OneHour 60min)\n");
std::printf(" --gen-sdr-buffs <wsdr-base> [name]\n");
std::printf(" Emit .wsdr 4 long-duration buffs (PartyBuff 30m / RaidBuff 60m / WorldBuff 4hr / UntilDeath -1)\n");
std::printf(" --gen-sdr-dot <wsdr-base> [name]\n");
std::printf(" Emit .wsdr 4 DoT/HoT buckets (4-tick 12s / 5-tick 15s / 6-tick 18s / 8-tick 24s)\n");
std::printf(" --info-wsdr <wsdr-base> [--json]\n");
std::printf(" Print WSDR entries (id / kind / baseMs / perLevelMs / maxMs / iconColor / name)\n");
std::printf(" --validate-wsdr <wsdr-base> [--json]\n");
std::printf(" Static checks: id+name required, durationKind 0..4, base>0 for Timed/TickBased, base<0 for permanent kinds, max>=base, no duplicate ids\n");
std::printf(" --export-wsdr-json <wsdr-base> [out.json]\n");
std::printf(" Export binary .wsdr to a human-editable JSON sidecar (defaults to <base>.wsdr.json)\n");
std::printf(" --import-wsdr-json <json-path> [out-base]\n");
std::printf(" Import a .wsdr.json sidecar back into binary .wsdr (accepts durationKind int OR durationKindName string)\n");
std::printf(" --gen-cdb <wscd-base> [name]\n");
std::printf(" Emit .wscd starter: 4 baseline cooldown buckets (GlobalCooldown 1.5s / ShortItem 5s / MediumItem 30s / LongItem 60s shared)\n");
std::printf(" --gen-cdb-class <wscd-base> [name]\n");
std::printf(" Emit .wscd 5 mage class buckets (Polymorph family / AlterTime 90s / Counterspell 24s / Blink 15s / IceBlock 5min)\n");
std::printf(" --gen-cdb-items <wscd-base> [name]\n");
std::printf(" Emit .wscd 5 item buckets (HealingPot+ManaPot 60s shared / ManaJade GCD-only / EngineerTrinket 60s / Hearthstone 60min)\n");
std::printf(" --info-wscd <wscd-base> [--json]\n");
std::printf(" Print WSCD entries (id / kind / cooldownMs / category flags / name) — flags decoded as label list\n");
std::printf(" --validate-wscd <wscd-base> [--json]\n");
std::printf(" Static checks: id+name required, bucketKind 0..4, no duplicate ids; warns on Global without OnGCDStart and Spell with SharedWithItems\n");
std::printf(" --export-wscd-json <wscd-base> [out.json]\n");
std::printf(" Export binary .wscd to a human-editable JSON sidecar (defaults to <base>.wscd.json)\n");
std::printf(" --import-wscd-json <json-path> [out-base]\n");
std::printf(" Import a .wscd.json sidecar back into binary .wscd (accepts bucketKind int OR name; categoryFlags as int OR pipe-separated label string)\n");
std::printf(" --gen-cef <wcef-base> [name]\n");
std::printf(" Emit .wcef starter: 5 baseline beast families (Bear/Cat/Wolf/Boar/Crab) covering Tenacity + Ferocity trees\n");
std::printf(" --gen-cef-ferocity <wcef-base> [name]\n");
std::printf(" Emit .wcef 4 Ferocity-tree DPS pets (Cat / Wolf / Raptor / Devilsaur) with bleed/howl/armor mechanics\n");
std::printf(" --gen-cef-exotic <wcef-base> [name]\n");
std::printf(" Emit .wcef 4 exotic Beast Master families (Worm / Devilsaur / Chimaera / Core Hound) — Exotic kind, requires 51-pt BM\n");
std::printf(" --info-wcef <wcef-base> [--json]\n");
std::printf(" Print WCEF entries (id / kind / talent tree / tame level / skill line / food types / name)\n");
std::printf(" --validate-wcef <wcef-base> [--json]\n");
std::printf(" Static checks: id+name required, familyKind 0..5, talent tree 0..3, no duplicate ids; warns on NotPet+talent, Exotic+lvl>80, Beast/Exotic with no foods (would starve)\n");
std::printf(" --export-wcef-json <wcef-base> [out.json]\n");
std::printf(" Export binary .wcef to a human-editable JSON sidecar (defaults to <base>.wcef.json)\n");
std::printf(" --import-wcef-json <json-path> [out-base]\n");
std::printf(" Import a .wcef.json sidecar back into binary .wcef (accepts familyKind/petTalentTree int OR name; petFoodTypes int OR pipe-separated label string)\n");
std::printf(" --gen-spc <wspc-base> [name]\n");
std::printf(" Emit .wspc starter: 4 baseline mana cost tiers (NoCost / LowMana 5%% / MediumMana 15%% / HighMana 30%%) — %% of caster max mana\n");
std::printf(" --gen-spc-rage <wspc-base> [name]\n");
std::printf(" Emit .wspc 4 fixed warrior rage costs (HeroicStrike 15 / Slam 20 / Whirlwind 25 stance-locked / MortalStrike 30)\n");
std::printf(" --gen-spc-mixed <wspc-base> [name]\n");
std::printf(" Emit .wspc 5 cross-class costs covering every non-mana power type (Hunter Focus 30 / Rogue Energy 40 refund / DK Runic 30 / Paladin Holy 1 / Warlock Shard 1)\n");
std::printf(" --info-wspc <wspc-base> [--json]\n");
std::printf(" Print WSPC entries (id / powerType / baseCost / perLevelCost / percentOfBase / cost flags / name) — flags decoded as label list\n");
std::printf(" --validate-wspc <wspc-base> [--json]\n");
std::printf(" Static checks: id+name required, powerType 0..11, no duplicate ids; warns on percent outside [0,1], NoCost+nonzero, and non-NoCost types with no cost set (would cast for free)\n");
std::printf(" --export-wspc-json <wspc-base> [out.json]\n");
std::printf(" Export binary .wspc to a human-editable JSON sidecar (defaults to <base>.wspc.json)\n");
std::printf(" --import-wspc-json <json-path> [out-base]\n");
std::printf(" Import a .wspc.json sidecar back into binary .wspc (accepts powerType int OR name; costFlags int OR pipe-separated label string)\n");
std::printf(" --gen-gfs <wgfs-base> [name]\n");
std::printf(" Emit .wgfs starter: 6 baseline glyph slots (3 Major + 3 Minor) all-class, unlocking at 25/50/75 each\n");
std::printf(" --gen-gfs-wotlk <wgfs-base> [name]\n");
std::printf(" Emit .wgfs WotLK 3.3.5a layout: 3 Major (15/30/50) + 3 Minor (15/50/70), all-class\n");
std::printf(" --gen-gfs-cata <wgfs-base> [name]\n");
std::printf(" Emit .wgfs Cataclysm layout: 3 Prime + 3 Major + 3 Minor (9 slots), all unlocking at 25/50/75\n");
std::printf(" --info-wgfs <wgfs-base> [--json]\n");
std::printf(" Print WGFS entries (id / kind / displayOrder / minLevelToUnlock / classMask / name)\n");
std::printf(" --validate-wgfs <wgfs-base> [--json]\n");
std::printf(" Static checks: id+name+classMask required, slotKind 0..2, no duplicate ids; warns on lvl>80, displayOrder>4, and (kind+order) collisions for overlapping classMask\n");
std::printf(" --export-wgfs-json <wgfs-base> [out.json]\n");
std::printf(" Export binary .wgfs to a human-editable JSON sidecar (defaults to <base>.wgfs.json)\n");
std::printf(" --import-wgfs-json <json-path> [out-base]\n");
std::printf(" Import a .wgfs.json sidecar back into binary .wgfs (accepts slotKind int OR slotKindName string)\n");
std::printf(" --gen-cdf <wcdf-base> [name]\n");
std::printf(" Emit .wcdf starter: 4 example boss/mini/add routes with full 4-variant 10/25/H10/H25 mapping\n");
std::printf(" --gen-cdf-wotlk-raid <wcdf-base> [name]\n");
std::printf(" Emit .wcdf 4 ICC-style raid bosses (Marrowgar / Deathwhisper / Saurfang / Lich King) with all 4 difficulty variants\n");
std::printf(" --gen-cdf-fiveman <wcdf-base> [name]\n");
std::printf(" Emit .wcdf 4 5-man dungeon bosses with only Normal+Heroic 10-man variants set (25-man fields stay 0)\n");
std::printf(" --info-wcdf <wcdf-base> [--json]\n");
std::printf(" Print WCDF entries (id / kind / baseCreatureId / 4 variant ids / name)\n");
std::printf(" --validate-wcdf <wcdf-base> [--json]\n");
std::printf(" Static checks: id+name+baseCreatureId required, spawnGroupKind 0..5, no duplicate ids; warns on WorldBoss with variants, Boss with only n10, duplicate baseIds, all-self-ref non-WorldBoss\n");
std::printf(" --export-wcdf-json <wcdf-base> [out.json]\n");
std::printf(" Export binary .wcdf to a human-editable JSON sidecar (defaults to <base>.wcdf.json)\n");
std::printf(" --import-wcdf-json <json-path> [out-base]\n");
std::printf(" Import a .wcdf.json sidecar back into binary .wcdf (accepts spawnGroupKind int OR spawnGroupKindName string)\n");
std::printf(" --gen-mat <wmat-base> [name]\n");
std::printf(" Emit .wmat 5 armor materials (Cloth/Leather/Mail/Plate/Hide) with weight categories matching WoW's armor classes\n");
std::printf(" --gen-mat-weapon <wmat-base> [name]\n");
std::printf(" Emit .wmat 5 weapon materials (Wood breakable+flammable / Steel / Mithril / Adamantite / EnchantedSteel magical)\n");
std::printf(" --gen-mat-magical <wmat-base> [name]\n");
std::printf(" Emit .wmat 4 magical materials (Crystal magical+breakable / Ethereal / CursedBone / HolyForged charged)\n");
std::printf(" --info-wmat <wmat-base> [--json]\n");
std::printf(" Print WMAT entries (id / kind / weight / foley/impact sound ids / material flags / name) — flags decoded as label list\n");
std::printf(" --validate-wmat <wmat-base> [--json]\n");
std::printf(" Static checks: id+name required, materialKind 0..11, weightCategory 0..2, no duplicate ids; warns on Holy+Cursed combo, Plate non-heavy, Cloth non-light\n");
std::printf(" --export-wmat-json <wmat-base> [out.json]\n");
std::printf(" Export binary .wmat to a human-editable JSON sidecar (defaults to <base>.wmat.json)\n");
std::printf(" --import-wmat-json <json-path> [out-base]\n");
std::printf(" Import a .wmat.json sidecar back into binary .wmat (accepts materialKind/weightCategory int OR name; materialFlags int OR pipe-separated label string)\n");
std::printf(" --gen-psp <wpsp-base> [name]\n");
std::printf(" Emit .wpsp 5 Alliance starting profiles (Human Warrior / Dwarf Hunter / NightElf Druid / Gnome Mage / Draenei Shaman) with race+class spawn coords\n");
std::printf(" --gen-psp-horde <wpsp-base> [name]\n");
std::printf(" Emit .wpsp 5 Horde starting profiles (Orc Warrior / Tauren Druid / Undead Mage / Troll Hunter / BloodElf Priest)\n");
std::printf(" --gen-psp-dk <wpsp-base> [name]\n");
std::printf(" Emit .wpsp 2 Death Knight profiles (Alliance Human / Horde Orc) starting at lvl 55 in Acherus with DK starter spell loadout\n");
std::printf(" --info-wpsp <wpsp-base> [--json]\n");
std::printf(" Print WPSP entries (id / raceMask / classMask / map / zone / startingLevel / spawn coords / name)\n");
std::printf(" --validate-wpsp <wpsp-base> [--json]\n");
std::printf(" Static checks: id+name+race+class+startingLevel required, no duplicate ids; warns on (0,0,0) spawn, item id/count mismatch, lvl>80, DK not at 55\n");
std::printf(" --export-wpsp-json <wpsp-base> [out.json]\n");
std::printf(" Export binary .wpsp to a human-editable JSON sidecar (defaults to <base>.wpsp.json)\n");
std::printf(" --import-wpsp-json <json-path> [out-base]\n");
std::printf(" Import a .wpsp.json sidecar back into binary .wpsp (all per-entry fields preserved verbatim including spawn/bind coords and item/spell ids)\n");
std::printf(" --gen-tle <wtle-base> [name]\n");
std::printf(" Emit .wtle Warrior tabs: 3 trees (Arms DPS / Fury DPS / Protection Tank) with canonical icon and background art paths\n");
std::printf(" --gen-tle-mage <wtle-base> [name]\n");
std::printf(" Emit .wtle Mage tabs: 3 trees (Arcane / Fire / Frost), all DPS, with mage-blue icon color\n");
std::printf(" --gen-tle-paladin <wtle-base> [name]\n");
std::printf(" Emit .wtle Paladin tabs: 3 trees covering all 3 roles (Holy Healer / Protection Tank / Retribution DPS)\n");
std::printf(" --info-wtle <wtle-base> [--json]\n");
std::printf(" Print WTLE entries (id / classMask / displayOrder / role / name / backgroundFile)\n");
std::printf(" --validate-wtle <wtle-base> [--json]\n");
std::printf(" Static checks: id+name+classMask required, roleHint 0..4, no duplicate ids; warns on empty icon/background, displayOrder>3, and (classMask+order) UI position collisions\n");
std::printf(" --export-wtle-json <wtle-base> [out.json]\n");
std::printf(" Export binary .wtle to a human-editable JSON sidecar (defaults to <base>.wtle.json)\n");
std::printf(" --import-wtle-json <json-path> [out-base]\n");
std::printf(" Import a .wtle.json sidecar back into binary .wtle (accepts roleHint int OR roleHintName string)\n");
std::printf(" --gen-ctr <wctr-base> [name]\n");
std::printf(" Emit .wctr 4 PvP currencies (Honor 75k cap / Arena 5k weekly / Conquest 1650 weekly / Champion's Seal no cap)\n");
std::printf(" --gen-ctr-pve <wctr-base> [name]\n");
std::printf(" Emit .wctr 4 PvE raid currencies (Justice 4k cap / Valor 1k weekly / Emblem of Frost no cap / Trophy of Crusade no cap)\n");
std::printf(" --gen-ctr-faction <wctr-base> [name]\n");
std::printf(" Emit .wctr 4 faction reputation tokens (Hodir / Cenarion / Argent Dawn / Wintergrasp) — categoryId references WFAC factionId\n");
std::printf(" --info-wctr <wctr-base> [--json]\n");
std::printf(" Print WCTR entries (id / kind / itemId / max+weekly caps / categoryId / accountWide / name)\n");
std::printf(" --validate-wctr <wctr-base> [--json]\n");
std::printf(" Static checks: id+name required, currencyKind 0..5, no duplicate ids; warns on weekly>absolute, FactionToken+cat=0, no caps+no item+no icon\n");
std::printf(" --export-wctr-json <wctr-base> [out.json]\n");
std::printf(" Export binary .wctr to a human-editable JSON sidecar (defaults to <base>.wctr.json)\n");
std::printf(" --import-wctr-json <json-path> [out-base]\n");
std::printf(" Import a .wctr.json sidecar back into binary .wctr (accepts currencyKind int OR currencyKindName string; isAccountWide bool OR int)\n");
std::printf(" --gen-spr <wspr-base> [name]\n");
std::printf(" Emit .wspr 4 mage portal/teleport reagents (Stormwind/Ironforge/Darnassus/Theramore) consuming Rune of Teleportation\n");
std::printf(" --gen-spr-warlock <wspr-base> [name]\n");
std::printf(" Emit .wspr 4 warlock summons (Imp / Voidwalker / Succubus / Felhunter) each consuming 1 Soul Shard\n");
std::printf(" --gen-spr-rez <wspr-base> [name]\n");
std::printf(" Emit .wspr 3 resurrection variants (Shaman Reincarnation / Priest Resurrection focused / Druid Rebirth no-cost) demonstrating each ReagentKind\n");
std::printf(" --info-wspr <wspr-base> [--json]\n");
std::printf(" Print WSPR entries (id / spellId / kind / used slot count / item x count list / name)\n");
std::printf(" --validate-wspr <wspr-base> [--json]\n");
std::printf(" Static checks: id+name+spellId required, reagentKind 0..4, no duplicate ids; warns on slot id/count mismatch, SoulShard kind with non-canonical reagent, FocusedItem kind with no slots, duplicate spellId\n");
std::printf(" --export-wspr-json <wspr-base> [out.json]\n");
std::printf(" Export binary .wspr to a human-editable JSON sidecar (defaults to <base>.wspr.json). Reagent slot arrays exported as JSON arrays\n");
std::printf(" --import-wspr-json <json-path> [out-base]\n");
std::printf(" Import a .wspr.json sidecar back into binary .wspr (accepts reagentKind int OR reagentKindName string; reagent arrays pad with zeros if shorter than 8)\n");
std::printf(" --gen-acr <wacr-base> [name]\n");
std::printf(" Emit .wacr 5 kill-counting criteria (Defias 50 / Murloc 25 / Naga 100 / Dragon 1 / RareElite 1) under one composite achievement\n");
std::printf(" --gen-acr-quest <wacr-base> [name]\n");
std::printf(" Emit .wacr 4 quest-completion criteria (tutorial / starting zone / daily / escort) progression chain\n");
std::printf(" --gen-acr-mixed <wacr-base> [name]\n");
std::printf(" Emit .wacr 5 cross-type criteria (ReachLevel 80 / EarnGold 10k / GainHonor 5k / PvPKill 100 / ExploreZone Stormwind) showing CriteriaType variety\n");
std::printf(" --info-wacr <wacr-base> [--json]\n");
std::printf(" Print WACR entries (id / achievementId / type / targetId / requiredCount / timeLimitMs / progressOrder / name)\n");
std::printf(" --validate-wacr <wacr-base> [--json]\n");
std::printf(" Static checks: id+name+achievementId required, criteriaType 0..12, no duplicate ids; warns on missing targetId for type-specific kinds, ReachLevel>80, timeLimit on non-timed types, requiredCount=0\n");
std::printf(" --export-wacr-json <wacr-base> [out.json]\n");
std::printf(" Export binary .wacr to a human-editable JSON sidecar (defaults to <base>.wacr.json)\n");
std::printf(" --import-wacr-json <json-path> [out-base]\n");
std::printf(" Import a .wacr.json sidecar back into binary .wacr (accepts criteriaType int 0..12 OR criteriaTypeName string)\n");
std::printf(" --gen-sef <wsef-base> [name]\n");
std::printf(" Emit .wsef 5 damage effect entries (SchoolDamage / EnvironmentalDamage / WeaponDamageNoSchool / NormalizedWeaponDmg / PowerBurn)\n");
std::printf(" --gen-sef-healing <wsef-base> [name]\n");
std::printf(" Emit .wsef 4 healing effects (Heal / HealMaxHealth / HealPct / ScriptedHeal) all flagged IsBeneficialEffect\n");
std::printf(" --gen-sef-aura <wsef-base> [name]\n");
std::printf(" Emit .wsef 5 aura-application effects (ApplyAura / ApplyAuraOnPet / AreaAuraParty / AreaAuraOwner / PersistentAreaAura)\n");
std::printf(" --info-wsef <wsef-base> [--json]\n");
std::printf(" Print WSEF entries (id / kind / baseAmount / behavior flags / name) — flags decoded as label list\n");
std::printf(" --validate-wsef <wsef-base> [--json]\n");
std::printf(" Static checks: name required, effectKind 0..9, no duplicate ids; warns on Hostile+Beneficial conflict, Damage without TriggersGCD, Heal without IsBeneficialEffect\n");
std::printf(" --export-wsef-json <wsef-base> [out.json]\n");
std::printf(" Export binary .wsef to a human-editable JSON sidecar (defaults to <base>.wsef.json)\n");
std::printf(" --import-wsef-json <json-path> [out-base]\n");
std::printf(" Import a .wsef.json sidecar back into binary .wsef (accepts effectKind int OR effectKindName string; behaviorFlags int OR pipe-separated label string)\n");
std::printf(" --gen-aur <waur-base> [name]\n");
std::printf(" Emit .waur 5 periodic auras (PeriodicDamage / PeriodicHeal / PeriodicEnergize / PeriodicLeech / PeriodicTriggerSpell) at canonical 3s tick\n");
std::printf(" --gen-aur-stats <waur-base> [name]\n");
std::printf(" Emit .waur 5 stat-modifier auras (ModStat / ModResistance / ModDamageDone / ModHaste / ModCritPercent) — non-periodic, instantly applied\n");
std::printf(" --gen-aur-movement <waur-base> [name]\n");
std::printf(" Emit .waur 4 movement-impairing auras (Stun / ModDecreaseSpeed / ModConfuse / Root) typically applied by CC spells\n");
std::printf(" --info-waur <waur-base> [--json]\n");
std::printf(" Print WAUR entries (id / kind / targeting / stack flag / max stack / tick interval / name)\n");
std::printf(" --validate-waur <waur-base> [--json]\n");
std::printf(" Static checks: name required, auraKind 0..8, targetingHint 0..3, no duplicate ids; errors on Periodic without tick interval; warns on non-periodic with tick interval, maxStackCount without isStackable\n");
std::printf(" --export-waur-json <waur-base> [out.json]\n");
std::printf(" Export binary .waur to a human-editable JSON sidecar (defaults to <base>.waur.json)\n");
std::printf(" --import-waur-json <json-path> [out-base]\n");
std::printf(" Import a .waur.json sidecar back into binary .waur (accepts auraKind/targetingHint int OR name; isStackable bool OR int)\n");
std::printf(" --gen-iqr <wiqr-base> [name]\n");
std::printf(" Emit .wiqr 8 standard quality tiers (Poor through Heirloom) with canonical hex colors and disenchant rules\n");
std::printf(" --gen-iqr-server <wiqr-base> [name]\n");
std::printf(" Emit .wiqr 4 server-custom tiers (Junk / Weekly / QuestLocked / Donator) with custom colors and non-standard markups\n");
std::printf(" --gen-iqr-raid <wiqr-base> [name]\n");
std::printf(" Emit .wiqr 4 raid progression tiers (T1/T2/T3/Legendary lvl 60+) gated by minLevelToDrop and priced for server economy\n");
std::printf(" --info-wiqr <wiqr-base> [--json]\n");
std::printf(" Print WIQR entries (id / name / nameColor RGBA / vendor multiplier / minLevel / maxLevel / disenchant flag / border texture)\n");
std::printf(" --validate-wiqr <wiqr-base> [--json]\n");
std::printf(" Static checks: name required, no duplicate ids, vendor>=0, min<=max; warns on lvl>80 (unreachable), vendor>100x (sanity), alpha=0 nameColor (invisible)\n");
std::printf(" --export-wiqr-json <wiqr-base> [out.json]\n");
std::printf(" Export binary .wiqr to a human-editable JSON sidecar (defaults to <base>.wiqr.json). Colors as RGBA uint32, easy to paste hex values\n");
std::printf(" --import-wiqr-json <json-path> [out-base]\n");
std::printf(" Import a .wiqr.json sidecar back into binary .wiqr (canBeDisenchanted accepts bool OR int)\n");
std::printf(" --gen-scs <wscs-base> [name]\n");
std::printf(" Emit .wscs 6 canonical profession tiers (Apprentice/Journeyman/Expert/Artisan/Master/GrandMaster) with standard skill ranges and gold costs\n");
std::printf(" --gen-scs-weapon <wscs-base> [name]\n");
std::printf(" Emit .wscs 5 weapon skill tiers (Beginner/Trained/Skilled/Expert/Master) — free to train, level-gated, capped at 5x char level\n");
std::printf(" --gen-scs-riding <wscs-base> [name]\n");
std::printf(" Emit .wscs 5 riding skill tiers (Apprentice 60%% / Journeyman 100%% / Expert 150%% / Artisan 280%% / Cold Weather Flying) with canonical Vanilla/TBC/WotLK gold costs\n");
std::printf(" --info-wscs <wscs-base> [--json]\n");
std::printf(" Print WSCS entries (id / rank / kind / minSkill / maxSkill / required level / gold cost / name)\n");
std::printf(" --validate-wscs <wscs-base> [--json]\n");
std::printf(" Static checks: id+name required, costKind 0..4, no duplicate ids, min<max; warns on lvl>80, RidingSkill below lvl 20, Profession with cost=0\n");
std::printf(" --export-wscs-json <wscs-base> [out.json]\n");
std::printf(" Export binary .wscs to a human-editable JSON sidecar (defaults to <base>.wscs.json)\n");
std::printf(" --import-wscs-json <json-path> [out-base]\n");
std::printf(" Import a .wscs.json sidecar back into binary .wscs (accepts costKind int OR costKindName string)\n");
std::printf(" --gen-ifs <wifs-base> [name]\n");
std::printf(" Emit .wifs 8 canonical Item.dbc flag bits (NoLoot / Conjured / Lootable / Wrapped / Heroic / Deprecated / NoUserDestroy / NoEquipCooldown)\n");
std::printf(" --gen-ifs-binding <wifs-base> [name]\n");
std::printf(" Emit .wifs 5 binding-related flags (BindOnPickup / BindOnEquip / BindOnUse / BindToAccount / Soulbound) — all isPositive=0 (restrict trading)\n");
std::printf(" --gen-ifs-server <wifs-base> [name]\n");
std::printf(" Emit .wifs 5 server-custom flag bits in upper range (Donator / EventReward / Anniversary / Honored / Heroic25man)\n");
std::printf(" --info-wifs <wifs-base> [--json]\n");
std::printf(" Print WIFS entries (id / bitMask hex / kind / +/- positivity / name) — handy for decoding raw item.flags integers\n");
std::printf(" --validate-wifs <wifs-base> [--json]\n");
std::printf(" Static checks: id+name+bitMask required, flagKind 0..6, no duplicate ids, no duplicate bitMasks (collision); warns on multi-bit masks (unusual, usually want a single bit)\n");
std::printf(" --export-wifs-json <wifs-base> [out.json]\n");
std::printf(" Export binary .wifs to a human-editable JSON sidecar (defaults to <base>.wifs.json)\n");
std::printf(" --import-wifs-json <json-path> [out-base]\n");
std::printf(" Import a .wifs.json sidecar back into binary .wifs (accepts flagKind int OR name; isPositive bool OR int)\n");
std::printf(" --gen-bkd <wbkd-base> [name]\n");
std::printf(" Emit .wbkd 5 city services (Banker / Mailbox / Innkeeper / Auctioneer / FlightMaster) typical of capital city offerings\n");
std::printf(" --gen-bkd-battle <wbkd-base> [name]\n");
std::printf(" Emit .wbkd 3 battlemaster services (Alterac Valley / Warsong Gulch / Arathi Basin) for queueing into Vanilla BGs\n");
std::printf(" --gen-bkd-profession <wbkd-base> [name]\n");
std::printf(" Emit .wbkd 4 profession services (Blacksmith Trainer / Tailoring Trainer / Reagent Vendor / Stable Master)\n");
std::printf(" --info-wbkd <wbkd-base> [--json]\n");
std::printf(" Print WBKD entries (id / kind / gold cost / faction gate / gossip text id / name)\n");
std::printf(" --validate-wbkd <wbkd-base> [--json]\n");
std::printf(" Static checks: id+name required, serviceKind 0..11, no duplicate ids; warns on Mailbox+gossip (no NPC dialog), Innkeeper+no-gossip (silent bind), Battlemaster+gold (queues are free)\n");
std::printf(" --export-wbkd-json <wbkd-base> [out.json]\n");
std::printf(" Export binary .wbkd to a human-editable JSON sidecar (defaults to <base>.wbkd.json)\n");
std::printf(" --import-wbkd-json <json-path> [out-base]\n");
std::printf(" Import a .wbkd.json sidecar back into binary .wbkd (accepts serviceKind int OR serviceKindName string)\n");
std::printf(" --gen-tbr <wtbr-base> [name]\n");
std::printf(" Emit .wtbr 5 raid tier-token redemptions (T9 Conqueror's helm / Vanquisher's chest / T10 Protector's legs / Trophy Gloves) consuming Trophy of the Crusade and Emblem of Frost\n");
std::printf(" --gen-tbr-pvp <wtbr-base> [name]\n");
std::printf(" Emit .wtbr 5 PvP token redemptions (BG mount / Arena weapon / Wrathful PvP helm / Combatant title / PvP tabard)\n");
std::printf(" --gen-tbr-faction <wtbr-base> [name]\n");
std::printf(" Emit .wtbr 5 faction-rep-gated rewards (Argent tabard @ Honored / Hodir mammoth @ Exalted / Cenarion ring @ Revered / Argent title @ Exalted / Wintergrasp pet @ Honored)\n");
std::printf(" --info-wtbr <wtbr-base> [--json]\n");
std::printf(" Print WTBR entries (id / spent token x count / reward kind / rewardId / faction@standing gate / name)\n");
std::printf(" --validate-wtbr <wtbr-base> [--json]\n");
std::printf(" Static checks: id+name+spentTokenItemId+count required, rewardKind 0..7, requiredFactionStanding 0..7, no duplicate ids; warns on rewardId=0 (no actual reward), standing>Neutral with factionId=0, Currency conversion item->itself\n");
std::printf(" --export-wtbr-json <wtbr-base> [out.json]\n");
std::printf(" Export binary .wtbr to a human-editable JSON sidecar (defaults to <base>.wtbr.json)\n");
std::printf(" --import-wtbr-json <json-path> [out-base]\n");
std::printf(" Import a .wtbr.json sidecar back into binary .wtbr (accepts rewardKind/requiredFactionStanding int OR name)\n");
std::printf(" --gen-sps <wsps-base> [name]\n");
std::printf(" Emit .wsps 4 weapon-imbue procs (Windfury 20PPM+3sICD / Frostbrand 9PPM / Flametongue 15PPM / Mana Oil 4PPM+5sICD) on DealtMeleeAutoAttack\n");
std::printf(" --gen-sps-aura <wsps-base> [name]\n");
std::printf(" Emit .wsps 4 aura-tied procs (Blessing of Wisdom mana / Molten Armor reflect / Earth Shield heal / Judgement of Wisdom)\n");
std::printf(" --gen-sps-talent <wsps-base> [name]\n");
std::printf(" Emit .wsps 4 talent procs (Clearcasting / Omen of Clarity / Seal of Righteousness / Nightfall) with charge-consuming variants\n");
std::printf(" --info-wsps <wsps-base> [--json]\n");
std::printf(" Print WSPS entries (id / triggerSpellId / fromSpellId / chance%% / PPM / ICD / charges / proc flags)\n");
std::printf(" --validate-wsps <wsps-base> [--json]\n");
std::printf(" Static checks: id+name+triggerSpellId+procFlags required, no duplicate ids; warns on chance outside [0,1], procPpm<0, both chance+ppm set (PPM wins), neither set (never fires)\n");
std::printf(" --export-wsps-json <wsps-base> [out.json]\n");
std::printf(" Export binary .wsps to a human-editable JSON sidecar (defaults to <base>.wsps.json)\n");
std::printf(" --import-wsps-json <json-path> [out-base]\n");
std::printf(" Import a .wsps.json sidecar back into binary .wsps (procFlags accepts int OR pipe-separated label string)\n");
std::printf(" --gen-cmr <wcmr-base> [name]\n");
std::printf(" Emit .wcmr 3 small patrols showing each pathKind (4-pt Loop guard / 6-pt OneShot run / 8-pt Random tiger)\n");
std::printf(" --gen-cmr-city <wcmr-base> [name]\n");
std::printf(" Emit .wcmr 4 capital-city guard routes (Stormwind / Orgrimmar / Ironforge / Thunder Bluff) with 6-point loops\n");
std::printf(" --gen-cmr-boss <wcmr-base> [name]\n");
std::printf(" Emit .wcmr 3 raid-zone patrols (AQ40 12-pt Loop / Naxx 8-pt OneShot / ICC 16-pt Random) demonstrating long-path support\n");
std::printf(" --info-wcmr <wcmr-base> [--json]\n");
std::printf(" Print WCMR entries (id / creatureGuid / pathKind / moveType / waypoint count / total path length yards / name)\n");
std::printf(" --validate-wcmr <wcmr-base> [--json]\n");
std::printf(" Static checks: id+name+creatureGuid+waypoints required, pathKind 0..3, moveType 0..3, no duplicate ids; warns on 1-waypoint paths (idle), Loop with <3 waypoints (degenerate)\n");
std::printf(" --export-wcmr-json <wcmr-base> [out.json]\n");
std::printf(" Export binary .wcmr to a human-editable JSON sidecar (defaults to <base>.wcmr.json). Waypoints exported as JSON arrays for variable-length editing\n");
std::printf(" --import-wcmr-json <json-path> [out-base]\n");
std::printf(" Import a .wcmr.json sidecar back into binary .wcmr (accepts pathKind/moveType int OR name; waypoint arrays length-preserving)\n");
std::printf(" --gen-bos <wbos-base> [name]\n");
std::printf(" Emit .wbos 3 5-man dungeon bosses (TrollChieftain 2-phase / ShamanWraith / DrakTharonFinal 3-phase) at recommended ilvl 200-210\n");
std::printf(" --gen-bos-raid10 <wbos-base> [name]\n");
std::printf(" Emit .wbos 4 ICC 10-Normal raid bosses (Marrowgar 2-phase / Deathwhisper 2-phase / Saurfang 1-phase / Lich King 5-phase) with soft-enrage timers\n");
std::printf(" --gen-bos-world <wbos-base> [name]\n");
std::printf(" Emit .wbos 2 outdoor world bosses (Doom Lord Kazzak / Doomwalker) — 25-player, no enrage, no difficultyId\n");
std::printf(" --info-wbos <wbos-base> [--json]\n");
std::printf(" Print WBOS entries (id / boss creature / map / difficulty / phases / size / ilvl / soft-enrage minutes / berserk spell / name)\n");
std::printf(" --validate-wbos <wbos-base> [--json]\n");
std::printf(" Static checks: id+name+boss+map+phases+size required, no duplicate ids; warns on non-standard party size, berserkSpellId set without enrageTimerMs, enrage > 30 min\n");
std::printf(" --export-wbos-json <wbos-base> [out.json]\n");
std::printf(" Export binary .wbos to a human-editable JSON sidecar (defaults to <base>.wbos.json)\n");
std::printf(" --import-wbos-json <json-path> [out-base]\n");
std::printf(" Import a .wbos.json sidecar back into binary .wbos (all per-entry fields preserved verbatim)\n");
std::printf(" --gen-hld <whld-base> [name]\n");
std::printf(" Emit .whld 4 ICC raid weekly lockouts (10N / 25N / 10H / 25H) — 12 boss kill cap, 7-day reset\n");
std::printf(" --gen-hld-dungeon <whld-base> [name]\n");
std::printf(" Emit .whld 4 5-man heroic dungeon daily lockouts (HoR / FoS / PoS / TotC) — 24h reset, 5-player size\n");
std::printf(" --gen-hld-event <whld-base> [name]\n");
std::printf(" Emit .whld 3 world-event lockouts (Brewfest daily / Hallow's End daily / Wintergrasp 2.5h Custom interval)\n");
std::printf(" --info-whld <whld-base> [--json]\n");
std::printf(" Print WHLD entries (id / map / diff / kind / interval (formatted) / boss kills / size / bonus rolls / name)\n");
std::printf(" --validate-whld <whld-base> [--json]\n");
std::printf(" Static checks: id+name+kind+interval required, no duplicate ids; warns on non-standard group size, kind/interval mismatches (Daily not 24h, Weekly not 7d), 0 boss kill cap\n");
std::printf(" --export-whld-json <whld-base> [out.json]\n");
std::printf(" Export binary .whld to a human-editable JSON sidecar (defaults to <base>.whld.json)\n");
std::printf(" --import-whld-json <json-path> [out-base]\n");
std::printf(" Import a .whld.json sidecar back into binary .whld (accepts raidLockoutKind int OR raidLockoutKindName string)\n");
std::printf(" --gen-stc <wstc-base> [name]\n");
std::printf(" Emit .wstc 5 canonical hunter stable slots (Active + 4 stabled, unlocking lvl 10/20/30/40/50 with 0/10s/50s/2g/10g costs)\n");
std::printf(" --gen-stc-cata <wstc-base> [name]\n");
std::printf(" Emit .wstc 6 Cata-style slots (Active + 5 stabled), with slot 5 unlocking at lvl 60 for 25g\n");
std::printf(" --gen-stc-premium <wstc-base> [name]\n");
std::printf(" Emit .wstc 4 server-custom donator-only slots (premium=1, no level/gold gate)\n");
std::printf(" --info-wstc <wstc-base> [--json]\n");
std::printf(" Print WSTC entries (id / displayOrder / minLevelToUnlock / cost (formatted) / premium flag / name)\n");
std::printf(" --validate-wstc <wstc-base> [--json]\n");
std::printf(" Static checks: id+name required, no duplicate ids; warns on lvl>80 (unreachable), Premium+nonzero cost (donor slots are free), duplicate displayOrder (UI collision)\n");
std::printf(" --export-wstc-json <wstc-base> [out.json]\n");
std::printf(" Export binary .wstc to a human-editable JSON sidecar (defaults to <base>.wstc.json)\n");
std::printf(" --import-wstc-json <json-path> [out-base]\n");
std::printf(" Import a .wstc.json sidecar back into binary .wstc (isPremium accepts bool OR int)\n");
std::printf(" --gen-stm <wstm-base> [name]\n");
std::printf(" Emit .wstm 5 crit curves (MeleeCrit / RangedCrit / SpellCrit / Parry / Dodge) with canonical 3.3.5a base+per-level scaling\n");
std::printf(" --gen-stm-regen <wstm-base> [name]\n");
std::printf(" Emit .wstm 4 regen curves (ManaPerSpirit / HpPerSpirit / EnergyPerSec / RageDecay) with stock formulas\n");
std::printf(" --gen-stm-armor <wstm-base> [name]\n");
std::printf(" Emit .wstm 3 armor/mitigation curves (BaseArmorPerLevel / ArmorMitigationPct / ResistancePerLevel)\n");
std::printf(" --info-wstm <wstm-base> [--json]\n");
std::printf(" Print WSTM entries (id / kind / minLvl / maxLvl / baseValue / perLevelDelta / multiplier / value@lvl80 sample / name)\n");
std::printf(" --validate-wstm <wstm-base> [--json]\n");
std::printf(" Static checks: id+name required, curveKind 0..6, minLevel<=maxLevel, no duplicate ids; warns on maxLevel>80, multiplier=0 (always 0), multiplier<0 (inverts), perLevelDelta<0 (shrinks)\n");
std::printf(" --export-wstm-json <wstm-base> [out.json]\n");
std::printf(" Export binary .wstm to a human-editable JSON sidecar (defaults to <base>.wstm.json)\n");
std::printf(" --import-wstm-json <json-path> [out-base]\n");
std::printf(" Import a .wstm.json sidecar back into binary .wstm (accepts curveKind int OR curveKindName string)\n");
std::printf(" --gen-act <wact-base> [name]\n");
std::printf(" Emit .wact 10 Warrior starter bindings on Main bar (Heroic Strike / Charge / Rend / Thunder Clap / Battle Shout / Sunder Armor / Mocking Blow / Hamstring / Overpower / Victory Rush)\n");
std::printf(" --gen-act-mage <wact-base> [name]\n");
std::printf(" Emit .wact 10 Mage starter bindings on Main bar (Fireball / Frostbolt / Frost Nova / Polymorph / Mage Armor / Arcane Intellect / Counterspell / Blink / Fire Blast / Conjure Water)\n");
std::printf(" --gen-act-pet <wact-base> [name]\n");
std::printf(" Emit .wact 10 Hunter pet-bar bindings on Pet bar mode (Attack / Follow / Stay / Aggressive / Defensive / Passive / Bite / Claw / Growl / Dismiss)\n");
std::printf(" --info-wact <wact-base> [--json]\n");
std::printf(" Print WACT entries (id / classMask / barMode / buttonSlot / spellId / itemId / name)\n");
std::printf(" --validate-wact <wact-base> [--json]\n");
std::printf(" Static checks: id+name+classMask required, barMode 0..6, no duplicate ids; warns on slot>143, both spellId+itemId set, both 0 (empty button), and (classMask+barMode+slot) collisions for overlapping classes\n");
std::printf(" --export-wact-json <wact-base> [out.json]\n");
std::printf(" Export binary .wact to a human-editable JSON sidecar (defaults to <base>.wact.json)\n");
std::printf(" --import-wact-json <json-path> [out-base]\n");
std::printf(" Import a .wact.json sidecar back into binary .wact (accepts barMode int OR barModeName string)\n");
std::printf(" --gen-grp <wgrp-base> [name]\n");
std::printf(" Emit .wgrp 3 5-man comps (Classic 1T/1H/3D, Heavy-Heal 1T/2H/2D, Roleless 5D speed run)\n");
std::printf(" --gen-grp-raid10 <wgrp-base> [name]\n");
std::printf(" Emit .wgrp 3 10-man raid comps (Standard 2T/3H/5D, HealingHeavy 2T/4H/4D, MeleeStack 1T/2H/7D for melee-cleave fights)\n");
std::printf(" --gen-grp-raid25 <wgrp-base> [name]\n");
std::printf(" Emit .wgrp 3 25-man raid comps (Standard 2T/6H/17D, HealingHeavy 1T/8H/16D, ZergDPS 0T/4H/21D)\n");
std::printf(" --info-wgrp <wgrp-base>\n");
std::printf(" Print WGRP entries (id / map / diff / required tanks/heals/dps / min/max party / spec gate / name)\n");
std::printf(" --validate-wgrp <wgrp-base>\n");
std::printf(" Static checks: id+name+mapId required, min<=max, role sum<=maxParty (else unfulfillable), no duplicate ids; warns on non-standard size, role sum<minParty, requiredTanks=0 (tank-immune fights)\n");
std::printf(" --export-wgrp-json <wgrp-base> [out.json]\n");
std::printf(" Export binary .wgrp to a human-editable JSON sidecar (defaults to <base>.wgrp.json; sizeCategory string is informational, ignored on import)\n");
std::printf(" --import-wgrp-json <json-path> [out-base]\n");
std::printf(" Import a .wgrp.json sidecar back into binary .wgrp (requireSpec accepts bool OR int)\n");
std::printf(" --gen-hrt <whrt-base> [name]\n");
std::printf(" Emit .whrt 4 starter-city innkeepers (Stormwind / Ironforge / Orgrimmar / Thunder Bluff) faction-gated\n");
std::printf(" --gen-hrt-capitals <whrt-base> [name]\n");
std::printf(" Emit .whrt 6 capital-hall bind clerks (Stormwind / Ironforge / Darnassus / Orgrimmar / Undercity / Thunder Bluff)\n");
std::printf(" --gen-hrt-inns <whrt-base> [name]\n");
std::printf(" Emit .whrt 8 starter-zone inns (Goldshire / Brill / Razor Hill / Bloodhoof Village / Kharanos / Aldrassil / Shadowglen / Sun Rock Retreat)\n");
std::printf(" --info-whrt <whrt-base> [--json]\n");
std::printf(" Print WHRT entries (id / map / area / faction / kind / npc / levelMin / name)\n");
std::printf(" --validate-whrt <whrt-base> [--json]\n");
std::printf(" Static checks: id+name required, factionMask 1..3, bindKind 0..5, no duplicate ids; warns on (0,0,0) position, Inn with npcId=0, Quest with levelMin=0\n");
std::printf(" --export-whrt-json <whrt-base> [out.json]\n");
std::printf(" Export binary .whrt to a human-editable JSON sidecar (defaults to <base>.whrt.json; emits both bindKind/factionMask ints AND name strings)\n");
std::printf(" --import-whrt-json <json-path> [out-base]\n");
std::printf(" Import a .whrt.json sidecar back into binary .whrt (accepts bindKind int OR \"inn\"/\"capital\"/\"quest\"/\"guild\"/\"specialport\"/\"faction\"; factionMask int OR \"alliance\"/\"horde\"/\"both\")\n");
std::printf(" --gen-scb <wscb-base> [name]\n");
std::printf(" Emit .wscb 4 login-MOTD entries (welcome banner / patch notes summary / Discord link / forum link)\n");
std::printf(" --gen-scb-maintenance <wscb-base> [name]\n");
std::printf(" Emit .wscb 3 RaidWarning entries for restart countdown (15min / 5min / 60sec, intervalSeconds=0 — fired by external scheduler)\n");
std::printf(" --gen-scb-helptips <wscb-base> [name]\n");
std::printf(" Emit .wscb 6 HelpTip channel rotating tips on 600s cycle (talents / mounts / auction / professions / dungeon finder / hearthstone, level-gated)\n");
std::printf(" --info-wscb <wscb-base> [--json]\n");
std::printf(" Print WSCB entries (id / channel / faction / interval / level range / name)\n");
std::printf(" --validate-wscb <wscb-base> [--json]\n");
std::printf(" Static checks: id+name+messageText required, factionFilter 1..3, channelKind 0..4, min<=max level, no duplicate ids, intervalSeconds>=10 (errors below); warns on interval>0 with login/MOTD (timer ignored), interval<60 (spammy), text>255 chars (truncation)\n");
std::printf(" --export-wscb-json <wscb-base> [out.json]\n");
std::printf(" Export binary .wscb to a human-editable JSON sidecar (defaults to <base>.wscb.json; emits both channelKind/factionFilter ints AND name strings)\n");
std::printf(" --import-wscb-json <json-path> [out-base]\n");
std::printf(" Import a .wscb.json sidecar back into binary .wscb (channelKind int OR \"login\"/\"system\"/\"raidwarning\"/\"motd\"/\"helptip\"; factionFilter int OR \"alliance\"/\"horde\"/\"both\")\n");
std::printf(" --gen-cmg <wcmg-base> [name]\n");
std::printf(" Emit .wcmg 1 Warrior 3-stance mutex group (Battle / Defensive / Berserker)\n");
std::printf(" --gen-cmg-druid <wcmg-base> [name]\n");
std::printf(" Emit .wcmg 2 Druid mutex groups (5 ground shapeshift forms + 2 flight forms — separate buckets so flight isn't broken by Cat Form)\n");
std::printf(" --gen-cmg-all <wcmg-base> [name]\n");
std::printf(" Emit .wcmg 4 cross-class mutex groups (Warrior stances + Hunter aspects + DK presences + Druid forms — one representative group per mutex-having class)\n");
std::printf(" --info-wcmg <wcmg-base> [--json]\n");
std::printf(" Print WCMG entries (id / classMask / category / exclusive / member count / name) plus per-group spell ID list\n");
std::printf(" --validate-wcmg <wcmg-base> [--json]\n");
std::printf(" Static checks: id+name+classMask required, categoryKind 0..5, members[] non-empty, no duplicate spellIds within a group, no duplicate groupIds, no spellId in two exclusive groups (undecidable mutex); warns on single-member groups\n");
std::printf(" --export-wcmg-json <wcmg-base> [out.json]\n");
std::printf(" Export binary .wcmg to a human-editable JSON sidecar (defaults to <base>.wcmg.json; emits both categoryKind int AND name string; members[] as JSON array of spell IDs)\n");
std::printf(" --import-wcmg-json <json-path> [out-base]\n");
std::printf(" Import a .wcmg.json sidecar back into binary .wcmg (categoryKind int OR \"stance\"/\"form\"/\"aspect\"/\"presence\"/\"posture\"/\"sigil\"; exclusive bool OR int)\n");
std::printf(" --gen-msp <wmsp-base> [name]\n");
std::printf(" Emit .wmsp 1 default realm entry (WoweeMain — WotLK 3.3.5a Normal PvE Public Medium)\n");
std::printf(" --gen-msp-cluster <wmsp-base> [name]\n");
std::printf(" Emit .wmsp 3-realm cluster (WoweePvE/PvP/RP on same login address — players pick rule-set without changing login)\n");
std::printf(" --gen-msp-multi <wmsp-base> [name]\n");
std::printf(" Emit .wmsp 4 progression realms across all expansion gates (Vanilla 1.12.1 build 5875 / TBC 2.4.3 build 8606 / WotLK 3.3.5a build 12340 / Cata 4.3.4 build 15595)\n");
std::printf(" --info-wmsp <wmsp-base> [--json]\n");
std::printf(" Print WMSP entries (id / type / category / expansion / population / cap / GM-only / build / address / name)\n");
std::printf(" --validate-wmsp <wmsp-base> [--json]\n");
std::printf(" Static checks: id+name+address required, realmType in {0,1,4,6,8}, realmCategory 0..3, expansion 0..3, population 0..4, characterCap>0, no duplicate ids OR names; warns on no-port address, build<5000\n");
std::printf(" --export-wmsp-json <wmsp-base> [out.json]\n");
std::printf(" Export binary .wmsp to a human-editable JSON sidecar (defaults to <base>.wmsp.json; emits all 4 enums as both int AND name string + a versionString \"x.y.z\" convenience field)\n");
std::printf(" --import-wmsp-json <json-path> [out-base]\n");
std::printf(" Import a .wmsp.json sidecar back into binary .wmsp (realmType int OR \"normal\"/\"pvp\"/\"rp\"/\"rppvp\"/\"test\"; realmCategory \"public\"/\"private\"/\"beta\"/\"dev\"; expansion \"vanilla\"/\"tbc\"/\"wotlk\"/\"cata\"; population \"low\"/\"medium\"/\"high\"/\"full\"/\"locked\")\n");
std::printf(" --gen-emo <wemo-base> [name]\n");
std::printf(" Emit .wemo 8 universal social emotes (wave / bow / laugh / cheer / cry / sleep / kneel / applaud)\n");
std::printf(" --gen-emo-combat <wemo-base> [name]\n");
std::printf(" Emit .wemo 5 combat-themed emotes (roar / threaten / charge / victory / surrender)\n");
std::printf(" --gen-emo-rp <wemo-base> [name]\n");
std::printf(" Emit .wemo 6 roleplay emotes (bonk / ponder / soothe / plead / shoo / scoff)\n");
std::printf(" --info-wemo <wemo-base> [--json]\n");
std::printf(" Print WEMO entries (id / slash command / kind / animation / sound / sex filter / TTS hint)\n");
std::printf(" --validate-wemo <wemo-base> [--json]\n");
std::printf(" Static checks: id+name+slashCommand required, slash must be lowercase + no leading '/' (chat parser case-folds before lookup), emoteKind 0..3, sex 0..2, ttsHint 0..3, no duplicate ids OR commands; warns on targetMessage with !=2 %%s tokens, noTargetMessage with !=1\n");
std::printf(" --export-wemo-json <wemo-base> [out.json]\n");
std::printf(" Export binary .wemo to a human-editable JSON sidecar (defaults to <base>.wemo.json; emits all 3 enums as both int AND name string)\n");
std::printf(" --import-wemo-json <json-path> [out-base]\n");
std::printf(" Import a .wemo.json sidecar back into binary .wemo (emoteKind int OR \"social\"/\"combat\"/\"roleplay\"/\"system\"; sex int OR \"both\"/\"male\"/\"female\"; ttsHint int OR \"talk\"/\"whisper\"/\"yell\"/\"silent\")\n");
std::printf(" --gen-bab <wbab-base> [name]\n");
std::printf(" Emit .wbab 4 Mage Arcane Intellect rank chain (R1 +3 Int -> R4 +25 Int) with explicit prev/nextRankId edges\n");
std::printf(" --gen-bab-druid <wbab-base> [name]\n");
std::printf(" Emit .wbab 5 Druid Mark of the Wild rank chain (R1 +3 stats -> R5 +18 stats) with explicit prev/nextRankId edges\n");
std::printf(" --gen-bab-raid <wbab-base> [name]\n");
std::printf(" Emit .wbab 6 max-rank standalone raid buffs (Mark of the Wild R7 / Prayer of Fortitude R4 / Arcane Brilliance R2 / Greater Blessing of Kings / Battle Shout R9 / Trueshot Aura) — one per buffing class\n");
std::printf(" --info-wbab <wbab-base> [--json]\n");
std::printf(" Print WBAB entries (id / spellId / classMask / target mask / stat kind / rank / amount / duration / prev+next rank ids / name)\n");
std::printf(" --validate-wbab <wbab-base> [--json]\n");
std::printf(" Static checks: id+name+spellId+castClassMask+targetTypeMask required, statBonusKind 0..9 OR 255, no duplicate ids, no self-referencing rank edges, all next/prev IDs resolve to existing entries, AND back-edges symmetric (A.next=B implies B.prev=A); warns on rank=0, maxStackCount=0\n");
std::printf(" --export-wbab-json <wbab-base> [out.json]\n");
std::printf(" Export binary .wbab to a human-editable JSON sidecar (defaults to <base>.wbab.json; emits statBonusKind as int+name and targetTypeMask as both int AND \"self+party+raid\" join string)\n");
std::printf(" --import-wbab-json <json-path> [out-base]\n");
std::printf(" Import a .wbab.json sidecar back into binary .wbab (statBonusKind int OR \"stamina\"/\"intellect\"/\"spirit\"/\"allstats\"/\"armor\"/\"spellpower\"/\"attackpower\"/\"critrating\"/\"hasterating\"/\"manaregen\"/\"other\"; targetTypeMask int OR \"+\"-joined tokens \"self\"/\"party\"/\"raid\"/\"friendly\")\n");
std::printf(" --gen-tbd <wtbd-base> [name]\n");
std::printf(" Emit .wtbd 4 Alliance-themed system tabards (Lion / DwarvenHammer / KulTirasAnchor / HighlordSword)\n");
std::printf(" --gen-tbd-horde <wtbd-base> [name]\n");
std::printf(" Emit .wtbd 4 Horde-themed system tabards (OrgrimmarWolfhead / BarrensCrossedAxes / ForsakenSkull / SilvermoonPyramid)\n");
std::printf(" --gen-tbd-faction <wtbd-base> [name]\n");
std::printf(" Emit .wtbd 6 faction-rep tabards (Argent Crusade / Ebon Blade / Sons of Hodir / Wyrmrest / Kalu'ak / Frenzyheart)\n");
std::printf(" --info-wtbd <wtbd-base> [--json]\n");
std::printf(" Print WTBD entries (id / bg-pattern / border / emblem / guild / approval state / name)\n");
std::printf(" --validate-wtbd <wtbd-base> [--json]\n");
std::printf(" Static checks: id+name required, backgroundPattern 0..4, borderPattern 0..3, no duplicate ids; warns on emblemId>1023, alpha=0 on any color layer (transparent), and emblem-vs-background color similarity (squared RGB distance < 1500 — emblem unreadable)\n");
std::printf(" --export-wtbd-json <wtbd-base> [out.json]\n");
std::printf(" Export binary .wtbd to a human-editable JSON sidecar (defaults to <base>.wtbd.json; emits both backgroundPattern/borderPattern ints AND name strings; all 3 colors as 0xAARRGGBB uint32)\n");
std::printf(" --import-wtbd-json <json-path> [out-base]\n");
std::printf(" Import a .wtbd.json sidecar back into binary .wtbd (backgroundPattern int OR \"solid\"/\"gradient\"/\"chevron\"/\"quartered\"/\"starburst\"; borderPattern int OR \"none\"/\"thin\"/\"thick\"/\"decorative\"; isApproved bool OR int)\n");
std::printf(" --gen-spm <wspm-base> [name]\n");
std::printf(" Emit .wspm 4 mage AoE ground markers (Blizzard / Flamestrike / BlastWave ring / Frost Nova ring)\n");
std::printf(" --gen-spm-raid <wspm-base> [name]\n");
std::printf(" Emit .wspm 5 boss-arena hazard zones (Putricide poison pool / Sindragosa frost tomb / Saurfang Mark zone / Putricide shadow puddle / Marrowgar Bone Storm)\n");
std::printf(" --gen-spm-env <wspm-base> [name]\n");
std::printf(" Emit .wspm 3 environmental ground effects (Wintergrasp lightning / Silithus sandstorm cone / open-world blizzard zone)\n");
std::printf(" --info-wspm <wspm-base> [--json]\n");
std::printf(" Print WSPM entries (id / spell / radius / duration / tick interval / fade mode / stack-flag / destroy-on-cancel / name)\n");
std::printf(" --validate-wspm <wspm-base> [--json]\n");
std::printf(" Static checks: id+name+spellId+texturePath required, radius>0, edgeFadeMode 0..2, no duplicate markerIds, no duplicate spellIds (spell-cast lookup ambiguity); warns on radius>100yd, tickIntervalMs<100ms (perf risk for stackable), decalColor alpha=0 (invisible)\n");
std::printf(" --export-wspm-json <wspm-base> [out.json]\n");
std::printf(" Export binary .wspm to a human-editable JSON sidecar (defaults to <base>.wspm.json; emits edgeFadeMode as both int AND name string; radius+duration as floats; decalColor as 0xAARRGGBB uint32)\n");
std::printf(" --import-wspm-json <json-path> [out-base]\n");
std::printf(" Import a .wspm.json sidecar back into binary .wspm (edgeFadeMode int OR \"hard\"/\"softedge\"/\"pulse\"; stackable/destroyOnCancel bool OR int)\n");
std::printf(" --gen-ldn <wldn-base> [name]\n");
std::printf(" Emit .wldn 5 LevelReach milestone notifications (level 20 mounts / 30 talent reset / 40 epic mount / 60 flying / 80 endgame)\n");
std::printf(" --gen-ldn-account <wldn-base> [name]\n");
std::printf(" Emit .wldn 4 ItemAcquired/ZoneEntered/SpellLearned/QuestComplete notifications (first mail tutorial / Stormwind auction tip / dual-spec activation / transmog vendor unlock)\n");
std::printf(" --gen-ldn-rep <wldn-base> [name]\n");
std::printf(" Emit .wldn 3 FactionStanding milestone notifications (Honored 9000 / Revered 21000 / Exalted 42000 with the Argent Crusade)\n");
std::printf(" --info-wldn <wldn-base> [--json]\n");
std::printf(" Print WLDN entries (id / triggerKind / triggerValue / channel / faction filter / minTimePlayed / name)\n");
std::printf(" --validate-wldn <wldn-base> [--json]\n");
std::printf(" Static checks: id+name+messageText required, triggerKind 0..5, channelKind 0..4, factionFilter 1..3, no duplicate ids; per-trigger triggerValue ranges (LevelReach 1-80, FactionStanding +-42000, ItemAcquired/QuestComplete/SpellLearned/ZoneEntered > 0)\n");
std::printf(" --export-wldn-json <wldn-base> [out.json]\n");
std::printf(" Export binary .wldn to a human-editable JSON sidecar (defaults to <base>.wldn.json; emits all 3 enums as both int AND name string; triggerValue as signed int32)\n");
std::printf(" --import-wldn-json <json-path> [out-base]\n");
std::printf(" Import a .wldn.json sidecar back into binary .wldn (triggerKind int OR \"levelreach\"/\"factionstanding\"/\"itemacquired\"/\"questcomplete\"/\"spelllearned\"/\"zoneentered\"; channelKind \"raidwarning\"/\"systemmsg\"/\"subtitle\"/\"tutorial\"/\"motdappend\"; factionFilter \"alliance\"/\"horde\"/\"both\")\n");
std::printf(" --gen-cre <wcre-base> [name]\n");
std::printf(" Emit .wcre 5 raid-boss resist profiles (Ragnaros 100%% fire-immune / Vael 50%% all schools / Hakkar arcane-immune / KT shadow-immune / Onyxia fire+frost partial)\n");
std::printf(" --gen-cre-elites <wcre-base> [name]\n");
std::printf(" Emit .wcre 5 elite mid-tier profiles with single-school resists (water elemental fire / stone giant nature / scarlet priest holy / dustwind arcane / frostwolf frost)\n");
std::printf(" --gen-cre-immune <wcre-base> [name]\n");
std::printf(" Emit .wcre 4 CC-immunity test profiles (treant root-immune / alpha worg stun-immune / acolyte silence-immune / risen construct fear+charm+poly immune)\n");
std::printf(" --info-wcre <wcre-base> [--json]\n");
std::printf(" Print WCRE entries (id / creatureEntry / 6 school resists / phys%% / school-immune mask / CC-immune token list / name)\n");
std::printf(" --validate-wcre <wcre-base> [--json]\n");
std::printf(" Static checks: id+name+creatureEntry required, no duplicate resistIds OR creatureEntries (damage-calc lookup ambiguity); warns on resist<-100 (extreme negative >2x dmg taken), physicalResistPct>75 (clamped at runtime), schoolImmunityMask reserved bits 0xC0 set\n");
std::printf(" --export-wcre-json <wcre-base> [out.json]\n");
std::printf(" Export binary .wcre to a human-editable JSON sidecar (defaults to <base>.wcre.json; emits ccImmunityMask as both raw uint16 AND \"+\"-joined name string \"root+stun+fear\" / \"all\" / \"none\")\n");
std::printf(" --import-wcre-json <json-path> [out-base]\n");
std::printf(" Import a .wcre.json sidecar back into binary .wcre (ccImmunityMask int OR token string \"all\"/\"none\"/\"+\"-joined from {root,snare,stun,fear,sleep,silence,charm,disarm,polymorph,banish,knockback,interrupt,taunt,bleed})\n");
std::printf(" --gen-ptt <wptt-base> [name]\n");
std::printf(" Emit .wptt 6 Ferocity (DPS) Hunter pet talents with grid placement + prereq chains (CobraReflexes / SerpentSwiftness / SpikedCollar / BoarsSpeed / SpidersBite / Rabid)\n");
std::printf(" --gen-ptt-cunning <wptt-base> [name]\n");
std::printf(" Emit .wptt 5 Cunning (utility) Hunter pet talents (Dash / OwlsFocus / RoarOfRecovery / Cornered / HeartOfThePhoenix)\n");
std::printf(" --gen-ptt-tenacity <wptt-base> [name]\n");
std::printf(" Emit .wptt 5 Tenacity (tank) Hunter pet talents (Charge / GreatStamina / Thunderstomp / Taunt / LastStand)\n");
std::printf(" --info-wptt <wptt-base> [--json]\n");
std::printf(" Print WPTT entries (id / tree / tier / column / max ranks / prereq talentId / loyalty req / name) plus per-talent rank-spell IDs\n");
std::printf(" --validate-wptt <wptt-base> [--json]\n");
std::printf(" Static checks: id+name required, treeKind 0..2, tier 0..6, column 0..2, maxRank 1..5, no duplicate talentIds, no two talents in same (tree,tier,col) cell, no self-referencing prereqs, prereqs resolve to existing entries IN SAME TREE at EARLIER TIER, spellIdsByRank.size() == maxRank, no zero-spell-id within array\n");
std::printf(" --export-wptt-json <wptt-base> [out.json]\n");
std::printf(" Export binary .wptt to a human-editable JSON sidecar (defaults to <base>.wptt.json; emits treeKind as both int AND name string; spellIdsByRank as a JSON array of spell IDs)\n");
std::printf(" --import-wptt-json <json-path> [out-base]\n");
std::printf(" Import a .wptt.json sidecar back into binary .wptt (treeKind int OR \"cunning\"/\"ferocity\"/\"tenacity\")\n");
std::printf(" --gen-hrd <whrd-base> [name]\n");
std::printf(" Emit .whrd 5 WotLK 5-man Heroic scalings (Utgarde Keep / Nexus / Azjol-Nerub / Ahn'kahet / Drak'Tharon — +13 ilvl, 2x Emblem of Heroism)\n");
std::printf(" --gen-hrd-raid25 <whrd-base> [name]\n");
std::printf(" Emit .whrd 4 WotLK 25H raid scalings (Naxx +13 / EoE +13 / Ulduar +26 / ICC +26 ilvl, 1.5x rare drop chance, +1 Emblem of Conquest/Triumph/Frost)\n");
std::printf(" --gen-hrd-cm <whrd-base> [name]\n");
std::printf(" Emit .whrd 3 challenge-mode tier scalings (Bronze +13/Silver +20/Gold +26 ilvl) — anachronistic for WotLK but useful template for custom-server backports\n");
std::printf(" --info-whrd <whrd-base> [--json]\n");
std::printf(" Print WHRD entries (id / map / difficulty / +ilvl / bonus quality %% / drop multiplier / token id / extra emblems / name)\n");
std::printf(" --validate-whrd <whrd-base> [--json]\n");
std::printf(" Static checks: id+name required, difficultyId>0 (Normal=0 by convention), bonusQualityChance<=10000 basis points, dropChanceMultiplier>0, no duplicate scalingIds, no two scalings binding the same (mapId,difficultyId) tuple unless mapId=0 wildcard; warns on negative ilvlDelta (Heroic worse than Normal?), ilvl>50 (beyond canonical range), drop multiplier>10x\n");
std::printf(" --export-whrd-json <whrd-base> [out.json]\n");
std::printf(" Export binary .whrd to a human-editable JSON sidecar (defaults to <base>.whrd.json; emits bonusQualityChance as both raw basis points AND derived bonusQualityPct float convenience field)\n");
std::printf(" --import-whrd-json <json-path> [out-base]\n");
std::printf(" Import a .whrd.json sidecar back into binary .whrd (bonusQualityChance accepts raw basis points int OR bonusQualityPct float — converts pct *100 -> basis points; itemLevelDelta is signed int16; dropChanceMultiplier is float)\n");
std::printf(" --gen-rpr <wrpr-base> [name]\n");
std::printf(" Emit .wrpr 4 Argent Crusade reputation tiers (Friendly 3000 / Honored 9000 / Revered 21000 / Exalted 42000) with progressive item + recipe unlocks plus tabard at Honored and Argent Charger mount at Exalted\n");
std::printf(" --gen-rpr-kaluak <wrpr-base> [name]\n");
std::printf(" Emit .wrpr 4 Kalu'ak fishing-themed reputation tiers with cooking recipe unlocks (Sweet Potato / Imperial Manta Steak / Pygmy Suit cosmetic at Exalted)\n");
std::printf(" --gen-rpr-accord <wrpr-base> [name]\n");
std::printf(" Emit .wrpr 3 Wyrmrest Accord tiers showcasing tabard + mount unlock flags (Honored items / Revered tabard / Exalted Reins of the Red Drake)\n");
std::printf(" --info-wrpr <wrpr-base> [--json]\n");
std::printf(" Print WRPR entries (id / faction / standing / standing tier / discount %% / tabard flag / mount flag / item count / recipe count / name)\n");
std::printf(" --validate-wrpr <wrpr-base> [--json]\n");
std::printf(" Static checks: id+name+factionId required, minStanding [-42000, 42000], no zero item/recipe IDs, no duplicate tierIds, no two tiers binding same (factionId,minStanding) tuple; warns on discountPct>20%% (exceeds Exalted cap), and PER-FACTION non-monotonic discount progression (higher standing should never give worse discount)\n");
std::printf(" --export-wrpr-json <wrpr-base> [out.json]\n");
std::printf(" Export binary .wrpr to a human-editable JSON sidecar (defaults to <base>.wrpr.json; emits both unlockedItemIds and unlockedRecipeIds as JSON arrays of IDs; standingTier derived label \"Friendly/Honored/Revered/Exalted\" added for readability)\n");
std::printf(" --import-wrpr-json <json-path> [out-base]\n");
std::printf(" Import a .wrpr.json sidecar back into binary .wrpr (grantsTabard/grantsMount accept bool OR int; both unlock arrays serialize as plain JSON int arrays; standingTier label is informational only — minStanding int is authoritative)\n");
std::printf(" --gen-mnl <wmnl-base> [name]\n");
std::printf(" Emit .wmnl 3 Stormwind minimap levels (Old Town Z 0-80 / Keep Approach Z 80-130 / Throne Room Z 130-200) at mapId 0 / areaId 1519\n");
std::printf(" --gen-mnl-dalaran <wmnl-base> [name]\n");
std::printf(" Emit .wmnl 4 Dalaran minimap levels (Sewers / Street / Above Street / Floating Cathedral) — Wrath's most vertical city\n");
std::printf(" --gen-mnl-undercity <wmnl-base> [name]\n");
std::printf(" Emit .wmnl 5 Undercity minimap levels (Sewer / Canal / Outer Ring / Inner Ring / Throne Room) — deepest layered city in EK\n");
std::printf(" --info-wmnl <wmnl-base> [--json]\n");
std::printf(" Print WMNL entries (id / map / area / levelIndex / Z-range / displayName / name)\n");
std::printf(" --validate-wmnl <wmnl-base> [--json]\n");
std::printf(" Static checks: id+name+areaId required, minZ<maxZ, no duplicate levelIds; per-area: no two levels at same levelIndex (picker UI conflict), no Z-range overlap between sibling levels (minimap flicker in overlap region); warns on empty texturePath (untextured layer) or empty displayName (blank picker entry)\n");
std::printf(" --export-wmnl-json <wmnl-base> [out.json]\n");
std::printf(" Export binary .wmnl to a human-editable JSON sidecar (defaults to <base>.wmnl.json; minZ/maxZ as floats, all string fields as plain strings)\n");
std::printf(" --import-wmnl-json <json-path> [out-base]\n");
std::printf(" Import a .wmnl.json sidecar back into binary .wmnl (no enums to coerce — pure positional/textual data; minZ/maxZ float-precise round-trip)\n");
std::printf(" --gen-pcr <wpcr-base> [name]\n");
std::printf(" Emit .wpcr 5 Hunter pet care actions (Revive Pet / Mend Pet / Feed Pet / Dismiss Pet / Tame Beast)\n");
std::printf(" --gen-pcr-stable <wpcr-base> [name]\n");
std::printf(" Emit .wpcr 4 stable-master actions (Stable Slot Purchase 500g / Untrain Pet 1g+ramp / Rename Pet / Abandon Pet permanent)\n");
std::printf(" --gen-pcr-warlock <wpcr-base> [name]\n");
std::printf(" Emit .wpcr 4 Warlock minion summons (Imp 6.5s / Voidwalker 10s / Succubus 10s / Felhunter 10s, all 1 Soul Shard)\n");
std::printf(" --info-wpcr <wpcr-base> [--json]\n");
std::printf(" Print WPCR entries (id / spellId / classFilter / actionKind / happiness / pet-required / stable-NPC required / cost copper / reagent / cast ms / name)\n");
std::printf(" --validate-wpcr <wpcr-base> [--json]\n");
std::printf(" Static checks: id+name+classFilter required, actionKind 0..10, no duplicate actionIds, per-kind constraints (Tame and Summon REQUIRE no active pet, requiresPet must be 0); warns on happinessRestore outside +/-25, Stable kind without requiresStableNPC, Tame kind without cooldown (canonically 15 sec)\n");
std::printf(" --export-wpcr-json <wpcr-base> [out.json]\n");
std::printf(" Export binary .wpcr to a human-editable JSON sidecar (defaults to <base>.wpcr.json; emits actionKind as both int AND name string; requiresPet/requiresStableNPC as bool)\n");
std::printf(" --import-wpcr-json <json-path> [out-base]\n");
std::printf(" Import a .wpcr.json sidecar back into binary .wpcr (actionKind int OR \"revive\"/\"mend\"/\"feed\"/\"dismiss\"/\"tame\"/\"beastlore\"/\"stable\"/\"untrain\"/\"rename\"/\"abandon\"/\"summon\"; bool fields accept bool OR int)\n");
std::printf(" --gen-mvc <wmvc-base> [name]\n");
std::printf(" Emit .wmvc 5 WotLK intro cinematic credit blocks (Production / Direction / Music / Voice Cast / Special Thanks) — first format with variable-length string arrays\n");
std::printf(" --gen-mvc-quest <wmvc-base> [name]\n");
std::printf(" Emit .wmvc 3 quest cinematic credit blocks (Quest Designer / Voice / Cinematic Director)\n");
std::printf(" --gen-mvc-starter <wmvc-base> [name]\n");
std::printf(" Emit .wmvc 4 starter cinematic credit blocks (Production / Engineering / Art / Special Thanks) — generic template\n");
std::printf(" --info-wmvc <wmvc-base> [--json]\n");
std::printf(" Print WMVC entries (id / cinematicId / category / orderHint / line count / name) plus per-block credit lines\n");
std::printf(" --validate-wmvc <wmvc-base> [--json]\n");
std::printf(" Static checks: id+name+cinematicId required, category 0..6, lines[] non-empty, no duplicate rollIds, no two blocks at same (cinematicId, orderHint) slot (would render in non-deterministic order); warns on empty lines (blank renders) or lines > 80 chars (text-buffer wrap)\n");
std::printf(" --export-wmvc-json <wmvc-base> [out.json]\n");
std::printf(" Export binary .wmvc to a human-editable JSON sidecar (defaults to <base>.wmvc.json; emits category as both int AND name string; lines[] as JSON string array)\n");
std::printf(" --import-wmvc-json <json-path> [out-base]\n");
std::printf(" Import a .wmvc.json sidecar back into binary .wmvc (category int OR \"production\"/\"music\"/\"audio\"/\"engineering\"/\"art\"/\"voice\"/\"special\"; lines[] is a JSON array of strings — directly editable to add/remove credit lines without binary tooling)\n");
std::printf(" --gen-spv <wspv-base> [name]\n");
std::printf(" Emit .wspv 4 stance-conditional Warrior spell variants (Heroic Strike Berserker / Heroic Strike Battle / Mocking Blow Defensive / Pummel Berserker)\n");
std::printf(" --gen-spv-talent <wspv-base> [name]\n");
std::printf(" Emit .wspv 4 talent-modified spell variants (Frostbolt + Brain Freeze instant / Lava Burst + Flame Shock auto-crit / Earth Shield + Improved bonus heal / Ferocious Bite + Berserk)\n");
std::printf(" --gen-spv-racial <wspv-base> [name]\n");
std::printf(" Emit .wspv 4 racial spell variants (Stoneform Dwarf / War Stomp Tauren / Berserking Troll / Will of the Forsaken)\n");
std::printf(" --info-wspv <wspv-base> [--json]\n");
std::printf(" Print WSPV entries (id / baseSpellId / variantSpellId / conditionKind / conditionValue / priority / name)\n");
std::printf(" --validate-wspv <wspv-base> [--json]\n");
std::printf(" Static checks: id+name+baseSpellId+variantSpellId required, conditionKind 0..5, no duplicate variantIds, no two variants binding the same (baseSpell, conditionKind, conditionValue, priority) tuple (would tie at runtime and resolve non-deterministically); warns on conditionValue=0 (always-zero default match — gate becomes no-op)\n");
std::printf(" --export-wspv-json <wspv-base> [out.json]\n");
std::printf(" Export binary .wspv to a human-editable JSON sidecar (defaults to <base>.wspv.json; emits conditionKind as both int AND name string; conditionValue stays as raw uint32 — its semantics depend on conditionKind so no general-purpose pretty-printing)\n");
std::printf(" --import-wspv-json <json-path> [out-base]\n");
std::printf(" Import a .wspv.json sidecar back into binary .wspv (conditionKind int OR \"stance\"/\"form\"/\"talent\"/\"race\"/\"equippedweapon\"/\"auraactive\")\n");
std::printf(" --gen-vox <wvox-base> [name]\n");
std::printf(" Emit .wvox 5 questgiver voice clips (Greeting / QuestStart / QuestProgress / QuestComplete / Goodbye)\n");
std::printf(" --gen-vox-boss <wvox-base> [name]\n");
std::printf(" Emit .wvox 6 boss voice clips with phase milestones (Aggro / 75%% Phase / 50%% Phase / 25%% Phase / Special Mechanic / Death) — Lich King example\n");
std::printf(" --gen-vox-vendor <wvox-base> [name]\n");
std::printf(" Emit .wvox 4 vendor voice clips (Greeting / Buy / Sell / Goodbye)\n");
std::printf(" --info-wvox <wvox-base> [--json]\n");
std::printf(" Print WVOX entries (id / npcId / eventKind / gender / variant / duration ms / volume dB / name) plus per-entry transcript\n");
std::printf(" --validate-wvox <wvox-base> [--json]\n");
std::printf(" Static checks: id+name+npcId required, eventKind 0..8, genderHint 0..2, audioPath non-empty, no duplicate voiceIds, no two clips at same (npcId, eventKind, variantIndex) triple (random pick at trigger time would be ambiguous); warns on durationMs=0 (subtitle sync impossible), volumeDb outside [-20,+6] (clip risk), empty transcript (TTS+chat-bubble blank)\n");
std::printf(" --export-wvox-json <wvox-base> [out.json]\n");
std::printf(" Export binary .wvox to a human-editable JSON sidecar (defaults to <base>.wvox.json; emits eventKind and genderHint as both int AND name string; transcript as plain string for accessibility editing)\n");
std::printf(" --import-wvox-json <json-path> [out-base]\n");
std::printf(" Import a .wvox.json sidecar back into binary .wvox (eventKind int OR \"greeting\"/\"aggro\"/\"death\"/\"queststart\"/\"questprogress\"/\"questcomplete\"/\"goodbye\"/\"special\"/\"phase\"; genderHint int OR \"male\"/\"female\"/\"both\"; volumeDb is signed int8)\n");
std::printf(" --gen-trd <wtrd-base> [name]\n");
std::printf(" Emit .wtrd 4 standard trade rules (Soulbound Forbidden / Quest items Forbidden / 2hr SoulboundException for raid drops / SameFactionOnly default)\n");
std::printf(" --gen-trd-admin <wtrd-base> [name]\n");
std::printf(" Emit .wtrd 3 server-admin trade rules (GM-only escrow / AccountBound own-character transfer / CrossFactionAllowed at level 80 for custom servers)\n");
std::printf(" --gen-trd-rmt <wtrd-base> [name]\n");
std::printf(" Emit .wtrd 4 anti-RMT trade rules (LowLevelGoldCap 10g / NewAccountValueCap 500g for accounts <30 days / HighValueAuditLog for trades >1000g / FirstTradeMandatoryDelay 24hr)\n");
std::printf(" --info-wtrd <wtrd-base> [--json]\n");
std::printf(" Print WTRD entries (id / ruleKind / targetingFilter / level requirement / priority / category bitmask / gold cap / name)\n");
std::printf(" --validate-wtrd <wtrd-base> [--json]\n");
std::printf(" Static checks: id+name required, ruleKind 0..6, targetingFilter 0..4, no duplicate ruleIds, GoldEscrowMax kind requires goldEscrowMaxCopper > 0 (else self-contradicting); warns on levelRequirement > 80 (exceeds cap), GMOnly targeting with priority < 50 (would be overridden by player rules)\n");
std::printf(" --export-wtrd-json <wtrd-base> [out.json]\n");
std::printf(" Export binary .wtrd to a human-editable JSON sidecar (defaults to <base>.wtrd.json; emits both ruleKind and targetingFilter as int + name string; goldEscrowMaxCopper as uint64)\n");
std::printf(" --import-wtrd-json <json-path> [out-base]\n");
std::printf(" Import a .wtrd.json sidecar back into binary .wtrd (ruleKind int OR \"allowed\"/\"forbidden\"/\"soulboundexception\"/\"crossfactionallowed\"/\"levelgated\"/\"goldescrowmax\"/\"auditlogged\"; targetingFilter int OR \"anyplayer\"/\"samerealmonly\"/\"samefactiononly\"/\"sameaccountonly\"/\"gmonly\")\n");
std::printf(" --gen-wfl <wwfl-base> [name]\n");
std::printf(" Emit .wwfl 5 RMT/spam patterns (wts gold drop / wtb gold drop / g0ld typo-substitution replace / 1000g for drop / free gold mute) — non-profanity moderation only\n");
std::printf(" --gen-wfl-caps <wwfl-base> [name]\n");
std::printf(" Emit .wwfl 3 all-caps patterns (case-sensitive uppercase word / triple-exclamation / dollar-symbol spam)\n");
std::printf(" --gen-wfl-url <wwfl-base> [name]\n");
std::printf(" Emit .wwfl 3 URL-detection patterns (http:// / https:// / www. — replace with [link] placeholder)\n");
std::printf(" --info-wwfl <wwfl-base> [--json]\n");
std::printf(" Print WWFL entries (id / kind / severity / case-sensitive / pattern -> replacement / name)\n");
std::printf(" --validate-wwfl <wwfl-base> [--json]\n");
std::printf(" Static checks: id+name+pattern required, filterKind 0..5 OR 255 Misc, severity 0..3, no duplicate filterIds, no two filters with same pattern (preprocessor dispatch ambiguity); warns on Replace severity with empty replacement (would silently lose match — use Drop explicitly if intended)\n");
std::printf(" --export-wwfl-json <wwfl-base> [out.json]\n");
std::printf(" Export binary .wwfl to a human-editable JSON sidecar (defaults to <base>.wwfl.json; emits both filterKind and severity as int + name string; pattern and replacement as plain strings)\n");
std::printf(" --import-wwfl-json <json-path> [out-base]\n");
std::printf(" Import a .wwfl.json sidecar back into binary .wwfl (filterKind int OR \"spam\"/\"goldseller\"/\"allcaps\"/\"repeatchar\"/\"url\"/\"advertreward\"/\"misc\"; severity int OR \"warn\"/\"replace\"/\"drop\"/\"mute\"; caseSensitive accepts bool OR int)\n");
std::printf(" --catalog-pluck <wXXX-file> <id> [--json]\n");
std::printf(" Extract one entry by id from any registered catalog format. Auto-detects magic, dispatches to the per-format --info-* handler internally, then prints just the matching entry. Primary-key field is auto-detected (first *Id field, or first numeric)\n");
std::printf(" --catalog-find <directory> <id> [--magic <WXXX>] [--json]\n");
std::printf(" Search every catalog file under <directory> for an entry with the given id (recursive walk). Prints all hits as [WXXX] file:fieldName=id name. Use --magic to limit search to one format family when the same id is a primary key in multiple\n");
std::printf(" --catalog-by-name <directory> <substring> [--magic <WXXX>] [--ignore-case] [--json]\n");
std::printf(" Search every catalog file under <directory> for entries whose name contains the substring. Complements --catalog-find (id-based) and --catalog-grep (catalog-header label only). --ignore-case for fuzzy substring matching\n");
std::printf(" --catalog-id-range <directory> [--magic <WXXX>] [--json]\n");
std::printf(" For every catalog file under <directory>, print entry count, min/max primary-key id, gap count, first gap, and a recommended next id (smallest gap if any, else max+1). Useful when adding new entries without ID conflicts. --magic narrows to one format family\n");
std::printf(" --gen-weather-temperate <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: clear-dominant + occasional rain + fog (forest / grassland)\n");
std::printf(" --gen-weather-arctic <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: snow-dominant + blizzard + fog (tundra / glacier)\n");
std::printf(" --gen-weather-desert <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: clear-dominant + sandstorm (dunes / wasteland)\n");
std::printf(" --gen-weather-stormy <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: heavy rain + storm + occasional clear (coastal / monsoon)\n");
std::printf(" --gen-zone-atmosphere <zoneDir> [--name <zoneName>] [--preset default|arctic|desert|stormy|cave]\n");
std::printf(" Convenience: drop both atmosphere.wol + atmosphere.wow into <zoneDir> using a paired light/weather preset\n");
std::printf(" --info-wot <wot-base> [--json]\n");
std::printf(" Print WOT/WHM terrain metadata (tile, chunks, height range) and exit\n");
std::printf(" --info-extract <dir> [--json]\n");
std::printf(" Walk extracted asset tree and report open-format coverage and exit\n");
std::printf(" --info-extract-tree <dir>\n");
std::printf(" Hierarchical view of an extracted asset tree grouped by top-level dir + format\n");
std::printf(" --info-extract-budget <dir> [--json]\n");
std::printf(" Per-extension byte breakdown of an extract dir (sized largest-first)\n");
std::printf(" --info-png <path> [--json]\n");
std::printf(" Print PNG header (width, height, channels, bit depth) and exit\n");
std::printf(" --info-blp <path> [--json]\n");
std::printf(" Print BLP texture header (format, compression, mips, dimensions) and exit\n");
std::printf(" --info-m2 <path> [--json]\n");
std::printf(" Print proprietary M2 model metadata (verts, bones, anims, particles)\n");
std::printf(" --info-wmo <path> [--json]\n");
std::printf(" Print proprietary WMO building metadata (groups, portals, doodads)\n");
std::printf(" --info-adt <path> [--json]\n");
std::printf(" Print proprietary ADT terrain metadata (chunks, placements, textures)\n");
std::printf(" --info-jsondbc <path> [--json]\n");
std::printf(" Print JSON DBC sidecar metadata (records, fields, source) and exit\n");
std::printf(" --list-missing-sidecars <dir> [--json]\n");
std::printf(" List proprietary files lacking open-format sidecars (one per line)\n");
std::printf(" --info-zone <dir|json> [--json]\n");
std::printf(" Print zone.json fields (manifest, tiles, audio, flags) and exit\n");
std::printf(" --info-zone-overview <zoneDir> [--json]\n");
std::printf(" One-line compact zone summary (tiles, biome, counts, audio status)\n");
std::printf(" --info-project-overview <projectDir> [--json]\n");
std::printf(" One-line summary per zone in a project (single-page health check)\n");
std::printf(" --copy-project <fromDir> <toDir>\n");
std::printf(" Recursively copy a project tree (every zone subdir + manifests)\n");
std::printf(" --info-creatures <p> [--json]\n");
std::printf(" Print creatures.json summary (counts, behaviors) and exit\n");
std::printf(" --info-creatures-by-faction <p> [--json]\n");
std::printf(" Histogram of creature counts grouped by faction id\n");
std::printf(" --info-creatures-by-level <p> [--json]\n");
std::printf(" Distribution of creature levels (min/max/avg + per-level counts)\n");
std::printf(" --info-objects-by-path <p> [--json]\n");
std::printf(" Histogram of object placements grouped by model path (most-used first)\n");
std::printf(" --info-objects-by-type <p> [--json]\n");
std::printf(" M2 vs WMO breakdown plus scale distribution (min/max/avg)\n");
std::printf(" --info-objects <p> [--json]\n");
std::printf(" Print objects.json summary (counts, types, scale range) and exit\n");
std::printf(" --info-quests <p> [--json]\n");
std::printf(" Print quests.json summary (counts, rewards, chain errors) and exit\n");
std::printf(" --info-quests-by-level <p> [--json]\n");
std::printf(" Distribution of required levels across quests (min/max/avg + bar chart)\n");
std::printf(" --info-quests-by-xp <p> [--json]\n");
std::printf(" Distribution of XP rewards (min/max/avg + per-bucket histogram)\n");
std::printf(" --list-creatures <p> [--json]\n");
std::printf(" List every creature with index, name, position, level (for --remove-creature)\n");
std::printf(" --list-objects <p> [--json]\n");
std::printf(" List every object with index, type, path, position\n");
std::printf(" --list-quests <p> [--json]\n");
std::printf(" List every quest with index, title, giver, XP\n");
std::printf(" --list-quest-objectives <p> <questIdx> [--json]\n");
std::printf(" List every objective on a quest (for --remove-quest-objective)\n");
std::printf(" --list-quest-rewards <p> <questIdx> [--json]\n");
std::printf(" List XP/coin/item rewards on a quest\n");
std::printf(" --info-quest-graph-stats <p> [--json]\n");
std::printf(" Analyze quest chain graph (roots, leaves, depths, cycles, orphans)\n");
std::printf(" --info-creature <p> <idx> [--json]\n");
std::printf(" Print every field for one creature spawn (stats, behavior, AI, flags)\n");
std::printf(" --info-quest <p> <idx> [--json]\n");
std::printf(" Print every field for one quest (objectives + reward + chain in one shot)\n");
std::printf(" --info-object <p> <idx> [--json]\n");
std::printf(" Print every field for one object placement (type, path, transform)\n");
std::printf(" --info-wcp <wcp-path> [--json]\n");
std::printf(" Print WCP archive metadata (name, files) and exit\n");
std::printf(" --info-pack-budget <wcp-path> [--json]\n");
std::printf(" Per-extension byte breakdown of a WCP archive (sized largest-first)\n");
std::printf(" --info-pack-tree <wcp-path>\n");
std::printf(" Render a tree view of a WCP's directory structure with byte sizes\n");
std::printf(" --list-wcp <wcp-path> Print every file inside a WCP archive (sorted by path) and exit\n");
std::printf(" --diff-wcp <a> <b> [--json]\n");
std::printf(" Compare two WCPs file-by-file; exit 0 if identical, 1 otherwise\n");
std::printf(" --diff-zone <a> <b> [--json]\n");
std::printf(" Compare two zone dirs (creatures/objects/quests/manifest); exit 0 if identical\n");
std::printf(" --diff-glb <a> <b> [--json]\n");
std::printf(" Compare two glTF 2.0 binaries structurally; exit 0 if identical\n");
std::printf(" --diff-wom <a-base> <b-base> [--json]\n");
std::printf(" Compare two WOM models (verts, indices, bones, anims, batches, bounds)\n");
std::printf(" --diff-wob <a-base> <b-base> [--json]\n");
std::printf(" Compare two WOB buildings (groups, portals, doodads, totals)\n");
std::printf(" --diff-whm <a-base> <b-base> [--json]\n");
std::printf(" Compare two WHM/WOT terrain pairs (chunks, height range, placements)\n");
std::printf(" --diff-woc <a> <b> [--json]\n");
std::printf(" Compare two WOC collision meshes (triangles, walkable/steep counts, tile)\n");
std::printf(" --diff-jsondbc <a> <b> [--json]\n");
std::printf(" Compare two JSON DBC sidecars (format/source/recordCount/fieldCount)\n");
std::printf(" --diff-extract <a> <b> [--json]\n");
std::printf(" Compare two extracted asset directories (per-extension file count + bytes)\n");
std::printf(" --diff-checksum <a> <b> [--json]\n");
std::printf(" Diff two SHA256SUMS files; report added/removed/changed entries\n");
std::printf(" --pack-wcp <zone> [dst] Pack a zone dir/name into a .wcp archive and exit\n");
std::printf(" --unpack-wcp <wcp> [dst] Extract a WCP archive (default dst=custom_zones/) and exit\n");
std::printf(" --list-commands Print every recognized --flag, one per line, and exit\n");
std::printf(" --list-primitives [--mesh|--texture] [--json]\n");
std::printf(" Filtered list of just procedural primitive flags (--gen-mesh-*, --gen-texture-*)\n");
std::printf(" --list-packs Print every --gen-*-pack composite flag (camp, blacksmith, village, temple…)\n");
std::printf(" --info-cli-stats [--json]\n");
std::printf(" Meta-stats on the CLI surface (command count by category prefix)\n");
std::printf(" --info-cli-categories\n");
std::printf(" Group every --flag by verb prefix (gen/info/list/...) for discovery\n");
std::printf(" --info-cli-help <pattern>\n");
std::printf(" Substring-search the help text and print matching command lines\n");
std::printf(" --validate-cli-help [--json]\n");
std::printf(" Self-check: every kArgRequired flag must appear in the help text\n");
std::printf(" --gen-completion <bash|zsh>\n");
std::printf(" Print a shell-completion script for wowee_editor (source it from your rc file)\n");
std::printf(" --version Show version and format info\n\n");
std::printf("Wowee World Editor v1.0.0 — by Kelsi Davis\n");
std::printf("Novel open formats: WOT/WHM/WOM/WOB/WOC/WCP + PNG/JSON\n");
}
} // namespace cli
} // namespace editor
} // namespace wowee
Reference in a new issue View git blame Copy permalink