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("  --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-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]\n");
    std::printf("                         Walk every .wom under root, run welded watertight check; exit code = failure count (CI-friendly)\n");
    std::printf("  --audit-watertight-wob <zoneDir|projectDir> [--weld <eps>] [--json]\n");
    std::printf("                         Walk every .wob, check that EVERY group is closed (per-group weld) — interior rooms must be solid\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-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("  --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