sindicate 0.10.0 → 0.12.0

package/docs/plans/world-splits-recon.json

@@ -0,0 +1,387 @@
+{
+  "summary": "Map both games' world layers for the final engine extraction",
+  "agentCount": 2,
+  "logs": [],
+  "result": {
+    "western": {
+      "summary": "WESTERN's world layer is ~6,100 lines of builder code over ~6,000 lines of data (src/world/data/). The engine (Sindicate/src/world/) already holds the leaf systems — scatter, tileManager, grass, water materials, sky/weather, collision BVH, flora, walkHumps, lampField/Glow, footprints — and western already feeds them through the established setX(content)/self-register seams (setFloraTerrain, registerHumps, setRoadNetwork, setChartWorld, setHerdTerrain...). What remains game-side is the world-BUILDING machinery: the terrain math kit + solvers (terrainData.js), the chunked heightfield + cook harness (terrain.js), the Synty kit-stamper with doors/datums (town.js), the placement/cook/occupancy machinery (zones.js), the permanent-way builder (railway.js), the chord-deck bridge stamper (bridges.js), and the World facade (world.js) whose capsule-controller half is duplicated nearly line-for-line in fable. Two files (regions.js, road.js) are dead fable-fork leftovers with zero importers in western. The extraction is factoring each file into pure machinery (engine) + county tables and policy regexes (game), guarded by the cook-fingerprint scheme (TERRAIN/ZONES_COOK_VER + FIELDS/PAINT/WATER/CROP_SIG in bin filenames) which makes behavioral drift loudly visible.",
+      "modules": [
+        {
+          "file": "/Users/nick/Sites/western/src/world/terrainData.js",
+          "lines": 1611,
+          "what": "Headless terrain math + the county's survey. The single heightAt() source of truth: base noise, mesa relief, valley cuts, lake bowls, road benches, rail formation, bridge deck holds — composed at module scope over the data tables.",
+          "mechanism": "The richest extraction target: fbm/ridged/terrace/smoothstep noise kit; chunked-AABB polyline distance indices (roadDistance, riverInfo with per-course enclosing boxes, railInfo with _railBox — all the same pattern); the bridge SPLICER (road x river segment intersection -> chord anchors -> road re-splice -> BRIDGE_SPOTS, multi-pass to fixed point); valleyCut (asymmetric banks keyed to baked curvature, point-bar shelves, single-gate core damp, road approach cone mode); fallBench (terrace stamp aimed at a bed step); the RAIL FORMATION SOLVER (survey ground -> level yards -> Lipschitz ceil/floor envelopes at MAX_GRADE -> midpoint -> diffusion vertical curves -> merge-weld spurs -> trestle gate past FILL_MAX); applyRail ownership-weighted corridor blend (1/(d/w)^8); crossing discovery + deck lift; the 5-pass river wy bake (solved PASS 0 + unsolved 1-4 machinery); waterSurfaceAt; WATER_SIG generic FNV table hasher.",
+          "content": "ROADS (16 hand-annotated polylines), TOWN/PADS anchors, RIVERS/LAKES resolved from data/waterSolved.js, baseHeight + outerRelief noise recipes (the county's bones), SEA_LEVEL/COAST_Z parked, Albion-era anchors (GUILD/MOOR/CRYPT... — fable fork residue kept for straggler imports), biome factor stubs returning 0, VILLAGE_CASTLE_ROAD back-compat alias (only dead road.js wanted it). At module end it self-registers: setRoadNetwork({roads, roadDistance}) into sindicate/systems/roadGraph.js — the pattern the whole extraction follows.",
+          "deps": "three/addons ImprovedNoise (only non-data import — stays headless), ./scale.js, data/outposts.js, data/railLine.js, data/waterSolved.js; registers into sindicate/systems/roadGraph.js.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/terrain.js",
+          "lines": 607,
+          "what": "The rendered ground: chunked vertex-painted heightfield mesh + the terrain cook, re-exporting terrainData.",
+          "mechanism": "Chunk-grid mesh builder over ONE shared height lattice with central-difference normals (seam-free borders by construction); the self-writing TERRAIN COOK (bin fetch -> replay, record -> POST /__save-cookbin, fingerprints in the FILENAME so stale bins 404); the TSL ground-material stack — world-space dual-scale detail texture, bump relief, and the whole rain response (puddle mask from flatness x hollows x ruts, sky-mirror roughnessNode, splash cells, snow cover) reading engine weatherUniforms; sandAt ground-code lattice; PAINT_SIG hash-from-the-table pattern.",
+          "content": "PAINT palette (the county's colours), paintVertex biome layering order (sage under grass under fields under town under rock), analytic wheel ruts + plough furrows in the fragment shader, TERRAIN_COOK_VER changelog, building aprons off dustwaterLayout.",
+          "deps": "sindicate/core/assets, sindicate/world/weatherUniforms, three/tsl, ./terrainData.js, ./scale.js, data/biomes.js, data/dustwaterLayout.js.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/town.js",
+          "lines": 1172,
+          "what": "THE KIT-STAMPER: merges Synty kit pieces into per-building geometries, stamps area-local layouts anywhere (buildArea), splits doors onto hinges, seats props by datum rules.",
+          "mechanism": "buildingGeometry merge + _geoCache (tiled plots share geometry); det3/flipWinding/bake negative-determinant mirror handling; the DOOR pipeline (DOOR_SPLIT leaf extraction, pane re-weld, clusterDoorways union-find, hinge solving from measured hardware, one BatchedMesh per material with per-instance culling, 8m door-collider grid, updateDoors/toggleDoor with hx=0 as the open switch); buildLadders collinear-merge; buildArea area-local transform stamper with the whole seating law (GROUND_OFF/SNAP/BED datum, floorUnder/interiorUnder oriented-box floor claims, area.datum='ground', landform/overLandform support tests, drop rule, floorSeat); per-file InstancedMesh prop batching with mirrored-instance second batch; fence-panel capsules; townMaterial one-pipeline-per-(atlas,flip) cache.",
+          "content": "Dustwater EXTRAS (fountain, hitching rails, derived lamp posts), PROP_DELETE/PROP_GROUND click ledgers, BUILDING_ATLASES recolour list, HINGE_HW measured hardware table, SHELL_RE/SHELL_BODY/NO_COLLIDE/AIRBORNE_OK/GROUND_ONLY policy regexes (Synty-kit-specific, belong in a kit contract config), LAYOUT/PIECES imports, dressTownCenter map-editor path. Exports the LIVE MUTABLE REGISTRIES everything shares: colliders, buildingObjects, doors, ladders, doorColliders, PROPS, BUILDINGS.",
+          "deps": "sindicate core/assets + world/scatter (flattenToGeometry) + world/lampField, ./terrain.js, data/townMap.js, data/dustwaterLayout.js; consumed by world.js, zones.js, railway.js, bridges.js.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/zones.js",
+          "lines": 1230,
+          "what": "Wilderness scatter manifest + placement cook + grass occupancy + water meshes — the county's dressing, streamed through the engine's TileField/scatterResident/GrassField.",
+          "mechanism": "placementField rejection sampler (box/accept/sPow/fitY) + listField grid generator, both behind the PLACEMENT COOK (record/replay Float32 slices, sigs in filename, slice-count mismatch guard, determinism FNV probe); residentSpec/res/resFlat/resHump wrappers encoding the collision-by-name contract (scatter:/scatterGround:) and walkHumps registration identical on cooked+computed paths; the grass OCCUPANCY GRID (circle mark, oriented-rect mark, and per-triangle building-footprint rasterizer); buildRiverMesh ribbon chunker (200m chunks, per-vertex depth/flow/drop bake from solved hydraulics, seam-duplicated boundary rows); lake sheet builder with aDepth/aRClip bakes on ONE shared material; buildSea; refreshRiverDepths re-bake; map-editor overrides applier addressed slice:index.",
+          "content": "The manifest itself (~60 Synty species rows with counts/colliders/salts), SOW crop table + CROP_SIG, all the biome accepts (openDesert, cactusPatch, sage, riparian, badland, townGround...), field builders (cropRows, cutStraw windrows, scarecrows, fieldFences + dedupe + capsule pass), TOWN_BOX/VERGE_BOX, ZONES_COOK_VER changelog, grassAccept gates, straw recolour of engine grass.",
+          "deps": "sindicate world/scatter + tileManager + grass + water + flora + walkHumps, core/utils + quality, ./terrain.js, ./scale.js, ./town.js (colliders/BUILDINGS/PROPS/buildingObjects), data/biomes + railLine + railway + outposts + townMap; registers setFloraTerrain at import.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/world.js",
+          "lines": 747,
+          "what": "World facade: build orchestration + ALL spatial queries — the capsule controller, 2D collider walk, BVH oracles, LOS, region streamer, per-frame world update.",
+          "mechanism": "The World class body is engine-grade and duplicated near-verbatim in fable: collide() (oriented boxes, capsules, circles, height bands, door grid), moveCapsule/_capsuleStep substepped capsule-vs-BVH with up-resolve on walkable normals + snap-to-ground, solidPush vehicle wall push-out, walkSurfaceAt/navFloorAt straight-down BVH floor oracles, losBlocked/segmentBlocked, probe() dev capsule drop, _updateRegionStreamer (approach + idle-trickle deferred builds spliced into worker-built side BVHs), the update() plumbing (LOD rebucket with stationary skip, grass/tile streaming, lamp-field nightly resort), BVH assembly from the scatter:/scatterCol: name contract.",
+          "content": "build()'s county recipe (terrain -> town -> coach stops -> outposts -> railway -> doors -> bridges BEFORE zones -> BVH -> refreshRiverDepths), the EXCLUDE regex with the quarry_ exception, saloon interior lamp positions, zoneName(), deferred-asset prewarm paths, and the boot-time engine registrations: setHerdTerrain, setTumbleweedTerrain, setFootstepTerrain, setLawBench, setCoachContent, setTrainContent, plus importing ./chartData.js for its side effect.",
+          "deps": "Everything: sindicate world/* + systems/* content hooks, ./terrain, ./town, ./zones, ./railway, ./bridges, all data modules, game/data/drops.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/railway.js",
+          "lines": 378,
+          "what": "Lays the permanent way as geometry: track/ballast panel batches, trestles, junction castings, tunnel-ridge portals, station areas.",
+          "mechanism": "matrixFor YXZ chord placement (yaw then pitch then z-scale — adaptive panel lengths in one batch); flattenToGeometry split track/ballast into two batches so ballast runs through junctions; trestle builder (deck-only casting under flying panels + one bent per joint, walkables returned for a side BVH); mirrorX proper geometry reflection (positions+normals+winding); single() one-off casting placer; seeded-rng ridge dresser.",
+          "content": "Synty track/mine asset paths and their measured 2:1 gauge mating, tunnel portal art direction (rock rows, bore quad, core plugs — heavily Nick-iterated), Dustwater station/loading-stage stamping via RAILWAY_AREAS, scatterDeco walk-over contract.",
+          "deps": "sindicate core/assets + world/scatter, ./terrainData (heightAt), ./town (buildArea, colliders, buildingObjects), data/railway.js.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/bridges.js",
+          "lines": 159,
+          "what": "Seats a timber span asset on each BRIDGE_SPOTS chord; header states it is ported from fable's bridges.js (177 lines).",
+          "mechanism": "Measure the GLB deck plane (triangle-area histogram gave DECK_Y=0.80), centre XZ-only, tile 2 pieces along the chord at near-native plank pitch, size the across-cover from the ACTUAL imported coach route polylines (coachLegsFor/laneCover walking riverInfo), push mesh into buildingObjects for the BVH.",
+          "content": "SM_Env_Bridge_01 + frontier atlas, DECK_Y/LIP constants, COACH_LANE/TRAV_LANE imports from game/coachRoute.js and traveller lane law.",
+          "deps": "./terrain.js (heightAt, riverInfo, BRIDGE_SPOTS), sindicate core/assets (instantiate), ./town.js (buildingObjects), ../game/coachRoute.js.",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/scale.js",
+          "lines": 84,
+          "what": "The county's size law: WORLD_SCALE and the PIN / SITE-LOCAL / BEHAVIOUR three-bucket doctrine.",
+          "mechanism": "The authoring-time scale constructors S/P/off, dens polyline re-densifier, poly compose — plus SEGMENTS derived from CHUNKS so divisibility holds by construction. Deliberately import-free leaf.",
+          "content": "WORLD_SCALE=2, BASE_SIZE 2160, BASE_INNER, LATTICE 3.2727, CHUNK_TARGET 360 — all county numbers.",
+          "deps": "None (load-bearing: data/railLine.js depends on it staying a leaf).",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/chartData.js",
+          "lines": 24,
+          "what": "Pure registration module: hands the county's survey to the engine cartograph.",
+          "mechanism": "None — it IS the target pattern: data self-registers via setChartWorld/setChartGazetteer/setChartSettlements before the boot chart bake (imported for side effect by world.js).",
+          "content": "All of it: wiring of heightAt/roads/rivers/rail/outposts/buildings/settlements/shops into the engine chart hooks.",
+          "deps": "sindicate/ui/cartograph.js, ./terrainData, data/*, ../game/data/county + shops.",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/regions.js",
+          "lines": 53,
+          "what": "DEAD CODE in western: fable's Aldenvale region table, byte-identical to /Users/nick/Sites/fable/src/world/regions.js. Zero importers here.",
+          "mechanism": "regionAt point-in-blob lookup (trivial). The REGIONS blob shape is live in fable's cartograph/discovery — worth an engine setChartRegions hook when fable ports.",
+          "content": "Frostreach/Gravemoor/King's Vale... — fable content, meaningless in Dustwater.",
+          "deps": "None.",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/road.js",
+          "lines": 66,
+          "what": "DEAD CODE in western: fable's Oakhollow->Kingsreach cobble paver (castle kit piece, fantasy atlas). Zero importers; terrainData exports VILLAGE_CASTLE_ROAD solely to keep it compiling.",
+          "mechanism": "A tidy generic polyline paver (two jittered lanes of an instanced cluster piece, river-bed skip) — live in fable, worth engine adoption THERE, deletable here along with the alias.",
+          "content": "Castle-kit asset paths, fantasy road polyline import.",
+          "deps": "sindicate/core/assets, ./terrainData (heightAt, riverInfo, VILLAGE_CASTLE_ROAD).",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/western/src/world/data/ (14 files)",
+          "lines": 6059,
+          "what": "The county itself: biomes.js (383 — biome field fns + FIELDS/FIELDS_SIG), railLine.js (491 — survey plan + measured kit constants + formation params, import-free leaf), railway.js (600 — solved panels/areas/trestleSpans/inTunnelRidge), waterSolved.js (899 — GENERATED by scripts/solve-water.mjs), settlements.js (774), dustwaterLayout.js + frontierLayout.js (2536 — GENERATED by parse_demo_scene.py / parse_frontier_scene.py), outposts.js, coachStop.js, townMap.js, campfires.js, lodItems.js.",
+          "mechanism": "Mostly none — this is the content that STAYS. Exceptions worth engine notes: biomes.js's '(x,z) -> 0..1 field read by both paint and scatter' is the engine's biome contract shape; the offline generators (water solver, demo-scene parsers, verify-* scripts in western/scripts/) are engine-grade tooling candidates for a later pass.",
+          "content": "Everything — this directory is the definition of 'the county stays game data'.",
+          "deps": "scale.js only (and each other); deliberately renderer-free so verify scripts run headless.",
+          "extractability": "game-specific"
+        }
+      ],
+      "counterpart": "Fable's src/world/ is the same organism one fork back — the shared shapes are explicit. (1) Identical file skeleton: terrain.js / terrainData.js (976 lines: same fbm/heightAt/ROADS/RIVERS/BRIDGE_SPOTS/PADS architecture — western's is the evolved twin that added the rail formation, solved water, and cook sigs; western still exports fable's GUILD/MOOR/CRYPT anchors as parked 'Albion-era' names). (2) world.js contains the SAME World class — groundAt, collide, moveCapsule/_capsuleStep, losBlocked, probe at nearly the same line numbers — plus fable-only dungeon/castle floor branches; this is the single highest-value union (engine WorldBase, game overrides). (3) bridges.js: western's header says outright 'Ported from fable's bridges.js (177 lines)' — the chord-seating + infos {x,z,y,r,mesh} return shape is already a shared contract. (4) western's regions.js and road.js ARE fable's files, dead here — when fable ports, regionAt/REGIONS wants a cartograph setChartRegions hook and road.js's polyline paver is a clean engine candidate. (5) zones.js: same placement-cook/scatter architecture (987 lines). (6) Where western unified all settlement building onto ONE buildArea stamper, fable still has seven bespoke stampers (villages, castleTown, ironkeep, goblinCamp, camps, kingsreachMarket, bracklow) — the union should crown western's kit-stamper as the engine's and port fable's places onto area layouts. Fable already consumes sindicate (12 engine imports in its world.js alone), so both games are positioned to swap onto engine world modules file by file.",
+      "plan": "Registry patterns this project already uses and each step must follow: (a) engine module exports setXContent(obj) merging into a module-local record (setFloraTerrain, setRoadNetwork, setChartWorld); (b) game DATA modules self-register at module end, before consumers import (chartData.js, terrainData's setRoadNetwork — 'data registers itself; consumers follow'); (c) engine modules may own live-mutable registries games push into (walkHumps.registerHumps; town.js's colliders/buildingObjects arrays become this); (d) cook fingerprints live in bin FILENAMES — every extraction must either keep outputs bit-identical (same seeds/constants passed in, verified by the zones determinism hash and cook names) or bump the VER knowingly.\n\nOrdered so western boots after every step:\n\nSTEP 0 — Delete dead fable residue: western regions.js, road.js, and terrainData's VILLAGE_CASTLE_ROAD alias. Pure removal, boot test. (Optionally park them in fable's tree where they are live.)\n\nSTEP 1 — engine world/terrainKit.js: the pure math kit — makeFbm(noise) (ImprovedNoise injected so determinism is the game's), clamp/lerp/smoothstep, ridged, terrace, segDist, buildPolylineIndex(pts, near) returning {distanceAt, nearestAt} (unifies the road/river/rail/swamp chunked-AABB pattern), and fnvSig(table) (unifies WATER_SIG/FIELDS_SIG/PAINT_SIG/CROP_SIG). terrainData/zones/biomes switch imports; cook names must not change — that is the regression test.\n\nSTEP 2 — engine world/railFormation.js: solveFormation({nodes,s,w,flat}, {maxGrade, smoothPasses, mergeIn/Out, fillMax}, groundFn, mergedSolve) -> {y,g,e}; makeRailCorridor(lines, {formHalf, batter, batterMin/Max, railhead}) -> {railInfo, railDistance, applyRail}; findCrossings(roads, railLines) + crossingBlend factory. Game keeps railLine.js untouched and composes in terrainData. Verify RAIL_FORMATION arrays bit-identical (terrain cook name unchanged = proof).\n\nSTEP 3 — engine world/waterSurvey.js: densifyCourse/confluence/estuary passes, bakeReachDepths, bakeValleyCurvature, applyPlungePools, makeRiverIndex -> riverInfo, valleyCut factory, fallBench factory, applyLakes, bakeWaterLevels (passes 0-4), makeWaterSurfaceAt, and spliceBridges(roads, rivers, opts) -> BRIDGE_SPOTS (the splicer + final bank push). The game's terrainData keeps its exact call ORDER (the TDZ/ordering comments are the spec). Regression: scripts/verify-water.mjs + WATER_SIG/cook names unchanged.\n\nSTEP 4 — engine world/heightfield.js + world/groundMaterial.js: buildHeightfield({worldSize, chunks, segments, heightAt, paint(vertexCtx), cookName, cookVer, saveEndpoint}) doing lattice fill, central-diff normals, chunk grid, cook read/record; makeGroundMaterial({detailTex, baseColor(vcol,ctx), extraNodes}) wrapping the rain/puddle/splash/snow/roughness/bump stack that already reads engine weatherUniforms (western injects ruts/furrows as extraNodes, keeps PAINT + paintVertex + VER). First boot may re-cook; behavior otherwise identical.\n\nSTEP 5 — engine world/kitStamper.js (the centerpiece): move buildingGeometry/_geoCache, bake/flipWinding/det3, the whole door pipeline (clusterDoorways, doorway, makeDoors, buildDoorBatches, updateDoors, toggleDoor, indexDoors/doorsAt + doorColliders), buildLadders, townMaterial cache, buildArea + prop batching + fence capsules + all datum/seating law. Engine owns the live registries (colliders, buildingObjects, doors, ladders) — world.js/zones.js/railway.js/bridges.js re-import them from the engine path. Game supplies a KIT CONTRACT via setKitContent({resolveDir/resolveTex, NO_COLLIDE, HINGE_HW, SHELL_RE, AIRBORNE_OK, GROUND_ONLY, GROUND_OFF/SNAP/BED, propDelete/propGround}) — western town.js shrinks to that contract + EXTRAS + a buildTown that is buildArea(LAYOUT at origin). Regression: doors/leaves/slabs boot log counts + scripts/verify_dustwater.mjs.\n\nSTEP 6 — engine world/placement.js + world/waterMeshes.js: placementField/listField + the cook record/replay harness (sig parts and save endpoint injected), residentSpec/res/resFlat/resHump (already wrap engine scatterResident; resHump already calls engine registerHumps), the occupancy grid + building-triangle rasterizer + editor-overrides applier; buildRiverMesh, lake sheet builder, buildSea, refreshRiverDepths (parameterized by RIVERS/LAKES shapes + engine water materials). western zones.js becomes accepts + SOW + manifest + wiring. Regression: determinism hash and zones cook name unchanged.\n\nSTEP 7 — engine world/worldBase.js: WorldBase carrying collide/moveCapsule/_capsuleStep/solidPush/walkSurfaceAt/navFloorAt/losBlocked/segmentBlocked/probe/colliderInfo/showCollider/_updateRegionStreamer and the update() plumbing, reading {groundAt parts, doorsAt, colliders, tiles/grass/lampGlow handles} it owns or is handed. Western's World extends it keeping build() recipe, zoneName, saloon lamps, quarry EXCLUDE extension, and all setX registrations. Last because it touches everything — and it is the step that unblocks fable, whose identical class body then ports onto the same base with dungeon/castle overrides.\n\nSTEP 8 (parallel/optional) — engine world/permanentWay.js: matrixFor chord placement, track/ballast split batching, trestle deck+bents+walkables, mirrorX, single() — game keeps data/railway.js, station stamping and the tunnel-ridge dressing. Bridges' chord-deck stamper can follow as a thin engine helper (spanOnChord) or stay game-side; it is 159 lines and both games already agree on its contract.\n\nThroughout: never move a data/ file; every moved mechanism takes its numbers as parameters so FIELDS_SIG/WATER_SIG/CROP_SIG/PAINT_SIG and the cook names prove equivalence for free."
+    },
+    "fable": {
+      "summary": "Fable's world layer (22 modules + data/, ~6,850 lines) is the starter code western forked, already half-ported onto the Sindicate engine (sky/weather/scatter/tileManager/grass/water/flora/collision/footprints all consumed from 'sindicate/world/*', with setX content registries in use). It splits into three strata: (1) shared machinery that western also carries near-verbatim and belongs in the engine — the World capsule/BVH/streamer core, the chunked terrain-lattice+cook builder, the placement-manifest cook + occupancy grid, the polyline solvers (roads/rivers/bridge-splice), and the building placer; regions.js and road.js are byte-identical between the two games; (2) fable-only set-piece streamers (castleTown/ironkeep/bloodfang/goblinCamp) that share one unextracted streamer pattern among themselves; (3) pure fable content (anchors, LAKES/RIVERS/ROADS/PADS, settlement/camp/POI layouts, biome manifest). One latent bug found: floraFields.js forestness() references FOREST and sstep without importing them — crashes on any non-cooked boot when placement accepts run.",
+      "modules": [
+        {
+          "file": "/Users/nick/Sites/fable/src/world/world.js",
+          "lines": 722,
+          "what": "World assembly + spatial queries: build() orchestrates every builder, plus the capsule character controller and update loop",
+          "mechanism": "Capsule controller (moveCapsule/_capsuleStep: substepped BVH shapecast depenetration, up-normal resolve, snap-to-ground, heightfield floor), 2D collide() (circle/capsule/oriented-box with height bands + jumpable 'low' fences), LOS/segment ray tests over a BVH list (_shotBVHs/_rayBlocked), region streamer (_updateRegionStreamer: deferred builds, nearest-first + idle trickle, worker side-BVHs), deferred-asset pre-warm pen, fixed lamp-pool reposition (never toggle lights — WebGPU recompile law), LOD rebucket cadence with stationary skip, probe()/colliderInfo() dev tools",
+          "content": "Build order for every fable region (town→villages→camps→bracklow→carriages→POIs→bridges→zones→dungeon→castle→goblinCamp→ironkeep→bloodfang→road), zoneName() names, dungeon/Ironkeep fog+ambience overrides, underIronkeepRoof(), bloodfangFloorAt(), engine registrations at module scope (setFloraTerrain/setFloraFields/setHerdTerrain/setHorseWorld/setFootstepTerrain)",
+          "deps": "sindicate: sky, weather, footprints, scatter (LODs/impostor), collision (buildBVH/Async), assets, utils, quality, flora, herd, horse, footsteps; fable: terrain(Data), ironkeepMask, all sibling builders",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/terrain.js",
+          "lines": 304,
+          "what": "Chunked heightfield mesh + vertex-paint + binary terrain cook",
+          "mechanism": "Shared height lattice (each vert computed once), central-difference normals (seam-proof chunk borders), TERRAIN_COOK_VER binary cache (heights+sand+paint, self-writing via /__save-cookbin), sandAt() baked lattice query, TSL node material (grass tex × vertex colour, aSand drop, uWet/uCover weather response)",
+          "content": "Fable palette (grass/moor/snow/blight/swamp/jungle/coast colours), paintVertex biome rules, plaza/road tinting, Ironkeep-mask Discard in colorNode, coast/riverbed paint logic, CHUNK_TARGET 360",
+          "deps": "./terrainData (re-exports it all), ./ironkeepMask, sindicate assets + weatherUniforms, three/tsl",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/terrainData.js",
+          "lines": 976,
+          "what": "Headless terrain math + ALL geographic data; the single heightAt source of truth",
+          "mechanism": "fbm/ridged/terrace noise, catmull densify, chunked-AABB polyline distance accelerators (roadDistance/riverInfo/swampFactor), 4-pass river water-level bake (cross-section min → terminus monotone → riffle relief → estuary descent), fixed-point bridge-crossing splice producing BRIDGE_SPOTS (segment intersection, perpendicular deck chords, rejoin walking, bank push), pad stamping with river-carve precedence, outer-ring relief mask, road bench grading, waterSurfaceAt() single source of truth",
+          "content": "WORLD_SIZE 4320/SEGMENTS/SEA_LEVEL/COAST_Z, every landmark anchor (TOWN/GUILD/MOOR/DWARF/CASTLE/CITY…), 25 LAKES with adaptive bowls, 9 RIVERS with confluence widths, ~30 ROADS, ~45 PADS, biome factor fields (snow/blight/swamp/jungle/moor), Ironkeep sculpt loading + sculptKey; registers setRoadNetwork(ROADS, roadDistance) at module end",
+          "deps": "three/addons ImprovedNoise, sindicate roadGraph (registration only) — deliberately headless, no three/webgpu",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/zones.js",
+          "lines": 987,
+          "what": "The placement manifest: all wilderness/biome scatter, water meshes, streaming grass, tiles",
+          "mechanism": "placementField (deterministic mulberry32(1337) + space-hashed accepts + guard loop + fitY cliff seating), ZONES_COOK_VER binary placement cook (record/replay, slice refs for editor overrides, FNV determinism hash), residentSpec contract feeding TileField (ensure/write/free, per-tile collider registration), occupancy-grid grass gating (mark circle/markRect/rasterTri stamping real building-floor triangles), buildRiverMesh ribbon (per-vert depth/flow/drop attrs), buildSea flood-mask plane, refreshRiverDepths re-derive, palm bark+leaf albedo compositor, editor overrides.json application",
+          "content": "~150 manifest entries: all species per biome (meadow/forest/moor/coast/beach/alpine/blight/swamp/jungle/meadowlands/highland mountains), boxes, atlases, accept predicates, quality multipliers, riverside dressing, crypt/gallows set props",
+          "deps": "sindicate: scatter (5 variants), tileManager, grass, water materials, flora, utils, quality; fable: terrain, town, villages, camps, bracklow, data/townMap",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/town.js",
+          "lines": 294,
+          "what": "Oakhollow: buildings/props/fences data + builder; owns the shared colliders and buildingObjects registries",
+          "mechanism": "Building placer: road-distance-gradient nudge, lowest-footprint-sample seating (0.8m cap), LOD0/LOD3-GLB/impostor cross-fade registration, fence-run instancing with jumpable capsule colliders, per-file prop batching, dressTownCenter (editor TOWN_MAP matrices, dual FBX/GLB atlas flips, scatterCol:/scatterDeco: naming for BVH pickup)",
+          "content": "BUILDINGS/FENCES/PROPS/SPOTS/WANDER_POINTS for Oakhollow + moor/mill outliers",
+          "deps": "fable terrain, data/townMap; sindicate assets, quality, scatter, utils",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/villages.js",
+          "lines": 345,
+          "what": "~35 hamlets/towns: hand layouts + procedural preset() generator + builder",
+          "mechanism": "preset() deterministic ring generator (hashed id → rng), snowifyBuilding TSL node material (normalWorld-gated snow caps at LOD0+LOD3), bubble/deferred split (near.r) returning streamer closures, buildOneVillage = same building placer as town.js verbatim (nudge/seat/LOD/impostor) + per-frame yield",
+          "content": "VILLAGES data (layouts, styles, clearR/musicR, torchAt, props), SPOTS registration for every village at module end, drumfell/glendour bible anchors",
+          "deps": "fable terrain, town.js (SPOTS/colliders/buildingObjects mutation); sindicate assets, quality, scatter",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/camps.js",
+          "lines": 234,
+          "what": "War camps + goblin-camp integration surfaces + garrison spawner data",
+          "mechanism": "Grouped per-file instanced prop stamping with bubble/deferred split (buildOneCamp); circle colliders register at build time so no side-BVH needed",
+          "content": "CAMPS (layouts, clearR/baldR scatter integration radii), CAMP_SPAWNERS + RAVENSPIRE_COURT (combat spawn data living in a world file), atlas routing (dungeon/corrupt flags)",
+          "deps": "fable terrain; sindicate scatter",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/bracklow.js",
+          "lines": 139,
+          "what": "Bracklow loom-city quarter: fixed layout + builder",
+          "mechanism": "Same building placer pattern (LOD chain, buildingObjects) + generated wall runs from corner-pivot pieces",
+          "content": "B layout (gate, walkable quarter, skyline facade), PROPS/lamps, BRACKLOW anchor",
+          "deps": "fable terrain, town.js registries; sindicate assets/quality/scatter",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/carriages.js",
+          "lines": 90,
+          "what": "Fast-travel carriage network: stops, fares, NPC dialogue defs, stand dressing",
+          "mechanism": "Distance-priced fare + fade-to-black game-time teleport (carriageTravel); generated Carriage Master npcDefs",
+          "content": "CARRIAGE_STOPS + SPOTS registration, dialogue lines",
+          "deps": "fable terrain, town SPOTS; sindicate scatter; game object (g.teleport/ui/after)",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/pois.js",
+          "lines": 135,
+          "what": "Roadside POIs: waystones/shrines/loot camps/named landmarks/vantages",
+          "mechanism": "Plain scatter seating + chest base/lid split for openChest contract; NAMED_POIS auto-pin via mapIcon spread",
+          "content": "All POI coordinates, lore strings, POI_BUILD preset lists",
+          "deps": "fable terrain; sindicate assets/scatter",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/goblinCamp.js",
+          "lines": 274,
+          "what": "Goblin raider camps: procedural palisade layouts + one streamer for all camps",
+          "mechanism": "Mathematical palisade ring from measured wall-segment width (tangent-aligned, gate arc skip, towers), heightAt−pieceMinY ground seating, LOAD_R streamer + shared BVH, goblinCampLamps() pre-export for the night pool",
+          "content": "GOBLIN_CAMPS sites/sizes, interior layouts per size, KitForge texmap paths",
+          "deps": "fable terrain; sindicate utils/collision; /assets/goblincamp manifest",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/castleTown.js",
+          "lines": 308,
+          "what": "Kingsreach: KitForge town.json streamer (walled town + castle)",
+          "mechanism": "Manifest set-piece streamer: piece-GLB cache, per-primitive texmap routing, seat modes (floor/base/asis), 3rd-percentile baseY, instancing grouped by piece-mesh×texture, COLLIDE/NO_COLLIDE regexes, async BVH, _compiled reveal gate, hinged gate doors + portcullis with day/night animation and toggleable oriented-box gate colliders, ladder gathering for Climbing, road-tree culling",
+          "content": "KINGSREACH anchor, LOAD_R, regex filters, buried-foundation cull, market hookup",
+          "deps": "fable terrain/town colliders/kingsreachMarket; sindicate assets/utils/collision",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/ironkeep.js",
+          "lines": 580,
+          "what": "Ironkeep: POLYGON Dwarven Dungeon Map demo-scene streamer at the NE massif",
+          "mechanism": "Unity negX matrix conjugation, mirrored-instance (det<0) BackSide meshes, localStorage+committed overrides/additions editor merge, tree/grass swap to alpine biome foliage via scatterTree, boot-created brazier light pool, ironkeepFireLamps export, ironkeepMask bake trigger, INTERIOR_R visibility ring, merge-by-texture draws",
+          "content": "ANCHOR/LOAD_R/CULL/COLLIDE regexes, ALP_PINE_SPECS swap table, dwarfmap asset paths",
+          "deps": "fable terrainData (DWARF), ironkeepMask, town colliders, game/torchfire; sindicate assets/utils/collision/scatter/quality",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/ironkeepMask.js",
+          "lines": 70,
+          "what": "Runtime-baked 2D 'under the hold's roof' mask",
+          "mechanism": "Chunked async bake: per 2m cell, up-ray (roof within 60m) AND down-ray (floor within 40m) against the set-piece BVH → DataTexture consumed by terrain colorNode Discard + ironkeepMaskAt() physics query in _capsuleStep",
+          "content": "IKM grid box around DWARF",
+          "deps": "fable terrainData; three",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/bloodfang.js",
+          "lines": 268,
+          "what": "Ravenspire: POLYGON Dark Fantasy cathedral+graveyard streamer",
+          "mechanism": "Same negX/merge-by-texture×winding streamer family as ironkeep; canonical per-piece MATMAP (Godot prefab-derived) material routing, glass skip, hinged great doors kept out of the merge, crag baseY seating",
+          "content": "BLOODFANG/ANCHOR/GRAVE_OFFSET, COLLIDE/NO_COLLIDE regexes, DF texture conventions",
+          "deps": "fable town colliders; sindicate assets/collision; BufferGeometryUtils",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/dungeon.js",
+          "lines": 312,
+          "what": "The Barrow Depths: seeded procedural dungeon beneath the overworld",
+          "mechanism": "generateLayout(): seeded 5m-grid rooms (entry/boss/side crypts) + L-corridors, wall/door edge rules; in-browser pivot calibration (bbox-measured), instanced floors/walls/ceilings/doorframes, dual atlas-flip materials, torch FX + flame pool, dungeonColliders registry",
+          "content": "DUNGEON_ORIGIN/SPAWN/BOSS_POS, SEED, Synty dungeon kit dressing",
+          "deps": "sindicate assets/scatter(flatten)/utils; game/torchfire",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/bridges.js",
+          "lines": 177,
+          "what": "Auto-bridges at every BRIDGE_SPOTS crossing",
+          "mechanism": "Composed wooden span from kit pieces (module rhythm tiling, lanes, rails/posts, bed-stretched piers, deck-end stone stairs with live STEP_TUNE), stone-arch scaling for becks, bbox-centred piece instancing, decks join buildingObjects for walkable BVH; returns autopilot zone infos for road travellers",
+          "content": "FK Walkway_Wood/step piece paths, STEP_TUNE bake, w>7 wooden-vs-stone rule",
+          "deps": "fable terrain (BRIDGE_SPOTS), town buildingObjects; sindicate assets",
+          "extractability": "needs-seams"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/road.js",
+          "lines": 66,
+          "what": "Oakhollow→Kingsreach cobble highway instancer",
+          "mechanism": "Two-lane overlapping cluster instancing along a densified polyline with yaw/scale/height jitter, river-bed skip — BYTE-IDENTICAL to western/src/world/road.js",
+          "content": "Piece path, LANES offsets, VILLAGE_CASTLE_ROAD consumer",
+          "deps": "fable terrainData; sindicate assets",
+          "extractability": "clean"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/regions.js",
+          "lines": 53,
+          "what": "Named map regions + regionAt() lookup — BYTE-IDENTICAL to western's",
+          "mechanism": "Blob-circle membership with closest-relative tie-break",
+          "content": "7 REGIONS (labels, anchors, blobs, ranks) — this data is fable's despite the identical file (western never re-authored it)",
+          "deps": "none — leaf module",
+          "extractability": "clean"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/floraFields.js",
+          "lines": 26,
+          "what": "Fable's moisture/forestness registered into engine flora via setFloraFields",
+          "mechanism": "Already the extraction seam (engine flora.js live-binding exports). BUG: forestness() uses FOREST and sstep, neither imported — ReferenceError on any cook-miss boot when placement accepts actually run (cooked boots never call accepts, masking it)",
+          "content": "Greenshade forest field + river/lake moisture model",
+          "deps": "fable terrainData; sindicate utils",
+          "extractability": "clean"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/footstepSurfaces.js",
+          "lines": 24,
+          "what": "Footstep surface classifier registered via engine setFootstepTerrain",
+          "mechanism": "Already the seam: priority classifier (water>snow>mud>stone>earth>grass) closed over world",
+          "content": "PAVED plaza circles",
+          "deps": "fable terrain; consumed by sindicate footsteps",
+          "extractability": "clean"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/kingsreachMarket.js",
+          "lines": 70,
+          "what": "Kingsreach plaza market dressing + throne",
+          "mechanism": "Editor-layout-driven placement with z-fight ground clearance; bbox-normalized throne seating",
+          "content": "Reads data/kingsreachLayout.js; streamed by castleTown",
+          "deps": "fable terrain, data/kingsreachLayout; sindicate assets",
+          "extractability": "game-specific"
+        },
+        {
+          "file": "/Users/nick/Sites/fable/src/world/data/",
+          "lines": 395,
+          "what": "Pure content: townMap.js (editor matrices), kingsreachLayout.js, oakhollowLayout.js, lodItems.js + lodConfig.json (impostor tier manifest for /lodconfig), ironkeepFloor/Ground.json",
+          "mechanism": "None — data only; lodItems/lodConfig is the same shape as western's data/ pair",
+          "content": "All of it",
+          "deps": "none (leaf data modules)",
+          "extractability": "game-specific"
+        }
+      ],
+      "counterpart": "Western's src/world/ is the same skeleton fable forked, re-themed to a desert and further along the engine port. Byte-identical: regions.js and road.js. Same-role, same-machinery files: terrainData.js (1611 ln — same fbm/roadDistance/riverInfo chunked accelerators, BRIDGE_SPOTS, setRoadNetwork-at-module-end; adds scale.js WORLD_SCALE three-bucket law and moves solved rivers/lakes into data/waterSolved.js, rail into data/railLine.js), terrain.js (same lattice/cook/chunk builder, richer desert TSL shader), zones.js (same placementField/cook/TileField residentSpec + GrassField + water/river materials, but simple scatterResident only — no impostor chains; registers setFloraTerrain from zones instead of world), world.js (same World class: moveCapsule/_capsuleStep/collide/region streamer/sideBVHs — 631 diff lines but the machinery is line-for-line the same shape), town.js (1172 ln — same building placer grown into buildArea for settlements/outposts, plus doors machinery fable lacks). Western consumes MORE engine: walkHumps, lampField/lampGlow (replacing fable's hand-rolled world.js lamp pool), cartograph via self-registering chartData.js, setCoachContent/setTrainContent/setLawBench/setTumbleweedTerrain. Western-only: railway.js + scale.js. Fable-only: the four set-piece streamers (castleTown/ironkeep/bloodfang/goblinCamp), dungeon.js, ironkeepMask.js, villages/camps/carriages/pois. Shared shapes worth unioning into the engine: World capsule/BVH/streamer core, terrain lattice+cook builder, placement manifest cook + occupancy grid, river ribbon/sea/refreshRiverDepths, polyline solver toolkit (catmull/chunk-index/river-wy bake/bridge splice), building placer (nudge/seat/LOD/impostor), regionAt, laned-path instancer.",
+      "plan": "Registry patterns this project already uses and extraction should follow: (a) setX content hooks — engine holds machinery, game injects data/queries (setFloraTerrain/setFloraFields/setFootstepTerrain/setHerdTerrain/setRoadNetwork/setCoachContent); (b) data registers itself at module end (terrainData.js calls setRoadNetwork after building ROADS; western's chartData.js is a pure side-effect import); (c) live-binding exports replaced by registration (flora.js `export let moistureAt` + setFloraFields). Ordered steps:\n\n1. Fix fable floraFields.js first (import FOREST + smoothstep-as-sstep from terrainData) — latent ReferenceError on any cook-miss boot; cheap and de-risks everything after.\n2. Extract the World core from WESTERN into sindicate/world/worldCore.js (or a World base class): moveCapsule/_capsuleStep/collide/_rayBlocked/probe/colliderInfo/showCollider + the region streamer + a registered-BVH list (setWorldBVHs or world.registerBVH) so fable's castle/goblinCamp/ironkeep/bloodfang bvhs and western's sideBVHs both become list entries instead of hardcoded fields. Fable adopts by subclassing: keeps build() order, zoneName, fog overrides, underIronkeepRoof.\n3. Extract the terrain mesh builder into sindicate/world/terrainMesh.js: lattice fill + central-difference normals + chunk grid + cook bin read/record + sandAt, parameterized by { heightAt, paintVertex, makeMaterial, cookVer, cookKey }. Fable keeps its palette/paintVertex + ironkeep-mask Discard; western keeps its desert shader.\n4. Extract the polyline/terrain solver toolkit into sindicate/world/geo.js: catmull, segDist, chunked-AABB polyline index (generalizes roadDistance/riverInfo/swampFactor/roadBenchAt), the 4-pass river wy bake, the fixed-point bridge-crossing splice (emits BRIDGE_SPOTS), pad stamping, ridged/terrace/outer-ring helpers. Each game's terrainData.js shrinks toward data + composition and keeps registering setRoadNetwork at module end. Optionally adopt western's scale.js pattern engine-side as the canonical scaling law.\n5. Extract the placement layer into sindicate/world/manifest.js: placementField, cook record/replay + determinism hash + slice refs, residentSpec, editor-overrides application, occupancy grid (mark/markRect/rasterTri); and move buildRiverMesh/buildSea/refreshRiverDepths next to the engine water materials. zones.js in both games becomes: accept predicates + species manifest + grass accept.\n6. Extract the building placer into sindicate/world/settlement.js: road-gradient nudge, lowest-footprint seat, LOD3/impostor registration, bubble/deferred split, grouped prop stamper, with a decorate hook (fable passes snowifyBuilding). town.js/villages.js/bracklow.js/camps.js shrink to data; western town.js buildArea adopts the same kit.\n7. Promote the two byte-identical files: regionAt mechanism → engine (regions data stays per game, ideally feeding cartograph the way western's chartData.js does), road.js laned-path instancer → engine (piece path + polyline as args).\n8. Fable adopts western's already-extracted lamp machinery (lampField/lampGlow) to delete world.js's hand-rolled lamp pool, and walkHumps if wanted.\n9. Fable-extracted (western has no counterpart, but the GTA game will want it): a set-piece streamer base in sindicate/world/setpiece.js — LOAD_R gate, GLB piece cache, per-primitive texmap routing, optional Unity negX conjugation, mirrored-instance BackSide, COLLIDE/NO_COLLIDE filters, async BVH, _compiled reveal gate, door/gate animation + gate colliders. castleTown/ironkeep/bloodfang/goblinCamp become thin configs/subclasses. ironkeepMask.js generalizes into an interior-mask bake utility (box + BVH in, DataTexture + query out). dungeon.js's generateLayout could move later as an engine dungeon generator; its Synty-kit emit stays fable.\n\nStays fable-specific: all data (terrainData anchors/LAKES/RIVERS/ROADS/PADS, VILLAGES/CAMPS/BRACKLOW/POI/carriage layouts, regions data, zones species manifest, data/*), the four set-piece scenes' configs, dungeon content, kingsreachMarket, footstepSurfaces + floraFields (already seam-shaped registrations)."
+    }
+  },
+  "workflowProgress": [
+    {
+      "type": "workflow_phase",
+      "index": 1,
+      "title": "Recon"
+    },
+    {
+      "type": "workflow_agent",
+      "index": 1,
+      "label": "western-world",
+      "phaseIndex": 1,
+      "phaseTitle": "Recon",
+      "agentId": "afc91f46ae0cff8f3",
+      "model": "claude-fable-5",
+      "state": "done",
+      "startedAt": 1784914324020,
+      "queuedAt": 1784914324014,
+      "attempt": 1,
+      "lastToolName": "StructuredOutput",
+      "lastToolSummary": "WESTERN's world layer is ~6,100 lines of builder code over …",
+      "promptPreview": "Map WESTERN's world layer for extraction into the Sindicate engine. ls /Users/nick/Sites/western/src/world/ and read every file (large ones in chunks): terrain solvers, the town kit-stamper, zones/areas machinery, scatter, tiles, water — everything. For each module report mechanism vs content vs deps and an extractability verdict. Context: the engine lives at /Users/nick/Sites/Sindicate (src/syste…",
+      "lastProgressAt": 1784914660557,
+      "tokens": 229421,
+      "toolCalls": 30,
+      "durationMs": 336536,
+      "resultPreview": "{\"summary\":\"WESTERN's world layer is ~6,100 lines of builder code over ~6,000 lines of data (src/world/data/). The engine (Sindicate/src/world/) already holds the leaf systems — scatter, tileManager, grass, water materials, sky/weather, collision BVH, flora, walkHumps, lampField/Glow, footprints — and western already feeds them through the established setX(content)/self-register seams (setFloraTer…"
+    },
+    {
+      "type": "workflow_agent",
+      "index": 2,
+      "label": "fable-world",
+      "phaseIndex": 1,
+      "phaseTitle": "Recon",
+      "agentId": "a01592a2ed924126f",
+      "model": "claude-fable-5",
+      "state": "done",
+      "startedAt": 1784914324021,
+      "queuedAt": 1784914324014,
+      "attempt": 1,
+      "lastToolName": "StructuredOutput",
+      "lastToolSummary": "Fable's world layer (22 modules + data/, ~6,850 lines) is t…",
+      "promptPreview": "Map FABLE's world layer the same way. ls /Users/nick/Sites/fable/src/world/ and read every file (large ones in chunks): terrain, tiles, zones, villages, scatter, water, regions — everything. For each module report mechanism vs content vs deps and extractability. Context: the engine lives at /Users/nick/Sites/Sindicate; fable consumes it via file: symlink (check fable's imports from 'sindicate/' to…",
+      "lastProgressAt": 1784914643912,
+      "tokens": 217811,
+      "toolCalls": 40,
+      "durationMs": 319891,
+      "resultPreview": "{\"summary\":\"Fable's world layer (22 modules + data/, ~6,850 lines) is the starter code western forked, already half-ported onto the Sindicate engine (sky/weather/scatter/tileManager/grass/water/flora/collision/footprints all consumed from 'sindicate/world/*', with setX content registries in use). It splits into three strata: (1) shared machinery that western also carries near-verbatim and belongs …"
+    }
+  ],
+  "totalTokens": 447232,
+  "totalToolCalls": 70
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sindicate",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Sindicate — open-world game engine for three.js WebGPU. Streaming worlds, characters, mounts & vehicles, missions, crowds.",
   "type": "module",
   "main": "src/index.js",

package/src/core/assets.js

@@ -13,6 +13,12 @@ export function setAtlasEmissiveHook(fn) { atlasEmissiveHook = fn; }
 // it), not the engine — register per game: setClipCacheVersion(2). Defaults to 2
 // (western's current rebake generation).
 export function setClipCacheVersion(v) { CLIP_JSON_VER = v; }
+
+// A registered CLIP PACK (e.g. Accentimations) is consulted BEFORE the per-game cooked
+// cache: registerClipPack({ urlFor: (sourceStem) => url|null }). Misses fall through to
+// the cooked cache, then the FBX parse — fully backwards compatible.
+let clipPack = null;
+export function registerClipPack(pack) { clipPack = pack; }
 // Patched loader from vendor/ — merges ALL FBX animation layers per stack. The
 // engine does NOT depend on a node_modules postinstall patch.
 import { FBXLoader } from '../vendor/FBXLoader.js';
@@ -547,6 +553,18 @@ export async function loadClip(url, name) {
   if (!clipCache.has(url)) {
     const jsonName = clipJsonName(url);
     const p = (async () => {
+      const packUrl = clipPack?.urlFor?.(url.split('/').pop().replace(/\.fbx$/i, ''));
+      if (packUrl) {
+        try {
+          const r = await fetch(packUrl);
+          if (r.ok) {
+            const clip = THREE.AnimationClip.parse(await r.json());
+            clip.name = name ?? url.split('/').pop().replace('.fbx', '');
+            tick(clip.name);
+            return clip;
+          }
+        } catch (e) { /* pack miss — fall through to the cooked cache */ }
+      }
       try {
         const r = await fetch(`/assets/clips/${jsonName}`);
         if (r.ok) {

package/src/core/engine.js

@@ -15,6 +15,7 @@
 //   engine.onFps((fps) => …)                     // 1s-window fps readout
 //   engine.start()                               // hands the loop to the renderer
 import * as THREE from 'three/webgpu';
+import { tune } from './tune.js';
 
 export class Engine {
   constructor({ renderer, scene, camera, input, post = null, isPaused = () => false, isUiModal = () => false }) {
@@ -43,6 +44,14 @@ export class Engine {
     });
     this.shakeT = 0;
 
+    // world-speed dial for the dev GUI — a plain contributor that reads the tune
+    // registry at call time (never an onChange closure over `this`: a second Engine
+    // construction would strand the first mid-tune and pin it against GC)
+    this.addTimeScale(() => tune.value('time', 'scale', 1));
+    tune.group('time', {
+      scale: { value: 1, min: 0.05, max: 2, step: 0.05 },
+    });
+
     // culling frustum — built by buildCullFrustum() once per unpaused frame; MAY BE
     // NULL and null means "don't cull" (a stale frustum mis-culls; see render contract)
     this.cullFrustum = null;

package/src/core/retarget.js

@@ -193,7 +193,10 @@ export function buildRetargetContext(targetRoot, rigKey = null) {
   // Synty rigs, where Root and Hips are coincident) used to yield posScale = 0, which
   // multiplied every Hips.position key by ZERO: the pelvis got pinned to the root and the
   // character sank into the ground. Only rescale when BOTH hip heights are real; else 1:1.
-  if (!(posScale > 0.01 && posScale < 100)) posScale = 1;
+  // BOUNDS: a metre-scale target fed cm clips has posScale ≈ 0.01 EXACTLY (fable's modular
+  // hero — the old `> 0.01` guard rejected its own legitimate ratio and the pelvis flew
+  // 87m up). 0.002 still excludes the genuine degenerate-bind zero case.
+  if (!(posScale > 0.002 && posScale < 500)) posScale = 1;
 
   // Same bone NAMES don't guarantee the same bind POSE: the Fantasy Rivals bosses each carry a
   // custom rest stance (bent legs, etc.) on anim-rig bone names. The clip can only be used as-is

package/src/core/tune.js

@@ -0,0 +1,50 @@
+// TUNABLES REGISTRY (ENGINE_DESIGN §5b) — systems declare their tweakable values;
+// the dev GUI (/__sindicate/, served by sindicateDevTools) edits them LIVE in the
+// running game through the game bus. Ships inert in production: registration is
+// cheap, the window handle only exists in dev.
+//
+//   import { tune } from '../core/tune.js';
+//   tune.group('weaponWheel', {
+//     slowMo:    { value: 0.3, min: 0.05, max: 1, step: 0.05 },
+//     holdDelay: { value: 0.18, min: 0, max: 0.6, step: 0.02 },
+//   }, { onChange: (key, v) => { wheel[key] = v; } });
+//
+// `onChange` applies the edit to the live system. `file` (optional) names the game
+// data file these values persist to — the GUI shows it so a keeper tune can be
+// copied home (write-through persistence arrives with the ctx.tune contract).
+const groups = new Map();
+
+export const tune = {
+  group(name, spec, { onChange = null, file = null } = {}) {
+    // re-registration (bench soft-restart, second Engine in a page) keeps tuned values —
+    // a fresh constructor must not silently snap live dials back to defaults
+    const prev = groups.get(name);
+    if (prev) for (const [k, v] of Object.entries(spec)) {
+      if (prev.spec[k]?.value !== undefined) v.value = prev.spec[k].value;
+    }
+    groups.set(name, { name, spec, onChange, file });
+  },
+  // read-at-call-time accessor — systems that poll every frame use THIS instead of an
+  // onChange closure, so re-registration can never strand an instance mid-tune
+  value(name, key, fallback = undefined) {
+    const v = groups.get(name)?.spec[key]?.value;
+    return v === undefined ? fallback : v;
+  },
+  set(name, key, value) {
+    const g = groups.get(name);
+    if (!g || !(key in g.spec)) return false;
+    g.spec[key].value = value;
+    try { g.onChange?.(key, value, g.spec); } catch (e) { console.warn(`[tune] ${name}.${key} onChange`, e); }
+    return true;
+  },
+  list() {
+    return [...groups.values()].map((g) => ({
+      name: g.name,
+      file: g.file,
+      spec: Object.fromEntries(Object.entries(g.spec).map(([k, v]) => [k, { ...v }])),
+    }));
+  },
+};
+
+// the dev GUI reaches the registry through the game bus via this handle
+if (typeof window !== 'undefined' && import.meta.env?.DEV) window.__sindTune = tune;

package/src/systems/nav.js

@@ -89,7 +89,10 @@ class NavGrid {
         const wx = this.cx - HALF + (ix + 0.5) * CELL;
         const wz = this.cz - HALF + (iz + 0.5) * CELL;
         const gterrain = world.groundAt(wx, wz);
-        const y = world.navFloorAt(wx, wz);   // the FLOOR a walker stands on — terrain outdoors, the raised floor indoors — so a building INTERIOR is navigable instead of being blocked by its own floorboards. (navFloorAt, not walkSurfaceAt: the latter returns the highest surface = a TABLETOP, which made tables read walkable and speckled the interior; the floor lets the furniture ray below catch the tabletops instead.)
+        // navFloorAt is the WESTERN world's interior-floor oracle; a game without it
+        // (fable pre-upgrade) falls back to groundAt — outdoor obstacles still bake
+        // correctly, interiors just stay ungraded until the game grows the oracle.
+        const y = world.navFloorAt ? world.navFloorAt(wx, wz) : world.groundAt(wx, wz);   // the FLOOR a walker stands on — terrain outdoors, the raised floor indoors — so a building INTERIOR is navigable instead of being blocked by its own floorboards. (navFloorAt, not walkSurfaceAt: the latter returns the highest surface = a TABLETOP, which made tables read walkable and speckled the interior; the floor lets the furniture ray below catch the tabletops instead.)
         // ── STATIC geometry (BOTH grids) ──────────────────────────────────────────────────────────
         // 2D circles/rects (trees/fences/wells/stall posts): blocked = the point gets corrected away.
         // Then BVH (buildings/props): knee-height cross + counter-height cross + a DOWNWARD post. The

package/src/ui/cartograph.js

@@ -26,7 +26,11 @@ let heightAt = () => 0, roadDistance = () => 1e9, fbm = () => 0;
 let ROADS = [], RIVERS = [], LAKES = [], TOWN = null, RAIL_PATHS = [];
 let OUTPOSTS = [], CAMPFIRE_SPOTS = [], COACH_STOP = null, STOPS = [], DUSTWATER = [];
 export let WORLD_SIZE = 4320;
+// Registration order must NOT be load-bearing: every setter invalidates the derived
+// memos (shopSpots/allPOIs/allBuildings), so data landing after a first read still lands.
+function invalidateChart() { _shops = _pois = _blds = null; }
 export function setChartWorld(w = {}) {
+  invalidateChart();
   if (w.heightAt) heightAt = w.heightAt;
   if (w.roadDistance) roadDistance = w.roadDistance;
   if (w.fbm) fbm = w.fbm;
@@ -47,6 +51,7 @@ export function setChartWorld(w = {}) {
 let AREAS = [], RAILWAY_AREAS = [], COUNTY_DEFS = [];
 let shopIdFor = () => null, SHOPS = {}, isMerchant = () => false;
 export function setChartGazetteer(g = {}) {
+  invalidateChart();
   if (g.areas) AREAS = g.areas;
   if (g.railwayAreas) RAILWAY_AREAS = g.railwayAreas;
   if (g.countyDefs) COUNTY_DEFS = g.countyDefs;
@@ -59,6 +64,7 @@ export function setChartGazetteer(g = {}) {
 // worked only game-side; an engine file cannot glob a game's data directory).
 let SETTLEMENTS = [], SETTLEMENT_AREAS = {};
 export function setChartSettlements(s = {}) {
+  invalidateChart();
   if (s.settlements) SETTLEMENTS = s.settlements;
   if (s.settlementAreas) SETTLEMENT_AREAS = s.settlementAreas;
 }