Kelsidavis-WoWee/tools/editor/cli_help.cpp

#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("  --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