wip(L16, side branch): disk terrain cache design + headless Linux prototype

Exact lossless zlib tile records (keyed on world/season/recipe/plan/evaluator/options/tile),
pristine cache plus ordered edits, server never trusts client caches, corruption/stale rejection,
atomic writes, 2 GB cap. Loaded tiles match regenerated hashes (L1 view, 24 m crossing).
NOT for assembler/world yet: the shared StreamBenchmarkPipeline.h includes Linux-only headers
(unistd/fcntl/zlib), which would break the Windows viewer build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CSFYgsdW8ejZSyiMf4qRSX

ARCHITECTURE.md

@@ -578,7 +578,19 @@ driven by `EditorBrush*` props.
   the result through the normal MPSC queue; the game thread reads the token again before applying.
   `FChunkResult::Epoch` still guards the generation epoch. Desired work is sorted from the true pawn
   position, with the occupied/support LOD0 tile and the next tile along the heading in an absolute
-  high-priority prefix. Stationary player ≈ free. (Old per-frame O(loaded×desired) scan = 22ms.)
+  high-priority prefix. Admission counts queued/running `ActiveTaskCount`; `PendingTiles` stays until
+  game-thread apply for duplicate suppression and result bookkeeping, but completed MPSC results do
+  not occupy a worker slot. `voxel.StreamingLegacyPendingResultCap=1` restores the old result-inclusive
+  admission count. `voxel.StreamingDynamicNearReserve=1` holds the authored near reserve while moving
+  or before the walkable gate, then releases it to coarse work after the stationary ring is ready.
+  Stationary player ≈ free. (Old per-frame O(loaded×desired) scan = 22ms.)
+  Core region compilation is a separate resource gate. With the default
+  `voxel.CoreRegionConcurrentAdmission=1`, tile keys that need the pending region are withheld, while
+  independent keys may use remaining worker slots. `0` restores the all-admission wait. Region pages
+  are built off the lookup map, published as immutable shared pages, and reclaimed when the final
+  reader releases its shared owner. `voxel.StreamingResultBacklogCap=256` independently bounds queued
+  result payloads plus active tile tasks and held prequeue results; `0` disables this memory backstop.
+  Result count is not used as a worker-slot count.
 - **LOD** changes HOT-SWAP (`LoadTile` only, never unload-first) → no holes. LOD
   reconciliation lives in the PERSISTENT per-frame submit loop (same loop as new-chunk loads),
   NOT as a one-shot on the boundary-cross frame — a one-shot drops every chunk past the task
@@ -636,6 +648,7 @@ driven by `EditorBrush*` props.
   two global settings through `FVoxelOpContext` once per chunk, while `ClassifyBox`/`ClassifyTile`
   share the radial proof. This adds no cache, state, RNG, or clipmap stream, and does not touch the
   density grid's two-pass MC loop or any existing `thread_local` cache.
+- **Large `thread_local` caches are lazy** (`VoxelForgeCoreThreadLocal::FLazy<T>`, `Standalone/Core/include/VoxelForgeCore/ThreadLocalStorage.h`, round Linux4): the per-thread handle is a pointer; the table is heap-allocated on that thread's first use and freed at thread exit. Still worker-private and lock-free. It keeps the static TLS block at ~43 KiB instead of 17.3 MiB (glibc carves static TLS out of each thread's stack, and a Linux server pays it on every thread). New cache tables over a few KiB go through `FLazy`, never a bare `thread_local` array.
 - **Biome cache** (`ResolveBiomeSampleAt`/`FChunkBiomeCache`, §8.14): validity is a world-XY BOX +
   ChunkZ + Seed, NOT a chunk key — same reason as the SDF cache. The cell classification is
   noise-heavy; a chunk-key would thrash it on gradient-normal / +X/+Y boundary samples. Keep
@@ -682,6 +695,10 @@ driven by `EditorBrush*` props.
   position → seamless across chunk borders (both sides use identical pure samples). NO per-vertex
   `GetDensityAt` (was ~6/vertex, often as costly as the whole grid). `ComputeGradientNormal` is now
   unused. Only NORMALS changed vs the old path; geometry is identical.
+  Round 18 memoizes these exact central-difference `FVector`s in per-worker scratch arrays for the
+  step-1 ShapeWorld path. Validity is reset for each tile; cache hits return the same vector and do
+  not bypass the density grid, halo, or two-pass cell loop. Keep the cache worker-local and exact;
+  do not move gradient probes above the surface-cell test.
 - **Core hybrid sharp mesher (M2)** (`CoreMesherRecipe` / `MesherRecipe`): the property remains
   opt-in and defaults to `MarchingCubesV1`; `bUseVoxelForgeCore` remains separately default-off.
   V1 preserves the round-3 feature-aware dual-contouring path for repeatability. V2 reuses the
@@ -715,6 +732,15 @@ driven by `EditorBrush*` props.
   its default member initialization was never observable; removing that generated TLS leaf avoids
   constructor work without changing a height or density. Integer queries still read the cached
   payload, and fractional queries still use the same direct locals.
+- **Core shared column cache (L7)**: `Heightfield2D` and FloatingIslands keep their `FLazy`
+  worker-local caches as the first tier. A world-owned, fixed-size four-way table is the second
+  tier, keyed by recipe and plan identity plus content hash, exact XY, and an optional exact
+  sub-domain identity (FloatingIslands uses the island stable ID). Hits read versioned atomic
+  entries without taking a lock; misses take only their set's spin lock, recheck, compute once, and
+  publish. The tables are bounded and die with the world after its tile work has drained. This
+  deliberately adds shared reads on column-cache hits while preserving the no-lock hot-path rule;
+  S14's purely worker-local cache remains the first lookup. Keep large worker-local storage behind
+  `FLazy`, and do not make cache values or keys depend on engine objects.
 - **Sampler unknown-source audit**: the earlier plugin-side `FSurfaceColumn` constructor PCs no longer
   occur after the trivial-payload change. The largest remaining LOD0 unknown cluster in the final
   sampler raw CSV is `UnrealEditor-Core.dll + RVA 0xC080` (runtime PCs around
@@ -1435,6 +1461,385 @@ LOD7/8 shell repair is skipped for certified SurfaceWorld tiles, the renderer do
 backfaces, and the strips predate S4 in S2/S3. Refining all steep faces would multiply far mesh work;
 S4 leaves that cost/quality tradeoff open.
 
+### 8.26 Streaming readiness gates and admission order — World Assembler S5 / M3 Round 9
+
+Do not use “every tile in the current desired clipmap is resident” as a moving-player readiness
+gate: the center and desired keys change continuously, so that condition can remain false even when
+the player has safe ground and a closed view. Report three independent gates from the first actor
+tick: (1) **walkable now** — the support tile and collision-required level-0 tiles in the 3×3 XY
+neighborhood have installed collision (or are explicitly collision-not-required); (2) **enclosed
+now** — the active view has ground, horizon and the family-appropriate ceiling, with no exposed
+coverage hole or unexpected sky; (3) **refined soon** — each target LOD resolves within its stated
+time or travel distance after entering range. While moving, report the largest frame/time gap in
+enclosure and maximum distance that unresolved work trails the pawn. FloatingIslands has open sky by
+design, so its enclosure check excludes a planar roof.
+
+The shared `AVoxelWorld::UpdateChunksAroundPosition` scheduler serves both the Core snapshot path and
+Core-off legacy path. It admits the collision-critical 3×3 ring first. The measured S5 order remains
+opt-in because it did not beat the legacy order on the gates and the viewer could not confirm screen
+presentation: set `voxel.StreamingCoarseFirst=1` to admit coarse desired levels from the maximum LOD
+down to `max(2, FullResClipLevels)`, favoring tiles ahead of travel and then nearer tiles within each
+LOD; LOD0/1 refinement follows. Default `0` preserves the S4 LOD0-to-LOD8 order.
+`voxel.StreamingDynamicNearReserve=1` keeps the authored near-task reserve while the pawn moves or
+until the stationary walkable ring is ready; this is now the default. Set it to `0` only for the
+legacy-admission negative control. After the stationary nine-tile ring is ready, coarse work can use
+the formerly reserved slots.
+The standalone queue defaults to legacy order; `--coarse-first-stream-order` opts into the S5 tiers
+and `--legacy-stream-order` explicitly selects the legacy order.
+
+This order changes only which key starts first. Tile field arithmetic, hashes, `Epoch`, cancellation
+checks, `ModsLock`, the four `EQueueMode::Mpsc` result queues and `EndPlay` draining remain unchanged.
+The clipmap remains a non-overlapping partition, and `TransitionHold` still performs load-before-
+unload reconciliation. No duplicate coarse placeholder is admitted: the current transition rules
+do not make a temporary overlapping parent safe at initial spawn without a separate all-descendants
+hide/swap gate. A coarse tile completion count alone is not proof of enclosure; verify the actual
+view and family-specific ground/ceiling coverage.
+
+`VoxelStartupTrace` records request and worker-start ordinals, LOD, priority, epoch, resident-at-
+request, queue wait, build time, result wait, apply time and discarded/cancelled result reasons.
+Use `-voxel.StartupTraceUntilEndPlay=1` for a moving trace. Round 9 found similar cold walkable-gate
+times, no demonstrated enclosure win, and fewer cancellations at 60 m/s, while that route's center
+deltas were invalid. DXGI marked the capture window occluded, so its images are back-buffer evidence
+rather than proof of screen presentation. Keep S5 opt-in until an owner-visible run measures the
+three gates and closes that gap. Full results and limits are in
+`Standalone/Research/WorldAssemblerM3/Round9/REPORT.md`.
+
+### 8.27 Cold-view throughput trace and gated coarse admission — World Assembler S6 / M3 Round 10
+
+`UpdateChunksAroundPosition` samples residency at intervals of at least 0.25 seconds. A `streaming_sample`
+timestamp is therefore a quantized observation, not a tile-completion timestamp or an admission throttle.
+Use the direct per-tile apply records for completion time, and `apply_frame` records for the game-thread
+budget, queued-result estimate and running-worker count. `collision_ready` measures the asynchronous
+RealtimeMesh submit-to-body-update interval; it is not an isolated Chaos CPU-cook timer.
+
+The staged SurfaceWorld actor trace contained 2,578 desired keys. With legacy order and the authored
+4-visible-mesh / 2 ms apply budget, the full desired set became resident at 17.412 s and the required
+collision ring became walkable at 0.632 s. `voxel.StreamingCoarseFirst=1` with
+`voxel.StreamingDynamicNearReserve=1` completed the same set at 11.704 s while the ring gate remained
+0.627 s. Coarse admissions begin only after the nine-tile walkable gate. This reduces measured cold
+residency by about one third on the staged plan, but null-RHI residency does not prove rendered
+enclosure. Keep coarse-first opt-in until that view is checked in a rendered owner-plan run.
+
+The separate `voxel.StreamingStartupApplyBoost` switch stays default-off. At `1`, it temporarily allows
+12 visible mesh submissions / 14 ms while the initial desired set and walkable ring are incomplete,
+with a 30 second ceiling; at `0`, the authored budget is unchanged. On the matched legacy-order test,
+the boost changed full-set readiness from 17.412 s to 17.346 s and removed count-cap frames, but did
+not improve end-to-end residency. Keep the normal 4 / 2 ms guard for play.
+
+The S6 trace found the shared pool was not saturated: its 10-slot idle estimate was about 132
+slot-seconds on legacy order and 73 on gated coarse-first, while game-thread tile applies totaled only
+about 0.24 seconds. S7's frame-level admission and cumulative worker-task accounting revisited that
+open question; see §8.28.
+
+The report records per-LOD worker, queue, result-queue and apply totals, collision latency, frame
+percentiles, hashes, regressions and the command lines. The standalone 60 m/s viewer now counts
+forward +Y center crossings across multi-chunk deltas; that route reports valid crossing deltas, but
+its latency gate still fails. These are scheduling and instrumentation changes only: deterministic
+W1/W8/W16 world and LOD hashes are unchanged, as are `Epoch`, cancellation, `ModsLock`, MPSC queue,
+shutdown-drain and game-thread UObject-creation rules. See
+[`Standalone/Research/WorldAssemblerM3/Round10/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round10/REPORT.md).
+
+### 8.28 Shared admission accounting and worker supply — World Assembler S7 / M3 Round 11
+
+`PendingTiles` is a game-thread result-bookkeeping set: its entry lasts from task submission until
+`ApplyTileResult`, so it can include work that has finished and is waiting in one of the MPSC result
+queues. It is not the count of active generation tasks. The S6 admission path used
+`PendingTiles.Num()` for that cap. On the S7 old-path control, after LOD0 had no missing keys, 877
+admission frames still had LOD1+ work missing and hit the four-slot near reserve; at a representative
+frame, occupancy was 6/10 while only four tasks were queued/running and two completed results were
+waiting to apply. 806 of those 877 frames had a positive completed-result estimate.
+
+Admission now uses `ActiveTaskCount`, which is incremented before launching the UE task and released
+by its RAII guard when the worker lambda exits. This still counts queued and running work, but completed
+results do not consume an admission slot. `voxel.StreamingLegacyPendingResultCap=1` restores the old
+`PendingTiles` accounting; the test harness's `NearReserveMode=Legacy` also sets
+`voxel.StreamingDynamicNearReserve=0`, reproducing the S6 path. `StreamingDynamicNearReserve` now
+defaults to `1`; `StreamingCoarseFirst` remains `0`, and the apply boost remains `0` in the matched
+measurement.
+
+On the 2,578-key owner SurfaceWorld trace, the old-path control reached the full set in 17.527 s,
+walkable ring in 0.650 s, and full LOD0 in 2.281 s. Dynamic admission reached them in 7.780 s,
+0.581 s, and 1.439 s. Its first-request-to-ready interval was 7.342 s with 41.364 worker-seconds,
+or 5.63 integrated busy-worker equivalents. Using the S6 10-slot idle formula on that same interval
+gives 32.06 slot-seconds, versus 133.01 on the S7 old-path control and 132.1 in S6. The ten S7
+spawn samples that ended with free admission capacity and missing keys all recorded a submission
+stop at the 10-task cap (one worker could finish before the end-of-pass sample); the frame trace
+found no near-reserve decline, all-loaded latch, walkable gate failure, or inner `LoadTile` rejection
+in those passes. Result-aware admission therefore removes the measured cold-set blocker and
+reproduces the legacy control within 0.7%, but the 7.78 s full-set result still misses the rough
+4.14 s `worker-seconds / 10 slots` estimate. Across the full 45 s trace, free-capacity frames with
+missing keys were classified by LOD as near reserve or full cap; none was unclassified.
+
+The per-frame `running_workers` value is biased high when sampled only at admission/apply boundaries;
+S7 added cumulative task intervals and found 5.63 busy-worker equivalents over the first-request-to-
+ready span, with eight sustained overlaps in the reconstructed intervals; a zero-duration endpoint
+tie briefly counts nine. This locates
+the remaining gap downstream of an admission refusal, but does not distinguish UE task-pool dispatch
+from work internal to a tile. Measured worker task time rose 9.7% versus the negative control
+(16.04 ms versus 14.62 ms per initial tile); hashes match and the trace records elapsed task time,
+not CPU cycles. During the later +Y move, the loader's `bCoreRegionCompilePending` guard also
+blocked 10 legacy and 11 dynamic submission passes despite free tasks; each inner-decline record
+had that flag set. The tick trace reports aggregate `TestWorld->Tick()` only: spawn p95/max was
+2.262/5.230 ms and walk p95/max was 2.512/28.893 ms; no subsystem marker names the walk
+maximum. The nine-tile ring and full LOD0 are faster than S6. Tile output hashes did not change, so
+the recipe version remains unchanged. Null-RHI runs do not prove player-visible enclosure. See
+[`Standalone/Research/WorldAssemblerM3/Round11/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round11/REPORT.md)
+for the audit counts, RMC review, quality matrix, commands and binary hashes.
+
+### 8.29 Concurrent region admission and bounded result backlog — World Assembler S8 / M3 Round 12
+
+The S7 moving trace found `bCoreRegionCompilePending` returning before all tile submissions. Each
+such update could leave most slots unused while a new player center requested a region page. The
+default `voxel.CoreRegionConcurrentAdmission=1` lets `LoadCoreTile` continue for keys outside the
+pending and in-flight region sets. Keys that need those sets wait for publication; setting the CVar
+to `0` restores the old all-admission gate for an A/B control. This changes scheduling only.
+
+`World::compileTileRegion` builds region pages without mutating pages already in use, then publishes
+them under the region-map lock. `generateTile` copies a `shared_ptr` while holding the map's shared
+lock and keeps it for the whole mesh read. Evicting or replacing a map entry therefore cannot free a
+page under an existing worker. The actor's shared `WorldLock` prevents a world edit/reset while a
+tile reader or region compiler is active; `EndPlay` waits for the shared active-task count before
+destroying the actor's UObject state.
+
+The result backlog has its own backpressure control. `voxel.StreamingResultBacklogCap=256` counts
+queued MPSC results, active tile-generation tasks and held visible-LOD0 prequeue results. Reaching
+the cap stops new tile admissions until apply drains results or active tasks retire. It does not make
+finished results consume worker slots in the normal admission count. `0` is the uncapped negative
+control; the Core-off legacy test also exercises the default cap.
+
+On the 25 cm owner SurfaceWorld plan, the matched 6 m/s CVar-off/on runs both completed 11 region
+requests (one initial desired set plus ten center moves). The old gate recorded 11 global scheduler
+skips; concurrent admission recorded none and submitted 110 unrelated tiles with no dependent-key
+declines. All eleven changing support centers had the nine-tile walkable ring ready immediately.
+Accumulated pending windows were about 0.43 s, but measured compiler wall time totaled about 11 ms.
+At 60 m/s with a 400 m teleport, the trace recorded 113 region requests, 782 independent submissions
+and 983 dependent-key declines. Most support centers advanced before their nine-tile ring could
+become ready, so the high-speed gate still fails its travel-time target.
+
+The shared result trace now records `queued_peak`, peak payload bytes, the configurable cap, and cap
+stops. A slow-apply teleport stress run peaked at 256 results / 76.2 MB with the default cap; the
+uncapped control reached 1,577 / 125.1 MB. Payload bytes exclude queue-node and allocator overhead.
+The cap kept the observed backlog finite without reinstating the S6/S7 finished-result worker-slot
+decline. Full timings, per-center records, quality checks and hashes are in
+[`Standalone/Research/WorldAssemblerM3/Round12/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round12/REPORT.md).
+
+### 8.30 Velocity-scaled support-ring lookahead — World Assembler S9 / M3 Round 13
+
+The ring gate uses the support tile, which can sit one tile below the clipmap center on a surface
+world. Both scheduler branches must use the same `GetPlayerSupportTile` result for the active 3x3
+collision-critical ring and its predicted rings. Predicting from the stream center can spend work on
+the wrong vertical slice, so the trace includes both `center` and `walkable_center`.
+
+`voxel.StreamingCollisionLookahead` defaults to `1`; `0` disables only the prediction and is the
+negative control. `GetStreamingHeadingStep` transforms velocity into actor space and selects its
+dominant axis, including Z for a fall; when motion is zero it falls back to pawn forward. The
+lookahead targets 350 ms of travel, rounds up to whole active LOD0 tiles, and clamps the lead to one
+or two rings. The scheduler adds the future 3x3 keys only when they already belong to the desired
+clipmap, then moves those collision keys into `CriticalDesiredTiles`. It does not reserve more worker
+slots, expand the clipmap, cancel in-flight jobs, or change tile arithmetic. `collision_lookahead`
+records speed, direction, stream/support centers, promoted-key count and missing desired keys.
+
+On the staged SurfaceWorld owner plan at 25 cm, the S9 `+Y` trace found the ring ready at all 74/74
+support-center arrivals through 40 m/s; the corrected-source CVar-off control found 15/74. The
+S8 no-lookahead baseline was 25/74. At 50 m/s scripted downward motion, 93/93 support-center
+arrivals were ready. The 40 m/s matched on/off initial-ready times were 7.743/7.778 s, so the
+prediction did not slow spawn in this pair. These figures support 40 m/s as the highest horizontal
+speed tested; they do not measure a higher horizontal ceiling. The vertical trace is a scripted
+actor move through the owner plan, not a free-fall physics replay.
+
+For 108 critical LOD0 tile jobs with complete stage joins at 40 m/s, request-to-worker start was
+0.02/9.59 ms p50/p95, generation 66.6/84.0 ms, result wait 9.3/17.7 ms, game-thread apply to mesh
+submit 0.17/0.24 ms, RMC collision submit 0.01/0.02 ms, and RMC submit-to-body-update 37.6/85.9 ms.
+The latter is the observable body-ready interval, not a Chaos-only CPU timer. The current trace saw
+no scheduler skips, a 113-result peak under the 256 cap and 33 ms maximum region-page compile with
+concurrent admission. Generation and body update dominate the measured tile path; the lookahead
+gives those stages time to finish before the support center changes. LOD0-missing clipmap frames
+remain separately visible in the Round 13 table; they are not equivalent to a missing support ring.
+
+The scheduler change does not alter field, mesh or collision output, so `WorldAssemblerPlanV1` and
+the far-horizon recipe versions stay unchanged. Core-off legacy, M2 fixtures, SurfaceWorld and
+FloatingIslands checks passed; the S3/S4 ground, cap and coverage audit passed. The full sweep,
+negative control, hashes, stage ledger and the deferred LOD8 optimization plan are in
+[`Standalone/Research/WorldAssemblerM3/Round13/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round13/REPORT.md).
+
+### 8.31 LOD8 planar far-horizon sampling — World Assembler S10 / M3 Round 14
+
+The planar far horizon is already built from a `Heightfield2D` column profile, but LOD8 previously
+refined ground and cap at a 128-voxel grid even though a 25 cm LOD8 marching-cubes cell spans 512
+voxels (128 m). `BuildNativeHorizonGridCoordinates` now keeps the globally aligned 128-voxel edge
+strips and uses the marching-cubes step through the LOD8 interior. The boundary strips preserve
+shared edge samples; the interior does not build detail smaller than the LOD8 cell spacing. LOD4–7
+retain their prior sample coordinates. No agreement tolerance was relaxed.
+
+This applies to native horizon plans that declare a planar heightfield. Ground and cap still run in
+separate refinement passes, using the same deterministic coordinate lattice. `Heightfield2D` keeps
+its thread-local column cache: S10 records remaining duplicate evaluations across LOD8 tiles and
+workers but does not share cache pages between workers. The `--far-horizon-lod8-step=128` Standalone
+override restores the old sampling density for an A/B control; it does not restore the old v2 hash
+salt. The default sampling change bumps the far recipe hash version from 2 to 3. LOD0–3 hashes and
+density are unchanged.
+
+`VoxelForgeSharedFeatureCost` now reports column evaluation, marching-cubes, ground-refine,
+cap-refine and output-assembly timings separately. Column evaluation is subtracted from each
+overlapping MC/refinement wall interval; output assembly includes the final payload flattening and
+optional diagnostic hashing. Percentiles are computed independently and are not additive. The
+optional LOD8 XY capture uses worker-local vectors and records only diagnostics; it does not affect
+mesh generation or recipe identity.
+
+On the staged 25 cm SurfaceWorld plan, the warmed LOD8 full-tile p95 fell from 59.848 ms to
+13.933 ms. Column evaluation fell from 31.319 ms to 7.478 ms; ground and cap refinement fell from
+11.666/10.029 ms to 1.690/1.330 ms. The S3 ground agreement, S4 cap agreement and 100% cap-ray
+coverage gates still pass at their existing tolerances. BuildHost actor startup, the W1/W8/W16
+matrix, W1/W8/W12 Standalone hashes, the 40 m/s support-ring trace and the S10/S9 captures are
+recorded in [`Standalone/Research/WorldAssemblerM3/Round14/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round14/REPORT.md).
+
+### 8.32 Bounded spawn-phase mesh applies — World Assembler S11 / M3 Round 15
+
+The shared `AVoxelWorld::ProcessPendingChunks` startup budget now defaults on for the initial desired
+set: up to 12 visible mesh applies or 14 ms in one frame, with a 30 second ceiling. It ends as soon
+as the first desired set and stationary walkable ring are ready, the desired epoch changes, an
+explicit per-step apply override is supplied, or the ceiling expires. Normal play uses the authored
+`MaxMeshAppliesPerFrame` and `MaxMeshApplyMilliseconds` values. Set
+`voxel.StreamingStartupApplyBoost=0` for the matched authored-budget control. `startup_apply_config`
+records the actor-read CVar and both budgets; `startup_apply_budget` records when the bounded phase
+starts and ends.
+
+On the matched 25 cm SurfaceWorld trace, both fresh processes handled 2,578 initial tiles. With the
+authored 4-mesh/2 ms budget, readiness was 7.118 s, the nine-tile walkable ring was ready at 0.495 s,
+and full LOD0 at 1.444 s. The four-mesh limit hit 305 of 399 apply frames; result backlog peaked at
+252/256 and result-wait p95/max was 847/1,119 ms. The last LOD8 worker ended at 6.068 s, but its
+result applied at 7.182 s. With the shared startup budget enabled, readiness was 5.960 s, the ring
+was ready at 0.486 s, and full LOD0 at 1.403 s. No apply-count frame hit its limit; backlog peaked
+at 10 and result-wait p95/max fell to 16.6/19.3 ms. The last LOD8 worker/apply times were 6.015/6.019 s.
+
+The remaining worker-generation span is frame-paced: 2,578 requests arrived over 310 submission
+passes (8.32 per pass) in 5.58 s. The trace integrates 4.8 busy workers out of 10, while sampled
+active task guards averaged 9.9/10 and sampled running workers peaked at 8. The LOD4 group used the
+most worker time (6.590 s) but finished at 4.276 s; the final LOD8 group applied at 6.019 s. The 60
+initial RMC body updates had an 18.4 ms p95 submit-to-body-update interval, and the walkable ring was
+ready well before that far-LOD tail. Geometry and collision arithmetic do not change, so recipe
+versions stay unchanged.
+See [`Standalone/Research/WorldAssemblerM3/Round15/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round15/REPORT.md).
+
+### 8.33 Streaming worker supply and tick-independent task pickup — World Assembler S12 / M3 Round 16
+
+The S11 trace showed that admission was paced by the actor tick: typical tiles finished within one
+18 ms frame, while the eight TaskGraph background workers waited for the next scheduler pass to
+receive another task. The host exposed ten TaskGraph workers (two foreground, eight background),
+and the tile tasks ran only on the eight background workers. The shared scheduler now admits up to
+one additional worker-set of prioritized tile tasks (`voxel.StreamingReadyQueueDepth`, default 8,
+clamped to the effective worker count). These tasks are still selected and submitted on the game
+thread through the existing desired-tile ordering; UE's background executor dispatches queued work
+as each worker becomes free. There is no worker-owned continuation list, and no UObject, RMC, or
+desired-set mutation moves off the game thread.
+
+`voxel.StreamingBackgroundWorkerCap=1` sizes the streaming admission slots to
+`FTaskGraphInterface::GetNumBackgroundThreads()`. It does not lower `GetMaxConcurrentTasks()` or the
+worker limit used inside Core's parallel generation. `0` restores the old logical-core-derived
+streaming cap. The `worker_backend_config` and `streaming_worker_cap_readback` trace events record
+the CVar readback, logical core count, TaskGraph and global queued-pool sizes, task API, and effective
+slot count. Each tile row records its submission, worker start/end, and OS thread ID. The external
+BuildHost sample also records process thread count and working set; its eight tile IDs match the
+TaskGraph background pool. RMC's inspected async collision path queues through `GThreadPool`, which
+is a separate 10-thread pool; it does not occupy those eight TaskGraph worker IDs. Arbitrary UE
+background tasks can share TaskGraph background workers, so the pool count alone does not imply
+those workers are idle outside the measured tile task intervals.
+
+Admission remains shared by `LoadTile` and `LoadCoreTile`. The queue-aware dynamic near reserve is
+at least the ready-queue depth while moving or before the stationary walkable gate is ready, capped
+at one less than the worker slots. Horizon work uses a separate coarse cap; while moving, ordinary
+LOD0 admission stops at the actual worker-slot count and critical collision/edit work retains its
+existing higher admission cap. Thus queued far work cannot consume the reserved near capacity.
+`bStreamingPlayerMoving` is captured on the game thread for both admission paths. Existing
+`GenerationEpoch` / `DesiredEpoch` and per-request cancellation checks still reject stale tasks and
+results; no preprepared desired list survives a set change.
+
+On the matched 25 cm SurfaceWorld startup trace, queue depth 8 plus the 8-worker slot cap brought the
+2,578-tile ready time to 4.911 s (the matched queue-depth-zero control took 7.024 s). The LOD0
+worker tail ended at trace time 1.167 s; its last apply was at 1.087 s on the actor startup clock,
+against S11's 1.403 s. The stationary 3×3 collision-ready ring was ready at 0.509 s, close to the S11
+0.488 s measurement. The per-tile trace contains all 2,578 initial requests and shows eight active
+workers at peak, 29.432 worker-seconds, and 6.573 seconds of inter-task idle time summed across the
+eight slots. 500 ms busy-worker equivalents, per-LOD completion and each slot's inter-task gap are
+saved under `Saved/BuildHost/Round16/`. The full table and matched controls are in the Round 16
+report.
+
+Foreground task priorities were tested and rejected: they increased spawn/walk `UWorld::Tick`
+tails despite occupying more TaskGraph workers. The shipped priorities stay `BackgroundHigh` for
+near and `BackgroundNormal` for horizon tasks. The task-pickup changes do not alter density,
+triangulation, collision, or Core output, so no recipe version changes.
+See [`Standalone/Research/WorldAssemblerM3/Round16/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round16/REPORT.md).
+
+### 8.34 Tile cost and column reuse audit — World Assembler S13 / M3 Round 17
+
+The owner SurfaceWorld uses 32 marching-cubes cells only at LOD0–1; LOD2 and farther use 16
+coarse cells. Including the normal halo, those are 35³ and 19³ density samples, respectively.
+Round 17 added exclusive timing for classification, column evaluations during MC/ground/cap,
+non-column MC/refinement work, and mesh assembly. Percentiles are independent. The measured
+owner route is a planar `Heightfield2D` surface: its recipe noise is evaluated while computing XY
+columns, with no volumetric cave, tunnel, room, or route density term. The two-tile interpolation
+probe reduced measured column-compute time by about 71–74% at stride two, but exceeded the 2 cm error gate at
+LOD1 and every tested coarse LOD; stride four also exceeded it on LOD0. It had no near-zero fallback
+and was not enabled in generation.
+
+LOD4 is the first far-cap refinement level: its cap grid is 16 voxels (4 m), while LOD5–7 use the
+128-voxel boundary grid (32 m); ground refinement begins at LOD5. LOD4's cap pass costs about
+4.87 ms of column evaluation plus 1.26 ms exclusive at the eight-tile p95, but its largest measured
+cost is 29.36 ms of column evaluation during MC. LOD4 also has 8,224 column-cache misses per sampled
+tile p95 versus 1,634 at LOD3 and 1,916 at LOD5. The cache remains thread-local. The all-LOD overlap
+probe found substantial cross-worker duplicate XY evaluations, which is evidence for a future
+shared-page A/B test, not proof that a shared cache will pay after synchronization and lifetime
+costs. Round 17 changed no density, mesh, collision, or recipe output; recipe versions remain
+unchanged. See [`Standalone/Research/WorldAssemblerM3/Round17/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round17/REPORT.md).
+
+**Round 18 / S14:** the 65,536-entry worker-local XY column cache keeps the legacy direct-map
+lookup for LOD0–2 (at most 33/28/4 conflict misses in the cold audit) and uses four-way sets for
+LOD3–8. The deterministic coordinate/hash mixer and round-robin replacement cut LOD4 from 8,224
+misses / 7,407 conflict misses to 1,437 / 0, and LOD3 from 1,634 / 1,119 to 574 / 0. Exact key
+validation keeps fill order from affecting samples. `voxel.CoreColumnCacheDirectMapped=1` restores
+the S13 route as a recorded negative control.
+
+The step-1 ShapeWorld gradient memo reduced LOD0 fallback density probes from 11,474 to 3,018 at
+the sampled p95 and gradient-normal cost from 65.10 to 24.16 ns/sample; the two-pass MC invariant
+is unchanged. `voxel.CoreMCGradientMemoization=0` is its recorded negative control. No shared XY
+page was added: cross-worker repeats alone do not establish a net page-cache win, and the S8
+immutable-page lifetime rules would add ownership and memory cost. Round 18 changed no output or
+recipe version. See [`Standalone/Research/WorldAssemblerM3/Round18/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round18/REPORT.md).
+
+### 8.35 Shared Core column cache — World Assembler L7
+
+L7 measured 1.34 million repeated formula evaluations on the W12 L1 view before sharing: 83.6%
+were another worker's XY, 4.0% were same-worker repeats after eviction, and 12.0% were halo/normal
+repeats. The world-owned shared second tier cut measured formula executions by 60.9% and improved
+median whole-view-ready time by 19.0%; moving 8 m and generating 144 entering tiles improved median
+wall time by 36.1%. Peak RSS rose by about 66 MiB. The cache is a bounded exact-value table rather
+than published pages; no scheduling affinity or page prefetch was needed to clear the measured
+whole-view threshold.
+
+The thread-local first tier remains because it avoids shared atomics for local hits. The shared
+table has no lock on hits; only a miss takes a set-local spin lock. FloatingIslands' cache identity
+includes its island stable ID because distinct anchors can request the same XY with different
+column metrics. All W1/W12 L1 hashes, exact queries, and the seed-0 FloatingIslands fixture match
+the pre-L7 binary with Clang FP contraction off and GCC defaults. See
+[`Standalone/Research/WorldAssemblerM3/Linux7/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux7/REPORT.md).
+
+### 8.36 Route-invariant Core density — World Assembler M3 L13
+
+For an unedited Core world, tile density, mesh, payload, and topology are a function of the world
+manifest/recipe, seed, and tile key. The reviewed manifest field is authoritative: SurfaceWorld uses
+its `Heightfield2D`, while FloatingIslands uses its `FloatingIslandFieldV1`. `World::densityAt` and
+tile generation read the same `FStandaloneShapeWorld` instance. A compiled analytic region page
+retains bounded spatial bins for page ownership and routing, but `SetSharedDensitySource` binds it to
+that base shape before publication; density, lattice, detail, classification, and solid queries
+delegate to the shared evaluator. This keeps exact queries, collision occupancy signs, page tiles,
+and base tiles on one field. Player edits remain explicit versioned overlays on that world state.
+
+The route-binding change increments `WorldAssemblyEvaluatorVersion` from 5 to 6. Do not restore a
+page-local legacy evaluator: it disagrees with the reviewed field. Uniform-block proof audits must
+fill and check page tiles against the evaluator they actually sample. This is the shared Core path;
+the Unreal adapter and its asynchronous MPSC/Epoch flow are unchanged. See
+[`Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md).
+
 ## 9. Multiplayer model (listen-server first, dedicated-friendly)
 
 > **Status: transport is DESIGN ONLY — nothing is networked in-tree yet** (no `Replicated`/`HasAuthority`/RPCs; a

CODEMAP.md

@@ -158,6 +158,9 @@ remains `0`, and lateral regions remain gated off.
 | `VoxelForge.Build.cs` | Deps: Core, CoreUObject, Engine, **GameplayTags**, **RealtimeMeshComponent**, `VoxelForgeCore`. `AVoxelWorld::bUseVoxelForgeCore` opts into the Core runtime route; it defaults off. |
 | `../../VoxelForgeCore/VoxelForgeCore.Build.cs` | C++20 runtime module. Reads `Standalone/Core/core_sources.txt`, validates one include shim per canonical source, and fails UBT on missing, extra, or mismatched shims. No unity/PCH; private copied implementation stays under `vfcore::detail`. |
 | `../../VoxelForgeCore/Private/Manifest/VFCore_*.cpp` | Eighteen one-source UBT shims that include canonical files under `Standalone/`; they do not copy Core implementation. The API-boundary row includes `Core/src/VoxelForgeCore.cpp` directly. |
+| `../../Standalone/Core/include/VoxelForgeCore/ThreadLocalStorage.h` | `VoxelForgeCoreThreadLocal::FLazy<T>`: thread-local handle that heap-allocates a worker-private cache on first use. Large worker-local caches use it (HeightfieldColumnCache, IslandColumnCache, GFloorReliefCache, GRoomGraphCache, GSurfColCache, tunnel/diff caches). See ARCHITECTURE §8.10. |
+| `../../Standalone/Core/include/VoxelForgeCore/SharedColumnCache.h` | Bounded four-way second-tier cache for exact per-column values. Readers use versioned atomic slots without a lock; misses use a set-local spin lock. World-owned lifetime, recipe/plan identity and content hashes, XY and optional sub-domain identity. SurfaceWorld and FloatingIslands share this mechanism; see ARCHITECTURE §8.35. |
+| `../../Standalone/Core/src/CoreNamespacePreamble.h` | First include of every Core TU. Forces FP contraction off per compiler (Clang/MSVC/GCC pragmas; unknown compiler = `#error`) and defines `vfcore::fp_contract::selfTest`, which `World::compile` runs before building: a fused multiply-add (e.g. Clang `-ffp-contract=fast`) refuses world generation. The world depends on contraction (Linux2/Linux3 reports), so never remove either. |
 | `../../VoxelForgeCore/Private/ModuleEntry/` | Unreal module entry and an isolated `CoreMinimal.h` shim for the actual engine header. |
 | `../../Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h` | Standard-library-only public Core API. `VOXELFORGECORE_API` exports the API from the Unreal module and is empty for standalone builds. |
 | `../../Standalone/Core/src/FloatingIslandsInternal.h` | Canonical standalone/Core floating-island planner, geometry-versioned field, manifest serializer, influence bounds, capsule-route checks, and thickness audit. |
@@ -328,6 +331,14 @@ the four MPSC result queues `CriticalProcessQueue` / `EditedProcessQueue` / `Nea
 `ProcessQueue`, and `PendingTiles` (TSet) (VoxelWorld.h:908-912).
 **Async state:** `bShuttingDown`, `ActiveTaskCount` (atomics), `GenerationEpoch`, and the
 game-thread `PendingTileCancellation` map whose per-request atomic flags are read-only on workers.
+S5 assigns request and worker-start ordinals to each tile, preserving epoch, resident-at-request,
+priority, queue-wait and build timing in the opt-in startup trace. All four result queues remain MPSC;
+EndPlay still waits for workers and drains every queue.
+S8 adds `StartPendingCoreRegionCompile`: by default `voxel.CoreRegionConcurrentAdmission=1` lets
+`LoadCoreTile` admit keys independent of a pending region page; `0` restores the global compile gate.
+`voxel.StreamingResultBacklogCap=256` limits queued result payloads + active tile tasks + held
+prequeue results without folding completed results back into worker-slot admission; `0` disables it.
+Core region pages are immutable shared owners while readers are active. See §8.29 and §3.15.
 
 **⭐ Espace ACTEUR / ACTOR SPACE (2026-08-17).** Le champ de densite est defini en espace **acteur** :
 `(0,0)` est l origine de l acteur `AVoxelWorld`, pas celle du monde Unreal. `WorldToLocalCm` /
@@ -349,6 +360,8 @@ casse cette arithmetique *structurellement* — `BeginPlay` loggue une **Error**
 | `ValidateDeterminism()` | — | **F2 CallInEditor button (PIE)**: re-samples boundary points under left- vs right-chunk cache warm-ups + a same-alignment repeat; any non-zero delta = window-invariance regression (§8.4). Run after every "bit-identical" hot-path refactor. |
 | `GetMaxConcurrentTasks()` | — | T2.d — asset `MaxConcurrentTasks` capped to logical cores − 2 (all three budget checks use it). |
 | `GetActiveGenerationTaskCount()` | — | Normal mode returns the existing pending count. With `voxel.Step1PrequeueVisibleLOD0>0`, completed held results are excluded from active worker admission so a full render corpus can be generated before the upload release. |
+| `StartPendingCoreRegionCompile()` / `LoadCoreTile()` | — | Background Core region-page compile. `voxel.CoreRegionConcurrentAdmission=0` is the global-stop control; default `1` withholds only keys in the pending/in-flight region sets. Independent tiles can proceed. Core pages use immutable `shared_ptr` ownership under a separate shared mutex. §8.29. |
+| `EnqueueStreamingResult()` / `IsStreamingResultBacklogCapped()` | — | Central result accounting for all four MPSC queues. `voxel.StreamingResultBacklogCap=256` caps queued results + active tile tasks + held prequeue results; `0` disables the cap. This bounds result-payload growth separately from worker-slot admission. §8.29. |
 | `PostEditChangeProperty` | 1000 | Editor live-edit hook. |
 | `OnObjectModifiedInEditor` | 1022 | Regenerates when a strate asset is edited (if `bLiveEditStrates`). |
 | `EndPlay` | 1118 | Sets `bShuttingDown`, **waits for `ActiveTaskCount`→0**, unbinds delegate. |
@@ -359,7 +372,7 @@ casse cette arithmetique *structurellement* — `BeginPlay` loggue une **Error**
 | `AdvanceHeadlessDigMotionTest` / `RecordHeadlessDigMotionFrame` | 3060 / 3217 | Explicit `-voxel.TestDigMotion=1` repro: optional near digs, then repeats underfoot digs and samples `Generator->GetDensityAt` immediately after each edit, on its first subsequent simulated frame, and on every following observation frame. `-voxel.TestDigMotionFieldOverride=1` is a measurement-only prototype that clears `CurrentFloor` and switches CMC to falling when the sampled post-edit density is air; it is inactive by default. The test counts false support, false air and downward velocity beyond one gravity step. `-voxel.TestDigMotionUnderfootDigCount` is clamped to 1–100; `-voxel.TestDigMotionUnderfootIntervalSeconds=0` performs per-frame rapid edits. The accompanying gap audit is scoped to the dig session. |
 | `MaybeFinishHeadlessStreamingTest` | — | The existing `voxel.TestExitSeconds` diagnostic emits `VoxelForgeStreamingExitDiag` at most every 30 elapsed seconds, including threshold and early-return test flags; no output when the timer is unconfigured. |
 | `UpdateVisualStalenessAudit` | 5034 | Test-only camera-frustum coverage audit: tracks up to 24 real pre-skirt isosurface points per visible component, then counts frames where no visible tile component covers a previously visible, still-desired point (excluding edited bounds). `voxel.TestVisualGapInjectEarlyHide=1` hides a valid component for three frames and must be caught. `voxel.TestGapAuditLegacyHandoff=1` restores old handoff culling for A/B baselines. |
-| `ProcessPendingChunks` | 7435 | Drains critical, edited, near, then ordinary result queues under the per-frame budget; reads the per-request cancellation token before removing its map entry, drops obsolete/aborted results, then applies each live result via `ApplyTileResult`. Collision profiling timestamps the result's arrival here to separate worker completion from game-thread apply wait. Step 1's `voxel.Step1PrequeueVisibleLOD0` holds completed results until the requested non-empty L0 count is ready, then releases them through this same drain and emits the `VFStep1UploadCorpusReleased` CSV event for UE's delayed CSV capture. |
+| `ProcessPendingChunks` | 7435 | Drains `CriticalProcessQueue`, `EditedProcessQueue`, `NearProcessQueue`, then `ProcessQueue`; applies under the authored 4-mesh/2 ms budget during normal play and the bounded shared startup budget (12 meshes/14 ms) until the initial desired set and walkable ring are ready. `voxel.StreamingStartupApplyBoost=0` restores the authored budget. `startup_apply_config` traces the actor-read CVar and both budgets; `startup_apply_budget` records activation/end. Reads per-request cancellation before removing its map entry, traces stale/obsolete/aborted discards with epoch and ordinal, then applies via `ApplyTileResult`. Step 1 prequeue still releases here and emits `VFStep1UploadCorpusReleased`. |
 | `ApplyTileResult` | — | **Shared game-thread apply** for one `FChunkResult` (async drain + sync carve): discards stale generation epochs and keys no longer desired, marks loaded, ingests capture, EMPTY releases the tile's existing component (a re-gen can flip content→empty on band change — old geometry must not linger), else `ApplyMeshToTile`. Returns true iff a visible mesh uploaded (counts the budget). Doesn't touch `PendingTiles` (caller's). |
 | `FVoxelStackSampler` / `FScopedVoxelStackRegistration` (`VoxelStackSampler.h/.cpp`) | — | **Diagnostic raw stack sampler, off by default.** A sampler thread captures registered generation workers' stacks (`CaptureThreadStackBackTrace`) every N µs and tags each with the tile's LOD. It writes bounded raw PCs to CSV plus a symbolization-free summary under `Saved/`; symbol resolution is deferred until after process exit so the measured process never initializes/calls DbgHelp for this diagnostic. Lifecycle teardown is serialized and registration TLS is session-tagged. Registration is per tile TASK in `LoadTile` (and the export's tasks), never per sample; disabled costs one relaxed atomic load. Game `-voxel.SampleStacks=<us>`, commandlet `-samplestacks[=us]`. |
 | Room-cache performance (2026-09-13): `VF_FindPlayerFitPointForRoomMemoized` / `GPlayerFitMemo` (`VoxelCaveMorphology.cpp`), `voxel.TileCacheWindow` + `VoxelGenLOD::TileOriginVoxels/TileCellsPerAxis` (`VoxelGenerator.h`), `FChunkSDFSpatialIndex` | — | **Player-fit memo:** exact 97-word key, process-wide, `voxel.PlayerFitMemo`. **Tile cache window:** the room cache covers the requesting tile's footprint plus a fixed collect margin. It is set via `TGuardValue` in `GenerateMesh`/classify, and is window-invariant by construction (the margin does not grow with the tile). **LOD-gated:** fused path at LOD ≥ `voxel.TileCacheWindowMinLOD` (3), op-stack at LOD ≥ `voxel.TileCacheWindowOpStackMinLOD` (4); lower LODs keep the 4-chunk worker window, because the tile window slowed LOD0 evaluation ~6%. Strates whose authored terrain ops exceed the proven 256-voxel extent (or are malformed/unloaded) fall back to the legacy window (`VF_ComputeTerrainOpEnvelope`). `voxel.SpatialIndex` is -1 auto (off at fused LOD0, on elsewhere), 0 or 1. **Spatial index:** ordered XY buckets over cache primitives, exact rejection. The `static_assert` in `VoxelStrateTypes.h` ties `VF_STRATE_PARAM_FIELDS` to `FStrateGenerationParams` (83 fields + 8 B padding). |
@@ -367,7 +380,7 @@ casse cette arithmetique *structurellement* — `BeginPlay` loggue une **Error**
 | `RecordTileHash` / `WriteTileHashDump` | — | Headless `-voxel.TileHashDump=<absolute path>` parity instrument. Records the exact `FVoxelMeshData` used by the streaming result, including empty/classified tiles, then writes sorted absolute tile keys, LOD step/cells, content-band limits, settings digest context, and the shared `VoxelGeometryHash` at `EndPlay`. |
 | `SyncRemeshTile` | — | **INSTANT DIG**: level-0 same-frame re-mesh on the game thread. Uses `PreEditDensityCache` when the tile is resident in the bounded local cache, replays the current DiffLayer over that exact procedural lattice, then meshes/applies inline so a carve is visible THIS frame. A cache miss uses normal generation; it captures the unedited lattice if the tile needs meshing, while uniform-tile proofs remain enabled. |
 | `PreEditDensityCache` / `VoxelForgePreEditDensityCache::BuildEditedGrid` | — | Per-world cache of the pawn's current L0 tile: exact 35³ pre-edit samples, max **171,500 bytes**. It is pruned when the pawn crosses chunk boundaries and cleared on `RegenerateAllChunks`. `BuildEditedGrid` snapshots touched diff chunks once and reproduces `GetDensityAt`'s final `pre-edit - EvaluateMods` operation before the per-call shared-grid mesher path. |
-| `UpdateChunksAroundPosition` | 8603 | Builds desired set, cancels pending keys that left it, sorts from the **true pawn position**, submits the occupied/support LOD0 tile and the next tile along the pawn heading as an absolute `BackgroundHigh` prefix, then loads/unloads and handles LOD changes. **Delta cull**: `BuildDesiredTiles` returns the LEAVERS (stamped `DesiredStamped` map, one sweep) — only those + `TransitionHold` are considered per crossing, not every loaded tile. `BuildDesiredTiles` also applies `RenderDistanceChunks`: the outermost shell widens to cover the distance as level-MaxClipLevel MC tiles (`VF_OuterShell` shared with `IsTileInClipRange` so the cull sees the same horizon), dz pre-clamped to the vertical band. **§9.3 anchors:** also prunes dead `StreamingAnchors` + detects their chunk crossings → rebuilds the desired set when an anchor moves/(un)registers (`bAnchorsMoved`/`bForceDesiredRebuild`), same cadence as player movement. §8.10. |
+| `UpdateChunksAroundPosition` / `GetGenerationAdmissionCount` | 10990 / 10971 | Shared Core/legacy scheduler. Builds the desired set and delta-culls leavers; admits the occupied/support tile plus collision-required LOD0 tiles in the pawn's 3×3 XY ring as `CollisionCritical`. S5 coarse-first admission stays opt-in (`voxel.StreamingCoarseFirst=1`). `voxel.StreamingDynamicNearReserve=1` is now the default: it keeps the authored near reserve while moving or until the stationary walkable ring is ready, then makes those slots available to coarse work. Admission counts submitted queued/running tasks, not completed results waiting in the MPSC result queues; `voxel.StreamingLegacyPendingResultCap=1` restores the old `PendingTiles`-based cap for the negative control. `PendingTiles` still lasts through game-thread apply for duplicate suppression and result bookkeeping. The clipmap stays non-overlapping and load-before-unload / `TransitionHold` reconciliation remains authoritative. Standalone has no mirror of this actor scheduler. §8.10 + §8.26–8.28. |
 | `AdvanceHeadlessCollisionGateStressTest` / `ObserveHeadlessCollisionGateStressTest` / `MaybeFinishHeadlessCollisionGateStressTest` / `MeasureHeadlessCollisionGateStressTerrain` | — | Explicit `-voxel.TestCollisionGateStress=1` harness only. The normal spawn-height cvar offsets from the measured density surface; `voxel.TestCollisionGateStressDeepDrop=1` carves a process-local box shaft from above the top to just above the floor tile, extending along the post-landing route so the pawn does not run into the shaft sidewall, temporarily raises only the transient test DiffLayer brush-radius allowance for that fixture, removes only the local pawn's redundant streaming anchor for this isolated repro, proves every sample in two complete outside-ring level-0 tiles is air before seeding their known-empty status, prewarms the known-empty in-ring column, and asserts that the support walk reaches the in-layout floor outside the aligned level-0 render ring before the pawn drops. The log reports whether the fixed gate retains that otherwise out-of-ring target. Other streaming anchors remain active. The fixture rejects a target or floor outside the layout, a non-air empty-tile proof, or a floor inside the aligned level-0 ring. The `GetDensityAt` column at capsule feet defines the local air/solid surface; the deep-drop column crossing is cached after its first exact scan. Each frame records actor position, velocity, direct foot tile and gate support readiness, gate state, signed feet clearance, and a ≤0.5-voxel sweep between positions. PASS requires no measured clearance below −5 cm; deep-drop gate-on also requires horizontal travel during a hold. Result logs include the terminal density column, first crossing below spawn height, hold count/time, and gated horizontal progress. |
 | `BuildDesiredTiles` | 6482 | Builds `DesiredSorted`+`DesiredStamped` (player clipmap shells), then adds streaming anchors and the pending player's collision-only support column before the leaver sweep. It orders from the true local pawn position and builds `CriticalDesiredTiles` for the unresolved support target, occupied/support and heading tiles. Also rebuilds `DesiredTransitionDescendants` (ancestor → desired descendants, including face/edge-touching replacements) for the reconcile pass. |
 | `CollisionGateDesiredTiles` / `RequestCollisionGateSupportTile` | 5062 | Retains an unresolved support target and up to three level-0 tiles below it across desired-set rebuilds. The additional keys are hidden collision-only tiles, queued ahead of ordinary streaming, and pruned once resolved or outside the active column. |
@@ -380,7 +393,8 @@ casse cette arithmetique *structurellement* — `BeginPlay` loggue une **Error**
 | `AddAnchorDesiredTiles` | — | **§9.3 multi-anchor:** folds each `FVoxelStreamingAnchor`'s thin level-0 box (`XYRadiusChunks`/`ZBelowChunks`/`ZAboveChunks`) into the SAME desired set and the independent collision set, so AI/remote players keep collision loaded around them; delta cull releases them on move/unregister. **§9.4:** a tile only a CollisionOnly anchor wants (clipmap didn't stamp it) → `CollisionOnlyTiles` → hidden at apply. Zero cost when no anchors. |
 | `ReconcileAnchorTileVisibility` | — | **§9.4:** after each rebuild, toggle `SetVisibility` on ALREADY-LOADED tiles that flipped render↔collision-only (diff `CollisionOnlyTiles` vs prev — bounded, no O(loaded) scan; unhide only if still desired). No-op without CollisionOnly anchors. |
 | `RegisterStreamingAnchor` / `UnregisterStreamingAnchor` | — | **BlueprintCallable §9.3:** add/remove an actor as a streaming anchor (`EVoxelAnchorPolicy` CollisionOnly/FullVisual + XY/ZBelow/ZAbove box). Idempotent; forces a rebuild next Tick. §9.4: CollisionOnly tiles cook collision but are hidden (no draw/VSM) unless the player clipmap wants them too. |
-| `LoadTile` | 9033 | Budget check → `UE::Tasks::Launch` background gen+mesh; RAII task guard. Worker runs `Generator->ClassifyTile` first (T1.d): AllSolid/AllAir ⇒ skip `GenerateMesh`, tile stays empty (capture tiles always generate). It carries `GenerationEpoch`/desired epoch and checks `bShuttingDown`, generation pause, and its read-only cancellation token between expensive stages; obsolete work returns through `ProcessQueue`. STRATE CONTENT CUT: tiles ≥ `StrateContentCutMinLevel` pass the player-strate band (`MeshBandChunkLo/Hi` → voxels) to `GenerateMesh` + stamp it on `FChunkResult::BandChunkLo/Hi`; band change re-queues via `BandRemeshQueue` (see `UpdateChunksAroundPosition`). `voxel.TestFullResClipLevels` is a measurement-only runtime override; default -1 uses the authored setting. TOO-COARSE SKIP: if one cell is taller than the band (`Step > band height` — level ≥7 territory) the tile is enqueued EMPTY without launching a task (cell-granular cut could only render garbage). §8.10. |
+| `LoadTile` / `LoadCoreTile` | 9033 / 11633 | Budget check → background generation; RAII task guard. Both paths preserve `Epoch`, desired/modification epochs, cancellation state and MPSC result routing. Requests receive a monotonic request ordinal; workers assign a generation-start ordinal. `VoxelStartupTrace` joins those with priority, resident-at-request, queue wait, worker build, result wait, apply time and discard reason. Legacy `LoadTile` retains its classify/mesh and strate-band behavior; Core delegates to the resolved immutable snapshot. `EndPlay` still drains workers/results. §8.10. |
+| `VoxelStartupTrace::RecordRequest` / `RecordTile` | — | Opt-in JSONL via `-voxel.StartupTraceFile=...`; `-voxel.StartupTraceUntilEndPlay=1` keeps tracing through movement, otherwise it stops at initial settle. Each request is keyed by epoch and ordinal; applied tile records add worker-start order, priority, queue/build/apply timings. Discard events identify stale epoch, obsolete, no-longer-desired and aborted results. |
 | `UnloadTile` | — | Clears tile state; marks any matching generation request obsolete without removing its pending slot, so a late result cannot clear a replacement request; the component is PARKED in the pool (T2.c), not destroyed. |
 | `ApplyMeshToTile` | 9838 | Upload geometry. One component per tile (clipmap keeps count low; supersedes the old region batching); worker-built streams (T1.f) → `CreateSectionGroup(MoveTemp)`. Reuses the component's existing `URealtimeMesh` (no per-apply mesh alloc). **F17: two polygroups** (0 ground / 1 sky-cap, per-triangle class from the mesher) → RMC auto-section per non-empty group; slot 0 = override/default material, slot 1 = `CeilingMaterial` (fallback ground); config gated by `FChunkResult::bHasGroundTris/bHasCeilingTris`. Takes `FChunkResult&`; strate lookups clamp Z into `Result.BandChunkLo/Hi` (strate content cut) — ground at clamped bottom chunk, cap at clamped top (mid = gap fallback). Collision level-0 only (T1.c) both groups; shadow per SECTION: ground casts at level≤1, cap never. Ordinary same-tile re-cooks retain the installed body while it is valid. A carve intersecting the pawn's current support tile and capsule bounds suppresses that old body until the replacement cook is installed. `voxel.ProfileCollisionCookStages` reports generation/apply waits, combined RMC time, completion hops, triangle/skirt counts and collision settings. With `voxel.Step1PrequeueVisibleLOD0>0`, logs apply frame and waits for `GetLastRenderTime` to advance for first-visible frame; `voxel.Step1UploadDisableCollision=1` isolates render upload. Routes each terrain base through shared MIDs; disabled volume MIDs bind neutral `VolP*` and null `VolTex*`. **§9.4:** `SetVisibility(false)` when the tile is in `CollisionOnlyTiles` (anchor-only, hidden — collision still cooks). §8.10 + ARCHITECTURE SurfaceWorld row. |
 | `HandleRealtimeMeshCollisionBodyUpdated` / `HandleTileCollisionCookComplete` / `PollStep1SupportSweepProbes` | 6964 / 7192 / — | Correlate RMC body-install event and collision-future completion. `voxel.ProfileCollisionCookStages=1` logs worker queue/gen, result wait, apply/upload/config submission, RMC submit→body update, body event→future, future→game-thread hop, submit frames, pending VoxelForge cooks, priority, collision flags, and triangle/skirt totals; it also reports mesh-generation-end→ready. `voxel.Step1CollisionProbe=1` sweeps the pawn capsule against the exact component pointer, logs both the first hit and whether it is the target body, and checks every body in the captured support cohort. RMC's end-frame dequeue, async worker start, geometry extraction and core cook remain inside the external plugin and are not individually timestampable from this module. |
@@ -863,8 +877,14 @@ round-2 matched capture source and results are under
 [`Standalone/Research/WorldAssemblerM3/Round2/`](Standalone/Research/WorldAssemblerM3/Round2/).
 `RefineLod8NativeCap` in [`Standalone/Core/src/VoxelForgeCore.cpp`](Standalone/Core/src/VoxelForgeCore.cpp)
 replaces coarse LOD8 ceiling surfaces with the planned 2D cap field while retaining ceiling skirts.
-The standalone SurfaceWorld plan composer and capture/audit entry point live in
-[`Standalone/Source/StandaloneViewer.cpp`](Standalone/Source/StandaloneViewer.cpp).
+The standalone SurfaceWorld plan composer (`AttachRound1WorldAssemblyPrototype`) lives in
+[`Standalone/Source/WorldAssemblyPrototype.h`](Standalone/Source/WorldAssemblyPrototype.h), and the
+streaming benchmark/hash pipeline (`RunPipelinedStreamingBenchmark`, `HashTileRows`) in
+[`Standalone/Source/StreamBenchmarkPipeline.h`](Standalone/Source/StreamBenchmarkPipeline.h); both are
+shared by the D3D11 viewer ([`StandaloneViewer.cpp`](Standalone/Source/StandaloneViewer.cpp), which
+keeps the capture/audit entry points) and the Linux headless tool
+([`StreamBenchmarkHeadless.cpp`](Standalone/Source/StreamBenchmarkHeadless.cpp), built by
+`Standalone/BuildLinux.sh`; see `Standalone/Research/WorldAssemblerM3/Linux1/REPORT.md`).
 
 `RunStandaloneWorldExport` in `VoxelForgeExploreCommandlet.cpp` serializes owner assets on the game
 thread to schema-v1 JSON. The adapter parses it through `ResolvedWorldSnapshot::FromJson` and keeps
@@ -992,6 +1012,131 @@ exact-density-root LOD7/8 agreement audit with its datum-offset negative control
 ARCHITECTURE §8.25 and
 [`Standalone/Research/WorldAssemblerM3/Round8/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round8/REPORT.md).
 
+### 3.14 Cold streaming admission and apply trace — World Assembler S7 / M3 Round 11
+
+`AVoxelWorld::UpdateChunksAroundPosition` writes a `scheduler_admission` record on each submission
+pass, plus `scheduler_skip` for core-readiness bypasses and all-loaded latches that still have missing
+work. The admission record includes desired/missing/pending keys by LOD, task caps, submitted attempts,
+stop level, decline reason, `bCoreRegionCompilePending`, pending-result estimate, and cumulative
+worker-task time. Rule codes are 1=full task cap, 2=near reserve, 3=all-loaded latch, 4=inner
+`LoadTile`/`LoadCoreTile` rejection, and 5=desired work still missing with apparent capacity.
+This is the trace used to separate the
+old near-reserve stop from completed-but-unapplied results counted as active. The default admission
+count uses queued/running `ActiveTaskCount`; `voxel.StreamingLegacyPendingResultCap=1` restores the
+old pending-result cap. The negative-control harness sets that together with
+`voxel.StreamingDynamicNearReserve=0`. `ProcessPendingChunks` still records result draining,
+visible-mesh applies, per-LOD counts and budget use; direct `tile` events separate worker queue,
+task time, result queue and game-thread apply. `collision_ready` records RealtimeMesh submit-to-body
+update latency. The per-frame `running_workers` sample aliases short task bursts, so use the
+cumulative task intervals for worker-seconds. `VoxelForgeExploreCommandlet.cpp` drives the staged
+owner-plan trace and moving actor check. See ARCHITECTURE §8.27–8.28 and
+[`Standalone/Research/WorldAssemblerM3/Round11/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round11/REPORT.md).
+
+### 3.15 Moving region admission and result-backlog safety trace — World Assembler S8 / M3 Round 12
+
+`core_region_compile_request/start/complete` record why the desired region is being built (initial
+set, player-center move, or same-center desired-set change), center delta, pending tiles, compile wall
+time, accumulated pending interval, independent submissions and dependent-key declines. While a
+compile is pending, `scheduler_skip.reason=core_region_compile_pending` records per-LOD missing
+counts, motion and speed. The default concurrent mode should have no global region-pending skip;
+its negative control is `voxel.CoreRegionConcurrentAdmission=0`.
+
+`walkable_gate` logs every support-center change and whether all nine required LOD0 collision tiles
+are ready there. `result_queue_frame` samples queued results, payload bytes, active tile tasks and
+the cap; `result_queue_summary` stores peak queue length/bytes and admission stops. These counters
+include slow-apply, teleport and high-speed controls added to `VoxelForgeExploreCommandlet.cpp` and
+`Tools/TestVoxelForgeCoreWorldHost.ps1`. Keep the cap negative control (`voxel.StreamingResultBacklogCap=0`)
+separate from the region-gate control. Round12 found 11/11 ready support centers at 6 m/s and 8/113
+immediately ready at 60 m/s with a 400 m teleport; see the traces under `Saved/BuildHost` and
+[`Standalone/Research/WorldAssemblerM3/Round12/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round12/REPORT.md).
+
+### 3.16 Velocity-scaled support-ring lookahead — World Assembler S9 / M3 Round 13
+
+`voxel.StreamingCollisionLookahead` defaults on; `0` is the negative control. The shared
+`GetStreamingHeadingStep` uses actor-local motion, including vertical speed. The support tile from
+`GetPlayerSupportTile` is the reference for both the active 3x3 critical ring and up to two future
+3x3 rings. `GetStreamingCollisionLookaheadTiles` aims 350 ms ahead, rounded up to whole LOD0 tiles
+and capped at two. Prediction only promotes keys already inside the desired clipmap. The
+`collision_lookahead` trace records stream/support centers, direction, speed, ring count and any
+missing desired keys. `VoxelForgeExploreCommandlet.cpp` and `Tools/TestVoxelForgeCoreWorldHost.ps1`
+accept a movement vector so the same trace covers horizontal and vertical travel. See ARCHITECTURE
+§8.30 and [`Standalone/Research/WorldAssemblerM3/Round13/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round13/REPORT.md).
+
+### 3.17 LOD8 planar far-horizon sampling — World Assembler S10 / M3 Round 14
+
+Native planar SurfaceWorld horizon refinement uses the LOD8 marching-cubes step for its interior
+grid (512 voxels / 128 m at 25 cm), retaining globally aligned 128-voxel boundary strips for tile
+and LOD joins. LOD4–LOD7 keep their previous grids. Far recipe version 3 salts changed LOD4–LOD8
+mesh outputs; density and LOD0–LOD3 output are unchanged. The ground and cap passes use the same
+coordinate lattice but still sample separately. The per-thread column cache remains local to each
+worker; no cross-worker page cache was added. Diagnostics report exclusive column, MC, ground,
+cap and output-assembly costs, plus opt-in duplicated LOD8 XY evaluations. The Standalone-only
+`--far-horizon-lod8-step=128` restores S9 sampling for the negative control. See ARCHITECTURE §8.31
+and [`Standalone/Research/WorldAssemblerM3/Round14/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round14/REPORT.md).
+
+### 3.18 Streaming worker supply and ready queue — World Assembler S12 / M3 Round 16
+
+`AVoxelWorld::LoadTile` and `LoadCoreTile` retain the existing `UE::Tasks::Launch` background
+priorities (`BackgroundHigh` for near work, `BackgroundNormal` for horizon work). The shared
+scheduler now sizes streaming admission to the TaskGraph background worker count by default
+(`voxel.StreamingBackgroundWorkerCap=1`) and admits a bounded ready queue of up to one worker-set
+(`voxel.StreamingReadyQueueDepth=8` on the 8-background-worker host). This lets UE dispatch the next
+already-admitted task as a worker becomes free without waiting for the next actor tick. Setting the
+worker cap to `0` restores the prior logical-core cap; setting queue depth to `0` restores one-slot-per
+worker admission. The moving near reserve grows with the ready queue, coarse/horizon work remains
+under its separate cap, and moving LOD0 admission is limited to the actual worker slots so far work
+cannot occupy reserved headroom. `bStreamingPlayerMoving` is a game-thread scheduler snapshot used
+by both admission helpers. `worker_backend_config`, `streaming_worker_cap_readback`, and
+`scheduler_admission` record the pool counts and effective CVar values. Per-tile trace rows record
+submit/start/end times and the OS worker thread ID. No tile generation, mesh, density, collision, or
+Core recipe output changes; recipe versions remain unchanged. See ARCHITECTURE §8.33 and
+[`Standalone/Research/WorldAssemblerM3/Round16/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round16/REPORT.md).
+
+### 3.19 Exclusive tile cost and all-LOD column overlap — World Assembler S13 / M3 Round 17
+
+`VoxelForgeCore::TileGenerationStats` now exposes classification-exclusive time and the column
+evaluation performed during marching cubes, ground refinement, and cap refinement. The BuildHost
+shared-feature audit reports these p95 stages and per-density-sample costs for owner SurfaceWorld
+tiles at LOD0, 1, 3, 4, 5, and 8. Standalone `--profile-column-overlap` opts into XY miss-coordinate
+capture for all LODs and reports repeated evaluations across same-LOD tiles and workers; the older
+`--profile-far-column-overlap` spelling remains an alias. `--profile-column-overlap` changes no
+generation output. Measurement-only stride and octave probes are confined to the shared-feature
+audit and are not runtime controls. The result and limits are recorded in
+[`Standalone/Research/WorldAssemblerM3/Round17/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round17/REPORT.md).
+
+### 3.20 MC stage audit and coarse column-cache conflicts — World Assembler S14 / M3 Round 18
+
+`Standalone/Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp` records the sampled density
+grid, cell classification, grid-gradient normals, edge interpolation, and vertex/dedup stream
+stages for the BuildHost audit. Its exact per-worker gradient memo is controlled and trace-read
+back through `voxel.CoreMCGradientMemoization`. `Standalone/Core/src/WorldAssemblerInternal.h`
+keeps the 65,536-entry worker-local column cache, using the S13 direct-map for LOD0–2 and a
+deterministic four-way set-associative route for LOD3–8; `voxel.CoreColumnCacheDirectMapped=1`
+restores the S13 path for the negative control. Runtime CVar capture lives in
+`Source/VoxelForge/Private/VoxelWorld.cpp`; stage and conflict counts are reported by
+`Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp`. The measurements, controls, and
+cold-path decision are in
+[`Standalone/Research/WorldAssemblerM3/Round18/REPORT.md`](Standalone/Research/WorldAssemblerM3/Round18/REPORT.md).
+
+### 3.21 LOD1 uniform-block proof — World Assembler M3 Linux9
+
+`FStandaloneShapeWorld::IsNativeSurfaceBox` gates the step-2 proof to a single native SurfaceWorld
+stratum. `ClassifyBoxDetailed(..., bUseNativeLatticeProof)` delegates to
+`Heightfield2D::classifyLatticeBox`, whose ground/cap extrema cover the MC lattice and normal halo.
+`UVoxelMarchingCubesMesher::GenerateMesh` sparsely fills only Mixed blocks and their sample halo;
+Mixed/Unknown remains on the fill path. The headless `--audit-uniform-block-proofs` forces sample
+verification, while `--profile-lod-work` reports per-LOD filled samples; both are off by default.
+Implementation and evidence: [`Standalone/Research/WorldAssemblerM3/Linux9/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux9/REPORT.md).
+
+### 3.22 Route-invariant Core density — World Assembler M3 Linux13
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `FStandaloneShapeWorld::SetSharedDensitySource`, `SharedDensitySource` | `Standalone/Core/src/ShapeWorldInternal.h`, bound before publication in `Standalone/Core/src/VoxelForgeCore.cpp` | Makes compiled analytic pages delegate field, lattice, detail, classification, and solid queries to the Core world's base shape; `WorldAssemblyEvaluatorVersion` is 6. |
+
+The base manifest field is authoritative for tile generation and exact queries. See ARCHITECTURE
+§8.36 and [`Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md).
+
 ## 4. The density pipeline (most-edited hot path)
 
 ### 4.1 `GetDensityWithParams` (TunnelNetwork) — VoxelGenerator.cpp:3749

Source/VoxelForge/Private/VoxelStartupTrace.cpp

@@ -5,6 +5,8 @@
 #include "Misc/CommandLine.h"
 #include "Misc/Parse.h"
 
+#include <atomic>
+
 namespace VoxelForgeStartupTrace
 {
 namespace
@@ -18,6 +20,7 @@ namespace
         int32 TileRecordsSeen = 0;
         int32 TileRecordsWritten = 0;
         int32 TileRecordsSuppressed = 0;
+        int32 ApplyFrameRecords = 0;
         TArray<FTileSample> Samples;
         TMap<FString, double> StageStarts;
         TMap<FString, double> StageTotals;
@@ -27,6 +30,7 @@ namespace
 
     FCriticalSection GTraceLock;
     TUniquePtr<FState> GState;
+    std::atomic<bool> GTraceActive{false};
 
     FString JsonEscape(const FString& In)
     {
@@ -49,9 +53,8 @@ namespace
         const FString WithNewline = Line + TEXT("\n");
         FTCHARToUTF8 Utf8(*WithNewline);
         State.Archive->Serialize(const_cast<ANSICHAR*>(Utf8.Get()), Utf8.Length());
-        // The trace is intended to remain readable if a harness terminates the editor after
-        // the steady-state record. This is bounded I/O (startup only), not the shared UE log.
-        State.Archive->Flush();
+        // The file archive buffers records; flushing every tile/request can stall the game thread.
+        // L'archive tamponne les lignes ; vider apres chaque tuile/requete peut bloquer le thread de jeu.
     }
 
     void WriteEventLocked(FState& State, const TCHAR* Type, const FString& FieldsJson)
@@ -92,7 +95,7 @@ namespace
 
     FString BuildTileGroupJson(const TArray<FTileSample>& Samples, int32 Level)
     {
-        TArray<double> Request, Queue, Generation, Classify, Mesh, Apply;
+        TArray<double> Request, Queue, WorkerTask, Generation, Classify, Mesh, Apply;
         int32 Count = 0;
         int32 Empty = 0;
         int32 AllAir = 0;
@@ -115,6 +118,7 @@ namespace
             GeometryBytes += Sample.GeometryBytes;
             Request.Add(Sample.RequestToApplySeconds);
             Queue.Add(Sample.QueueWaitSeconds);
+            WorkerTask.Add(Sample.WorkerTaskSeconds);
             Generation.Add(Sample.GenerationSeconds);
             Classify.Add(Sample.ClassifySeconds);
             Mesh.Add(Sample.MeshSeconds);
@@ -125,6 +129,7 @@ namespace
             TEXT("{\"count\":%d,\"empty\":%d,\"all_air\":%d,\"all_solid\":%d,\"mixed\":%d,\"vertices\":%lld,\"triangles\":%lld,\"geometry_bytes\":%llu,"
                  "\"request_apply_s\":{\"p50\":%s,\"p95\":%s,\"max\":%s},"
                  "\"queue_s\":{\"p50\":%s,\"p95\":%s,\"max\":%s},"
+                 "\"worker_task_s\":{\"p50\":%s,\"p95\":%s,\"max\":%s},"
                  "\"generation_s\":{\"p50\":%s,\"p95\":%s,\"max\":%s},"
                  "\"classify_s\":{\"p50\":%s,\"p95\":%s,\"max\":%s},"
                  "\"mesh_s\":{\"p50\":%s,\"p95\":%s,\"max\":%s},"
@@ -134,6 +139,7 @@ namespace
             static_cast<unsigned long long>(GeometryBytes),
             *Number(Percentile(Request, 0.50)), *Number(Percentile(Request, 0.95)), *Number(Maximum(Request)),
             *Number(Percentile(Queue, 0.50)), *Number(Percentile(Queue, 0.95)), *Number(Maximum(Queue)),
+            *Number(Percentile(WorkerTask, 0.50)), *Number(Percentile(WorkerTask, 0.95)), *Number(Maximum(WorkerTask)),
             *Number(Percentile(Generation, 0.50)), *Number(Percentile(Generation, 0.95)), *Number(Maximum(Generation)),
             *Number(Percentile(Classify, 0.50)), *Number(Percentile(Classify, 0.95)), *Number(Maximum(Classify)),
             *Number(Percentile(Mesh, 0.50)), *Number(Percentile(Mesh, 0.95)), *Number(Maximum(Mesh)),
@@ -171,11 +177,12 @@ namespace
         return FString::Printf(
             TEXT("\"reason\":\"%s\",\"wall_s\":%s,\"tile_records_seen\":%d,"
                  "\"tile_records_written\":%d,\"tile_records_suppressed\":%d,"
-                 "\"tile_record_cap\":%d,\"stage_seconds\":%s,\"tile_percentiles\":{%s}"),
+                 "\"tile_record_cap\":%d,\"apply_frame_records\":%d,"
+                 "\"stage_seconds\":%s,\"tile_percentiles\":{%s}"),
             *JsonEscape(Reason ? FString(Reason) : FString(TEXT("unknown"))),
             *Number(FPlatformTime::Seconds() - State.StartSeconds),
             State.TileRecordsSeen, State.TileRecordsWritten, State.TileRecordsSuppressed,
-            State.TileRecordCap, *Stages, *Groups);
+            State.TileRecordCap, State.ApplyFrameRecords, *Stages, *Groups);
     }
 }
 
@@ -203,6 +210,7 @@ void BeginFromCommandLine()
     NewState->StartSeconds = FPlatformTime::Seconds();
     NewState->bActive = true;
     GState = MoveTemp(NewState);
+    GTraceActive.store(true, std::memory_order_release);
     WriteEventLocked(*GState, TEXT("header"), FString::Printf(
         TEXT("\"schema\":1,\"path\":\"%s\",\"tile_record_cap\":%d"),
         *JsonEscape(GState->Path), GState->TileRecordCap));
@@ -210,8 +218,7 @@ void BeginFromCommandLine()
 
 bool IsActive()
 {
-    FScopeLock Lock(&GTraceLock);
-    return GState.IsValid() && GState->bActive;
+    return GTraceActive.load(std::memory_order_acquire);
 }
 
 void RecordEvent(const TCHAR* Type, const FString& FieldsJson)
@@ -221,6 +228,18 @@ void RecordEvent(const TCHAR* Type, const FString& FieldsJson)
     WriteEventLocked(*GState, Type, FieldsJson);
 }
 
+void RecordRequest(const FTileSample& Sample, uint32 Epoch)
+{
+    FScopeLock Lock(&GTraceLock);
+    if (!GState.IsValid() || !GState->bActive) return;
+    WriteEventLocked(*GState, TEXT("request"), FString::Printf(
+        TEXT("\"tile\":[%d,%d,%d],\"level\":%d,\"priority\":%d,"
+             "\"request_ordinal\":%llu,\"epoch\":%u,\"resident_at_request\":%d"),
+        Sample.TileX, Sample.TileY, Sample.TileZ, Sample.Level, Sample.WorkPriority,
+        static_cast<unsigned long long>(Sample.RequestOrdinal), Epoch,
+        Sample.bResidentAtRequest ? 1 : 0));
+}
+
 void StageBegin(const TCHAR* Name)
 {
     if (Name == nullptr) return;
@@ -265,24 +284,92 @@ void RecordTile(const FTileSample& Sample)
 
     GState->Samples.Add(Sample);
     ++GState->TileRecordsWritten;
+    const double TraceNowSeconds = FPlatformTime::Seconds() - GState->StartSeconds;
+    const double SubmittedAtSeconds = Sample.RequestStartCycles != 0
+        ? TraceNowSeconds - Sample.RequestToApplySeconds : -1.0;
+    const double WorkerStartedAtSeconds = Sample.WorkerTaskStartCycles != 0
+        ? SubmittedAtSeconds + Sample.WorkerQueueSeconds : -1.0;
+    const double WorkerEndedAtSeconds = Sample.WorkerTaskEndCycles != 0
+        ? WorkerStartedAtSeconds + Sample.WorkerTaskSeconds : -1.0;
     WriteEventLocked(*GState, TEXT("tile"), FString::Printf(
-        TEXT("\"tile\":[%d,%d,%d],\"level\":%d,\"verdict\":%d,\"proof\":%d,\"empty\":%d,\"vertices\":%d,\"triangles\":%d,\"geometry_bytes\":%llu,"
-             "\"request_to_apply_s\":%s,\"queue_wait_s\":%s,\"worker_queue_s\":%s,\"result_queue_s\":%s,"
+        TEXT("\"tile\":[%d,%d,%d],\"level\":%d,\"priority\":%d,"
+             "\"request_ordinal\":%llu,\"generation_ordinal\":%llu,\"resident_at_request\":%d,"
+             "\"submitted_t_s\":%s,\"worker_start_t_s\":%s,\"worker_end_t_s\":%s,\"worker_thread_id\":%u,"
+             "\"verdict\":%d,\"proof\":%d,\"empty\":%d,\"vertices\":%d,\"triangles\":%d,\"geometry_bytes\":%llu,"
+             "\"request_to_apply_s\":%s,\"queue_wait_s\":%s,\"worker_queue_s\":%s,\"result_queue_s\":%s,\"worker_task_s\":%s,"
              "\"generation_s\":%s,\"classify_s\":%s,\"mesh_s\":%s,\"stream_s\":%s,\"apply_s\":%s"),
         Sample.TileX, Sample.TileY, Sample.TileZ,
-        Sample.Level, Sample.Verdict, Sample.bSealedSolidProof ? 1 : 0,
+        Sample.Level, Sample.WorkPriority,
+        static_cast<unsigned long long>(Sample.RequestOrdinal),
+        static_cast<unsigned long long>(Sample.GenerationOrdinal),
+        Sample.bResidentAtRequest ? 1 : 0,
+        *Number(SubmittedAtSeconds),
+        *Number(WorkerStartedAtSeconds),
+        *Number(WorkerEndedAtSeconds),
+        Sample.WorkerThreadId,
+        Sample.Verdict, Sample.bSealedSolidProof ? 1 : 0,
         Sample.bEmpty ? 1 : 0, Sample.Vertices, Sample.Triangles,
         static_cast<unsigned long long>(Sample.GeometryBytes),
         *Number(Sample.RequestToApplySeconds), *Number(Sample.QueueWaitSeconds),
         *Number(Sample.WorkerQueueSeconds), *Number(Sample.ResultQueueSeconds),
+        *Number(Sample.WorkerTaskSeconds),
         *Number(Sample.GenerationSeconds), *Number(Sample.ClassifySeconds),
         *Number(Sample.MeshSeconds), *Number(Sample.StreamSeconds), *Number(Sample.ApplySeconds)));
 }
 
+void RecordApplyFrame(const FApplyFrameSample& Sample)
+{
+    FScopeLock Lock(&GTraceLock);
+    if (!GState.IsValid() || !GState->bActive) return;
+
+    FString PendingByLevel = TEXT("[");
+    FString ApplyResultsByLevel = TEXT("[");
+    FString MeshesByLevel = TEXT("[");
+    FString ApplyMillisecondsByLevel = TEXT("[");
+    for (int32 Level = 0; Level < 9; ++Level)
+    {
+        if (Level > 0)
+        {
+            PendingByLevel += TEXT(",");
+            ApplyResultsByLevel += TEXT(",");
+            MeshesByLevel += TEXT(",");
+            ApplyMillisecondsByLevel += TEXT(",");
+        }
+        PendingByLevel += FString::FromInt(Sample.PendingByLevel[Level]);
+        ApplyResultsByLevel += FString::FromInt(Sample.ApplyResultsByLevel[Level]);
+        MeshesByLevel += FString::FromInt(Sample.MeshesAppliedByLevel[Level]);
+        ApplyMillisecondsByLevel += Number(Sample.ApplySecondsByLevel[Level] * 1000.0);
+    }
+    PendingByLevel += TEXT("]");
+    ApplyResultsByLevel += TEXT("]");
+    MeshesByLevel += TEXT("]");
+    ApplyMillisecondsByLevel += TEXT("]");
+
+    ++GState->ApplyFrameRecords;
+    WriteEventLocked(*GState, TEXT("apply_frame"), FString::Printf(
+        TEXT("\"frame\":%llu,\"frame_ms\":%s,\"speed_cm_s\":%s,\"apply_ms\":%s,\"drain_ms\":%s,"
+             "\"active_tasks\":%d,\"running_workers\":%d,\"task_cap\":%d,"
+             "\"pending_tiles\":%d,\"pending_results_estimate\":%d,"
+             "\"results_drained\":%d,\"apply_results\":%d,\"meshes_applied\":%d,\"max_applies\":%d,"
+             "\"apply_budget_ms\":%s,\"count_limit_reached\":%d,\"time_limit_reached\":%d,"
+             "\"pending_by_lod\":%s,\"apply_results_by_lod\":%s,"
+             "\"meshes_by_lod\":%s,\"apply_ms_by_lod\":%s"),
+        static_cast<unsigned long long>(Sample.Frame),
+        *Number(Sample.FrameSeconds * 1000.0), *Number(Sample.SpeedCmPerSecond),
+        *Number(Sample.ApplySeconds * 1000.0), *Number(Sample.DrainSeconds * 1000.0), Sample.ActiveTasks,
+        Sample.RunningWorkerTasks, Sample.TaskCap, Sample.PendingTiles,
+        Sample.PendingResultsEstimate, Sample.ResultsDrained, Sample.ApplyResultsByLevelTotal,
+        Sample.MeshesApplied,
+        Sample.MaxApplies, *Number(Sample.ApplyBudgetMilliseconds),
+        Sample.bCountLimitReached ? 1 : 0, Sample.bTimeLimitReached ? 1 : 0,
+        *PendingByLevel, *ApplyResultsByLevel, *MeshesByLevel, *ApplyMillisecondsByLevel));
+}
+
 void Finish(const TCHAR* Reason)
 {
     FScopeLock Lock(&GTraceLock);
     if (!GState.IsValid() || !GState->bActive) return;
+    GTraceActive.store(false, std::memory_order_release);
 
     // Close any stage left open by an abnormal early exit so the summary remains useful.
     const double Now = FPlatformTime::Seconds();

Source/VoxelForge/Public/VoxelStartupTrace.h

@@ -13,7 +13,15 @@ namespace VoxelForgeStartupTrace
         int32 TileY = 0;
         int32 TileZ = 0;
         int32 Level = -1;
+        int32 WorkPriority = 0;
         int32 Verdict = -1; // Mixed=0, AllSolid=1, AllAir=2, -1=not classified (early path)
+        uint64 RequestOrdinal = 0;
+        uint64 GenerationOrdinal = 0;
+        uint64 RequestStartCycles = 0;
+        uint64 WorkerTaskStartCycles = 0;
+        uint64 WorkerTaskEndCycles = 0;
+        uint32 WorkerThreadId = 0;
+        bool bResidentAtRequest = false;
         bool bSealedSolidProof = false;
         bool bEmpty = true;
         int32 Vertices = 0;
@@ -25,6 +33,7 @@ namespace VoxelForgeStartupTrace
         double QueueWaitSeconds = 0.0;
         double WorkerQueueSeconds = 0.0;
         double ResultQueueSeconds = 0.0;
+        double WorkerTaskSeconds = 0.0;
         double GenerationSeconds = 0.0;
         double ClassifySeconds = 0.0;
         double MeshSeconds = 0.0;
@@ -32,6 +41,31 @@ namespace VoxelForgeStartupTrace
         double ApplySeconds = 0.0;
     };
 
+    struct VOXELFORGE_API FApplyFrameSample
+    {
+        uint64 Frame = 0;
+        double FrameSeconds = 0.0;
+        double SpeedCmPerSecond = 0.0;
+        double ApplySeconds = 0.0;
+        double DrainSeconds = 0.0;
+        int32 ActiveTasks = 0;
+        int32 RunningWorkerTasks = 0;
+        int32 TaskCap = 0;
+        int32 PendingTiles = 0;
+        int32 PendingResultsEstimate = 0;
+        int32 ResultsDrained = 0;
+        int32 ApplyResultsByLevelTotal = 0;
+        int32 MeshesApplied = 0;
+        int32 MaxApplies = 0;
+        double ApplyBudgetMilliseconds = 0.0;
+        bool bCountLimitReached = false;
+        bool bTimeLimitReached = false;
+        TStaticArray<int32, 9> PendingByLevel{};
+        TStaticArray<int32, 9> ApplyResultsByLevel{};
+        TStaticArray<int32, 9> MeshesAppliedByLevel{};
+        TStaticArray<double, 9> ApplySecondsByLevel{};
+    };
+
     /** Starts when -voxel.StartupTraceFile=<absolute path> is present. */
     VOXELFORGE_API void BeginFromCommandLine();
 
@@ -40,11 +74,17 @@ namespace VoxelForgeStartupTrace
     /** FieldsJson is the contents after the type/timestamp object prefix, without braces. */
     VOXELFORGE_API void RecordEvent(const TCHAR* Type, const FString& FieldsJson = FString());
 
+    VOXELFORGE_API void RecordRequest(const FTileSample& Sample, uint32 Epoch);
+
     VOXELFORGE_API void StageBegin(const TCHAR* Name);
     VOXELFORGE_API void StageEnd(const TCHAR* Name);
 
     VOXELFORGE_API void RecordTile(const FTileSample& Sample);
 
+    /** One game-thread result-drain sample, including worker occupancy and per-LOD applies. */
+    /** Echantillon de vidage des resultats, avec occupation des travailleurs et applications par LOD. */
+    VOXELFORGE_API void RecordApplyFrame(const FApplyFrameSample& Sample);
+
     /** Writes the final bounded summary and closes the file. Safe to call more than once. */
     VOXELFORGE_API void Finish(const TCHAR* Reason);
 

Source/VoxelForge/Public/VoxelWorld.h

@@ -132,6 +132,14 @@ struct FChunkResult
     // opt-in profile. It is carried through the worker queue so the report can separate scheduler
     // wait from generation time.
     uint64 RequestStartCycles = 0;
+    // Full background-task boundaries include stream conversion and result packaging around the
+    // generator call; they let the trace reconcile per-tile worker-seconds with worker occupancy.
+    // Les bornes de tâche incluent la conversion et la préparation du résultat autour du générateur.
+    uint64 WorkerTaskStartCycles = 0;
+    uint64 WorkerTaskEndCycles = 0;
+    // Operating-system thread id identifies the physical worker slot used by this tile.
+    // L'identifiant du thread systeme repere le slot worker utilise par cette tuile.
+    uint32 WorkerThreadId = 0;
     // Worker timing boundaries for separating scheduler wait from generation and result/apply wait.
     // These are captured with low overhead for the clean streaming-latency summary; expensive
     // per-tile profiling remains opt-in.
@@ -139,6 +147,11 @@ struct FChunkResult
     uint64 GenerationEndCycles = 0;
     uint64 ApplyStartCycles = 0;
     EVoxelTileWorkPriority WorkPriority = EVoxelTileWorkPriority::Horizon;
+    // Ordinals make admitted order and actual worker start order auditable across MPSC results.
+    // Les numeros d'ordre rendent auditables l'admission et le demarrage des workers via MPSC.
+    uint64 RequestOrdinal = 0;
+    uint64 GenerationOrdinal = 0;
+    bool bResidentAtRequest = false;
     // Step-1-only tag captured on the game thread for the pawn's bounded support cohort.
     bool bStep1SupportCohort = false;
     int32 ClassifyVerdict = -1; double ClassifySeconds = 0.0; double MeshSeconds = 0.0; double StreamSeconds = 0.0; int32 NumTriangles = 0; int32 NumCeilingTriangles = 0; int32 NumSkirtTriangles = 0;
@@ -433,7 +446,13 @@ public:
      *  capped to (logical cores − 2) so small CPUs don't thrash on a flat 16 (background
      *  priority stops frame starvation, not the context-switch overhead). */
     int32 GetMaxConcurrentTasks() const;
+    int32 GetMaxConcurrentStreamingTasks() const;
+    /** Submitted generation tasks still queued or running; completed MPSC results do not occupy admission.
+     *  Taches de generation soumises, en file ou en cours ; les resultats MPSC termines ne bloquent pas l'admission. */
     int32 GetActiveGenerationTaskCount() const;
+    /** Count queued/running work for admission; the legacy CVar can include finished results awaiting apply.
+     *  Compter le travail en file/en cours ; le CVar de compatibilite peut inclure les resultats finis en attente. */
+    int32 GetGenerationAdmissionCount() const;
     /** Reserve task slots for collision-critical/edit/LOD0 work; far work uses the remainder. */
     int32 GetNearTaskReserve(int32 MaxTasks) const;
 
@@ -687,8 +706,17 @@ private:
     void BuildCoreDesiredTiles(const FIntVector& Center, const FVector& PlayerPosition,
                                APawn* PlayerPawn, const FVector& PlayerHeading,
                                TArray<FVoxelTileKey>& OutLeavers);
+    FIntVector GetStreamingHeadingStep(const FVector& PlayerHeading,
+                                       const APawn* PlayerPawn) const;
+    int32 GetStreamingCollisionLookaheadTiles(const FVector& PlayerHeading,
+                                              const FIntVector& HeadingStep) const;
     void StartPendingCoreRegionCompile();
     void LoadCoreTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority WorkPriority);
+    void EnqueueStreamingResult(FChunkResult&& Result);
+    void RecordStreamingResultDequeued(const FChunkResult& Result);
+    uint64 GetStreamingResultPayloadBytes(const FChunkResult& Result) const;
+    int32 GetStreamingResultBacklogCount() const;
+    bool IsStreamingResultBacklogCapped() const;
     void ApplyCoreModification(const FVoxelModification& Modification);
     void BuildDesiredTransitionIndex();
     float GetActiveVoxelSizeCm() const;
@@ -753,7 +781,20 @@ private:
     FVector CoreFallbackCenterLocalCm = FVector::ZeroVector;
     bool bCoreRegionCompilePending = false;
     TArray<FVoxelTileKey> PendingCoreRegionTiles;
+    TSet<FVoxelTileKey> PendingCoreRegionTileSet;
     TArray<FVoxelTileKey> PendingCoreRetainedTiles;
+    TSet<FVoxelTileKey> CoreRegionCompileTilesInFlight;
+    FIntVector LastCoreRegionRequestCenter = FIntVector(MAX_int32, MAX_int32, MAX_int32);
+    FIntVector PendingCoreRegionRequestCenter = FIntVector::ZeroValue;
+    FIntVector ActiveCoreRegionCompileCenter = FIntVector::ZeroValue;
+    bool bHasLastCoreRegionRequestCenter = false;
+    double CoreRegionPendingSinceSeconds = 0.0;
+    double ActiveCoreRegionCompileStartSeconds = 0.0;
+    uint64 ActiveCoreRegionCompileStartCycles = 0;
+    uint64 CoreRegionIndependentSubmissions = 0;
+    uint64 CoreRegionDependentDeclines = 0;
+    int32 CoreRegionCompileRequestSerial = 0;
+    int32 ActiveCoreRegionCompileRequestSerial = 0;
 
 public:
 
@@ -1083,7 +1124,19 @@ public:
     TQueue<FChunkResult, EQueueMode::Mpsc> EditedProcessQueue;
     TQueue<FChunkResult, EQueueMode::Mpsc> NearProcessQueue;
     TQueue<FChunkResult, EQueueMode::Mpsc> ProcessQueue;
-    TSet<FVoxelTileKey> PendingTiles;   // tiles with a gen task in flight
+    // The cap counts completed MPSC results plus admitted tile tasks, so a slow game-thread apply
+    // cannot accumulate an unbounded payload queue while completed work never consumes worker slots.
+    // Le plafond compte les resultats MPSC et les taches admises; un apply lent ne peut donc pas
+    // accumuler sans limite, et les resultats termines ne reprennent pas de slot worker.
+    std::atomic<int32> QueuedStreamingResultCount{0};
+    std::atomic<uint64> QueuedStreamingResultBytes{0};
+    std::atomic<int32> PeakQueuedStreamingResultCount{0};
+    std::atomic<uint64> PeakQueuedStreamingResultBytes{0};
+    std::atomic<int32> ActiveTileTaskCount{0};
+    std::atomic<uint64> StreamingResultBacklogCapStops{0};
+    // Keys stay pending from task submission until the game thread applies the result; completed results can wait here.
+    // Les cles restent en attente de la soumission jusqu'a l'application sur le thread de jeu ; les resultats termines y attendent.
+    TSet<FVoxelTileKey> PendingTiles;
     // Game-thread-owned map; workers retain the shared token and only read its atomic flag.
     TMap<FVoxelTileKey, TSharedPtr<FVoxelTileCancellationState, ESPMode::ThreadSafe>>
         PendingTileCancellation;
@@ -1111,8 +1164,12 @@ public:
     // Active pendant les mutations de génération lancées par l'éditeur, sans signifier la destruction.
     std::atomic<bool> bGenerationPaused{false};
 
-    // Number of async tasks currently running — EndPlay waits for this to reach 0
+    // Submitted async tasks (including UE-queued work) — EndPlay waits for this to reach 0.
+    // Taches asynchrones soumises (y compris la file UE) — EndPlay attend que le compteur revienne a 0.
     std::atomic<int32> ActiveTaskCount{0};
+    // Active workers are counted inside the launched tile task, distinct from tasks queued by UE.
+    // Les travailleurs actifs sont comptes dans la tache de tuile, distincts des taches en attente UE.
+    std::atomic<int32> ActiveGenerationWorkerCount{0};
 
     FORCEINLINE bool ShouldAbortWork(const std::atomic<bool>* ObsoleteFlag = nullptr) const
     {
@@ -1170,6 +1227,12 @@ public:
     bool bAllChunksLoaded = false;
     bool bStartupTraceDesiredRecorded = false;
     bool bSampleStacksStarted = false;
+    bool bStartupApplyBoostStarted = false;
+    bool bStartupApplyBoostEnded = false;
+    // Trace the resolved startup budget once per world. / Tracer une fois le budget de demarrage resolu par monde.
+    bool bStartupApplyConfigTraced = false;
+    uint64 LastApplyFrameCycles = 0;
+    float StartupTraceSpeedCmPerSecond = 0.0f;
     TArray<FVoxelTileKey> DesiredSorted;   // critical floor prefix, then true-pawn distance-first
     TArray<FVoxelTileKey> CriticalDesiredTiles; // occupied/support tile, then heading tile
     // Ancestor -> desired descendants, rebuilt with DesiredSorted. Reconciliation uses this
@@ -1179,6 +1242,15 @@ public:
     uint32 DesiredEpoch = 0;               // increments whenever DesiredStamped is rebuilt
     int32 ObsoleteTileAbortCount = 0;      // cumulative per-world moving-session cancellation count
     float PeakObservedPawnSpeedCmPerSecond = 0.0f;
+    int32 EffectiveNearTaskReserve = -1;
+    bool bStreamingPlayerMoving = false;  // GT snapshot consumed by admission helpers / instantane GT pour les admissions
+    uint64 NextStreamingRequestOrdinal = 0;
+    std::atomic<uint64> NextStreamingGenerationOrdinal{0};
+    // Cumulative worker-task wall cycles avoid aliasing the instantaneous per-frame counter.
+    // Les cycles cumules des taches evitent l'aliasing du compteur instantane echantillonne par frame.
+    std::atomic<uint64> TotalGenerationWorkerTaskCycles{0};
+    double LastStreamingSchedulerSampleSeconds = 0.0;
+    uint64 LastStreamingSchedulerWorkerCycles = 0;
 
     struct FReadyTransitionVisibilitySample
     {
@@ -1257,6 +1329,11 @@ public:
     bool bHeadlessStreamingTestExitOnSteady = false;
     bool bHeadlessStreamingTestExitRequested = false;
     bool bStartupTraceThroughCrossing = false;
+    bool bStartupTraceUntilEndPlay = false;
+    bool bHasLastWalkableGateSample = false;
+    bool bLastWalkableGateReady = false;
+    FIntVector LastWalkableGateCenter = FIntVector::ZeroValue;
+    double LastStreamingTraceSampleSeconds = 0.0;
     bool bHeadlessStreamingTestCenterOverride = false;
     FVector HeadlessStreamingTestCenterVoxel = FVector::ZeroVector;
     int32 HeadlessStreamingTestMoveAttempts = 0;
@@ -1264,6 +1341,9 @@ public:
     float HeadlessStreamingTestSpeedCmPerSecond = 0.0f;
     float HeadlessStreamingTestStartSeconds = 0.0f;
     float HeadlessStreamingTestExitSeconds = 0.0f;
+    float HeadlessStreamingTestTeleportAtSeconds = 0.0f;
+    float HeadlessStreamingTestTeleportDistanceCm = 0.0f;
+    bool bHeadlessStreamingTestTeleportDone = false;
     FVector HeadlessStreamingTestDirection = FVector::XAxisVector;
     FVector HeadlessStreamingTestLastActualPosition = FVector::ZeroVector;
     double HeadlessStreamingTestBeginSeconds = 0.0;

Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp

@@ -72,6 +72,7 @@
 #include "VoxelTerrainOpDefinition.h"
 #include "VoxelTypes.h"
 #include "VoxelWorld.h"
+#include "VoxelStartupTrace.h"
 #include "VoxelForgeCoreAssetAdapter.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 
@@ -878,6 +879,7 @@ struct FExploreArguments
     int32 PassageFloorWrites = 1;
     bool bStandaloneWorldExport = false;
     bool bCoreWorldTest = false;
+    bool bCoreWorldStreamTraceOnly = false;
     bool bRenderCameraOverride = false;
     FVector RenderCamera = FVector::ZeroVector;
     bool bRenderTargetOverride = false;
@@ -923,6 +925,9 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
     int32 CoreWorldTest = 0;
     FParse::Value(*Params, TEXT("coreworldtest="), CoreWorldTest);
     OutArguments.bCoreWorldTest = CoreWorldTest != 0;
+    int32 CoreWorldStreamTraceOnly = 0;
+    FParse::Value(*Params, TEXT("coreworldstreamtrace="), CoreWorldStreamTraceOnly);
+    OutArguments.bCoreWorldStreamTraceOnly = CoreWorldStreamTraceOnly != 0;
     FParse::Value(*Params, TEXT("corevoxelsizecm="), OutArguments.CoreVoxelSizeCm);
     if (!FMath::IsFinite(OutArguments.CoreVoxelSizeCm)
         || OutArguments.CoreVoxelSizeCm < VOXEL_SIZE
@@ -1499,6 +1504,11 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
         OutError = TEXT("coreworldtest requires settingsref and must omit strateref.");
         return false;
     }
+    if (OutArguments.bCoreWorldStreamTraceOnly && !OutArguments.bCoreWorldTest)
+    {
+        OutError = TEXT("coreworldstreamtrace requires coreworldtest.");
+        return false;
+    }
     if ((OutArguments.bCoreHybridMesher || OutArguments.bCoreHybridFixturePlacement
             || OutArguments.bCoreHybridCliffOnly || OutArguments.bCoreHybridFixturesOnly
             || OutArguments.bCoreFloatingIslandTest || OutArguments.bCoreFallbackTest
@@ -15930,67 +15940,472 @@ bool RunCoreSharedFeatureCostAudit(VoxelForgeCore::World& World,
     const std::vector<VoxelForgeCore::TileKey>& Keys,const TCHAR* Label,
     const VoxelForgeCore::WorldAssemblyManifest* Assembly,FString& OutError)
 {
-    for (const int32 LOD : {0,1,7,8})
+    if(Assembly!=nullptr&&FCString::Stricmp(Label,TEXT("surface"))==0)
+    {
+        struct FProbeColumn
+        {
+            std::int64_t Ground=0;
+            std::int64_t Cap=0;
+        };
+        const auto P95=[](TArray<double> Values)
+        { Values.Sort(); return Values.IsEmpty() ? 0.0 : Values[FMath::Clamp(
+            FMath::CeilToInt(Values.Num()*0.95f)-1,0,Values.Num()-1)]; };
+        const auto MaxValue=[](const TArray<double>& Values)
+        { return Values.IsEmpty() ? 0.0 : *std::max_element(Values.GetData(),Values.GetData()+Values.Num()); };
+        const std::int32_t TileVoxelCount=static_cast<std::int32_t>(
+            World.configuration().tileVoxelCount);
+        constexpr std::int64_t Subvoxels=VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
+        constexpr double CoreVoxelSizeCm=25.0;
+        for(const std::int32_t LOD:{0,1,3,4,5,8})
+        {
+            for(const std::int32_t Stride:{2,4})
+            {
+                const std::int32_t Cells=LOD<World.configuration().fullResolutionLodCount
+                    ?TileVoxelCount:std::max(1,World.configuration().coarseTileCells);
+                TArray<double> GroundErrorsCm,CapErrorsCm,BaselineColumnMs,CandidateColumnMs;
+                std::uint64_t BaselineColumns=0,CandidateColumns=0,FiniteFeatureTiles=0;
+                std::int32_t Tiles=0;
+                for(const auto& Key:Keys)
+                {
+                    if(Key.lod!=LOD||Tiles>=2)continue;
+                    const std::int64_t TileExtent=static_cast<std::int64_t>(TileVoxelCount)<<LOD;
+                    const std::int64_t TileStep=TileExtent/Cells;
+                    const std::int64_t OriginX=static_cast<std::int64_t>(Key.coordinate.x)*TileExtent;
+                    const std::int64_t OriginY=static_cast<std::int64_t>(Key.coordinate.y)*TileExtent;
+                    const std::int64_t OriginZ=static_cast<std::int64_t>(Key.coordinate.z)*TileExtent;
+                    const std::int64_t TileMinimumZ=OriginZ;
+                    const std::int64_t TileMaximumZ=OriginZ+TileExtent;
+                    const auto PlanIt=std::find_if(Assembly->plan.strates.begin(),
+                        Assembly->plan.strates.end(),[TileMinimumZ,TileMaximumZ,TileVoxelCount](const auto& Plan)
+                        {
+                            const std::int64_t PlanMinimumZ=static_cast<std::int64_t>(
+                                std::min(Plan.bottomChunkZ,Plan.topChunkZ))*TileVoxelCount;
+                            const std::int64_t PlanMaximumZ=(static_cast<std::int64_t>(
+                                std::max(Plan.bottomChunkZ,Plan.topChunkZ))+1)*TileVoxelCount;
+                            return TileMinimumZ<=PlanMaximumZ&&TileMaximumZ>=PlanMinimumZ;
+                        });
+                    if(PlanIt==Assembly->plan.strates.end())continue;
+
+                    const VoxelForgeCore::Heightfield2D Field(Assembly->recipe,*PlanIt);
+                    if(!Field.isValid())continue;
+                    const std::array<std::int64_t,3> Minimum={
+                        (OriginX-TileStep)*Subvoxels,(OriginY-TileStep)*Subvoxels,
+                        (OriginZ-TileStep)*Subvoxels};
+                    const std::array<std::int64_t,3> Maximum={
+                        (OriginX+TileExtent+TileStep)*Subvoxels,
+                        (OriginY+TileExtent+TileStep)*Subvoxels,
+                        (OriginZ+TileExtent+TileStep)*Subvoxels};
+                    std::vector<VoxelForgeCore::WorldAssemblyFeatureQueryV1> Queries;
+                    Queries.push_back({Field.recipe(),Field.plan(),Field.buildFeatureTileList(Minimum,Maximum)});
+                    const VoxelForgeCore::ScopedWorldAssemblyFeatureQueriesV1 QueryScope{
+                        std::span<const VoxelForgeCore::WorldAssemblyFeatureQueryV1>(Queries)};
+                    const bool bHasFiniteFeature=std::any_of(PlanIt->features.begin(),
+                        PlanIt->features.end(),[&](const auto& Feature)
+                        {
+                            return (Feature.type==2||Feature.type==4)
+                                &&Feature.minimumSubvoxels[0]<=Maximum[0]
+                                &&Feature.maximumSubvoxels[0]>=Minimum[0]
+                                &&Feature.minimumSubvoxels[1]<=Maximum[1]
+                                &&Feature.maximumSubvoxels[1]>=Minimum[1]
+                                &&Feature.minimumSubvoxels[2]<=Maximum[2]
+                                &&Feature.maximumSubvoxels[2]>=Minimum[2];
+                        });
+                    if(bHasFiniteFeature)++FiniteFeatureTiles;
+
+                    std::vector<FProbeColumn> Exact(static_cast<std::size_t>(Cells+1)*(Cells+1));
+                    VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true);
+                    for(std::int32_t Y=0;Y<=Cells;++Y)
+                    for(std::int32_t X=0;X<=Cells;++X)
+                    {
+                        const auto Sample=Field.point((OriginX+X*TileStep)*Subvoxels,
+                            (OriginY+Y*TileStep)*Subvoxels,0);
+                        Exact[static_cast<std::size_t>(Y)*(Cells+1)+X]={
+                            Sample.groundHeightSubvoxels,Sample.capHeightSubvoxels};
+                    }
+                    const auto& BaselineStats=VoxelForgeCore::Heightfield2D::threadColumnCacheStats();
+                    BaselineColumnMs.Add(BaselineStats.columnComputeMilliseconds);
+                    BaselineColumns+=BaselineStats.columnMisses;
+
+                    std::vector<std::int32_t> Axis;
+                    for(std::int32_t Index=0;Index<=Cells;Index+=Stride)Axis.push_back(Index);
+                    if(Axis.empty()||Axis.back()!=Cells)Axis.push_back(Cells);
+                    std::vector<FProbeColumn> Coarse(static_cast<std::size_t>(Axis.size())*Axis.size());
+                    VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true);
+                    for(std::size_t Y=0;Y<Axis.size();++Y)
+                    for(std::size_t X=0;X<Axis.size();++X)
+                    {
+                        const auto Sample=Field.point((OriginX+Axis[X]*TileStep)*Subvoxels,
+                            (OriginY+Axis[Y]*TileStep)*Subvoxels,0);
+                        Coarse[Y*Axis.size()+X]={Sample.groundHeightSubvoxels,
+                            Sample.capHeightSubvoxels};
+                    }
+                    const auto& CandidateStats=VoxelForgeCore::Heightfield2D::threadColumnCacheStats();
+                    CandidateColumnMs.Add(CandidateStats.columnComputeMilliseconds);
+                    CandidateColumns+=CandidateStats.columnMisses;
+                    const auto Bracket=[&Axis](std::int32_t Value)
+                    {
+                        const auto Upper=std::upper_bound(Axis.begin(),Axis.end(),Value);
+                        const std::size_t High=Upper==Axis.end()?Axis.size()-1
+                            :static_cast<std::size_t>(Upper-Axis.begin());
+                        const std::size_t Low=High==0?0:High-1;
+                        return std::pair<std::size_t,std::size_t>{Low,High};
+                    };
+                    const auto Lerp=[](double A,double B,double T){return A+(B-A)*T;};
+                    for(std::int32_t Y=0;Y<=Cells;++Y)
+                    for(std::int32_t X=0;X<=Cells;++X)
+                    {
+                        const auto [X0,X1]=Bracket(X);
+                        const auto [Y0,Y1]=Bracket(Y);
+                        const double TX=Axis[X1]==Axis[X0]?0.0
+                            :static_cast<double>(X-Axis[X0])/(Axis[X1]-Axis[X0]);
+                        const double TY=Axis[Y1]==Axis[Y0]?0.0
+                            :static_cast<double>(Y-Axis[Y0])/(Axis[Y1]-Axis[Y0]);
+                        const auto& C00=Coarse[Y0*Axis.size()+X0];
+                        const auto& C10=Coarse[Y0*Axis.size()+X1];
+                        const auto& C01=Coarse[Y1*Axis.size()+X0];
+                        const auto& C11=Coarse[Y1*Axis.size()+X1];
+                        const double Ground=Lerp(Lerp(static_cast<double>(C00.Ground),
+                            static_cast<double>(C10.Ground),TX),Lerp(static_cast<double>(C01.Ground),
+                            static_cast<double>(C11.Ground),TX),TY);
+                        const double Cap=Lerp(Lerp(static_cast<double>(C00.Cap),
+                            static_cast<double>(C10.Cap),TX),Lerp(static_cast<double>(C01.Cap),
+                            static_cast<double>(C11.Cap),TX),TY);
+                        const auto& Reference=Exact[static_cast<std::size_t>(Y)*(Cells+1)+X];
+                        GroundErrorsCm.Add(std::abs(Ground-Reference.Ground)*CoreVoxelSizeCm/Subvoxels);
+                        CapErrorsCm.Add(std::abs(Cap-Reference.Cap)*CoreVoxelSizeCm/Subvoxels);
+                    }
+                    ++Tiles;
+                }
+                std::uint64_t GroundOver2Cm=0,CapOver2Cm=0;
+                for(const double Error:GroundErrorsCm)if(Error>2.0)++GroundOver2Cm;
+                for(const double Error:CapErrorsCm)if(Error>2.0)++CapOver2Cm;
+                double BaselineAverageMs=0.0,CandidateAverageMs=0.0;
+                for(const double Value:BaselineColumnMs)BaselineAverageMs+=Value;
+                for(const double Value:CandidateColumnMs)CandidateAverageMs+=Value;
+                if(!BaselineColumnMs.IsEmpty())BaselineAverageMs/=BaselineColumnMs.Num();
+                if(!CandidateColumnMs.IsEmpty())CandidateAverageMs/=CandidateColumnMs.Num();
+                UE_LOG(LogTemp,Display,
+                    TEXT("[WorldAssemblerInterpolationProbe] label=%s lod=%d tiles=%d stride_samples=%d exact_column_evals=%llu coarse_column_evals=%llu column_eval_saving_pct=%.2f baseline_column_avg_ms=%.5f coarse_column_avg_ms=%.5f ground_error_p95_cm=%.4f ground_error_max_cm=%.4f ground_over_2cm=%llu/%d cap_error_p95_cm=%.4f cap_error_max_cm=%.4f cap_over_2cm=%llu/%d finite_feature_tiles=%llu fallback=none"),
+                    TEXT("surface"),LOD,Tiles,Stride,
+                    static_cast<unsigned long long>(BaselineColumns),
+                    static_cast<unsigned long long>(CandidateColumns),
+                    BaselineAverageMs>0.0?100.0*(1.0-CandidateAverageMs/BaselineAverageMs):0.0,
+                    BaselineAverageMs,CandidateAverageMs,
+                    P95(GroundErrorsCm),MaxValue(GroundErrorsCm),
+                    static_cast<unsigned long long>(GroundOver2Cm),GroundErrorsCm.Num(),
+                    P95(CapErrorsCm),MaxValue(CapErrorsCm),
+                    static_cast<unsigned long long>(CapOver2Cm),CapErrorsCm.Num(),
+                    static_cast<unsigned long long>(FiniteFeatureTiles));
+            }
+        }
+        for(const std::int32_t LOD:{0,1,3,4,5,8})
+        for(const std::uint32_t Drop:{1u,2u})
+        {
+            const std::int32_t Cells=LOD<World.configuration().fullResolutionLodCount
+                ?TileVoxelCount:std::max(1,World.configuration().coarseTileCells);
+            TArray<double> GroundErrorsCm,CapErrorsCm,BaselineColumnMs,CandidateColumnMs;
+            std::uint64_t BaselineColumns=0,CandidateColumns=0,FiniteFeatureTiles=0;
+            std::int32_t Tiles=0;
+            for(const auto& Key:Keys)
+            {
+                if(Key.lod!=LOD||Tiles>=2)continue;
+                const std::int64_t TileExtent=static_cast<std::int64_t>(TileVoxelCount)<<LOD;
+                const std::int64_t TileStep=TileExtent/Cells;
+                const std::int64_t OriginX=static_cast<std::int64_t>(Key.coordinate.x)*TileExtent;
+                const std::int64_t OriginY=static_cast<std::int64_t>(Key.coordinate.y)*TileExtent;
+                const std::int64_t OriginZ=static_cast<std::int64_t>(Key.coordinate.z)*TileExtent;
+                const std::int64_t TileMinimumZ=OriginZ,TileMaximumZ=OriginZ+TileExtent;
+                const auto PlanIt=std::find_if(Assembly->plan.strates.begin(),
+                    Assembly->plan.strates.end(),[TileMinimumZ,TileMaximumZ,TileVoxelCount](const auto& Plan)
+                    {
+                        const std::int64_t PlanMinimumZ=static_cast<std::int64_t>(
+                            std::min(Plan.bottomChunkZ,Plan.topChunkZ))*TileVoxelCount;
+                        const std::int64_t PlanMaximumZ=(static_cast<std::int64_t>(
+                            std::max(Plan.bottomChunkZ,Plan.topChunkZ))+1)*TileVoxelCount;
+                        return TileMinimumZ<=PlanMaximumZ&&TileMaximumZ>=PlanMinimumZ;
+                    });
+                if(PlanIt==Assembly->plan.strates.end())continue;
+                const VoxelForgeCore::Heightfield2D Field(Assembly->recipe,*PlanIt);
+                if(!Field.isValid())continue;
+                const std::array<std::int64_t,3> Minimum={
+                    (OriginX-TileStep)*Subvoxels,(OriginY-TileStep)*Subvoxels,
+                    (OriginZ-TileStep)*Subvoxels};
+                const std::array<std::int64_t,3> Maximum={
+                    (OriginX+TileExtent+TileStep)*Subvoxels,
+                    (OriginY+TileExtent+TileStep)*Subvoxels,
+                    (OriginZ+TileExtent+TileStep)*Subvoxels};
+                std::vector<VoxelForgeCore::WorldAssemblyFeatureQueryV1> Queries;
+                Queries.push_back({Field.recipe(),Field.plan(),Field.buildFeatureTileList(Minimum,Maximum)});
+                const VoxelForgeCore::ScopedWorldAssemblyFeatureQueriesV1 QueryScope{
+                    std::span<const VoxelForgeCore::WorldAssemblyFeatureQueryV1>(Queries)};
+                const bool bHasFiniteFeature=std::any_of(PlanIt->features.begin(),
+                    PlanIt->features.end(),[&](const auto& Feature)
+                    {
+                        return (Feature.type==2||Feature.type==4)
+                            &&Feature.minimumSubvoxels[0]<=Maximum[0]
+                            &&Feature.maximumSubvoxels[0]>=Minimum[0]
+                            &&Feature.minimumSubvoxels[1]<=Maximum[1]
+                            &&Feature.maximumSubvoxels[1]>=Minimum[1]
+                            &&Feature.minimumSubvoxels[2]<=Maximum[2]
+                            &&Feature.maximumSubvoxels[2]>=Minimum[2];
+                    });
+                if(bHasFiniteFeature)++FiniteFeatureTiles;
+                std::vector<FProbeColumn> Exact(static_cast<std::size_t>(Cells+1)*(Cells+1));
+                VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true,0);
+                for(std::int32_t Y=0;Y<=Cells;++Y)
+                for(std::int32_t X=0;X<=Cells;++X)
+                {
+                    const auto Sample=Field.point((OriginX+X*TileStep)*Subvoxels,
+                        (OriginY+Y*TileStep)*Subvoxels,0);
+                    Exact[static_cast<std::size_t>(Y)*(Cells+1)+X]={
+                        Sample.groundHeightSubvoxels,Sample.capHeightSubvoxels};
+                }
+                const auto& BaselineStats=VoxelForgeCore::Heightfield2D::threadColumnCacheStats();
+                BaselineColumnMs.Add(BaselineStats.columnComputeMilliseconds);
+                BaselineColumns+=BaselineStats.columnMisses;
+                VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true,Drop);
+                for(std::int32_t Y=0;Y<=Cells;++Y)
+                for(std::int32_t X=0;X<=Cells;++X)
+                {
+                    const auto Sample=Field.point((OriginX+X*TileStep)*Subvoxels,
+                        (OriginY+Y*TileStep)*Subvoxels,0);
+                    GroundErrorsCm.Add(std::abs(static_cast<double>(Sample.groundHeightSubvoxels)
+                        -Exact[static_cast<std::size_t>(Y)*(Cells+1)+X].Ground)
+                        *CoreVoxelSizeCm/Subvoxels);
+                    CapErrorsCm.Add(std::abs(static_cast<double>(Sample.capHeightSubvoxels)
+                        -Exact[static_cast<std::size_t>(Y)*(Cells+1)+X].Cap)
+                        *CoreVoxelSizeCm/Subvoxels);
+                }
+                const auto& CandidateStats=VoxelForgeCore::Heightfield2D::threadColumnCacheStats();
+                CandidateColumnMs.Add(CandidateStats.columnComputeMilliseconds);
+                CandidateColumns+=CandidateStats.columnMisses;
+                ++Tiles;
+            }
+            std::uint64_t GroundOver2Cm=0,CapOver2Cm=0;
+            for(const double Error:GroundErrorsCm)if(Error>2.0)++GroundOver2Cm;
+            for(const double Error:CapErrorsCm)if(Error>2.0)++CapOver2Cm;
+            double BaselineAverageMs=0.0,CandidateAverageMs=0.0;
+            for(const double Value:BaselineColumnMs)BaselineAverageMs+=Value;
+            for(const double Value:CandidateColumnMs)CandidateAverageMs+=Value;
+            if(!BaselineColumnMs.IsEmpty())BaselineAverageMs/=BaselineColumnMs.Num();
+            if(!CandidateColumnMs.IsEmpty())CandidateAverageMs/=CandidateColumnMs.Num();
+            UE_LOG(LogTemp,Display,
+                TEXT("[WorldAssemblerFrequencyProbe] label=surface lod=%d tiles=%d drop_highest_octaves=%d exact_column_evals=%llu reduced_column_evals=%llu column_eval_saving_pct=%.2f baseline_column_avg_ms=%.5f reduced_column_avg_ms=%.5f ground_error_p95_cm=%.4f ground_error_max_cm=%.4f ground_over_2cm=%llu/%d cap_error_p95_cm=%.4f cap_error_max_cm=%.4f cap_over_2cm=%llu/%d finite_feature_tiles=%llu"),
+                LOD,Tiles,static_cast<std::int32_t>(Drop),
+                static_cast<unsigned long long>(BaselineColumns),
+                static_cast<unsigned long long>(CandidateColumns),
+                BaselineAverageMs>0.0?100.0*(1.0-CandidateAverageMs/BaselineAverageMs):0.0,
+                BaselineAverageMs,CandidateAverageMs,
+                P95(GroundErrorsCm),MaxValue(GroundErrorsCm),
+                static_cast<unsigned long long>(GroundOver2Cm),GroundErrorsCm.Num(),
+                P95(CapErrorsCm),MaxValue(CapErrorsCm),
+                static_cast<unsigned long long>(CapOver2Cm),CapErrorsCm.Num(),
+                static_cast<unsigned long long>(FiniteFeatureTiles));
+        }
+        VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true,0);
+    }
+    for (const int32 LOD : {0,1,2,3,4,5,6,7,8})
     {
         TArray<double> FullTimes,CandidateTimes,FullShellTimes,CandidateShellTimes,ListTimes;
-        TArray<double> UnknownBoxes,FieldCalls,ColumnMisses,StratumShellTimes,ConnectorShellTimes;
-        TArray<double> ClassificationTimes,ColumnComputeTimes,MeshingTimes,HorizonTimes,RepairSkipped;
+        TArray<double> UnknownBoxes,FieldCalls,UnclampedFieldCalls,ColumnMisses,ColumnConflictMisses,StratumShellTimes,ConnectorShellTimes;
+        TArray<double> DensitySamples,ClassificationTimes,ClassificationExclusiveTimes;
+        TArray<double> ColumnComputeTimes,MeshingTimes,HorizonTimes,RepairSkipped;
+        TArray<double> ColumnEvalExclusiveTimes,MarchingExclusiveTimes,GroundRefineExclusiveTimes;
+        TArray<double> CapRefineExclusiveTimes,MeshAssemblyTimes;
+        TArray<double> MarchingColumnTimes,GroundColumnTimes,CapColumnTimes;
+        TArray<double> ClassificationNsPerSample,ColumnNsPerSample,MarchingNsPerSample;
+        TArray<double> GroundNsPerSample,CapNsPerSample,AssemblyNsPerSample,ListNsPerSample;
+        TArray<double> MarchingColumnNsPerSample,GroundColumnNsPerSample,CapColumnNsPerSample;
+        TArray<double> McProfileTotalTimes,McProfileGridTimes,McProfileGridExclusiveTimes;
+        TArray<double> McProfileCellTimes,McProfileNormalTimes,McProfileInterpolationTimes;
+        TArray<double> McProfileStreamTimes,McProfileOtherTimes,McProfileResidualTimes;
+        TArray<double> McProfileGradientFallbackCalls,McProfileEdgeMidpointCalls,McProfileGradientMemoHits;
+        TArray<double> McProfileGridNsPerSample,McProfileGridExclusiveNsPerSample;
+        TArray<double> McProfileCellNsPerSample,McProfileNormalNsPerSample;
+        TArray<double> McProfileInterpolationNsPerSample,McProfileStreamNsPerSample;
+        TArray<double> McProfileOtherNsPerSample,McProfileResidualNsPerSample;
         TArray<double> StratumFieldCalls,ConnectorFieldCalls,ShellTriangles,GroundTriangles,GroundRemoved,CapTriangles;
+        const bool bMcStageAudit=FParse::Param(FCommandLine::Get(),TEXT("coremcstageaudit"));
+        int32 AuditDirectMappedColumnCache=0,AuditMemoizeMcGradients=1;
+        FParse::Value(FCommandLine::Get(),TEXT("voxel.CoreColumnCacheDirectMapped="),
+            AuditDirectMappedColumnCache);
+        FParse::Value(FCommandLine::Get(),TEXT("voxel.CoreMCGradientMemoization="),
+            AuditMemoizeMcGradients);
         for (const auto& Key : Keys)
         {
             if (Key.lod!=LOD || FullTimes.Num()>=8) continue;
             VoxelForgeCore::TileGenerationOptions Options;
             Options.hashDensity=true;
             Options.useAssemblyFeatureQueries=false;
+            Options.legacyDirectMappedColumnCache=AuditDirectMappedColumnCache!=0;
+            Options.memoizeMcGradients=AuditMemoizeMcGradients!=0;
             std::string Error;
-            // Warm both routes before measuring: column/page caches must not favor the second route.
-            // Chauffer les deux parcours : les caches ne doivent pas favoriser le second.
-            if (!World.generateTile(Key,Options,Error)) return false;
+            // Check density and mesh parity with hashes, then time uncached runtime generation.
+            // Verifier la parite avec hashes, puis mesurer la generation sans cache de colonnes.
+            const auto FullParity=World.generateTile(Key,Options,Error);
+            if (!FullParity) return false;
             Options.useAssemblyFeatureQueries=true;
-            if (!World.generateTile(Key,Options,Error)) return false;
+            const auto CandidateParity=World.generateTile(Key,Options,Error);
+            if (!CandidateParity||FullParity->densityHash!=CandidateParity->densityHash
+                ||FullParity->meshHash!=CandidateParity->meshHash
+                ||FullParity->payloadHash!=CandidateParity->payloadHash
+                ||FullParity->topologyHash!=CandidateParity->topologyHash)
+            { OutError=TEXT("Shared feature full/candidate tile hashes differ."); return false; }
+            Options.hashDensity=false;
             Options.useAssemblyFeatureQueries=false;
+            VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true);
             const double FullStart=FPlatformTime::Seconds();
             auto Full=World.generateTile(Key,Options,Error);
             FullTimes.Add((FPlatformTime::Seconds()-FullStart)*1000.0);
             Options.useAssemblyFeatureQueries=true;
+            VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true);
             const double CandidateStart=FPlatformTime::Seconds();
             auto Candidate=World.generateTile(Key,Options,Error);
             CandidateTimes.Add((FPlatformTime::Seconds()-CandidateStart)*1000.0);
-            if (!Full||!Candidate||Full->densityHash!=Candidate->densityHash
-                ||Full->meshHash!=Candidate->meshHash||Full->payloadHash!=Candidate->payloadHash
-                ||Full->topologyHash!=Candidate->topologyHash)
-            { OutError=TEXT("Shared feature full/candidate tile hashes differ."); return false; }
+            if (!Full||!Candidate)
+            { OutError=TEXT("Shared feature full/candidate measured generation failed."); return false; }
             FullShellTimes.Add(Full->diagnostics.farShellMilliseconds);
             CandidateShellTimes.Add(Candidate->diagnostics.farShellMilliseconds);
             ListTimes.Add(Candidate->diagnostics.featureListMilliseconds);
-            UnknownBoxes.Add(static_cast<double>(Full->diagnostics.unknownBoxes));
-            FieldCalls.Add(static_cast<double>(Full->diagnostics.fieldCalls));
-            ColumnMisses.Add(static_cast<double>(Full->diagnostics.columnCacheMisses));
-            ClassificationTimes.Add(Full->diagnostics.classificationMilliseconds);
-            ColumnComputeTimes.Add(Full->diagnostics.columnComputeMilliseconds);
-            MeshingTimes.Add(Full->diagnostics.meshingMilliseconds);
-            HorizonTimes.Add(Full->diagnostics.farHorizonMilliseconds);
-            RepairSkipped.Add(Full->diagnostics.farShellRepairSkipped?1.0:0.0);
-            StratumShellTimes.Add(Full->diagnostics.farStratumShellMilliseconds);
-            ConnectorShellTimes.Add(Full->diagnostics.farConnectorShellMilliseconds);
-            StratumFieldCalls.Add(static_cast<double>(Full->diagnostics.farStratumFieldCalls));
-            ConnectorFieldCalls.Add(static_cast<double>(Full->diagnostics.farConnectorFieldCalls));
-            ShellTriangles.Add(static_cast<double>(Full->diagnostics.farShellTrianglesAdded));
-            GroundTriangles.Add(static_cast<double>(Full->diagnostics.horizonGroundTriangles));
-            GroundRemoved.Add(static_cast<double>(Full->diagnostics.horizonGroundTrianglesRemoved));
-            CapTriangles.Add(static_cast<double>(Full->diagnostics.horizonCapTriangles));
+            const auto& Diagnostics=Candidate->diagnostics;
+            const double SampleCount=static_cast<double>(Candidate->densitySampleCount);
+            DensitySamples.Add(static_cast<double>(Candidate->densitySampleCount));
+            UnknownBoxes.Add(static_cast<double>(Diagnostics.unknownBoxes));
+            FieldCalls.Add(static_cast<double>(Diagnostics.fieldCalls));
+            UnclampedFieldCalls.Add(static_cast<double>(Diagnostics.unclampedFieldCalls));
+            ColumnMisses.Add(static_cast<double>(Diagnostics.columnCacheMisses));
+            ColumnConflictMisses.Add(static_cast<double>(Diagnostics.columnCacheConflictMisses));
+            ClassificationTimes.Add(Diagnostics.classificationMilliseconds);
+            ClassificationExclusiveTimes.Add(Diagnostics.classificationExclusiveMilliseconds);
+            ColumnComputeTimes.Add(Diagnostics.columnComputeMilliseconds);
+            ColumnEvalExclusiveTimes.Add(Diagnostics.columnEvaluationExclusiveMilliseconds);
+            MarchingExclusiveTimes.Add(Diagnostics.marchingCubesExclusiveMilliseconds);
+            MarchingColumnTimes.Add(Diagnostics.marchingCubesColumnComputeMilliseconds);
+            GroundRefineExclusiveTimes.Add(Diagnostics.groundRefinementExclusiveMilliseconds);
+            GroundColumnTimes.Add(Diagnostics.groundRefinementColumnComputeMilliseconds);
+            CapRefineExclusiveTimes.Add(Diagnostics.capRefinementExclusiveMilliseconds);
+            CapColumnTimes.Add(Diagnostics.capRefinementColumnComputeMilliseconds);
+            MeshAssemblyTimes.Add(Diagnostics.meshAssemblyMilliseconds);
+            MeshingTimes.Add(Diagnostics.meshingMilliseconds);
+            HorizonTimes.Add(Diagnostics.farHorizonMilliseconds);
+            RepairSkipped.Add(Diagnostics.farShellRepairSkipped?1.0:0.0);
+            StratumShellTimes.Add(Diagnostics.farStratumShellMilliseconds);
+            ConnectorShellTimes.Add(Diagnostics.farConnectorShellMilliseconds);
+            StratumFieldCalls.Add(static_cast<double>(Diagnostics.farStratumFieldCalls));
+            ConnectorFieldCalls.Add(static_cast<double>(Diagnostics.farConnectorFieldCalls));
+            ShellTriangles.Add(static_cast<double>(Diagnostics.farShellTrianglesAdded));
+            GroundTriangles.Add(static_cast<double>(Diagnostics.horizonGroundTriangles));
+            GroundRemoved.Add(static_cast<double>(Diagnostics.horizonGroundTrianglesRemoved));
+            CapTriangles.Add(static_cast<double>(Diagnostics.horizonCapTriangles));
+            if(SampleCount>0.0)
+            {
+                ClassificationNsPerSample.Add(Diagnostics.classificationExclusiveMilliseconds
+                    *1000000.0/SampleCount);
+                ColumnNsPerSample.Add(Diagnostics.columnEvaluationExclusiveMilliseconds
+                    *1000000.0/SampleCount);
+                MarchingColumnNsPerSample.Add(Diagnostics.marchingCubesColumnComputeMilliseconds
+                    *1000000.0/SampleCount);
+                MarchingNsPerSample.Add(Diagnostics.marchingCubesExclusiveMilliseconds
+                    *1000000.0/SampleCount);
+                GroundColumnNsPerSample.Add(Diagnostics.groundRefinementColumnComputeMilliseconds
+                    *1000000.0/SampleCount);
+                GroundNsPerSample.Add(Diagnostics.groundRefinementExclusiveMilliseconds
+                    *1000000.0/SampleCount);
+                CapColumnNsPerSample.Add(Diagnostics.capRefinementColumnComputeMilliseconds
+                    *1000000.0/SampleCount);
+                CapNsPerSample.Add(Diagnostics.capRefinementExclusiveMilliseconds
+                    *1000000.0/SampleCount);
+                AssemblyNsPerSample.Add(Diagnostics.meshAssemblyMilliseconds
+                    *1000000.0/SampleCount);
+                ListNsPerSample.Add(Diagnostics.featureListMilliseconds*1000000.0/SampleCount);
+            }
+            if(bMcStageAudit)
+            {
+                // Profile a separate cold tile so the audit's ordinary timing rows keep the
+                // uninstrumented path and comparable clock scope.
+                // Profiler une tuile froide separee pour garder les mesures ordinaires sans instrumentation.
+                Options.profileMesherStages=true;
+                VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(false,true);
+                auto Profiled=World.generateTile(Key,Options,Error);
+                Options.profileMesherStages=false;
+                if(!Profiled)
+                { OutError=TEXT("Cold MC stage profile tile generation failed."); return false; }
+                const auto& Mc=Profiled->diagnostics;
+                const double Total=Mc.marchingCubesExclusiveMilliseconds
+                    +Mc.marchingCubesColumnComputeMilliseconds;
+                const double Grid=Mc.marchingCubesDensityGridMilliseconds;
+                const double GridExclusive=FMath::Max(0.0,Grid
+                    -Mc.marchingCubesColumnComputeMilliseconds);
+                const double Cell=Mc.marchingCubesCellClassificationMilliseconds;
+                const double Normal=Mc.marchingCubesGradientNormalsMilliseconds;
+                const double Interpolation=Mc.marchingCubesEdgeInterpolationMilliseconds;
+                const double Stream=Mc.marchingCubesVertexDedupStreamMilliseconds;
+                const double Other=Mc.marchingCubesOtherMilliseconds;
+                const double Residual=FMath::Max(0.0,Mc.marchingCubesExclusiveMilliseconds
+                    -GridExclusive-Cell-Normal-Interpolation-Stream);
+                McProfileTotalTimes.Add(Total);
+                McProfileGridTimes.Add(Grid);
+                McProfileGridExclusiveTimes.Add(GridExclusive);
+                McProfileCellTimes.Add(Cell);
+                McProfileNormalTimes.Add(Normal);
+                McProfileInterpolationTimes.Add(Interpolation);
+                McProfileStreamTimes.Add(Stream);
+                McProfileOtherTimes.Add(Other);
+                McProfileResidualTimes.Add(Residual);
+                McProfileGradientFallbackCalls.Add(static_cast<double>(
+                    Mc.marchingCubesGradientFallbackDensityCalls));
+                McProfileEdgeMidpointCalls.Add(static_cast<double>(
+                    Mc.marchingCubesEdgeMidpointDensityCalls));
+                McProfileGradientMemoHits.Add(static_cast<double>(
+                    Mc.marchingCubesGradientMemoHits));
+                const double ProfileSamples=static_cast<double>(Profiled->densitySampleCount);
+                if(ProfileSamples>0.0)
+                {
+                    McProfileGridNsPerSample.Add(Grid*1000000.0/ProfileSamples);
+                    McProfileGridExclusiveNsPerSample.Add(GridExclusive*1000000.0/ProfileSamples);
+                    McProfileCellNsPerSample.Add(Cell*1000000.0/ProfileSamples);
+                    McProfileNormalNsPerSample.Add(Normal*1000000.0/ProfileSamples);
+                    McProfileInterpolationNsPerSample.Add(Interpolation*1000000.0/ProfileSamples);
+                    McProfileStreamNsPerSample.Add(Stream*1000000.0/ProfileSamples);
+                    McProfileOtherNsPerSample.Add(Other*1000000.0/ProfileSamples);
+                    McProfileResidualNsPerSample.Add(Residual*1000000.0/ProfileSamples);
+                }
+            }
         }
         const auto P95=[](TArray<double> Values)
         { Values.Sort(); return Values.IsEmpty() ? 0.0 : Values[FMath::Clamp(
             FMath::CeilToInt(Values.Num()*0.95f)-1,0,Values.Num()-1)]; };
         UE_LOG(LogTemp,Display,
-            TEXT("[VoxelForgeSharedFeatureCost] label=%s lod=%d tiles=%d hashes_identical=1 full_p95_ms=%.5f candidate_p95_ms=%.5f list_p95_ms=%.5f classification_p95_ms=%.5f column_compute_p95_ms=%.5f meshing_p95_ms=%.5f horizon_p95_ms=%.5f full_shell_p95_ms=%.5f candidate_shell_p95_ms=%.5f repair_skipped_p95=%.0f unknown_boxes_p95=%.0f field_calls_p95=%.0f column_misses_p95=%.0f stratum_shell_p95_ms=%.5f stratum_field_calls_p95=%.0f connector_shell_p95_ms=%.5f connector_field_calls_p95=%.0f shell_triangles_p95=%.0f horizon_ground_triangles_p95=%.0f horizon_ground_removed_p95=%.0f horizon_cap_triangles_p95=%.0f"),
-            Label,LOD,FullTimes.Num(),P95(FullTimes),P95(CandidateTimes),P95(ListTimes),
-            P95(ClassificationTimes),P95(ColumnComputeTimes),P95(MeshingTimes),P95(HorizonTimes),
+            TEXT("[VoxelForgeSharedFeatureCost] label=%s lod=%d column_cache_direct_mapped=%d gradient_memoization=%d tiles=%d hashes_identical=1 full_p95_ms=%.5f candidate_p95_ms=%.5f list_p95_ms=%.5f classification_wall_p95_ms=%.5f classification_exclusive_p95_ms=%.5f column_compute_p95_ms=%.5f column_eval_exclusive_p95_ms=%.5f mc_column_compute_p95_ms=%.5f mc_exclusive_p95_ms=%.5f ground_column_compute_p95_ms=%.5f ground_refine_exclusive_p95_ms=%.5f cap_column_compute_p95_ms=%.5f cap_refine_exclusive_p95_ms=%.5f mesh_assembly_p95_ms=%.5f meshing_p95_ms=%.5f horizon_p95_ms=%.5f samples_p95=%.0f classification_ns_per_sample_p95=%.2f column_ns_per_sample_p95=%.2f mc_column_ns_per_sample_p95=%.2f mc_ns_per_sample_p95=%.2f ground_column_ns_per_sample_p95=%.2f ground_ns_per_sample_p95=%.2f cap_column_ns_per_sample_p95=%.2f cap_ns_per_sample_p95=%.2f assembly_ns_per_sample_p95=%.2f feature_list_ns_per_sample_p95=%.2f full_shell_p95_ms=%.5f candidate_shell_p95_ms=%.5f repair_skipped_p95=%.0f unknown_boxes_p95=%.0f field_calls_p95=%.0f unclamped_field_calls_p95=%.0f column_misses_p95=%.0f column_conflict_misses_p95=%.0f stratum_shell_p95_ms=%.5f stratum_field_calls_p95=%.0f connector_shell_p95_ms=%.5f connector_field_calls_p95=%.0f shell_triangles_p95=%.0f horizon_ground_triangles_p95=%.0f horizon_ground_removed_p95=%.0f horizon_cap_triangles_p95=%.0f"),
+            Label,LOD,AuditDirectMappedColumnCache!=0?1:0,AuditMemoizeMcGradients!=0?1:0,
+            FullTimes.Num(),P95(FullTimes),P95(CandidateTimes),P95(ListTimes),
+            P95(ClassificationTimes),P95(ClassificationExclusiveTimes),P95(ColumnComputeTimes),
+            P95(ColumnEvalExclusiveTimes),P95(MarchingColumnTimes),P95(MarchingExclusiveTimes),
+            P95(GroundColumnTimes),P95(GroundRefineExclusiveTimes),P95(CapColumnTimes),
+            P95(CapRefineExclusiveTimes),
+            P95(MeshAssemblyTimes),P95(MeshingTimes),P95(HorizonTimes),P95(DensitySamples),
+            P95(ClassificationNsPerSample),P95(ColumnNsPerSample),P95(MarchingColumnNsPerSample),
+            P95(MarchingNsPerSample),P95(GroundColumnNsPerSample),P95(GroundNsPerSample),
+            P95(CapColumnNsPerSample),P95(CapNsPerSample),P95(AssemblyNsPerSample),P95(ListNsPerSample),
             P95(FullShellTimes),P95(CandidateShellTimes),P95(RepairSkipped),P95(UnknownBoxes),P95(FieldCalls),
-            P95(ColumnMisses),P95(StratumShellTimes),P95(StratumFieldCalls),
+            P95(UnclampedFieldCalls),
+            P95(ColumnMisses),P95(ColumnConflictMisses),P95(StratumShellTimes),P95(StratumFieldCalls),
             P95(ConnectorShellTimes),P95(ConnectorFieldCalls),P95(ShellTriangles),
             P95(GroundTriangles),P95(GroundRemoved),P95(CapTriangles));
+        if(bMcStageAudit)
+        {
+            UE_LOG(LogTemp,Display,
+                TEXT("[VoxelForgeMCStageCost] label=%s lod=%d tiles=%d sampling=row_total_and_1_of_8_cells total_p95_ms=%.5f density_grid_inclusive_p95_ms=%.5f density_grid_ex_column_p95_ms=%.5f cell_classification_p95_ms=%.5f gradient_normals_p95_ms=%.5f edge_interpolation_p95_ms=%.5f vertex_dedup_stream_p95_ms=%.5f setup_finalization_p95_ms=%.5f unassigned_residual_p95_ms=%.5f grid_ns_per_sample_p95=%.2f grid_ex_column_ns_per_sample_p95=%.2f cell_ns_per_sample_p95=%.2f normals_ns_per_sample_p95=%.2f interpolation_ns_per_sample_p95=%.2f dedup_stream_ns_per_sample_p95=%.2f setup_finalization_ns_per_sample_p95=%.2f residual_ns_per_sample_p95=%.2f gradient_fallback_density_calls_p95=%.0f edge_midpoint_density_probes_p95=%.0f gradient_memo_hits_p95=%.0f"),
+                Label,LOD,McProfileTotalTimes.Num(),P95(McProfileTotalTimes),P95(McProfileGridTimes),
+                P95(McProfileGridExclusiveTimes),P95(McProfileCellTimes),P95(McProfileNormalTimes),
+                P95(McProfileInterpolationTimes),P95(McProfileStreamTimes),P95(McProfileOtherTimes),
+                P95(McProfileResidualTimes),P95(McProfileGridNsPerSample),
+                P95(McProfileGridExclusiveNsPerSample),P95(McProfileCellNsPerSample),
+                P95(McProfileNormalNsPerSample),P95(McProfileInterpolationNsPerSample),
+                P95(McProfileStreamNsPerSample),P95(McProfileOtherNsPerSample),
+                P95(McProfileResidualNsPerSample),P95(McProfileGradientFallbackCalls),
+                P95(McProfileEdgeMidpointCalls),P95(McProfileGradientMemoHits));
+        }
     }
     if(Assembly!=nullptr&&!Assembly->plan.strates.empty())
     {
@@ -17329,6 +17744,262 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
         return false;
     }
 
+    if (Arguments.bCoreWorldStreamTraceOnly)
+    {
+        const UWorld::InitializationValues WorldInitialization = UWorld::InitializationValues()
+            .AllowAudioPlayback(false)
+            .RequiresHitProxies(false)
+            .CreatePhysicsScene(true)
+            .CreateNavigation(false)
+            .CreateAISystem(false)
+            .ShouldSimulatePhysics(true)
+            .SetDefaultGameMode(AGameModeBase::StaticClass())
+            .SetTransactional(false);
+        UWorld* TestWorld = UWorld::CreateWorld(
+            EWorldType::Game, false, FName(TEXT("VoxelForgeCoreStreamTraceWorld")),
+            GetTransientPackage(), false, ERHIFeatureLevel::Num, &WorldInitialization);
+        if (TestWorld == nullptr)
+        {
+            OutError = TEXT("Could not create the transient BuildHost stream-trace world.");
+            return false;
+        }
+        UGameInstance* TestGameInstance = NewObject<UGameInstance>(GEngine);
+        FWorldContext& TestWorldContext = GEngine->CreateNewWorldContext(EWorldType::Game);
+        TestWorldContext.OwningGameInstance = TestGameInstance;
+        TestWorldContext.SetCurrentWorld(TestWorld);
+        TestWorld->SetGameInstance(TestGameInstance);
+        TestWorld->SetShouldTick(false);
+        TestGameInstance->Init();
+        TestWorld->AddToRoot();
+        struct FStreamTraceWorldCleanup
+        {
+            UWorld* World = nullptr;
+            uint64 PreviousFrameCounter = GFrameCounter;
+            ~FStreamTraceWorldCleanup()
+            {
+                if (World != nullptr)
+                {
+                    if (World->HasBegunPlay())
+                    {
+                        World->BeginTearingDown();
+                        World->EndPlay(EEndPlayReason::Quit);
+                    }
+                    if (UGameInstance* GameInstance = World->GetGameInstance())
+                    {
+                        GameInstance->Shutdown();
+                    }
+                    if (GEngine != nullptr) GEngine->DestroyWorldContext(World);
+                    World->DestroyWorld(false);
+                    if (World->IsRooted()) World->RemoveFromRoot();
+                }
+                GFrameCounter = PreviousFrameCounter;
+            }
+        } Cleanup{TestWorld, GFrameCounter};
+
+        if (!TestWorld->SetGameMode(FURL()))
+        {
+            OutError = TEXT("Could not create the transient BuildHost GameMode for stream tracing.");
+            return false;
+        }
+        if (AGameModeBase* GameMode = TestWorld->GetAuthGameMode())
+        {
+            GameMode->DefaultPawnClass = nullptr;
+        }
+        UPlayer* TestPlayer = NewObject<UPlayer>(GEngine, NAME_None, RF_Transient);
+        APlayerController* PlayerController = TestWorld->SpawnActor<APlayerController>(
+            APlayerController::StaticClass(), FTransform::Identity, FActorSpawnParameters());
+        if (TestPlayer == nullptr || PlayerController == nullptr)
+        {
+            OutError = TEXT("Could not create the BuildHost stream-trace player controller.");
+            return false;
+        }
+        PlayerController->SetPlayer(TestPlayer);
+        TestWorld->AddController(PlayerController);
+        APawn* PlayerPawn = TestWorld->SpawnActor<APawn>(
+            APawn::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator);
+        if (PlayerPawn == nullptr)
+        {
+            OutError = TEXT("Could not create the BuildHost stream-trace pawn.");
+            return false;
+        }
+        USceneComponent* PawnRoot = NewObject<USceneComponent>(PlayerPawn, NAME_None, RF_Transient);
+        if (PawnRoot == nullptr)
+        {
+            OutError = TEXT("Could not create the BuildHost stream-trace pawn root.");
+            return false;
+        }
+        PlayerPawn->SetRootComponent(PawnRoot);
+        PawnRoot->RegisterComponent();
+        PlayerPawn->SetActorLocation(FVector::ZeroVector, false, nullptr, ETeleportType::TeleportPhysics);
+        PlayerController->Possess(PlayerPawn);
+        if (TestWorld->GetFirstPlayerController() != PlayerController
+            || PlayerController->GetPawn() != PlayerPawn)
+        {
+            OutError = TEXT("BuildHost stream-trace controller did not retain its pawn.");
+            return false;
+        }
+
+        const FTransform ActorTransform = FTransform::Identity;
+        AVoxelWorld* Actor = TestWorld->SpawnActorDeferred<AVoxelWorld>(
+            AVoxelWorld::StaticClass(), ActorTransform, nullptr, nullptr,
+            ESpawnActorCollisionHandlingMethod::AlwaysSpawn);
+        if (Actor == nullptr)
+        {
+            OutError = TEXT("Could not spawn the transient AVoxelWorld for stream tracing.");
+            return false;
+        }
+        Actor->Settings = AuthoredSettings;
+        Actor->bManageAtmosphere = false;
+        Actor->bUseVoxelForgeCore = true;
+        Actor->CoreVoxelSizeCm = Arguments.CoreVoxelSizeCm;
+        Actor->CoreMesherRecipe = Arguments.CoreHybridMesherVersion == 2
+            ? EVoxelForgeCoreMesherRecipe::WorldAssemblerHybridV2
+            : (Arguments.CoreHybridMesherVersion == 1
+                ? EVoxelForgeCoreMesherRecipe::WorldAssemblerHybridV1
+                : EVoxelForgeCoreMesherRecipe::MarchingCubesV1);
+        Actor->CoreClipRadius = 3;
+        Actor->CoreMaxClipLevel = 8;
+        Actor->bCaptureVoxelForgeCoreHashesForValidation = true;
+        Actor->FinishSpawning(ActorTransform);
+        TestWorld->InitializeActorsForPlay(FURL());
+        TestWorld->BeginPlay();
+        if (!VoxelForgeStartupTrace::IsActive())
+        {
+            OutError = TEXT("Core stream trace mode requires -voxel.StartupTraceFile.");
+            return false;
+        }
+        Actor->SetActorTickEnabled(true);
+
+        auto DesiredTilesLoaded = [](const AVoxelWorld* World)
+        {
+            if (World == nullptr || World->DesiredSorted.IsEmpty()) return false;
+            for (const FVoxelTileKey& Key : World->DesiredSorted)
+            {
+                if (!World->LoadedTiles.Contains(Key)) return false;
+            }
+            return true;
+        };
+        auto CollisionSetSettled = [](const AVoxelWorld* World)
+        {
+            if (World == nullptr) return false;
+            for (const FVoxelTileKey& Key : World->CollisionDesiredTiles)
+            {
+                if (!World->CollisionReadyTiles.Contains(Key)
+                    && !World->CollisionNotRequiredTiles.Contains(Key)) return false;
+            }
+            return true;
+        };
+        const double ActorBeginSeconds = FPlatformTime::Seconds();
+        constexpr double WalkStartSeconds = 30.0;
+        constexpr double RunDurationSeconds = 45.0;
+        float WalkSpeedCmPerSecond = 600.0f;
+        FParse::Value(FCommandLine::Get(), TEXT("voxel.TestMoveSpeedCmPerSecond="),
+                      WalkSpeedCmPerSecond);
+        FString WalkDirectionText(TEXT("0,1,0"));
+        const FString DirectionKey(TEXT("voxel.TestMoveDirection="));
+        const FString CommandLineText(FCommandLine::Get());
+        const int32 DirectionKeyIndex = CommandLineText.Find(
+            DirectionKey, ESearchCase::IgnoreCase, ESearchDir::FromStart);
+        if (DirectionKeyIndex != INDEX_NONE)
+        {
+            WalkDirectionText = CommandLineText.Mid(DirectionKeyIndex + DirectionKey.Len());
+            const int32 DirectionEnd = WalkDirectionText.Find(
+                TEXT(" "), ESearchCase::CaseSensitive, ESearchDir::FromStart);
+            if (DirectionEnd != INDEX_NONE)
+            {
+                WalkDirectionText.LeftInline(DirectionEnd, EAllowShrinking::No);
+            }
+            WalkDirectionText.TrimStartAndEndInline();
+            WalkDirectionText.RemoveFromStart(TEXT("\""));
+            WalkDirectionText.RemoveFromEnd(TEXT("\""));
+        }
+        TArray<double> SpawnTickMilliseconds;
+        TArray<double> WalkTickMilliseconds;
+        TArray<TPair<double, double>> TickSamples;
+        bool bInitialSetReady = false;
+        double InitialSetReadySeconds = -1.0;
+        while (FPlatformTime::Seconds() - ActorBeginSeconds < RunDurationSeconds)
+        {
+            const double TickStartSeconds = FPlatformTime::Seconds();
+            TestWorld->Tick(LEVELTICK_All, 0.016f);
+            const double TickMilliseconds =
+                (FPlatformTime::Seconds() - TickStartSeconds) * 1000.0;
+            ++GFrameCounter;
+            const double ElapsedSeconds = FPlatformTime::Seconds() - ActorBeginSeconds;
+            TickSamples.Emplace(ElapsedSeconds, TickMilliseconds);
+
+            if (!bInitialSetReady && Actor->IsVoxelForgeCoreReady()
+                && Actor->bAllChunksLoaded && Actor->PendingTiles.IsEmpty()
+                && Actor->PendingCollisionCooks.IsEmpty() && Actor->PendingUnload.IsEmpty()
+                && Actor->ActiveTaskCount.load(std::memory_order_acquire) == 0
+                && DesiredTilesLoaded(Actor) && CollisionSetSettled(Actor))
+            {
+                bInitialSetReady = true;
+                InitialSetReadySeconds = ElapsedSeconds;
+                VoxelForgeStartupTrace::RecordEvent(TEXT("stream_trace_milestone"), FString::Printf(
+                    TEXT("\"name\":\"initial_set_ready\",\"elapsed_s\":%s,\"desired\":%d,\"loaded\":%d,\"collision_desired\":%d,\"collision_ready\":%d"),
+                    *FString::SanitizeFloat(ElapsedSeconds), Actor->DesiredSorted.Num(),
+                    Actor->LoadedTiles.Num(), Actor->CollisionDesiredTiles.Num(),
+                    Actor->CollisionReadyTiles.Num()));
+            }
+            FPlatformProcess::Sleep(0.016f);
+        }
+
+        for (const TPair<double, double>& Sample : TickSamples)
+        {
+            if (bInitialSetReady && Sample.Key <= InitialSetReadySeconds)
+            {
+                SpawnTickMilliseconds.Add(Sample.Value);
+            }
+            else if (Sample.Key >= WalkStartSeconds)
+            {
+                WalkTickMilliseconds.Add(Sample.Value);
+            }
+        }
+
+        auto PercentileMilliseconds = [](TArray<double> Values, double Fraction)
+        {
+            if (Values.IsEmpty()) return 0.0;
+            Values.Sort();
+            const int32 Index = FMath::Clamp(
+                FMath::CeilToInt(Fraction * static_cast<double>(Values.Num() - 1)),
+                0, Values.Num() - 1);
+            return Values[Index];
+        };
+        const auto MaxMilliseconds = [](const TArray<double>& Values)
+        {
+            double Maximum = 0.0;
+            for (const double Value : Values) Maximum = FMath::Max(Maximum, Value);
+            return Maximum;
+        };
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeCoreWorldStreamTrace] initial_ready=%d initial_ready_s=%.6f walk_start_s=%.3f run_s=%.3f desired=%d loaded=%d "
+                 "spawn_tick_ms_p95=%.3f spawn_tick_ms_max=%.3f walk_tick_ms_p95=%.3f walk_tick_ms_max=%.3f"),
+            bInitialSetReady ? 1 : 0, InitialSetReadySeconds, WalkStartSeconds,
+            RunDurationSeconds, Actor->DesiredSorted.Num(), Actor->LoadedTiles.Num(),
+            PercentileMilliseconds(SpawnTickMilliseconds, 0.95),
+            MaxMilliseconds(SpawnTickMilliseconds),
+            PercentileMilliseconds(WalkTickMilliseconds, 0.95),
+            MaxMilliseconds(WalkTickMilliseconds));
+        if (!bInitialSetReady)
+        {
+            OutError = FString::Printf(
+                TEXT("Actor-only Core stream trace did not reach initial readiness: ready=%d desired=%d loaded=%d pending=%d cooks=%d active=%d."),
+                Actor->IsVoxelForgeCoreReady() ? 1 : 0, Actor->DesiredSorted.Num(),
+                Actor->LoadedTiles.Num(), Actor->PendingTiles.Num(),
+                Actor->PendingCollisionCooks.Num(),
+                Actor->ActiveTaskCount.load(std::memory_order_acquire));
+            return false;
+        }
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeCoreWorldStreamTrace] pass complete=1 recipe=%s voxel_cm=%.3f walk_speed_cm_s=%.0f walk_direction=%s"),
+            Arguments.CoreHybridMesherVersion == 2 ? TEXT("WorldAssemblerHybridV2")
+                : (Arguments.CoreHybridMesherVersion == 1 ? TEXT("WorldAssemblerHybridV1")
+                    : TEXT("MarchingCubesV1")),
+            Arguments.CoreVoxelSizeCm, WalkSpeedCmPerSecond, *WalkDirectionText);
+        return true;
+    }
+
     // Build one Standalone reference before creating the actor world so the two full Core worlds
     // never overlap in memory. The reference also precomputes the exact edit result and hashes.
     // Construire la référence Standalone avant le monde acteur pour ne jamais garder deux mondes

Standalone/Build.ps1

@@ -2,14 +2,14 @@
 param(
     [string]$OutputName = 'VoxelForgeCoreStandalone.exe',
     [ValidateSet('All','Core')][string]$Target = 'All',
-    [ValidateRange(1,16)][int]$CompileWorkers = 16,
+    [ValidateRange(1,12)][int]$CompileWorkers = 12,
     [ValidateSet('Normal','BelowNormal')][string]$BuildPriority = 'Normal'
 )
 
 $ErrorActionPreference = 'Stop'
 $BuildHostProcess = Get-Process -Id $PID
 $BuildHostProcess.PriorityClass = $BuildPriority
-$BuildHostProcess.ProcessorAffinity = [IntPtr]0xFFFF
+$BuildHostProcess.ProcessorAffinity = [IntPtr]0xFFF
 $Root = [IO.Path]::GetFullPath($PSScriptRoot)
 $BuildDir = Join-Path $Root 'Build\VoxelForgeCore'
 $BinDir = Join-Path $Root 'bin'
@@ -24,6 +24,33 @@ $CoreLibrary = Join-Path $BuildDir 'VoxelForgeCore.lib'
 $VcVars = 'E:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat'
 if (-not (Test-Path -LiteralPath $VcVars -PathType Leaf)) { throw "MSVC environment script not found: $VcVars" }
 
+if (-not ('VoxelForgeStandaloneBuildMemoryProbe' -as [type])) {
+    Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class VoxelForgeStandaloneBuildMemoryProbe {
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    private struct MEMORYSTATUSEX {
+        public uint dwLength, dwMemoryLoad;
+        public ulong ullTotalPhys, ullAvailPhys, ullTotalPageFile, ullAvailPageFile;
+        public ulong ullTotalVirtual, ullAvailVirtual, ullAvailExtendedVirtual;
+    }
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX status);
+    public static ulong AvailablePhysicalBytes() {
+        var status = new MEMORYSTATUSEX();
+        status.dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX));
+        if (!GlobalMemoryStatusEx(ref status)) throw new InvalidOperationException("GlobalMemoryStatusEx failed.");
+        return status.ullAvailPhys;
+    }
+}
+'@
+}
+while ([VoxelForgeStandaloneBuildMemoryProbe]::AvailablePhysicalBytes() -lt 4GB) {
+    Write-Warning 'Standalone build is waiting for at least 4 GiB of free physical memory.'
+    Start-Sleep -Seconds 20
+}
+
 $SourceManifest = Join-Path $Root 'Core\core_sources.txt'
 if (-not (Test-Path -LiteralPath $SourceManifest -PathType Leaf)) { throw "Core source manifest not found: $SourceManifest" }
 $CoreSourceNames = @(Get-Content -LiteralPath $SourceManifest | ForEach-Object { $_.Trim() } |

Standalone/BuildLinux.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "${VOXELFORGE_LIMITED_BUILD:-0}" != "1" ]]; then
+    exec taskset -c 0-11 prlimit --as=6442450944 -- env VOXELFORGE_LIMITED_BUILD=1 "$0" "$@"
+fi
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$SCRIPT_DIR"
+COMPILER="clang++-19"
+VARIANT="clang19"
+FP_CONTRACT="off"
+JOBS=12
+
+while (($#)); do
+    case "$1" in
+        --compiler=*) COMPILER="${1#*=}" ;;
+        --variant=*) VARIANT="${1#*=}" ;;
+        --fp-contract=*) FP_CONTRACT="${1#*=}" ;;
+        --jobs=*) JOBS="${1#*=}" ;;
+        *) printf 'Unknown build option: %s\n' "$1" >&2; exit 2 ;;
+    esac
+    shift
+done
+
+if [[ ! "$JOBS" =~ ^[0-9]+$ ]] || ((JOBS < 1 || JOBS > 12)); then
+    printf 'jobs must be from 1 to 12\n' >&2
+    exit 2
+fi
+if [[ "$FP_CONTRACT" != "default" && "$FP_CONTRACT" != "off" && "$FP_CONTRACT" != "on" && "$FP_CONTRACT" != "fast" ]]; then
+    printf 'fp-contract must be default, off, on, or fast\n' >&2
+    exit 2
+fi
+command -v "$COMPILER" >/dev/null || { printf 'Compiler not found: %s\n' "$COMPILER" >&2; exit 2; }
+command -v ar >/dev/null || { printf 'ar not found\n' >&2; exit 2; }
+command -v pkg-config >/dev/null || { printf 'pkg-config not found\n' >&2; exit 2; }
+pkg-config --exists egl glesv2 libpng || { printf 'EGL, GLESv2, and libpng development files are required\n' >&2; exit 2; }
+
+BUILD_DIR="$ROOT/Build/linux-$VARIANT"
+BIN_DIR="$ROOT/bin/linux"
+mkdir -p "$BUILD_DIR/wrappers" "$BUILD_DIR/objects" "$BIN_DIR"
+
+INCLUDES=(
+    "-I$ROOT/Core/include"
+    "-I$ROOT/Core/src"
+    "-I$ROOT/Compat"
+    "-I$ROOT/Source"
+    "-I$ROOT/Source/VoxelForge/Public"
+    "-I$ROOT/Source/VoxelForge/Private"
+)
+FLAGS=(
+    -std=c++20 -O2 -mavx2 -mfma -fno-fast-math
+    -fexceptions -pthread "${INCLUDES[@]}"
+)
+if [[ "$FP_CONTRACT" != "default" ]]; then
+    FLAGS+=("-ffp-contract=$FP_CONTRACT")
+fi
+if [[ "$($COMPILER --version | head -n 1)" == *clang* ]]; then
+    FLAGS+=(-Wno-c++11-narrowing)
+else
+    FLAGS+=(-Wno-narrowing)
+fi
+
+CORE_OBJECTS=()
+LEGACY_OBJECTS=()
+PIDS=()
+wait_oldest() {
+    local pid="${PIDS[0]}"
+    wait "$pid"
+    PIDS=("${PIDS[@]:1}")
+}
+compile_background() {
+    local source="$1" output="$2"
+    "$COMPILER" "${FLAGS[@]}" -c "$source" -o "$output" &
+    PIDS+=("$!")
+    if ((${#PIDS[@]} >= JOBS)); then wait_oldest; fi
+}
+
+while IFS= read -r source_name || [[ -n "$source_name" ]]; do
+    source_name="${source_name%%#*}"
+    source_name="${source_name//[[:space:]]/}"
+    [[ -z "$source_name" ]] && continue
+    source_path="$ROOT/$source_name"
+    [[ -f "$source_path" ]] || { printf 'Missing source from core_sources.txt: %s\n' "$source_name" >&2; exit 2; }
+    if [[ "$source_name" == "Core/src/VoxelForgeCore.cpp" ]]; then
+        object="$BUILD_DIR/objects/VoxelForgeCore.o"
+        compile_background "$source_path" "$object"
+        CORE_OBJECTS+=("$object")
+        continue
+    fi
+    wrapper_name="vfcore_${source_name//[^A-Za-z0-9]/_}"
+    wrapper="$BUILD_DIR/wrappers/$wrapper_name.cpp"
+    cat > "$wrapper" <<WRAPPER
+#include "CoreNamespacePreamble.h"
+namespace vfcore::detail
+{
+#include "$source_path"
+}
+WRAPPER
+    object="$BUILD_DIR/objects/$wrapper_name.o"
+    compile_background "$wrapper" "$object"
+    CORE_OBJECTS+=("$object")
+
+    # The same copied compatibility implementations are also needed by the standalone owner
+    # loader/mesher host. They are compiled globally for that reference layer, as in Build.ps1.
+    legacy_object="$BUILD_DIR/objects/legacy_${wrapper_name}.o"
+    compile_background "$source_path" "$legacy_object"
+    LEGACY_OBJECTS+=("$legacy_object")
+done < "$ROOT/Core/core_sources.txt"
+
+headless_object="$BUILD_DIR/objects/StreamBenchmarkHeadless.o"
+compile_background "$ROOT/Source/StreamBenchmarkHeadless.cpp" "$headless_object"
+LEGACY_OBJECTS+=("$headless_object")
+
+for pid in "${PIDS[@]}"; do wait "$pid"; done
+PIDS=()
+
+CORE_LIBRARY="$BUILD_DIR/libVoxelForgeCore.a"
+"$(command -v ar)" rcs "$CORE_LIBRARY" "${CORE_OBJECTS[@]}"
+OUTPUT="$BIN_DIR/VoxelForgeCoreHeadless-$VARIANT"
+"$COMPILER" -pthread "${LEGACY_OBJECTS[@]}" "$CORE_LIBRARY" -lz -o "$OUTPUT"
+CAPTURE_OUTPUT="$BIN_DIR/VoxelForgeOffscreenCapture-$VARIANT"
+"$COMPILER" -std=c++20 -O2 -fno-fast-math -pthread \
+    "$ROOT/Source/LinuxOffscreenCapture.cpp" -o "$CAPTURE_OUTPUT" \
+    $(pkg-config --cflags --libs egl glesv2 libpng)
+printf 'Built Core library: %s\nBuilt headless benchmark: %s\n' "$CORE_LIBRARY" "$OUTPUT"
+printf 'Built EGL offscreen capture: %s\n' "$CAPTURE_OUTPUT"
+printf 'Compiler: %s | variant: %s | fp-contract: %s | jobs: %s\n' "$COMPILER" "$VARIANT" "$FP_CONTRACT" "$JOBS"

Standalone/Compat/CoreMinimal.h

@@ -10,6 +10,7 @@
 #include <chrono>
 #include <charconv>
 #include <cctype>
+#include <cfloat>
 #include <cstdarg>
 #include <cmath>
 #include <cstdint>

Standalone/Compat/StandaloneDataAssetGlue.cpp

@@ -11,6 +11,11 @@ void UVoxelStrateDefinition::PostLoad()
     GenerationParams.bTunnelFloorEnabled = true;
 }
 
+FPrimaryAssetId UVoxelSeasonAsset::GetPrimaryAssetId() const
+{
+    return FPrimaryAssetId(TEXT("VoxelSeason"),GetFName());
+}
+
 bool UVoxelSeasonAsset::LoadManifest(FVoxelSeasonManifest& OutManifest, FString& OutReport) const
 {
     OutManifest = FVoxelSeasonManifest();

Standalone/Core/include/VoxelForgeCore/SharedColumnCache.h

@@ -0,0 +1,183 @@
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+namespace VoxelForgeCoreShared
+{
+    // Exact input identity for a pure XY column value. LOD is deliberately not part of this key:
+    // the same recipe/plan column has the same bits at every sampling step.
+    struct FColumnCacheKey
+    {
+        std::uint64_t recipeIdentity = 0;
+        std::uint64_t recipeContentHash = 0;
+        std::uint64_t planIdentity = 0;
+        std::uint64_t planContentHash = 0;
+        std::int64_t xSubvoxels = 0;
+        std::int64_t ySubvoxels = 0;
+        // Optional exact sub-domain identity for recipes with several independent columns
+        // at the same XY (for example, a floating-island anchor).
+        std::uint64_t contextIdentity = 0;
+
+        std::array<std::uint64_t, 7> words() const noexcept
+        {
+            return {recipeIdentity, recipeContentHash, planIdentity, planContentHash,
+                static_cast<std::uint64_t>(xSubvoxels), static_cast<std::uint64_t>(ySubvoxels),
+                contextIdentity};
+        }
+    };
+
+    // A bounded, world-owned second-level cache. Existing thread-local caches stay first, so
+    // their ordinary hit path remains private and lock-free. Shared hits read atomic words; only
+    // a shared miss takes the set spin lock. Entries are four-way set associative, evict on
+    // collision, and carry pointer identities plus content hashes to reject stale reuse.
+    // Les caches TLS restent le premier niveau; seul un defaut partage prend le verrou du groupe.
+    template <typename TValue, std::size_t SetCount, std::size_t Ways = 4>
+    class TSharedColumnValueCache
+    {
+        static_assert(SetCount > 0 && (SetCount & (SetCount - 1)) == 0,
+            "column cache set count must be a power of two");
+        static_assert(Ways > 0 && Ways <= 16, "unsupported column cache associativity");
+        static_assert(std::is_trivially_copyable_v<TValue>,
+            "shared column values must be trivially copyable");
+
+        static constexpr std::size_t ValueWordCount = (sizeof(TValue) + 7) / 8;
+        using FKeyWords = std::array<std::uint64_t, 7>;
+        using FValueWords = std::array<std::uint64_t, ValueWordCount>;
+
+        struct FEntry
+        {
+            std::atomic<std::uint64_t> Version{0};
+            std::atomic<std::uint64_t> Tag{0};
+            std::array<std::atomic<std::uint64_t>, 7> Key{};
+            std::array<std::atomic<std::uint64_t>, ValueWordCount> Value{};
+        };
+
+        struct FSet
+        {
+            std::atomic_flag Writer = ATOMIC_FLAG_INIT;
+            std::uint8_t NextWay = 0;
+            std::array<FEntry, Ways> Entries{};
+        };
+
+        struct FSpinGuard
+        {
+            explicit FSpinGuard(std::atomic_flag& value) : Flag(value)
+            {
+                while (Flag.test_and_set(std::memory_order_acquire))
+                    std::this_thread::yield();
+            }
+            ~FSpinGuard() { Flag.clear(std::memory_order_release); }
+            std::atomic_flag& Flag;
+        };
+
+    public:
+        TSharedColumnValueCache() : Sets(std::make_unique<FSet[]>(SetCount)) {}
+        TSharedColumnValueCache(const TSharedColumnValueCache&) = delete;
+        TSharedColumnValueCache& operator=(const TSharedColumnValueCache&) = delete;
+
+        static TSharedColumnValueCache* setThreadActive(TSharedColumnValueCache* value) noexcept
+        {
+            TSharedColumnValueCache* previous = Active;
+            Active = value;
+            return previous;
+        }
+
+        static TSharedColumnValueCache* threadActive() noexcept { return Active; }
+
+        template <typename TFactory>
+        TValue getOrCompute(const FColumnCacheKey& key, TFactory&& factory,
+            bool& computed)
+        {
+            computed = false;
+            const FKeyWords keyWords = key.words();
+            const std::uint64_t tag = Hash(keyWords);
+            const std::size_t setIndex = static_cast<std::size_t>(tag) & (SetCount - 1);
+            FSet& set = Sets[setIndex];
+            TValue value{};
+            if (TryReadSet(set, keyWords, tag, value)) return value;
+
+            FSpinGuard lock(set.Writer);
+            if (TryReadSet(set, keyWords, tag, value)) return value;
+
+            value = std::forward<TFactory>(factory)();
+            computed = true;
+            FValueWords valueWords{};
+            std::memcpy(valueWords.data(), &value, sizeof(TValue));
+
+            std::size_t replacement = Ways;
+            for (std::size_t way = 0; way < Ways; ++way)
+                if (set.Entries[way].Version.load(std::memory_order_seq_cst) == 0)
+                { replacement = way; break; }
+            if (replacement == Ways)
+            {
+                replacement = set.NextWay;
+                set.NextWay = static_cast<std::uint8_t>((set.NextWay + 1) % Ways);
+            }
+            FEntry& entry = set.Entries[replacement];
+            std::uint64_t version = entry.Version.load(std::memory_order_seq_cst);
+            if (version & 1u) ++version;
+            entry.Version.store(version + 1, std::memory_order_seq_cst);
+            for (std::size_t word = 0; word < keyWords.size(); ++word)
+                entry.Key[word].store(keyWords[word], std::memory_order_seq_cst);
+            for (std::size_t word = 0; word < valueWords.size(); ++word)
+                entry.Value[word].store(valueWords[word], std::memory_order_seq_cst);
+            entry.Tag.store(tag, std::memory_order_seq_cst);
+            entry.Version.store(version + 2, std::memory_order_seq_cst);
+            return value;
+        }
+
+    private:
+        static std::uint64_t Hash(const FKeyWords& words) noexcept
+        {
+            std::uint64_t hash = 0x9E3779B185EBCA87ull;
+            for (const std::uint64_t word : words)
+            {
+                hash ^= word + 0x9E3779B97F4A7C15ull + (hash << 6) + (hash >> 2);
+                hash ^= hash >> 30;
+                hash *= 0xBF58476D1CE4E5B9ull;
+                hash ^= hash >> 27;
+                hash *= 0x94D049BB133111EBull;
+                hash ^= hash >> 31;
+            }
+            return hash == 0 ? 1 : hash;
+        }
+
+        static bool TryRead(const FEntry& entry, const FKeyWords& keyWords,
+            std::uint64_t tag, TValue& out)
+        {
+            const std::uint64_t before = entry.Version.load(std::memory_order_seq_cst);
+            if (before == 0 || (before & 1u)
+                || entry.Tag.load(std::memory_order_seq_cst) != tag) return false;
+            FKeyWords foundKey{};
+            for (std::size_t word = 0; word < foundKey.size(); ++word)
+                foundKey[word] = entry.Key[word].load(std::memory_order_seq_cst);
+            if (foundKey != keyWords) return false;
+            FValueWords foundValue{};
+            for (std::size_t word = 0; word < foundValue.size(); ++word)
+                foundValue[word] = entry.Value[word].load(std::memory_order_seq_cst);
+            const std::uint64_t after = entry.Version.load(std::memory_order_seq_cst);
+            if (before != after || (after & 1u)) return false;
+            std::memcpy(&out, foundValue.data(), sizeof(TValue));
+            return true;
+        }
+
+        static bool TryReadSet(const FSet& set, const FKeyWords& keyWords,
+            std::uint64_t tag, TValue& out)
+        {
+            for (const FEntry& entry : set.Entries)
+                if (TryRead(entry, keyWords, tag, out)) return true;
+            return false;
+        }
+
+        std::unique_ptr<FSet[]> Sets;
+        inline static thread_local TSharedColumnValueCache* Active = nullptr;
+    };
+}

Standalone/Core/include/VoxelForgeCore/ThreadLocalStorage.h

@@ -0,0 +1,33 @@
+#pragma once
+
+// Keep large worker caches out of each thread's eager ELF TLS image. Each handle is itself
+// thread-local; its payload is allocated on the first use by that thread and released when the
+// thread exits. The payload is never shared and this type has no synchronization.
+namespace VoxelForgeCoreThreadLocal
+{
+    template <typename T>
+    class FLazy
+    {
+    public:
+        FLazy() noexcept = default;
+        FLazy(const FLazy&) = delete;
+        FLazy& operator=(const FLazy&) = delete;
+
+        ~FLazy()
+        {
+            delete Value;
+        }
+
+        T& Get()
+        {
+            if (Value == nullptr)
+            {
+                Value = new T{};
+            }
+            return *Value;
+        }
+
+    private:
+        T* Value = nullptr;
+    };
+}

Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h

@@ -110,9 +110,19 @@ namespace VoxelForgeCore
 
     enum class TileClass : std::uint8_t { allSolid, allAir, mixed, unknown };
 
+    struct HeightfieldColumnEvaluation
+    {
+        std::int64_t x = 0, y = 0;
+        std::uint64_t sequence = 0;
+        bool outsideTileFootprint = false;
+    };
+
     struct TileGenerationStats
     {
         TileClass tileClass = TileClass::unknown;
+        bool nativeOnlyRoute = false;
+        bool analyticRegionPageRoute = false;
+        bool nativeSurfaceTile = false;
         std::uint64_t solidBoxes = 0;
         std::uint64_t airBoxes = 0;
         std::uint64_t mixedBoxes = 0;
@@ -123,8 +133,35 @@ namespace VoxelForgeCore
         std::uint64_t unclampedFieldCalls = 0;
         std::uint64_t columnCacheHits = 0;
         std::uint64_t columnCacheMisses = 0;
+        std::uint64_t columnCacheConflictMisses = 0;
+        std::uint64_t sharedColumnCacheHits = 0;
+        std::uint64_t columnEvaluations = 0;
+        std::uint64_t uniformBlockProofsChecked = 0;
+        std::uint64_t uniformBlockProofSamplesChecked = 0;
+        std::uint64_t uniformBlockProofFallbackBlocks = 0;
+        std::uint64_t uniformBlockProofUnknownBlocks = 0;
+        std::uint64_t uniformBlockProofViolations = 0;
         double classificationMilliseconds = 0.0;
         double columnComputeMilliseconds = 0.0;
+        double columnEvaluationExclusiveMilliseconds = 0.0;
+        double marchingCubesColumnComputeMilliseconds = 0.0;
+        double groundRefinementColumnComputeMilliseconds = 0.0;
+        double capRefinementColumnComputeMilliseconds = 0.0;
+        double classificationExclusiveMilliseconds = 0.0;
+        double marchingCubesExclusiveMilliseconds = 0.0;
+        double marchingCubesDensityGridMilliseconds = 0.0;
+        double marchingCubesCellClassificationMilliseconds = 0.0;
+        double marchingCubesGradientNormalsMilliseconds = 0.0;
+        double marchingCubesEdgeInterpolationMilliseconds = 0.0;
+        double marchingCubesVertexDedupStreamMilliseconds = 0.0;
+        double marchingCubesSkirtMilliseconds = 0.0;
+        double marchingCubesOtherMilliseconds = 0.0;
+        std::uint64_t marchingCubesGradientFallbackDensityCalls = 0;
+        std::uint64_t marchingCubesEdgeMidpointDensityCalls = 0;
+        std::uint64_t marchingCubesGradientMemoHits = 0;
+        double groundRefinementExclusiveMilliseconds = 0.0;
+        double capRefinementExclusiveMilliseconds = 0.0;
+        double meshAssemblyMilliseconds = 0.0;
         double meshingMilliseconds = 0.0;
         double featureListMilliseconds = 0.0;
         double farShellMilliseconds = 0.0;
@@ -133,6 +170,20 @@ namespace VoxelForgeCore
         double farHorizonMilliseconds = 0.0;
         std::uint64_t farStratumFieldCalls = 0;
         std::uint64_t farConnectorFieldCalls = 0;
+        std::uint64_t farStratumColumnPointCalls = 0;
+        std::uint64_t farStratumColumnCacheHits = 0;
+        std::uint64_t farStratumColumnCacheMisses = 0;
+        std::uint64_t farStratumColumnConflictMisses = 0;
+        std::uint64_t farStratumSharedColumnCacheHits = 0;
+        std::uint64_t farStratumColumnEvaluations = 0;
+        std::uint64_t farConnectorColumnPointCalls = 0;
+        std::uint64_t farConnectorColumnCacheHits = 0;
+        std::uint64_t farConnectorColumnCacheMisses = 0;
+        std::uint64_t farConnectorColumnConflictMisses = 0;
+        std::uint64_t farConnectorSharedColumnCacheHits = 0;
+        std::uint64_t farConnectorColumnEvaluations = 0;
+        double farStratumColumnComputeMilliseconds = 0.0;
+        double farConnectorColumnComputeMilliseconds = 0.0;
         std::uint64_t farShellTrianglesAdded = 0;
         std::uint64_t horizonGroundTriangles = 0;
         std::uint64_t horizonGroundTrianglesRemoved = 0;
@@ -146,6 +197,9 @@ namespace VoxelForgeCore
         std::uint64_t capRefinedCells = 0;
         std::uint64_t capRefinedTriangles = 0;
         bool capRefined = false;
+        std::uint64_t columnEvaluationWorkerHash = 0;
+        bool columnCoordinateCaptureComplete = true;
+        std::vector<HeightfieldColumnEvaluation> evaluatedColumnCoordinates;
     };
 
     struct TileMesh
@@ -195,7 +249,8 @@ namespace VoxelForgeCore
     // L'assembleur v1 encode coordonnees et scalaires en 1/256 de voxel, independamment des tuiles.
     inline constexpr std::int64_t WorldAssemblySubvoxelsPerVoxel = 256;
     inline constexpr std::uint32_t WorldAssemblySchemaVersion = 1;
-    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 5;
+    // Version 6 binds every compiled tile page to the world's base density evaluator.
+    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 6;
 
     enum class FieldChannel : std::uint32_t
     {
@@ -627,7 +682,13 @@ namespace VoxelForgeCore
         std::uint64_t pointCalls = 0;
         std::uint64_t columnHits = 0;
         std::uint64_t columnMisses = 0;
+        std::uint64_t columnConflictMisses = 0;
+        std::uint64_t sharedColumnHits = 0;
+        std::uint64_t columnEvaluations = 0;
         double columnComputeMilliseconds = 0.0;
+        bool captureCoordinates = false;
+        bool coordinateCaptureComplete = true;
+        std::vector<HeightfieldColumnEvaluation> evaluatedCoordinates;
     };
 
     struct FieldInfluenceBounds
@@ -676,8 +737,17 @@ namespace VoxelForgeCore
             std::int64_t minimumYSubvoxels, std::int64_t minimumZSubvoxels,
             std::int64_t maximumXSubvoxels, std::int64_t maximumYSubvoxels,
             std::int64_t maximumZSubvoxels, std::int32_t stepVoxels) const noexcept;
-        static void resetThreadColumnCacheStats() noexcept;
-        static HeightfieldColumnCacheStats threadColumnCacheStats() noexcept;
+        static void resetThreadColumnCacheStats(bool captureCoordinates = false,
+            bool clearCache = false, std::uint32_t octaveDrop = 0) noexcept;
+        static void setThreadColumnCaptureBounds(std::int64_t minimumXSubvoxels,
+            std::int64_t minimumYSubvoxels, std::int64_t maximumXSubvoxels,
+            std::int64_t maximumYSubvoxels) noexcept;
+        static void setThreadColumnOctaveDrop(std::uint32_t octaveDrop) noexcept;
+        static std::uint32_t threadColumnOctaveDrop() noexcept;
+        static void setThreadColumnInterpolationStrideSubvoxels(std::int64_t stride) noexcept;
+        static std::int64_t threadColumnInterpolationStrideSubvoxels() noexcept;
+        static void setThreadColumnCacheLegacyDirectMapped(bool enabled) noexcept;
+        static const HeightfieldColumnCacheStats& threadColumnCacheStats() noexcept;
         FieldInterval interval(std::int64_t minimumXSubvoxels,
                                std::int64_t minimumYSubvoxels,
                                std::int64_t minimumZSubvoxels,
@@ -995,6 +1065,9 @@ namespace VoxelForgeCore
         std::int32_t bandMaxZVoxel = 2147483647;
         bool hashDensity = false;
         bool captureDensitySamples = false;
+        // Diagnostic only; materialize the full density lattice even when block proofs
+        // establish that the tile has no surface.
+        bool forceFullDensityCapture = false;
         bool skipUvAndColors = false;
         bool skipUv = false;
         bool skipColors = false;
@@ -1002,11 +1075,39 @@ namespace VoxelForgeCore
         // Validation control only; never participates in recipe/world identity.
         // Controle de validation seulement, sans effet sur l'identite du monde.
         bool useAssemblyFeatureQueries = true;
+        // Opt-in diagnostic only; records XY columns evaluated by this LOD8 tile.
+        // Diagnostic seulement; enregistre les colonnes XY evaluees par cette tuile LOD8.
+        bool captureColumnCoordinates = false;
+        bool useSharedColumnCache = true;
+        // Separate cold pass only; samples the MC inner stages without changing output.
+        // Passe froide separee seulement; mesure les etapes internes MC sans changer la sortie.
+        bool profileMesherStages = false;
+        // Diagnostic only; fills and checks every lattice sample in blocks certified uniform.
+        // Diagnostic seulement; evalue et verifie tous les echantillons des blocs uniformes.
+        bool auditUniformBlockProofs = false;
+        // Negative control for the shared XY-column cache; 1 restores the old direct-map indexing.
+        // Controle negatif du cache XY partage; 1 restaure l'ancien indexage direct.
+        bool legacyDirectMappedColumnCache = false;
+        // Diagnostic/performance control; memoizes exact MC lattice gradients at LOD0.
+        // Controle de mesure/performance; memorise les gradients MC exacts au LOD0.
+        bool memoizeMcGradients = true;
+        // LOD8-only planar horizon interior grid; zero follows the MC step, 128 restores S9.
+        // Grille interieure LOD8 seulement; zero suit la maille MC, 128 restaure S9.
+        std::int32_t lod8HorizonInteriorStepVoxels = 0;
         // Bump when the distant cap representation changes. LOD4-8 mesh hashes are salted;
         // density and LOD0-3 hashes remain unchanged.
         // Incremente quand le plafond lointain change. Les hashes LOD4-8 incluent cette version;
         // densite et hashes LOD0-3 restent inchanges.
-        std::uint32_t farHorizonVersion = 2;
+        std::uint32_t farHorizonVersion = 3;
+        // Linux research controls for reproducing L5 negative controls. Defaults preserve output.
+        std::uint32_t diagnosticGlobalOctaveDrop = 0;
+        std::uint32_t diagnosticCellStride = 1;
+        std::uint32_t diagnosticColumnInterpolationStride = 1;
+        // Diagnostic negative control only: deliberately bypass the native-only readiness
+        // proof and require the sampling guard to reject any shape-dependent tile.
+        // Controle negatif diagnostique: contourne volontairement la preuve native seule
+        // et exige que la garde rejette toute tuile dependante de la forme.
+        bool diagnosticForceNativeOnly = false;
     };
 
     class VFCORE_API World
@@ -1021,16 +1122,29 @@ namespace VoxelForgeCore
 
         bool compile(const ShapeBuildRequest& request, const JobScheduler& scheduler,
                      std::string& error);
+        // True only when a fine tile needs a separately compiled region before generation.
+        // Vrai seulement si une tuile fine doit attendre la compilation d'une region dediee.
+        bool needsTileRegion(const TileKey& tile) const;
+        // Conservative precompile proof: true only for a tile that can sample the native
+        // SurfaceWorld heightfield throughout its padded mesh domain without compiled shape data.
+        // Preuve prudente avant compilation: vrai seulement si toute la zone maillee avec marge
+        // utilise le champ SurfaceWorld natif, sans lire la forme compilee.
+        bool isTileShapeFree(const TileKey& tile) const;
         // Compile missing detail regions for entering fine tiles. Generated tile keys map to
-        // shared world-coordinate regions. The default analyticOnly path coalesces each entering
-        // LOD slab, builds its primitives/bins, and evaluates density on demand without
-        // rasterizing unused lattice volumes. Set false to use fixed absolute packed pages. The
-        // optional count is newly covered tile keys; regions stay resident until retainTileRegions.
+        // bounded, world-aligned pages. The default analyticOnly path builds each page's
+        // primitives/bins and evaluates density on demand without rasterizing unused lattice
+        // volumes. Set false to use fixed absolute packed pages. The optional count is newly
+        // covered tile keys; regions stay resident until retainTileRegions.
+        // Compile les regions de detail manquantes. Les tuiles entrantes sont regroupees en pages
+        // bornees alignees au monde; analyticOnly construit les primitives et bins sans rasteriser
+        // de volume inutilise. Sinon, utilise les pages compactes fixes; le compteur indique les
+        // nouvelles tuiles couvertes et retainTileRegions libere les anciennes regions.
         bool compileTileRegion(std::span<const TileKey> tiles, std::uint32_t workerLimit,
                                const JobScheduler& scheduler, std::string& error,
                                std::size_t* outCompiledTiles = nullptr,
                                TileRegionCompileStats* outStats = nullptr,
-                               bool analyticOnly = true);
+                               bool analyticOnly = true,
+                               bool diagnosticIncludeBaseCoveredTiles = false);
         void retainTileRegions(std::span<const TileKey> desiredTiles);
         void buildFarWorld();
         bool isCompiled() const noexcept;

Standalone/Core/src/CoreNamespacePreamble.h

@@ -10,6 +10,7 @@
 #include <cassert>
 #include <cctype>
 #include <charconv>
+#include <cfloat>
 #include <chrono>
 #include <cmath>
 #include <condition_variable>
@@ -53,3 +54,42 @@
 // value tree shared lets the viewer resolve its reference world and Core snapshot from one parse.
 #include "Json.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
+#include "VoxelForgeCore/ThreadLocalStorage.h"
+#include "VoxelForgeCore/SharedColumnCache.h"
+
+// Keep Core's expression-level FMA behavior fixed regardless of the toolchain setting.
+// Clang's "fast" mode ignores the pragma, so Core's runtime self-test rejects that build.
+#if defined(__clang__)
+    #pragma clang fp contract(off)
+#elif defined(_MSC_VER)
+    #pragma fp_contract(off)
+#elif defined(__GNUC__)
+    #pragma GCC optimize ("fp-contract=off")
+#else
+    #error "VoxelForge Core requires a compiler-specific FP contraction control"
+#endif
+
+namespace vfcore::fp_contract
+{
+#if defined(_MSC_VER)
+    #define VFCORE_FP_PROBE_NOINLINE __declspec(noinline)
+#else
+    #define VFCORE_FP_PROBE_NOINLINE __attribute__((noinline))
+#endif
+
+    [[maybe_unused]] static VFCORE_FP_PROBE_NOINLINE double multiplyAddProbe(
+        double a, double b, double c) noexcept
+    {
+        return a * b + c;
+    }
+
+    [[maybe_unused]] static bool selfTest() noexcept
+    {
+        volatile double a = 1.0 + 0x1p-27;
+        volatile double b = 1.0 - 0x1p-27;
+        volatile double c = -1.0;
+        return multiplyAddProbe(a, b, c) == 0.0;
+    }
+
+    #undef VFCORE_FP_PROBE_NOINLINE
+}

Standalone/Core/src/FloatingIslandsInternal.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "VoxelForgeCore/ThreadLocalStorage.h"
 #include "Json.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 
@@ -424,6 +425,9 @@ namespace floating_island_detail
     struct FIslandColumnCacheEntry
     {
         bool bValid=false;
+        const FloatingIslandRecipeV1* RecipeIdentity=nullptr;
+        const FloatingIslandPlanV1* PlanIdentity=nullptr;
+        std::uint64_t RecipeContentHash=0,PlanContentHash=0;
         std::uint32_t Seed=0;
         std::uint64_t StableId=0;
         std::int64_t SampleX=0,SampleY=0,CenterX=0,CenterY=0,TopZ=0,Radius=0,TopHalf=0;
@@ -431,9 +435,12 @@ namespace floating_island_detail
         double DeltaX=0.0,DeltaY=0.0,Radial=0.0,Angle=0.0,LobePhase=0.0,TopSurface=0.0;
     };
 
+    using FSharedIslandColumnCache =
+        VoxelForgeCoreShared::TSharedColumnValueCache<FIslandColumnCacheEntry,16384,4>;
+
     inline const FIslandColumnCacheEntry& IslandColumnCache(
-        const FloatingIslandRecipeV1& recipe,const FloatingIslandAnchorV1& island,
-        double x,double y)
+        const FloatingIslandRecipeV1& recipe,const FloatingIslandPlanV1& plan,
+        const FloatingIslandAnchorV1& island,double x,double y)
     {
         // Density samples arrive on integer Core lattice columns; reuse the exact column metrics
         // across Z samples without changing the field value or touching shared world state.
@@ -441,22 +448,29 @@ namespace floating_island_detail
         constexpr std::size_t Ways=4;
         constexpr std::size_t SetCount=2048;
         static_assert((SetCount&(SetCount-1))==0);
-        static thread_local std::array<FIslandColumnCacheEntry,SetCount*Ways> Cache{};
+        static thread_local VoxelForgeCoreThreadLocal::FLazy<
+            std::array<FIslandColumnCacheEntry,SetCount*Ways>> Cache;
+        auto& cache=Cache.Get();
         const std::int64_t SampleX=static_cast<std::int64_t>(x);
         const std::int64_t SampleY=static_cast<std::int64_t>(y);
         std::uint64_t IndexKey=island.stableId
             ^(static_cast<std::uint64_t>(SampleX)*0x9e3779b97f4a7c15ull)
             ^(static_cast<std::uint64_t>(SampleY)*0xc2b2ae3d27d4eb4full)
-            ^(static_cast<std::uint64_t>(recipe.seed)<<23);
+            ^(static_cast<std::uint64_t>(recipe.seed)<<23)
+            ^recipe.contentHash^std::rotl(plan.contentHash,17)
+            ^static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&recipe))
+            ^std::rotl(static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&plan)),31);
         IndexKey^=IndexKey>>33;
         IndexKey*=0xff51afd7ed558ccdull;
         IndexKey^=IndexKey>>33;
         const std::size_t Base=static_cast<std::size_t>(IndexKey&(SetCount-1))*Ways;
-        FIslandColumnCacheEntry* Replacement=&Cache[Base+((IndexKey>>11)&(Ways-1))];
+        FIslandColumnCacheEntry* Replacement=&cache[Base+((IndexKey>>11)&(Ways-1))];
         for(std::size_t Way=0;Way<Ways;++Way)
         {
-            FIslandColumnCacheEntry& Entry=Cache[Base+Way];
-            const bool bKeyMatches=Entry.bValid&&Entry.Seed==recipe.seed
+            FIslandColumnCacheEntry& Entry=cache[Base+Way];
+            const bool bKeyMatches=Entry.bValid&&Entry.RecipeIdentity==&recipe
+                &&Entry.PlanIdentity==&plan&&Entry.RecipeContentHash==recipe.contentHash
+                &&Entry.PlanContentHash==plan.contentHash&&Entry.Seed==recipe.seed
                 &&Entry.StableId==island.stableId
                 &&Entry.SampleX==SampleX&&Entry.SampleY==SampleY
                 &&Entry.CenterX==island.centerSubvoxels[0]
@@ -470,8 +484,14 @@ namespace floating_island_detail
             if(!Entry.bValid)Replacement=&Entry;
         }
 
-        FIslandColumnCacheEntry& Entry=*Replacement;
+        const auto build=[&]()
+        {
+            FIslandColumnCacheEntry Entry;
             Entry.bValid=true;
+            Entry.RecipeIdentity=&recipe;
+            Entry.PlanIdentity=&plan;
+            Entry.RecipeContentHash=recipe.contentHash;
+            Entry.PlanContentHash=plan.contentHash;
             Entry.Seed=recipe.seed;
             Entry.StableId=island.stableId;
             Entry.SampleX=SampleX;
@@ -496,6 +516,21 @@ namespace floating_island_detail
                 *static_cast<double>(island.topHalfSubvoxels)*2.0*Edge*Edge;
             Entry.TopSurface=static_cast<double>(island.topZSubvoxels)-Drop;
             return Entry;
+        };
+        FIslandColumnCacheEntry Entry{};
+        if(auto* shared=FSharedIslandColumnCache::threadActive())
+        {
+            const VoxelForgeCoreShared::FColumnCacheKey key{
+                static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&recipe)),
+                recipe.contentHash,
+                static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&plan)),
+                plan.contentHash,SampleX,SampleY,island.stableId};
+            bool computed=false;
+            Entry=shared->getOrCompute(key,build,computed);
+        }
+        else Entry=build();
+        *Replacement=Entry;
+        return *Replacement;
     }
 
     inline std::int64_t ScaledQ16(std::int64_t value, std::int64_t scaleQ16)
@@ -559,11 +594,13 @@ namespace floating_island_detail
         // Mettre en cache les constantes par worker; la cle complete evite tout partage d'etat.
         constexpr std::size_t CacheSize=1024;
         static_assert((CacheSize&(CacheSize-1))==0);
-        static thread_local std::array<FRootLobeCacheEntry,CacheSize> Cache{};
+        static thread_local VoxelForgeCoreThreadLocal::FLazy<
+            std::array<FRootLobeCacheEntry,CacheSize>> Cache;
+        auto& cache=Cache.Get();
         const std::uint64_t IndexKey=island.stableId^(island.stableId>>33)
             ^(static_cast<std::uint64_t>(recipe.seed)<<17)
             ^(static_cast<std::uint64_t>(static_cast<std::uint32_t>(rootIndex))*0x9e3779b97f4a7c15ull);
-        FRootLobeCacheEntry& Entry=Cache[static_cast<std::size_t>(IndexKey)&(CacheSize-1)];
+        FRootLobeCacheEntry& Entry=cache[static_cast<std::size_t>(IndexKey)&(CacheSize-1)];
         const bool bKeyMatches=Entry.bValid&&Entry.Seed==recipe.seed
             &&Entry.StableId==island.stableId&&Entry.RootIndex==rootIndex
             &&Entry.GeometryVersion==recipe.geometryVersion
@@ -636,6 +673,7 @@ namespace floating_island_detail
     }
 
     inline double IslandDensity(const FloatingIslandRecipeV1& recipe,
+                                const FloatingIslandPlanV1& plan,
                                 const FloatingIslandAnchorV1& island,
                                 double x, double y, double z)
     {
@@ -660,7 +698,7 @@ namespace floating_island_detail
                 std::max({z - top, radial - envelope, bottomZ - z}), x, y, z);
         }
 
-        const FIslandColumnCacheEntry& Column=IslandColumnCache(recipe,island,x,y);
+        const FIslandColumnCacheEntry& Column=IslandColumnCache(recipe,plan,island,x,y);
         const double dx=Column.DeltaX;
         const double dy=Column.DeltaY;
         const double radial=Column.Radial;
@@ -728,7 +766,7 @@ namespace floating_island_detail
         double result = static_cast<double>(MaxDensity);
         for (const auto& island : plan.islands)
         {
-            double group = IslandDensity(recipe, island,
+            double group = IslandDensity(recipe, plan, island,
                 static_cast<double>(x), static_cast<double>(y), static_cast<double>(z));
             for (const auto& edge : plan.clusterEdges)
             {
@@ -764,7 +802,7 @@ namespace floating_island_detail
         const auto evaluateLocalGroup = [&](std::size_t islandIndex)
         {
             const auto& island = plan.islands[islandIndex];
-            double group = IslandDensity(recipe, island,
+            double group = IslandDensity(recipe, plan, island,
                 static_cast<double>(x), static_cast<double>(y), static_cast<double>(z));
             for (const std::uint32_t edgeIndex : featureIndices)
             {
@@ -790,7 +828,7 @@ namespace floating_island_detail
         const auto evaluateDistantGroup = [&](std::size_t islandIndex)
         {
             const auto& island = plan.islands[islandIndex];
-            double group = IslandDensity(recipe, island,
+            double group = IslandDensity(recipe, plan, island,
                 static_cast<double>(x), static_cast<double>(y), static_cast<double>(z));
             for (const auto& edge : plan.clusterEdges)
             {

Standalone/Core/src/ShapeWorldInternal.h

@@ -319,6 +319,7 @@ public:
         Owner=&World;WorldAssembly=InWorldAssembly;
         WorkerCount=std::clamp(Workers,1,16);DetailVariant=Variant;
         Scheduler=InScheduler;RoundTunnelsEnabled=bInRoundTunnels;
+        bUseNativeManifestFields=true;
         bAnalyticOnly=false;
         bProfileDetailBand=bInProfileDetailBand;
         for(int32 A=0;A<3;++A)
@@ -470,10 +471,16 @@ public:
     bool BuildAnalyticRegion(FStandaloneOwnerWorld& World,const FIntVector& MinVoxels,
                const FIntVector& MaxVoxels,const FIntVector& ClipMinVoxels,
                const FIntVector& ClipMaxVoxels,EDetailVariant Variant,
-               bool bInRoundTunnels,std::string& Error)
+               bool bInRoundTunnels,
+               const VoxelForgeCore::WorldAssemblyManifest* InWorldAssembly,
+               std::string& Error)
     {
         using Clock=std::chrono::steady_clock;
-        Owner=&World;WorkerCount=1;DetailVariant=Variant;Scheduler=nullptr;
+        Owner=&World;WorldAssembly=InWorldAssembly;
+        WorkerCount=1;DetailVariant=Variant;Scheduler=nullptr;
+        // Analytic pages retain their bounded owner bins for route bookkeeping. Once published,
+        // the Core world binds each page to its base shape as the single density evaluator.
+        bUseNativeManifestFields=true;
         RoundTunnelsEnabled=bInRoundTunnels;bAnalyticOnly=true;bProfileDetailBand=false;
         for(int32 A=0;A<3;++A)
         {
@@ -487,7 +494,13 @@ public:
         const auto Stage=Clock::now();
         BuildLayerBounds();BuildOwnerPrimitives();
         if(RoundTunnelsEnabled)BuildRoundTunnelPrimitives();
-        BuildSpatialBins(LineBinSize);
+        // Analytic regions never build packed interval lines. Their exact-density fallback only
+        // reads the sparse 3D primitive bins; allocating the dense per-axis line-bin grids here
+        // scales with the region's XY bounding rectangle and is both unnecessary and unbounded.
+        // Les regions analytiques n'utilisent pas les intervalles compactes; leur repli exact lit
+        // les bins 3D clairsemes. Les grilles denses par axe croitraient avec la surface XY sans
+        // servir ce chemin.
+        BuildSpatialBins(LineBinSize,false);
         Stats.ShapeSeconds=std::chrono::duration<double>(Clock::now()-Stage).count();
         Stats.PrimitiveCount=Primitives.size();
         if(Primitives.empty())
@@ -497,6 +510,59 @@ public:
         return true;
     }
 
+    void InitializeNativeSurfaceOnly(FStandaloneOwnerWorld& World,
+        const VoxelForgeCore::WorldAssemblyManifest* InWorldAssembly,
+        const FIntVector& InMinimum,const FIntVector& InMaximum)
+    {
+        Owner=&World;WorldAssembly=InWorldAssembly;
+        NativeOnlyMinimum=InMinimum;NativeOnlyMaximum=InMaximum;
+        bUseNativeManifestFields=true;bNativeOnly=true;bAnalyticOnly=true;Built=true;
+        NativeOnlyViolations.store(0,std::memory_order_relaxed);
+    }
+
+    bool BuildShapeDependencyProof(FStandaloneOwnerWorld& World,
+        const FIntVector& MinVoxels,const FIntVector& MaxVoxels,bool bInRoundTunnels)
+    {
+        Owner=&World;WorkerCount=1;RoundTunnelsEnabled=bInRoundTunnels;
+        bAnalyticOnly=true;bNativeOnly=false;Stats={};
+        for(int32 Axis=0;Axis<3;++Axis)
+        {
+            Min[Axis]=(&MinVoxels.X)[Axis]-2;Max[Axis]=(&MaxVoxels.X)[Axis]+2;
+            ClipMin[Axis]=(&MinVoxels.X)[Axis];ClipMax[Axis]=(&MaxVoxels.X)[Axis];
+            Size[Axis]=Max[Axis]-Min[Axis]+1;
+            if(Size[Axis]<=0||Size[Axis]>4096||ClipMax[Axis]<ClipMin[Axis])return false;
+        }
+        BuildLayerBounds();BuildOwnerPrimitives();
+        if(RoundTunnelsEnabled)BuildRoundTunnelPrimitives();
+        return true;
+    }
+
+    bool HasShapeDependencyInBox(const FIntVector& Origin,int32 Step,int32 Cells) const
+    {
+        const int32 Pad=std::max(Step,1);
+        const int32 BMin[3]={Origin.X-Pad,Origin.Y-Pad,Origin.Z-Pad};
+        const int32 BMax[3]={Origin.X+(Cells+1)*Step,Origin.Y+(Cells+1)*Step,
+            Origin.Z+(Cells+1)*Step};
+        for(const FPrimitive& Primitive:Primitives)
+        {
+            bool bOverlaps=true;
+            for(int32 Axis=0;Axis<3;++Axis)
+                bOverlaps=bOverlaps&&Primitive.Max[Axis]+DetailBand>=BMin[Axis]
+                    &&Primitive.Min[Axis]-DetailBand<=BMax[Axis];
+            if(bOverlaps)return true;
+        }
+        for(const FInterval& Range:LayerRanges)
+            if(Range.Lo<=BMax[2]&&Range.Hi>=BMin[2]
+                &&(Range.Lo>=BMin[2]||Range.Hi<=BMax[2]))return true;
+        return false;
+    }
+
+    bool IsNativeOnly() const { return bNativeOnly; }
+    uint32 GetNativeOnlyViolationCount() const
+    { return NativeOnlyViolations.load(std::memory_order_relaxed); }
+    void RecordNativeOnlyViolation() const
+    { NativeOnlyViolations.fetch_add(1,std::memory_order_relaxed); }
+
     const FBuildStats& GetStats() const { return Stats; }
     bool IsBuilt() const { return Built; }
     bool HasFarWorld() const { return FarBuilt; }
@@ -925,6 +991,9 @@ public:
         }
     }
 
+    void SetSharedDensitySource(const FStandaloneShapeWorld* Source)
+    { SharedDensitySource=Source==this?nullptr:Source; }
+
     bool HasEditTransaction() const { return !EditBrushes.empty(); }
     FIntVector GetEditBoundsMin() const { return EditBoundsMin; }
     FIntVector GetEditBoundsMax() const { return EditBoundsMax; }
@@ -951,6 +1020,16 @@ public:
     // edge interpolation and normals to the existing mesher.
     float DensityAt(float X,float Y,float Z) const
     {
+        if(SharedDensitySource)return SharedDensitySource->DensityAt(X,Y,Z);
+        if(bNativeOnly)
+        {
+            if(!NativeOnlyContains(X,Y,Z))
+            {RecordNativeOnlyViolation();return 0.0f;}
+            float NativeDensity=0.0f;
+            if(!NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
+            {RecordNativeOnlyViolation();return 0.0f;}
+            return NativeDensity;
+        }
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(X,Y,Z,IslandDensity))
         {
@@ -975,6 +1054,18 @@ public:
 
     float DensityAtLattice(int32 X,int32 Y,int32 Z) const
     {
+        if(SharedDensitySource)return SharedDensitySource->DensityAtLattice(X,Y,Z);
+        if(bNativeOnly)
+        {
+            if(!NativeOnlyContains(static_cast<float>(X),static_cast<float>(Y),
+                static_cast<float>(Z)))
+            {RecordNativeOnlyViolation();return 0.0f;}
+            float NativeDensity=0.0f;
+            if(!NativeSurfaceDensityAt(static_cast<float>(X),static_cast<float>(Y),
+                static_cast<float>(Z),NativeDensity))
+            {RecordNativeOnlyViolation();return 0.0f;}
+            return NativeDensity;
+        }
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(static_cast<float>(X),static_cast<float>(Y),
             static_cast<float>(Z),IslandDensity))
@@ -1003,6 +1094,16 @@ public:
 
     float DensityAtUnclamped(float X,float Y,float Z) const
     {
+        if(SharedDensitySource)return SharedDensitySource->DensityAtUnclamped(X,Y,Z);
+        if(bNativeOnly)
+        {
+            if(!NativeOnlyContains(X,Y,Z))
+            {RecordNativeOnlyViolation();return 0.0f;}
+            float NativeDensity=0.0f;
+            if(!NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
+            {RecordNativeOnlyViolation();return 0.0f;}
+            return NativeDensity;
+        }
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(X,Y,Z,IslandDensity))
         {
@@ -1022,7 +1123,10 @@ public:
 
     VoxelForgeCore::DetailFieldSample DetailSampleAt(float X,float Y,float Z) const
     {
+        if(SharedDensitySource)return SharedDensitySource->DetailSampleAt(X,Y,Z);
         VoxelForgeCore::DetailFieldSample Sample;
+        if(bNativeOnly)
+        {RecordNativeOnlyViolation();return Sample;}
         AnalyticDensityAt(X,Y,Z,false,&Sample.displacement,
             &Sample.caveInfluence,&Sample.floorInfluence);
         return Sample;
@@ -1038,8 +1142,19 @@ public:
     void DensityAtLatticeX8(int32 XStart,int32 XStep,int32 Y,int32 Z,
                             int32 Count,float OutDensity[8]) const
     {
+        if(SharedDensitySource)
+        {
+            SharedDensitySource->DensityAtLatticeX8(XStart,XStep,Y,Z,Count,OutDensity);
+            return;
+        }
         Count=std::clamp(Count,0,8);
         if(Count==0)return;
+        if(bNativeOnly)
+        {
+            for(int32 Lane=0;Lane<Count;++Lane)
+                OutDensity[Lane]=DensityAtLattice(XStart+Lane*XStep,Y,Z);
+            return;
+        }
         bool bHasLegacySurfaceSample=false;
         bool bHasNativeIslandSample=false;
         for(int32 Lane=0;Lane<Count;++Lane)
@@ -1138,6 +1253,8 @@ private:
                             float* OutFloorInfluence=nullptr,
                             bool bApplyEdits=true) const
     {
+        if(SharedDensitySource)return SharedDensitySource->AnalyticDensityAt(X,Y,Z,
+            bClampNearZero,OutDetailDisplacement,OutCaveInfluence,OutFloorInfluence,bApplyEdits);
         if(OutDetailDisplacement)*OutDetailDisplacement=0.0f;
         if(OutCaveInfluence)*OutCaveInfluence=0.0f;
         if(OutFloorInfluence)*OutFloorInfluence=0.0f;
@@ -1200,12 +1317,21 @@ public:
     bool GetNativeSurfaceHeightsAt(float X,float Y,int32 ChunkZ,
                                    float& OutGroundZ,float& OutCeilingZ) const
     {
+        if(SharedDensitySource)
+            return SharedDensitySource->GetNativeSurfaceHeightsAt(X,Y,ChunkZ,OutGroundZ,OutCeilingZ);
         if(!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
             ||!std::isfinite(X)||!std::isfinite(Y))return false;
+        const std::int64_t chunkMinimum=static_cast<std::int64_t>(ChunkZ)*CHUNK_SIZE;
+        const std::int64_t chunkMaximum=chunkMinimum+CHUNK_SIZE;
+        if(bNativeOnly&&(!NativeOnlyContainsColumn(X,Y)
+            ||chunkMaximum<NativeOnlyMinimum.Z||chunkMinimum>NativeOnlyMaximum.Z
+            ||Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
+                !=ECaveGeneratorType::SurfaceWorld))
+        {RecordNativeOnlyViolation();return false;}
         if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
             !=ECaveGeneratorType::SurfaceWorld)return false;
         const int32 StrateIndex=Owner->Manager->GetStrateIndex(
-            static_cast<float>((static_cast<double>(ChunkZ*CHUNK_SIZE+CHUNK_SIZE/2))*VOXEL_SIZE));
+            static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
         const auto* Plan=FindWorldAssemblyStratum(StrateIndex,ChunkZ);
         if(!Plan)return false;
         constexpr double Scale=static_cast<double>(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
@@ -1227,8 +1353,49 @@ public:
     EVoxelTileClass ClassifyBox(const FIntVector& Origin,int32 Step,int32 Cells) const
     { return ClassifyBoxDetailed(Origin,Step,Cells).Verdict; }
 
-    FBoxClassification ClassifyBoxDetailed(const FIntVector& Origin,int32 Step,int32 Cells) const
+    bool IsNativeSurfaceBox(const FIntVector& Origin,int32 Step,int32 Cells) const
     {
+        if(SharedDensitySource)return SharedDensitySource->IsNativeSurfaceBox(Origin,Step,Cells);
+        if(!WorldAssembly||!Owner||!Owner->Manager||Step<=0||Cells<=0)return false;
+        const int32 Pad=std::max(Step,1);
+        const int32 BMin=Origin.Z-Pad;
+        const int32 BMax=Origin.Z+(Cells+1)*Step;
+        const int32 FirstChunk=FMath::FloorToInt(static_cast<float>(BMin)
+            /static_cast<float>(CHUNK_SIZE));
+        const int32 LastChunk=FMath::FloorToInt(static_cast<float>(BMax)
+            /static_cast<float>(CHUNK_SIZE));
+        const VoxelForgeCore::WorldAssemblyStratumPlanV1* Plan=nullptr;
+        for(int32 ChunkZ=FirstChunk;ChunkZ<=LastChunk;++ChunkZ)
+        {
+            const auto It=std::find_if(WorldAssembly->plan.strates.begin(),
+                WorldAssembly->plan.strates.end(),[ChunkZ](const auto& Entry)
+                {return ChunkZ<=Entry.topChunkZ&&ChunkZ>=Entry.bottomChunkZ;});
+            if(It==WorldAssembly->plan.strates.end())return false;
+            const auto* Candidate=&*It;
+            if(Plan&&Plan!=Candidate)return false;
+            if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
+                !=ECaveGeneratorType::SurfaceWorld)return false;
+            Plan=Candidate;
+        }
+        if(bNativeOnly)
+        {
+            const int32 BMinX=Origin.X-Pad,BMinY=Origin.Y-Pad;
+            const int32 BMaxX=Origin.X+(Cells+1)*Step;
+            const int32 BMaxY=Origin.Y+(Cells+1)*Step;
+            if(BMinX<NativeOnlyMinimum.X||BMinY<NativeOnlyMinimum.Y
+                ||BMin<NativeOnlyMinimum.Z||BMaxX>NativeOnlyMaximum.X
+                ||BMaxY>NativeOnlyMaximum.Y||BMax>NativeOnlyMaximum.Z)
+            {RecordNativeOnlyViolation();return false;}
+        }
+        if(bNativeOnly&&!Plan)RecordNativeOnlyViolation();
+        return Plan!=nullptr;
+    }
+
+    FBoxClassification ClassifyBoxDetailed(const FIntVector& Origin,int32 Step,int32 Cells,
+                                            bool bUseNativeLatticeProof=false) const
+    {
+        if(SharedDensitySource)
+            return SharedDensitySource->ClassifyBoxDetailed(Origin,Step,Cells,bUseNativeLatticeProof);
         using Clock=std::chrono::steady_clock;
         const auto Start=Clock::now();
         const int32 Pad=std::max(Step,1);
@@ -1254,7 +1421,7 @@ public:
                 {
                     bSurfaceOverlap=true;
                     const int32 StrateIndex=Owner->Manager->GetStrateIndex(
-                        static_cast<float>((static_cast<double>(ChunkZ*CHUNK_SIZE+CHUNK_SIZE/2))*VOXEL_SIZE));
+                        static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
                     const auto* Candidate=FindWorldAssemblyStratum(StrateIndex,ChunkZ);
                     if(!Candidate||(SurfacePlan&&SurfacePlan!=Candidate))
                         bBadPlan=true;
@@ -1279,7 +1446,7 @@ public:
                 {
                     bIslandOverlap=true;
                     const int32 StrateIndex=Owner->Manager->GetStrateIndex(
-                        static_cast<float>((static_cast<double>(ChunkZ*CHUNK_SIZE+CHUNK_SIZE/2))*VOXEL_SIZE));
+                        static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
                     const auto* Candidate=FindWorldAssemblyFloatingIslandStratum(StrateIndex,ChunkZ);
                     if(!Candidate||(IslandPlan&&IslandPlan!=Candidate))bBadPlan=true;
                     IslandPlan=Candidate;
@@ -1300,6 +1467,19 @@ public:
             else ++Counts.MixedBoxes;
             return Result;
         };
+        if(bNativeOnly)
+        {
+            const bool bInsideProofBox=BMin[0]>=NativeOnlyMinimum.X
+                &&BMin[1]>=NativeOnlyMinimum.Y&&BMin[2]>=NativeOnlyMinimum.Z
+                &&BMax[0]<=NativeOnlyMaximum.X&&BMax[1]<=NativeOnlyMaximum.Y
+                &&BMax[2]<=NativeOnlyMaximum.Z;
+            if(!bInsideProofBox||!bSurfaceOverlap||bIslandOverlap||bOtherStrateOverlap
+                ||bBadPlan||!EditBrushes.empty())
+            {
+                RecordNativeOnlyViolation();
+                return Finish(EVoxelTileClass::Mixed,true);
+            }
+        }
         // A box crossing recipes cannot use one field interval; unknown composition stays Mixed.
         // Une boite qui traverse plusieurs recettes reste Mixed, car l'intervalle d'un seul champ ne suffit pas.
         if(bBadPlan||(bSurfaceOverlap&&(bIslandOverlap||bOtherStrateOverlap))
@@ -1310,6 +1490,12 @@ public:
             &&EditBoundsMin.Y<=BMax[1]&&EditBoundsMax.Y>=BMin[1]
             &&EditBoundsMin.Z<=BMax[2]&&EditBoundsMax.Z>=BMin[2])
             return Finish(EVoxelTileClass::Mixed,true);
+        // The native interval path below is the exact field selected first by DensityAtLattice
+        // for SurfaceWorld and FloatingIslands. Legacy analytic primitives/layer bounds cannot
+        // modify that field; only the explicit edit transaction above can. Keep their guards on
+        // the legacy classifier path, where those overlays do participate in density.
+        if(!bNativeOnly&&(!bUseNativeLatticeProof||(!bSurfaceOverlap&&!bIslandOverlap)))
+        {
             for(int32 BZ=FloorDiv(BMin[2],ActiveSpatialBinSize);BZ<=FloorDiv(BMax[2],ActiveSpatialBinSize);++BZ)
             for(int32 BY=FloorDiv(BMin[1],ActiveSpatialBinSize);BY<=FloorDiv(BMax[1],ActiveSpatialBinSize);++BY)
             for(int32 BX=FloorDiv(BMin[0],ActiveSpatialBinSize);BX<=FloorDiv(BMax[0],ActiveSpatialBinSize);++BX)
@@ -1327,10 +1513,14 @@ public:
                 if(R.Lo<=BMax[2]&&R.Hi>=BMin[2]
                     &&(R.Lo>=BMin[2]||R.Hi<=BMax[2]))
                     return Finish(EVoxelTileClass::Mixed);
+        }
         if(bSurfaceOverlap)
         {
             if(!WorldAssembly||!SurfacePlan)return Finish(EVoxelTileClass::Mixed,true);
             const VoxelForgeCore::Heightfield2D Block(WorldAssembly->recipe,*SurfacePlan);
+            // classifyLatticeBox takes the exact extrema of ground/cap columns at every
+            // MC lattice XY in this box. Since density is min(z-ground, cap-z), those extrema
+            // bound every lattice sample in Z without a noise amplitude guess.
             const auto Verdict=Block.classifyLatticeBox(
                 static_cast<int64>(BMin[0])*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel,
                 static_cast<int64>(BMin[1])*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel,
@@ -1386,6 +1576,7 @@ public:
 
     bool IsRock(int32 X,int32 Y,int32 Z) const
     {
+        if(SharedDensitySource)return SharedDensitySource->IsRock(X,Y,Z);
         if(!Contains(X,Y,Z))return EvaluateFast(X,Y,Z);
         const size_t Line=static_cast<size_t>(Y-Min[1])*Size[0]
             +static_cast<size_t>(X-Min[0]);
@@ -1843,6 +2034,21 @@ public:
     }
 
 private:
+    bool NativeOnlyContainsColumn(float X,float Y) const
+    {
+        return std::isfinite(X)&&std::isfinite(Y)
+            &&X>=NativeOnlyMinimum.X&&X<=NativeOnlyMaximum.X
+            &&Y>=NativeOnlyMinimum.Y&&Y<=NativeOnlyMaximum.Y;
+    }
+
+    bool NativeOnlyContains(float X,float Y,float Z) const
+    {
+        return std::isfinite(X)&&std::isfinite(Y)&&std::isfinite(Z)
+            &&X>=NativeOnlyMinimum.X&&X<=NativeOnlyMaximum.X
+            &&Y>=NativeOnlyMinimum.Y&&Y<=NativeOnlyMaximum.Y
+            &&Z>=NativeOnlyMinimum.Z&&Z<=NativeOnlyMaximum.Z;
+    }
+
     static FClassificationThreadStats& ThreadClassificationStats()
     {
         static thread_local FClassificationThreadStats Stats;
@@ -1871,13 +2077,13 @@ private:
 
     bool NativeSurfaceDensityAt(float X,float Y,float Z,float& OutDensity) const
     {
-        if(!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
+        if(!bUseNativeManifestFields||!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
             ||!std::isfinite(X)||!std::isfinite(Y)||!std::isfinite(Z))return false;
         const int32 ChunkZ=FMath::FloorToInt(Z/static_cast<float>(CHUNK_SIZE));
         if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
             !=ECaveGeneratorType::SurfaceWorld)return false;
         const int32 StrateIndex=Owner->Manager->GetStrateIndex(
-            static_cast<float>((static_cast<double>(ChunkZ*CHUNK_SIZE+CHUNK_SIZE/2))*VOXEL_SIZE));
+            static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
         const auto* Plan=FindWorldAssemblyStratum(StrateIndex,ChunkZ);
         if(!Plan)return false;
         constexpr double Scale=static_cast<double>(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
@@ -1896,8 +2102,9 @@ private:
 
     bool NativeFloatingIslandDensityAt(float X,float Y,float Z,float& OutDensity) const
     {
-        if(!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
-            ||!std::isfinite(X)||!std::isfinite(Y)||!std::isfinite(Z))return false;
+        if(!bUseNativeManifestFields||!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
+            ||!std::isfinite(X)||!std::isfinite(Y)||!std::isfinite(Z))
+            return false;
         // Convert Core query Z back to the owner's legacy chunk coordinate.
         // Convertir Z du Core vers la coordonnee de chunk legacy du proprietaire.
         const double CoreVoxelsPerLegacyChunk=GetCoreVoxelsPerOwnerChunk();
@@ -1905,7 +2112,7 @@ private:
         if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
             !=ECaveGeneratorType::FloatingIslands)return false;
         const int32 StrateIndex=Owner->Manager->GetStrateIndex(
-            static_cast<float>((static_cast<double>(ChunkZ*CHUNK_SIZE+CHUNK_SIZE/2))*VOXEL_SIZE));
+            static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
         const auto* Plan=FindWorldAssemblyFloatingIslandStratum(StrateIndex,ChunkZ);
         if(!Plan)return false;
         constexpr double Scale=static_cast<double>(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
@@ -4637,7 +4844,18 @@ public:
     void DensityAtLatticeZRun(int32 X,int32 Y,int32 ZStart,int32 ZStep,
                               int32 Count,float* OutDensity) const
     {
+        if(SharedDensitySource)
+        {
+            SharedDensitySource->DensityAtLatticeZRun(X,Y,ZStart,ZStep,Count,OutDensity);
+            return;
+        }
         if(Count<=0||OutDensity==nullptr)return;
+        if(bNativeOnly)
+        {
+            for(int32 Lane=0;Lane<Count;++Lane)
+                OutDensity[Lane]=DensityAtLattice(X,Y,ZStart+Lane*ZStep);
+            return;
+        }
         bool bHasLegacySurfaceSample=false;
         for(int32 Lane=0;Lane<Count;++Lane)
             bHasLegacySurfaceSample|=UsesLegacySurfaceField(static_cast<float>(X),
@@ -5161,6 +5379,7 @@ private:
 
     FStandaloneOwnerWorld* Owner=nullptr;
     const VoxelForgeCore::WorldAssemblyManifest* WorldAssembly=nullptr;
+    const FStandaloneShapeWorld* SharedDensitySource=nullptr;
     int32 WorkerCount=6;
     const VoxelForgeCore::JobScheduler* Scheduler=nullptr;
     bool RoundTunnelsEnabled=false;
@@ -5174,6 +5393,11 @@ private:
     size_t WordsPerZ=0;
     EDetailVariant DetailVariant=EDetailVariant::Coherent;
     bool Built=false;
+    bool bNativeOnly=false;
+    bool bUseNativeManifestFields=false;
+    FIntVector NativeOnlyMinimum=FIntVector::ZeroValue;
+    FIntVector NativeOnlyMaximum=FIntVector::ZeroValue;
+    mutable std::atomic<uint32> NativeOnlyViolations{0};
     bool FarBuilt=false;
     std::vector<FInterval> LayerRanges;
     std::vector<FLayerField> LayerFields;

Standalone/Core/src/WorldAssemblerInternal.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include "VoxelForgeCore/ThreadLocalStorage.h"
 #include "Json.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 
 #include <algorithm>
+#include <atomic>
 #include <bit>
 #include <charconv>
 #include <chrono>
@@ -120,6 +122,9 @@ WorldAssemblyFeatureColumnRangeV1 BuildWorldAssemblyFeatureColumnRangeV1(
 
 namespace world_assembly_detail
 {
+    using FSharedHeightfieldColumnCache =
+        VoxelForgeCoreShared::TSharedColumnValueCache<HeightfieldPointSample,131072,4>;
+
     // Preserve recipe order without allocating or looking up metadata in the point loop.
     // Garder l'ordre de recette sans allocation ni recherche de metadonnees par point.
     struct FeatureRange
@@ -1027,11 +1032,19 @@ namespace world_assembly_detail
                                           std::int64_t wavelengthSubvoxels)
     { return FloorDiv(positionSubvoxels * Q16, wavelengthSubvoxels); }
 
+    // Audit-only override; normal tile generation resets this to zero before evaluating a recipe.
+    // Surcharge reservee aux mesures; la generation remet zero avant d'evaluer une recette.
+    inline thread_local std::uint32_t HeightfieldColumnOctaveDrop = 0;
+    inline thread_local std::int64_t HeightfieldColumnInterpolationStrideSubvoxels = 0;
+
     inline std::int32_t FractalNoiseQ16(std::int64_t xQ16, std::int64_t yQ16,
         std::int64_t zQ16, std::uint32_t octaves, bool ridged = false)
     {
         std::int64_t total = 0, weightSum = 0, weight = Q16, ridgeWeight = Q16;
-        for (std::uint32_t octave = 0; octave < octaves; ++octave)
+        std::uint32_t effectiveOctaves=octaves;
+        if(HeightfieldColumnOctaveDrop!=0&&octaves!=0)
+            effectiveOctaves=std::max(1u,octaves-std::min(octaves-1,HeightfieldColumnOctaveDrop));
+        for (std::uint32_t octave = 0; octave < effectiveOctaves; ++octave)
         {
             const std::int64_t scale = 1ll << octave;
             const std::int64_t noise = Perlin3DQ16(xQ16 * scale,yQ16 * scale,zQ16 * scale);
@@ -1354,11 +1367,39 @@ namespace world_assembly_detail
         std::int64_t x = 0, y = 0;
         HeightfieldPointSample column{};
     };
-    // Coarse LOD tiles revisit a wider set of gradient-sample columns than the full-resolution
-    // band. Keep those columns resident for a complete worker tile so the 3D mesher does not
-    // repeat the procedural biome evaluation for every Z sample.
-    inline thread_local std::array<HeightfieldColumnCacheEntry, 65536> HeightfieldColumnCache{};
+    // Keep 65,536 entries in each worker cache; four ways tolerate coordinate families that
+    // deliberately share low hash bits at coarse LODs.
+    // Chaque cache worker garde 65 536 entrees; quatre voies absorbent les coordonnees grossieres
+    // qui partagent les bits faibles du hash.
+    constexpr std::size_t HeightfieldColumnCacheWays=4;
+    constexpr std::size_t HeightfieldColumnCacheSetCount=65536/HeightfieldColumnCacheWays;
+    inline thread_local VoxelForgeCoreThreadLocal::FLazy<
+        std::array<HeightfieldColumnCacheEntry, 65536>> HeightfieldColumnCache;
+    inline thread_local VoxelForgeCoreThreadLocal::FLazy<
+        std::array<std::uint8_t, HeightfieldColumnCacheSetCount>> HeightfieldColumnCacheNextWay;
     inline thread_local HeightfieldColumnCacheStats HeightfieldColumnStats{};
+    inline thread_local bool HeightfieldColumnCacheLegacyDirectMapped=false;
+    inline thread_local std::array<std::int64_t,4> HeightfieldColumnCaptureBounds{};
+    inline thread_local bool HeightfieldColumnCaptureBoundsValid=false;
+    inline std::atomic<std::uint64_t> HeightfieldColumnCaptureSequence{0};
+
+    inline std::size_t HeightfieldColumnCacheSet(const WorldAssemblyRecipeV1& recipe,
+        const WorldAssemblyStratumPlanV1& plan,std::int64_t x,std::int64_t y) noexcept
+    {
+        // Avalanche every coordinate bit before masking. The old direct hash kept too little
+        // entropy from widely spaced coarse LOD coordinates in its low 16 bits.
+        // Melanger tous les bits de coordonnee avant le masque; l'ancien hash perdait de
+        // l'entropie sur les coordonnees espacees des LOD grossiers.
+        std::uint64_t mixed=static_cast<std::uint64_t>(x)*0x9E3779B185EBCA87ull
+            ^std::rotl(static_cast<std::uint64_t>(y)*0xC2B2AE3D27D4EB4Full,29)
+            ^recipe.contentHash^std::rotl(plan.contentHash,17);
+        mixed^=mixed>>30;
+        mixed*=0xBF58476D1CE4E5B9ull;
+        mixed^=mixed>>27;
+        mixed*=0x94D049BB133111EBull;
+        mixed^=mixed>>31;
+        return static_cast<std::size_t>(mixed)&(HeightfieldColumnCacheSetCount-1);
+    }
 
     inline HeightfieldPointSample EvaluateColumn(const WorldAssemblyRecipeV1& recipe,
         const WorldAssemblyStratumPlanV1& plan,std::int64_t x,std::int64_t y)
@@ -1473,20 +1514,126 @@ namespace world_assembly_detail
     inline HeightfieldPointSample CachedColumn(const WorldAssemblyRecipeV1& recipe,
         const WorldAssemblyStratumPlanV1& plan,std::int64_t x,std::int64_t y)
     {
+        const std::int64_t InterpolationStride=HeightfieldColumnInterpolationStrideSubvoxels;
+        if(InterpolationStride>0)
+        {
+            const std::int64_t X0=FloorDiv(x,InterpolationStride)*InterpolationStride;
+            const std::int64_t Y0=FloorDiv(y,InterpolationStride)*InterpolationStride;
+            const std::int64_t X1=X0+InterpolationStride,Y1=Y0+InterpolationStride;
+            const std::int64_t Fx=x-X0,Fy=y-Y0;
+            struct FScopedInterpolationSampling
+            {
+                std::int64_t Previous=HeightfieldColumnInterpolationStrideSubvoxels;
+                ~FScopedInterpolationSampling()
+                {HeightfieldColumnInterpolationStrideSubvoxels=Previous;}
+            } SamplingScope;
+            HeightfieldColumnInterpolationStrideSubvoxels=0;
+            const HeightfieldPointSample C00=CachedColumn(recipe,plan,X0,Y0);
+            const HeightfieldPointSample C10=CachedColumn(recipe,plan,X1,Y0);
+            const HeightfieldPointSample C01=CachedColumn(recipe,plan,X0,Y1);
+            const HeightfieldPointSample C11=CachedColumn(recipe,plan,X1,Y1);
+            const auto Lerp=[&](std::int64_t A,std::int64_t B,std::int64_t T)
+            {return A+((B-A)*T)/InterpolationStride;};
+            const auto Bilinear=[&](std::int64_t A,std::int64_t B,
+                std::int64_t C,std::int64_t D)
+            {
+                const std::int64_t Top=Lerp(A,B,Fx),Bottom=Lerp(C,D,Fx);
+                return Lerp(Top,Bottom,Fy);
+            };
+            HeightfieldPointSample Out=C00;
+            Out.groundHeightSubvoxels=Bilinear(C00.groundHeightSubvoxels,
+                C10.groundHeightSubvoxels,C01.groundHeightSubvoxels,
+                C11.groundHeightSubvoxels);
+            Out.capHeightSubvoxels=Bilinear(C00.capHeightSubvoxels,
+                C10.capHeightSubvoxels,C01.capHeightSubvoxels,
+                C11.capHeightSubvoxels);
+            return Out;
+        }
+        if(HeightfieldColumnOctaveDrop!=0)
+            return EvaluateColumn(recipe,plan,x,y);
+        auto& cache=HeightfieldColumnCache.Get();
+        auto& nextWay=HeightfieldColumnCacheNextWay.Get();
+        HeightfieldColumnCacheEntry* replacement=nullptr;
+        if(HeightfieldColumnCacheLegacyDirectMapped)
+        {
+            // Preserve S13's exact direct-map index as an in-process negative control.
+            // Conserver l'index direct exact de S13 comme controle negatif en cours d'execution.
             const std::uint64_t mixed=(static_cast<std::uint64_t>(x)*0x9E3779B185EBCA87ull)
                 ^std::rotl(static_cast<std::uint64_t>(y)*0xC2B2AE3D27D4EB4Full,23)
                 ^static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&recipe))
                 ^std::rotl(static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&plan)),41);
-        auto& entry=HeightfieldColumnCache[static_cast<std::size_t>(mixed)&
-            (HeightfieldColumnCache.size()-1)];
-        if(entry.recipe==&recipe&&entry.plan==&plan&&entry.recipeHash==recipe.contentHash
-            &&entry.planHash==plan.contentHash&&entry.x==x&&entry.y==y)
-        {++HeightfieldColumnStats.columnHits;return entry.column;}
+            replacement=&cache[static_cast<std::size_t>(mixed)&(cache.size()-1)];
+            if(replacement->recipe==&recipe&&replacement->plan==&plan
+                &&replacement->recipeHash==recipe.contentHash
+                &&replacement->planHash==plan.contentHash&&replacement->x==x&&replacement->y==y)
+            {++HeightfieldColumnStats.columnHits;return replacement->column;}
+            if(replacement->recipe!=nullptr)++HeightfieldColumnStats.columnConflictMisses;
+        }
+        else
+        {
+            const std::size_t set=HeightfieldColumnCacheSet(recipe,plan,x,y);
+            const std::size_t first=set*HeightfieldColumnCacheWays;
+            std::size_t replacementWay=HeightfieldColumnCacheWays;
+            for(std::size_t way=0;way<HeightfieldColumnCacheWays;++way)
+            {
+                auto& candidate=cache[first+way];
+                if(candidate.recipe==&recipe&&candidate.plan==&plan
+                    &&candidate.recipeHash==recipe.contentHash&&candidate.planHash==plan.contentHash
+                    &&candidate.x==x&&candidate.y==y)
+                {++HeightfieldColumnStats.columnHits;return candidate.column;}
+                if(candidate.recipe==nullptr&&replacementWay==HeightfieldColumnCacheWays)
+                    replacementWay=way;
+            }
+            if(replacementWay==HeightfieldColumnCacheWays)
+            {
+                ++HeightfieldColumnStats.columnConflictMisses;
+                replacementWay=nextWay[set];
+            }
+            nextWay[set]=static_cast<std::uint8_t>(
+                (replacementWay+1)%HeightfieldColumnCacheWays);
+            replacement=&cache[first+replacementWay];
+        }
+        auto& entry=*replacement;
+        ++HeightfieldColumnStats.columnMisses;
+        const auto compute=[&]()
+        {
+            const std::uint64_t sequence=HeightfieldColumnStats.captureCoordinates
+                ?HeightfieldColumnCaptureSequence.fetch_add(1,std::memory_order_relaxed):0;
             const auto start=std::chrono::steady_clock::now();
-        HeightfieldPointSample column=EvaluateColumn(recipe,plan,x,y);
+            HeightfieldPointSample result=EvaluateColumn(recipe,plan,x,y);
             HeightfieldColumnStats.columnComputeMilliseconds+=std::chrono::duration<double,std::milli>(
                 std::chrono::steady_clock::now()-start).count();
-        ++HeightfieldColumnStats.columnMisses;
+            ++HeightfieldColumnStats.columnEvaluations;
+            if(HeightfieldColumnStats.captureCoordinates
+                &&HeightfieldColumnStats.coordinateCaptureComplete)
+            {
+                try
+                {
+                    const bool outside=HeightfieldColumnCaptureBoundsValid
+                        &&(x<HeightfieldColumnCaptureBounds[0]||x>HeightfieldColumnCaptureBounds[2]
+                            ||y<HeightfieldColumnCaptureBounds[1]||y>HeightfieldColumnCaptureBounds[3]);
+                    HeightfieldColumnStats.evaluatedCoordinates.push_back({x,y,sequence,outside});
+                }
+                catch(...)
+                {
+                    HeightfieldColumnStats.coordinateCaptureComplete=false;
+                }
+            }
+            return result;
+        };
+        HeightfieldPointSample column{};
+        if(auto* shared=FSharedHeightfieldColumnCache::threadActive())
+        {
+            const VoxelForgeCoreShared::FColumnCacheKey key{
+                static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&recipe)),
+                recipe.contentHash,
+                static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(&plan)),
+                plan.contentHash,x,y};
+            bool computed=false;
+            column=shared->getOrCompute(key,compute,computed);
+            if(!computed)++HeightfieldColumnStats.sharedColumnHits;
+        }
+        else column=compute();
         entry={&recipe,&plan,recipe.contentHash,plan.contentHash,x,y,column};
         return column;
     }
@@ -1954,10 +2101,58 @@ HeightfieldPointSample Heightfield2D::point(std::int64_t x, std::int64_t y,
     return out;
 }
 
-void Heightfield2D::resetThreadColumnCacheStats() noexcept
-{ world_assembly_detail::HeightfieldColumnStats={}; }
+void Heightfield2D::resetThreadColumnCacheStats(bool captureCoordinates, bool clearCache,
+    std::uint32_t octaveDrop) noexcept
+{
+    // Diagnostic probes may clear old tile entries before comparing isolated sample grids.
+    // Les sondes de mesure peuvent vider les entrees d'une tuile avant de comparer deux grilles.
+    if(clearCache)
+    {
+        world_assembly_detail::HeightfieldColumnCache.Get().fill(
+            world_assembly_detail::HeightfieldColumnCacheEntry{});
+        world_assembly_detail::HeightfieldColumnCacheNextWay.Get().fill(0);
+    }
+    auto& Stats=world_assembly_detail::HeightfieldColumnStats;
+    world_assembly_detail::HeightfieldColumnOctaveDrop=octaveDrop;
+    Stats.pointCalls=0;
+    Stats.columnHits=0;
+    Stats.columnMisses=0;
+    Stats.columnConflictMisses=0;
+    Stats.sharedColumnHits=0;
+    Stats.columnEvaluations=0;
+    Stats.columnComputeMilliseconds=0.0;
+    Stats.captureCoordinates=captureCoordinates;
+    Stats.coordinateCaptureComplete=true;
+    Stats.evaluatedCoordinates.clear();
+    world_assembly_detail::HeightfieldColumnCaptureBoundsValid=false;
+}
 
-HeightfieldColumnCacheStats Heightfield2D::threadColumnCacheStats() noexcept
+void Heightfield2D::setThreadColumnCaptureBounds(std::int64_t minimumXSubvoxels,
+    std::int64_t minimumYSubvoxels,std::int64_t maximumXSubvoxels,
+    std::int64_t maximumYSubvoxels) noexcept
+{
+    world_assembly_detail::HeightfieldColumnCaptureBounds={minimumXSubvoxels,
+        minimumYSubvoxels,maximumXSubvoxels,maximumYSubvoxels};
+    world_assembly_detail::HeightfieldColumnCaptureBoundsValid=true;
+}
+
+void Heightfield2D::setThreadColumnCacheLegacyDirectMapped(bool enabled) noexcept
+{ world_assembly_detail::HeightfieldColumnCacheLegacyDirectMapped=enabled; }
+
+void Heightfield2D::setThreadColumnOctaveDrop(std::uint32_t octaveDrop) noexcept
+{ world_assembly_detail::HeightfieldColumnOctaveDrop=octaveDrop; }
+
+std::uint32_t Heightfield2D::threadColumnOctaveDrop() noexcept
+{ return world_assembly_detail::HeightfieldColumnOctaveDrop; }
+
+void Heightfield2D::setThreadColumnInterpolationStrideSubvoxels(std::int64_t stride) noexcept
+{ world_assembly_detail::HeightfieldColumnInterpolationStrideSubvoxels=std::max<std::int64_t>(0,stride); }
+
+std::int64_t Heightfield2D::threadColumnInterpolationStrideSubvoxels() noexcept
+{ return world_assembly_detail::HeightfieldColumnInterpolationStrideSubvoxels; }
+
+
+const HeightfieldColumnCacheStats& Heightfield2D::threadColumnCacheStats() noexcept
 { return world_assembly_detail::HeightfieldColumnStats; }
 
 HeightfieldBoxClass Heightfield2D::classifyLatticeBox(std::int64_t minimumX,

Standalone/Research/OwnerShapeWorld/gpu_field_port/LUNA_DIALOGUE.md

@@ -1237,3 +1237,101 @@ occurred. I did not open the owner's editor, build his project or edit assets, a
 push or stash.
 
 — Luna
+
+
+## World assembler S5 / M3 Round 9 — 2026-10-19
+
+I separated walkable collision, rendered enclosure, and per-LOD refinement rather than using the
+moving full-clipmap resident count as a gate. The old standalone order queued and started LOD0 first;
+the owner-camera trace shows LOD8 queue-wait p95 at 16.290 s and LOD8 build p95 at 365.8 ms. A
+five-second 60 m/s capture crossed 37 centers and logged 5,006 new requests / 3,211 queued cancels.
+This establishes queue churn, but not a visual-gap duration or proof that the Unreal actor starves.
+
+The source candidate gives the shared actor scheduler a collision-ring → coarse-shell → LOD0/1
+refinement order, retains the authored near reserve while moving, and adds request/start ordinals and
+discard tracing. Standalone mirrors the order and has a legacy-order control. I did not add an LOD8
+placeholder because initial overlapping parents do not have an all-descendants swap gate. The loaded
+full-view capture still shows a large sky region; do not call enclosure passed from tile counts.
+
+The S4-to-current standalone timing mismatch is unresolved: both report 2,553 tiles, but the current
+cold CPU run is 16.685 s versus Round 8's 3.107 s. The default-camera first run built only 2,226
+tiles and was rerun with the owner camera. Spawn samples through 2.0 s and the 60 m/s mid-flight
+sample are black. No candidate BuildHost, after captures, negative-control run, or S5 hash matrix is
+available yet.
+
+I stopped before compiling because plugin-root `CLAUDE.md` §#1 explicitly says never build/compile
+and to hand off at “ready to build.” The report lists the exact outstanding checks, compile spots,
+and every failed or corrected run in [WorldAssemblerM3/Round9/REPORT.md](../../WorldAssemblerM3/Round9/REPORT.md).
+No owner editor/project or asset was touched; no commit, push or stash was made.
+
+— Luna
+
+
+## World assembler S6 / M3 Round 10 — 2026-10-19
+
+The 251 ms staircase was the residency sampler cadence; direct tile apply events are the completion
+clock. The legacy-order control completed the staged 2,578-key set in 17.412 s. Gating coarse-first
+admission behind the nine-tile walkable ring reduced it to 11.704 s without delaying that gate
+(0.632 → 0.627 s). The 12-mesh / 14 ms spawn apply boost did not improve the legacy timeline, so it
+remains opt-in and the normal 4-mesh / 2 ms guard stays in place. Worker-side work supply/admission
+remains the measured floor; the trace does not isolate why worker slots stay idle. The 1.57 s aim is
+still unmet and rendered enclosure remains unproven in the null-RHI harness.
+
+The corrected standalone 60 m/s route now counts +Y crossings across multi-chunk deltas. Its
+crossing data is valid, though the latency gate still fails. W1/W8/W16 and all nine LOD hashes match
+S5. The new trace, regressions, run ledger, exact log-captured command lines, hashes and compile
+spots are in [WorldAssemblerM3/Round10/REPORT.md](../../WorldAssemblerM3/Round10/REPORT.md).
+
+— Luna
+
+
+## World assembler S7 / M3 Round 11 — 2026-10-19
+
+The BuildHost trace counted the old scheduler declines: after LOD0 completed, coarse work
+hit the four-slot near reserve for 877 frames; 806 also had finished results waiting to
+apply and counted against the old cap. The shared dynamic reserve and active-task count cut
+the cold 2,578-key set from 17.527 s to 7.780 s. The walkable ring is 0.581 s and full
+LOD0 is 1.439 s, both inside the requested limits. The full set still misses the roughly
+4.2 s worker-seconds/10-slots estimate, and measured worker task-seconds rose about 10%,
+so this is a throughput win with a tile-cost question left to profile. The moving trace also
+shows a separate `bCoreRegionCompilePending` gate: 10 legacy and 11 dynamic submission passes
+were rejected during region rebuilds despite free slots.
+
+W1/W8/W16 determinism, Core-off, M2 fixtures, SurfaceWorld/FloatingIslands, S3 ground
+agreement and S4 cap coverage passed. Three Standalone captures are saved, but their window
+was hidden/occluded and they do not sign off player-visible enclosure. I reviewed RMC's
+update batching, async collision and render-proxy paths; no change was clearly worth the
+measured apply cost this round. Full commands, hashes, RMC source references, quality
+limits and the async audit are in [WorldAssemblerM3/Round11/REPORT.md](../../WorldAssemblerM3/Round11/REPORT.md).
+
+No new source file was added. The likely compile spots are `VoxelWorld.cpp` and
+`VoxelWorld.h` in the VoxelForge runtime module; the harness controls changed in
+`Tools/TestVoxelForgeCoreWorldHost.ps1`. No owner project/editor, asset or external plugin
+file was modified. No commit, push or stash was made.
+
+— Luna
+
+
+## World assembler S8 / M3 Round 12 — 2026-10-19
+
+The S7 trace's moving-path `bCoreRegionCompilePending` stop was real: the matched 6 m/s negative
+control rejected 11 whole scheduler passes while region pages were rebuilt. With concurrent
+admission enabled, those passes disappeared and 110 unrelated tiles submitted; all 11 support
+centers still had a ready nine-tile ring. Overall moving worker use stayed near 2.7 of 10 slots, so
+this closes the region gate without changing the separate spawn bottleneck.
+
+The 60 m/s + 400 m teleport run admitted independent work too, but most center changes outran the
+walkable ring. Spawn remains 7.7 s: 306 LOD8 jobs make a broad tail, while no one job exceeds
+95 ms. The measured queue cap held the slow-apply backlog at 256 results / 76.2 MB; disabling it
+reached 1,577 / 125.1 MB. Core-off, M2 fixtures, SurfaceWorld, FloatingIslands, S3/S4 and W1/W8/W16
+checks passed. The optional tick subsystem marker was not added, leaving the 29 ms walk maximum
+unattributed.
+
+Full metrics, the matched controls, hashes, commands and async audit are in
+[`WorldAssemblerM3/Round12/REPORT.md`](../../WorldAssemblerM3/Round12/REPORT.md).
+
+No new source file was added. Compile spots are `VoxelWorld.cpp/.h`, the Core public header and
+`VoxelForgeCore.cpp`, `VoxelForgeExploreCommandlet.cpp`, and the BuildHost harness. No owner
+project/editor, asset or external plugin file was modified; no commit, push or stash was made.
+
+— Luna

Standalone/Research/WorldAssemblerM3/HANDOFF-ABYSS.md

@@ -0,0 +1,78 @@
+# Handoff: speed research moves to abyss (Debian 13, i9-12900HK)
+
+Written 2026-10-19 by the Windows orchestrator (Claude) for the Claude instance on abyss.
+
+## Where things stand
+- Branch `assembler/world`. Rounds S3–S13 committed. Each round's report is `Standalone/Research/WorldAssemblerM3/Round*/REPORT.md`.
+  Latest committed: S13 `87b0e5d` (Round17, a tile-cost breakdown, diagnostics only).
+- **S14 (Round18) is running on the Windows PC.** Its targets:
+  - LOD0 marching cubes costs 243 ns/sample: find out what's inside it;
+  - fix LOD4's column-cache misses (8,224 vs about 1,700);
+  - add shared column pages only if they're still worth it.
+
+  The Windows side finishes, reviews, commits and pushes it. Pull before you touch Core files.
+- **Current in-game numbers** (owner plan, BuildHost actor, 25 cm SurfaceWorld, owner's 5800X3D):
+  - full set about 4.9 s (S7: 17.4 s);
+  - walkable ring about 0.51 s;
+  - LOD0 about 1.09 s;
+  - 40 m/s ring 75/75;
+  - about 29 worker-seconds over 8 TaskGraph background workers.
+- **Open levers, in rough order:**
+  1. the S14 findings;
+  2. a frequency-aware far detail cutoff. A global octave drop failed, and the 2 cm LOD-agreement gate rejects any far
+     simplification, so a screen-space gate would need the owner's OK;
+  3. visibility-aware scheduling in caves;
+  4. RMC batching;
+  5. per-strate voxel size;
+  6. a disk terrain cache.
+
+  The disk cache is approved as a FEATURE (multiplayer-compatible, compression tested), not as a speed fix.
+
+## Owner rules (non-negotiable)
+- **Writable scope:** the VoxelForge repo only. On abyss, ask the owner before installing system packages, UE or
+  toolchains.
+- Never push `main`. Pushing `assembler/world` (and feature branches) is allowed.
+- **Byte-identical output vs earlier rounds is NEVER a gate.** The gates are:
+  - determinism of the current build across worker counts;
+  - no quality regression;
+  - bump the recipe version when output changes.
+- **Speed is judged on the cold path** (nothing cached): walking, flying and 40 m/s running must be smooth on a
+  first visit.
+- Changes go in the shared layer and must benefit every generator family.
+- Luna (Codex `gpt-6-luna`, effort max) implements; Claude orchestrates. Claude doesn't write code itself. Sol costs
+  20× and is used only for short read-only design asks, with the owner's OK.
+- **Briefs:**
+  - investigation rounds are open QUESTIONS answered with measurements, not directives;
+  - give the goal, invariants and evidence bar, not the method;
+  - be kind: credit what the last round got right.
+- Every brief says "Do not commit, push or stash". Claude reviews against the code and captures, then commits
+  specific files (never files over 300 KB, never raw PNGs).
+- **Owner explanations:**
+  - plain language, headline first;
+  - say what he'll SEE or feel in game;
+  - say what's measured vs inferred.
+- Plugin hard rules are in `CLAUDE.md`, plus `CODEMAP.md` and `ARCHITECTURE.md` (§8.10 protected invariants).
+
+## Codex launch (Linux)
+```
+codex exec -m gpt-6-luna -c model_reasoning_effort="max" -c sandbox_mode="workspace-write" -c tools.web_search=true - < brief.md > out.log 2>&1
+```
+- Launch it as a tracked background task, so you're notified when it ends.
+- **On "Selected model is at capacity":** wait 120 s, then resume with
+  `codex exec resume <session id> -m gpt-6-luna ... -` and a short "continue where you left off" on stdin.
+- Watch for runaway processes (more than 40 min) and rounds longer than 6 h.
+
+## First round on abyss: Linux baseline (proposed)
+1. **Build.** Get the Core library (`Standalone/Core`) and its headless benchmark/audit/hash tools building with Clang
+   on Linux. The Windows standalone uses MSVC plus a D3D11 viewer, so the viewer stays Windows-only.
+2. **Baseline.** Record the laptop baseline on its performance cores (plugged in, fixed power profile):
+   - per-LOD tile cost (S13 counters);
+   - standalone full clipmap;
+   - W1/W8/W12 hashes.
+3. **Determinism.** Compare the hashes against Windows (Round17/Round16 list them). A Linux/Windows mismatch is a real
+   multiplayer finding: dedicated servers usually run Linux.
+4. **Later, only if the owner agrees and provides UE 5.7 Linux plus his assets:** headless BuildHost (`-nullrhi`)
+   tests on Linux.
+
+**Not transferable:** cache-size effects (24 MB vs 96 MB L3), thread/slot tuning, smoothness, captures. Those must be
+confirmed on the owner's Windows PC before they're claimed to him.

Standalone/Research/WorldAssemblerM3/Linux1/MeasureProcess.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Run one child and report its wait4 peak RSS without /usr/bin/time."""
+import os
+import resource
+import sys
+import time
+
+if len(sys.argv) < 2:
+    raise SystemExit("usage: MeasureProcess.py executable [arguments ...]")
+
+address_limit, _ = resource.getrlimit(resource.RLIMIT_AS)
+stack_limit, _ = resource.getrlimit(resource.RLIMIT_STACK)
+if address_limit in (resource.RLIM_INFINITY, -1) or address_limit > 6 * 1024**3:
+    raise SystemExit("run under prlimit --as=6442450944")
+if stack_limit in (resource.RLIM_INFINITY, -1) or stack_limit < 64 * 1024**2:
+    raise SystemExit("run under prlimit --stack=67108864:67108864")
+if not os.sched_getaffinity(0).issubset(set(range(12))):
+    raise SystemExit("run under taskset -c 0-11")
+print(f"[ProcessLimits] address_limit={address_limit} stack_limit={stack_limit} affinity={sorted(os.sched_getaffinity(0))}", flush=True)
+
+started = time.monotonic()
+pid = os.fork()
+if pid == 0:
+    try:
+        os.execvp(sys.argv[1], sys.argv[1:])
+    except OSError as error:
+        print(f"MeasureProcess: exec failed: {error}", file=sys.stderr, flush=True)
+        os._exit(127)
+
+_, status, usage = os.wait4(pid, 0)
+wall = time.monotonic() - started
+exit_code = os.waitstatus_to_exitcode(status)
+print(f"[ProcessResources] exit_code={exit_code} wall_s={wall:.6f} peak_rss_kib={usage.ru_maxrss}", flush=True)
+raise SystemExit(exit_code)

Standalone/Research/WorldAssemblerM3/Linux1/REPORT.md

@@ -0,0 +1,153 @@
+# L1 — Linux baseline (abyss)
+
+## What changed
+
+- `Standalone/Source/StreamBenchmarkPipeline.h` now holds the S13 streaming benchmark, hash helpers, and per-LOD reporting. The Windows viewer and the headless executable call the same functions.
+- `Standalone/Source/WorldAssemblyPrototype.h` holds the existing Round 1 plan builder; both executables call it.
+- `Standalone/Source/StreamBenchmarkHeadless.cpp` is the Linux CLI entry point. It loads the same owner JSON, resolves it through `StandaloneOwnerLoader`, builds the same Core snapshot, and runs the shared pipeline. It has no window, renderer, D3D11, or Win32 setup.
+- `Standalone/BuildLinux.sh` builds the Core library and headless executable. `Linux1/MeasureProcess.py` checks affinity and memory/stack limits and records child peak RSS.
+- `Standalone/Source/StandaloneViewer.cpp` now includes and calls the shared headers. `Standalone/Core/src/CoreNamespacePreamble.h` and `Standalone/Compat/CoreMinimal.h` include `<cfloat>` for existing `FLT_MAX` use. `Standalone/Compat/StandaloneDataAssetGlue.cpp` now supplies the standalone `UVoxelSeasonAsset::GetPrimaryAssetId` implementation matching the engine source.
+
+The headless entry point retains the parsed JSON root for the existing snapshot adapter. The route planner, Core shape compile, tile generator, hash code, and pipeline counters are shared with the viewer, rather than reimplemented. Viewer-only command switches for process affinity, priority, and frame limit are accepted for command-line parity; the Linux runner pins and limits itself externally.
+
+**Windows compile risk:** MSVC was unavailable here, so the Windows viewer was not compiled. The likely risk spots are the new includes and namespaced calls in `StandaloneViewer.cpp`, and the moved inline bodies in `StreamBenchmarkPipeline.h` and `WorldAssemblyPrototype.h`; `Build.ps1` compiles that viewer with `/std:c++20`. The Linux-only main, script, and RSS helper are not in the explicit Windows source list. The compatibility `GetPrimaryAssetId` mirrors `VoxelSeasonAsset.cpp`; keep the engine `.cpp` out of the Standalone compatibility manifest to avoid a duplicate if that manifest is expanded later. No density formula changed, so no recipe-version bump is needed.
+
+## Build and run commands
+
+Run from the repo root. `BuildLinux.sh` enforces CPUs 0–11 and a 6 GiB address-space limit itself; the explicit wrapper below makes those limits visible at the call site too. The build output is under `Standalone/Build/linux-*` and `Standalone/bin/linux/`.
+
+```bash
+taskset -c 0-11 prlimit --as=6442450944 -- \
+  bash Standalone/BuildLinux.sh --compiler=clang++-19 --variant=clang19 --jobs=12 --fp-contract=off \
+  > Saved/Linux/build-clang19-final.log 2>&1
+
+taskset -c 0-11 prlimit --as=6442450944 -- \
+  bash Standalone/BuildLinux.sh --compiler=g++-14 --variant=gcc14 --jobs=12 --fp-contract=off \
+  > Saved/Linux/build-gcc14.log 2>&1
+```
+
+The measured build flags were `-std=c++20 -O2 -mavx2 -mfma -ffp-contract=off -fno-fast-math`; Clang also suppresses the legacy narrowing diagnostic that MSVC accepts. The benchmark wrapper below enforces the 6 GiB address-space cap, a 64 MiB stack, and CPU affinity, then records `wait4` peak RSS. These are the exact run calls; `yes` adds `--profile-column-overlap`.
+
+```bash
+run_bench() {
+  local variant="$1" workers="$2" overlap="$3" name="$4"
+  local profile=()
+  if [[ "$overlap" == yes ]]; then profile+=(--profile-column-overlap); fi
+  taskset -c 0-11 prlimit --as=6442450944 --stack=67108864:67108864 -- \
+    python3 Standalone/Research/WorldAssemblerM3/Linux1/MeasureProcess.py \
+    "Standalone/bin/linux/VoxelForgeCoreHeadless-$variant" Standalone/data/owner_world.json \
+    --workers="$workers" --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash \
+    --force-generate --clip-radius=3 --max-clip-level=8 \
+    --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 \
+    --process-priority=Normal --process-affinity=4095 --frame-limit=60 \
+    "${profile[@]}" > "Saved/Linux/$name.log" 2>&1
+}
+
+run_bench clang19 1 no bench-clang19-w1-r1
+run_bench clang19 8 no bench-clang19-w8-r1
+run_bench clang19 12 no bench-clang19-w12-r1
+run_bench clang19 8 no bench-clang19-w8-r2
+run_bench clang19 12 no bench-clang19-w12-r2
+run_bench clang19 1 no bench-clang19-w1-r2
+run_bench clang19 12 no bench-clang19-w12-r3
+run_bench clang19 1 no bench-clang19-w1-r3
+run_bench clang19 8 no bench-clang19-w8-r3
+run_bench clang19 8 yes bench-clang19-w8-columns-r1
+run_bench clang19 8 yes bench-clang19-w8-columns-r2
+run_bench clang19 8 yes bench-clang19-w8-columns-r3
+run_bench gcc14 8 no bench-gcc14-w8
+```
+
+Every run used a fresh process and a newly constructed streamer; the pipeline reported `cache_hits=0`, so no process or thread-local tile/column cache carried over. `--force-generate` was passed for CLI parity, not relied on for isolation. The kernel file cache was not purged: doing so would require a system-wide setting outside the allowed write boundary. Owner JSON load is included in the cold-start timer and took about 5 ms.
+
+## Hashes and determinism
+
+Every Linux hash below covers the same 2,553-tile Round17 view. Clang used `-ffp-contract=off`, matching the intended MSVC `/fp:precise` behavior; GCC used the same contraction setting. Both builds enabled AVX2/FMA instructions but disabled contraction.
+
+| Build / workers | Runs | Density | Mesh | Payload | Topology | Tiles |
+|---|---:|---|---|---|---|---:|
+| Windows S13 reference, W1/W8/W12 | S13 | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` | 2,553 |
+| Linux Clang 19, W1 | 3 | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` | 2,553 |
+| Linux Clang 19, W8 | 3 | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` | 2,553 |
+| Linux Clang 19, W12 | 3 | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` | 2,553 |
+| Linux GCC 14, W8 | 1 | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` | 2,553 |
+
+There was no divergence in this owner seed/view, so there is no first sample or stage to bisect and no density fix to make. The result covers the full hashed view, not every possible seed or platform math-library input. The tested flags show no observable FMA, libm, integer-width, container-order, or SIMD difference here; they do not establish what default Clang contraction would do.
+
+Clang W1/W8/W12 each produced identical hashes across all three runs. The GCC W8 run agreed too. The overlap-capture counts varied slightly with worker scheduling, while the generated hashes stayed fixed.
+
+## Linux timing and per-LOD cost
+
+Machine: Debian 13, Intel i9-12900H, 15 GB RAM, 24 MiB L3. Processes were pinned to logical CPUs 0–11 (the six P-cores and their SMT siblings); CPUs 12–19 remained free. CPUs 0–11 reported `powersave` governor and `balance_performance` EPP. No governor or system setting was changed; priority remained normal. `RLIMIT_AS` was 6 GiB for every build and benchmark process. The benchmark stack was limited to 64 MiB after the default-stack failures below. No run reached the 30-minute limit.
+
+`whole_view_ready` is the cold-start timer from process start through all 2,553 tiles, including owner load, plan, shape compile, and streamed generation. Values are median `[min–max]` of three interleaved runs. Peak RSS values are the three `wait4` readings in KiB, in run order; the maximum across all successful runs was 604,652 KiB.
+
+| Workers | `whole_view_ready` median [range] | Peak RSS per run (KiB) |
+|---:|---:|---|
+| W1 | 16.555 s [16.069–16.660] | 218,372 / 329,308 / 329,012 |
+| W8 | 3.562 s [3.558–3.602] | 445,884 / 462,588 / 462,216 |
+| W12 | 3.512 s [3.482–3.557] | 536,884 / 537,208 / 539,036 |
+| W8 with overlap capture | 3.718 s [3.638–3.718] | 603,820 / 603,480 / 604,652 |
+| GCC 14 W8 hash check | 3.789 s (one run) | 463,276 |
+
+The S13 W8 Windows reference was 3.518 s on the owner’s 5800X3D. The Linux W8 result is 44 ms (about 1.3%) slower for the same source view and timer, but these are different CPUs and this is a baseline comparison, not an optimization result. Round17 documents no corresponding W1/W12 timing for a direct comparison.
+
+The next table divides S13’s accumulated `worker_sum_s` by tile count. Each cell is median `[min–max]` milliseconds per tile across the three Clang runs. It is average worker time per tile, not a per-tile p95 or whole-pipeline elapsed time.
+
+| LOD | W1 ms/tile | W8 ms/tile | W12 ms/tile |
+|---:|---:|---:|---:|
+| 0 | 2.131 [2.066–2.144] | 4.222 [4.146–4.343] | 6.405 [6.364–6.489] |
+| 1 | 4.429 [4.281–4.441] | 7.394 [7.335–7.491] | 11.084 [11.000–11.296] |
+| 2 | 1.319 [1.282–1.319] | 1.871 [1.842–1.943] | 2.771 [2.740–2.813] |
+| 3 | 5.520 [5.366–5.527] | 7.916 [7.860–8.179] | 11.777 [11.670–11.916] |
+| 4 | 16.305 [15.787–16.344] | 23.403 [23.382–23.798] | 34.479 [34.229–34.654] |
+| 5 | 7.389 [7.223–7.443] | 10.714 [10.567–10.926] | 15.520 [15.288–15.605] |
+| 6 | 15.521 [15.021–15.638] | 22.183 [21.813–22.350] | 32.063 [31.641–32.163] |
+| 7 | 17.203 [16.495–17.226] | 24.476 [23.925–24.560] | 33.760 [33.085–33.885] |
+| 8 | 12.087 [11.673–12.228] | 16.591 [16.559–16.617] | 22.738 [22.610–23.673] |
+
+S13’s exclusive stage counters are also retained per LOD: column evaluation, marching cubes, ground/cap refinement, and mesh assembly. At W8, column evaluation averaged 21.124 ms/tile at LOD4 `[21.083–21.462]`, versus 6.815 ms at LOD3 `[6.761–7.014]`; LOD4 remains the standout cost. Standalone has matching aggregate stage sums, but no BuildHost-style per-tile p95 or per-LOD classify-exclusive p95. It also has no counterpart for full-scan versus candidate feature-list p95, field-point calls p95, column misses p95, or approximate per-LOD hit rate; its field/cache totals are whole-run totals, and its overlap capture measures cross-tile XY reuse instead. BuildHost `UWorld::Tick`, apply, and stationary-ring timings also have no headless equivalent.
+
+The W8 overlap capture completed for all tiles and all LODs. Each cell is median `[min–max]` across three captures.
+
+| LOD | Unique XY columns | Repeated tile evaluations | Neighbor repeats | Cross-worker neighbor repeats |
+|---:|---:|---:|---:|---:|
+| 0 | 128,240 [128,240–128,240] | 360,764 [359,953–364,225] | 301,491 [300,316–301,913] | 296,573 [294,996–297,862] |
+| 1 | 103,957 [103,464–104,384] | 300,707 [296,768–312,183] | 243,479 [236,767–246,556] | 238,030 [228,885–241,780] |
+| 2 | 32,267 [32,263–32,271] | 106,072 [104,091–106,939] | 90,338 [88,410–90,534] | 87,693 [84,976–87,921] |
+| 3 | 33,286 [33,286–33,286] | 87,531 [87,310–88,408] | 81,853 [79,915–83,171] | 78,814 [76,126–78,903] |
+| 4 | 91,325 [91,325–91,325] | 231,088 [230,967–231,122] | 228,336 [226,998–228,369] | 207,383 [191,310–207,789] |
+| 5 | 71,960 [71,960–71,960] | 118,805 [118,676–118,806] | 118,665 [117,782–118,797] | 111,453 [108,197–112,585] |
+| 6 | 280,336 [280,336–280,336] | 63,463 [63,148–63,624] | 63,463 [63,148–63,624] | 63,204 [62,944–63,579] |
+| 7 | 71,530 [71,530–71,530] | 7,762 [7,752–7,807] | 7,762 [7,752–7,807] | 7,155 [7,074–7,262] |
+| 8 | 106,219 [106,219–106,219] | 32,092 [32,013–32,155] | 32,092 [32,013–32,155] | 28,393 [27,959–28,598] |
+
+## Failed and retried attempts
+
+- `build-clang19.log` failed because `FLT_MAX` was undeclared; adding `<cfloat>` fixed it.
+- `build-clang19-retry1.log` failed on existing double-to-float list initializers in `VoxelStrateManager.cpp` and an incorrect dereference in the new runner. The Linux build suppresses that legacy Clang narrowing diagnostic and passes the snapshot value correctly.
+- `build-clang19-retry2.log` linked with unresolved `typeinfo for UVoxelSeasonAsset`; the compatibility glue now provides the missing `GetPrimaryAssetId`. `build-clang19-retry3.log` and `build-clang19-final.log` succeeded.
+- A temporary diagnostic relink in `rebuild-headless-crash-handler.log` omitted `main` and failed; `relink-headless-crash-handler.log` corrected it. This was only for diagnosis and is not part of the final source.
+- `smoke-clang19-w1.log` stopped before launching because `/usr/bin/time` was absent. No package was installed; `MeasureProcess.py` replaced it.
+- Seven default-stack W1 attempts (`smoke-clang19-w1-r1.log` through `r7.log`) and three instrumented diagnostic runs (`smoke-clang19-direct.log`, `smoke-clang19-entry.log`, `smoke-clang19-stack.log`) exited with SIGSEGV while entering `FStandaloneStreamingGenerator::Generate` under the default 8 MiB stack. Their peak RSS was 211,056–329,008 KiB. A 64 MiB stack completed the diagnostic run (`smoke-clang19-stack64m.log`, 330,288 KiB peak RSS); temporary tracing pointed to worker stack exhaustion. That diagnostic included an extra direct tile and was excluded from the baseline. All clean baseline runs used the 64 MiB stack.
+
+## Note for the owner
+
+For this owner seed and view, a Linux server and Windows client generate identical hashed density, mesh, payload, and topology, and the hashes stayed stable across Linux worker counts and compilers. This i9-12900H result is a local Linux speed baseline; the W8 time is close to the S13 Windows number, but the machines differ and it should not be read as a speedup.
+
+## Orchestrator review (Claude)
+
+- **The default-stack crash is thread-local storage, not deep recursion.** `-fstack-usage` shows no frame over
+  ~4 KB in Core or the headless tool (`Generate` is 8 KB). But the binary's TLS segment is
+  `0x115068d` = **17.3 MiB per thread** (6.1 MiB of it initialised data), and glibc carves static TLS out of
+  each thread's stack, so an 8 MiB default stack overflows before any work runs. Largest pieces:
+  `world_assembly_detail::HeightfieldColumnCache` 6.8 MB, `GFloorReliefCache` 1.3 MB (x2: Core and
+  legacy copies), `IslandColumnCache` 1.1 MB, `GRoomGraphCache` 0.97 MB (x2), `GSurfColCache` 0.83 MB (x2).
+  Windows allocates TLS separately from the 1 MB thread stack, which is why it never showed there.
+  It matters for a Linux dedicated server: every worker thread pays ~17 MB and copies 6 MB on start.
+  Open for a later round (after S14, which reworks the column cache).
+- **Untested:** the hash match is with `-ffp-contract=off`. Whether the hash would *detect* contraction
+  (`on`/`fast`) has not been shown, so it is not yet proven the flag is load-bearing.
+- Viewer move checked: of 738 removed viewer lines, all but 12 signature lines (now `inline`/namespaced)
+  reappear verbatim in the two shared headers; every remaining viewer use is qualified or `using`-imported.
+  MSVC compile still unverified.

Standalone/Research/WorldAssemblerM3/Linux10/REPORT.md

@@ -0,0 +1,115 @@
+# Linux10 — startup and region crossing
+
+**Result:** no world-generation optimization was shipped. The dominant spawn gate is full shape compilation; the current Core API does not let tiles consume a partially built shape safely. L10 adds opt-in phase and crossing telemetry to the headless research path.
+
+Runs used CPUs 0–11, normal priority, at most `-j12`, a 6 GiB address-space cap, and the unchanged `powersave` governor. Peak monitored RSS was 624,996 KiB (610.3 MiB). Final builds: Clang 19 with FP contraction off, SHA-256 `7d5360e2baa637f8b2b4679df9616580bffe689afd101470e311260f0ecd4975`; GCC 14 default, `5041cf15019766f453eb59fe8ff7fc4cd98ca6a904208b645e3d7ca4584e1195`. The L9 Clang timing/hash baseline is `Standalone/bin/linux/VoxelForgeCoreHeadless-linux9-clang`, SHA-256 `0cd3f0ef993ced2c615418c6e2b37b83f57eff6d024d7d1568c30ea51490384a`.
+
+## 1. Startup phases
+
+SurfaceWorld seed 0, W12, no hash; five runs on the optimized Clang build. Wall and process CPU are medians. Process CPU sums work across threads. First-tile time is from cold start; its CPU column is CPU since pool start.
+
+| Phase | Wall ms | Process CPU ms | Threads used |
+|---|---:|---:|---|
+| Owner data load and resolve | 5.05 | 5.05 | 1 |
+| Assembly plan build | 51.04 | 51.03 | 1 |
+| Core snapshot | 0.53 | 0.54 | 1 |
+| First desired-set build, 2,553 tiles | 0.74 | 0.74 | 1 |
+| Shape request setup | 0.03 | 0.03 | 1 |
+| Shape compile | 222.59 | 856.79 | caller + up to 8 scheduler workers |
+| Streamer setup | 0.01 | 0.01 | 1 |
+| Worker-pool start | 0.41 | 1.27 | 12 requested; 8–11 had entered at print |
+| First tile starts at 299.62 ms | — | 1.59 since pool start | 12/12 entered |
+
+Shape-compile wall ranged 215.89–324.88 ms; first tile started at 286.56–409.76 ms. Owner load, plan, local shape setup, and far-parent construction are serial. Before the pool starts, there are no sleeping stream workers, but most of the 12 allowed CPUs are unused. During the interval and detail-band phases the scheduler uses at most 8 workers, leaving up to 4 CPUs unused.
+
+The phase-trace mode’s whole-view median was 1.436 s, versus 1.372 s with tracing off. The phase runs are for decomposition only; the performance ranking and A/B below use the optimized build with tracing disabled and hashing off. In that flag-off path, shape wall time was 0.222 s median, consistent with the phase trace.
+
+## 2. Shape contents and first-tile dependencies
+
+| Shape phase | Wall ms | Process CPU ms | Work / concurrency |
+|---|---:|---:|---|
+| Local owner shapes and spatial bins | 40.46 | 40.44 | Extracts owner primitives; 1 thread |
+| Rock intervals, signs, candidate bands | 40.20 | 187.14 | Packed column signs and candidate masks; up to 8 workers |
+| Detail band and sign-edge distances | 81.00 | 568.78 | Applies coherent detail to candidate nodes and builds distance proxies; up to 8 workers |
+| Route validation and shared-field setup | 1.12 | 1.13 | 5,642 passage samples; then shared primitive form |
+| Far parents and bins | 55.56 | 55.57 | 6,050 far rooms / 18,348 links; 1 thread |
+
+The compile extracts 18,348 owner primitives (71 rooms, 74 tunnels, 2 passages), covers 138,188,413 sign nodes, allocates 36.71 MiB of packed words and 263.57 MiB of proxy address capacity, and visits 214,538 detail candidates (6,098 flips).
+
+For this SurfaceWorld fixture, the first LOD0 tile’s density queries take the native `Heightfield2D` path before packed-shape lookup. Far-parent shapes are not needed by that first tile. However, `World::generateTile` rejects requests until the full base shape is marked built, and `compileTileRegion` also requires that base shape. So the current API gates the near tile on the interval, detail, validation, and far-parent work even when that tile does not sample those arrays. Other recipes and fallback/query paths do use the analytic primitives and packed signs/proxies.
+
+There is no seed-independent owner shape payload to cache at build time. The assembly plan is built from owner data; region pages also re-run owner primitive extraction, spatial-bin construction, and shared-field packing. Those immutable owner-derived structures are a possible per-world reuse target, but the measured short crossings below built no pages, so this run does not price that work.
+
+## 3. Moving crossing
+
+Hashing off, W12, same camera and already-streamed initial view. Region compile was called, but all entering fine keys were covered by the initial shape bounds; it built zero regions.
+
+| Camera step | New tiles | LOD breakdown | Region compile | Tile work wall | Crossing total |
+|---|---:|---|---:|---:|---:|
+| 8 m | 144 | LOD2: 128, LOD3: 16 | 0.010 ms | 12.61 ms | 12.81 ms |
+| 16 m | 288 | LOD0: 128, LOD1: 16, LOD2: 128, LOD3: 16 | 0.010 ms | 60.49 ms | 60.68 ms |
+
+The 16 m crossing’s worker-time sum was 633 ms; its wall time was 60.5 ms. No plan or full shape compile repeated. A 24 m attempt terminated with `std::bad_alloc` after base shape compilation and before crossing metrics; the failing allocation site is unknown.
+
+## 4. Ranked levers
+
+| Rank | Lever | Upper bound from these measurements | Assessment |
+|---:|---|---|---|
+| 1 | Overlap near-tile work with shape compilation | 222.6 ms, 16.2% of 1.372 s whole-view-ready; first tile could start earlier by up to the compile time | Largest opportunity. Not built: tiles and region compilation currently require a fully built base shape. A safe version needs immutable partial-page publication and a wait before any tile reads an unfinished sign, proxy, primitive bin, or far field. |
+| 2 | Defer far-parent construction until far tiles need it | 55.6 ms, at most 4.1% of whole-view-ready and 18.6% of the first-tile delay | Could improve spawn, but far and near paths share mutable spatial-bin state today. Needs separate immutable bins and a synchronized readiness state; no crossing benefit was measured. |
+| 3 | Parallelize assembly-plan construction | 51.0 ms, at most 3.7% of whole-view-ready | Serial and seed/owner-specific. No safe deterministic parallel split was established. |
+| 4 | Raise shape scheduler cap from 8 to 12 | About 121 ms currently lies in the two worker phases; ideal linear scaling saves about 40 ms (2.9% of whole-view-ready) | Below the 3% bar before overhead, and no crossing benefit. Not built. |
+
+For any future partial or deferred build, hashes can fail if a tile observes a partially written sign/proxy array, if region publication races with tile lookup, or if shared bins change while a tile is sampling. The page must be immutable before publication; worker-count and timing tests must compare W1 with W12 and repeat W12. Any asynchronous result must also follow the Epoch/MPSC shutdown-drain rules.
+
+## 5. Final-build timing and hashes
+
+Five interleaved W12 runs, no hash. Pair values are `whole_view_ready / stream_wall` in seconds.
+
+| Pair | L9 `7650abb` Clang | L10 Clang | Delta, ms |
+|---:|---:|---:|---:|
+| 1 | 1.336 / 1.050 | 1.346 / 1.060 | +10 / +10 |
+| 2 | 1.351 / 1.062 | 1.365 / 1.073 | +14 / +11 |
+| 3 | 1.359 / 1.073 | 1.374 / 1.083 | +15 / +10 |
+| 4 | 1.363 / 1.077 | 1.375 / 1.081 | +12 / +4 |
+| 5 | 1.387 / 1.089 | 1.372 / 1.092 | −15 / +3 |
+| **Median** | **1.359 / 1.073** | **1.372 / 1.081** | **+13 / +8** |
+
+The measurement-only candidate is +1.0% whole-view-ready and +0.7% stream median; this is no demonstrated speedup. Hashing was off for these timings.
+
+Final rebuilt binaries passed SurfaceWorld and FloatingIslands seed-0 hash checks at W1, W8, and five W12 runs per compiler: Clang FP contraction off and GCC default. Every full-detail, whole-view, LOD0–8, and exact-query row matches the compiler-matched L9 baseline. Audit files: `Saved/Linux/l10_final_surface_hash_audit.txt` and `Saved/Linux/l10_islands_hash_audit.txt`.
+
+| Recipe / scope | Density | Mesh | Payload | Topology |
+|---|---|---|---|---|
+| SurfaceWorld full detail | `0x0ee0579bd15cbbe4` | `0x32e5d4964d610fee` | `0x1932b96ee4b1d910` | `0x69743c6bad3447dc` |
+| SurfaceWorld whole view | `0xc10697a8f48380c7` | `0xe75c9119a1498cd5` | `0x49a9a8d1835a6c8c` | `0xedcb23288b5e8724` |
+| FloatingIslands full detail | `0x6d842d2878b08ef6` | `0x4b868a3184f08035` | `0x2cedf2236788752d` | `0xeac17d5e0cb5044a` |
+| FloatingIslands whole view | `0x5be4d8cde79b2a76` | `0x96f75041f6861b3a` | `0x3700a516cc89d50c` | `0x6b99948d6eab4f21` |
+
+Exact-query hashes also match: SurfaceWorld density `0xe4d4a8eb95b35933`, detail `0xefcba20c0c70c415`, collision `0xe604823a249029bf`; FloatingIslands density `0x61daded9c303becb`, detail `0xefcba20c0c70c415`, collision `0x84d37463be9b0573`.
+
+## 6. Failed or retried runs
+
+- One phase smoke omitted the explicit owner-data path and resolved it under `Standalone/bin/data`; reran with `Standalone/data/owner_world.json`.
+- A no-camera phase smoke produced 2,370 tiles instead of the 2,553-tile fixture; discarded it and reran with the fixed camera.
+- A malformed `--workers=w8` command exited during argument parsing; reran with numeric `--workers=8`.
+- The first FloatingIslands matrix invocation omitted the three required streaming-mode switches. All 14 attempts exited before generation; corrected the command and all 14 final runs passed.
+- The 24 m crossing attempt failed with `std::bad_alloc` as described above.
+- The first hash-audit parser expected 13 rows; the actual audit contains 12 scopes. Corrected the parser and all final comparisons passed.
+
+At spawn, the first tile starts about 300 ms after cold start, with roughly 223 ms in full shape compilation and 51 ms in the single-threaded plan; this round did not make that wait shorter. While moving, the 16 m crossing completed 288 entering tiles in about 61 ms and repeated no shape compile, so the measured delay was tile work rather than region setup.
+
+## Orchestrator review (Claude)
+
+- **Not committed:** the L10 telemetry code. It is +1.0% whole-view median with tracing off (4 of 5
+  pairs slower), and the rule is zero cost when off. Saved as `Saved/Linux/claude/l10-telemetry.patch`
+  (gitignored) for reuse; the tree is reset to `7650abb`.
+- **Key finding, for L11:** the first SurfaceWorld tiles take the native `Heightfield2D` path and don't
+  read the cave shape, yet `World::generateTile` waits for the full base shape (~223 ms). A per-tile
+  readiness check (start tiles whose recipe path provably never touches shape arrays) is lever #1 in
+  safe form.
+- **Open bug, for L11:** the 24 m crossing died with `std::bad_alloc` under the 6 GiB **address-space**
+  cap (`RLIMIT_AS`). That cap counts reservations, not resident memory; L10 also reports 263.57 MiB
+  of proxy address *capacity*. It is not yet known whether this is a real memory blow-up on larger
+  crossings or the cap counting reserved address space. L7's 32 m step also hit the 160M-node
+  interval bound.

Standalone/Research/WorldAssemblerM3/Linux11/REPORT.md

@@ -0,0 +1,74 @@
+# VoxelForge L11 — Linux report
+
+## 24 m crossing crash
+
+The crash is real. The original binary threw `std::bad_alloc` after base shape compilation with both 6 GiB and 16 GiB `RLIMIT_AS`; the 16 GiB run peaked at 476,128 KiB RSS and 1,542,284 KiB virtual size. The allocation trace identifies a 432,345,551,342,665,824-byte resize in `BuildSpatialBins`, reached from `BuildAnalyticRegion` during `World::compileTileRegion`. The crossing code had coalesced disjoint entering tiles into a large LOD rectangle and tried to allocate dense per-axis bins that the analytic fallback never reads. L10's 263.57 MiB figure is the proxies' reserved virtual capacity; RSS samples record resident usage separately.
+
+Analytic regions now skip those dense bins and compile in world-aligned 128-voxel pages. Pages are built privately and published together; coordinate, `bad_alloc`, and size failures return errors before partial pages are published. On the final L11 binary, 24 m and 32 m both passed (16 pages each); 1,000 m passed with 2,260 entering keys, 72 pages, 63 ms region-build wall time, 700,232 KiB peak RSS, and 2,578,588 KiB peak virtual size. The fixed 24 m run peaked at 533,420 KiB RSS and 2,578,588 KiB virtual size. Crossing pages build no packed interval nodes (`lattice_nodes=0`) and do not expand the immutable base sign/proxy arrays; they add analytic primitive/bin data. `retainTileRegions` prunes pages outside the desired set. The largest empirically verified step is 1,000 m. Work follows the destination's entering tile set; once the old and new views are disjoint, its page count stays bounded by the active view as travel distance increases. Keys outside Core's signed 32-bit voxel range are rejected with `tile region coordinate is out of range` before page construction. The earlier L7 32 m / 160-million-node failure was the same unbounded region geometry.
+
+| Step | Entering keys | Pages | Added interval nodes | Base proxy nodes / virtual capacity |
+|---:|---:|---:|---:|---:|
+| 24 m | 432 | 16 | 0 | 185,024 / 263.57 MiB |
+| 1,000 m | 2,260 | 72 | 0 | 185,024 / 263.57 MiB |
+
+## Shape readiness
+
+`isTileShapeFree` accepts only LOD0 tiles whose padded mesh box maps to one valid SurfaceWorld plan, excludes FloatingIslands, plan features, routes, passages, edits, and overlaps with owner shape primitives or detail bounds. This covers the MC skirt and sample margin. Higher LODs are conservatively shape-dependent; the accepted path cannot use far parents. The native-only context is initialized without building sign arrays, proxies, owner primitive vectors, or spatial bins. Native sampling and classification paths check the padded bounds, reject unsupported fallbacks, and count any attempted shape-dependent read; tile generation then fails instead of returning a partial mesh.
+
+The SurfaceWorld spawn view proved 27/27 near-ring tiles shape-free. A deliberately mis-marked distant tile `(0,0,100000,lod0)` reached the sampler and was rejected by the guard. After shape publication, native-only and full-shape generation matched all four hashes for all 27 tiles. Shape-dependent tiles waited for the release-published shape; tile jobs continue through the existing Epoch and MPSC result path, and published shape/page data is immutable. The FloatingIslands spawn proof accepted 0/27 tiles, so all waited for its shape. Slow-shape delay defaults to zero; audit and negative-control work is opt-in.
+
+## No-hash timing pairs
+
+Five interleaved W12 pairs, camera `0,-35,-487.94`, seed 0, Clang `-ffp-contract=off`, hashing off. Times are from process start. The L9 executable does not emit a first-tile completion event and starts tile workers only after shape compilation; its first-tile cell is therefore unavailable.
+
+| Pair | First tile L9 / L11 | Near ring L9 / L11 | Whole view L9 / L11 |
+|---:|---:|---:|---:|
+| 1 | — / 153 ms | 343 / 166 ms | 1,439 / 1,429 ms |
+| 2 | — / 160 ms | 424 / 173 ms | 1,526 / 1,447 ms |
+| 3 | — / 145 ms | 347 / 163 ms | 1,447 / 1,443 ms |
+| 4 | — / 146 ms | 353 / 170 ms | 1,457 / 1,449 ms |
+| 5 | — / 153 ms | 376 / 173 ms | 1,478 / 1,464 ms |
+| Median | — / 153 ms | 353 / 170 ms | 1,457 / 1,447 ms |
+
+The delayed maximum-overlap W12 run held shape compilation for 1.5 s: first tile 133 ms, near ring 166 ms, shape ready 1.696 s. Shape-free and full-shape near-ring hashes matched, and whole-view, full-detail, per-LOD, and exact-query hashes matched the baseline.
+
+## Hashes
+
+All 28 configurations passed against L10's committed `b370908` baseline: SurfaceWorld and FloatingIslands, seed 0, W1/W8/W12, Clang `-ffp-contract=off` and GCC default, with five W12 repeats per compiler and recipe. Each run matched all 12 rows: full-detail, whole-view, nine LODs, and exact queries. The delayed-overlap run also matched.
+
+| Recipe | Full-detail density / mesh / payload / topology | Whole-view density / mesh / payload / topology | Exact-query density & unclamped / detail / collision |
+|---|---|---|---|
+| SurfaceWorld | `0x0ee0579bd15cbbe4` / `0x32e5d4964d610fee` / `0x1932b96ee4b1d910` / `0x69743c6bad3447dc` | `0xc10697a8f48380c7` / `0xe75c9119a1498cd5` / `0x49a9a8d1835a6c8c` / `0xedcb23288b5e8724` | `0xe4d4a8eb95b35933` / `0xefcba20c0c70c415` / `0xe604823a249029bf` |
+| FloatingIslands | `0x6d842d2878b08ef6` / `0x4b868a3184f08035` / `0x2cedf2236788752d` / `0xeac17d5e0cb5044a` | `0x5be4d8cde79b2a76` / `0x96f75041f6861b3a` / `0x3700a516cc89d50c` / `0x6b99948d6eab4f21` | `0x61daded9c303becb` / `0xefcba20c0c70c415` / `0x84d37463be9b0573` |
+
+The per-LOD D/M/P/T rows match exactly in every configuration; the complete comparison is recorded in `Saved/Linux/l11_hash_audit.txt`.
+
+## Failed and retried runs
+
+- The 24 m reproduction failed with `std::bad_alloc` under both address-space caps (`l11-cross24-as6g.log`, `l11-cross24-as16g.log`); the allocation trace above isolated the oversized bin resize. Final-binary 24 m, 32 m, and 1,000 m reruns passed (`l11-final-cross-24m.log`, `l11-final-cross-32m.log`, `l11-final-cross-1000m.log`).
+- The first readiness proof admitted 512 LOD0 keys (`l11-readiness-audit.log`, `l11-readiness-audit2.log`). Although the 27 near-ring equivalence check passed, distant owner-shape tiles changed the whole-view density hash. Tightening the proof to test owner primitive bounds reduced early admission to the 27 safe near-ring tiles and restored every hash (`l11-readiness-audit-final.log`).
+- One rebuilt audit invocation omitted the owner JSON path and exited 2 before generation (`l11-readiness-audit-path-error.log`; `Standalone/bin/data/owner_world.json` was missing). It was rerun with `Standalone/data/owner_world.json` and passed.
+- The required hash matrix and five timing pairs had no failed runs. All monitored run processes stayed below the 6,000,000,000-byte RSS ceiling; governor remained `powersave`.
+
+The standalone Core/headless builds passed with Clang and GCC. The Unreal adapter change was source-reviewed but could not be built here because UnrealBuildTool/UnrealEditor are not installed on this Linux machine.
+
+At spawn on SurfaceWorld, the near ring is ready at a 170 ms median versus 353 ms on L9, and the first L11 tile is ready at 153 ms median before shape publication; L9 gates tile work on shape compilation and does not report that milestone. For fast movement, destination-page work stays bounded through the tested 1 km crossing, while invalid Core coordinates return an error before allocation.
+
+## Orchestrator review (Claude)
+
+- **Re-run by me, 5 interleaved W12 pairs, no hashing.** Near ring (`neighborhood_ready`) L9
+  0.338/0.338/0.337/0.326/0.334 s vs L11 0.159/0.159/0.167/0.169/0.159 s (median 0.337 → 0.159 s,
+  −53%). Whole view 1.337 → 1.365 s median (+2.1%, 4 of 5 pairs slower): a small cost, accepted for a
+  2× faster spawn ring. W12 hash runs give density `c10697a8f48380c7`.
+- **Crossings re-run by me on L11** (`--region-crossing --camera-step=S,0,0`): 24 m gives 432 tiles,
+  0.867 s wall, 10.05 worker-s, rc 0; 1,000 m gives 2,260 tiles, 5.90 s wall, 70.4 worker-s, rc 0. The L9
+  binary lacks the option, so the original crash rests on Luna's reproduction and allocation trace.
+- **New finding, for L12:** the 24 m crossing costs ~23 ms of work per tile, against ~2 ms for L10's 16 m
+  crossing (288 tiles, 0.633 worker-s). Tiles outside the base shape bounds, served from analytic
+  region pages, look about 10× more expensive. That is a moving-player cost.
+- **Concurrency read:** `World::compile` builds the shape privately, then sets `impl_->shape` and
+  `buildRequest` before a release store of `shapeReady`. Every shape reader acquire-checks
+  `shapeReady` first (short-circuit), and shape-free tiles use a private native-only context. Sound.
+- **Unreal:** `Source/VoxelForge/Private/VoxelWorld.cpp` changed (compile outside the writer lock;
+  proven shape-free tiles start before `bReady`). It is NOT compiled here, so it must be built on the
+  owner's PC before it is trusted in game.

Standalone/Research/WorldAssemblerM3/Linux12/REPORT.md

@@ -0,0 +1,62 @@
+# VoxelForge L12 — Linux report
+
+Governor stayed `powersave`. Builds and runs used CPUs 0–11, at most 12 jobs, a 6 GiB address-space cap, and RSS monitors. Clang and GCC builds passed; peak sampled RSS was 881 MiB for one GCC compiler process and 679 MiB for the 1 km crossing. The GCC build process group peaked at 4.35 GiB. No Unreal adapter files changed.
+
+## LOD cost and change
+
+The 24 m profile is like-for-like at LOD1 in the same SurfaceWorld crossing. L11 generated 160 LOD1 tiles: 32 base-shape tiles averaged 2.73 ms each, while 128 analytic-page tiles averaged 71.72 ms. Of the LOD1 worker time, 9.06 of 9.27 seconds went to the marching-cubes density grid; the page compiler added 15 ms and built no packed lattice nodes. The page route lacked the manifest input needed for the exact LOD1 block proofs. Across all 160 LOD1 tiles, the sample counter reported 5.64 million density samples, or 35,271 per tile.
+
+Analytic pages now retain the immutable shared manifest for block classification while continuing to sample the legacy density field. The proof audit checked 27,479 blocks and 36,574,549 samples, with zero violations. On the plain 24 m profile, page-backed LOD1 fell to 5.60 ms per tile; all 160 LOD1 tiles reported 432,000 samples (2,700 per tile) and 435 ms in density-grid work. Base LOD1 tiles averaged 2.51 ms, so page tiles are now about 2.2× their base cost. No base-shape bounds changed; pages remain privately built, immutably published, and bounded, with 16 pages at 24/32 m and 72 at 1 km.
+
+## Plain W12 crossings
+
+Worker time is the sum across tile workers; per-tile values use that sum. L11 values are from the L11 executable and logs. L12 values include region compilation in wall time.
+
+| Step | Tiles | L11 wall / worker-s / ms per tile | L12 wall / worker-s / ms per tile |
+|---:|---:|---:|---:|
+| 8 m | 144 | 0.038 s / 0.381 / 2.65 | 0.035 s / 0.360 / 2.50 |
+| 16 m | 288 | 0.831 s / 9.476 / 32.90 | 0.125 s / 1.096 / 3.80 |
+| 24 m | 432 | 0.869 s / 9.912 / 22.95 | 0.164 s / 1.596 / 3.69 |
+| 32 m | 576 | 0.898 s / 10.261 / 17.81 | 0.172 s / 1.691 / 2.94 |
+| 1 km | 2,260 | 5.892 s / 69.534 / 30.77 | 1.247 s / 14.003 / 6.20 |
+
+All five L12 steps passed; peak crossing RSS was 679 MiB. The 8 m L11 comparison is `l12-baseline-8m-page.log`; 16 m is `l12-baseline-16m-page.log`; 24 m, 32 m, and 1 km are the L11 final crossing logs.
+
+## Spawn and hashes
+
+Three plain W12 spawn runs had medians of 146 ms first tile, 161 ms near ring, and 1.361 s whole view. L11 medians were 153 ms, 170 ms, and 1.447 s.
+
+All 28 requested L1 hash configurations matched L11: SurfaceWorld and FloatingIslands seed 0, Clang `-ffp-contract=off` and GCC default, W1/W8/W12, with five W12 repeats. Every run matched all 12 rows: full detail, whole view, nine LODs, and exact queries. Clang/GCC full-detail and whole-view D/M/P/T plus exact-query values are unchanged from the L11 report. The L3 FP-contract preamble/self-test remains in place.
+
+| Recipe | Full-detail density / mesh / payload / topology | Whole-view density / mesh / payload / topology | Exact density+unclamped / detail / collision |
+|---|---|---|---|
+| SurfaceWorld | `0x0ee0579bd15cbbe4` / `0x32e5d4964d610fee` / `0x1932b96ee4b1d910` / `0x69743c6bad3447dc` | `0xc10697a8f48380c7` / `0xe75c9119a1498cd5` / `0x49a9a8d1835a6c8c` / `0xedcb23288b5e8724` | `0xe4d4a8eb95b35933` / `0xefcba20c0c70c415` / `0xe604823a249029bf` |
+| FloatingIslands | `0x6d842d2878b08ef6` / `0x4b868a3184f08035` / `0x2cedf2236788752d` / `0xeac17d5e0cb5044a` | `0x5be4d8cde79b2a76` / `0x96f75041f6861b3a` / `0x3700a516cc89d50c` / `0x6b99948d6eab4f21` | `0x61daded9c303becb` / `0xefcba20c0c70c415` / `0x84d37463be9b0573` |
+
+The 24 m crossing hash also matches L11 at W1 and W12 (432 rows each): density `0x174588abdc8c0d2c`, mesh `0x4c401e27d9d05dea`, payload `0xeb10d9801c5ef125`, topology `0xf59d12304d0dcb4a`.
+
+The route-verified base/page audit does **not** pass the requested exact-tile invariant. For `(0,-5,-31,lod1)`, the base density hash is `0xe0672dae7528f8d7` and page density hash is `0x882280f67bfddd77`; mesh, payload, and topology match. All 48 base-covered LOD1 candidates had density mismatches; 10 also differed in mesh/payload/topology. Across eight route-verified LOD0/LOD1 pairs, all eight density hashes differed. The base SurfaceWorld route uses manifest density while L11 pages use the legacy density evaluator; switching page samples to the base field would change the L11 crossing hashes. I kept the legacy page field to preserve the required crossing output, so this pre-existing parity conflict remains unresolved.
+
+## Failed and retried runs
+
+- An attempted 24 m base-shape expansion exited 2 at the 160-million-node bound (`l12-baseline-24m-base.log`). A separate per-tile native-only proof promotion failed with `region OOM` and was reverted (`l12-probe-cross24-profile-w12.log`).
+- The first plain step command passed `32` as the camera distance while labeling it 8 m; output identified it as 32 m. It was retained as the 32 m result, and 8 m was rerun with the correct distance.
+- The first FloatingIslands matrix omitted `--auto-surface-camera`, so it hashed the wrong 2,553-tile view. It was rerun with the L11 seed-0 island placement; all 28 corrected matrix configurations passed. The comparison helper also needed two small script fixes before it reported the final 28/28 result.
+- One base/page audit initially treated a LOD2 base-route fallback (`page_keys=0`) as a match. The audit now verifies the generated route; that apparent pass was rejected and the route-verified parity failure above is the final result.
+
+Walking into new ground should feel much better: the plain 24 m crossing fell from 0.869 s to 0.164 s, and the 1 km crossing from 5.892 s to 1.247 s. Page-backed LOD1 tiles are down from 71.7 to 5.6 ms each while the L11 crossing hashes stay exact; base/page density-hash parity remains a separate unresolved constraint.
+
+## Orchestrator review (Claude)
+
+- Re-run by me (W12, no hashing, 3 interleaved pairs): 24 m crossing L11 0.874/0.914/0.898 s vs L12
+  0.154/0.166/0.166 s (median 0.898 → 0.166 s, 5.4×). Spawn is unchanged (near ring 0.160–0.184 s).
+  The 24 m crossing hash (density `0x174588abdc8c0d2c`, mesh `0x4c401e27d9d05dea`) matches L11 at W1
+  and W12. Hash runs refill skipped samples, so time crossings with hashing off.
+- **Soundness of page-tile skipping:** the proof audit figures (27,479 blocks / 36,574,549 samples)
+  are the base-shape audit from L9, not page tiles. The evidence for pages is the crossing hash
+  equalling L11 (which filled every sample). That is necessary but narrow: one crossing, one seed.
+- ⚠️ **Route-dependent output (a pre-existing multiplayer bug, now measured):** the same tile key
+  gives different density from the base shape (manifest field) than from an analytic page (legacy
+  field). All 48 base-covered LOD1 candidates differed in density, 10 also in mesh/payload/topology.
+  A tile's geometry then depends on streaming history (spawned near it vs walked to it), which
+  breaks peer determinism. Top priority for L13.

Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md

@@ -0,0 +1,140 @@
+# VoxelForge M3 Linux13 — route-invariant density
+
+## Field decision and fix
+
+The approved reference is the Core base shape built from the reviewed owner manifest: `Heightfield2D`
+for SurfaceWorld and `FloatingIslandFieldV1` for FloatingIslands. L12's base route sampled that
+field. Its analytic pages instead fell through to the copied legacy owner `GetDensityAt` evaluator,
+so the same key could sample different values after the player crossed into a page. In the L12
+SurfaceWorld audit, all 48 base-covered LOD1 candidates had different density; 10 also differed in
+mesh, payload, and topology. A 214,375-sample L12 negative-control run measured max/mean density
+delta `0.076171875 / 0.0133467594`, 29 sign changes, 170 edge-crossing changes, and up to 1.7778
+voxels of surface displacement. The manifest field is the approved Core world and is the reference
+kept here.
+
+Changing the page manifest flag alone did not fix FloatingIslands: 8/8 page pairs still failed,
+with max density delta `433.925781`, 262,676 sign changes, and 17,188 edge-crossing changes across
+343,000 samples. The source fix binds each compiled page to its world's base `FStandaloneShapeWorld`
+before publication. Page density, lattice, detail, classification, and solid queries now delegate
+to that one evaluator; the legacy page-local evaluator is no longer an independent output route.
+`WorldAssemblyEvaluatorVersion` is bumped from 5 to 6.
+
+## Route parity
+
+The L12 evaluator-v5 negative control fails as required: 5/5 selected base/page pairs mismatch. After the fix,
+four audits passed: SurfaceWorld seeds 0, 1, and 17, plus FloatingIslands seed 0.
+
+| Compared routes | Pairs | Mismatches |
+|---|---:|---:|
+| Base vs page (28 clipmap-requested pages; 26 base-covered page controls) | 54 | 0 |
+| Base vs native-only shape-free route (SurfaceWorld LOD0) | 27 | 0 |
+| Edited base vs edited page | 4 | 0 |
+| Same key built in initial and moved-world history | 2 | 0 |
+| Tile samples vs exact Core queries at LOD2–8 | 56 | 0 |
+
+All 87 tile-generation pairs match density, mesh, payload, and topology hashes. The 56 higher-LOD
+pairs compare the sampled tile lattice to direct `densityAt` / `densityAtLattice` queries; these
+also match all sampled densities and solid/air signs. The owner fixture has
+`full_res_clip_levels=2`, so analytic page routes exist only at LOD0–1. In total, page comparisons
+covered 2,315,250 density samples with zero delta, sign, edge-crossing, or surface-root differences;
+6,172,229 exact-query samples had zero mismatches. The audit exits nonzero on any output-hash,
+sample, route-verification, exact-query, or proof-violation mismatch.
+
+The history probe builds the same LOD0 key in a second Core world after a 96 m camera move. Both
+SurfaceWorld and FloatingIslands match all four hashes across those two build histories. The edit
+probe applies a sequence-1 density offset centered on a sampled sign crossing; it changes the field,
+and edited base/page results still match.
+
+### Page proof audit
+
+The fill-and-check audit generated page tiles with full density capture and uniform-block proof
+verification, so it checked the field those pages actually sample. Across the four audits it checked
+1,274 blocks / 1,695,694 samples: 518 blocks used the exact fallback, 6 were unknown, and there were
+zero false proofs or violations. SurfaceWorld walkability passed 5,642/5,642, 6,080/6,080, and
+4,785/4,785 samples for seeds 0, 1, and 17; FloatingIslands passed 4,000/4,000. Shape readiness
+passed 27/27 near-ring tiles where eligible. FloatingIslands has no eligible native-only tiles.
+
+## Cost, hashing off
+
+W12, seed 0, `--force-generate`, camera `0,-35,-487.94`, with the same crossing setup as L12:
+
+| Move | Entering tiles | L12 crossing | L13 crossing | L13 peak RSS |
+|---|---:|---:|---:|---:|
+| 8 m | 144 | 0.0347 s | 0.0399 s | 468 MiB |
+| 16 m | 288 | 0.1249 s | 0.0856 s | 513 MiB |
+| 24 m | 432 | 0.1635 s | 0.1242 s | 512 MiB |
+| 32 m | 576 | 0.1717 s | 0.1692 s | 511 MiB |
+| 1 km | 2,260 | 1.2474 s | 0.7696 s | 673 MiB |
+
+Three W12 spawn runs had medians of 157 ms first tile, 180 ms near ring, and 1.499 s whole view;
+L12 medians were 146 ms, 161 ms, and 1.361 s. Each spawn run generated the same 2,553-tile
+benchmark view. The final timings are in `Saved/Linux/l13-crossing-final-*.log` and
+`Saved/Linux/l13-spawn-final-*.log`.
+
+## Determinism and invariants
+
+All 28 required configurations passed: SurfaceWorld and FloatingIslands seed 0; Clang
+`-ffp-contract=off` and GCC default; W1/W8/W12, with five W12 repeats per compiler and recipe. Each
+run matched all 12 rows (full detail, whole view, LOD0–8, exact queries) against L12/L11.
+
+| Recipe | Full detail D/M/P/T | Whole view D/M/P/T | Exact density / unclamped / detail / collision |
+|---|---|---|---|
+| SurfaceWorld | `0x0ee0579bd15cbbe4 / 0x32e5d4964d610fee / 0x1932b96ee4b1d910 / 0x69743c6bad3447dc` | `0xc10697a8f48380c7 / 0xe75c9119a1498cd5 / 0x49a9a8d1835a6c8c / 0xedcb23288b5e8724` | `0xe4d4a8eb95b35933 / 0xe4d4a8eb95b35933 / 0xefcba20c0c70c415 / 0xe604823a249029bf` |
+| FloatingIslands | `0x6d842d2878b08ef6 / 0x4b868a3184f08035 / 0x2cedf2236788752d / 0xeac17d5e0cb5044a` | `0x5be4d8cde79b2a76 / 0x96f75041f6861b3a / 0x3700a516cc89d50c / 0x6b99948d6eab4f21` | `0x61daded9c303becb / 0x61daded9c303becb / 0xefcba20c0c70c415 / 0x84d37463be9b0573` |
+
+The crossing output changes as intended. The 24 m W1 and W12 moved-tile hashes match each other:
+`0x337ca62131576728 / 0x7612f48e2ddbbaab / 0x69a67ed4add83b87 / 0xf11ac1ebd0f7ddb8` (D/M/P/T),
+replacing L12's `0x174588abdc8c0d2c / 0x4c401e27d9d05dea / 0xeb10d9801c5ef125 / 0xf59d12304d0dcb4a`.
+
+The L3 FP-contract preamble and runtime self-test, L4 `FLazy`, L7 shared column cache, L9/L12
+proofs, and L11 native-only readiness/crash fixes were preserved. The L6 screen-space controls
+still pass their six same-LOD checks and reject the missing/floating-surface, global-octave, and
+stride-2 negative controls as required. Its whole gate still rejects the known far-field error over
+the 1 px bound (exit 6); the route binding does not affect those LOD3–8 base-field comparisons.
+The asynchronous MPSC/Epoch path and `ARCHITECTURE.md` §8.10 invariants are unchanged. No Unreal
+adapter files were touched; the Core exact-query and collision-sign routes were checked, but Unreal
+collision cooking was not built here. `ARCHITECTURE.md` §8.36 and `CODEMAP.md` §3.22 document the new
+route law.
+
+Builds and runs used CPUs 0–11, at most 12 workers, a 6 GiB address-space cap, and a 6,000,000,000
+byte RSS monitor. The governor remained `powersave`. Peak sampled RSS was 904 MiB across runs
+(673 MiB in the no-hash cost table); the GCC build process group peaked at 4.27 GiB. Clang and GCC
+builds passed. No system changes or Unreal builds were made.
+
+## Failed and retried runs
+
+- `l13-route-baseline-s0-w12.log` exited 2 because the inferred binary-relative owner JSON path did
+  not exist; reruns used the explicit repository JSON. The first baseline capture used the wrong
+  camera, then an audit pass had empty proof-skipped density captures; the final L12 negative
+  control is `l13-route-baseline-s0-w12-r4.log`.
+- `l13-route-fi-diagnostic.log` and `l13-route-fi-diagnostic-r2.log` intentionally exposed the
+  remaining FloatingIslands split before the shared-source binding; both exit 9 on 8/8 mismatches.
+- `l13-route-edit-s0.log` exited 9 because its brush did not change the selected tile. Centering the
+  brush on a sampled sign crossing fixed the audit in `l13-route-edit-s0-r2.log`.
+- `l13-route-history-sw-s0.log` exited 9 because the second-world probe exceeded the 4,096-node
+  region compiler envelope. The retry compiles one matching LOD0 anchor tile and passes.
+- The first `l13-cost-*` measurements omitted `--force-generate` and used the owner JSON start;
+  those are not used above. The final crossing and spawn runs use L12's camera and force-generation
+  setting. The screen-space run's exit 6 is its expected far-field rejection, not a retried run.
+- All final builds, the 28 hash runs, eight no-hash cost runs, and two crossing-hash runs completed
+  within their limits. No commit, push, or stash was made.
+
+## Multiplayer note for the owner
+
+Peers with the same manifest, seed, evaluator version 6, and tile key now reconstruct the same Core
+density and tile output through each available base, page, or native-only route, regardless of
+arrival history; terrain geometry still does not need to cross the network. Player edits remain an
+explicit versioned diff that must be ordered and synchronized between peers.
+
+## Orchestrator review (Claude)
+
+- **Spawn cost re-run by me, 5 interleaved W12 pairs, no hashing:** whole view L12
+  1.385/1.405/1.419/1.443/1.460 s vs L13 1.401/1.448/1.430/1.435/1.451 s (median 1.419 → 1.435 s,
+  +1.1%, within noise); near ring 0.168 → 0.171 s. The +10% in the cost table above compares L13 runs
+  with L12 numbers from another session; interleaved, there is no measurable spawn regression.
+- The fix is structural: pages are bound to their world's single base `FStandaloneShapeWorld`
+  evaluator before publication, so routes can't diverge by construction. The negative control fails
+  on L12 (5/5), and the 87 tile pairs, 56 exact-query pairs and 2.3M page samples show 0 mismatches
+  after. The page lifetime is safe because the base shape is owned by the `World` and outlives its pages.
+- Crossing output changed, as intended (evaluator version 5 → 6); the spawn and island worlds are
+  unchanged.

Standalone/Research/WorldAssemblerM3/Linux14/REPORT.md

@@ -0,0 +1,157 @@
+# Linux14 — far spawn work
+
+No mesh or density code changed. The source changes add opt-in profiling for far-shell column
+lookups; counter snapshots are behind the existing profile guard, with no added timing or counter
+increments when profiling is off. The final plain build has the same output as L13.
+
+## Far LOD cost and ranking
+
+The first table is from five interleaved, W12, hashing-off pairs: L13 binary before and L14 binary
+after. Values are median worker-sums across that LOD; per-tile time is the L14 median divided by
+tile count. The ranking is L6, L8, L4, L5, L7 on both binaries.
+
+| LOD | Tiles | L13 → L14 median worker-s (s) | L14 worker-ms/tile |
+|---:|---:|---:|---:|
+| 4 | 320 | 1.600 → 1.572 | 4.91 |
+| 5 | 144 | 1.421 → 1.411 | 9.80 |
+| 6 | 96 | 2.624 → 2.585 | 26.93 |
+| 7 | 48 | 1.152 → 1.158 | 24.13 |
+| 8 | 153 | 2.044 → 2.046 | 13.37 |
+
+Phase detail below is one W12 `--profile-lod-work` run on the final Clang binary. Cache counters
+include all column work for that LOD, not just refinement. A “shared hit” is a hit from the
+world-shared cache; formula evaluations equal local misses minus shared hits.
+
+| LOD | Calls | Local hits / misses | Shared hits | Formula evaluations (per tile) | Column compute (ms) | MC non-column (ms) | Ground/cap non-column (ms) | Connector shell non-column (ms) | Skirt (ms) | Assembly (ms) |
+|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 4 | 1,845,787 | 1,579,868 / 265,919 | 175,805 | 90,114 (282) | 521 | 472 | 385 | 0 | 186 | 3 |
+| 5 | 877,542 | 701,124 / 176,418 | 105,477 | 70,941 (493) | 408 | 135 | 705 | 0 | 159 | 2 |
+| 6 | 760,952 | 418,443 / 342,509 | 63,209 | 279,300 (2,909) | 1,594 | 90 | 474 | 210 | 158 | 2 |
+| 7 | 337,328 | 257,969 / 79,359 | 8,878 | 70,481 (1,468) | 395 | 59 | 514 | 0 | 145 | 4 |
+| 8 | 644,565 | 508,799 / 135,766 | 29,545 | 106,221 (694) | 608 | 374 | 783 | 0 | 278 | 6 |
+
+MC and refinement column-compute / non-column times (ms) were L4 `221/472` MC and `281/385`
+ground/cap; L5 `199/135` MC and `209/705` ground/cap; L6 `196/90` MC and `205/474` ground/cap;
+L7 `184/59` MC and `211/514` ground/cap; L8 `413/374` MC and `195/783` ground/cap. The column
+compute column overlaps those column portions. Timers are worker sums and may differ by a few ms
+from their subphase sums.
+
+Stratum shells made zero field calls at LOD4–8 and took under 0.03 ms total. The profiler run
+measured about 1.408 s whole-view-ready; the unprofiled interleaved runs below are the timing result.
+
+## Connector-shell repair
+
+`AppendFarConnectorShells` is guarded to LOD6 and above. Coarse marching cubes can leave gaps in a
+route connector wall, so the repair checks four axial rays at connector stations and adds only the
+panels where the nearest coarse-mesh hit misses the source-field radius tolerance. LOD6 checks at
+128-voxel stations; LOD7–8 use 256-voxel stations. Only LOD6 had repair candidates in this spawn
+view: 5,066 triangles were added. The shell took 1.403 worker-s, including 1.193 s of column
+evaluation (about 0.210 s shell work outside those evaluations).
+
+The LOD6 repair made 251,475 source/column calls: 44,596 worker-local hits, 206,879 local misses,
+30 shared-cache hits, and 206,849 formula evaluations. Thus 82.3% of calls evaluated a formula;
+the work is mostly uncached. A cache miss can include a point evicted by the four-way worker cache,
+so these counters do not prove every evaluated XY is unique. The L13-bound base evaluator already
+feeds the shared exact-XY cache; neighboring LOD samples mostly use different XY coordinates, and
+only 30 repair samples hit the shared cache. Reducing stations or rays would change the repair
+geometry, and no bit-identical reduction was proved.
+
+## Ground and cap refinement
+
+Ground refinement starts at LOD5 (32-voxel grid there, 64 at LOD6, then 128 at LOD7–8). Cap
+refinement starts at LOD4 (16-voxel grid there, then 128 at LOD5–7; LOD8 may use its configured
+interior override). Both query exact `Heightfield2D` columns and use those values for heights,
+normals, materials, clipping, and replacing nearby coarse faces. The existing shared cache is keyed
+by recipe/plan and exact XY, so aligned samples can already be reused across tiles and levels. The
+LOD-wide shared-hit counts are in the table above; they are not refinement-only counts.
+
+Current safe skips are the plan Z-range check for ground and the cap-height-bound check for caps.
+No additional tile/cell skip was shown to preserve every sample that affects output; a grid point
+can also supply a neighboring normal or clipped cell. No new refinement sharing or skip was built.
+
+## Ranked exact-output work
+
+No exact-output change with a measured saving above 3% was proved, so no geometry optimization was
+built. The ranked work buckets are:
+
+1. Ground/cap refinement across LOD4–8: about 3.95 worker-s including its column work. Removing all
+   of it would be an unrealistic idealized 23% of 1.419 s at 12-way division; the sampled values
+   currently affect geometry/materials/normals.
+2. LOD6 connector repair: 1.403 worker-s inclusive, an idealized upper bound near 8.2% at 12-way
+   division. Most calls are uncached, and the missing panels are required for the current mesh.
+3. Far-LOD column formula work: 3.53 worker-s across LOD4–8, overlapping the two buckets above.
+   Exact-XY sharing is already active; no redundant set large enough to remove was demonstrated.
+4. Marching-cubes non-column work is 1.13 worker-s and skirts 0.93 worker-s. Assembly is only
+   0.017 worker-s; stratum shells are negligible. No exact reduction was established.
+
+These idealized conversions divide worker-s by 12 and are not predicted wall-time gains. The L6
+screen-space gate was not used because this round made no geometry change.
+
+## Interleaved cost, builds, and hashes
+
+Five hashing-off W12 pairs ran in one session, alternating
+`Standalone/bin/linux/VoxelForgeCoreHeadless-linux13-clang` and
+`Standalone/bin/linux/VoxelForgeCoreHeadless-linux14-clang`. Every run generated 2,553 tiles at
+seed 0 and camera `0,-35,-487.94,0,-22`.
+
+| Pair | L13 whole-view-ready (s) | L14 whole-view-ready (s) |
+|---:|---:|---:|
+| 1 | 1.416 | 1.410 |
+| 2 | 1.436 | 1.388 |
+| 3 | 1.416 | 1.424 |
+| 4 | 1.429 | 1.419 |
+| 5 | 1.430 | 1.426 |
+
+Median was 1.429 s before and 1.419 s after (−0.7%, within this run spread). The telemetry is
+opt-in; the plain run shows no measurable cost when off.
+
+Final binaries `Standalone/bin/linux/VoxelForgeCoreHeadless-linux14-clang` and
+`Standalone/bin/linux/VoxelForgeCoreHeadless-linux14-gcc` were rebuilt with `Standalone/BuildLinux.sh`,
+`-j12`, CPUs 0–11, and a 6 GiB address-space cap: Clang 19 with FP contraction off and GCC 14 with
+default contraction. Builds passed. Runtime peak RSS was 926,520 KiB; largest individual
+build-process RSS was 901,968 KiB (GCC), with a 4,557,196 KiB process-group peak. Governor remained
+`powersave`.
+
+The final hash matrix passed 28/28: SurfaceWorld seed 0 and FloatingIslands seed 0, Clang/GCC,
+W1/W8/W12, with five W12 repeats per recipe/compiler. Full-detail, whole-view, all nine per-LOD,
+and exact-query rows match L13 exactly. Route parity also passed for SurfaceWorld seeds 0,
+1, and 17 and FloatingIslands seed 0: page/native-only routes, edits, history, higher-LOD exact
+queries, and proof checks had zero mismatches. The final 24 m crossing hash matched at W1/W12 on
+both compilers: `0x337ca62131576728 / 0x7612f48e2ddbbaab / 0x69a67ed4add83b87 / 0xf11ac1ebd0f7ddb8`
+(density/mesh/payload/topology).
+
+| Recipe | Full-detail D/M/P/T | Whole-view D/M/P/T | Exact density / unclamped / detail / collision |
+|---|---|---|---|
+| SurfaceWorld | `0x0ee0579bd15cbbe4 / 0x32e5d4964d610fee / 0x1932b96ee4b1d910 / 0x69743c6bad3447dc` | `0xc10697a8f48380c7 / 0xe75c9119a1498cd5 / 0x49a9a8d1835a6c8c / 0xedcb23288b5e8724` | `0xe4d4a8eb95b35933 / 0xe4d4a8eb95b35933 / 0xefcba20c0c70c415 / 0xe604823a249029bf` |
+| FloatingIslands | `0x6d842d2878b08ef6 / 0x4b868a3184f08035 / 0x2cedf2236788752d / 0xeac17d5e0cb5044a` | `0x5be4d8cde79b2a76 / 0x96f75041f6861b3a / 0x3700a516cc89d50c / 0x6b99948d6eab4f21` | `0x61daded9c303becb / 0x61daded9c303becb / 0xefcba20c0c70c415 / 0x84d37463be9b0573` |
+
+Hash logs and the 28-row comparator are in `Saved/Linux/l14-final-hash-*.log` and
+`Saved/Linux/l14-final-hash-audit.txt`. Final route logs are `Saved/Linux/l14-final-route-*.log`;
+crossing and pair logs use the `l14-final-crossing-*` and `l14-final-cost-*` names.
+
+## Failed or retried runs
+
+- The first SurfaceWorld hash matrix and first crossing checks omitted the spawn camera and used the
+  headless origin. Their comparisons differed from L13; all 14 SurfaceWorld configurations and all
+  four crossing configurations were rerun with the spawn camera and passed. FloatingIslands used
+  its auto-surface camera and matched on the first run.
+- The first route probes also used the wrong camera selection. A later seed-1 probe used the fixed
+  seed-0 camera, exited 9 on two LOD2 exact-query checks, and was rerun with `--auto-surface-camera`;
+  the corrected seed-1 and seed-17 audits passed. The origin-camera route probes returned success
+  but were not used as reference results.
+- Clang was rebuilt after the connector counters were added and again after folding aggregation
+  into the existing opt-in guard. Both Clang builds and the final GCC build succeeded. No run hit
+  the RSS, 15-minute stuck-step, or 30-minute limits.
+
+Owner note: the highest measured far cost is still LOD6 connector repair, but its formula work is
+mostly uncached and its panels preserve the coarse route wall. The final interleaved plain runs show
+no measurable diagnostic overhead; no geometry change or L6 budget claim is made.
+
+## Orchestrator review (Claude)
+
+- Accepted as a counting round. Interleaved W12, no hashing: L13 1.429 s vs L14 1.419 s median, so the
+  opt-in counters cost nothing measurable when off; committed with the report.
+- Conclusion: exact-output far work has no remaining lever above 3%. The big buckets
+  (ground/cap refinement ~3.95 worker-s, LOD6 connector repair ~1.40 worker-s) produce visible
+  geometry. Further far savings need geometry changes, judged against today's same-LOD mesh within
+  the owner's budget (1 px at 1440p, at the LOD's closest display distance, display only).

Standalone/Research/WorldAssemblerM3/Linux15/REPORT.md

@@ -0,0 +1,195 @@
+# Linux15 report
+
+## Result
+
+Null result. No far-mesh shortcut passed the full 1 px, shading, swap, and topology gates, so no
+recipe enables one by default. Evaluator version 6→7 adds the optional `far_display_mesh` declaration;
+omitting it keeps the L14 output path. The controls are in the shared Core layer and do not touch
+LOD0–2, exact queries, collision, edits, or server state.
+
+Candidates measured:
+
+- Refinement grid scale ×2 at LOD4, 5, 6, 7, and 8. The all-tile LOD4 and LOD5 runs reject; the
+  remaining per-LOD probes exceed 1 px or change shading, and the LOD6–8 candidates worsen at
+  least one adjacent swap.
+- Reusing connector station radii leaves geometry p99 at 1.07 px but reaches 15.23 px maximum;
+  shading delta reaches 0.667 and the normal changes by 73.3°.
+- Coarsening refinement at LOD4–8 is the largest measured saving, but exceeds the display budget.
+  Halving connector station density also saves time but opens gaps. Removing
+  any one ray direction also opens gaps, and the removed-panel control finds 99 new holes.
+
+## Screen-space gate
+
+The gate samples 65×65 surface grids across all 1,145 displayed LOD3–8 tiles (5,208,134 samples;
+skirts excluded). Geometry is projected normal displacement against today's same-LOD mesh at its
+closest display distance, using 90° horizontal FOV and 2,560 px (0.000613592 rad/px). Shading delta
+is the maximum of fixed-light normalized Lambert change and material selector/blend-channel change;
+the limit is 1/255. Each number below is p50/p99/max. Exact-path baseline values are all zero.
+The gate rejects geometry max above 1 px, shading max above 1/255, any worse per-sample swap,
+missing surface, or new hole/crack/floater. Its own validation fails if S13, stride-2, missing
+surface, floating surface, missing fine-ring, or removed-panel controls are not rejected; the
+panel control must expose at least one new connector hole.
+
+| LOD | Tiles | Geometry px: baseline → refine×2 all | Shading delta: baseline → refine×2 all | Refine×2 holes / cracks / floating |
+|---:|---:|---:|---:|---:|
+| 3 | 384 | 0/0/0 → 0/0/0 | 0/0/0 → 0/0/0 | 0 / 0 / 0 |
+| 4 | 320 | 0/0/0 → 0/2.370/606.562 | 0/0/0 → 0/0.023529/1 | 254 / 400 / 254 |
+| 5 | 144 | 0/0/0 → 0/12.728/95.453 | 0/0/0 → 0/1/1 | 1,183 / 76 / 138 |
+| 6 | 96 | 0/0/0 → 0.023/13.408/799.596 | 0/0/0 → 0/1/1 | 476 / 0 / 201 |
+| 7 | 48 | 0/0/0 → 0/13.242/248.905 | 0/0/0 → 0/1/1 | 30 / 0 / 1 |
+| 8 | 153 | 0/0/0 → 0.158/19.250/187.465 | 0/0/0 → 0.003922/1/1 | 45 / 0 / 946 |
+
+The selected-patch swap report compares each baseline with refine×2 all. Values are p50/p99/max px.
+
+| Swap (distance) | Before | After refine×2 all |
+|---|---:|---:|
+| 3→2 (96 m) | 0.611/3.767/6.045 | 0.611/3.767/6.045 |
+| 4→3 (192 m) | 0.752/4.630/7.513 | 0.752/4.630/7.513 |
+| 5→4 (384 m) | 0/9.580/31.783 | 2.435/32.321/86.615 |
+| 6→5 (768 m) | 0/9.754/70.340 | 0.343/19.142/78.077 |
+| 7→6 (1,536 m) | 0/9.040/42.355 | 0.200/15.109/50.994 |
+| 8→7 (3,072 m) | 0.826/18.030/47.182 | 1.528/24.547/64.449 |
+
+The station×2 LOD6 screen scan measures 0/2/813.571 px, shading 0/0/1, with 1,349 holes and 1,690
+floaters. Its connector audit counts missing ray stations by stable tile/ray/station ID: holes 8→221
+(216 new), floating classifications 464→405 (111 new IDs). In the refine×2 all row above, the
+screen scan reports those all-tile holes, cracks, and floaters. Station×2 leaves all six selected-patch
+swap p50/p99/max rows at baseline values, including 6→5 at 0/9.754/70.340 px. All four ray directions are required:
+the four one-ray-removed
+controls create 1,008, 1,022, 1,171, and 1,158 new holes. The explicit panel-removal control creates
+99 new holes. The exact-path audit has zero new holes, cracks, or floating pieces; its raw connector
+audit counts remain 8 holes and 464 pre-existing floating classifications.
+
+The LOD4×2 and LOD5×2 candidates also fail in isolation. Reusing station radii misses the LOD6
+geometry and shading limits. The four one-ray-removed masks add 1,008, 1,022, 1,171, and 1,158
+connector holes, respectively.
+
+## Negative controls
+
+- The S13 global-octave-drop and stride-2 column-interpolation controls are rejected at every LOD3–8.
+- Missing displayed surface, a floating surface, and missing fine-ring surface controls are rejected.
+- Removing connector panels is rejected with 99 new holes. The exact connector path has zero new
+  station IDs classified as holes, cracks, or floaters.
+
+## Speed
+
+Five interleaved W12 pairs per candidate, hashing off, same 2,553-tile L1 view.
+`whole_view_ready` is the metric. Both candidates fail the quality gate.
+
+Station×2 connector stations:
+
+| Pair | L14 baseline | Station×2 | Change |
+|---:|---:|---:|---:|
+| 1 | 1.320 s | 1.304 s | −1.2% |
+| 2 | 1.363 s | 1.330 s | −2.4% |
+| 3 | 1.371 s | 1.332 s | −2.8% |
+| 4 | 1.393 s | 1.341 s | −3.7% |
+| 5 | 1.391 s | 1.345 s | −3.3% |
+| Median | 1.371 s | 1.332 s | −2.8% (3.3% median paired gain) |
+
+Refinement grid scale ×2 at LOD4–8:
+
+| Pair | L14 baseline | Refine×2 all | Change |
+|---:|---:|---:|---:|
+| 1 | 1.305 s | 1.164 s | −10.8% |
+| 2 | 1.336 s | 1.177 s | −11.9% |
+| 3 | 1.362 s | 1.169 s | −14.2% |
+| 4 | 1.378 s | 1.178 s | −14.5% |
+| 5 | 1.384 s | 1.190 s | −14.0% |
+| Median | 1.362 s | 1.177 s | −13.6% (14.0% median paired gain) |
+
+## Hashes and invariants
+
+The undeclared/default recipe path matches L14. LOD0–2 density/mesh/payload/topology hashes:
+
+| LOD | Density | Mesh | Payload | Topology |
+|---:|---|---|---|---|
+| 0 | `769f2a706d585a72` | `33eeeb39fa443816` | `645621a1d968983f` | `c2457ed905036c9d` |
+| 1 | `69cc5a5c0a2c60af` | `b48335f5410c57d5` | `d15c5480162ab8ba` | `feca1bd025823604` |
+| 2 | `85deed5683a77202` | `53469895987aeea2` | `e55f8ae7e1532033` | `d5feb12a0e85c09b` |
+
+Exact queries (density / unclamped / detail / collision) remain
+`e4d4a8eb95b35933 / e4d4a8eb95b35933 / efcba20c0c70c415 / e604823a249029bf`. The 24 m crossing's
+432 moved tiles match L14 at W1/W12 with Clang off and GCC default:
+`337ca62131576728 / 7612f48e2ddbbaab / 69a67ed4add83b87 / f11ac1ebd0f7ddb8` (D/M/P/T).
+Its LOD0–2 per-LOD hashes also match the three rows above.
+
+Determinism passed 28/28 configurations: SurfaceWorld seed 0 and FloatingIslands seed 0, Clang 19
+FP-contract off and GCC 14 default, W1/W8/W12 and five W12 repeats. All per-LOD and whole-view
+hashes match L14. L13 route parity passed for SurfaceWorld seeds 0, 1, and 17 and FloatingIslands
+seed 0; page, native-only, higher-LOD, edit, and history mismatch counts are zero.
+
+The L3 FP-contract preamble/self-test, L4 `FLazy`, L7 shared cache, L9/L12 proofs, L11 readiness and
+crash fix, L13 route binding, and CLAUDE.md async rules remain in place. The evaluator and optional
+recipe declaration are shared by all recipes. Builds and runs used CPUs 0–11, up to W12, normal
+priority, 6 GiB address-space limits, and the unchanged `powersave` governor. Peak RSS was 904,400 KB
+(GCC build); peak runtime RSS was 736,432 KB. No run exceeded the time or memory limits.
+
+## Capture pairs
+
+JPEGs are 1280×720 and each is under 74 KB. Before is L14; after is the rejected refinement×2
+candidate applied at LOD4–8.
+The L1 view uses `(0,-35,-487.94) m`, yaw 0°, pitch −22°. Horizon uses the same location at pitch −2°.
+The mesa frame aims from the L1 location at the L6 mesa band (`(-472,-1432,-463.151) m` in the
+gate) with yaw −161° and pitch 0.9°.
+
+| View | Before | After refine×2 all |
+|---|---|---|
+| L1 camera | [l1-camera-before.jpg](captures/l1-camera-before.jpg) (59 KB) | [l1-camera-after-refineall.jpg](captures/l1-camera-after-refineall.jpg) (57 KB) |
+| Horizon | [horizon-before.jpg](captures/horizon-before.jpg) (63 KB) | [horizon-after-refineall.jpg](captures/horizon-after-refineall.jpg) (60 KB) |
+| LOD6 mesa rim | [lod6-mesa-rim-before.jpg](captures/lod6-mesa-rim-before.jpg) (74 KB) | [lod6-mesa-rim-after-refineall.jpg](captures/lod6-mesa-rim-after-refineall.jpg) (67 KB) |
+
+## Failed and retried runs
+
+- The first Clang build wrapper exited 127 because `/usr/bin/time` is absent; the direct Clang
+  `-ffp-contract=off` build succeeded. GCC 14 default also built successfully.
+- A later sequential-build monitor was interrupted after Clang completed and before its GCC step
+  launched. Clang and GCC were rebuilt separately with the same compiler settings and 6 GiB cap.
+- The first hash matrix omitted `--seed=0` and was discarded. A second FloatingIslands matrix used
+  the SurfaceWorld spawn camera; it was rerun with the L14 auto-surface camera. The corrected matrix
+  passed all 28 configurations.
+- Initial SurfaceWorld route probes used no camera for seed 0 (the 2,370-tile bound), omitted
+  `--region-crossing` for seed 0 (shape compiler safety bound), and used the fixed seed-0 camera for
+  seed 1 (LOD2/exact-query parity mismatch; seed 17 was not run with that setup). They were rerun
+  with L14's camera selection and region-crossing option; all four final route audits passed. The
+  first 24 m crossing also omitted `--region-crossing` and exceeded the shape-build safety bound;
+  all four corrected compiler/worker combinations passed.
+- The first connector audit compared aggregate counts. It was replaced with stable per-ray station
+  ID comparison before the final gate. The initial L4 selected-tile gate missed a changed tile; the
+  all-desired-tile coverage gate found and rejected it. The full-view gate is used in the table above.
+- The first JPEG encoding pass did not set CPU affinity or an address-space cap. All six files were
+  re-encoded under CPUs 0–11 and the 6 GiB cap; sizes and pixels stayed the same.
+- The first five speed pairs included screen-gate color capture on ordinary streaming tiles. That
+  diagnostic copy is now enabled only for gate runs; all five cost pairs were rerun and the table
+  above uses only the final logs. The final exact gate passed and station×2 remained rejected.
+- No builds, captures, final audits, or cost runs timed out or breached their memory limits. The
+  intentional candidate rejections are listed above, not treated as infrastructure failures.
+
+Evidence logs are in `Saved/Linux`: the final baseline and station×2 all-tile gates are
+`l15-final-gatecolors-exact.log` and `l15-final-gatecolors-station2.log`; the best-payoff
+refinement×2 all-tile gate is `l15-final-gatecolors-refineall.log`. Single-LOD refinement coverage is in
+`l15-gate-alltiles-refine-l4x2.log` and `l15-gate-alltiles-refine-l5x2.log`. Single-LOD refinement
+and connector-ray probes are `l15-gate-refine-l{x}x2.log`, `l15-gate-reuse.log`, and
+`l15-gate-rays{14,13,11,7}.log`. Hash, route, and crossing evidence is in
+`l15-final-hash-audit.txt`, `l15-final-route-*.log`, and `l15-final-crossing-24m-*.log`; final
+station×2 speed pairs are `l15-final-speed-pair{1..5}-{before,after}.log`; refinement×2 pairs are
+`l15-final-speed-refineall-pair{1..5}-{before,after}.log`.
+
+## Note for the owner
+
+The default far terrain stays the same because every measured reduction exceeded the 1 px geometry
+or shading limit, worsened a swap, or opened holes. Refinement×2 across LOD4–8 saves 13.6% by the
+median whole-view ratio, but creates hundreds-pixel errors and visible gaps, so the captures show it
+for review only and it is not enabled.
+
+## Orchestrator review (Claude)
+
+- I looked at the LOD6 mesa-rim pair. After refine×2, the jagged crests are visibly smoothed, black
+  holes appear in the cap/ceiling, and a dark sliver shows on the left horizon. That confirms the
+  gate's rejection: the instrument is right this time, not the world.
+- **Not merged into `assembler/world`:** the candidate knobs and the evaluator 6→7 bump add no default
+  output and would invalidate version stamps for nothing. The full L15 code (the extended gate with
+  shading, swap and connector-ID audits, and the candidate controls) is kept on side branch
+  `wip/l15-far-budget`. `assembler/world` stays at L14 code plus this report.
+- Conclusion of L14+L15: far terrain has no exact or within-budget saving left with today's design. The
+  remaining far cost is the price of the current refinement and connector-repair geometry.

Standalone/Research/WorldAssemblerM3/Linux16/MeasureZstd.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Per-tile zstd CLI comparison over the pristine L1 records from this round."""
+
+from pathlib import Path
+import shutil
+import struct
+import subprocess
+import time
+import zlib
+
+
+REPO = Path.cwd().resolve()
+CACHE = REPO / "Saved/Linux/cache/l16-prototype"
+CAPTURE_LOG = REPO / "Saved/Linux/l16-cache-l1-q24-full-write.log"
+TEMP = CACHE / "codec-zstd"
+RESULT = REPO / "Saved/Linux/l16-zstd-codec.txt"
+
+assert CACHE.is_dir() and not CACHE.is_symlink()
+assert CACHE.resolve().parent == (REPO / "Saved/Linux/cache").resolve()
+assert CAPTURE_LOG.is_file()
+assert not TEMP.exists()
+
+cutoff_ns = CAPTURE_LOG.stat().st_mtime_ns
+records = [
+    path for world in CACHE.glob("world_*")
+    for path in world.glob("*.vftile")
+    if "_s0_d0000000000000000_" in path.name and path.stat().st_mtime_ns <= cutoff_ns
+]
+records.sort()
+assert len(records) == 2553, f"expected 2553 L1 pristine records, found {len(records)}"
+
+codec = shutil.which("zstd")
+assert codec, "zstd CLI is not available"
+TEMP.mkdir()
+per_lod = {}
+try:
+    for source in records:
+        record = source.read_bytes()
+        assert record[:8] == b"VFTILE16"
+        raw_size, compressed_size = struct.unpack_from("<QQ", record, 124)
+        raw = zlib.decompress(record[144:144 + compressed_size])
+        assert len(raw) == raw_size
+        lod = int(source.name.split("_", 1)[0][3:])
+        entry = per_lod.setdefault(lod, {"raw": 0, "files": [], "encode_ns": 0, "decode_ns": 0, "zstd": 0})
+        raw_file = TEMP / (source.stem + ".raw")
+        raw_file.write_bytes(raw)
+        entry["raw"] += len(raw)
+        entry["files"].append(raw_file)
+
+    for lod in sorted(per_lod):
+        entry = per_lod[lod]
+        start = time.perf_counter_ns()
+        subprocess.run([codec, "-q", "-1", "-f", "--", *map(str, entry["files"])], check=True)
+        entry["encode_ns"] = time.perf_counter_ns() - start
+        compressed_files = [Path(str(path) + ".zst") for path in entry["files"]]
+        entry["zstd"] = sum(path.stat().st_size for path in compressed_files)
+        start = time.perf_counter_ns()
+        subprocess.run([codec, "-q", "-d", "-f", "--", *map(str, compressed_files)], check=True)
+        entry["decode_ns"] = time.perf_counter_ns() - start
+
+    # Verify each decoded output byte-for-byte against the zlib payload again.
+    # The filename is the tile stem, so a deterministic source lookup is sufficient.
+    source_by_stem = {path.stem: path for path in records}
+    for entry in per_lod.values():
+        for raw_file in entry["files"]:
+            source = source_by_stem[raw_file.stem]
+            data = source.read_bytes()
+            _, compressed_size = struct.unpack_from("<QQ", data, 124)
+            assert raw_file.read_bytes() == zlib.decompress(data[144:144 + compressed_size])
+
+    lines = ["lod tiles raw_total_B zstd1_total_B zstd1_avg_B encode_us_per_tile decode_us_per_tile status"]
+    for lod in sorted(per_lod):
+        entry = per_lod[lod]
+        count = len(entry["files"])
+        lines.append(
+            f"{lod} {count} {entry['raw']} {entry['zstd']} {entry['zstd'] / count:.1f} "
+            f"{entry['encode_ns'] / count / 1000:.2f} {entry['decode_ns'] / count / 1000:.2f} PASS"
+        )
+    raw_total = sum(entry["raw"] for entry in per_lod.values())
+    zstd_total = sum(entry["zstd"] for entry in per_lod.values())
+    lines.append(f"total_tiles={len(records)} raw_bytes={raw_total} zstd1_bytes={zstd_total} ratio={zstd_total / raw_total:.6f}")
+    lines.append("decode=byte-exact; timing includes zstd CLI process startup once per LOD")
+    RESULT.write_text("\n".join(lines) + "\n")
+    print("\n".join(lines))
+finally:
+    resolved = TEMP.resolve()
+    assert resolved.parent == CACHE.resolve()
+    shutil.rmtree(TEMP)

Standalone/Research/WorldAssemblerM3/Linux16/REPORT.md

@@ -0,0 +1,232 @@
+# Linux16 — terrain cache design and Core prototype
+
+This is a persistence feature. The measurements judge exactness, storage, and worker responsiveness;
+first-time terrain generation remains a separate cost. The prototype is headless and opt-in. Unreal
+integration remains for the owner's PC.
+
+## Design
+
+- **Cache identity.** Production keys should include a stable world ID; season ID and canonical
+  season-content hash; seed and RNG contract; recipe, plan, biome/manifest and owner-content hashes;
+  schema and `WorldAssemblyEvaluatorVersion` (6 here); tile coordinate and LOD; voxel size and tile
+  dimensions; generation options; material/payload-section schema; mesher contract; and a generator
+  build/FP-contract identity. Include a platform or compiler identity unless cross-build output has
+  been proven equivalent. Clang and GCC matched this round's full hash matrix, but that alone does
+  not make every future build interchangeable. Use canonical content hashes so whitespace or JSON
+  key order does not change the world identity.
+- **Prototype identity.** The header and file name include the raw owner-snapshot hash, Core
+  configuration, recipe/plan/manifest hashes, seed, schema, evaluator, voxel size, tile size,
+  mesher/FP contract, generation-options hash, tile key and LOD. The edited-tile probe also includes
+  edit sequence and tile edit digest. The prototype uses 64-bit FNV for identity inputs and CRC32
+  for accidental file corruption. Production should use a 256-bit content hash and a stable world
+  ID; the prototype hashes are evidence machinery, not a security boundary.
+- **Edits.** Keep the reusable cache pristine. On load, apply the authoritative versioned diff layer
+  in sequence, then build the edited render/collision result. A derived edited-tile cache, if useful,
+  must key on the last applied sequence and a digest of edits intersecting that tile. A newer edit
+  invalidates only derived entries for touched tiles; it leaves pristine entries valid. The edit
+  probe wrote and reread sequence 1 with digest `3cd5603ebf707d0c` and matched every array and hash.
+- **Server.** Never accept a client's cached mesh or collision as authoritative. The server may use
+  its own locally generated cache for pristine meshes, then apply its ordered edit layer and build
+  collision from that result. Client cache contents never cross the network; only validated edits
+  do. A server restart can reuse its own cache after identity and payload validation.
+- **Invalidation and verification.** Season/content, seed/RNG, recipe, plan, evaluator, generator,
+  mesher, FP, voxel-grid, LOD, options, or payload-schema changes select a different key. Evaluator
+  bump and edit-sequence bump were rejected by the prototype. A canonical uncompressed-payload hash
+  should be stored and verified at load; corruption or a mismatch is a cache miss, followed by
+  regeneration on a worker. The prototype verifies CRCs and structure on every load, compares the
+  complete mesh arrays and Core D/M/P/T hashes after every generated write/read, and regenerates a
+  deliberately corrupted cached tile. This proves the sampled write/read route; a file's own hash
+  cannot independently prove generator semantics on every later hit, so complete identity and
+  version discipline remain essential.
+- **Stored data.** The prototype stores the final Core mesh: exact double positions/normals, float
+  UVs, RGBA, section/group counts, indices, skirt masks, density sample count, and D/M/P/T hashes.
+  This avoids remeshing on a hit and maps directly to future RMC sections. The indices and section
+  ranges can feed server-side collision construction after edits. Density/sign tiles offer more
+  freedom for future meshers but require meshing, materials, and collision work on load; density
+  sizes were not benchmarked here. Keep collision ownership server-side in either design.
+- **Worker/smoothness path.** Cache reads, zlib decode, integrity checks, serialization, and writes
+  run in the existing headless Core tile worker/result route. The Unreal game thread was not
+  present on this machine; its later integration should submit cache work through the same worker
+  queue and return the ordinary tile result. The prototype uses that route for all recipes and
+  changes no recipe implementation. It exercises SurfaceWorld for cache round trips; the cache-off
+  matrix and route audits cover SurfaceWorld and FloatingIslands.
+- **Read versus regenerate.** Track per-LOD generation and load/decode EWMA. If a demanded tile's
+  estimated read/decode time exceeds generation time, schedule generation directly; if an attempted
+  load fails, discard it and regenerate without blocking the result queue. Keep the same tile
+  priority and permit the previous coarser LOD to remain visible while work finishes. On this L1
+  set, warm read/decode averaged about 0.11 ms per LOD0 tile and 0.91–1.61 ms per LOD8/7 tile,
+  compared with 3.97 ms LOD0 and 12.89–24.24 ms LOD8/6 mesh generation in the instrumented fill.
+- **Layout, crash safety, and eviction.** One file per tile under a world-content directory keeps
+  reads and eviction independent; the prototype has 2,553 L1 records and 2,986 touched records after
+  the 24 m crossing. It writes a same-directory `.tmp`, flushes and `fsync`s it, atomically renames
+  to `.vftile`, then syncs the directory. Readers only open final `.vftile` names and reject bad
+  lengths, versions, identities, CRCs, counts, indices, and padding. A crash before rename leaves a
+  non-loadable temp file. Production startup should remove old temp files. Use a global 2 GB cap
+  with an LRU index by last use, protect entries currently in use, reserve space under one lock,
+  evict oldest unpinned records before writes, and skip the write if space still cannot be made.
+  The prototype enforces the cap and skips writes when full; it does not implement LRU eviction.
+  Its 4 KiB padding enabled `O_DIRECT` measurements and can be removed in production buffered I/O.
+
+## Compression measurements
+
+Available system zlib headers/library (zlib 1.3.1) were linked with `-lz`. The existing zstd 1.5.7
+CLI had no development headers, so it was tested as a per-tile CLI codec in LOD batches; its times
+include one process start per LOD. No installs or system changes were made. All totals below cover
+all 2,553 L1 tiles except Q16, whose first run had five route-audit tiles prepopulated before codec
+sampling. Sizes are payload bytes; the lossless cache also has headers and per-file 4 KiB padding.
+
+| Encoding | Total bytes | Relative to raw | Exact Core arrays? | L1 gate |
+|---|---:|---:|---|---|
+| Raw canonical mesh | 107,342,349 | 100% | Yes | Pass |
+| zlib level 6 | 47,388,401 | 44.15% | Yes | Pass |
+| zstd level 1 (CLI, per tile) | 46,513,479 | 43.33% | Yes | Pass; 1.85% smaller than zlib payload |
+| Q16 positions + oct16 normals + delta-varint indices | 38,672,768 (2,548 tiles sampled) | 36.17% | No | Fail: 11.4482 px at LOD0; 6 degeneracy changes (2 at LOD4, 4 at LOD6) |
+| Q24 positions + oct16 normals + delta-varint indices | 42,862,996 | 39.94% | No | Pass: 0.0458 px max, 0.000060 Lambert delta max, 0.00361° normal error max, no winding/degeneracy changes |
+
+Q24 is about 9.5% smaller than zlib's payload, but it changes floating-point positions/normals and
+cannot satisfy exact loaded-versus-regenerated hashes. The selected cache path is lossless zlib.
+The zstd CLI decoded every tile byte-for-byte, and was modestly smaller/faster in this test. There
+are no zstd development headers here, so it was not linked into the worker prototype. The L1 zlib
+records occupied 55,685,120 bytes on disk, including record framing and page padding.
+
+Per-tile size averages by LOD:
+
+| LOD | Tiles | Raw B | zlib B | zstd B | Q16 B* | Q24 B |
+|---:|---:|---:|---:|---:|---:|---:|
+| 0 | 512 | 19,232.6 | 7,901.7 | 8,009.4 | 7,115.2 | 7,797.3 |
+| 1 | 448 | 15,437.8 | 6,715.2 | 6,715.6 | 5,394.2 | 6,244.9 |
+| 2 | 448 | 11,152.2 | 4,452.4 | 4,516.8 | 4,129.9 | 4,548.7 |
+| 3 | 384 | 11,750.3 | 4,813.1 | 4,885.5 | 4,361.7 | 4,801.7 |
+| 4 | 320 | 49,186.9 | 18,865.3 | 18,352.3 | 17,858.1 | 19,738.2 |
+| 5 | 144 | 83,106.3 | 37,693.0 | 37,004.3 | 30,247.6 | 33,494.7 |
+| 6 | 96 | 128,102.3 | 59,624.7 | 56,521.2 | 46,390.6 | 51,437.7 |
+| 7 | 48 | 308,206.8 | 141,387.7 | 139,348.3 | 110,361.7 | 121,997.0 |
+| 8 | 153 | 171,712.3 | 81,805.0 | 79,662.9 | 60,755.8 | 67,046.4 |
+
+*Q16 averages are over the 2,548 newly generated tiles; five prepopulated tiles did not enter its
+codec sample. Raw, zlib, and Q24 averages are from the clean 2,553-tile fill.
+
+Average codec encode/decode time per tile, microseconds:
+
+| LOD | Raw E/D | zlib E/D | zstd CLI E/D | Q24 mesh E/D |
+|---:|---:|---:|---:|---:|
+| 0 | 38.60 / 12.31 | 736.63 / 79.49 | 72.14 / 47.97 | 16.28 / 18.78 |
+| 1 | 30.13 / 9.47 | 608.30 / 68.07 | 62.71 / 40.53 | 14.26 / 16.04 |
+| 2 | 18.94 / 4.64 | 286.44 / 37.86 | 48.50 / 34.65 | 8.20 / 7.55 |
+| 3 | 20.21 / 5.18 | 313.54 / 41.77 | 50.73 / 35.90 | 8.81 / 8.07 |
+| 4 | 90.46 / 27.53 | 1,508.23 / 189.40 | 134.50 / 78.66 | 41.58 / 41.93 |
+| 5 | 163.48 / 55.53 | 2,935.24 / 370.92 | 220.23 / 140.52 | 76.90 / 79.86 |
+| 6 | 254.98 / 96.01 | 4,900.50 / 611.07 | 361.50 / 184.35 | 127.39 / 136.19 |
+| 7 | 621.57 / 211.84 | 11,944.70 / 1,475.82 | 861.84 / 442.64 | 327.72 / 391.27 |
+| 8 | 325.34 / 109.80 | 6,478.56 / 784.32 | 486.54 / 289.96 | 167.25 / 186.01 |
+
+## Smoothness, prototype, and budgets
+
+- A clean write generated, losslessly stored, reloaded, and exactly compared all 2,553 L1 tiles.
+  The whole-view D/M/P/T hash matched L14. The warm run hit 2,553/2,553 tiles, returned the same
+  hash, and reached whole-view-ready in 0.450 s including 0.193 s of shape setup; tile streaming
+  took 0.243 s.
+- The 24 m crossing covered 432 entering tiles. Its D/M/P/T hash was
+  `337ca62131576728 / 7612f48e2ddbbaab / 69a67ed4add83b87 / f11ac1ebd0f7ddb8`, equal to L14.
+  The cache route audit passed 9 pristine pairs, one edited pair, and one movement-history pair,
+  all with exact arrays and zero D/M/P/T mismatches. The crossing fill generated and round-tripped
+  428 tiles; four had already been created by the route audit.
+- Safety controls passed: evaluator bump rejected, edit-sequence bump rejected, a flipped compressed
+  payload byte rejected by record CRC, and a truncated file rejected by size validation. A separate
+  L1 run with one real tile corrupted regenerated that tile, hit the other 2,552, and restored the
+  exact L14 whole-view hash.
+- `O_DIRECT` bypassed the kernel page cache for the 55,685,120-byte L1 record set: 0.269 s
+  (197.6 MiB/s). Buffered first touch was 0.0191 s and the repeat was 0.0126 s, but those passes
+  followed file writes/verification and were page-cache warm. No page cache was dropped; device
+  firmware may also cache blocks, so `O_DIRECT` is page-cache-cold evidence rather than proof of a
+  physical cold-device read. The ordinary worker hit path includes buffered read, zlib decode,
+  validation, and tile construction.
+- The instrumentation measures raw, zlib, and mesh candidates on a miss, so its clean-fill
+  whole-view-ready time was 2.674 s versus 1.718 s for the hash-on no-cache L1 run. This includes
+  benchmark-only extra codec work. Production should encode only its selected lossless format on a
+  miss. Warm disk work and decode stay on workers; the first tile was ready in 0.226 s on fill and
+  0.208 s warm. These headless timings show worker completion; an Unreal frame-time check is still
+  for the integration round.
+- The cache root peaked at 60,835,840 bytes after L1, the 24 m crossing, edit probe, and corruption
+  controls; the enforced limit is 2,000,000,000 bytes. No eviction was needed. The actual cache
+  implementation is a headless Core-worker prototype, not the Unreal plugin integration.
+
+## Default-path cost and compatibility
+
+Five interleaved W12 L1 pairs, hash off, 2,553 tiles each:
+
+| Pair | L14 seconds | L16 cache-disabled seconds |
+|---:|---:|---:|
+| 1 | 1.450 | 1.446 |
+| 2 | 1.464 | 1.457 |
+| 3 | 1.458 | 1.453 |
+| 4 | 1.525 | 1.472 |
+| 5 | 1.459 | 1.483 |
+
+Median: 1.459 s L14, 1.457 s L16, −0.14%; no measurable cache-off cost in this run.
+
+All 28 L14 hash configurations passed (SurfaceWorld and FloatingIslands; Clang 19 FP off and GCC
+14 default FP; W1/W8/W12 with five W12 repeats). Every one matched all 12 full-detail, whole-view,
+nine LOD, and exact-query rows. The four default 24 m crossing checks (W1/W12 on both compilers)
+matched all 13 rows, including the 432-tile crossing hash. Default route parity passed for both
+compilers across SurfaceWorld seeds 0, 1, and 17 and FloatingIslands seed 0, using the existing
+96 m history probe. The cache route passed its separate L1 and 24 m crossing audits.
+
+Representative SurfaceWorld seed-0 hashes (D/M/P/T):
+
+| View | Density / mesh / payload / topology |
+|---|---|
+| Full detail, 960 tiles | `0ee0579bd15cbbe4 / 32e5d4964d610fee / 1932b96ee4b1d910 / 69743c6bad3447dc` |
+| Whole L1, 2,553 tiles | `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724` |
+| LOD0, 512 tiles | `769f2a706d585a72 / 33eeeb39fa443816 / 645621a1d968983f / c2457ed905036c9d` |
+| LOD1, 448 tiles | `69cc5a5c0a2c60af / b48335f5410c57d5 / d15c5480162ab8ba / feca1bd025823604` |
+| LOD2, 448 tiles | `85deed5683a77202 / 53469895987aeea2 / e55f8ae7e1532033 / d5feb12a0e85c09b` |
+| LOD3, 384 tiles | `6518caefb3be7e7f / ec513c90b853a614 / f62fa1137ff17f82 / ccf1dcf681965816` |
+| LOD4, 320 tiles | `62d4be96021992f4 / f1e4c6efcc2615a9 / 9dc5f9c88be02f33 / fe6f55125a07c3bf` |
+| LOD5, 144 tiles | `5e4a8c38b8cea6fc / 08ee56998aaf21e5 / 541eea8558f26cc8 / 6539374a8b3336d8` |
+| LOD6, 96 tiles | `e036e95b9006945b / 624a33f941a99b02 / 81b73e14f68bdf86 / 4de4c63ce1f80a56` |
+| LOD7, 48 tiles | `8ee358af56a30d8d / 46ab3c6184048b7c / 0a6164b7e68e80c5 / 0c26b85bb03bc831` |
+| LOD8, 153 tiles | `c3458e1cbdb9c471 / 46c03d0994d75192 / 8f89fc5bde12d230 / d16dc0cf62031898` |
+| Exact queries: density / unclamped / detail / collision | `e4d4a8eb95b35933 / e4d4a8eb95b35933 / efcba20c0c70c415 / e604823a249029bf` |
+
+FloatingIslands full-detail was `6d842d2878b08ef6 / 4b868a3184f08035 / 2cedf2236788752d / eac17d5e0cb5044a`; whole-view was `5be4d8cde79b2a76 / 96f75041f6861b3a / 3700a516cc89d50c / 6b99948d6eab4f21`. Its exact-query hashes also matched L14: `61daded9c303becb / 61daded9c303becb / efcba20c0c70c415 / 84d37463be9b0573`.
+
+## Runs and limits
+
+- First Clang build was interrupted during a silent compile phase. The next build exposed a const
+  error in the prototype file index; making that index mutable fixed it. Final Clang and GCC builds
+  passed.
+- The first L1 command used the binary's incorrect default data path (`Standalone/bin/data`) and
+  exited before writing. Supplying `Standalone/data/owner_world.json` passed.
+- The first codec run sampled 2,548 tiles because route parity had prepopulated five; it was kept
+  for Q16 measurements. A clean fill then sampled all 2,553 Q24 tiles.
+- A route wrapper first required a moving hash when hashing was disabled; the route audit itself
+  passed. Seed 17's 24 m history probe had no departed-tile candidate and failed on both L16 and
+  the L14 control. The same L14 96 m history setup passed on both L16 compilers. The required 24 m
+  crossing was separately checked and passed.
+- The first crossing-hash comparator used an incorrect old-log filename; correcting the filename
+  let all four comparisons pass. No run exceeded 30 minutes or stalled for 15 minutes.
+- Final review found that the cache-hit route audit's `exact_arrays` field initially reported hash
+  agreement without comparing the arrays themselves. The audit was changed to compare complete
+  arrays; after rebuilding, both L1 and 24 m crossing route audits passed with zero mismatches.
+
+Runs used CPUs 0–11, at most 12 build jobs, a 6 GiB address-space cap, and normal priority. The
+governor stayed `powersave`; peak sampled single-process RSS was 943,844 KiB (FloatingIslands route
+audit, GCC). No installs, system changes, or page-cache drops were made. The L3 FP-contract preamble
+and self-test, L4 `FLazy`, L7 shared cache, L9/L12 proofs, L11 readiness/crash fix, L13 route binding,
+and async worker/result rules remain enabled. Cache logic is recipe-agnostic.
+
+**Owner note:** Saving generated terrain works exactly and fits well under the round's disk cap.
+Lossless zlib saved about 56% of the serialized payload. The smaller Q24 mesh encoding passed the
+screen gate but changed exact hashes, so the feature should use the lossless record format.
+
+## Orchestrator review (Claude)
+
+- Design accepted: the key, the pristine cache plus ordered edits, a server that never trusts client
+  caches, corruption/stale rejection, lossless zlib, and atomic writes.
+- **Not merged into `assembler/world`:** `Standalone/Source/StreamBenchmarkPipeline.h` (included by the
+  Windows viewer `StandaloneViewer.cpp`) now unconditionally includes `TileCachePrototype.h`, which
+  includes `<unistd.h>`, `<fcntl.h>` and `<zlib.h>`. That would break the MSVC build. Kept on side
+  branch `wip/l16-tile-cache`. Before merging, the prototype must be platform-guarded (or the cache
+  given a portable I/O and codec layer), and zlib needs a Windows source (UE ships zlib).
+- Cache-off cost re-checked by Luna at −0.14% (within noise).

Standalone/Research/WorldAssemblerM3/Linux2/MeasureProcess.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Run one child and print its wait4 peak RSS under the Linux2 process limits."""
+import os
+import resource
+import sys
+import time
+
+if len(sys.argv) < 2:
+    raise SystemExit("usage: MeasureProcess.py executable [arguments ...]")
+
+address_limit, _ = resource.getrlimit(resource.RLIMIT_AS)
+stack_limit, _ = resource.getrlimit(resource.RLIMIT_STACK)
+if address_limit in (resource.RLIM_INFINITY, -1) or address_limit > 6 * 1024**3:
+    raise SystemExit("run under prlimit --as=6442450944")
+if stack_limit in (resource.RLIM_INFINITY, -1) or stack_limit < 8 * 1024**2:
+    raise SystemExit("run with the ordinary process stack limit of at least 8 MiB")
+if not os.sched_getaffinity(0).issubset(set(range(12))):
+    raise SystemExit("run under taskset -c 0-11")
+print(f"[ProcessLimits] address_limit={address_limit} stack_limit={stack_limit} affinity={sorted(os.sched_getaffinity(0))}", flush=True)
+
+started = time.monotonic()
+pid = os.fork()
+if pid == 0:
+    try:
+        os.execvp(sys.argv[1], sys.argv[1:])
+    except OSError as error:
+        print(f"MeasureProcess: exec failed: {error}", file=sys.stderr, flush=True)
+        os._exit(127)
+
+_, status, usage = os.wait4(pid, 0)
+wall = time.monotonic() - started
+exit_code = os.waitstatus_to_exitcode(status)
+print(f"[ProcessResources] exit_code={exit_code} wall_s={wall:.6f} peak_rss_kib={usage.ru_maxrss}")
+raise SystemExit(exit_code)

Standalone/Research/WorldAssemblerM3/Linux2/REPORT.md

@@ -0,0 +1,97 @@
+# WorldAssemblerM3 Linux2
+
+## Result and changes
+
+The hash check can go red. `-ffp-contract=on`, `fast`, and GCC's default each change the first stage hash (density) on the L1 view; contraction off still reproduces all four L1 hashes at W1 and W12. No Core cache or density source was changed.
+
+The standalone now accepts `--seed`, `--recipe`, and `--render-distance-chunks`; the viewer uses those same options for Windows replay. Linux standalone workers use 32 MiB pthread stacks, while the process retains its ordinary 8 MiB stack limit. The build script still defaults to contraction off; `--fp-contract=default` omits that override for the compiler-default probe.
+
+Environment: i9-12900H, CPUs 0–11, Clang 19.1.7, GCC 14.2.0, governor `powersave`, EPP `balance_performance`. Runs used `taskset -c 0-11`, `RLIMIT_AS=6,442,450,944`, normal priority, and no 64 MiB stack limit. Peak `wait4` RSS was 539,648 KiB on the 2,553-tile checks and 293,460 KiB in the seed sweep.
+
+## Commands
+
+Build variants, with `--fp-contract=off`, `on`, and `fast` as named; `default` leaves the compiler flag unset:
+
+```bash
+bash Standalone/BuildLinux.sh --compiler=clang++-19 --variant=clang19-l2-off --jobs=12 --fp-contract=off
+bash Standalone/BuildLinux.sh --compiler=clang++-19 --variant=clang19-l2-on --jobs=12 --fp-contract=on
+bash Standalone/BuildLinux.sh --compiler=clang++-19 --variant=clang19-l2-fast --jobs=12 --fp-contract=fast
+bash Standalone/BuildLinux.sh --compiler=g++-14 --variant=gcc14-l2-off --jobs=12 --fp-contract=off
+bash Standalone/BuildLinux.sh --compiler=g++-14 --variant=gcc14-l2-default --jobs=12 --fp-contract=default
+```
+
+The L1-view call was `taskset -c 0-11 prlimit --as=6442450944 -- python3 Standalone/Research/WorldAssemblerM3/Linux2/MeasureProcess.py <binary> Standalone/data/owner_world.json --workers=<1|12> --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0`. The per-variant commands and resource records are in `Saved/Linux/linux2-contract-final-*.log`.
+
+The seed matrix ran with:
+
+```bash
+python3 Standalone/Research/WorldAssemblerM3/Linux2/RunSeedSweep.py 1800
+```
+
+## Contraction sensitivity
+
+All rows cover the same 2,553-tile L1 view, W12. `g++-14 -Q --help=optimizers -O2 -fno-fast-math` reports `-ffp-contract=fast` when no override is given.
+
+| Build | Density | Mesh | Payload | Topology | First divergence from off |
+|---|---|---|---|---|---|
+| Clang 19 off; GCC 14 off | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` | — |
+| Clang 19 on | `acfa7023c3671dd6` | `adacc34b568be881` | `7c1de424738166e3` | `78e77fd29674920f` | density |
+| Clang 19 fast | `f04bb87094a92a25` | `07596ba1a83f91d5` | `1292f277745a876d` | `b07b82bfb52166f5` | density |
+| GCC 14 default (effective fast) | `03ed0b826a9ff773` | `07596ba1a83f91d5` | `fb6f82e779be56b2` | `9e5d549138ef2bc0` | density |
+
+The hashes come from the whole-view pipeline stages in order: density, mesh, payload, topology. The same contraction-off binaries reproduce L1 at W1 as well as W12.
+
+## Seed sweep
+
+`seeds.txt` contains seed 0 plus 47 distinct values sampled without replacement from signed int32 using `random.Random(0x564F58454C464F52)`. With no mismatch among the 47 random draws, the one-sided 95% binomial upper bound is 6.18% for a random seed to mismatch on this exact matrix; seed 0 is included as the fixed L1 baseline.
+
+| Recipe | Seeds | Linux combinations | Coverage per seed |
+|---|---:|---|---|
+| SurfaceWorld | 48 | Clang/GCC × W1/W12 (192 rows) | 27 LOD0 tiles; voxels `(-32,-192,-1984)` to `(64,-96,-1888)`, a 96³ cube (24 m per side) |
+| FloatingIslands | 48 | Clang/GCC × W1/W12 (192 rows) | 27 LOD0 tiles; voxels `(-32,-32,-160)` to `(64,64,-64)`, a 96³ cube (24 m per side) |
+
+All 384 runs passed. Clang/GCC matched at both worker counts in 192 comparisons; W1/W12 also matched within each compiler in 192 comparisons. The full per-seed, per-stage hashes, tile extents, wall time, and RSS are in [seed_hashes.csv](seed_hashes.csv); the summary is in [seed_sweep_summary.txt](seed_sweep_summary.txt). The sweep took 290.1 seconds; its maximum per-process peak RSS was 293,460 KiB. Coverage is limited to these fixed local cubes.
+
+For seed 0, SurfaceWorld hashes are `e93491225d0202f9 / 6b2a630951428df2 / fc2798d6a5478b25 / 0c08d7d980a84301`; FloatingIslands hashes are `ea74d3354b5ce671 / 476d49ae2a4ba2a6 / 16078fcd36b68ff0 / cfb6c412b7118172`. Each sequence is density / mesh / payload / topology and matched across both compilers and worker counts.
+
+The viewer seed override was added in `StandaloneViewer.cpp` and the standalone recipe helper; no Core change is needed. [windows_commands.txt](windows_commands.txt) contains all 192 PowerShell commands. Example from the repository root:
+
+```powershell
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=0 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+```
+
+Build the viewer with `powershell -ExecutionPolicy Bypass -File Standalone\Build.ps1`, then run the full replay with `powershell -ExecutionPolicy Bypass -File Standalone\Research\WorldAssemblerM3\Linux2\WindowsReplay.ps1`; it writes logs under `Saved\Linux`. Windows/MSVC compilation was unavailable here. Portability risk spots are the new C++20 helpers in `WorldAssemblyPrototype.h`, `strtoll` argument parsing in `StandaloneViewer.cpp`, and the `__linux__`/`std::thread` split in `StandaloneWorkerThread.h`; the pthread path is Linux-guarded.
+
+## TLS cost and follow-up
+
+`readelf -lW` reports `PT_TLS` FileSiz 6,093,024 bytes (5.81 MiB initialized image) and MemSiz 18,155,149 bytes (17.31 MiB per thread). Three 12-worker probes under the ordinary 8 MiB process stack measured a median spawn-to-ready time of 5.63 ms per thread (5.07–6.44 ms), and a resident increase of 17,736 KiB per worker after the first (17,936 KiB for the first). At 12 workers, `/proc/self/statm` rose by 213,036 KiB (208.0 MiB); the 32 MiB worker stacks reserve a further 32,772 KiB of virtual address space each. The largest wait4 peak across TLS probes was 268,476 KiB.
+
+The large TLS symbols include `HeightfieldColumnCache` (0x680000 bytes, about 6.8 MB), `IslandColumnCache` (0x110000), plus duplicated `GFloorReliefCache` (0x140000 each), `GRoomGraphCache` (0xed000 each), and `GSurfColCache` (0xc9e78 each). `GPlayerFitMemo` is also duplicated as a process-wide object in ordinary `.bss`. [core_sources.txt](../../../Core/core_sources.txt) has 18 translation units: `VoxelForgeCore.cpp` is compiled once; each other 17 is compiled both as a `vfcore::detail` wrapper for Core and as a global legacy object for the standalone owner loader/mesher. This isolates the Core copy from Unreal-shaped global symbols and preserves the legacy reference path; the duplicate objects also duplicate cache state.
+
+The L2 executable's static TLS measurement does not establish the Unreal plugin's model. Inference: a runtime-loaded shared object using general-dynamic TLS can obtain per-thread blocks through the dynamic loader, so it may avoid this exact static-TLS-in-stack footprint; the actual UBT `.so` flags and relocations must be inspected. glibc documents the TLS/dlopen compatibility concern for initial-exec TLS and recommends global-dynamic for more general shared-object loading ([glibc Dynamic Linker Hardening](https://www.sourceware.org/glibc/manual/latest/html_node/Dynamic-Linker-Hardening.html)); GCC describes the per-thread storage model and its loader/libc support ([GCC Thread-Local Storage](https://gcc.gnu.org/onlinedocs/gcc-13.3.0/gcc/Thread-Local.html)).
+
+After S14, prototype a small per-thread TLS handle backed by a bounded worker scratch pool or explicit generation context; share immutable initialized data and remove the Core/legacy duplicate cache where practical. This is a proposal only. The standalone stack wrapper already avoids the external 64 MiB process-stack setting: its own Linux workers request 32 MiB, and the L1 hashes stayed unchanged.
+
+## Failed and retried runs
+
+- The first Clang-off build failed because one join loop still named `std::thread&`; it was changed to `FStandaloneWorkerThread&` and rebuilt successfully (`linux2-build-clang-off.log`, then the retry logs). One later GCC-off build attempt stopped with `headless_object: unbound variable` (`linux2-build-gcc-off-final2.log`); an immediate identical build under the same CPU/address-space limits succeeded (`linux2-build-gcc-off-debug.log`), and the failure did not recur.
+- The first FloatingIslands smoke used the default far ring and planned 186,911 tiles; it was stopped after about 10 seconds before generation (`linux2-floating-smoke-clang-w1.log`). With `--render-distance-chunks=0`, a radius-2/max-LOD-4 smoke completed 791 tiles in 18.94 seconds (`linux2-floating-smoke-clang-w1-r2.log`); the sweep uses radius 1/max-LOD 0 (27 tiles).
+- The first contraction pass omitted the L1 camera and covered 2,370 tiles (`linux2-contract-*-w12.log`), so those hashes were discarded. The exact L1 camera rerun covered 2,553 tiles and produced the table above (`linux2-contract-final-*.log`).
+- An optional one-ULP diagnostic attempt did not trigger (no injection line and no hash change; `linux2-negative-one-ulp-clang-off-w12.log`), so that switch was removed. It was unnecessary after the contraction variants made the check go red. The seed sweep had no failed or retried runs.
+
+## Note for the owner
+
+Contraction off reproduces L1 at W1/W12, while Clang on/fast and GCC default diverge first at density, so the Unreal Linux build's effective FP flags are decisive. The 48-seed sample matched across compilers and worker counts on 24 m-sided cubes in both recipes; the Windows replay commands are ready, with their MSVC build still unverified.
+
+## Orchestrator review (Claude)
+
+- **Surface sweep coverage is 14 effective seeds, not 48.** In `seed_hashes.csv`, 34 of the 48 SurfaceWorld
+  seeds give seed 0's exact density hash `0xe93491225d0202f9`, i.e. the fixed 24 m cube carries no
+  seed-dependent surface for them. Only 14 seeds exercise distinct terrain, so the 6.18% bound applies to
+  FloatingIslands (48 distinct hashes) but not to SurfaceWorld. Future sweeps should place the cube on each
+  seed's surface and report a per-seed non-empty-mesh count, so an empty cube can't count as a pass.
+- Re-run by me: `VoxelForgeCoreHeadless-clang19-l2-off`, W12, plain 8 MiB `ulimit -s`, L1 view:
+  whole view 3.361 s, hashes `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724`.
+- **Consequence of the contraction table:** Core's world now provably depends on the toolchain's FP-contract
+  setting, which every build outside `Build.ps1`/`BuildLinux.sh` (UBT on Windows and Linux) sets for itself.
+  Next: make Core immune to, or loudly detect, contraction instead of relying on flags.

Standalone/Research/WorldAssemblerM3/Linux2/RunSeedSweep.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Run the deterministic Linux2 seed/compiler/worker matrix under the owner limits."""
+import csv
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path.cwd()
+ROUND = ROOT / "Standalone/Research/WorldAssemblerM3/Linux2"
+LOG_DIR = ROOT / "Saved/Linux"
+MEASURE = ROUND / "MeasureProcess.py"
+DATA = ROOT / "Standalone/data/owner_world.json"
+BINARIES = {
+    "clang19": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-clang19-l2-off",
+    "gcc14": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-gcc14-l2-off",
+}
+CAMERAS = {
+    "surface-world": "0,-35,-487.94,0,-22",
+    "floating-islands": "0,0,-32,0,-22",
+}
+HASH_RE = re.compile(
+    r"\[PipelineWholeViewHash\] tiles=(\d+) density=0x([0-9a-f]+) "
+    r"mesh=0x([0-9a-f]+) payload=0x([0-9a-f]+) topology=0x([0-9a-f]+)"
+)
+VOLUME_RE = re.compile(
+    r"\[PipelineVolume\] tiles=(\d+) lod=(\d+)\.\.(\d+) "
+    r"min_voxel=\((-?\d+),(-?\d+),(-?\d+)\) "
+    r"max_voxel=\((-?\d+),(-?\d+),(-?\d+)\)"
+)
+READY_RE = re.compile(r"\[StreamPipeline\].*whole_view_ready=([0-9.]+)s")
+RESOURCE_RE = re.compile(r"\[ProcessResources\] exit_code=(-?\d+) wall_s=([0-9.]+) peak_rss_kib=(\d+)")
+
+
+def main() -> int:
+    if not (1 <= len(sys.argv) <= 2):
+        raise SystemExit("usage: RunSeedSweep.py [budget-seconds; default 1800]")
+    budget_seconds = int(sys.argv[1]) if len(sys.argv) == 2 else 1800
+    seeds = [int(line.strip()) for line in (ROUND / "seeds.txt").read_text().splitlines() if line.strip()]
+    if len(seeds) != 48 or len(set(seeds)) != len(seeds):
+        raise SystemExit("seeds.txt must contain 48 unique signed int32 seeds")
+    missing = [str(path) for path in [MEASURE, DATA, *BINARIES.values()] if not path.is_file()]
+    if missing:
+        raise SystemExit("missing sweep input/build: " + ", ".join(missing))
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    output_path = ROUND / "seed_hashes.csv"
+    fields = [
+        "seed", "recipe", "compiler", "workers", "tiles", "lod_min", "lod_max",
+        "min_x", "min_y", "min_z", "max_x", "max_y", "max_z",
+        "density_hash", "mesh_hash", "payload_hash", "topology_hash",
+        "whole_view_ready_s", "wall_s", "peak_rss_kib", "exit_code", "status",
+    ]
+    started = time.monotonic()
+    total = len(seeds) * len(CAMERAS) * len(BINARIES) * 2
+    print(f"Sweep: {len(seeds)} seeds × 2 recipes × 2 compilers × W1/W12 = {total} runs; budget={budget_seconds}s", flush=True)
+
+    with output_path.open("w", newline="") as csv_file:
+        writer = csv.DictWriter(csv_file, fieldnames=fields)
+        writer.writeheader()
+        for seed in seeds:
+            for recipe, camera in CAMERAS.items():
+                for compiler, binary in BINARIES.items():
+                    for workers in (1, 12):
+                        remaining = budget_seconds - (time.monotonic() - started)
+                        if remaining <= 0:
+                            print("Sweep exceeded its 30 minute budget; stopping.", file=sys.stderr, flush=True)
+                            return 124
+                        stem = f"linux2-seed-{seed}-{recipe}-{compiler}-w{workers}"
+                        log_path = LOG_DIR / f"{stem}.log"
+                        args = [
+                            str(binary), str(DATA), f"--seed={seed}", f"--recipe={recipe}",
+                            "--render-distance-chunks=0", f"--workers={workers}",
+                            "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+                            "--stream-hash", "--force-generate", "--clip-radius=1",
+                            "--max-clip-level=0", f"--camera={camera}", "--far-horizon-lod8-step=0",
+                        ]
+                        command = [
+                            "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+                            "python3", str(MEASURE), *args,
+                        ]
+                        with log_path.open("w") as log_file:
+                            log_file.write("[SweepCommand] " + " ".join(command) + "\n")
+                            log_file.flush()
+                            try:
+                                result = subprocess.run(
+                                    command, cwd=ROOT, stdout=log_file, stderr=subprocess.STDOUT,
+                                    timeout=min(900, max(1, remaining)), check=False,
+                                )
+                                exit_code = result.returncode
+                            except subprocess.TimeoutExpired:
+                                exit_code = 124
+                                log_file.write("\n[SweepTimeout] run reached its allotted limit\n")
+
+                        output = log_path.read_text(errors="replace")
+                        volume = VOLUME_RE.search(output)
+                        hashes = HASH_RE.search(output)
+                        ready = READY_RE.search(output)
+                        resources = RESOURCE_RE.search(output)
+                        passed = exit_code == 0 and volume and hashes and ready and resources
+                        row = {
+                            "seed": seed, "recipe": recipe, "compiler": compiler, "workers": workers,
+                            "tiles": "", "lod_min": "", "lod_max": "",
+                            "min_x": "", "min_y": "", "min_z": "", "max_x": "", "max_y": "", "max_z": "",
+                            "density_hash": "", "mesh_hash": "", "payload_hash": "", "topology_hash": "",
+                            "whole_view_ready_s": "", "wall_s": "", "peak_rss_kib": "",
+                            "exit_code": exit_code, "status": "PASS" if passed else "FAIL",
+                        }
+                        if passed:
+                            row.update({
+                                "tiles": hashes.group(1),
+                                "lod_min": volume.group(2), "lod_max": volume.group(3),
+                                "min_x": volume.group(4), "min_y": volume.group(5), "min_z": volume.group(6),
+                                "max_x": volume.group(7), "max_y": volume.group(8), "max_z": volume.group(9),
+                                "density_hash": "0x" + hashes.group(2), "mesh_hash": "0x" + hashes.group(3),
+                                "payload_hash": "0x" + hashes.group(4), "topology_hash": "0x" + hashes.group(5),
+                                "whole_view_ready_s": ready.group(1), "wall_s": resources.group(2),
+                                "peak_rss_kib": resources.group(3),
+                            })
+                        writer.writerow(row)
+                        csv_file.flush()
+                        completed = sum(1 for _ in output_path.open()) - 1
+                        elapsed = time.monotonic() - started
+                        print(f"[{completed}/{total}] seed={seed} recipe={recipe} compiler={compiler} W{workers} "
+                              f"tiles={row['tiles']} wall={row['wall_s']}s status={row['status']} "
+                              f"elapsed={elapsed:.1f}s", flush=True)
+                        if not passed:
+                            print(f"Run failed; details: {log_path}", file=sys.stderr, flush=True)
+                            return exit_code or 1
+
+    rows = list(csv.DictReader(output_path.open(newline="")))
+    keys = ("density_hash", "mesh_hash", "payload_hash", "topology_hash")
+    checks = []
+    for seed in seeds:
+        for recipe in CAMERAS:
+            for workers in (1, 12):
+                pair = [r for r in rows if int(r["seed"]) == seed and r["recipe"] == recipe
+                        and int(r["workers"]) == workers]
+                equal = len(pair) == 2 and all(pair[0][key] == pair[1][key] for key in keys)
+                checks.append((seed, recipe, workers, equal))
+    worker_checks = []
+    for seed in seeds:
+        for recipe in CAMERAS:
+            for compiler in BINARIES:
+                pair = [r for r in rows if int(r["seed"]) == seed and r["recipe"] == recipe
+                        and r["compiler"] == compiler]
+                equal = len(pair) == 2 and all(pair[0][key] == pair[1][key] for key in keys)
+                worker_checks.append((seed, recipe, compiler, equal))
+    summary_path = ROUND / "seed_sweep_summary.txt"
+    mismatch_count = sum(not equal for _, _, _, equal in checks)
+    worker_mismatch_count = sum(not equal for _, _, _, equal in worker_checks)
+    summary_path.write_text(
+        f"runs={len(rows)} seeds={len(seeds)} recipes={len(CAMERAS)} compilers={len(BINARIES)} "
+        f"workers=1,12 cross_compiler_comparisons={len(checks)} cross_compiler_mismatches={mismatch_count} "
+        f"cross_worker_comparisons={len(worker_checks)} cross_worker_mismatches={worker_mismatch_count} "
+        f"elapsed_s={time.monotonic()-started:.3f}\n"
+    )
+    print(summary_path.read_text(), end="", flush=True)
+    return 0 if mismatch_count == 0 and worker_mismatch_count == 0 else 3
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Standalone/Research/WorldAssemblerM3/Linux2/WindowsReplay.ps1

@@ -0,0 +1,46 @@
+$ErrorActionPreference = 'Stop'
+$Root = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\..\..\..'))
+$Viewer = Join-Path $Root 'Standalone\bin\VoxelForgeCoreStandalone.exe'
+$Data = Join-Path $Root 'Standalone\data\owner_world.json'
+$SeedFile = Join-Path $PSScriptRoot 'seeds.txt'
+$LogDir = Join-Path $Root 'Saved\Linux'
+[IO.Directory]::CreateDirectory($LogDir) | Out-Null
+
+$Recipes = @(
+    @{ Name = 'surface-world'; Camera = '0,-35,-487.94,0,-22' },
+    @{ Name = 'floating-islands'; Camera = '0,0,-32,0,-22' }
+)
+$Seeds = @(Get-Content -LiteralPath $SeedFile | ForEach-Object { [int]$_.Trim() })
+if ($Seeds.Count -ne 48) { throw "Expected 48 seeds in $SeedFile" }
+if (-not (Test-Path -LiteralPath $Viewer -PathType Leaf)) { throw "Viewer not found: $Viewer" }
+
+foreach ($Recipe in $Recipes) {
+    foreach ($Seed in $Seeds) {
+        foreach ($Workers in @(1, 12)) {
+            $Arguments = @(
+                $Data,
+                "--seed=$Seed",
+                "--recipe=$($Recipe.Name)",
+                '--render-distance-chunks=0',
+                "--workers=$Workers",
+                '--world-assembler-prototype',
+                '--stream-benchmark',
+                '--stream-pipeline',
+                '--stream-hash',
+                '--force-generate',
+                '--clip-radius=1',
+                '--max-clip-level=0',
+                "--camera=$($Recipe.Camera)",
+                '--far-horizon-lod8-step=0',
+                '--process-affinity=4095',
+                '--process-priority=Normal',
+                '--frame-limit=60'
+            )
+            $Stem = "windows2-seed-$Seed-$($Recipe.Name)-w$Workers"
+            $Log = Join-Path $LogDir "$Stem.log"
+            Write-Host "& `"$Viewer`" $($Arguments -join ' ')"
+            & $Viewer @Arguments *> $Log
+            if ($LASTEXITCODE -ne 0) { throw "Viewer failed ($LASTEXITCODE); see $Log" }
+        }
+    }
+}

Standalone/Research/WorldAssemblerM3/Linux2/seed_hashes.csv

@@ -0,0 +1,385 @@
+seed,recipe,compiler,workers,tiles,lod_min,lod_max,min_x,min_y,min_z,max_x,max_y,max_z,density_hash,mesh_hash,payload_hash,topology_hash,whole_view_ready_s,wall_s,peak_rss_kib,exit_code,status
+-1990830953,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.124,0.139871,82432,0,PASS
+-1990830953,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.447,0.472868,277576,0,PASS
+-1990830953,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.104,0.120573,83292,0,PASS
+-1990830953,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.418,0.444282,277964,0,PASS
+-1990830953,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xbd4dd4a500b8d62e,0xe1d28012b857510b,0x3ecc1269ee435844,0x10c100e1503e62f6,0.913,0.929393,83896,0,PASS
+-1990830953,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xbd4dd4a500b8d62e,0xe1d28012b857510b,0x3ecc1269ee435844,0x10c100e1503e62f6,0.611,0.639175,286112,0,PASS
+-1990830953,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xbd4dd4a500b8d62e,0xe1d28012b857510b,0x3ecc1269ee435844,0x10c100e1503e62f6,1.007,1.024022,84836,0,PASS
+-1990830953,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xbd4dd4a500b8d62e,0xe1d28012b857510b,0x3ecc1269ee435844,0x10c100e1503e62f6,0.604,0.631134,287396,0,PASS
+-1900684165,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.122,0.138823,87580,0,PASS
+-1900684165,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.443,0.470531,282936,0,PASS
+-1900684165,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.115,0.131311,88568,0,PASS
+-1900684165,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.430,0.455647,283260,0,PASS
+-1900684165,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x6579d1933b1981fa,0xfd19fc2d3a0c84b3,0xb8c9aa5ec03bea15,0x854620bb0b15a2da,1.468,1.485107,88252,0,PASS
+-1900684165,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x6579d1933b1981fa,0xfd19fc2d3a0c84b3,0xb8c9aa5ec03bea15,0x854620bb0b15a2da,0.724,0.749926,291776,0,PASS
+-1900684165,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x6579d1933b1981fa,0xfd19fc2d3a0c84b3,0xb8c9aa5ec03bea15,0x854620bb0b15a2da,1.654,1.671498,88740,0,PASS
+-1900684165,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x6579d1933b1981fa,0xfd19fc2d3a0c84b3,0xb8c9aa5ec03bea15,0x854620bb0b15a2da,0.722,0.748795,292444,0,PASS
+-1766412538,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.123,0.139772,82472,0,PASS
+-1766412538,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.421,0.446302,277376,0,PASS
+-1766412538,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.118,0.135907,82932,0,PASS
+-1766412538,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.413,0.439059,278060,0,PASS
+-1766412538,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x2a92f5e32e60e02f,0x8f64e72825b53b77,0xc8ef053d65d9a8f2,0xf908b7c927a221be,1.182,1.198659,83916,0,PASS
+-1766412538,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x2a92f5e32e60e02f,0x8f64e72825b53b77,0xc8ef053d65d9a8f2,0xf908b7c927a221be,0.635,0.661517,288544,0,PASS
+-1766412538,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x2a92f5e32e60e02f,0x8f64e72825b53b77,0xc8ef053d65d9a8f2,0xf908b7c927a221be,1.217,1.234070,84676,0,PASS
+-1766412538,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x2a92f5e32e60e02f,0x8f64e72825b53b77,0xc8ef053d65d9a8f2,0xf908b7c927a221be,0.641,0.668605,289160,0,PASS
+-1721984596,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.120,0.135727,82528,0,PASS
+-1721984596,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.412,0.437074,277672,0,PASS
+-1721984596,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.111,0.126643,83176,0,PASS
+-1721984596,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.419,0.443825,278120,0,PASS
+-1721984596,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x232835b6d49194bf,0x1caaf34cc5d6cd64,0x03053c530184f232,0xb660395e0dc7fd90,1.217,1.234173,84404,0,PASS
+-1721984596,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x232835b6d49194bf,0x1caaf34cc5d6cd64,0x03053c530184f232,0xb660395e0dc7fd90,0.637,0.663034,287872,0,PASS
+-1721984596,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x232835b6d49194bf,0x1caaf34cc5d6cd64,0x03053c530184f232,0xb660395e0dc7fd90,1.317,1.333028,84808,0,PASS
+-1721984596,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x232835b6d49194bf,0x1caaf34cc5d6cd64,0x03053c530184f232,0xb660395e0dc7fd90,0.655,0.681308,287700,0,PASS
+-1239598758,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x0bf609e90c8c98cd,0x73cd83a10b4aada9,0x4eba3fd151b267a4,0x559a118b768faf58,0.298,0.314757,83276,0,PASS
+-1239598758,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x0bf609e90c8c98cd,0x73cd83a10b4aada9,0x4eba3fd151b267a4,0x559a118b768faf58,0.445,0.471042,288560,0,PASS
+-1239598758,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x0bf609e90c8c98cd,0x73cd83a10b4aada9,0x4eba3fd151b267a4,0x559a118b768faf58,0.285,0.301659,84036,0,PASS
+-1239598758,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x0bf609e90c8c98cd,0x73cd83a10b4aada9,0x4eba3fd151b267a4,0x559a118b768faf58,0.443,0.468361,288380,0,PASS
+-1239598758,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x13ec8dd8009a6ca3,0xa834791c4bf4a3a6,0xf75429e19a3d3f57,0xec51f6ca14f0103f,1.387,1.403191,84688,0,PASS
+-1239598758,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x13ec8dd8009a6ca3,0xa834791c4bf4a3a6,0xf75429e19a3d3f57,0xec51f6ca14f0103f,0.673,0.699757,289244,0,PASS
+-1239598758,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x13ec8dd8009a6ca3,0xa834791c4bf4a3a6,0xf75429e19a3d3f57,0xec51f6ca14f0103f,1.443,1.458164,85260,0,PASS
+-1239598758,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x13ec8dd8009a6ca3,0xa834791c4bf4a3a6,0xf75429e19a3d3f57,0xec51f6ca14f0103f,0.687,0.712986,289888,0,PASS
+-1085993262,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x58d4e8746928d967,0x40dd37203989d7ba,0x912a7f27bda7e867,0x3aaea1143bebf060,0.146,0.161610,83596,0,PASS
+-1085993262,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x58d4e8746928d967,0x40dd37203989d7ba,0x912a7f27bda7e867,0x3aaea1143bebf060,0.434,0.459626,280092,0,PASS
+-1085993262,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x58d4e8746928d967,0x40dd37203989d7ba,0x912a7f27bda7e867,0x3aaea1143bebf060,0.137,0.155311,84108,0,PASS
+-1085993262,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x58d4e8746928d967,0x40dd37203989d7ba,0x912a7f27bda7e867,0x3aaea1143bebf060,0.429,0.457999,280480,0,PASS
+-1085993262,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x2f2773f2a0da46ab,0x3bc615085f3da506,0xf696b9a9fcf6e3e6,0x7726f0e025442908,1.270,1.286525,86016,0,PASS
+-1085993262,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x2f2773f2a0da46ab,0x3bc615085f3da506,0xf696b9a9fcf6e3e6,0x7726f0e025442908,0.627,0.653909,289560,0,PASS
+-1085993262,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x2f2773f2a0da46ab,0x3bc615085f3da506,0xf696b9a9fcf6e3e6,0x7726f0e025442908,1.410,1.427078,86780,0,PASS
+-1085993262,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x2f2773f2a0da46ab,0x3bc615085f3da506,0xf696b9a9fcf6e3e6,0x7726f0e025442908,0.648,0.673667,290288,0,PASS
+-1033703345,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x5e33a829837b74bd,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.153,0.171501,82920,0,PASS
+-1033703345,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x5e33a829837b74bd,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.433,0.459168,278696,0,PASS
+-1033703345,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x5e33a829837b74bd,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.146,0.161211,83612,0,PASS
+-1033703345,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x5e33a829837b74bd,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.436,0.462555,279276,0,PASS
+-1033703345,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x65b606ed9df8b9dd,0x874360dc2d5480ad,0xe1a7c4c63c916b8a,0xf8bfac0093f57137,2.179,2.196290,84960,0,PASS
+-1033703345,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x65b606ed9df8b9dd,0x874360dc2d5480ad,0xe1a7c4c63c916b8a,0xf8bfac0093f57137,0.837,0.862488,286132,0,PASS
+-1033703345,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x65b606ed9df8b9dd,0x874360dc2d5480ad,0xe1a7c4c63c916b8a,0xf8bfac0093f57137,2.229,2.245540,85384,0,PASS
+-1033703345,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x65b606ed9df8b9dd,0x874360dc2d5480ad,0xe1a7c4c63c916b8a,0xf8bfac0093f57137,0.854,0.878634,286968,0,PASS
+-854671705,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.168,0.184503,81968,0,PASS
+-854671705,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.458,0.482105,276888,0,PASS
+-854671705,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.156,0.172642,82296,0,PASS
+-854671705,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.440,0.463845,277156,0,PASS
+-854671705,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xb324a85fd9f31fa1,0x92f35776d53f0bbe,0x5b4e0dc015e5a4b1,0x3dcce3ff950e5940,1.997,2.014139,83980,0,PASS
+-854671705,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xb324a85fd9f31fa1,0x92f35776d53f0bbe,0x5b4e0dc015e5a4b1,0x3dcce3ff950e5940,0.777,0.803614,286988,0,PASS
+-854671705,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xb324a85fd9f31fa1,0x92f35776d53f0bbe,0x5b4e0dc015e5a4b1,0x3dcce3ff950e5940,1.975,1.991424,84460,0,PASS
+-854671705,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xb324a85fd9f31fa1,0x92f35776d53f0bbe,0x5b4e0dc015e5a4b1,0x3dcce3ff950e5940,0.827,0.853700,287876,0,PASS
+-713963806,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.116,0.133079,83972,0,PASS
+-713963806,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.403,0.432000,278940,0,PASS
+-713963806,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.103,0.119423,84248,0,PASS
+-713963806,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.395,0.419569,279096,0,PASS
+-713963806,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x38a60c8389c671eb,0xcbca321fa24f4d74,0x6aa8ea9d8c735dbb,0x8b9d8e479ea5329e,1.614,1.634105,84584,0,PASS
+-713963806,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x38a60c8389c671eb,0xcbca321fa24f4d74,0x6aa8ea9d8c735dbb,0x8b9d8e479ea5329e,0.696,0.722153,287504,0,PASS
+-713963806,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x38a60c8389c671eb,0xcbca321fa24f4d74,0x6aa8ea9d8c735dbb,0x8b9d8e479ea5329e,1.642,1.658169,84804,0,PASS
+-713963806,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x38a60c8389c671eb,0xcbca321fa24f4d74,0x6aa8ea9d8c735dbb,0x8b9d8e479ea5329e,0.702,0.728362,287544,0,PASS
+-621039221,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.108,0.123847,84240,0,PASS
+-621039221,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.404,0.429052,279360,0,PASS
+-621039221,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.097,0.114239,84872,0,PASS
+-621039221,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.418,0.445942,279796,0,PASS
+-621039221,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xa70bd050fb2e002e,0x93c9bfa37a0cd298,0x5fd74cd54a52292b,0x194b571023058cf7,1.740,1.756998,85916,0,PASS
+-621039221,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xa70bd050fb2e002e,0x93c9bfa37a0cd298,0x5fd74cd54a52292b,0x194b571023058cf7,0.736,0.762822,290788,0,PASS
+-621039221,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xa70bd050fb2e002e,0x93c9bfa37a0cd298,0x5fd74cd54a52292b,0x194b571023058cf7,1.779,1.795250,86420,0,PASS
+-621039221,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xa70bd050fb2e002e,0x93c9bfa37a0cd298,0x5fd74cd54a52292b,0x194b571023058cf7,0.767,0.793669,291496,0,PASS
+-474448608,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.112,0.126682,82408,0,PASS
+-474448608,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.420,0.445710,277208,0,PASS
+-474448608,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.114,0.131780,83016,0,PASS
+-474448608,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.408,0.434334,277788,0,PASS
+-474448608,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x80da251d7da20717,0x54a773cac2ae0da4,0xb42e970d98e5e448,0x08d56fddf5a487d6,1.639,1.655937,85268,0,PASS
+-474448608,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x80da251d7da20717,0x54a773cac2ae0da4,0xb42e970d98e5e448,0x08d56fddf5a487d6,0.748,0.775722,289208,0,PASS
+-474448608,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x80da251d7da20717,0x54a773cac2ae0da4,0xb42e970d98e5e448,0x08d56fddf5a487d6,1.756,1.771783,86096,0,PASS
+-474448608,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x80da251d7da20717,0x54a773cac2ae0da4,0xb42e970d98e5e448,0x08d56fddf5a487d6,0.758,0.784193,289568,0,PASS
+-432690581,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x1e3b98fa361c46b9,0x510dd77a7ca94d0e,0x4e6917a7b06f3f41,0x09791c912e85d14a,0.249,0.264467,83624,0,PASS
+-432690581,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x1e3b98fa361c46b9,0x510dd77a7ca94d0e,0x4e6917a7b06f3f41,0x09791c912e85d14a,0.457,0.482472,286124,0,PASS
+-432690581,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x1e3b98fa361c46b9,0x510dd77a7ca94d0e,0x4e6917a7b06f3f41,0x09791c912e85d14a,0.251,0.267531,83844,0,PASS
+-432690581,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x1e3b98fa361c46b9,0x510dd77a7ca94d0e,0x4e6917a7b06f3f41,0x09791c912e85d14a,0.456,0.481234,286612,0,PASS
+-432690581,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x85185a56cb2ff97a,0x656076e11a4da13b,0x708d7e58be02ab16,0xfa20cfd819664d48,1.465,1.481966,84272,0,PASS
+-432690581,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x85185a56cb2ff97a,0x656076e11a4da13b,0x708d7e58be02ab16,0xfa20cfd819664d48,0.651,0.678094,286596,0,PASS
+-432690581,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x85185a56cb2ff97a,0x656076e11a4da13b,0x708d7e58be02ab16,0xfa20cfd819664d48,1.518,1.534396,84508,0,PASS
+-432690581,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x85185a56cb2ff97a,0x656076e11a4da13b,0x708d7e58be02ab16,0xfa20cfd819664d48,0.675,0.700961,287236,0,PASS
+-380556572,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.122,0.138061,83744,0,PASS
+-380556572,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.419,0.443950,278968,0,PASS
+-380556572,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.119,0.136000,84296,0,PASS
+-380556572,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.409,0.435025,279452,0,PASS
+-380556572,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x18cb13a590f41d1f,0xdb9b7450859f053a,0x5dc9ac331ba35450,0x8cda9fbcede81e46,0.903,0.918921,85380,0,PASS
+-380556572,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x18cb13a590f41d1f,0xdb9b7450859f053a,0x5dc9ac331ba35450,0x8cda9fbcede81e46,0.587,0.614393,289360,0,PASS
+-380556572,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x18cb13a590f41d1f,0xdb9b7450859f053a,0x5dc9ac331ba35450,0x8cda9fbcede81e46,0.983,0.998686,85572,0,PASS
+-380556572,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x18cb13a590f41d1f,0xdb9b7450859f053a,0x5dc9ac331ba35450,0x8cda9fbcede81e46,0.567,0.592607,290168,0,PASS
+-238925630,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.106,0.121729,82080,0,PASS
+-238925630,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.426,0.453650,277360,0,PASS
+-238925630,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.106,0.120742,82848,0,PASS
+-238925630,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.391,0.417157,277784,0,PASS
+-238925630,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x3b99d22e2baa2ad7,0xf8a56dd82f8dbe0f,0x91fbb129908c4373,0x0d0d12d4bc8eca05,2.159,2.174883,84956,0,PASS
+-238925630,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x3b99d22e2baa2ad7,0xf8a56dd82f8dbe0f,0x91fbb129908c4373,0x0d0d12d4bc8eca05,0.798,0.823378,286820,0,PASS
+-238925630,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x3b99d22e2baa2ad7,0xf8a56dd82f8dbe0f,0x91fbb129908c4373,0x0d0d12d4bc8eca05,2.135,2.151003,86032,0,PASS
+-238925630,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x3b99d22e2baa2ad7,0xf8a56dd82f8dbe0f,0x91fbb129908c4373,0x0d0d12d4bc8eca05,0.848,0.872951,287200,0,PASS
+-216679974,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.113,0.128975,84840,0,PASS
+-216679974,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.424,0.448196,279868,0,PASS
+-216679974,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.110,0.125699,85388,0,PASS
+-216679974,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.419,0.443897,280212,0,PASS
+-216679974,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x329264ded82099ac,0x4fe355cb337a1fd9,0x0f1cf173f8b6da09,0x29c9025339a1891c,1.154,1.170155,87404,0,PASS
+-216679974,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x329264ded82099ac,0x4fe355cb337a1fd9,0x0f1cf173f8b6da09,0x29c9025339a1891c,0.599,0.627832,291380,0,PASS
+-216679974,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x329264ded82099ac,0x4fe355cb337a1fd9,0x0f1cf173f8b6da09,0x29c9025339a1891c,1.244,1.260024,88080,0,PASS
+-216679974,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x329264ded82099ac,0x4fe355cb337a1fd9,0x0f1cf173f8b6da09,0x29c9025339a1891c,0.652,0.682174,292220,0,PASS
+-133096164,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.120,0.137668,83564,0,PASS
+-133096164,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.416,0.440317,278792,0,PASS
+-133096164,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.112,0.129823,84168,0,PASS
+-133096164,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.407,0.430509,278888,0,PASS
+-133096164,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xd365848036423e24,0x8357d602689e662a,0x71d6cc040cfb374d,0xe50280db1b51428d,0.922,0.937785,84360,0,PASS
+-133096164,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xd365848036423e24,0x8357d602689e662a,0x71d6cc040cfb374d,0xe50280db1b51428d,0.589,0.618394,288344,0,PASS
+-133096164,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xd365848036423e24,0x8357d602689e662a,0x71d6cc040cfb374d,0xe50280db1b51428d,1.012,1.027635,84716,0,PASS
+-133096164,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xd365848036423e24,0x8357d602689e662a,0x71d6cc040cfb374d,0xe50280db1b51428d,0.635,0.660045,288680,0,PASS
+-112366806,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x117219c29ee67785,0x997b517646187e1a,0x85cb430517cbbf42,0x685ea038d9f06065,0.243,0.260958,84464,0,PASS
+-112366806,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x117219c29ee67785,0x997b517646187e1a,0x85cb430517cbbf42,0x685ea038d9f06065,0.493,0.519148,283500,0,PASS
+-112366806,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x117219c29ee67785,0x997b517646187e1a,0x85cb430517cbbf42,0x685ea038d9f06065,0.227,0.243726,84772,0,PASS
+-112366806,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x117219c29ee67785,0x997b517646187e1a,0x85cb430517cbbf42,0x685ea038d9f06065,0.465,0.489473,284084,0,PASS
+-112366806,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x9014ca6f9bc869cb,0x8b4f78faf1311e89,0x9556cf42e66d3d0a,0x74d6915603c033ad,1.309,1.326524,85228,0,PASS
+-112366806,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x9014ca6f9bc869cb,0x8b4f78faf1311e89,0x9556cf42e66d3d0a,0x74d6915603c033ad,0.701,0.726986,287836,0,PASS
+-112366806,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x9014ca6f9bc869cb,0x8b4f78faf1311e89,0x9556cf42e66d3d0a,0x74d6915603c033ad,1.395,1.411147,85016,0,PASS
+-112366806,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x9014ca6f9bc869cb,0x8b4f78faf1311e89,0x9556cf42e66d3d0a,0x74d6915603c033ad,0.739,0.765027,288736,0,PASS
+0,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.119,0.135072,84800,0,PASS
+0,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.426,0.451782,279552,0,PASS
+0,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.113,0.128723,84848,0,PASS
+0,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.420,0.445716,280480,0,PASS
+0,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xea74d3354b5ce671,0x476d49ae2a4ba2a6,0x16078fcd36b68ff0,0xcfb6c412b7118172,1.559,1.574177,85036,0,PASS
+0,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xea74d3354b5ce671,0x476d49ae2a4ba2a6,0x16078fcd36b68ff0,0xcfb6c412b7118172,0.717,0.744287,287992,0,PASS
+0,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xea74d3354b5ce671,0x476d49ae2a4ba2a6,0x16078fcd36b68ff0,0xcfb6c412b7118172,1.736,1.751668,85428,0,PASS
+0,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xea74d3354b5ce671,0x476d49ae2a4ba2a6,0x16078fcd36b68ff0,0xcfb6c412b7118172,0.739,0.765220,288024,0,PASS
+5808593,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.138,0.152855,82892,0,PASS
+5808593,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.442,0.467475,277756,0,PASS
+5808593,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.135,0.152123,83220,0,PASS
+5808593,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.455,0.480133,278336,0,PASS
+5808593,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xebd71c4fe9dd2dc6,0x9ffa12a70e6f7875,0x1a4ca0cc9847ee58,0xf19d80d6dd09e180,1.035,1.051725,84148,0,PASS
+5808593,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xebd71c4fe9dd2dc6,0x9ffa12a70e6f7875,0x1a4ca0cc9847ee58,0xf19d80d6dd09e180,0.590,0.616756,287312,0,PASS
+5808593,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xebd71c4fe9dd2dc6,0x9ffa12a70e6f7875,0x1a4ca0cc9847ee58,0xf19d80d6dd09e180,1.066,1.081777,85048,0,PASS
+5808593,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xebd71c4fe9dd2dc6,0x9ffa12a70e6f7875,0x1a4ca0cc9847ee58,0xf19d80d6dd09e180,0.607,0.633661,287888,0,PASS
+28573228,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.114,0.129946,83304,0,PASS
+28573228,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.413,0.438628,278012,0,PASS
+28573228,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.106,0.121266,83976,0,PASS
+28573228,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.405,0.430367,278532,0,PASS
+28573228,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x8bc79bd6b4d338f9,0xac4276d07d65ceb0,0x357351bb0d2f1cb8,0x900a254512dfc430,1.328,1.344479,84096,0,PASS
+28573228,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x8bc79bd6b4d338f9,0xac4276d07d65ceb0,0x357351bb0d2f1cb8,0x900a254512dfc430,0.657,0.682189,287896,0,PASS
+28573228,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x8bc79bd6b4d338f9,0xac4276d07d65ceb0,0x357351bb0d2f1cb8,0x900a254512dfc430,1.475,1.493744,84604,0,PASS
+28573228,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x8bc79bd6b4d338f9,0xac4276d07d65ceb0,0x357351bb0d2f1cb8,0x900a254512dfc430,0.688,0.715502,288240,0,PASS
+70955227,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.122,0.139162,83836,0,PASS
+70955227,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.419,0.446187,279048,0,PASS
+70955227,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.118,0.133338,84804,0,PASS
+70955227,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.405,0.428654,279540,0,PASS
+70955227,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xdaf7faa124800a90,0x0e2038b6f58233ec,0x9df861ebdd4ad5a0,0x50b94b2a529261d7,1.560,1.576865,86016,0,PASS
+70955227,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xdaf7faa124800a90,0x0e2038b6f58233ec,0x9df861ebdd4ad5a0,0x50b94b2a529261d7,0.849,0.882918,288164,0,PASS
+70955227,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xdaf7faa124800a90,0x0e2038b6f58233ec,0x9df861ebdd4ad5a0,0x50b94b2a529261d7,1.635,1.651152,86548,0,PASS
+70955227,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xdaf7faa124800a90,0x0e2038b6f58233ec,0x9df861ebdd4ad5a0,0x50b94b2a529261d7,0.767,0.793113,288924,0,PASS
+75274690,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.112,0.129015,83520,0,PASS
+75274690,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.405,0.432266,278808,0,PASS
+75274690,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.107,0.122969,84248,0,PASS
+75274690,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.400,0.425046,279232,0,PASS
+75274690,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xdf250106794ae38c,0x76706ba6a26f55ce,0x533b1070a58f2158,0x4f2ac497b8e00d2c,1.140,1.158530,86028,0,PASS
+75274690,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xdf250106794ae38c,0x76706ba6a26f55ce,0x533b1070a58f2158,0x4f2ac497b8e00d2c,0.635,0.661364,290020,0,PASS
+75274690,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xdf250106794ae38c,0x76706ba6a26f55ce,0x533b1070a58f2158,0x4f2ac497b8e00d2c,1.237,1.253451,86900,0,PASS
+75274690,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xdf250106794ae38c,0x76706ba6a26f55ce,0x533b1070a58f2158,0x4f2ac497b8e00d2c,0.629,0.657284,290424,0,PASS
+81375760,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x55d1e034d67632f5,0xf493f363535135e7,0xf1081c7533a6b533,0x24c1ef771b2e29df,0.302,0.321425,84348,0,PASS
+81375760,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x55d1e034d67632f5,0xf493f363535135e7,0xf1081c7533a6b533,0x24c1ef771b2e29df,0.473,0.498702,288596,0,PASS
+81375760,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x55d1e034d67632f5,0xf493f363535135e7,0xf1081c7533a6b533,0x24c1ef771b2e29df,0.284,0.300131,84776,0,PASS
+81375760,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x55d1e034d67632f5,0xf493f363535135e7,0xf1081c7533a6b533,0x24c1ef771b2e29df,0.465,0.493912,289032,0,PASS
+81375760,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x5e5bc1daf1855a5d,0x6d9a375c60771dd6,0x0e23381363a677c9,0xcd4cbbab580c6da6,1.644,1.660225,85756,0,PASS
+81375760,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x5e5bc1daf1855a5d,0x6d9a375c60771dd6,0x0e23381363a677c9,0xcd4cbbab580c6da6,0.738,0.765107,289596,0,PASS
+81375760,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x5e5bc1daf1855a5d,0x6d9a375c60771dd6,0x0e23381363a677c9,0xcd4cbbab580c6da6,1.724,1.741866,86704,0,PASS
+81375760,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x5e5bc1daf1855a5d,0x6d9a375c60771dd6,0x0e23381363a677c9,0xcd4cbbab580c6da6,0.751,0.778126,289620,0,PASS
+146979566,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x28dc20a8ab6fb2d0,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.146,0.162199,83420,0,PASS
+146979566,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x28dc20a8ab6fb2d0,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.407,0.434165,281384,0,PASS
+146979566,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x28dc20a8ab6fb2d0,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.154,0.171817,84220,0,PASS
+146979566,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x28dc20a8ab6fb2d0,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.404,0.429003,282144,0,PASS
+146979566,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xac33a725e13e3886,0x86611ee4c12947c9,0x2991daf2b7f1f2e4,0x91e98f0e880b1f3d,1.638,1.654237,86300,0,PASS
+146979566,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xac33a725e13e3886,0x86611ee4c12947c9,0x2991daf2b7f1f2e4,0x91e98f0e880b1f3d,0.698,0.725703,289448,0,PASS
+146979566,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xac33a725e13e3886,0x86611ee4c12947c9,0x2991daf2b7f1f2e4,0x91e98f0e880b1f3d,1.845,1.861845,86680,0,PASS
+146979566,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xac33a725e13e3886,0x86611ee4c12947c9,0x2991daf2b7f1f2e4,0x91e98f0e880b1f3d,0.759,0.786078,290128,0,PASS
+244951180,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x1cc26cbbf38ba8e9,0xeaace7e8b8443be0,0x61a9b62f2967c453,0xd0358bf6bbc94bb9,0.195,0.213011,86480,0,PASS
+244951180,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x1cc26cbbf38ba8e9,0xeaace7e8b8443be0,0x61a9b62f2967c453,0xd0358bf6bbc94bb9,0.452,0.479860,284556,0,PASS
+244951180,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x1cc26cbbf38ba8e9,0xeaace7e8b8443be0,0x61a9b62f2967c453,0xd0358bf6bbc94bb9,0.181,0.197358,87220,0,PASS
+244951180,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x1cc26cbbf38ba8e9,0xeaace7e8b8443be0,0x61a9b62f2967c453,0xd0358bf6bbc94bb9,0.434,0.459596,284852,0,PASS
+244951180,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x8bd265dfa2c428c4,0x47904e96f2a9213c,0xa9683a3e3251c768,0x585c686bcfe6be65,1.121,1.137204,86652,0,PASS
+244951180,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x8bd265dfa2c428c4,0x47904e96f2a9213c,0xa9683a3e3251c768,0x585c686bcfe6be65,0.603,0.628602,289720,0,PASS
+244951180,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x8bd265dfa2c428c4,0x47904e96f2a9213c,0xa9683a3e3251c768,0x585c686bcfe6be65,1.192,1.207485,87296,0,PASS
+244951180,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x8bd265dfa2c428c4,0x47904e96f2a9213c,0xa9683a3e3251c768,0x585c686bcfe6be65,0.638,0.665330,290548,0,PASS
+245433414,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.112,0.131222,82516,0,PASS
+245433414,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.408,0.432991,277848,0,PASS
+245433414,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.100,0.115984,83136,0,PASS
+245433414,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.419,0.444156,277616,0,PASS
+245433414,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x8740ccf600a029e2,0x04589dea4d5c0710,0x15ebf34a211b4233,0x1249a8b782a9ff85,1.203,1.220959,86352,0,PASS
+245433414,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x8740ccf600a029e2,0x04589dea4d5c0710,0x15ebf34a211b4233,0x1249a8b782a9ff85,0.630,0.655544,290084,0,PASS
+245433414,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x8740ccf600a029e2,0x04589dea4d5c0710,0x15ebf34a211b4233,0x1249a8b782a9ff85,1.279,1.296620,86904,0,PASS
+245433414,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x8740ccf600a029e2,0x04589dea4d5c0710,0x15ebf34a211b4233,0x1249a8b782a9ff85,0.664,0.692096,290640,0,PASS
+277442974,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.190,0.206505,84588,0,PASS
+277442974,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.498,0.524538,279420,0,PASS
+277442974,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.188,0.203434,85052,0,PASS
+277442974,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.493,0.518404,279564,0,PASS
+277442974,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x175a35be1d6f3efe,0xec304bc7b17ae96e,0x3559b943893fa981,0x491b549b23966102,1.322,1.338231,87924,0,PASS
+277442974,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x175a35be1d6f3efe,0xec304bc7b17ae96e,0x3559b943893fa981,0x491b549b23966102,0.676,0.700980,292844,0,PASS
+277442974,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x175a35be1d6f3efe,0xec304bc7b17ae96e,0x3559b943893fa981,0x491b549b23966102,1.366,1.382495,88588,0,PASS
+277442974,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x175a35be1d6f3efe,0xec304bc7b17ae96e,0x3559b943893fa981,0x491b549b23966102,0.701,0.727447,293072,0,PASS
+297746112,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xca1d94b876e4eeab,0xa25988b781b26dd4,0x054762688f50e323,0x71019e04b6b0de40,0.245,0.260033,85384,0,PASS
+297746112,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xca1d94b876e4eeab,0xa25988b781b26dd4,0x054762688f50e323,0x71019e04b6b0de40,0.465,0.490415,288008,0,PASS
+297746112,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xca1d94b876e4eeab,0xa25988b781b26dd4,0x054762688f50e323,0x71019e04b6b0de40,0.243,0.258435,86024,0,PASS
+297746112,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xca1d94b876e4eeab,0xa25988b781b26dd4,0x054762688f50e323,0x71019e04b6b0de40,0.471,0.498359,288480,0,PASS
+297746112,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x87cc040ef39b9130,0x0a2ea7d615d2f513,0x22cdcf9ca191de12,0xe2f6e225caca52f0,1.652,1.667443,86192,0,PASS
+297746112,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x87cc040ef39b9130,0x0a2ea7d615d2f513,0x22cdcf9ca191de12,0xe2f6e225caca52f0,0.747,0.773312,289872,0,PASS
+297746112,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x87cc040ef39b9130,0x0a2ea7d615d2f513,0x22cdcf9ca191de12,0xe2f6e225caca52f0,1.731,1.748813,86708,0,PASS
+297746112,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x87cc040ef39b9130,0x0a2ea7d615d2f513,0x22cdcf9ca191de12,0xe2f6e225caca52f0,0.764,0.789221,290484,0,PASS
+336768467,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.114,0.128946,82460,0,PASS
+336768467,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.419,0.445300,277468,0,PASS
+336768467,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.110,0.125258,83208,0,PASS
+336768467,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.397,0.423317,278004,0,PASS
+336768467,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x51c11d2bb0b34ea1,0x7b5968648098e169,0x6671281233fba737,0xf6d98fa4825abf1c,1.629,1.646272,85052,0,PASS
+336768467,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x51c11d2bb0b34ea1,0x7b5968648098e169,0x6671281233fba737,0xf6d98fa4825abf1c,0.728,0.754451,288124,0,PASS
+336768467,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x51c11d2bb0b34ea1,0x7b5968648098e169,0x6671281233fba737,0xf6d98fa4825abf1c,1.705,1.720538,85388,0,PASS
+336768467,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x51c11d2bb0b34ea1,0x7b5968648098e169,0x6671281233fba737,0xf6d98fa4825abf1c,0.738,0.766954,288356,0,PASS
+512532080,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.153,0.168716,82560,0,PASS
+512532080,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.440,0.467645,277488,0,PASS
+512532080,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.143,0.159069,82904,0,PASS
+512532080,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.445,0.469304,277704,0,PASS
+512532080,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x072b184717239693,0x9fac948bbd70a853,0xc00c647e52d9427e,0x4cc2ff6aed2ad23d,1.226,1.242263,84388,0,PASS
+512532080,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x072b184717239693,0x9fac948bbd70a853,0xc00c647e52d9427e,0x4cc2ff6aed2ad23d,0.629,0.654951,288556,0,PASS
+512532080,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x072b184717239693,0x9fac948bbd70a853,0xc00c647e52d9427e,0x4cc2ff6aed2ad23d,1.360,1.375755,85232,0,PASS
+512532080,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x072b184717239693,0x9fac948bbd70a853,0xc00c647e52d9427e,0x4cc2ff6aed2ad23d,0.672,0.697654,289308,0,PASS
+821120640,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.153,0.168054,82828,0,PASS
+821120640,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.462,0.487309,277536,0,PASS
+821120640,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.149,0.163984,82908,0,PASS
+821120640,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.445,0.471081,277668,0,PASS
+821120640,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x799f3dddb77b2373,0x2ff216b7c9c0a0f7,0xbd06c753c834d621,0xe6452e48c09c779c,1.491,1.507224,85000,0,PASS
+821120640,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x799f3dddb77b2373,0x2ff216b7c9c0a0f7,0xbd06c753c834d621,0xe6452e48c09c779c,0.700,0.726549,289052,0,PASS
+821120640,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x799f3dddb77b2373,0x2ff216b7c9c0a0f7,0xbd06c753c834d621,0xe6452e48c09c779c,1.661,1.677544,85416,0,PASS
+821120640,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x799f3dddb77b2373,0x2ff216b7c9c0a0f7,0xbd06c753c834d621,0xe6452e48c09c779c,0.775,0.801706,289404,0,PASS
+853538490,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe9c955bb88ef453e,0xf6ff06a22d87a886,0x8affd2ace9c02ca9,0xa87ab0dfc3a7abaf,0.351,0.367197,83708,0,PASS
+853538490,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe9c955bb88ef453e,0xf6ff06a22d87a886,0x8affd2ace9c02ca9,0xa87ab0dfc3a7abaf,0.498,0.524390,287376,0,PASS
+853538490,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe9c955bb88ef453e,0xf6ff06a22d87a886,0x8affd2ace9c02ca9,0xa87ab0dfc3a7abaf,0.309,0.325235,84408,0,PASS
+853538490,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe9c955bb88ef453e,0xf6ff06a22d87a886,0x8affd2ace9c02ca9,0xa87ab0dfc3a7abaf,0.503,0.529485,287824,0,PASS
+853538490,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xf325b1581a7f5166,0x375b7d2ab1227a19,0xa5b6bfe633662d7e,0xaceab7327811c4f7,1.594,1.609537,84548,0,PASS
+853538490,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xf325b1581a7f5166,0x375b7d2ab1227a19,0xa5b6bfe633662d7e,0xaceab7327811c4f7,0.744,0.770634,287636,0,PASS
+853538490,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xf325b1581a7f5166,0x375b7d2ab1227a19,0xa5b6bfe633662d7e,0xaceab7327811c4f7,1.565,1.581727,85352,0,PASS
+853538490,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xf325b1581a7f5166,0x375b7d2ab1227a19,0xa5b6bfe633662d7e,0xaceab7327811c4f7,0.783,0.809731,287652,0,PASS
+861026696,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.120,0.140722,84164,0,PASS
+861026696,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.424,0.450365,279168,0,PASS
+861026696,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.112,0.128137,84788,0,PASS
+861026696,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.404,0.429204,279848,0,PASS
+861026696,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xca1edaff577a4e1c,0xd032eac020ae2194,0x573cba10f70617e8,0xa8ef305116ad999c,1.511,1.528290,85840,0,PASS
+861026696,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xca1edaff577a4e1c,0xd032eac020ae2194,0x573cba10f70617e8,0xa8ef305116ad999c,0.690,0.716270,288668,0,PASS
+861026696,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xca1edaff577a4e1c,0xd032eac020ae2194,0x573cba10f70617e8,0xa8ef305116ad999c,1.581,1.598332,86244,0,PASS
+861026696,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xca1edaff577a4e1c,0xd032eac020ae2194,0x573cba10f70617e8,0xa8ef305116ad999c,0.737,0.763910,288720,0,PASS
+1026251636,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.125,0.140307,87376,0,PASS
+1026251636,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.431,0.456676,282440,0,PASS
+1026251636,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.120,0.136933,87768,0,PASS
+1026251636,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.410,0.435138,282592,0,PASS
+1026251636,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x389074d90273f26e,0xa38bcee9be5ec7eb,0x640d982fa1ac7f9c,0xe03c1c060ff49cca,2.194,2.209401,90204,0,PASS
+1026251636,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x389074d90273f26e,0xa38bcee9be5ec7eb,0x640d982fa1ac7f9c,0xe03c1c060ff49cca,0.851,0.878001,292176,0,PASS
+1026251636,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x389074d90273f26e,0xa38bcee9be5ec7eb,0x640d982fa1ac7f9c,0xe03c1c060ff49cca,2.274,2.290952,90476,0,PASS
+1026251636,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x389074d90273f26e,0xa38bcee9be5ec7eb,0x640d982fa1ac7f9c,0xe03c1c060ff49cca,0.835,0.863009,292140,0,PASS
+1077415394,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x87ee69cb17aba224,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.146,0.163297,86188,0,PASS
+1077415394,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x87ee69cb17aba224,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.414,0.439121,283756,0,PASS
+1077415394,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x87ee69cb17aba224,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.148,0.168584,86796,0,PASS
+1077415394,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x87ee69cb17aba224,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.426,0.450855,284368,0,PASS
+1077415394,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x9584311b92b45072,0xee776f01c536080b,0x6648ac4dfaf4abfd,0x18119783a47a0df1,1.601,1.617268,87912,0,PASS
+1077415394,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x9584311b92b45072,0xee776f01c536080b,0x6648ac4dfaf4abfd,0x18119783a47a0df1,0.699,0.725603,292220,0,PASS
+1077415394,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x9584311b92b45072,0xee776f01c536080b,0x6648ac4dfaf4abfd,0x18119783a47a0df1,1.727,1.745677,88476,0,PASS
+1077415394,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x9584311b92b45072,0xee776f01c536080b,0x6648ac4dfaf4abfd,0x18119783a47a0df1,0.833,0.867727,292828,0,PASS
+1130999017,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x38c8b5c86fc861ed,0x0871f41c7adbcbec,0x983b9c5b7bfc9c68,0x920b30bf2774555b,0.291,0.307690,85160,0,PASS
+1130999017,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x38c8b5c86fc861ed,0x0871f41c7adbcbec,0x983b9c5b7bfc9c68,0x920b30bf2774555b,0.452,0.481022,289968,0,PASS
+1130999017,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x38c8b5c86fc861ed,0x0871f41c7adbcbec,0x983b9c5b7bfc9c68,0x920b30bf2774555b,0.266,0.282332,85784,0,PASS
+1130999017,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x38c8b5c86fc861ed,0x0871f41c7adbcbec,0x983b9c5b7bfc9c68,0x920b30bf2774555b,0.444,0.470657,290324,0,PASS
+1130999017,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x519dd11ec1b6fd25,0x03655ab9c5d71117,0xbd12d3dae54569a6,0x80d8d87e27a7de44,1.472,1.489302,84108,0,PASS
+1130999017,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x519dd11ec1b6fd25,0x03655ab9c5d71117,0xbd12d3dae54569a6,0x80d8d87e27a7de44,0.713,0.738699,287528,0,PASS
+1130999017,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x519dd11ec1b6fd25,0x03655ab9c5d71117,0xbd12d3dae54569a6,0x80d8d87e27a7de44,1.530,1.545977,84776,0,PASS
+1130999017,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x519dd11ec1b6fd25,0x03655ab9c5d71117,0xbd12d3dae54569a6,0x80d8d87e27a7de44,0.685,0.710911,288188,0,PASS
+1156488597,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.121,0.139125,83040,0,PASS
+1156488597,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.403,0.428569,278288,0,PASS
+1156488597,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.109,0.125855,83948,0,PASS
+1156488597,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.425,0.450644,278660,0,PASS
+1156488597,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x640a6e138f3d100a,0x89a1c96de1216f8a,0xabb2594c0f2aa5e1,0xbdaec02426d2a060,1.216,1.232170,85424,0,PASS
+1156488597,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x640a6e138f3d100a,0x89a1c96de1216f8a,0xabb2594c0f2aa5e1,0xbdaec02426d2a060,0.645,0.670839,287908,0,PASS
+1156488597,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x640a6e138f3d100a,0x89a1c96de1216f8a,0xabb2594c0f2aa5e1,0xbdaec02426d2a060,1.312,1.328475,86080,0,PASS
+1156488597,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x640a6e138f3d100a,0x89a1c96de1216f8a,0xabb2594c0f2aa5e1,0xbdaec02426d2a060,0.704,0.729815,288444,0,PASS
+1172304228,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.109,0.123809,82616,0,PASS
+1172304228,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.407,0.431733,277580,0,PASS
+1172304228,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.101,0.115688,82980,0,PASS
+1172304228,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.407,0.432724,277708,0,PASS
+1172304228,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xfb46579ab737c12d,0x0a000a703c549cc1,0xfea6b41d2c3dda0e,0x9640bd6047c9a630,0.869,0.885113,85556,0,PASS
+1172304228,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xfb46579ab737c12d,0x0a000a703c549cc1,0xfea6b41d2c3dda0e,0x9640bd6047c9a630,0.584,0.611186,288244,0,PASS
+1172304228,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xfb46579ab737c12d,0x0a000a703c549cc1,0xfea6b41d2c3dda0e,0x9640bd6047c9a630,0.964,0.980259,85884,0,PASS
+1172304228,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xfb46579ab737c12d,0x0a000a703c549cc1,0xfea6b41d2c3dda0e,0x9640bd6047c9a630,0.611,0.636011,289012,0,PASS
+1370340570,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.106,0.121360,82860,0,PASS
+1370340570,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.413,0.439779,277640,0,PASS
+1370340570,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.105,0.120822,83596,0,PASS
+1370340570,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.406,0.430247,278132,0,PASS
+1370340570,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x34624cba09f42b66,0xd81a376b1e97ec8b,0xf965f89b36b5d843,0xf6abf6a7f4a15687,1.678,1.694262,85176,0,PASS
+1370340570,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x34624cba09f42b66,0xd81a376b1e97ec8b,0xf965f89b36b5d843,0xf6abf6a7f4a15687,0.691,0.717560,287996,0,PASS
+1370340570,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x34624cba09f42b66,0xd81a376b1e97ec8b,0xf965f89b36b5d843,0xf6abf6a7f4a15687,1.820,1.836129,85504,0,PASS
+1370340570,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x34624cba09f42b66,0xd81a376b1e97ec8b,0xf965f89b36b5d843,0xf6abf6a7f4a15687,0.768,0.793448,288372,0,PASS
+1383925073,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.112,0.129033,81792,0,PASS
+1383925073,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.401,0.427476,277224,0,PASS
+1383925073,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.105,0.120673,82892,0,PASS
+1383925073,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.402,0.425822,277488,0,PASS
+1383925073,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x32c8a3f9cd2d249e,0xe504e184d0529243,0x58408898b37b6d53,0x3154f68bf8585d9e,1.772,1.788831,84816,0,PASS
+1383925073,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x32c8a3f9cd2d249e,0xe504e184d0529243,0x58408898b37b6d53,0x3154f68bf8585d9e,0.882,0.907588,287224,0,PASS
+1383925073,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x32c8a3f9cd2d249e,0xe504e184d0529243,0x58408898b37b6d53,0x3154f68bf8585d9e,1.870,1.886415,84956,0,PASS
+1383925073,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x32c8a3f9cd2d249e,0xe504e184d0529243,0x58408898b37b6d53,0x3154f68bf8585d9e,0.907,0.933394,287936,0,PASS
+1401164998,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.287,0.303400,84652,0,PASS
+1401164998,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.478,0.503793,287484,0,PASS
+1401164998,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.275,0.290885,85324,0,PASS
+1401164998,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.467,0.494139,288496,0,PASS
+1401164998,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xec2a42ee2976845f,0xa295763ea8d9e67f,0xe9c0bff6914243ba,0x62b04de967523696,1.963,1.979104,84732,0,PASS
+1401164998,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xec2a42ee2976845f,0xa295763ea8d9e67f,0xe9c0bff6914243ba,0x62b04de967523696,0.747,0.775087,287448,0,PASS
+1401164998,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xec2a42ee2976845f,0xa295763ea8d9e67f,0xe9c0bff6914243ba,0x62b04de967523696,1.910,1.926095,85012,0,PASS
+1401164998,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xec2a42ee2976845f,0xa295763ea8d9e67f,0xe9c0bff6914243ba,0x62b04de967523696,0.798,0.823400,288392,0,PASS
+1558879574,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.115,0.132445,81992,0,PASS
+1558879574,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.422,0.447714,276768,0,PASS
+1558879574,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.103,0.119871,82376,0,PASS
+1558879574,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.421,0.447570,277272,0,PASS
+1558879574,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x6a6961f63402e799,0xcdeb03b89b00d39d,0x0b036e09b5273b49,0x971cac1901dff195,0.920,0.936756,83620,0,PASS
+1558879574,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x6a6961f63402e799,0xcdeb03b89b00d39d,0x0b036e09b5273b49,0x971cac1901dff195,0.595,0.621724,287708,0,PASS
+1558879574,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x6a6961f63402e799,0xcdeb03b89b00d39d,0x0b036e09b5273b49,0x971cac1901dff195,0.939,0.954884,84488,0,PASS
+1558879574,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x6a6961f63402e799,0xcdeb03b89b00d39d,0x0b036e09b5273b49,0x971cac1901dff195,0.600,0.626689,288548,0,PASS
+1753015542,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.106,0.121516,83192,0,PASS
+1753015542,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.420,0.448397,278160,0,PASS
+1753015542,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.110,0.129636,83988,0,PASS
+1753015542,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.405,0.431222,278696,0,PASS
+1753015542,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xb91a6e87bdb9610e,0xfdbb714aa24253d8,0xfea893be04158e3f,0x3365335c4b56e58c,1.661,1.678331,85292,0,PASS
+1753015542,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xb91a6e87bdb9610e,0xfdbb714aa24253d8,0xfea893be04158e3f,0x3365335c4b56e58c,0.725,0.750781,288032,0,PASS
+1753015542,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xb91a6e87bdb9610e,0xfdbb714aa24253d8,0xfea893be04158e3f,0x3365335c4b56e58c,1.786,1.802204,86188,0,PASS
+1753015542,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xb91a6e87bdb9610e,0xfdbb714aa24253d8,0xfea893be04158e3f,0x3365335c4b56e58c,0.739,0.765903,288808,0,PASS
+1827697875,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.106,0.122073,84540,0,PASS
+1827697875,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.412,0.435966,279476,0,PASS
+1827697875,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.105,0.121830,84676,0,PASS
+1827697875,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.409,0.434709,279752,0,PASS
+1827697875,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x699dd931ec3a2699,0x88331e1e5644593e,0xaa2288bc01794464,0xf92b0fbeb4ea279b,1.666,1.681850,89140,0,PASS
+1827697875,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x699dd931ec3a2699,0x88331e1e5644593e,0xaa2288bc01794464,0xf92b0fbeb4ea279b,0.739,0.764550,292172,0,PASS
+1827697875,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x699dd931ec3a2699,0x88331e1e5644593e,0xaa2288bc01794464,0xf92b0fbeb4ea279b,1.784,1.800585,89620,0,PASS
+1827697875,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x699dd931ec3a2699,0x88331e1e5644593e,0xaa2288bc01794464,0xf92b0fbeb4ea279b,0.774,0.801097,293460,0,PASS
+1909311298,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.126,0.140793,81792,0,PASS
+1909311298,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.454,0.479793,277000,0,PASS
+1909311298,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.119,0.138021,82780,0,PASS
+1909311298,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.439,0.465770,277320,0,PASS
+1909311298,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x15c0afb4c79cdd4e,0xc5f83ce7199a4708,0x1a923e880b787190,0xb9ca42e4a6e19d87,1.677,1.692282,84504,0,PASS
+1909311298,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x15c0afb4c79cdd4e,0xc5f83ce7199a4708,0x1a923e880b787190,0xb9ca42e4a6e19d87,0.726,0.753056,287464,0,PASS
+1909311298,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x15c0afb4c79cdd4e,0xc5f83ce7199a4708,0x1a923e880b787190,0xb9ca42e4a6e19d87,1.895,1.911071,84364,0,PASS
+1909311298,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x15c0afb4c79cdd4e,0xc5f83ce7199a4708,0x1a923e880b787190,0xb9ca42e4a6e19d87,0.754,0.781499,287952,0,PASS
+2011898099,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.113,0.129139,83892,0,PASS
+2011898099,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.433,0.459151,278756,0,PASS
+2011898099,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.103,0.117822,84760,0,PASS
+2011898099,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.428,0.456161,279268,0,PASS
+2011898099,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x4e5bc61fa6d60b4e,0x3c54a6c3cc817e24,0xa9a3c69c604071a5,0x53009044905f1269,1.148,1.163696,87080,0,PASS
+2011898099,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x4e5bc61fa6d60b4e,0x3c54a6c3cc817e24,0xa9a3c69c604071a5,0x53009044905f1269,0.624,0.651689,289916,0,PASS
+2011898099,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x4e5bc61fa6d60b4e,0x3c54a6c3cc817e24,0xa9a3c69c604071a5,0x53009044905f1269,1.234,1.252059,87640,0,PASS
+2011898099,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x4e5bc61fa6d60b4e,0x3c54a6c3cc817e24,0xa9a3c69c604071a5,0x53009044905f1269,0.650,0.677250,290788,0,PASS
+2015768509,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x5d69d4a0b6a3d1c3,0x300ab4e08dc23479,0xb1638622b8b616ad,0x082af297bc0e2595,0.319,0.335248,82712,0,PASS
+2015768509,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x5d69d4a0b6a3d1c3,0x300ab4e08dc23479,0xb1638622b8b616ad,0x082af297bc0e2595,0.497,0.523192,286708,0,PASS
+2015768509,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0x5d69d4a0b6a3d1c3,0x300ab4e08dc23479,0xb1638622b8b616ad,0x082af297bc0e2595,0.280,0.296244,83728,0,PASS
+2015768509,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0x5d69d4a0b6a3d1c3,0x300ab4e08dc23479,0xb1638622b8b616ad,0x082af297bc0e2595,0.479,0.505113,287436,0,PASS
+2015768509,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0xd9c1ee0b4c2e8ce8,0x7d2329c4b87bc6f1,0x8f9d279d8d590839,0x7ac25c667e165fa7,1.490,1.506239,84120,0,PASS
+2015768509,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0xd9c1ee0b4c2e8ce8,0x7d2329c4b87bc6f1,0x8f9d279d8d590839,0x7ac25c667e165fa7,0.717,0.744393,288996,0,PASS
+2015768509,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0xd9c1ee0b4c2e8ce8,0x7d2329c4b87bc6f1,0x8f9d279d8d590839,0x7ac25c667e165fa7,1.600,1.617351,84900,0,PASS
+2015768509,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0xd9c1ee0b4c2e8ce8,0x7d2329c4b87bc6f1,0x8f9d279d8d590839,0x7ac25c667e165fa7,0.742,0.769135,289484,0,PASS
+2070776516,surface-world,clang19,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.126,0.141678,81840,0,PASS
+2070776516,surface-world,clang19,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.430,0.456364,276976,0,PASS
+2070776516,surface-world,gcc14,1,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.114,0.131120,82540,0,PASS
+2070776516,surface-world,gcc14,12,27,0,0,-32,-192,-1984,64,-96,-1888,0xe93491225d0202f9,0x6b2a630951428df2,0xfc2798d6a5478b25,0x0c08d7d980a84301,0.401,0.425293,277436,0,PASS
+2070776516,floating-islands,clang19,1,27,0,0,-32,-32,-160,64,64,-64,0x2cc0f6dce797b31f,0x8760f9677ab58f62,0x03d2511d3ea2f55b,0x2f55edd35d7b78ef,0.998,1.014096,84548,0,PASS
+2070776516,floating-islands,clang19,12,27,0,0,-32,-32,-160,64,64,-64,0x2cc0f6dce797b31f,0x8760f9677ab58f62,0x03d2511d3ea2f55b,0x2f55edd35d7b78ef,0.575,0.600529,286932,0,PASS
+2070776516,floating-islands,gcc14,1,27,0,0,-32,-32,-160,64,64,-64,0x2cc0f6dce797b31f,0x8760f9677ab58f62,0x03d2511d3ea2f55b,0x2f55edd35d7b78ef,1.054,1.070063,84768,0,PASS
+2070776516,floating-islands,gcc14,12,27,0,0,-32,-32,-160,64,64,-64,0x2cc0f6dce797b31f,0x8760f9677ab58f62,0x03d2511d3ea2f55b,0x2f55edd35d7b78ef,0.597,0.622079,287140,0,PASS

Standalone/Research/WorldAssemblerM3/Linux2/seed_sweep_summary.txt

@@ -0,0 +1 @@
+runs=384 seeds=48 recipes=2 compilers=2 workers=1,12 cross_compiler_comparisons=192 cross_compiler_mismatches=0 cross_worker_comparisons=192 cross_worker_mismatches=0 elapsed_s=290.100

Standalone/Research/WorldAssemblerM3/Linux2/seeds.txt

@@ -0,0 +1,48 @@
+-1990830953
+-1900684165
+-1766412538
+-1721984596
+-1239598758
+-1085993262
+-1033703345
+-854671705
+-713963806
+-621039221
+-474448608
+-432690581
+-380556572
+-238925630
+-216679974
+-133096164
+-112366806
+0
+5808593
+28573228
+70955227
+75274690
+81375760
+146979566
+244951180
+245433414
+277442974
+297746112
+336768467
+512532080
+821120640
+853538490
+861026696
+1026251636
+1077415394
+1130999017
+1156488597
+1172304228
+1370340570
+1383925073
+1401164998
+1558879574
+1753015542
+1827697875
+1909311298
+2011898099
+2015768509
+2070776516

Standalone/Research/WorldAssemblerM3/Linux2/windows_commands.txt

@@ -0,0 +1,192 @@
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1990830953 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1990830953 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1900684165 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1900684165 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1766412538 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1766412538 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1721984596 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1721984596 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1239598758 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1239598758 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1085993262 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1085993262 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1033703345 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1033703345 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-854671705 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-854671705 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-713963806 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-713963806 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-621039221 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-621039221 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-474448608 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-474448608 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-432690581 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-432690581 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-380556572 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-380556572 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-238925630 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-238925630 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-216679974 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-216679974 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-133096164 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-133096164 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-112366806 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-112366806 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=0 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=0 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=5808593 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=5808593 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=28573228 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=28573228 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=70955227 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=70955227 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=75274690 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=75274690 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=81375760 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=81375760 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=146979566 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=146979566 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=244951180 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=244951180 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=245433414 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=245433414 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=277442974 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=277442974 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=297746112 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=297746112 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=336768467 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=336768467 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=512532080 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=512532080 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=821120640 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=821120640 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=853538490 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=853538490 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=861026696 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=861026696 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1026251636 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1026251636 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1077415394 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1077415394 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1130999017 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1130999017 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1156488597 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1156488597 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1172304228 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1172304228 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1370340570 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1370340570 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1383925073 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1383925073 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1401164998 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1401164998 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1558879574 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1558879574 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1753015542 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1753015542 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1827697875 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1827697875 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1909311298 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1909311298 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2011898099 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2011898099 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2015768509 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2015768509 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2070776516 --recipe=surface-world --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2070776516 --recipe=surface-world --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1990830953 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1990830953 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1900684165 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1900684165 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1766412538 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1766412538 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1721984596 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1721984596 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1239598758 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1239598758 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1085993262 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1085993262 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1033703345 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-1033703345 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-854671705 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-854671705 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-713963806 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-713963806 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-621039221 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-621039221 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-474448608 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-474448608 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-432690581 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-432690581 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-380556572 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-380556572 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-238925630 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-238925630 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-216679974 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-216679974 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-133096164 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-133096164 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-112366806 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=-112366806 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=0 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=0 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=5808593 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=5808593 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=28573228 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=28573228 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=70955227 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=70955227 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=75274690 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=75274690 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=81375760 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=81375760 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=146979566 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=146979566 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=244951180 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=244951180 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=245433414 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=245433414 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=277442974 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=277442974 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=297746112 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=297746112 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=336768467 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=336768467 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=512532080 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=512532080 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=821120640 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=821120640 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=853538490 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=853538490 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=861026696 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=861026696 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1026251636 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1026251636 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1077415394 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1077415394 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1130999017 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1130999017 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1156488597 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1156488597 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1172304228 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1172304228 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1370340570 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1370340570 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1383925073 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1383925073 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1401164998 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1401164998 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1558879574 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1558879574 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1753015542 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1753015542 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1827697875 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1827697875 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1909311298 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=1909311298 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2011898099 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2011898099 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2015768509 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2015768509 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2070776516 --recipe=floating-islands --render-distance-chunks=0 --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60
+& ".\Standalone\bin\VoxelForgeCoreStandalone.exe" ".\Standalone\data\owner_world.json" --seed=2070776516 --recipe=floating-islands --render-distance-chunks=0 --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=1 --max-clip-level=0 --camera=0,0,-32,0,-22 --far-horizon-lod8-step=0 --process-affinity=4095 --process-priority=Normal --frame-limit=60

Standalone/Research/WorldAssemblerM3/Linux3/REPORT.md

@@ -0,0 +1,93 @@
+# WorldAssemblerM3 Linux3 — FP contraction
+
+## Unreal flags: documented and inferred
+
+UE 5.7's Target Reference documents `FPSemantics`; Epic's Module Properties page documents the matching module-level property and says it overrides FP semantics. Epic Support says module and target overrides have existed since UE 5.4. This repo's `VoxelForgeCore.Build.cs` already sets `FPSemantics = FPSemanticsMode.Precise` and `PCHUsage = PCHUsageMode.NoPCHs` (existing lines 44–45). [UE 5.7 Target Reference](https://dev.epicgames.com/documentation/en-us/unreal-engine/unreal-engine-build-tool-target-reference?application_version=5.7), [Module Properties](https://dev.epicgames.com/documentation/unreal-engine/module-properties-in-unreal-engine), [Epic Support answer](https://forums.unrealengine.com/t/debug-game-development/2668723)
+
+Public UBT documentation does **not** publish one exact compiler argv for every plugin, platform, and configuration. Epic Support reports Windows DebugGame uses `/fp:precise` and Development uses `/fp:fast` by default. MSVC 2022 17+ defaults `/fp:precise` to contraction off; explicit `/fp:contract` can enable it under `/fp:precise`, and `/fp:fast` permits it by default. Earlier MSVC versions defaulted precise contraction on. Explicit `#pragma fp_contract(off)` overrides `/fp:fast`. Clang's `precise` model allows same-expression `-ffp-contract=on`; `-ffp-contract=fast` can fuse across statements and ignores `#pragma clang fp contract(off)`. GCC defaults to `-ffp-contract=fast`; its standard `FP_CONTRACT` pragma is not implemented, so this patch uses GCC's function-option pragma instead. [MSVC `/fp`](https://learn.microsoft.com/en-us/cpp/build/reference/fp-specify-floating-point-behavior?view=msvc-170), [MSVC pragma](https://learn.microsoft.com/en-us/cpp/preprocessor/fp-contract?view=msvc-170), [Clang FP pragmas and model](https://clang.llvm.org/docs/LanguageExtensions.html#extensions-to-specify-floating-point-flags), [GCC FP options](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html), [GCC function-specific pragmas](https://gcc.gnu.org/onlinedocs/gcc/Function-Specific-Option-Pragmas.html), [GCC FP implementation](https://gcc.gnu.org/onlinedocs/gcc/Floating-point-implementation.html)
+
+**Inference for this repo:** The standalone BuildHost is safe-by-configuration on current VS 2022: `Build.ps1` explicitly uses `/fp:precise`, whose 17.0+ default is contraction off. The owner's UBT Windows build is likely safe for the same reason because the module sets `Precise`, but it was not captured here; an older MSVC or an explicit `/fp:contract` could put it at risk. On Linux, `Precise` alone does not mean contraction off for Clang, so the UBT build was at risk before this change. UE 5.7's supported Linux compiler is Clang 20.1.8; this host tested Clang 19.1.7. Epic's UE 5.7 PS5 notes also show Clang flags vary by platform: PS5 removed `-ffp-contract=off` because its `-ffast-math` setting conflicted with it. This does not establish that Linux UBT passes `-ffast-math`; capture that module's actual command line on the owner PC. [UE Linux requirements](https://dev.epicgames.com/documentation/unreal-engine/linux-development-requirements-for-unreal-engine?lang=en-US), [UE 5.7 PS5 notes](https://dev.epicgames.com/documentation/en-us/unreal-engine/playstation-5-release-notes-for-unreal-engine-5-7)
+
+## Mechanism and Core lines touched
+
+Each Core translation unit loads `CoreNamespacePreamble.h` before its implementation. The preamble applies Clang `contract(off)`, MSVC `fp_contract(off)`, or GCC `optimize("fp-contract=off")`; unknown compilers fail at compile time. Its noinline probe evaluates `(1 + 2^-27) * (1 - 2^-27) - 1` using volatile inputs. Separate multiply/add rounds to `0`; a fused operation returns `-2^-54`.
+
+`World::compile` runs that probe before building the shape and returns an error before density generation if it fuses. The check and density implementation receive the same preamble/FP pragma in Core. Clang `fast` is deliberately refused because Clang documents that mode as ignoring the source pragma. GCC's default and the explicit Clang `on` mode are instead compiled with the source-level off control.
+
+Only these Core lines changed:
+
+- `Standalone/Core/src/CoreNamespacePreamble.h:58–93` — per-compiler pragma and shared self-test.
+- `Standalone/Core/src/VoxelForgeCore.cpp:972–976` — refusal before shape build.
+
+For this sweep, the standalone headless runner also gained `--auto-surface-camera` and `--mesh-coverage` in `Standalone/Source/StreamBenchmarkHeadless.cpp` and `Standalone/Source/StreamBenchmarkPipeline.h`.
+
+The probe guards FP contraction. It does not establish immunity to unrelated `-ffast-math` transformations such as reassociation; those flags must be captured and handled separately if present.
+
+## Hash immunity
+
+All successful rows cover the L1 whole view (2,553 tiles); each cell below lists density / mesh / payload / topology hashes. Runs used `Standalone/data/owner_world.json` and `--world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0`. `Clang fast` was built with `-ffp-contract=fast` and `-fno-fast-math`.
+
+| Compiler and setting | W1 | W12 |
+|---|---|---|
+| Clang 19 `-ffp-contract=off` | `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724` | same |
+| Clang 19 `-ffp-contract=on` | same | same |
+| Clang 19 `-ffp-contract=fast` | refused before generation | refused before generation |
+| GCC 14 default (effective contract=fast) | `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724` | same |
+
+All three supported configurations (Clang off/on, GCC default) match the L1 reference. Both Clang `fast` runs returned exit code 2 in about 0.066 s with the explicit diagnostic, before generating a density hash. Logs: [W1 refusal](../../../../Saved/Linux/linux3-final-hash-clang-fast-w1.log), [W12 refusal](../../../../Saved/Linux/linux3-final-hash-clang-fast-w12.log); successful per-run logs are `linux3-final-hash-*.log` under `Saved/Linux`.
+
+## Self-test negative control
+
+The test is in the shared Core preamble, not a separate differently compiled test file. In the deliberate Clang `fast` build it detected the fused result and the Core API rejected world generation at W1 and W12. A compiler-only probe also returned `0` for Clang off/on and GCC with its off pragma, and `-0x1p-54` for Clang fast ([probe log](../../../../Saved/Linux/linux3-pragma-probe.log)). The production-build refusal is the negative control.
+
+## Corrected seed sweep
+
+The sweep used 48 unique seeds, both recipes, Clang off/on and GCC default, and W1/W12: 576 runs in 432.977 s. Each SurfaceWorld 96³-voxel cube was centered at the original XY and moved to that seed's nearest heightfield surface; each FloatingIslands cube was centered on that seed's largest planned island. Every run covered 27 LOD0 tiles and contained triangles.
+
+| Recipe | Per-seed coverage across the sweep |
+|---|---|
+| SurfaceWorld | 9–18 nonempty mesh tiles; 26,182–52,468 indexed triangles |
+| FloatingIslands | 7–15 nonempty mesh tiles; 15,728–46,224 indexed triangles |
+
+All seeds had distinct density hashes within each recipe. Cross-build comparisons: 192, mismatches 0. W1/W12 comparisons: 288, mismatches 0. Empty-mesh rows: 0. Peak run RSS: 306,580 KiB. The full compiler/worker results are in [seed_mesh_coverage.csv](seed_mesh_coverage.csv); one row per seed and recipe, including the nonempty tile and triangle counts and placed camera, is in [seed_mesh_coverage_per_seed.csv](seed_mesh_coverage_per_seed.csv). Summary: [seed_mesh_coverage_summary.txt](seed_mesh_coverage_summary.txt).
+
+## Cost
+
+Three interleaved W12 runs per binary used the same 2,553-tile view, without mesh-coverage counting. “Before” is the S14 executable; “after” is the Clang-off L3 executable.
+
+| Build | Whole-view ready times (s) | Median |
+|---|---|---:|
+| S14 before | 2.260, 2.326, 2.339 | 2.326 s |
+| L3 after | 2.329, 2.384, 2.337 | 2.337 s |
+
+The interleaved median change is +0.011 s (+0.5%). The agreed owner-provided before baseline was 2.42 s; L3's 2.337 s median is 0.083 s below it. All six runs retained the L1 hashes. Maximum run RSS was about 550 MiB. Governor remained `powersave`; EPP remained `balance_performance`.
+
+## Windows work still needed
+
+MSVC was not available here. On the Windows BuildHost:
+
+1. Build the standalone Core and viewer from the updated tree: `powershell -ExecutionPolicy Bypass -File Standalone\Build.ps1 -Target All -CompileWorkers 12`. This uses `/fp:precise`; inspect `Standalone\Build\VoxelForgeCore\core-compile.rsp` to confirm.
+2. Run the resulting viewer on the L1 view twice, once with `--workers=1` and once with `--workers=12`, using `--world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0`. Require the four L1 hashes both times and no self-test error.
+3. To validate the MSVC pragma under an explicitly contracted setting, make a temporary copy of `Build.ps1`, change its single `/fp:precise` entry to `/fp:fast`, and build it with `-OutputName VoxelForgeCoreStandalone-msvc-fast.exe`. Run the same W1/W12 L1 checks and require unchanged hashes and a passing self-test.
+4. Build the owner project's UE 5.7 Win64 Development Editor target (and its Server target if configured) with this plugin enabled. Save the actual UBT `cl.exe` commands for `VoxelForgeCore` and record `/fp:*`, `/fp:contract`, and any `/fp:fast` or `/fp:precise` options. Run the owner's existing seed-0 Core world/hash path at W1 and W12 and confirm the L1 result and passing self-test.
+
+MSVC-specific risks: the pragma has not been compiled here; `/fp:precise` contraction defaults changed at VS 2022 17.0; target configuration may add `/fp:fast` or `/fp:contract`; and UBT's module override must reach every Core source. Microsoft documents that the explicit pragma overrides `/fp:fast`, but the Windows build must confirm that the actual toolset honors it. `VoxelForgeCore.Build.cs` already disables PCH and unity builds, and each Core wrapper includes the pragma preamble.
+
+## Runs and limits
+
+No build, hash, sweep, or timing run failed or needed a retry. The two Clang `fast` exits were the expected negative control. Build variants were Clang 19.1.7 and GCC 14.2; builds and runs used CPUs 0–11, at most 12 jobs, normal priority, and a 6 GiB per-process address-space limit. Build peak RSS: 895,640 KiB (GCC); L1 hash-run peak: 551,004 KiB; seed-sweep peak: 306,580 KiB. The 8 MiB process stack was unchanged; Linux workers retain their existing 32 MiB stacks. Build artifacts are under `Standalone/Build/linux-l3-*` and `Standalone/bin/linux/`; logs are under `Saved/Linux/`.
+
+## Note for the owner
+
+Core now disables expression contraction for Clang, GCC, and MSVC, and rejects Clang fast when that compiler ignores the off pragma; all supported Linux settings retained the L1 hashes. Please validate the source pragma on native MSVC and capture UE 5.7 UBT's actual Windows and Linux compiler arguments, since those builds were not available here.
+
+## Orchestrator review (Claude)
+
+- Re-run by me on Luna's binaries, W12, L1 view: Clang `off` 2.299 s and Clang `on` 2.302 s, both density
+  `c10697a8f48380c7`; GCC default 2.469 s, also `c10697a8f48380c7`; Clang `fast` exits 2 with the self-test
+  refusal. Clang `on` and GCC default gave *different* worlds in L2, so the pragma is demonstrably effective.
+- Known gap (small): the pragma sits after the standard headers, `Json.h` and the public API header in the
+  preamble, so inline/template code defined there is not covered. All Core world math (Compat, `*Internal.h`,
+  legacy sources) comes after it.
+- The probe guards contraction only; `-ffast-math` reassociation is a separate risk (as Luna says). The
+  Windows to-do list above is the gate before claiming this on MSVC/UBT.

Standalone/Research/WorldAssemblerM3/Linux3/RunSeedSweep.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""Run the corrected L3 seed/compiler/worker matrix with per-seed mesh coverage."""
+import csv
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path.cwd()
+ROUND = ROOT / "Standalone/Research/WorldAssemblerM3/Linux3"
+SEEDS = ROOT / "Standalone/Research/WorldAssemblerM3/Linux2/seeds.txt"
+LOG_DIR = ROOT / "Saved/Linux"
+MEASURE = ROOT / "Standalone/Research/WorldAssemblerM3/Linux2/MeasureProcess.py"
+DATA = ROOT / "Standalone/data/owner_world.json"
+BINARIES = {
+    "clang19-off": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-clang19-l3-off",
+    "clang19-on": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-clang19-l3-on",
+    "gcc14-default": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-gcc14-l3-default",
+}
+CAMERAS = {
+    "surface-world": "0,-35,-487.94,0,-22",
+    "floating-islands": "0,0,-32,0,-22",
+}
+HASH_RE = re.compile(
+    r"\[PipelineWholeViewHash\] tiles=(\d+) density=0x([0-9a-f]+) "
+    r"mesh=0x([0-9a-f]+) payload=0x([0-9a-f]+) topology=0x([0-9a-f]+)"
+)
+MESH_RE = re.compile(
+    r"\[PipelineMeshCoverage\] tiles=(\d+) nonempty_mesh_tiles=(\d+) indexed_triangles=(\d+)"
+)
+PLACEMENT_RE = re.compile(
+    r"\[SeedSurfacePlacement\].*camera_voxel=\(([-0-9.]+),([-0-9.]+),([-0-9.]+)\) status=PASS"
+)
+READY_RE = re.compile(r"\[StreamPipeline\].*whole_view_ready=([0-9.]+)s")
+RESOURCE_RE = re.compile(
+    r"\[ProcessResources\] exit_code=(-?\d+) wall_s=([0-9.]+) peak_rss_kib=(\d+)"
+)
+
+
+def main() -> int:
+    if len(sys.argv) > 2:
+        raise SystemExit("usage: RunSeedSweep.py [budget-seconds; default 1800]")
+    budget = int(sys.argv[1]) if len(sys.argv) == 2 else 1800
+    seeds = [int(line.strip()) for line in SEEDS.read_text().splitlines() if line.strip()]
+    if len(seeds) != 48 or len(set(seeds)) != 48:
+        raise SystemExit("expected the 48 unique signed int32 L2 seeds")
+    missing = [str(path) for path in [MEASURE, DATA, *BINARIES.values()] if not path.is_file()]
+    if missing:
+        raise SystemExit("missing sweep input/build: " + ", ".join(missing))
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    output_path = ROUND / "seed_mesh_coverage.csv"
+    fields = [
+        "seed", "recipe", "compiler_setting", "workers", "tiles",
+        "nonempty_mesh_tiles", "indexed_triangles", "camera_x_vox", "camera_y_vox", "camera_z_vox",
+        "density_hash", "mesh_hash", "payload_hash", "topology_hash",
+        "whole_view_ready_s", "wall_s", "peak_rss_kib", "exit_code", "status",
+    ]
+    started = time.monotonic()
+    total = len(seeds) * len(CAMERAS) * len(BINARIES) * 2
+    print(f"L3 sweep: {len(seeds)} seeds x 2 recipes x 3 builds x W1/W12 = {total}; budget={budget}s", flush=True)
+    with output_path.open("w", newline="") as csv_file:
+        writer = csv.DictWriter(csv_file, fieldnames=fields)
+        writer.writeheader()
+        completed = 0
+        for seed in seeds:
+            for recipe, camera in CAMERAS.items():
+                for compiler, binary in BINARIES.items():
+                    for workers in (1, 12):
+                        remaining = budget - (time.monotonic() - started)
+                        if remaining <= 0:
+                            print("L3 sweep exceeded its 30-minute budget; stopping.", file=sys.stderr, flush=True)
+                            return 124
+                        stem = f"linux3-seed-{seed}-{recipe}-{compiler}-w{workers}"
+                        log_path = LOG_DIR / f"{stem}.log"
+                        args = [
+                            str(binary), str(DATA), f"--seed={seed}", f"--recipe={recipe}",
+                            "--render-distance-chunks=0", f"--workers={workers}",
+                            "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+                            "--stream-hash", "--mesh-coverage", "--auto-surface-camera", "--force-generate",
+                            "--clip-radius=1", "--max-clip-level=0", f"--camera={camera}",
+                            "--far-horizon-lod8-step=0",
+                        ]
+                        command = [
+                            "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+                            "python3", str(MEASURE), *args,
+                        ]
+                        with log_path.open("w") as log_file:
+                            log_file.write("[SweepCommand] " + " ".join(command) + "\n")
+                            log_file.flush()
+                            try:
+                                result = subprocess.run(
+                                    command, cwd=ROOT, stdout=log_file, stderr=subprocess.STDOUT,
+                                    timeout=min(900, max(1, remaining)), check=False,
+                                )
+                                exit_code = result.returncode
+                            except subprocess.TimeoutExpired:
+                                exit_code = 124
+                                log_file.write("\n[SweepTimeout] row reached its allotted limit\n")
+
+                        output = log_path.read_text(errors="replace")
+                        hashes = HASH_RE.search(output)
+                        mesh = MESH_RE.search(output)
+                        placement = PLACEMENT_RE.search(output)
+                        ready = READY_RE.search(output)
+                        resources = RESOURCE_RE.search(output)
+                        passed = bool(
+                            exit_code == 0 and hashes and mesh and placement and ready and resources
+                            and int(hashes.group(1)) == 27 and int(mesh.group(1)) == 27
+                            and int(mesh.group(2)) > 0 and int(mesh.group(3)) > 0
+                            and int(resources.group(1)) == 0
+                        )
+                        row = {
+                            "seed": seed, "recipe": recipe, "compiler_setting": compiler, "workers": workers,
+                            "tiles": mesh.group(1) if mesh else "",
+                            "nonempty_mesh_tiles": mesh.group(2) if mesh else "",
+                            "indexed_triangles": mesh.group(3) if mesh else "",
+                            "camera_x_vox": placement.group(1) if placement else "",
+                            "camera_y_vox": placement.group(2) if placement else "",
+                            "camera_z_vox": placement.group(3) if placement else "",
+                            "density_hash": "0x" + hashes.group(2) if hashes else "",
+                            "mesh_hash": "0x" + hashes.group(3) if hashes else "",
+                            "payload_hash": "0x" + hashes.group(4) if hashes else "",
+                            "topology_hash": "0x" + hashes.group(5) if hashes else "",
+                            "whole_view_ready_s": ready.group(1) if ready else "",
+                            "wall_s": resources.group(2) if resources else "",
+                            "peak_rss_kib": resources.group(3) if resources else "",
+                            "exit_code": exit_code, "status": "PASS" if passed else "FAIL",
+                        }
+                        writer.writerow(row)
+                        csv_file.flush()
+                        completed += 1
+                        print(
+                            f"[{completed}/{total}] seed={seed} recipe={recipe} build={compiler} W{workers} "
+                            f"nonempty={row['nonempty_mesh_tiles']}/27 triangles={row['indexed_triangles']} "
+                            f"wall={row['wall_s']}s status={row['status']} elapsed={time.monotonic()-started:.1f}s",
+                            flush=True,
+                        )
+                        if not passed:
+                            print(f"Failed row log: {log_path}", file=sys.stderr, flush=True)
+                            return exit_code or 1
+
+    rows = list(csv.DictReader(output_path.open(newline="")))
+    hash_columns = ("density_hash", "mesh_hash", "payload_hash", "topology_hash")
+    compiler_checks = []
+    worker_checks = []
+    for seed in seeds:
+        for recipe in CAMERAS:
+            for workers in (1, 12):
+                pair = [r for r in rows if int(r["seed"]) == seed and r["recipe"] == recipe
+                        and int(r["workers"]) == workers]
+                compiler_checks.append(len(pair) == len(BINARIES)
+                    and all(all(row[key] == pair[0][key] for key in hash_columns) for row in pair))
+            for compiler in BINARIES:
+                pair = [r for r in rows if int(r["seed"]) == seed and r["recipe"] == recipe
+                        and r["compiler_setting"] == compiler]
+                worker_checks.append(len(pair) == 2
+                    and all(all(row[key] == pair[0][key] for key in hash_columns) for row in pair))
+    elapsed = time.monotonic() - started
+    maximum_rss = max(int(row["peak_rss_kib"]) for row in rows)
+    empty_rows = sum(int(row["nonempty_mesh_tiles"]) == 0 or int(row["indexed_triangles"]) == 0 for row in rows)
+    summary = (
+        f"runs={len(rows)} seeds={len(seeds)} recipes={len(CAMERAS)} builds={len(BINARIES)} workers=1,12 "
+        f"cross_build_checks={len(compiler_checks)} cross_build_mismatches={sum(not x for x in compiler_checks)} "
+        f"worker_checks={len(worker_checks)} worker_mismatches={sum(not x for x in worker_checks)} "
+        f"empty_mesh_rows={empty_rows} max_peak_rss_kib={maximum_rss} elapsed_s={elapsed:.3f}\n"
+    )
+    (ROUND / "seed_mesh_coverage_summary.txt").write_text(summary)
+    print(summary, end="", flush=True)
+    return 0 if all(compiler_checks) and all(worker_checks) and empty_rows == 0 and elapsed <= budget else 3
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Standalone/Research/WorldAssemblerM3/Linux3/seed_mesh_coverage.csv

@@ -0,0 +1,577 @@
+seed,recipe,compiler_setting,workers,tiles,nonempty_mesh_tiles,indexed_triangles,camera_x_vox,camera_y_vox,camera_z_vox,density_hash,mesh_hash,payload_hash,topology_hash,whole_view_ready_s,wall_s,peak_rss_kib,exit_code,status
+-1990830953,surface-world,clang19-off,1,27,9,26366,0.000000,-140.000000,-2021.785156,0x125d085ff63ece8a,0x3f219420ffe76ceb,0x386c66f61f66fde5,0x9fc08404031eb99b,0.162,0.180221,84360,0,PASS
+-1990830953,surface-world,clang19-off,12,27,9,26366,0.000000,-140.000000,-2021.785156,0x125d085ff63ece8a,0x3f219420ffe76ceb,0x386c66f61f66fde5,0x9fc08404031eb99b,0.397,0.424425,294988,0,PASS
+-1990830953,surface-world,clang19-on,1,27,9,26366,0.000000,-140.000000,-2021.785156,0x125d085ff63ece8a,0x3f219420ffe76ceb,0x386c66f61f66fde5,0x9fc08404031eb99b,0.163,0.180433,84540,0,PASS
+-1990830953,surface-world,clang19-on,12,27,9,26366,0.000000,-140.000000,-2021.785156,0x125d085ff63ece8a,0x3f219420ffe76ceb,0x386c66f61f66fde5,0x9fc08404031eb99b,0.401,0.427873,294656,0,PASS
+-1990830953,surface-world,gcc14-default,1,27,9,26366,0.000000,-140.000000,-2021.785156,0x125d085ff63ece8a,0x3f219420ffe76ceb,0x386c66f61f66fde5,0x9fc08404031eb99b,0.152,0.167928,84996,0,PASS
+-1990830953,surface-world,gcc14-default,12,27,9,26366,0.000000,-140.000000,-2021.785156,0x125d085ff63ece8a,0x3f219420ffe76ceb,0x386c66f61f66fde5,0x9fc08404031eb99b,0.398,0.424793,295392,0,PASS
+-1990830953,floating-islands,clang19-off,1,27,12,23386,-39.199219,16.363281,-121.039062,0xc04ef8acd44d8736,0x00e92c97d841dfe5,0xb57496fb3be7da11,0x64b0c5c3655299c2,0.872,0.887909,85248,0,PASS
+-1990830953,floating-islands,clang19-off,12,27,12,23386,-39.199219,16.363281,-121.039062,0xc04ef8acd44d8736,0x00e92c97d841dfe5,0xb57496fb3be7da11,0x64b0c5c3655299c2,0.549,0.575731,300132,0,PASS
+-1990830953,floating-islands,clang19-on,1,27,12,23386,-39.199219,16.363281,-121.039062,0xc04ef8acd44d8736,0x00e92c97d841dfe5,0xb57496fb3be7da11,0x64b0c5c3655299c2,0.884,0.901147,85000,0,PASS
+-1990830953,floating-islands,clang19-on,12,27,12,23386,-39.199219,16.363281,-121.039062,0xc04ef8acd44d8736,0x00e92c97d841dfe5,0xb57496fb3be7da11,0x64b0c5c3655299c2,0.578,0.605578,299564,0,PASS
+-1990830953,floating-islands,gcc14-default,1,27,12,23386,-39.199219,16.363281,-121.039062,0xc04ef8acd44d8736,0x00e92c97d841dfe5,0xb57496fb3be7da11,0x64b0c5c3655299c2,0.943,0.959068,85752,0,PASS
+-1990830953,floating-islands,gcc14-default,12,27,12,23386,-39.199219,16.363281,-121.039062,0xc04ef8acd44d8736,0x00e92c97d841dfe5,0xb57496fb3be7da11,0x64b0c5c3655299c2,0.588,0.614935,300548,0,PASS
+-1900684165,surface-world,clang19-off,1,27,10,27890,0.000000,-140.000000,-2011.214844,0xcc9819b02bd2f880,0x8cbe19f740d2b408,0xbe822577766381d4,0x69b6a50c6286fdf7,0.185,0.202214,89956,0,PASS
+-1900684165,surface-world,clang19-off,12,27,10,27890,0.000000,-140.000000,-2011.214844,0xcc9819b02bd2f880,0x8cbe19f740d2b408,0xbe822577766381d4,0x69b6a50c6286fdf7,0.418,0.446199,301944,0,PASS
+-1900684165,surface-world,clang19-on,1,27,10,27890,0.000000,-140.000000,-2011.214844,0xcc9819b02bd2f880,0x8cbe19f740d2b408,0xbe822577766381d4,0x69b6a50c6286fdf7,0.177,0.193134,89684,0,PASS
+-1900684165,surface-world,clang19-on,12,27,10,27890,0.000000,-140.000000,-2011.214844,0xcc9819b02bd2f880,0x8cbe19f740d2b408,0xbe822577766381d4,0x69b6a50c6286fdf7,0.438,0.466528,301656,0,PASS
+-1900684165,surface-world,gcc14-default,1,27,10,27890,0.000000,-140.000000,-2011.214844,0xcc9819b02bd2f880,0x8cbe19f740d2b408,0xbe822577766381d4,0x69b6a50c6286fdf7,0.180,0.196807,90492,0,PASS
+-1900684165,surface-world,gcc14-default,12,27,10,27890,0.000000,-140.000000,-2011.214844,0xcc9819b02bd2f880,0x8cbe19f740d2b408,0xbe822577766381d4,0x69b6a50c6286fdf7,0.442,0.468384,300628,0,PASS
+-1900684165,floating-islands,clang19-off,1,27,10,23186,39.199219,17.675781,-116.339844,0xfc7386c15431e2e1,0x46ce25dfb3745f53,0x97c9ffd0022012ad,0x64303145c5cc6d24,1.558,1.574129,89380,0,PASS
+-1900684165,floating-islands,clang19-off,12,27,10,23186,39.199219,17.675781,-116.339844,0xfc7386c15431e2e1,0x46ce25dfb3745f53,0x97c9ffd0022012ad,0x64303145c5cc6d24,0.699,0.726109,303932,0,PASS
+-1900684165,floating-islands,clang19-on,1,27,10,23186,39.199219,17.675781,-116.339844,0xfc7386c15431e2e1,0x46ce25dfb3745f53,0x97c9ffd0022012ad,0x64303145c5cc6d24,1.599,1.615516,89308,0,PASS
+-1900684165,floating-islands,clang19-on,12,27,10,23186,39.199219,17.675781,-116.339844,0xfc7386c15431e2e1,0x46ce25dfb3745f53,0x97c9ffd0022012ad,0x64303145c5cc6d24,0.727,0.755017,303964,0,PASS
+-1900684165,floating-islands,gcc14-default,1,27,10,23186,39.199219,17.675781,-116.339844,0xfc7386c15431e2e1,0x46ce25dfb3745f53,0x97c9ffd0022012ad,0x64303145c5cc6d24,1.692,1.708073,89664,0,PASS
+-1900684165,floating-islands,gcc14-default,12,27,10,23186,39.199219,17.675781,-116.339844,0xfc7386c15431e2e1,0x46ce25dfb3745f53,0x97c9ffd0022012ad,0x64303145c5cc6d24,0.763,0.790272,304528,0,PASS
+-1766412538,surface-world,clang19-off,1,27,9,27572,0.000000,-140.000000,-2004.851562,0x4d04ec633754c4ec,0xca8833dcfe9639d3,0x0a4008899d91f10e,0x2d6116327735df9a,0.181,0.196881,84084,0,PASS
+-1766412538,surface-world,clang19-off,12,27,9,27572,0.000000,-140.000000,-2004.851562,0x4d04ec633754c4ec,0xca8833dcfe9639d3,0x0a4008899d91f10e,0x2d6116327735df9a,0.414,0.439405,294580,0,PASS
+-1766412538,surface-world,clang19-on,1,27,9,27572,0.000000,-140.000000,-2004.851562,0x4d04ec633754c4ec,0xca8833dcfe9639d3,0x0a4008899d91f10e,0x2d6116327735df9a,0.181,0.196772,84172,0,PASS
+-1766412538,surface-world,clang19-on,12,27,9,27572,0.000000,-140.000000,-2004.851562,0x4d04ec633754c4ec,0xca8833dcfe9639d3,0x0a4008899d91f10e,0x2d6116327735df9a,0.412,0.438983,294880,0,PASS
+-1766412538,surface-world,gcc14-default,1,27,9,27572,0.000000,-140.000000,-2004.851562,0x4d04ec633754c4ec,0xca8833dcfe9639d3,0x0a4008899d91f10e,0x2d6116327735df9a,0.175,0.192855,84688,0,PASS
+-1766412538,surface-world,gcc14-default,12,27,9,27572,0.000000,-140.000000,-2004.851562,0x4d04ec633754c4ec,0xca8833dcfe9639d3,0x0a4008899d91f10e,0x2d6116327735df9a,0.430,0.455090,295516,0,PASS
+-1766412538,floating-islands,clang19-off,1,27,12,23618,-25.199219,-73.816406,-135.394531,0xdb6557b98f29060e,0x3b3147a1d020ca02,0x010127525a940a1e,0xc9563575ca60b627,1.542,1.556645,86260,0,PASS
+-1766412538,floating-islands,clang19-off,12,27,12,23618,-25.199219,-73.816406,-135.394531,0xdb6557b98f29060e,0x3b3147a1d020ca02,0x010127525a940a1e,0xc9563575ca60b627,0.673,0.699377,300448,0,PASS
+-1766412538,floating-islands,clang19-on,1,27,12,23618,-25.199219,-73.816406,-135.394531,0xdb6557b98f29060e,0x3b3147a1d020ca02,0x010127525a940a1e,0xc9563575ca60b627,1.587,1.602433,86588,0,PASS
+-1766412538,floating-islands,clang19-on,12,27,12,23618,-25.199219,-73.816406,-135.394531,0xdb6557b98f29060e,0x3b3147a1d020ca02,0x010127525a940a1e,0xc9563575ca60b627,0.702,0.728925,300536,0,PASS
+-1766412538,floating-islands,gcc14-default,1,27,12,23618,-25.199219,-73.816406,-135.394531,0xdb6557b98f29060e,0x3b3147a1d020ca02,0x010127525a940a1e,0xc9563575ca60b627,1.744,1.760677,87052,0,PASS
+-1766412538,floating-islands,gcc14-default,12,27,12,23618,-25.199219,-73.816406,-135.394531,0xdb6557b98f29060e,0x3b3147a1d020ca02,0x010127525a940a1e,0xc9563575ca60b627,0.741,0.770803,301248,0,PASS
+-1721984596,surface-world,clang19-off,1,27,9,27374,0.000000,-140.000000,-2006.878906,0x65b6ae0a3a1fdd35,0x117d40e403c960bc,0x9bc7a92591e7d7e3,0x988675caf5879337,0.172,0.187451,84428,0,PASS
+-1721984596,surface-world,clang19-off,12,27,9,27374,0.000000,-140.000000,-2006.878906,0x65b6ae0a3a1fdd35,0x117d40e403c960bc,0x9bc7a92591e7d7e3,0x988675caf5879337,0.424,0.450959,294996,0,PASS
+-1721984596,surface-world,clang19-on,1,27,9,27374,0.000000,-140.000000,-2006.878906,0x65b6ae0a3a1fdd35,0x117d40e403c960bc,0x9bc7a92591e7d7e3,0x988675caf5879337,0.183,0.199333,84536,0,PASS
+-1721984596,surface-world,clang19-on,12,27,9,27374,0.000000,-140.000000,-2006.878906,0x65b6ae0a3a1fdd35,0x117d40e403c960bc,0x9bc7a92591e7d7e3,0x988675caf5879337,0.426,0.452557,294916,0,PASS
+-1721984596,surface-world,gcc14-default,1,27,9,27374,0.000000,-140.000000,-2006.878906,0x65b6ae0a3a1fdd35,0x117d40e403c960bc,0x9bc7a92591e7d7e3,0x988675caf5879337,0.178,0.193728,85196,0,PASS
+-1721984596,surface-world,gcc14-default,12,27,9,27374,0.000000,-140.000000,-2006.878906,0x65b6ae0a3a1fdd35,0x117d40e403c960bc,0x9bc7a92591e7d7e3,0x988675caf5879337,0.427,0.454505,295184,0,PASS
+-1721984596,floating-islands,clang19-off,1,27,10,23728,64.398438,74.085938,-128.433594,0xbb7777932cd3328a,0x5d7243f5afb8902a,0xdb6cef72728d0d64,0x625882823c87a40b,1.554,1.570584,85220,0,PASS
+-1721984596,floating-islands,clang19-off,12,27,10,23728,64.398438,74.085938,-128.433594,0xbb7777932cd3328a,0x5d7243f5afb8902a,0xdb6cef72728d0d64,0x625882823c87a40b,0.718,0.745795,300772,0,PASS
+-1721984596,floating-islands,clang19-on,1,27,10,23728,64.398438,74.085938,-128.433594,0xbb7777932cd3328a,0x5d7243f5afb8902a,0xdb6cef72728d0d64,0x625882823c87a40b,1.578,1.593432,85580,0,PASS
+-1721984596,floating-islands,clang19-on,12,27,10,23728,64.398438,74.085938,-128.433594,0xbb7777932cd3328a,0x5d7243f5afb8902a,0xdb6cef72728d0d64,0x625882823c87a40b,0.708,0.734658,299780,0,PASS
+-1721984596,floating-islands,gcc14-default,1,27,10,23728,64.398438,74.085938,-128.433594,0xbb7777932cd3328a,0x5d7243f5afb8902a,0xdb6cef72728d0d64,0x625882823c87a40b,1.714,1.730034,85816,0,PASS
+-1721984596,floating-islands,gcc14-default,12,27,10,23728,64.398438,74.085938,-128.433594,0xbb7777932cd3328a,0x5d7243f5afb8902a,0xdb6cef72728d0d64,0x625882823c87a40b,0.757,0.784127,301460,0,PASS
+-1239598758,surface-world,clang19-off,1,27,15,38978,0.000000,-140.000000,-2001.816406,0x8aaf7c7c610e550f,0xeaa948233176c456,0x32c71b1231361cd2,0xecd43272e8d589a7,0.269,0.284560,84356,0,PASS
+-1239598758,surface-world,clang19-off,12,27,15,38978,0.000000,-140.000000,-2001.816406,0x8aaf7c7c610e550f,0xeaa948233176c456,0x32c71b1231361cd2,0xecd43272e8d589a7,0.447,0.473801,299712,0,PASS
+-1239598758,surface-world,clang19-on,1,27,15,38978,0.000000,-140.000000,-2001.816406,0x8aaf7c7c610e550f,0xeaa948233176c456,0x32c71b1231361cd2,0xecd43272e8d589a7,0.277,0.293296,84584,0,PASS
+-1239598758,surface-world,clang19-on,12,27,15,38978,0.000000,-140.000000,-2001.816406,0x8aaf7c7c610e550f,0xeaa948233176c456,0x32c71b1231361cd2,0xecd43272e8d589a7,0.460,0.486378,298388,0,PASS
+-1239598758,surface-world,gcc14-default,1,27,15,38978,0.000000,-140.000000,-2001.816406,0x8aaf7c7c610e550f,0xeaa948233176c456,0x32c71b1231361cd2,0xecd43272e8d589a7,0.261,0.276573,84996,0,PASS
+-1239598758,surface-world,gcc14-default,12,27,15,38978,0.000000,-140.000000,-2001.816406,0x8aaf7c7c610e550f,0xeaa948233176c456,0x32c71b1231361cd2,0xecd43272e8d589a7,0.464,0.492223,300696,0,PASS
+-1239598758,floating-islands,clang19-off,1,27,12,28162,39.199219,19.425781,-116.691406,0x9ee03f2326224bbc,0x0ea03da61381b41a,0x4b658d0bd4e527e6,0x402b075c754192e3,1.280,1.297085,85588,0,PASS
+-1239598758,floating-islands,clang19-off,12,27,12,28162,39.199219,19.425781,-116.691406,0x9ee03f2326224bbc,0x0ea03da61381b41a,0x4b658d0bd4e527e6,0x402b075c754192e3,0.642,0.669720,300940,0,PASS
+-1239598758,floating-islands,clang19-on,1,27,12,28162,39.199219,19.425781,-116.691406,0x9ee03f2326224bbc,0x0ea03da61381b41a,0x4b658d0bd4e527e6,0x402b075c754192e3,1.324,1.342774,85712,0,PASS
+-1239598758,floating-islands,clang19-on,12,27,12,28162,39.199219,19.425781,-116.691406,0x9ee03f2326224bbc,0x0ea03da61381b41a,0x4b658d0bd4e527e6,0x402b075c754192e3,0.637,0.664175,300712,0,PASS
+-1239598758,floating-islands,gcc14-default,1,27,12,28162,39.199219,19.425781,-116.691406,0x9ee03f2326224bbc,0x0ea03da61381b41a,0x4b658d0bd4e527e6,0x402b075c754192e3,1.465,1.480710,85820,0,PASS
+-1239598758,floating-islands,gcc14-default,12,27,12,28162,39.199219,19.425781,-116.691406,0x9ee03f2326224bbc,0x0ea03da61381b41a,0x4b658d0bd4e527e6,0x402b075c754192e3,0.678,0.706467,301428,0,PASS
+-1085993262,surface-world,clang19-off,1,27,13,30779,0.000000,-140.000000,-2018.355469,0x6dd63983ab04ee63,0x606e6964e1b2bfa0,0x30f2ccb9c65750ff,0x72fb3b77904151b8,0.203,0.219019,84900,0,PASS
+-1085993262,surface-world,clang19-off,12,27,13,30779,0.000000,-140.000000,-2018.355469,0x6dd63983ab04ee63,0x606e6964e1b2bfa0,0x30f2ccb9c65750ff,0x72fb3b77904151b8,0.442,0.468936,300076,0,PASS
+-1085993262,surface-world,clang19-on,1,27,13,30779,0.000000,-140.000000,-2018.355469,0x6dd63983ab04ee63,0x606e6964e1b2bfa0,0x30f2ccb9c65750ff,0x72fb3b77904151b8,0.209,0.226037,84848,0,PASS
+-1085993262,surface-world,clang19-on,12,27,13,30779,0.000000,-140.000000,-2018.355469,0x6dd63983ab04ee63,0x606e6964e1b2bfa0,0x30f2ccb9c65750ff,0x72fb3b77904151b8,0.434,0.461038,299916,0,PASS
+-1085993262,surface-world,gcc14-default,1,27,13,30779,0.000000,-140.000000,-2018.355469,0x6dd63983ab04ee63,0x606e6964e1b2bfa0,0x30f2ccb9c65750ff,0x72fb3b77904151b8,0.194,0.212574,85588,0,PASS
+-1085993262,surface-world,gcc14-default,12,27,13,30779,0.000000,-140.000000,-2018.355469,0x6dd63983ab04ee63,0x606e6964e1b2bfa0,0x30f2ccb9c65750ff,0x72fb3b77904151b8,0.421,0.449569,300836,0,PASS
+-1085993262,floating-islands,clang19-off,1,27,11,25186,-39.199219,16.968750,-116.531250,0x8dec867557d4e27c,0x13de3a8f9465573d,0x2e2ca36cfff2558a,0x42ad0d371549e563,1.085,1.101264,86672,0,PASS
+-1085993262,floating-islands,clang19-off,12,27,11,25186,-39.199219,16.968750,-116.531250,0x8dec867557d4e27c,0x13de3a8f9465573d,0x2e2ca36cfff2558a,0x42ad0d371549e563,0.573,0.602307,301496,0,PASS
+-1085993262,floating-islands,clang19-on,1,27,11,25186,-39.199219,16.968750,-116.531250,0x8dec867557d4e27c,0x13de3a8f9465573d,0x2e2ca36cfff2558a,0x42ad0d371549e563,1.085,1.100702,86848,0,PASS
+-1085993262,floating-islands,clang19-on,12,27,11,25186,-39.199219,16.968750,-116.531250,0x8dec867557d4e27c,0x13de3a8f9465573d,0x2e2ca36cfff2558a,0x42ad0d371549e563,0.576,0.603241,301652,0,PASS
+-1085993262,floating-islands,gcc14-default,1,27,11,25186,-39.199219,16.968750,-116.531250,0x8dec867557d4e27c,0x13de3a8f9465573d,0x2e2ca36cfff2558a,0x42ad0d371549e563,1.195,1.210876,87352,0,PASS
+-1085993262,floating-islands,gcc14-default,12,27,11,25186,-39.199219,16.968750,-116.531250,0x8dec867557d4e27c,0x13de3a8f9465573d,0x2e2ca36cfff2558a,0x42ad0d371549e563,0.617,0.646640,302080,0,PASS
+-1033703345,surface-world,clang19-off,1,27,16,50890,0.000000,-140.000000,-1585.519531,0xe2f8c4b421a9402a,0x730fd7c4692eaff3,0xacf64857ef930634,0x86e7853e9d0b4a35,0.342,0.358880,85076,0,PASS
+-1033703345,surface-world,clang19-off,12,27,16,50890,0.000000,-140.000000,-1585.519531,0xe2f8c4b421a9402a,0x730fd7c4692eaff3,0xacf64857ef930634,0x86e7853e9d0b4a35,0.451,0.477876,301748,0,PASS
+-1033703345,surface-world,clang19-on,1,27,16,50890,0.000000,-140.000000,-1585.519531,0xe2f8c4b421a9402a,0x730fd7c4692eaff3,0xacf64857ef930634,0x86e7853e9d0b4a35,0.318,0.334873,84996,0,PASS
+-1033703345,surface-world,clang19-on,12,27,16,50890,0.000000,-140.000000,-1585.519531,0xe2f8c4b421a9402a,0x730fd7c4692eaff3,0xacf64857ef930634,0x86e7853e9d0b4a35,0.461,0.490652,301616,0,PASS
+-1033703345,surface-world,gcc14-default,1,27,16,50890,0.000000,-140.000000,-1585.519531,0xe2f8c4b421a9402a,0x730fd7c4692eaff3,0xacf64857ef930634,0x86e7853e9d0b4a35,0.305,0.322211,85560,0,PASS
+-1033703345,surface-world,gcc14-default,12,27,16,50890,0.000000,-140.000000,-1585.519531,0xe2f8c4b421a9402a,0x730fd7c4692eaff3,0xacf64857ef930634,0x86e7853e9d0b4a35,0.476,0.502916,302484,0,PASS
+-1033703345,floating-islands,clang19-off,1,27,10,17406,-25.199219,-75.605469,-128.097656,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590,0x570a869c76c15846,0x8139f7fb5146e402,2.065,2.083040,86192,0,PASS
+-1033703345,floating-islands,clang19-off,12,27,10,17406,-25.199219,-75.605469,-128.097656,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590,0x570a869c76c15846,0x8139f7fb5146e402,0.776,0.804394,299624,0,PASS
+-1033703345,floating-islands,clang19-on,1,27,10,17406,-25.199219,-75.605469,-128.097656,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590,0x570a869c76c15846,0x8139f7fb5146e402,1.996,2.016862,86136,0,PASS
+-1033703345,floating-islands,clang19-on,12,27,10,17406,-25.199219,-75.605469,-128.097656,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590,0x570a869c76c15846,0x8139f7fb5146e402,0.841,0.879778,299580,0,PASS
+-1033703345,floating-islands,gcc14-default,1,27,10,17406,-25.199219,-75.605469,-128.097656,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590,0x570a869c76c15846,0x8139f7fb5146e402,1.997,2.013598,86416,0,PASS
+-1033703345,floating-islands,gcc14-default,12,27,10,17406,-25.199219,-75.605469,-128.097656,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590,0x570a869c76c15846,0x8139f7fb5146e402,0.820,0.848116,300464,0,PASS
+-854671705,surface-world,clang19-off,1,27,10,26198,0.000000,-140.000000,-2018.242188,0x0a9e017447ffff3d,0x807299923966d5be,0xdd97f14916c8157a,0x95313b997ff55c26,0.216,0.232793,83632,0,PASS
+-854671705,surface-world,clang19-off,12,27,10,26198,0.000000,-140.000000,-2018.242188,0x0a9e017447ffff3d,0x807299923966d5be,0xdd97f14916c8157a,0x95313b997ff55c26,0.462,0.492727,295640,0,PASS
+-854671705,surface-world,clang19-on,1,27,10,26198,0.000000,-140.000000,-2018.242188,0x0a9e017447ffff3d,0x807299923966d5be,0xdd97f14916c8157a,0x95313b997ff55c26,0.210,0.225523,83756,0,PASS
+-854671705,surface-world,clang19-on,12,27,10,26198,0.000000,-140.000000,-2018.242188,0x0a9e017447ffff3d,0x807299923966d5be,0xdd97f14916c8157a,0x95313b997ff55c26,0.460,0.486882,295460,0,PASS
+-854671705,surface-world,gcc14-default,1,27,10,26198,0.000000,-140.000000,-2018.242188,0x0a9e017447ffff3d,0x807299923966d5be,0xdd97f14916c8157a,0x95313b997ff55c26,0.204,0.220779,84224,0,PASS
+-854671705,surface-world,gcc14-default,12,27,10,26198,0.000000,-140.000000,-2018.242188,0x0a9e017447ffff3d,0x807299923966d5be,0xdd97f14916c8157a,0x95313b997ff55c26,0.447,0.476285,295724,0,PASS
+-854671705,floating-islands,clang19-off,1,27,13,39000,0.000000,-19.800781,-116.507812,0xbb5718ca3ad4c181,0x3250d2591365d443,0xec60f80b7f67216b,0xfe710427da53178b,1.858,1.873454,84868,0,PASS
+-854671705,floating-islands,clang19-off,12,27,13,39000,0.000000,-19.800781,-116.507812,0xbb5718ca3ad4c181,0x3250d2591365d443,0xec60f80b7f67216b,0xfe710427da53178b,0.769,0.797051,301256,0,PASS
+-854671705,floating-islands,clang19-on,1,27,13,39000,0.000000,-19.800781,-116.507812,0xbb5718ca3ad4c181,0x3250d2591365d443,0xec60f80b7f67216b,0xfe710427da53178b,1.927,1.944057,84916,0,PASS
+-854671705,floating-islands,clang19-on,12,27,13,39000,0.000000,-19.800781,-116.507812,0xbb5718ca3ad4c181,0x3250d2591365d443,0xec60f80b7f67216b,0xfe710427da53178b,0.798,0.826241,300776,0,PASS
+-854671705,floating-islands,gcc14-default,1,27,13,39000,0.000000,-19.800781,-116.507812,0xbb5718ca3ad4c181,0x3250d2591365d443,0xec60f80b7f67216b,0xfe710427da53178b,1.908,1.924264,85304,0,PASS
+-854671705,floating-islands,gcc14-default,12,27,13,39000,0.000000,-19.800781,-116.507812,0xbb5718ca3ad4c181,0x3250d2591365d443,0xec60f80b7f67216b,0xfe710427da53178b,0.804,0.831547,301148,0,PASS
+-713963806,surface-world,clang19-off,1,27,16,30292,0.000000,-140.000000,-2018.582031,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6,0x3f6ba7ffdf385024,0x7183d3025a48e8ea,0.211,0.228046,85784,0,PASS
+-713963806,surface-world,clang19-off,12,27,16,30292,0.000000,-140.000000,-2018.582031,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6,0x3f6ba7ffdf385024,0x7183d3025a48e8ea,0.443,0.470682,300976,0,PASS
+-713963806,surface-world,clang19-on,1,27,16,30292,0.000000,-140.000000,-2018.582031,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6,0x3f6ba7ffdf385024,0x7183d3025a48e8ea,0.210,0.226264,86008,0,PASS
+-713963806,surface-world,clang19-on,12,27,16,30292,0.000000,-140.000000,-2018.582031,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6,0x3f6ba7ffdf385024,0x7183d3025a48e8ea,0.416,0.444035,300924,0,PASS
+-713963806,surface-world,gcc14-default,1,27,16,30292,0.000000,-140.000000,-2018.582031,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6,0x3f6ba7ffdf385024,0x7183d3025a48e8ea,0.214,0.230669,86420,0,PASS
+-713963806,surface-world,gcc14-default,12,27,16,30292,0.000000,-140.000000,-2018.582031,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6,0x3f6ba7ffdf385024,0x7183d3025a48e8ea,0.417,0.445410,301040,0,PASS
+-713963806,floating-islands,clang19-off,1,27,8,16002,64.398438,74.308594,-120.453125,0xd590c16395cc515f,0x3a62d63b76bdd260,0x9424147669e1808f,0x137dd286dcedcad6,1.356,1.372073,84768,0,PASS
+-713963806,floating-islands,clang19-off,12,27,8,16002,64.398438,74.308594,-120.453125,0xd590c16395cc515f,0x3a62d63b76bdd260,0x9424147669e1808f,0x137dd286dcedcad6,0.676,0.703891,297840,0,PASS
+-713963806,floating-islands,clang19-on,1,27,8,16002,64.398438,74.308594,-120.453125,0xd590c16395cc515f,0x3a62d63b76bdd260,0x9424147669e1808f,0x137dd286dcedcad6,1.360,1.376357,84572,0,PASS
+-713963806,floating-islands,clang19-on,12,27,8,16002,64.398438,74.308594,-120.453125,0xd590c16395cc515f,0x3a62d63b76bdd260,0x9424147669e1808f,0x137dd286dcedcad6,0.655,0.682658,297928,0,PASS
+-713963806,floating-islands,gcc14-default,1,27,8,16002,64.398438,74.308594,-120.453125,0xd590c16395cc515f,0x3a62d63b76bdd260,0x9424147669e1808f,0x137dd286dcedcad6,1.293,1.309713,85500,0,PASS
+-713963806,floating-islands,gcc14-default,12,27,8,16002,64.398438,74.308594,-120.453125,0xd590c16395cc515f,0x3a62d63b76bdd260,0x9424147669e1808f,0x137dd286dcedcad6,0.656,0.682912,298628,0,PASS
+-621039221,surface-world,clang19-off,1,27,17,30168,0.000000,-140.000000,-2015.613281,0xa27c25107de22a4d,0xde2ffe789eb7fb05,0x966dae7a483679d3,0xf608770036c256a5,0.195,0.211023,85856,0,PASS
+-621039221,surface-world,clang19-off,12,27,17,30168,0.000000,-140.000000,-2015.613281,0xa27c25107de22a4d,0xde2ffe789eb7fb05,0x966dae7a483679d3,0xf608770036c256a5,0.426,0.453981,301240,0,PASS
+-621039221,surface-world,clang19-on,1,27,17,30168,0.000000,-140.000000,-2015.613281,0xa27c25107de22a4d,0xde2ffe789eb7fb05,0x966dae7a483679d3,0xf608770036c256a5,0.192,0.208197,86544,0,PASS
+-621039221,surface-world,clang19-on,12,27,17,30168,0.000000,-140.000000,-2015.613281,0xa27c25107de22a4d,0xde2ffe789eb7fb05,0x966dae7a483679d3,0xf608770036c256a5,0.427,0.454462,301016,0,PASS
+-621039221,surface-world,gcc14-default,1,27,17,30168,0.000000,-140.000000,-2015.613281,0xa27c25107de22a4d,0xde2ffe789eb7fb05,0x966dae7a483679d3,0xf608770036c256a5,0.194,0.212277,86740,0,PASS
+-621039221,surface-world,gcc14-default,12,27,17,30168,0.000000,-140.000000,-2015.613281,0xa27c25107de22a4d,0xde2ffe789eb7fb05,0x966dae7a483679d3,0xf608770036c256a5,0.407,0.437082,301508,0,PASS
+-621039221,floating-islands,clang19-off,1,27,15,46224,0.000000,-18.796875,-116.769531,0x8bf4ceae8c1ddbf6,0x61557967c37529fe,0xbe41280640aaac59,0xd511ae5cd4a47551,1.622,1.638054,87236,0,PASS
+-621039221,floating-islands,clang19-off,12,27,15,46224,0.000000,-18.796875,-116.769531,0x8bf4ceae8c1ddbf6,0x61557967c37529fe,0xbe41280640aaac59,0xd511ae5cd4a47551,0.688,0.715350,304400,0,PASS
+-621039221,floating-islands,clang19-on,1,27,15,46224,0.000000,-18.796875,-116.769531,0x8bf4ceae8c1ddbf6,0x61557967c37529fe,0xbe41280640aaac59,0xd511ae5cd4a47551,1.623,1.638541,87444,0,PASS
+-621039221,floating-islands,clang19-on,12,27,15,46224,0.000000,-18.796875,-116.769531,0x8bf4ceae8c1ddbf6,0x61557967c37529fe,0xbe41280640aaac59,0xd511ae5cd4a47551,0.717,0.744065,303692,0,PASS
+-621039221,floating-islands,gcc14-default,1,27,15,46224,0.000000,-18.796875,-116.769531,0x8bf4ceae8c1ddbf6,0x61557967c37529fe,0xbe41280640aaac59,0xd511ae5cd4a47551,1.757,1.775436,87644,0,PASS
+-621039221,floating-islands,gcc14-default,12,27,15,46224,0.000000,-18.796875,-116.769531,0x8bf4ceae8c1ddbf6,0x61557967c37529fe,0xbe41280640aaac59,0xd511ae5cd4a47551,0.731,0.760059,304508,0,PASS
+-474448608,surface-world,clang19-off,1,27,11,28424,0.000000,-140.000000,-2020.160156,0x0d40ad842a0123ea,0x273fb800c1246cac,0x7a8c602b445dc956,0xd0584f94b9e78e65,0.169,0.185724,84116,0,PASS
+-474448608,surface-world,clang19-off,12,27,11,28424,0.000000,-140.000000,-2020.160156,0x0d40ad842a0123ea,0x273fb800c1246cac,0x7a8c602b445dc956,0xd0584f94b9e78e65,0.407,0.433876,297484,0,PASS
+-474448608,surface-world,clang19-on,1,27,11,28424,0.000000,-140.000000,-2020.160156,0x0d40ad842a0123ea,0x273fb800c1246cac,0x7a8c602b445dc956,0xd0584f94b9e78e65,0.171,0.188006,84236,0,PASS
+-474448608,surface-world,clang19-on,12,27,11,28424,0.000000,-140.000000,-2020.160156,0x0d40ad842a0123ea,0x273fb800c1246cac,0x7a8c602b445dc956,0xd0584f94b9e78e65,0.435,0.461874,296040,0,PASS
+-474448608,surface-world,gcc14-default,1,27,11,28424,0.000000,-140.000000,-2020.160156,0x0d40ad842a0123ea,0x273fb800c1246cac,0x7a8c602b445dc956,0xd0584f94b9e78e65,0.165,0.180445,84884,0,PASS
+-474448608,surface-world,gcc14-default,12,27,11,28424,0.000000,-140.000000,-2020.160156,0x0d40ad842a0123ea,0x273fb800c1246cac,0x7a8c602b445dc956,0xd0584f94b9e78e65,0.426,0.453272,298176,0,PASS
+-474448608,floating-islands,clang19-off,1,27,12,26122,-39.199219,20.921875,-121.671875,0x2a634b2a3d2e38ef,0x52d2036bf1406614,0x0f3ab05afb9043d4,0x47b6e01bb7fbb7ba,1.629,1.645685,86612,0,PASS
+-474448608,floating-islands,clang19-off,12,27,12,26122,-39.199219,20.921875,-121.671875,0x2a634b2a3d2e38ef,0x52d2036bf1406614,0x0f3ab05afb9043d4,0x47b6e01bb7fbb7ba,0.726,0.754007,301436,0,PASS
+-474448608,floating-islands,clang19-on,1,27,12,26122,-39.199219,20.921875,-121.671875,0x2a634b2a3d2e38ef,0x52d2036bf1406614,0x0f3ab05afb9043d4,0x47b6e01bb7fbb7ba,1.622,1.638207,86372,0,PASS
+-474448608,floating-islands,clang19-on,12,27,12,26122,-39.199219,20.921875,-121.671875,0x2a634b2a3d2e38ef,0x52d2036bf1406614,0x0f3ab05afb9043d4,0x47b6e01bb7fbb7ba,0.718,0.747095,301408,0,PASS
+-474448608,floating-islands,gcc14-default,1,27,12,26122,-39.199219,20.921875,-121.671875,0x2a634b2a3d2e38ef,0x52d2036bf1406614,0x0f3ab05afb9043d4,0x47b6e01bb7fbb7ba,1.768,1.787964,87120,0,PASS
+-474448608,floating-islands,gcc14-default,12,27,12,26122,-39.199219,20.921875,-121.671875,0x2a634b2a3d2e38ef,0x52d2036bf1406614,0x0f3ab05afb9043d4,0x47b6e01bb7fbb7ba,0.743,0.770994,301472,0,PASS
+-432690581,surface-world,clang19-off,1,27,16,44640,0.000000,-140.000000,-1699.710938,0x3a23c958501ee719,0x45e154a2ee8b0f36,0x9077f2c785e84257,0x14d8bfb36426cbc5,0.306,0.322544,84304,0,PASS
+-432690581,surface-world,clang19-off,12,27,16,44640,0.000000,-140.000000,-1699.710938,0x3a23c958501ee719,0x45e154a2ee8b0f36,0x9077f2c785e84257,0x14d8bfb36426cbc5,0.459,0.485418,300580,0,PASS
+-432690581,surface-world,clang19-on,1,27,16,44640,0.000000,-140.000000,-1699.710938,0x3a23c958501ee719,0x45e154a2ee8b0f36,0x9077f2c785e84257,0x14d8bfb36426cbc5,0.306,0.321647,84076,0,PASS
+-432690581,surface-world,clang19-on,12,27,16,44640,0.000000,-140.000000,-1699.710938,0x3a23c958501ee719,0x45e154a2ee8b0f36,0x9077f2c785e84257,0x14d8bfb36426cbc5,0.474,0.502246,300440,0,PASS
+-432690581,surface-world,gcc14-default,1,27,16,44640,0.000000,-140.000000,-1699.710938,0x3a23c958501ee719,0x45e154a2ee8b0f36,0x9077f2c785e84257,0x14d8bfb36426cbc5,0.305,0.321094,85004,0,PASS
+-432690581,surface-world,gcc14-default,12,27,16,44640,0.000000,-140.000000,-1699.710938,0x3a23c958501ee719,0x45e154a2ee8b0f36,0x9077f2c785e84257,0x14d8bfb36426cbc5,0.479,0.507033,301668,0,PASS
+-432690581,floating-islands,clang19-off,1,27,7,20532,-39.199219,16.421875,-114.292969,0xd8b65942bf1c005c,0xe6557b8cadfb3356,0x446eeeb1e1fec3de,0x829b06ef76e4306d,1.352,1.368398,86148,0,PASS
+-432690581,floating-islands,clang19-off,12,27,7,20532,-39.199219,16.421875,-114.292969,0xd8b65942bf1c005c,0xe6557b8cadfb3356,0x446eeeb1e1fec3de,0x829b06ef76e4306d,0.661,0.690096,300352,0,PASS
+-432690581,floating-islands,clang19-on,1,27,7,20532,-39.199219,16.421875,-114.292969,0xd8b65942bf1c005c,0xe6557b8cadfb3356,0x446eeeb1e1fec3de,0x829b06ef76e4306d,1.354,1.371146,86172,0,PASS
+-432690581,floating-islands,clang19-on,12,27,7,20532,-39.199219,16.421875,-114.292969,0xd8b65942bf1c005c,0xe6557b8cadfb3356,0x446eeeb1e1fec3de,0x829b06ef76e4306d,0.657,0.685687,300432,0,PASS
+-432690581,floating-islands,gcc14-default,1,27,7,20532,-39.199219,16.421875,-114.292969,0xd8b65942bf1c005c,0xe6557b8cadfb3356,0x446eeeb1e1fec3de,0x829b06ef76e4306d,1.460,1.475496,86412,0,PASS
+-432690581,floating-islands,gcc14-default,12,27,7,20532,-39.199219,16.421875,-114.292969,0xd8b65942bf1c005c,0xe6557b8cadfb3356,0x446eeeb1e1fec3de,0x829b06ef76e4306d,0.665,0.692459,301076,0,PASS
+-380556572,surface-world,clang19-off,1,27,15,27832,0.000000,-140.000000,-2015.980469,0x54c47dd125294a9d,0x6e95e2a4fb185b89,0xdf1ac7f070338e53,0xe8b65412d19b0872,0.207,0.221590,85812,0,PASS
+-380556572,surface-world,clang19-off,12,27,15,27832,0.000000,-140.000000,-2015.980469,0x54c47dd125294a9d,0x6e95e2a4fb185b89,0xdf1ac7f070338e53,0xe8b65412d19b0872,0.437,0.466566,300296,0,PASS
+-380556572,surface-world,clang19-on,1,27,15,27832,0.000000,-140.000000,-2015.980469,0x54c47dd125294a9d,0x6e95e2a4fb185b89,0xdf1ac7f070338e53,0xe8b65412d19b0872,0.202,0.218609,85576,0,PASS
+-380556572,surface-world,clang19-on,12,27,15,27832,0.000000,-140.000000,-2015.980469,0x54c47dd125294a9d,0x6e95e2a4fb185b89,0xdf1ac7f070338e53,0xe8b65412d19b0872,0.440,0.468031,300284,0,PASS
+-380556572,surface-world,gcc14-default,1,27,15,27832,0.000000,-140.000000,-2015.980469,0x54c47dd125294a9d,0x6e95e2a4fb185b89,0xdf1ac7f070338e53,0xe8b65412d19b0872,0.190,0.205873,86136,0,PASS
+-380556572,surface-world,gcc14-default,12,27,15,27832,0.000000,-140.000000,-2015.980469,0x54c47dd125294a9d,0x6e95e2a4fb185b89,0xdf1ac7f070338e53,0xe8b65412d19b0872,0.432,0.460376,300688,0,PASS
+-380556572,floating-islands,clang19-off,1,27,10,25334,39.199219,17.386719,-117.285156,0x118f50002e1af1b1,0x57d82fed86d7545c,0xe6196a35a7e64fb8,0x094fe80cdf7fda78,0.839,0.855823,86260,0,PASS
+-380556572,floating-islands,clang19-off,12,27,10,25334,39.199219,17.386719,-117.285156,0x118f50002e1af1b1,0x57d82fed86d7545c,0xe6196a35a7e64fb8,0x094fe80cdf7fda78,0.572,0.600560,301428,0,PASS
+-380556572,floating-islands,clang19-on,1,27,10,25334,39.199219,17.386719,-117.285156,0x118f50002e1af1b1,0x57d82fed86d7545c,0xe6196a35a7e64fb8,0x094fe80cdf7fda78,0.875,0.890833,86184,0,PASS
+-380556572,floating-islands,clang19-on,12,27,10,25334,39.199219,17.386719,-117.285156,0x118f50002e1af1b1,0x57d82fed86d7545c,0xe6196a35a7e64fb8,0x094fe80cdf7fda78,0.551,0.578834,300960,0,PASS
+-380556572,floating-islands,gcc14-default,1,27,10,25334,39.199219,17.386719,-117.285156,0x118f50002e1af1b1,0x57d82fed86d7545c,0xe6196a35a7e64fb8,0x094fe80cdf7fda78,0.916,0.932667,86836,0,PASS
+-380556572,floating-islands,gcc14-default,12,27,10,25334,39.199219,17.386719,-117.285156,0x118f50002e1af1b1,0x57d82fed86d7545c,0xe6196a35a7e64fb8,0x094fe80cdf7fda78,0.606,0.635544,301708,0,PASS
+-238925630,surface-world,clang19-off,1,27,9,26908,0.000000,-140.000000,-2021.289062,0x01debb25b2642a4d,0xd316a4d6bbbdceee,0xba64591c42277c82,0x80e23990f3cb20b9,0.163,0.178003,84112,0,PASS
+-238925630,surface-world,clang19-off,12,27,9,26908,0.000000,-140.000000,-2021.289062,0x01debb25b2642a4d,0xd316a4d6bbbdceee,0xba64591c42277c82,0x80e23990f3cb20b9,0.405,0.433901,294484,0,PASS
+-238925630,surface-world,clang19-on,1,27,9,26908,0.000000,-140.000000,-2021.289062,0x01debb25b2642a4d,0xd316a4d6bbbdceee,0xba64591c42277c82,0x80e23990f3cb20b9,0.155,0.170979,84116,0,PASS
+-238925630,surface-world,clang19-on,12,27,9,26908,0.000000,-140.000000,-2021.289062,0x01debb25b2642a4d,0xd316a4d6bbbdceee,0xba64591c42277c82,0x80e23990f3cb20b9,0.424,0.450283,294552,0,PASS
+-238925630,surface-world,gcc14-default,1,27,9,26908,0.000000,-140.000000,-2021.289062,0x01debb25b2642a4d,0xd316a4d6bbbdceee,0xba64591c42277c82,0x80e23990f3cb20b9,0.157,0.173793,84632,0,PASS
+-238925630,surface-world,gcc14-default,12,27,9,26908,0.000000,-140.000000,-2021.289062,0x01debb25b2642a4d,0xd316a4d6bbbdceee,0xba64591c42277c82,0x80e23990f3cb20b9,0.418,0.444259,295140,0,PASS
+-238925630,floating-islands,clang19-off,1,27,10,20680,-39.199219,16.394531,-123.812500,0x36a07bf8d4383533,0x12f59de7f06e5270,0x327832e51af1db70,0xff0a971f18b6b590,2.096,2.113022,86240,0,PASS
+-238925630,floating-islands,clang19-off,12,27,10,20680,-39.199219,16.394531,-123.812500,0x36a07bf8d4383533,0x12f59de7f06e5270,0x327832e51af1db70,0xff0a971f18b6b590,0.812,0.839647,299904,0,PASS
+-238925630,floating-islands,clang19-on,1,27,10,20680,-39.199219,16.394531,-123.812500,0x36a07bf8d4383533,0x12f59de7f06e5270,0x327832e51af1db70,0xff0a971f18b6b590,2.107,2.123614,86584,0,PASS
+-238925630,floating-islands,clang19-on,12,27,10,20680,-39.199219,16.394531,-123.812500,0x36a07bf8d4383533,0x12f59de7f06e5270,0x327832e51af1db70,0xff0a971f18b6b590,0.795,0.823151,299740,0,PASS
+-238925630,floating-islands,gcc14-default,1,27,10,20680,-39.199219,16.394531,-123.812500,0x36a07bf8d4383533,0x12f59de7f06e5270,0x327832e51af1db70,0xff0a971f18b6b590,2.122,2.139698,87080,0,PASS
+-238925630,floating-islands,gcc14-default,12,27,10,20680,-39.199219,16.394531,-123.812500,0x36a07bf8d4383533,0x12f59de7f06e5270,0x327832e51af1db70,0xff0a971f18b6b590,0.807,0.834762,300372,0,PASS
+-216679974,surface-world,clang19-off,1,27,9,26538,0.000000,-140.000000,-2025.835938,0x04339f7c537f8920,0xb6d8dab4a5cd82ca,0x5bdc85d7f66eed92,0xac3b586f9be3e44e,0.168,0.185930,86460,0,PASS
+-216679974,surface-world,clang19-off,12,27,9,26538,0.000000,-140.000000,-2025.835938,0x04339f7c537f8920,0xb6d8dab4a5cd82ca,0x5bdc85d7f66eed92,0xac3b586f9be3e44e,0.408,0.433793,296948,0,PASS
+-216679974,surface-world,clang19-on,1,27,9,26538,0.000000,-140.000000,-2025.835938,0x04339f7c537f8920,0xb6d8dab4a5cd82ca,0x5bdc85d7f66eed92,0xac3b586f9be3e44e,0.160,0.176766,86712,0,PASS
+-216679974,surface-world,clang19-on,12,27,9,26538,0.000000,-140.000000,-2025.835938,0x04339f7c537f8920,0xb6d8dab4a5cd82ca,0x5bdc85d7f66eed92,0xac3b586f9be3e44e,0.426,0.453535,296576,0,PASS
+-216679974,surface-world,gcc14-default,1,27,9,26538,0.000000,-140.000000,-2025.835938,0x04339f7c537f8920,0xb6d8dab4a5cd82ca,0x5bdc85d7f66eed92,0xac3b586f9be3e44e,0.156,0.172641,87192,0,PASS
+-216679974,surface-world,gcc14-default,12,27,9,26538,0.000000,-140.000000,-2025.835938,0x04339f7c537f8920,0xb6d8dab4a5cd82ca,0x5bdc85d7f66eed92,0xac3b586f9be3e44e,0.431,0.459265,297424,0,PASS
+-216679974,floating-islands,clang19-off,1,27,9,25284,39.199219,20.230469,-108.953125,0x79bb86763243b67e,0x7fd748d3021d506d,0x83442fd7561cbb4e,0x5a36191d75130d85,1.202,1.219265,88692,0,PASS
+-216679974,floating-islands,clang19-off,12,27,9,25284,39.199219,20.230469,-108.953125,0x79bb86763243b67e,0x7fd748d3021d506d,0x83442fd7561cbb4e,0x5a36191d75130d85,0.652,0.679940,303236,0,PASS
+-216679974,floating-islands,clang19-on,1,27,9,25284,39.199219,20.230469,-108.953125,0x79bb86763243b67e,0x7fd748d3021d506d,0x83442fd7561cbb4e,0x5a36191d75130d85,1.221,1.237304,88612,0,PASS
+-216679974,floating-islands,clang19-on,12,27,9,25284,39.199219,20.230469,-108.953125,0x79bb86763243b67e,0x7fd748d3021d506d,0x83442fd7561cbb4e,0x5a36191d75130d85,0.613,0.640836,303412,0,PASS
+-216679974,floating-islands,gcc14-default,1,27,9,25284,39.199219,20.230469,-108.953125,0x79bb86763243b67e,0x7fd748d3021d506d,0x83442fd7561cbb4e,0x5a36191d75130d85,1.322,1.339480,89104,0,PASS
+-216679974,floating-islands,gcc14-default,12,27,9,25284,39.199219,20.230469,-108.953125,0x79bb86763243b67e,0x7fd748d3021d506d,0x83442fd7561cbb4e,0x5a36191d75130d85,0.655,0.683872,303612,0,PASS
+-133096164,surface-world,clang19-off,1,27,9,26182,0.000000,-140.000000,-2023.140625,0x1dadb5c6440181c0,0x4681d673371781ba,0x7b8f2bafde1628a9,0xf8f07e5a6d4f38f9,0.169,0.184384,85324,0,PASS
+-133096164,surface-world,clang19-off,12,27,9,26182,0.000000,-140.000000,-2023.140625,0x1dadb5c6440181c0,0x4681d673371781ba,0x7b8f2bafde1628a9,0xf8f07e5a6d4f38f9,0.417,0.443885,295568,0,PASS
+-133096164,surface-world,clang19-on,1,27,9,26182,0.000000,-140.000000,-2023.140625,0x1dadb5c6440181c0,0x4681d673371781ba,0x7b8f2bafde1628a9,0xf8f07e5a6d4f38f9,0.170,0.186315,85648,0,PASS
+-133096164,surface-world,clang19-on,12,27,9,26182,0.000000,-140.000000,-2023.140625,0x1dadb5c6440181c0,0x4681d673371781ba,0x7b8f2bafde1628a9,0xf8f07e5a6d4f38f9,0.429,0.457985,295652,0,PASS
+-133096164,surface-world,gcc14-default,1,27,9,26182,0.000000,-140.000000,-2023.140625,0x1dadb5c6440181c0,0x4681d673371781ba,0x7b8f2bafde1628a9,0xf8f07e5a6d4f38f9,0.162,0.178058,86036,0,PASS
+-133096164,surface-world,gcc14-default,12,27,9,26182,0.000000,-140.000000,-2023.140625,0x1dadb5c6440181c0,0x4681d673371781ba,0x7b8f2bafde1628a9,0xf8f07e5a6d4f38f9,0.424,0.454505,296144,0,PASS
+-133096164,floating-islands,clang19-off,1,27,11,26248,-39.199219,16.050781,-118.000000,0xad7be7cd6b0dbffc,0x06d2caf87f019f22,0xbede324e7af07e61,0xf2eff51f24bf458a,0.872,0.891001,85524,0,PASS
+-133096164,floating-islands,clang19-off,12,27,11,26248,-39.199219,16.050781,-118.000000,0xad7be7cd6b0dbffc,0x06d2caf87f019f22,0xbede324e7af07e61,0xf2eff51f24bf458a,0.563,0.589920,300908,0,PASS
+-133096164,floating-islands,clang19-on,1,27,11,26248,-39.199219,16.050781,-118.000000,0xad7be7cd6b0dbffc,0x06d2caf87f019f22,0xbede324e7af07e61,0xf2eff51f24bf458a,0.877,0.892147,85604,0,PASS
+-133096164,floating-islands,clang19-on,12,27,11,26248,-39.199219,16.050781,-118.000000,0xad7be7cd6b0dbffc,0x06d2caf87f019f22,0xbede324e7af07e61,0xf2eff51f24bf458a,0.561,0.587310,300416,0,PASS
+-133096164,floating-islands,gcc14-default,1,27,11,26248,-39.199219,16.050781,-118.000000,0xad7be7cd6b0dbffc,0x06d2caf87f019f22,0xbede324e7af07e61,0xf2eff51f24bf458a,0.936,0.951685,86128,0,PASS
+-133096164,floating-islands,gcc14-default,12,27,11,26248,-39.199219,16.050781,-118.000000,0xad7be7cd6b0dbffc,0x06d2caf87f019f22,0xbede324e7af07e61,0xf2eff51f24bf458a,0.581,0.608952,301120,0,PASS
+-112366806,surface-world,clang19-off,1,27,16,46567,0.000000,-140.000000,-1699.476562,0x7aafaa55fce58f77,0x84c7d73393ccdb09,0x46a53de4a9e7617c,0xc79fcc56dd0181c2,0.324,0.340848,85804,0,PASS
+-112366806,surface-world,clang19-off,12,27,16,46567,0.000000,-140.000000,-1699.476562,0x7aafaa55fce58f77,0x84c7d73393ccdb09,0x46a53de4a9e7617c,0xc79fcc56dd0181c2,0.487,0.514033,302296,0,PASS
+-112366806,surface-world,clang19-on,1,27,16,46567,0.000000,-140.000000,-1699.476562,0x7aafaa55fce58f77,0x84c7d73393ccdb09,0x46a53de4a9e7617c,0xc79fcc56dd0181c2,0.326,0.343022,85380,0,PASS
+-112366806,surface-world,clang19-on,12,27,16,46567,0.000000,-140.000000,-1699.476562,0x7aafaa55fce58f77,0x84c7d73393ccdb09,0x46a53de4a9e7617c,0xc79fcc56dd0181c2,0.482,0.509381,302920,0,PASS
+-112366806,surface-world,gcc14-default,1,27,16,46567,0.000000,-140.000000,-1699.476562,0x7aafaa55fce58f77,0x84c7d73393ccdb09,0x46a53de4a9e7617c,0xc79fcc56dd0181c2,0.308,0.323509,86516,0,PASS
+-112366806,surface-world,gcc14-default,12,27,16,46567,0.000000,-140.000000,-1699.476562,0x7aafaa55fce58f77,0x84c7d73393ccdb09,0x46a53de4a9e7617c,0xc79fcc56dd0181c2,0.480,0.507907,301052,0,PASS
+-112366806,floating-islands,clang19-off,1,27,9,21148,39.199219,16.867188,-114.605469,0xda065c33dc944d23,0x3c27d1ee8688fec9,0xa497259af00952cf,0x8697ac7f0567f069,1.266,1.282382,85796,0,PASS
+-112366806,floating-islands,clang19-off,12,27,9,21148,39.199219,16.867188,-114.605469,0xda065c33dc944d23,0x3c27d1ee8688fec9,0xa497259af00952cf,0x8697ac7f0567f069,0.681,0.717905,299852,0,PASS
+-112366806,floating-islands,clang19-on,1,27,9,21148,39.199219,16.867188,-114.605469,0xda065c33dc944d23,0x3c27d1ee8688fec9,0xa497259af00952cf,0x8697ac7f0567f069,1.340,1.364175,85696,0,PASS
+-112366806,floating-islands,clang19-on,12,27,9,21148,39.199219,16.867188,-114.605469,0xda065c33dc944d23,0x3c27d1ee8688fec9,0xa497259af00952cf,0x8697ac7f0567f069,0.705,0.732861,299840,0,PASS
+-112366806,floating-islands,gcc14-default,1,27,9,21148,39.199219,16.867188,-114.605469,0xda065c33dc944d23,0x3c27d1ee8688fec9,0xa497259af00952cf,0x8697ac7f0567f069,1.379,1.395616,86172,0,PASS
+-112366806,floating-islands,gcc14-default,12,27,9,21148,39.199219,16.867188,-114.605469,0xda065c33dc944d23,0x3c27d1ee8688fec9,0xa497259af00952cf,0x8697ac7f0567f069,0.744,0.770938,300416,0,PASS
+0,surface-world,clang19-off,1,27,9,27910,0.000000,-140.000000,-2003.089844,0x2339a02328c5ffa6,0x83d31e15bf9161b0,0xc056f0c0987d79b6,0x435c44ce6ca8e4ea,0.180,0.198233,86824,0,PASS
+0,surface-world,clang19-off,12,27,9,27910,0.000000,-140.000000,-2003.089844,0x2339a02328c5ffa6,0x83d31e15bf9161b0,0xc056f0c0987d79b6,0x435c44ce6ca8e4ea,0.422,0.449664,297060,0,PASS
+0,surface-world,clang19-on,1,27,9,27910,0.000000,-140.000000,-2003.089844,0x2339a02328c5ffa6,0x83d31e15bf9161b0,0xc056f0c0987d79b6,0x435c44ce6ca8e4ea,0.173,0.188744,86728,0,PASS
+0,surface-world,clang19-on,12,27,9,27910,0.000000,-140.000000,-2003.089844,0x2339a02328c5ffa6,0x83d31e15bf9161b0,0xc056f0c0987d79b6,0x435c44ce6ca8e4ea,0.450,0.477889,296820,0,PASS
+0,surface-world,gcc14-default,1,27,9,27910,0.000000,-140.000000,-2003.089844,0x2339a02328c5ffa6,0x83d31e15bf9161b0,0xc056f0c0987d79b6,0x435c44ce6ca8e4ea,0.165,0.181852,87064,0,PASS
+0,surface-world,gcc14-default,12,27,9,27910,0.000000,-140.000000,-2003.089844,0x2339a02328c5ffa6,0x83d31e15bf9161b0,0xc056f0c0987d79b6,0x435c44ce6ca8e4ea,0.435,0.462262,297640,0,PASS
+0,floating-islands,clang19-off,1,27,9,20740,-25.199219,-76.226562,-105.089844,0x7fd1e3389642e6f6,0x577e52a5ba8d96be,0x7c6ffe9f5bbbb450,0xb4d308de116f4657,1.761,1.778352,86204,0,PASS
+0,floating-islands,clang19-off,12,27,9,20740,-25.199219,-76.226562,-105.089844,0x7fd1e3389642e6f6,0x577e52a5ba8d96be,0x7c6ffe9f5bbbb450,0xb4d308de116f4657,0.768,0.794881,299068,0,PASS
+0,floating-islands,clang19-on,1,27,9,20740,-25.199219,-76.226562,-105.089844,0x7fd1e3389642e6f6,0x577e52a5ba8d96be,0x7c6ffe9f5bbbb450,0xb4d308de116f4657,1.765,1.781702,86056,0,PASS
+0,floating-islands,clang19-on,12,27,9,20740,-25.199219,-76.226562,-105.089844,0x7fd1e3389642e6f6,0x577e52a5ba8d96be,0x7c6ffe9f5bbbb450,0xb4d308de116f4657,0.765,0.792583,298772,0,PASS
+0,floating-islands,gcc14-default,1,27,9,20740,-25.199219,-76.226562,-105.089844,0x7fd1e3389642e6f6,0x577e52a5ba8d96be,0x7c6ffe9f5bbbb450,0xb4d308de116f4657,1.894,1.910737,86536,0,PASS
+0,floating-islands,gcc14-default,12,27,9,20740,-25.199219,-76.226562,-105.089844,0x7fd1e3389642e6f6,0x577e52a5ba8d96be,0x7c6ffe9f5bbbb450,0xb4d308de116f4657,0.802,0.828791,299460,0,PASS
+5808593,surface-world,clang19-off,1,27,14,29050,0.000000,-140.000000,-2014.406250,0x355972d90ab29593,0x563daf944391ab7c,0x8804eebac2acd898,0xc2b049b4f6426af0,0.209,0.225170,84472,0,PASS
+5808593,surface-world,clang19-off,12,27,14,29050,0.000000,-140.000000,-2014.406250,0x355972d90ab29593,0x563daf944391ab7c,0x8804eebac2acd898,0xc2b049b4f6426af0,0.440,0.467263,299048,0,PASS
+5808593,surface-world,clang19-on,1,27,14,29050,0.000000,-140.000000,-2014.406250,0x355972d90ab29593,0x563daf944391ab7c,0x8804eebac2acd898,0xc2b049b4f6426af0,0.214,0.230107,84720,0,PASS
+5808593,surface-world,clang19-on,12,27,14,29050,0.000000,-140.000000,-2014.406250,0x355972d90ab29593,0x563daf944391ab7c,0x8804eebac2acd898,0xc2b049b4f6426af0,0.450,0.477642,299356,0,PASS
+5808593,surface-world,gcc14-default,1,27,14,29050,0.000000,-140.000000,-2014.406250,0x355972d90ab29593,0x563daf944391ab7c,0x8804eebac2acd898,0xc2b049b4f6426af0,0.206,0.223073,85136,0,PASS
+5808593,surface-world,gcc14-default,12,27,14,29050,0.000000,-140.000000,-2014.406250,0x355972d90ab29593,0x563daf944391ab7c,0x8804eebac2acd898,0xc2b049b4f6426af0,0.441,0.468922,299624,0,PASS
+5808593,floating-islands,clang19-off,1,27,10,21000,39.199219,16.003906,-114.574219,0xb96bffb27bc457e0,0x1f867a2add682123,0xfd4c94fd6f9b5863,0x82dc1a7add5ea530,0.978,0.993595,85604,0,PASS
+5808593,floating-islands,clang19-off,12,27,10,21000,39.199219,16.003906,-114.574219,0xb96bffb27bc457e0,0x1f867a2add682123,0xfd4c94fd6f9b5863,0x82dc1a7add5ea530,0.587,0.614676,299336,0,PASS
+5808593,floating-islands,clang19-on,1,27,10,21000,39.199219,16.003906,-114.574219,0xb96bffb27bc457e0,0x1f867a2add682123,0xfd4c94fd6f9b5863,0x82dc1a7add5ea530,0.972,0.987363,85032,0,PASS
+5808593,floating-islands,clang19-on,12,27,10,21000,39.199219,16.003906,-114.574219,0xb96bffb27bc457e0,0x1f867a2add682123,0xfd4c94fd6f9b5863,0x82dc1a7add5ea530,0.607,0.635950,299516,0,PASS
+5808593,floating-islands,gcc14-default,1,27,10,21000,39.199219,16.003906,-114.574219,0xb96bffb27bc457e0,0x1f867a2add682123,0xfd4c94fd6f9b5863,0x82dc1a7add5ea530,1.060,1.076946,85540,0,PASS
+5808593,floating-islands,gcc14-default,12,27,10,21000,39.199219,16.003906,-114.574219,0xb96bffb27bc457e0,0x1f867a2add682123,0xfd4c94fd6f9b5863,0x82dc1a7add5ea530,0.631,0.659995,299816,0,PASS
+28573228,surface-world,clang19-off,1,27,13,27054,0.000000,-140.000000,-2016.695312,0x57cb2fe09976dc54,0x35ac4f38b432e8b7,0x7ed7b8d28bbb4ae8,0xe9bf4ba938198d73,0.183,0.198431,84548,0,PASS
+28573228,surface-world,clang19-off,12,27,13,27054,0.000000,-140.000000,-2016.695312,0x57cb2fe09976dc54,0x35ac4f38b432e8b7,0x7ed7b8d28bbb4ae8,0xe9bf4ba938198d73,0.413,0.440062,299560,0,PASS
+28573228,surface-world,clang19-on,1,27,13,27054,0.000000,-140.000000,-2016.695312,0x57cb2fe09976dc54,0x35ac4f38b432e8b7,0x7ed7b8d28bbb4ae8,0xe9bf4ba938198d73,0.188,0.203450,84968,0,PASS
+28573228,surface-world,clang19-on,12,27,13,27054,0.000000,-140.000000,-2016.695312,0x57cb2fe09976dc54,0x35ac4f38b432e8b7,0x7ed7b8d28bbb4ae8,0xe9bf4ba938198d73,0.409,0.435356,299552,0,PASS
+28573228,surface-world,gcc14-default,1,27,13,27054,0.000000,-140.000000,-2016.695312,0x57cb2fe09976dc54,0x35ac4f38b432e8b7,0x7ed7b8d28bbb4ae8,0xe9bf4ba938198d73,0.185,0.200823,85508,0,PASS
+28573228,surface-world,gcc14-default,12,27,13,27054,0.000000,-140.000000,-2016.695312,0x57cb2fe09976dc54,0x35ac4f38b432e8b7,0x7ed7b8d28bbb4ae8,0xe9bf4ba938198d73,0.420,0.448033,299724,0,PASS
+28573228,floating-islands,clang19-off,1,27,12,32456,0.000000,-18.683594,-116.187500,0x25ed5f499f9bf7ab,0x1c8e67c20374b473,0x786447fa7fb09cab,0x244fb7a45dc74437,1.396,1.413299,85492,0,PASS
+28573228,floating-islands,clang19-off,12,27,12,32456,0.000000,-18.683594,-116.187500,0x25ed5f499f9bf7ab,0x1c8e67c20374b473,0x786447fa7fb09cab,0x244fb7a45dc74437,0.693,0.719023,300784,0,PASS
+28573228,floating-islands,clang19-on,1,27,12,32456,0.000000,-18.683594,-116.187500,0x25ed5f499f9bf7ab,0x1c8e67c20374b473,0x786447fa7fb09cab,0x244fb7a45dc74437,1.354,1.373140,84808,0,PASS
+28573228,floating-islands,clang19-on,12,27,12,32456,0.000000,-18.683594,-116.187500,0x25ed5f499f9bf7ab,0x1c8e67c20374b473,0x786447fa7fb09cab,0x244fb7a45dc74437,0.663,0.689391,300568,0,PASS
+28573228,floating-islands,gcc14-default,1,27,12,32456,0.000000,-18.683594,-116.187500,0x25ed5f499f9bf7ab,0x1c8e67c20374b473,0x786447fa7fb09cab,0x244fb7a45dc74437,1.544,1.560291,85548,0,PASS
+28573228,floating-islands,gcc14-default,12,27,12,32456,0.000000,-18.683594,-116.187500,0x25ed5f499f9bf7ab,0x1c8e67c20374b473,0x786447fa7fb09cab,0x244fb7a45dc74437,0.727,0.755835,300920,0,PASS
+70955227,surface-world,clang19-off,1,27,13,29926,0.000000,-140.000000,-2047.484375,0xb205ad43941e41d8,0x722e775c7e0735bc,0x44a33dfc23ec62ed,0x39969012a7375b51,0.192,0.208106,85820,0,PASS
+70955227,surface-world,clang19-off,12,27,13,29926,0.000000,-140.000000,-2047.484375,0xb205ad43941e41d8,0x722e775c7e0735bc,0x44a33dfc23ec62ed,0x39969012a7375b51,0.448,0.476411,300752,0,PASS
+70955227,surface-world,clang19-on,1,27,13,29926,0.000000,-140.000000,-2047.484375,0xb205ad43941e41d8,0x722e775c7e0735bc,0x44a33dfc23ec62ed,0x39969012a7375b51,0.185,0.201218,85544,0,PASS
+70955227,surface-world,clang19-on,12,27,13,29926,0.000000,-140.000000,-2047.484375,0xb205ad43941e41d8,0x722e775c7e0735bc,0x44a33dfc23ec62ed,0x39969012a7375b51,0.429,0.457766,300792,0,PASS
+70955227,surface-world,gcc14-default,1,27,13,29926,0.000000,-140.000000,-2047.484375,0xb205ad43941e41d8,0x722e775c7e0735bc,0x44a33dfc23ec62ed,0x39969012a7375b51,0.183,0.198664,86928,0,PASS
+70955227,surface-world,gcc14-default,12,27,13,29926,0.000000,-140.000000,-2047.484375,0xb205ad43941e41d8,0x722e775c7e0735bc,0x44a33dfc23ec62ed,0x39969012a7375b51,0.438,0.466791,301440,0,PASS
+70955227,floating-islands,clang19-off,1,27,12,17426,-39.199219,18.582031,-121.785156,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23,0x6f301aefdb37973f,0xa38a1c2ec1a3b2f1,1.586,1.602163,87224,0,PASS
+70955227,floating-islands,clang19-off,12,27,12,17426,-39.199219,18.582031,-121.785156,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23,0x6f301aefdb37973f,0xa38a1c2ec1a3b2f1,0.715,0.741331,300680,0,PASS
+70955227,floating-islands,clang19-on,1,27,12,17426,-39.199219,18.582031,-121.785156,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23,0x6f301aefdb37973f,0xa38a1c2ec1a3b2f1,1.601,1.615814,87288,0,PASS
+70955227,floating-islands,clang19-on,12,27,12,17426,-39.199219,18.582031,-121.785156,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23,0x6f301aefdb37973f,0xa38a1c2ec1a3b2f1,0.746,0.774349,301108,0,PASS
+70955227,floating-islands,gcc14-default,1,27,12,17426,-39.199219,18.582031,-121.785156,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23,0x6f301aefdb37973f,0xa38a1c2ec1a3b2f1,1.718,1.733886,87436,0,PASS
+70955227,floating-islands,gcc14-default,12,27,12,17426,-39.199219,18.582031,-121.785156,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23,0x6f301aefdb37973f,0xa38a1c2ec1a3b2f1,0.780,0.806995,301540,0,PASS
+75274690,surface-world,clang19-off,1,27,15,28342,0.000000,-140.000000,-2019.648438,0x84af4380d33164a6,0xa18d6de0f9267e9f,0xe4bcbdc97074b806,0x5d71387401f96959,0.189,0.204204,85448,0,PASS
+75274690,surface-world,clang19-off,12,27,15,28342,0.000000,-140.000000,-2019.648438,0x84af4380d33164a6,0xa18d6de0f9267e9f,0xe4bcbdc97074b806,0x5d71387401f96959,0.445,0.471446,300620,0,PASS
+75274690,surface-world,clang19-on,1,27,15,28342,0.000000,-140.000000,-2019.648438,0x84af4380d33164a6,0xa18d6de0f9267e9f,0xe4bcbdc97074b806,0x5d71387401f96959,0.184,0.200607,85196,0,PASS
+75274690,surface-world,clang19-on,12,27,15,28342,0.000000,-140.000000,-2019.648438,0x84af4380d33164a6,0xa18d6de0f9267e9f,0xe4bcbdc97074b806,0x5d71387401f96959,0.420,0.448852,300344,0,PASS
+75274690,surface-world,gcc14-default,1,27,15,28342,0.000000,-140.000000,-2019.648438,0x84af4380d33164a6,0xa18d6de0f9267e9f,0xe4bcbdc97074b806,0x5d71387401f96959,0.192,0.207839,85924,0,PASS
+75274690,surface-world,gcc14-default,12,27,15,28342,0.000000,-140.000000,-2019.648438,0x84af4380d33164a6,0xa18d6de0f9267e9f,0xe4bcbdc97074b806,0x5d71387401f96959,0.425,0.452205,300748,0,PASS
+75274690,floating-islands,clang19-off,1,27,8,19760,64.398438,72.199219,-121.019531,0x045c98172a573800,0x86618a983d61425d,0x13523110d2e6a9b3,0x6f1ad87b335e3d3e,1.103,1.118954,86812,0,PASS
+75274690,floating-islands,clang19-off,12,27,8,19760,64.398438,72.199219,-121.019531,0x045c98172a573800,0x86618a983d61425d,0x13523110d2e6a9b3,0x6f1ad87b335e3d3e,0.628,0.655461,300972,0,PASS
+75274690,floating-islands,clang19-on,1,27,8,19760,64.398438,72.199219,-121.019531,0x045c98172a573800,0x86618a983d61425d,0x13523110d2e6a9b3,0x6f1ad87b335e3d3e,1.083,1.101596,86924,0,PASS
+75274690,floating-islands,clang19-on,12,27,8,19760,64.398438,72.199219,-121.019531,0x045c98172a573800,0x86618a983d61425d,0x13523110d2e6a9b3,0x6f1ad87b335e3d3e,0.658,0.694786,300572,0,PASS
+75274690,floating-islands,gcc14-default,1,27,8,19760,64.398438,72.199219,-121.019531,0x045c98172a573800,0x86618a983d61425d,0x13523110d2e6a9b3,0x6f1ad87b335e3d3e,1.176,1.192130,87488,0,PASS
+75274690,floating-islands,gcc14-default,12,27,8,19760,64.398438,72.199219,-121.019531,0x045c98172a573800,0x86618a983d61425d,0x13523110d2e6a9b3,0x6f1ad87b335e3d3e,0.653,0.680432,301468,0,PASS
+81375760,surface-world,clang19-off,1,27,18,48305,0.000000,-140.000000,-1894.296875,0x20c34733457b090d,0x9a6b57b63637db1f,0x2005693f7f6d7dcc,0xc5745d7ea096cff0,0.333,0.349470,85188,0,PASS
+81375760,surface-world,clang19-off,12,27,18,48305,0.000000,-140.000000,-1894.296875,0x20c34733457b090d,0x9a6b57b63637db1f,0x2005693f7f6d7dcc,0xc5745d7ea096cff0,0.480,0.508631,302276,0,PASS
+81375760,surface-world,clang19-on,1,27,18,48305,0.000000,-140.000000,-1894.296875,0x20c34733457b090d,0x9a6b57b63637db1f,0x2005693f7f6d7dcc,0xc5745d7ea096cff0,0.331,0.348279,85148,0,PASS
+81375760,surface-world,clang19-on,12,27,18,48305,0.000000,-140.000000,-1894.296875,0x20c34733457b090d,0x9a6b57b63637db1f,0x2005693f7f6d7dcc,0xc5745d7ea096cff0,0.506,0.532790,302092,0,PASS
+81375760,surface-world,gcc14-default,1,27,18,48305,0.000000,-140.000000,-1894.296875,0x20c34733457b090d,0x9a6b57b63637db1f,0x2005693f7f6d7dcc,0xc5745d7ea096cff0,0.340,0.357917,85568,0,PASS
+81375760,surface-world,gcc14-default,12,27,18,48305,0.000000,-140.000000,-1894.296875,0x20c34733457b090d,0x9a6b57b63637db1f,0x2005693f7f6d7dcc,0xc5745d7ea096cff0,0.476,0.502072,302172,0,PASS
+81375760,floating-islands,clang19-off,1,27,12,24146,-39.199219,20.589844,-119.359375,0x69b66261833e4676,0x75e6b0f427e7698a,0xcb222176f7352da7,0x20224eb0a8925b4d,1.592,1.607202,87600,0,PASS
+81375760,floating-islands,clang19-off,12,27,12,24146,-39.199219,20.589844,-119.359375,0x69b66261833e4676,0x75e6b0f427e7698a,0xcb222176f7352da7,0x20224eb0a8925b4d,0.729,0.756249,301856,0,PASS
+81375760,floating-islands,clang19-on,1,27,12,24146,-39.199219,20.589844,-119.359375,0x69b66261833e4676,0x75e6b0f427e7698a,0xcb222176f7352da7,0x20224eb0a8925b4d,1.678,1.694265,87328,0,PASS
+81375760,floating-islands,clang19-on,12,27,12,24146,-39.199219,20.589844,-119.359375,0x69b66261833e4676,0x75e6b0f427e7698a,0xcb222176f7352da7,0x20224eb0a8925b4d,0.746,0.773941,302184,0,PASS
+81375760,floating-islands,gcc14-default,1,27,12,24146,-39.199219,20.589844,-119.359375,0x69b66261833e4676,0x75e6b0f427e7698a,0xcb222176f7352da7,0x20224eb0a8925b4d,1.706,1.723259,87980,0,PASS
+81375760,floating-islands,gcc14-default,12,27,12,24146,-39.199219,20.589844,-119.359375,0x69b66261833e4676,0x75e6b0f427e7698a,0xcb222176f7352da7,0x20224eb0a8925b4d,0.743,0.770492,302508,0,PASS
+146979566,surface-world,clang19-off,1,27,14,31096,0.000000,-140.000000,-2014.601562,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53,0x6f23c17789836934,0x5063630f2a948856,0.242,0.259669,85944,0,PASS
+146979566,surface-world,clang19-off,12,27,14,31096,0.000000,-140.000000,-2014.601562,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53,0x6f23c17789836934,0x5063630f2a948856,0.431,0.458617,301156,0,PASS
+146979566,surface-world,clang19-on,1,27,14,31096,0.000000,-140.000000,-2014.601562,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53,0x6f23c17789836934,0x5063630f2a948856,0.237,0.254081,85952,0,PASS
+146979566,surface-world,clang19-on,12,27,14,31096,0.000000,-140.000000,-2014.601562,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53,0x6f23c17789836934,0x5063630f2a948856,0.428,0.456566,301360,0,PASS
+146979566,surface-world,gcc14-default,1,27,14,31096,0.000000,-140.000000,-2014.601562,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53,0x6f23c17789836934,0x5063630f2a948856,0.245,0.261764,86436,0,PASS
+146979566,surface-world,gcc14-default,12,27,14,31096,0.000000,-140.000000,-2014.601562,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53,0x6f23c17789836934,0x5063630f2a948856,0.453,0.480241,301596,0,PASS
+146979566,floating-islands,clang19-off,1,27,9,22370,39.199219,16.625000,-109.785156,0x93d0d67042bb05d2,0xe7f4981f907e316e,0x98081f3cf86e0b7f,0xa103fc9366460065,1.584,1.600638,87472,0,PASS
+146979566,floating-islands,clang19-off,12,27,9,22370,39.199219,16.625000,-109.785156,0x93d0d67042bb05d2,0xe7f4981f907e316e,0x98081f3cf86e0b7f,0xa103fc9366460065,0.691,0.717956,301644,0,PASS
+146979566,floating-islands,clang19-on,1,27,9,22370,39.199219,16.625000,-109.785156,0x93d0d67042bb05d2,0xe7f4981f907e316e,0x98081f3cf86e0b7f,0xa103fc9366460065,1.645,1.662341,87336,0,PASS
+146979566,floating-islands,clang19-on,12,27,9,22370,39.199219,16.625000,-109.785156,0x93d0d67042bb05d2,0xe7f4981f907e316e,0x98081f3cf86e0b7f,0xa103fc9366460065,0.716,0.744086,301388,0,PASS
+146979566,floating-islands,gcc14-default,1,27,9,22370,39.199219,16.625000,-109.785156,0x93d0d67042bb05d2,0xe7f4981f907e316e,0x98081f3cf86e0b7f,0xa103fc9366460065,1.743,1.760680,87812,0,PASS
+146979566,floating-islands,gcc14-default,12,27,9,22370,39.199219,16.625000,-109.785156,0x93d0d67042bb05d2,0xe7f4981f907e316e,0x98081f3cf86e0b7f,0xa103fc9366460065,0.726,0.752868,302004,0,PASS
+244951180,surface-world,clang19-off,1,27,18,52468,0.000000,-140.000000,-1798.816406,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd,0xcc6273def955b692,0x477e01281747a9c6,0.348,0.365147,87736,0,PASS
+244951180,surface-world,clang19-off,12,27,18,52468,0.000000,-140.000000,-1798.816406,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd,0xcc6273def955b692,0x477e01281747a9c6,0.475,0.502857,304536,0,PASS
+244951180,surface-world,clang19-on,1,27,18,52468,0.000000,-140.000000,-1798.816406,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd,0xcc6273def955b692,0x477e01281747a9c6,0.345,0.361096,87652,0,PASS
+244951180,surface-world,clang19-on,12,27,18,52468,0.000000,-140.000000,-1798.816406,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd,0xcc6273def955b692,0x477e01281747a9c6,0.462,0.489379,305156,0,PASS
+244951180,surface-world,gcc14-default,1,27,18,52468,0.000000,-140.000000,-1798.816406,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd,0xcc6273def955b692,0x477e01281747a9c6,0.319,0.334168,87880,0,PASS
+244951180,surface-world,gcc14-default,12,27,18,52468,0.000000,-140.000000,-1798.816406,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd,0xcc6273def955b692,0x477e01281747a9c6,0.468,0.496037,305128,0,PASS
+244951180,floating-islands,clang19-off,1,27,13,32272,0.000000,-18.179688,-116.664062,0x0b22965681c5b482,0x582ef8c1d263bedb,0x00179a81f23dbeee,0x5ea7d2a08ba7a249,1.132,1.147425,87072,0,PASS
+244951180,floating-islands,clang19-off,12,27,13,32272,0.000000,-18.179688,-116.664062,0x0b22965681c5b482,0x582ef8c1d263bedb,0x00179a81f23dbeee,0x5ea7d2a08ba7a249,0.586,0.615574,303052,0,PASS
+244951180,floating-islands,clang19-on,1,27,13,32272,0.000000,-18.179688,-116.664062,0x0b22965681c5b482,0x582ef8c1d263bedb,0x00179a81f23dbeee,0x5ea7d2a08ba7a249,1.099,1.116192,87252,0,PASS
+244951180,floating-islands,clang19-on,12,27,13,32272,0.000000,-18.179688,-116.664062,0x0b22965681c5b482,0x582ef8c1d263bedb,0x00179a81f23dbeee,0x5ea7d2a08ba7a249,0.588,0.615818,303076,0,PASS
+244951180,floating-islands,gcc14-default,1,27,13,32272,0.000000,-18.179688,-116.664062,0x0b22965681c5b482,0x582ef8c1d263bedb,0x00179a81f23dbeee,0x5ea7d2a08ba7a249,1.201,1.217254,87804,0,PASS
+244951180,floating-islands,gcc14-default,12,27,13,32272,0.000000,-18.179688,-116.664062,0x0b22965681c5b482,0x582ef8c1d263bedb,0x00179a81f23dbeee,0x5ea7d2a08ba7a249,0.615,0.643461,303388,0,PASS
+245433414,surface-world,clang19-off,1,27,14,32860,0.000000,-140.000000,-2022.468750,0xcc51a567f61f812d,0xc59dc3105dd493b2,0x03b8f1a7d0eac0d7,0x22f468a7d1585605,0.183,0.199554,84260,0,PASS
+245433414,surface-world,clang19-off,12,27,14,32860,0.000000,-140.000000,-2022.468750,0xcc51a567f61f812d,0xc59dc3105dd493b2,0x03b8f1a7d0eac0d7,0x22f468a7d1585605,0.528,0.554834,299804,0,PASS
+245433414,surface-world,clang19-on,1,27,14,32860,0.000000,-140.000000,-2022.468750,0xcc51a567f61f812d,0xc59dc3105dd493b2,0x03b8f1a7d0eac0d7,0x22f468a7d1585605,0.190,0.205364,84668,0,PASS
+245433414,surface-world,clang19-on,12,27,14,32860,0.000000,-140.000000,-2022.468750,0xcc51a567f61f812d,0xc59dc3105dd493b2,0x03b8f1a7d0eac0d7,0x22f468a7d1585605,0.424,0.450563,299552,0,PASS
+245433414,surface-world,gcc14-default,1,27,14,32860,0.000000,-140.000000,-2022.468750,0xcc51a567f61f812d,0xc59dc3105dd493b2,0x03b8f1a7d0eac0d7,0x22f468a7d1585605,0.182,0.197759,85244,0,PASS
+245433414,surface-world,gcc14-default,12,27,14,32860,0.000000,-140.000000,-2022.468750,0xcc51a567f61f812d,0xc59dc3105dd493b2,0x03b8f1a7d0eac0d7,0x22f468a7d1585605,0.433,0.459733,300260,0,PASS
+245433414,floating-islands,clang19-off,1,27,11,32838,0.000000,-17.574219,-116.296875,0x2e75a175d1005e4e,0x8f45449d7125c041,0x493909fdf6e5cba4,0x576100f342da3f02,1.138,1.154872,87048,0,PASS
+245433414,floating-islands,clang19-off,12,27,11,32838,0.000000,-17.574219,-116.296875,0x2e75a175d1005e4e,0x8f45449d7125c041,0x493909fdf6e5cba4,0x576100f342da3f02,0.629,0.656026,302520,0,PASS
+245433414,floating-islands,clang19-on,1,27,11,32838,0.000000,-17.574219,-116.296875,0x2e75a175d1005e4e,0x8f45449d7125c041,0x493909fdf6e5cba4,0x576100f342da3f02,1.112,1.129107,87048,0,PASS
+245433414,floating-islands,clang19-on,12,27,11,32838,0.000000,-17.574219,-116.296875,0x2e75a175d1005e4e,0x8f45449d7125c041,0x493909fdf6e5cba4,0x576100f342da3f02,0.582,0.610645,302704,0,PASS
+245433414,floating-islands,gcc14-default,1,27,11,32838,0.000000,-17.574219,-116.296875,0x2e75a175d1005e4e,0x8f45449d7125c041,0x493909fdf6e5cba4,0x576100f342da3f02,1.189,1.205364,87708,0,PASS
+245433414,floating-islands,gcc14-default,12,27,11,32838,0.000000,-17.574219,-116.296875,0x2e75a175d1005e4e,0x8f45449d7125c041,0x493909fdf6e5cba4,0x576100f342da3f02,0.635,0.663132,303108,0,PASS
+277442974,surface-world,clang19-off,1,27,9,27060,0.000000,-140.000000,-2004.875000,0x8bfa82ca5e492c37,0x1630487dbcc54469,0xb37b440b5f2b1c98,0xe296c565d2eb2ef0,0.274,0.290495,86336,0,PASS
+277442974,surface-world,clang19-off,12,27,9,27060,0.000000,-140.000000,-2004.875000,0x8bfa82ca5e492c37,0x1630487dbcc54469,0xb37b440b5f2b1c98,0xe296c565d2eb2ef0,0.471,0.497591,296556,0,PASS
+277442974,surface-world,clang19-on,1,27,9,27060,0.000000,-140.000000,-2004.875000,0x8bfa82ca5e492c37,0x1630487dbcc54469,0xb37b440b5f2b1c98,0xe296c565d2eb2ef0,0.264,0.280808,86376,0,PASS
+277442974,surface-world,clang19-on,12,27,9,27060,0.000000,-140.000000,-2004.875000,0x8bfa82ca5e492c37,0x1630487dbcc54469,0xb37b440b5f2b1c98,0xe296c565d2eb2ef0,0.481,0.507069,296232,0,PASS
+277442974,surface-world,gcc14-default,1,27,9,27060,0.000000,-140.000000,-2004.875000,0x8bfa82ca5e492c37,0x1630487dbcc54469,0xb37b440b5f2b1c98,0xe296c565d2eb2ef0,0.247,0.263402,86856,0,PASS
+277442974,surface-world,gcc14-default,12,27,9,27060,0.000000,-140.000000,-2004.875000,0x8bfa82ca5e492c37,0x1630487dbcc54469,0xb37b440b5f2b1c98,0xe296c565d2eb2ef0,0.476,0.504203,297224,0,PASS
+277442974,floating-islands,clang19-off,1,27,13,28088,39.199219,19.328125,-117.750000,0x8cb55c56b1629d42,0xc6532d9d3b8a987d,0x1a07243bd2c586c1,0x5d957c64ae620a5e,1.172,1.186572,88460,0,PASS
+277442974,floating-islands,clang19-off,12,27,13,28088,39.199219,19.328125,-117.750000,0x8cb55c56b1629d42,0xc6532d9d3b8a987d,0x1a07243bd2c586c1,0x5d957c64ae620a5e,0.642,0.673081,303884,0,PASS
+277442974,floating-islands,clang19-on,1,27,13,28088,39.199219,19.328125,-117.750000,0x8cb55c56b1629d42,0xc6532d9d3b8a987d,0x1a07243bd2c586c1,0x5d957c64ae620a5e,1.187,1.211616,88412,0,PASS
+277442974,floating-islands,clang19-on,12,27,13,28088,39.199219,19.328125,-117.750000,0x8cb55c56b1629d42,0xc6532d9d3b8a987d,0x1a07243bd2c586c1,0x5d957c64ae620a5e,0.664,0.692926,303956,0,PASS
+277442974,floating-islands,gcc14-default,1,27,13,28088,39.199219,19.328125,-117.750000,0x8cb55c56b1629d42,0xc6532d9d3b8a987d,0x1a07243bd2c586c1,0x5d957c64ae620a5e,1.210,1.225245,89264,0,PASS
+277442974,floating-islands,gcc14-default,12,27,13,28088,39.199219,19.328125,-117.750000,0x8cb55c56b1629d42,0xc6532d9d3b8a987d,0x1a07243bd2c586c1,0x5d957c64ae620a5e,0.662,0.689572,304204,0,PASS
+297746112,surface-world,clang19-off,1,27,13,38252,0.000000,-140.000000,-2010.195312,0x00c869b6875b7ef5,0x085684513feca8f2,0x118ce3a71b3a4b6d,0x5e5c8df181277ea2,0.266,0.281980,86512,0,PASS
+297746112,surface-world,clang19-off,12,27,13,38252,0.000000,-140.000000,-2010.195312,0x00c869b6875b7ef5,0x085684513feca8f2,0x118ce3a71b3a4b6d,0x5e5c8df181277ea2,0.462,0.489317,300184,0,PASS
+297746112,surface-world,clang19-on,1,27,13,38252,0.000000,-140.000000,-2010.195312,0x00c869b6875b7ef5,0x085684513feca8f2,0x118ce3a71b3a4b6d,0x5e5c8df181277ea2,0.265,0.281098,86148,0,PASS
+297746112,surface-world,clang19-on,12,27,13,38252,0.000000,-140.000000,-2010.195312,0x00c869b6875b7ef5,0x085684513feca8f2,0x118ce3a71b3a4b6d,0x5e5c8df181277ea2,0.447,0.474064,300408,0,PASS
+297746112,surface-world,gcc14-default,1,27,13,38252,0.000000,-140.000000,-2010.195312,0x00c869b6875b7ef5,0x085684513feca8f2,0x118ce3a71b3a4b6d,0x5e5c8df181277ea2,0.253,0.269185,87028,0,PASS
+297746112,surface-world,gcc14-default,12,27,13,38252,0.000000,-140.000000,-2010.195312,0x00c869b6875b7ef5,0x085684513feca8f2,0x118ce3a71b3a4b6d,0x5e5c8df181277ea2,0.461,0.489903,300916,0,PASS
+297746112,floating-islands,clang19-off,1,27,15,29396,39.199219,20.609375,-119.089844,0x2425273f1a174c04,0x204be5cda8d98412,0x0565960cfc012768,0x14faf071d204cf2c,1.471,1.486649,86560,0,PASS
+297746112,floating-islands,clang19-off,12,27,15,29396,39.199219,20.609375,-119.089844,0x2425273f1a174c04,0x204be5cda8d98412,0x0565960cfc012768,0x14faf071d204cf2c,0.707,0.733259,301392,0,PASS
+297746112,floating-islands,clang19-on,1,27,15,29396,39.199219,20.609375,-119.089844,0x2425273f1a174c04,0x204be5cda8d98412,0x0565960cfc012768,0x14faf071d204cf2c,1.476,1.492227,86404,0,PASS
+297746112,floating-islands,clang19-on,12,27,15,29396,39.199219,20.609375,-119.089844,0x2425273f1a174c04,0x204be5cda8d98412,0x0565960cfc012768,0x14faf071d204cf2c,0.697,0.724120,301764,0,PASS
+297746112,floating-islands,gcc14-default,1,27,15,29396,39.199219,20.609375,-119.089844,0x2425273f1a174c04,0x204be5cda8d98412,0x0565960cfc012768,0x14faf071d204cf2c,1.606,1.623971,87112,0,PASS
+297746112,floating-islands,gcc14-default,12,27,15,29396,39.199219,20.609375,-119.089844,0x2425273f1a174c04,0x204be5cda8d98412,0x0565960cfc012768,0x14faf071d204cf2c,0.744,0.770764,301868,0,PASS
+336768467,surface-world,clang19-off,1,27,15,29748,0.000000,-140.000000,-2014.343750,0x2756e6dc388ddf57,0x66344082236c5630,0x8d1456f1c9c5391d,0x8c5dafb1129150a4,0.193,0.210861,84432,0,PASS
+336768467,surface-world,clang19-off,12,27,15,29748,0.000000,-140.000000,-2014.343750,0x2756e6dc388ddf57,0x66344082236c5630,0x8d1456f1c9c5391d,0x8c5dafb1129150a4,0.439,0.465773,299308,0,PASS
+336768467,surface-world,clang19-on,1,27,15,29748,0.000000,-140.000000,-2014.343750,0x2756e6dc388ddf57,0x66344082236c5630,0x8d1456f1c9c5391d,0x8c5dafb1129150a4,0.203,0.220275,84220,0,PASS
+336768467,surface-world,clang19-on,12,27,15,29748,0.000000,-140.000000,-2014.343750,0x2756e6dc388ddf57,0x66344082236c5630,0x8d1456f1c9c5391d,0x8c5dafb1129150a4,0.442,0.472005,298776,0,PASS
+336768467,surface-world,gcc14-default,1,27,15,29748,0.000000,-140.000000,-2014.343750,0x2756e6dc388ddf57,0x66344082236c5630,0x8d1456f1c9c5391d,0x8c5dafb1129150a4,0.195,0.210295,84640,0,PASS
+336768467,surface-world,gcc14-default,12,27,15,29748,0.000000,-140.000000,-2014.343750,0x2756e6dc388ddf57,0x66344082236c5630,0x8d1456f1c9c5391d,0x8c5dafb1129150a4,0.441,0.468001,299924,0,PASS
+336768467,floating-islands,clang19-off,1,27,12,33652,0.000000,-20.933594,-116.355469,0xfa8249483c186760,0xc42acd7c93e1525c,0xdef1819f3ea0dfba,0xe7f844319ae479a5,1.560,1.576635,86384,0,PASS
+336768467,floating-islands,clang19-off,12,27,12,33652,0.000000,-20.933594,-116.355469,0xfa8249483c186760,0xc42acd7c93e1525c,0xdef1819f3ea0dfba,0xe7f844319ae479a5,0.687,0.715116,302356,0,PASS
+336768467,floating-islands,clang19-on,1,27,12,33652,0.000000,-20.933594,-116.355469,0xfa8249483c186760,0xc42acd7c93e1525c,0xdef1819f3ea0dfba,0xe7f844319ae479a5,1.607,1.622026,86512,0,PASS
+336768467,floating-islands,clang19-on,12,27,12,33652,0.000000,-20.933594,-116.355469,0xfa8249483c186760,0xc42acd7c93e1525c,0xdef1819f3ea0dfba,0xe7f844319ae479a5,0.756,0.786103,301928,0,PASS
+336768467,floating-islands,gcc14-default,1,27,12,33652,0.000000,-20.933594,-116.355469,0xfa8249483c186760,0xc42acd7c93e1525c,0xdef1819f3ea0dfba,0xe7f844319ae479a5,1.659,1.676423,87116,0,PASS
+336768467,floating-islands,gcc14-default,12,27,12,33652,0.000000,-20.933594,-116.355469,0xfa8249483c186760,0xc42acd7c93e1525c,0xdef1819f3ea0dfba,0xe7f844319ae479a5,0.745,0.770547,302312,0,PASS
+512532080,surface-world,clang19-off,1,27,14,28800,0.000000,-140.000000,-2011.875000,0xa5ad29a27d991d10,0x060bc1fca8569368,0x726e34d2232e7e04,0x2cfa7c1af8ec4ee4,0.238,0.255841,84384,0,PASS
+512532080,surface-world,clang19-off,12,27,14,28800,0.000000,-140.000000,-2011.875000,0xa5ad29a27d991d10,0x060bc1fca8569368,0x726e34d2232e7e04,0x2cfa7c1af8ec4ee4,0.472,0.498432,298872,0,PASS
+512532080,surface-world,clang19-on,1,27,14,28800,0.000000,-140.000000,-2011.875000,0xa5ad29a27d991d10,0x060bc1fca8569368,0x726e34d2232e7e04,0x2cfa7c1af8ec4ee4,0.224,0.240126,84544,0,PASS
+512532080,surface-world,clang19-on,12,27,14,28800,0.000000,-140.000000,-2011.875000,0xa5ad29a27d991d10,0x060bc1fca8569368,0x726e34d2232e7e04,0x2cfa7c1af8ec4ee4,0.456,0.482429,299344,0,PASS
+512532080,surface-world,gcc14-default,1,27,14,28800,0.000000,-140.000000,-2011.875000,0xa5ad29a27d991d10,0x060bc1fca8569368,0x726e34d2232e7e04,0x2cfa7c1af8ec4ee4,0.219,0.236902,84712,0,PASS
+512532080,surface-world,gcc14-default,12,27,14,28800,0.000000,-140.000000,-2011.875000,0xa5ad29a27d991d10,0x060bc1fca8569368,0x726e34d2232e7e04,0x2cfa7c1af8ec4ee4,0.468,0.494269,299636,0,PASS
+512532080,floating-islands,clang19-off,1,27,14,34900,0.000000,-20.355469,-116.640625,0xb098abe6a38cfe3a,0x436a6541192ed00e,0x75e2b7c9004349c2,0x534923147812f216,1.231,1.246649,86052,0,PASS
+512532080,floating-islands,clang19-off,12,27,14,34900,0.000000,-20.355469,-116.640625,0xb098abe6a38cfe3a,0x436a6541192ed00e,0x75e2b7c9004349c2,0x534923147812f216,0.615,0.641439,301628,0,PASS
+512532080,floating-islands,clang19-on,1,27,14,34900,0.000000,-20.355469,-116.640625,0xb098abe6a38cfe3a,0x436a6541192ed00e,0x75e2b7c9004349c2,0x534923147812f216,1.228,1.242805,85768,0,PASS
+512532080,floating-islands,clang19-on,12,27,14,34900,0.000000,-20.355469,-116.640625,0xb098abe6a38cfe3a,0x436a6541192ed00e,0x75e2b7c9004349c2,0x534923147812f216,0.627,0.655211,301628,0,PASS
+512532080,floating-islands,gcc14-default,1,27,14,34900,0.000000,-20.355469,-116.640625,0xb098abe6a38cfe3a,0x436a6541192ed00e,0x75e2b7c9004349c2,0x534923147812f216,1.359,1.374927,86224,0,PASS
+512532080,floating-islands,gcc14-default,12,27,14,34900,0.000000,-20.355469,-116.640625,0xb098abe6a38cfe3a,0x436a6541192ed00e,0x75e2b7c9004349c2,0x534923147812f216,0.653,0.684763,302532,0,PASS
+821120640,surface-world,clang19-off,1,27,17,29100,0.000000,-140.000000,-2017.054688,0xb6424f19c272b61c,0xe4f7308d87cb3bc2,0x3f43e313583419b6,0xe7bf900c0a18e037,0.235,0.252205,84088,0,PASS
+821120640,surface-world,clang19-off,12,27,17,29100,0.000000,-140.000000,-2017.054688,0xb6424f19c272b61c,0xe4f7308d87cb3bc2,0x3f43e313583419b6,0xe7bf900c0a18e037,0.471,0.497535,298356,0,PASS
+821120640,surface-world,clang19-on,1,27,17,29100,0.000000,-140.000000,-2017.054688,0xb6424f19c272b61c,0xe4f7308d87cb3bc2,0x3f43e313583419b6,0xe7bf900c0a18e037,0.232,0.246887,84276,0,PASS
+821120640,surface-world,clang19-on,12,27,17,29100,0.000000,-140.000000,-2017.054688,0xb6424f19c272b61c,0xe4f7308d87cb3bc2,0x3f43e313583419b6,0xe7bf900c0a18e037,0.444,0.469734,298640,0,PASS
+821120640,surface-world,gcc14-default,1,27,17,29100,0.000000,-140.000000,-2017.054688,0xb6424f19c272b61c,0xe4f7308d87cb3bc2,0x3f43e313583419b6,0xe7bf900c0a18e037,0.227,0.242379,84848,0,PASS
+821120640,surface-world,gcc14-default,12,27,17,29100,0.000000,-140.000000,-2017.054688,0xb6424f19c272b61c,0xe4f7308d87cb3bc2,0x3f43e313583419b6,0xe7bf900c0a18e037,0.446,0.472509,299120,0,PASS
+821120640,floating-islands,clang19-off,1,27,11,27034,39.199219,18.121094,-108.417969,0x3db9226404527944,0xb3328f1c88e96c70,0x1e9434cf277c52f2,0x7623a6394f56d6bc,1.593,1.609040,86048,0,PASS
+821120640,floating-islands,clang19-off,12,27,11,27034,39.199219,18.121094,-108.417969,0x3db9226404527944,0xb3328f1c88e96c70,0x1e9434cf277c52f2,0x7623a6394f56d6bc,0.771,0.798393,300532,0,PASS
+821120640,floating-islands,clang19-on,1,27,11,27034,39.199219,18.121094,-108.417969,0x3db9226404527944,0xb3328f1c88e96c70,0x1e9434cf277c52f2,0x7623a6394f56d6bc,1.647,1.661841,85752,0,PASS
+821120640,floating-islands,clang19-on,12,27,11,27034,39.199219,18.121094,-108.417969,0x3db9226404527944,0xb3328f1c88e96c70,0x1e9434cf277c52f2,0x7623a6394f56d6bc,0.731,0.757095,300348,0,PASS
+821120640,floating-islands,gcc14-default,1,27,11,27034,39.199219,18.121094,-108.417969,0x3db9226404527944,0xb3328f1c88e96c70,0x1e9434cf277c52f2,0x7623a6394f56d6bc,1.791,1.807593,86356,0,PASS
+821120640,floating-islands,gcc14-default,12,27,11,27034,39.199219,18.121094,-108.417969,0x3db9226404527944,0xb3328f1c88e96c70,0x1e9434cf277c52f2,0x7623a6394f56d6bc,0.778,0.806980,301348,0,PASS
+853538490,surface-world,clang19-off,1,27,13,41529,0.000000,-140.000000,-2000.957031,0xbe1224f297dc7ad0,0x7e10918947195940,0xac9466d520e8d24d,0xd4a8b472e9b12049,0.325,0.340334,84252,0,PASS
+853538490,surface-world,clang19-off,12,27,13,41529,0.000000,-140.000000,-2000.957031,0xbe1224f297dc7ad0,0x7e10918947195940,0xac9466d520e8d24d,0xd4a8b472e9b12049,0.490,0.517745,297932,0,PASS
+853538490,surface-world,clang19-on,1,27,13,41529,0.000000,-140.000000,-2000.957031,0xbe1224f297dc7ad0,0x7e10918947195940,0xac9466d520e8d24d,0xd4a8b472e9b12049,0.307,0.324074,84504,0,PASS
+853538490,surface-world,clang19-on,12,27,13,41529,0.000000,-140.000000,-2000.957031,0xbe1224f297dc7ad0,0x7e10918947195940,0xac9466d520e8d24d,0xd4a8b472e9b12049,0.484,0.510395,297860,0,PASS
+853538490,surface-world,gcc14-default,1,27,13,41529,0.000000,-140.000000,-2000.957031,0xbe1224f297dc7ad0,0x7e10918947195940,0xac9466d520e8d24d,0xd4a8b472e9b12049,0.292,0.309051,85156,0,PASS
+853538490,surface-world,gcc14-default,12,27,13,41529,0.000000,-140.000000,-2000.957031,0xbe1224f297dc7ad0,0x7e10918947195940,0xac9466d520e8d24d,0xd4a8b472e9b12049,0.487,0.516413,300220,0,PASS
+853538490,floating-islands,clang19-off,1,27,12,21100,64.398438,75.593750,-125.132812,0x7e568fc03c907914,0x6a9fc36512216056,0x42911f340bd75887,0x9a884d5fe3bc3a9f,1.502,1.518453,85300,0,PASS
+853538490,floating-islands,clang19-off,12,27,12,21100,64.398438,75.593750,-125.132812,0x7e568fc03c907914,0x6a9fc36512216056,0x42911f340bd75887,0x9a884d5fe3bc3a9f,0.752,0.778760,299572,0,PASS
+853538490,floating-islands,clang19-on,1,27,12,21100,64.398438,75.593750,-125.132812,0x7e568fc03c907914,0x6a9fc36512216056,0x42911f340bd75887,0x9a884d5fe3bc3a9f,1.511,1.527571,85176,0,PASS
+853538490,floating-islands,clang19-on,12,27,12,21100,64.398438,75.593750,-125.132812,0x7e568fc03c907914,0x6a9fc36512216056,0x42911f340bd75887,0x9a884d5fe3bc3a9f,0.743,0.771772,299476,0,PASS
+853538490,floating-islands,gcc14-default,1,27,12,21100,64.398438,75.593750,-125.132812,0x7e568fc03c907914,0x6a9fc36512216056,0x42911f340bd75887,0x9a884d5fe3bc3a9f,1.490,1.506165,86100,0,PASS
+853538490,floating-islands,gcc14-default,12,27,12,21100,64.398438,75.593750,-125.132812,0x7e568fc03c907914,0x6a9fc36512216056,0x42911f340bd75887,0x9a884d5fe3bc3a9f,0.733,0.759420,300016,0,PASS
+861026696,surface-world,clang19-off,1,27,14,29214,0.000000,-140.000000,-2015.378906,0xb04a05c6e8c488dc,0x28706d092bd82c9a,0xcdcd6eb7219ba860,0x713552a70402ee90,0.206,0.222328,85820,0,PASS
+861026696,surface-world,clang19-off,12,27,14,29214,0.000000,-140.000000,-2015.378906,0xb04a05c6e8c488dc,0x28706d092bd82c9a,0xcdcd6eb7219ba860,0x713552a70402ee90,0.442,0.469511,301112,0,PASS
+861026696,surface-world,clang19-on,1,27,14,29214,0.000000,-140.000000,-2015.378906,0xb04a05c6e8c488dc,0x28706d092bd82c9a,0xcdcd6eb7219ba860,0x713552a70402ee90,0.198,0.218476,86120,0,PASS
+861026696,surface-world,clang19-on,12,27,14,29214,0.000000,-140.000000,-2015.378906,0xb04a05c6e8c488dc,0x28706d092bd82c9a,0xcdcd6eb7219ba860,0x713552a70402ee90,0.420,0.449855,300708,0,PASS
+861026696,surface-world,gcc14-default,1,27,14,29214,0.000000,-140.000000,-2015.378906,0xb04a05c6e8c488dc,0x28706d092bd82c9a,0xcdcd6eb7219ba860,0x713552a70402ee90,0.198,0.213825,86600,0,PASS
+861026696,surface-world,gcc14-default,12,27,14,29214,0.000000,-140.000000,-2015.378906,0xb04a05c6e8c488dc,0x28706d092bd82c9a,0xcdcd6eb7219ba860,0x713552a70402ee90,0.425,0.451908,301600,0,PASS
+861026696,floating-islands,clang19-off,1,27,12,20194,-39.199219,16.035156,-124.882812,0xcb6792ec32335dc5,0x195efb6c80156e4a,0x99d2394c065c7d84,0xa650d8cc28f6ca8c,1.205,1.221248,86916,0,PASS
+861026696,floating-islands,clang19-off,12,27,12,20194,-39.199219,16.035156,-124.882812,0xcb6792ec32335dc5,0x195efb6c80156e4a,0x99d2394c065c7d84,0xa650d8cc28f6ca8c,0.626,0.656240,301180,0,PASS
+861026696,floating-islands,clang19-on,1,27,12,20194,-39.199219,16.035156,-124.882812,0xcb6792ec32335dc5,0x195efb6c80156e4a,0x99d2394c065c7d84,0xa650d8cc28f6ca8c,1.204,1.220794,86292,0,PASS
+861026696,floating-islands,clang19-on,12,27,12,20194,-39.199219,16.035156,-124.882812,0xcb6792ec32335dc5,0x195efb6c80156e4a,0x99d2394c065c7d84,0xa650d8cc28f6ca8c,0.629,0.656007,300976,0,PASS
+861026696,floating-islands,gcc14-default,1,27,12,20194,-39.199219,16.035156,-124.882812,0xcb6792ec32335dc5,0x195efb6c80156e4a,0x99d2394c065c7d84,0xa650d8cc28f6ca8c,1.304,1.320997,87184,0,PASS
+861026696,floating-islands,gcc14-default,12,27,12,20194,-39.199219,16.035156,-124.882812,0xcb6792ec32335dc5,0x195efb6c80156e4a,0x99d2394c065c7d84,0xa650d8cc28f6ca8c,0.661,0.688252,301512,0,PASS
+1026251636,surface-world,clang19-off,1,27,9,28584,0.000000,-140.000000,-2001.500000,0xf6bb5ab0a9e2307d,0x4767f425e56543f4,0x7d07264eb771e914,0x4c10ed20b1feb752,0.181,0.196873,89468,0,PASS
+1026251636,surface-world,clang19-off,12,27,9,28584,0.000000,-140.000000,-2001.500000,0xf6bb5ab0a9e2307d,0x4767f425e56543f4,0x7d07264eb771e914,0x4c10ed20b1feb752,0.429,0.455273,299856,0,PASS
+1026251636,surface-world,clang19-on,1,27,9,28584,0.000000,-140.000000,-2001.500000,0xf6bb5ab0a9e2307d,0x4767f425e56543f4,0x7d07264eb771e914,0x4c10ed20b1feb752,0.175,0.191878,88936,0,PASS
+1026251636,surface-world,clang19-on,12,27,9,28584,0.000000,-140.000000,-2001.500000,0xf6bb5ab0a9e2307d,0x4767f425e56543f4,0x7d07264eb771e914,0x4c10ed20b1feb752,0.421,0.446342,300064,0,PASS
+1026251636,surface-world,gcc14-default,1,27,9,28584,0.000000,-140.000000,-2001.500000,0xf6bb5ab0a9e2307d,0x4767f425e56543f4,0x7d07264eb771e914,0x4c10ed20b1feb752,0.186,0.201393,89824,0,PASS
+1026251636,surface-world,gcc14-default,12,27,9,28584,0.000000,-140.000000,-2001.500000,0xf6bb5ab0a9e2307d,0x4767f425e56543f4,0x7d07264eb771e914,0x4c10ed20b1feb752,0.440,0.465684,300752,0,PASS
+1026251636,floating-islands,clang19-off,1,27,8,19958,-25.199219,-74.664062,-109.117188,0xe62d0a684fcd1398,0xca0e1740a58cafbd,0xb28adbbe9f346438,0xaeddcc5189ee4f9c,2.014,2.030369,89720,0,PASS
+1026251636,floating-islands,clang19-off,12,27,8,19958,-25.199219,-74.664062,-109.117188,0xe62d0a684fcd1398,0xca0e1740a58cafbd,0xb28adbbe9f346438,0xaeddcc5189ee4f9c,0.784,0.811497,304088,0,PASS
+1026251636,floating-islands,clang19-on,1,27,8,19958,-25.199219,-74.664062,-109.117188,0xe62d0a684fcd1398,0xca0e1740a58cafbd,0xb28adbbe9f346438,0xaeddcc5189ee4f9c,2.037,2.053588,90148,0,PASS
+1026251636,floating-islands,clang19-on,12,27,8,19958,-25.199219,-74.664062,-109.117188,0xe62d0a684fcd1398,0xca0e1740a58cafbd,0xb28adbbe9f346438,0xaeddcc5189ee4f9c,0.805,0.831833,303992,0,PASS
+1026251636,floating-islands,gcc14-default,1,27,8,19958,-25.199219,-74.664062,-109.117188,0xe62d0a684fcd1398,0xca0e1740a58cafbd,0xb28adbbe9f346438,0xaeddcc5189ee4f9c,2.030,2.046181,90280,0,PASS
+1026251636,floating-islands,gcc14-default,12,27,8,19958,-25.199219,-74.664062,-109.117188,0xe62d0a684fcd1398,0xca0e1740a58cafbd,0xb28adbbe9f346438,0xaeddcc5189ee4f9c,0.829,0.855747,304588,0,PASS
+1077415394,surface-world,clang19-off,1,27,12,27666,0.000000,-140.000000,-2018.636719,0xb65f4acca21a93d8,0x0a3cddad02604438,0xe1cc5b39a1d20a9c,0xba1d3df14ef1dbc1,0.193,0.208931,87732,0,PASS
+1077415394,surface-world,clang19-off,12,27,12,27666,0.000000,-140.000000,-2018.636719,0xb65f4acca21a93d8,0x0a3cddad02604438,0xe1cc5b39a1d20a9c,0xba1d3df14ef1dbc1,0.436,0.463397,302684,0,PASS
+1077415394,surface-world,clang19-on,1,27,12,27666,0.000000,-140.000000,-2018.636719,0xb65f4acca21a93d8,0x0a3cddad02604438,0xe1cc5b39a1d20a9c,0xba1d3df14ef1dbc1,0.193,0.210262,87604,0,PASS
+1077415394,surface-world,clang19-on,12,27,12,27666,0.000000,-140.000000,-2018.636719,0xb65f4acca21a93d8,0x0a3cddad02604438,0xe1cc5b39a1d20a9c,0xba1d3df14ef1dbc1,0.420,0.447388,300700,0,PASS
+1077415394,surface-world,gcc14-default,1,27,12,27666,0.000000,-140.000000,-2018.636719,0xb65f4acca21a93d8,0x0a3cddad02604438,0xe1cc5b39a1d20a9c,0xba1d3df14ef1dbc1,0.190,0.205810,88040,0,PASS
+1077415394,surface-world,gcc14-default,12,27,12,27666,0.000000,-140.000000,-2018.636719,0xb65f4acca21a93d8,0x0a3cddad02604438,0xe1cc5b39a1d20a9c,0xba1d3df14ef1dbc1,0.423,0.451176,302760,0,PASS
+1077415394,floating-islands,clang19-off,1,27,9,25992,39.199219,20.472656,-109.757812,0x76ffc67a9d410089,0x712f9bef468c36e1,0xd15add3c403cf9d2,0x1f98a205464ab093,1.607,1.623777,88912,0,PASS
+1077415394,floating-islands,clang19-off,12,27,9,25992,39.199219,20.472656,-109.757812,0x76ffc67a9d410089,0x712f9bef468c36e1,0xd15add3c403cf9d2,0x1f98a205464ab093,0.714,0.740654,303924,0,PASS
+1077415394,floating-islands,clang19-on,1,27,9,25992,39.199219,20.472656,-109.757812,0x76ffc67a9d410089,0x712f9bef468c36e1,0xd15add3c403cf9d2,0x1f98a205464ab093,1.587,1.603589,89156,0,PASS
+1077415394,floating-islands,clang19-on,12,27,9,25992,39.199219,20.472656,-109.757812,0x76ffc67a9d410089,0x712f9bef468c36e1,0xd15add3c403cf9d2,0x1f98a205464ab093,0.678,0.704362,303820,0,PASS
+1077415394,floating-islands,gcc14-default,1,27,9,25992,39.199219,20.472656,-109.757812,0x76ffc67a9d410089,0x712f9bef468c36e1,0xd15add3c403cf9d2,0x1f98a205464ab093,1.751,1.766817,89248,0,PASS
+1077415394,floating-islands,gcc14-default,12,27,9,25992,39.199219,20.472656,-109.757812,0x76ffc67a9d410089,0x712f9bef468c36e1,0xd15add3c403cf9d2,0x1f98a205464ab093,0.726,0.753263,304336,0,PASS
+1130999017,surface-world,clang19-off,1,27,15,38852,0.000000,-140.000000,-1885.390625,0xd4fee006d89064ec,0xc2e722815c510b8d,0xaee1e5e204213289,0x6107884769e6196b,0.258,0.275630,85440,0,PASS
+1130999017,surface-world,clang19-off,12,27,15,38852,0.000000,-140.000000,-1885.390625,0xd4fee006d89064ec,0xc2e722815c510b8d,0xaee1e5e204213289,0x6107884769e6196b,0.452,0.478967,301608,0,PASS
+1130999017,surface-world,clang19-on,1,27,15,38852,0.000000,-140.000000,-1885.390625,0xd4fee006d89064ec,0xc2e722815c510b8d,0xaee1e5e204213289,0x6107884769e6196b,0.251,0.266976,85864,0,PASS
+1130999017,surface-world,clang19-on,12,27,15,38852,0.000000,-140.000000,-1885.390625,0xd4fee006d89064ec,0xc2e722815c510b8d,0xaee1e5e204213289,0x6107884769e6196b,0.443,0.472895,299580,0,PASS
+1130999017,surface-world,gcc14-default,1,27,15,38852,0.000000,-140.000000,-1885.390625,0xd4fee006d89064ec,0xc2e722815c510b8d,0xaee1e5e204213289,0x6107884769e6196b,0.243,0.258360,86216,0,PASS
+1130999017,surface-world,gcc14-default,12,27,15,38852,0.000000,-140.000000,-1885.390625,0xd4fee006d89064ec,0xc2e722815c510b8d,0xaee1e5e204213289,0x6107884769e6196b,0.430,0.459582,300604,0,PASS
+1130999017,floating-islands,clang19-off,1,27,14,25686,-39.199219,19.199219,-119.304688,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1,0x24ac0b621165dc1c,0x3e15c5e91f7d7e46,1.116,1.133283,84856,0,PASS
+1130999017,floating-islands,clang19-off,12,27,14,25686,-39.199219,19.199219,-119.304688,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1,0x24ac0b621165dc1c,0x3e15c5e91f7d7e46,0.608,0.635013,299952,0,PASS
+1130999017,floating-islands,clang19-on,1,27,14,25686,-39.199219,19.199219,-119.304688,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1,0x24ac0b621165dc1c,0x3e15c5e91f7d7e46,1.131,1.147307,84968,0,PASS
+1130999017,floating-islands,clang19-on,12,27,14,25686,-39.199219,19.199219,-119.304688,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1,0x24ac0b621165dc1c,0x3e15c5e91f7d7e46,0.600,0.627582,299320,0,PASS
+1130999017,floating-islands,gcc14-default,1,27,14,25686,-39.199219,19.199219,-119.304688,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1,0x24ac0b621165dc1c,0x3e15c5e91f7d7e46,1.180,1.196907,85352,0,PASS
+1130999017,floating-islands,gcc14-default,12,27,14,25686,-39.199219,19.199219,-119.304688,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1,0x24ac0b621165dc1c,0x3e15c5e91f7d7e46,0.653,0.679477,300280,0,PASS
+1156488597,surface-world,clang19-off,1,27,10,26660,0.000000,-140.000000,-2012.031250,0xf918cd1d254bf5ad,0x93e291c7e8ab3281,0x115d528201ee55de,0x8282368945b9aa39,0.169,0.185411,84912,0,PASS
+1156488597,surface-world,clang19-off,12,27,10,26660,0.000000,-140.000000,-2012.031250,0xf918cd1d254bf5ad,0x93e291c7e8ab3281,0x115d528201ee55de,0x8282368945b9aa39,0.415,0.440950,296868,0,PASS
+1156488597,surface-world,clang19-on,1,27,10,26660,0.000000,-140.000000,-2012.031250,0xf918cd1d254bf5ad,0x93e291c7e8ab3281,0x115d528201ee55de,0x8282368945b9aa39,0.170,0.185517,85336,0,PASS
+1156488597,surface-world,clang19-on,12,27,10,26660,0.000000,-140.000000,-2012.031250,0xf918cd1d254bf5ad,0x93e291c7e8ab3281,0x115d528201ee55de,0x8282368945b9aa39,0.458,0.494970,296900,0,PASS
+1156488597,surface-world,gcc14-default,1,27,10,26660,0.000000,-140.000000,-2012.031250,0xf918cd1d254bf5ad,0x93e291c7e8ab3281,0x115d528201ee55de,0x8282368945b9aa39,0.178,0.205454,85672,0,PASS
+1156488597,surface-world,gcc14-default,12,27,10,26660,0.000000,-140.000000,-2012.031250,0xf918cd1d254bf5ad,0x93e291c7e8ab3281,0x115d528201ee55de,0x8282368945b9aa39,0.454,0.483690,297532,0,PASS
+1156488597,floating-islands,clang19-off,1,27,14,22928,-39.199219,16.464844,-121.550781,0x080c04f591e988da,0x7d2e52b446efd9d1,0x6dccf350fe593410,0x97ae318aaff326ae,1.464,1.480495,87092,0,PASS
+1156488597,floating-islands,clang19-off,12,27,14,22928,-39.199219,16.464844,-121.550781,0x080c04f591e988da,0x7d2e52b446efd9d1,0x6dccf350fe593410,0x97ae318aaff326ae,0.684,0.710558,301280,0,PASS
+1156488597,floating-islands,clang19-on,1,27,14,22928,-39.199219,16.464844,-121.550781,0x080c04f591e988da,0x7d2e52b446efd9d1,0x6dccf350fe593410,0x97ae318aaff326ae,1.481,1.498290,87056,0,PASS
+1156488597,floating-islands,clang19-on,12,27,14,22928,-39.199219,16.464844,-121.550781,0x080c04f591e988da,0x7d2e52b446efd9d1,0x6dccf350fe593410,0x97ae318aaff326ae,0.707,0.737492,301040,0,PASS
+1156488597,floating-islands,gcc14-default,1,27,14,22928,-39.199219,16.464844,-121.550781,0x080c04f591e988da,0x7d2e52b446efd9d1,0x6dccf350fe593410,0x97ae318aaff326ae,1.635,1.652170,87388,0,PASS
+1156488597,floating-islands,gcc14-default,12,27,14,22928,-39.199219,16.464844,-121.550781,0x080c04f591e988da,0x7d2e52b446efd9d1,0x6dccf350fe593410,0x97ae318aaff326ae,0.730,0.758962,301644,0,PASS
+1172304228,surface-world,clang19-off,1,27,9,28078,0.000000,-140.000000,-2030.214844,0x466d74beb6a3c43f,0x935c08e020dbe116,0x495814a08ffe3b6e,0xa3a7e103fe545c77,0.159,0.176089,84448,0,PASS
+1172304228,surface-world,clang19-off,12,27,9,28078,0.000000,-140.000000,-2030.214844,0x466d74beb6a3c43f,0x935c08e020dbe116,0x495814a08ffe3b6e,0xa3a7e103fe545c77,0.416,0.444129,294644,0,PASS
+1172304228,surface-world,clang19-on,1,27,9,28078,0.000000,-140.000000,-2030.214844,0x466d74beb6a3c43f,0x935c08e020dbe116,0x495814a08ffe3b6e,0xa3a7e103fe545c77,0.159,0.174634,84268,0,PASS
+1172304228,surface-world,clang19-on,12,27,9,28078,0.000000,-140.000000,-2030.214844,0x466d74beb6a3c43f,0x935c08e020dbe116,0x495814a08ffe3b6e,0xa3a7e103fe545c77,0.409,0.435936,294684,0,PASS
+1172304228,surface-world,gcc14-default,1,27,9,28078,0.000000,-140.000000,-2030.214844,0x466d74beb6a3c43f,0x935c08e020dbe116,0x495814a08ffe3b6e,0xa3a7e103fe545c77,0.161,0.177733,84864,0,PASS
+1172304228,surface-world,gcc14-default,12,27,9,28078,0.000000,-140.000000,-2030.214844,0x466d74beb6a3c43f,0x935c08e020dbe116,0x495814a08ffe3b6e,0xa3a7e103fe545c77,0.407,0.433961,295552,0,PASS
+1172304228,floating-islands,clang19-off,1,27,12,25280,-39.199219,16.859375,-120.363281,0xa4ceaef6289c2778,0xac854a5846adc6cb,0xc79cc3dcf8aa7882,0x2a36a844bc640838,0.855,0.871675,86436,0,PASS
+1172304228,floating-islands,clang19-off,12,27,12,25280,-39.199219,16.859375,-120.363281,0xa4ceaef6289c2778,0xac854a5846adc6cb,0xc79cc3dcf8aa7882,0x2a36a844bc640838,0.566,0.594146,300964,0,PASS
+1172304228,floating-islands,clang19-on,1,27,12,25280,-39.199219,16.859375,-120.363281,0xa4ceaef6289c2778,0xac854a5846adc6cb,0xc79cc3dcf8aa7882,0x2a36a844bc640838,0.866,0.882396,86372,0,PASS
+1172304228,floating-islands,clang19-on,12,27,12,25280,-39.199219,16.859375,-120.363281,0xa4ceaef6289c2778,0xac854a5846adc6cb,0xc79cc3dcf8aa7882,0x2a36a844bc640838,0.576,0.603920,301252,0,PASS
+1172304228,floating-islands,gcc14-default,1,27,12,25280,-39.199219,16.859375,-120.363281,0xa4ceaef6289c2778,0xac854a5846adc6cb,0xc79cc3dcf8aa7882,0x2a36a844bc640838,0.938,0.954134,86620,0,PASS
+1172304228,floating-islands,gcc14-default,12,27,12,25280,-39.199219,16.859375,-120.363281,0xa4ceaef6289c2778,0xac854a5846adc6cb,0xc79cc3dcf8aa7882,0x2a36a844bc640838,0.586,0.615590,301852,0,PASS
+1370340570,surface-world,clang19-off,1,27,9,26888,0.000000,-140.000000,-2026.738281,0xb71aa861999e9064,0x5e6eb187fe7aa3d1,0xdbd2bf3e112249bb,0xbb50eff77e4ba5a7,0.159,0.175263,84752,0,PASS
+1370340570,surface-world,clang19-off,12,27,9,26888,0.000000,-140.000000,-2026.738281,0xb71aa861999e9064,0x5e6eb187fe7aa3d1,0xdbd2bf3e112249bb,0xbb50eff77e4ba5a7,0.416,0.441389,295492,0,PASS
+1370340570,surface-world,clang19-on,1,27,9,26888,0.000000,-140.000000,-2026.738281,0xb71aa861999e9064,0x5e6eb187fe7aa3d1,0xdbd2bf3e112249bb,0xbb50eff77e4ba5a7,0.153,0.168519,84744,0,PASS
+1370340570,surface-world,clang19-on,12,27,9,26888,0.000000,-140.000000,-2026.738281,0xb71aa861999e9064,0x5e6eb187fe7aa3d1,0xdbd2bf3e112249bb,0xbb50eff77e4ba5a7,0.409,0.438368,295092,0,PASS
+1370340570,surface-world,gcc14-default,1,27,9,26888,0.000000,-140.000000,-2026.738281,0xb71aa861999e9064,0x5e6eb187fe7aa3d1,0xdbd2bf3e112249bb,0xbb50eff77e4ba5a7,0.155,0.170254,85124,0,PASS
+1370340570,surface-world,gcc14-default,12,27,9,26888,0.000000,-140.000000,-2026.738281,0xb71aa861999e9064,0x5e6eb187fe7aa3d1,0xdbd2bf3e112249bb,0xbb50eff77e4ba5a7,0.409,0.437481,296036,0,PASS
+1370340570,floating-islands,clang19-off,1,27,8,20458,-39.199219,17.164062,-114.296875,0xfe631978312f065a,0xc41cdcb438a98b86,0xc2df8d535d4c97d9,0xe26e0e5cc9e21c14,1.581,1.599496,86948,0,PASS
+1370340570,floating-islands,clang19-off,12,27,8,20458,-39.199219,17.164062,-114.296875,0xfe631978312f065a,0xc41cdcb438a98b86,0xc2df8d535d4c97d9,0xe26e0e5cc9e21c14,0.702,0.729410,301536,0,PASS
+1370340570,floating-islands,clang19-on,1,27,8,20458,-39.199219,17.164062,-114.296875,0xfe631978312f065a,0xc41cdcb438a98b86,0xc2df8d535d4c97d9,0xe26e0e5cc9e21c14,1.595,1.611272,87072,0,PASS
+1370340570,floating-islands,clang19-on,12,27,8,20458,-39.199219,17.164062,-114.296875,0xfe631978312f065a,0xc41cdcb438a98b86,0xc2df8d535d4c97d9,0xe26e0e5cc9e21c14,0.691,0.717960,301388,0,PASS
+1370340570,floating-islands,gcc14-default,1,27,8,20458,-39.199219,17.164062,-114.296875,0xfe631978312f065a,0xc41cdcb438a98b86,0xc2df8d535d4c97d9,0xe26e0e5cc9e21c14,1.728,1.744814,87540,0,PASS
+1370340570,floating-islands,gcc14-default,12,27,8,20458,-39.199219,17.164062,-114.296875,0xfe631978312f065a,0xc41cdcb438a98b86,0xc2df8d535d4c97d9,0xe26e0e5cc9e21c14,0.754,0.781424,302088,0,PASS
+1383925073,surface-world,clang19-off,1,27,13,27826,0.000000,-140.000000,-2018.113281,0x564bb6a29953fc31,0x891c57b01dc509f8,0xf94dfef226e94ece,0xf277b25c2571f165,0.181,0.196556,83960,0,PASS
+1383925073,surface-world,clang19-off,12,27,13,27826,0.000000,-140.000000,-2018.113281,0x564bb6a29953fc31,0x891c57b01dc509f8,0xf94dfef226e94ece,0xf277b25c2571f165,0.426,0.453780,298648,0,PASS
+1383925073,surface-world,clang19-on,1,27,13,27826,0.000000,-140.000000,-2018.113281,0x564bb6a29953fc31,0x891c57b01dc509f8,0xf94dfef226e94ece,0xf277b25c2571f165,0.184,0.201221,84120,0,PASS
+1383925073,surface-world,clang19-on,12,27,13,27826,0.000000,-140.000000,-2018.113281,0x564bb6a29953fc31,0x891c57b01dc509f8,0xf94dfef226e94ece,0xf277b25c2571f165,0.407,0.434497,298520,0,PASS
+1383925073,surface-world,gcc14-default,1,27,13,27826,0.000000,-140.000000,-2018.113281,0x564bb6a29953fc31,0x891c57b01dc509f8,0xf94dfef226e94ece,0xf277b25c2571f165,0.175,0.191617,84528,0,PASS
+1383925073,surface-world,gcc14-default,12,27,13,27826,0.000000,-140.000000,-2018.113281,0x564bb6a29953fc31,0x891c57b01dc509f8,0xf94dfef226e94ece,0xf277b25c2571f165,0.406,0.432371,299400,0,PASS
+1383925073,floating-islands,clang19-off,1,27,8,17340,64.398438,76.132812,-101.687500,0x20a6d43f24557065,0xace78f99c63a90bc,0xba9503af152a1017,0xb09b522bed1b8c47,1.524,1.540376,85480,0,PASS
+1383925073,floating-islands,clang19-off,12,27,8,17340,64.398438,76.132812,-101.687500,0x20a6d43f24557065,0xace78f99c63a90bc,0xba9503af152a1017,0xb09b522bed1b8c47,0.688,0.716589,299068,0,PASS
+1383925073,floating-islands,clang19-on,1,27,8,17340,64.398438,76.132812,-101.687500,0x20a6d43f24557065,0xace78f99c63a90bc,0xba9503af152a1017,0xb09b522bed1b8c47,1.524,1.540170,85484,0,PASS
+1383925073,floating-islands,clang19-on,12,27,8,17340,64.398438,76.132812,-101.687500,0x20a6d43f24557065,0xace78f99c63a90bc,0xba9503af152a1017,0xb09b522bed1b8c47,0.693,0.719692,299196,0,PASS
+1383925073,floating-islands,gcc14-default,1,27,8,17340,64.398438,76.132812,-101.687500,0x20a6d43f24557065,0xace78f99c63a90bc,0xba9503af152a1017,0xb09b522bed1b8c47,1.661,1.676492,85764,0,PASS
+1383925073,floating-islands,gcc14-default,12,27,8,17340,64.398438,76.132812,-101.687500,0x20a6d43f24557065,0xace78f99c63a90bc,0xba9503af152a1017,0xb09b522bed1b8c47,0.728,0.755271,299796,0,PASS
+1401164998,surface-world,clang19-off,1,27,14,33671,0.000000,-140.000000,-1923.625000,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.286,0.301458,85156,0,PASS
+1401164998,surface-world,clang19-off,12,27,14,33671,0.000000,-140.000000,-1923.625000,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.451,0.477156,300516,0,PASS
+1401164998,surface-world,clang19-on,1,27,14,33671,0.000000,-140.000000,-1923.625000,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.282,0.297994,85456,0,PASS
+1401164998,surface-world,clang19-on,12,27,14,33671,0.000000,-140.000000,-1923.625000,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.448,0.476334,300584,0,PASS
+1401164998,surface-world,gcc14-default,1,27,14,33671,0.000000,-140.000000,-1923.625000,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.278,0.294323,85820,0,PASS
+1401164998,surface-world,gcc14-default,12,27,14,33671,0.000000,-140.000000,-1923.625000,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e,0xd87700809feafff4,0xc2e832153a03b5d7,0.463,0.489660,301300,0,PASS
+1401164998,floating-islands,clang19-off,1,27,12,25478,-25.199219,-76.433594,-133.500000,0xa22b8a0f16d1cb98,0x85e184e7768795d1,0x29a6f8ac91d35e09,0xb778d52817341912,1.889,1.905353,86852,0,PASS
+1401164998,floating-islands,clang19-off,12,27,12,25478,-25.199219,-76.433594,-133.500000,0xa22b8a0f16d1cb98,0x85e184e7768795d1,0x29a6f8ac91d35e09,0xb778d52817341912,0.755,0.783092,299600,0,PASS
+1401164998,floating-islands,clang19-on,1,27,12,25478,-25.199219,-76.433594,-133.500000,0xa22b8a0f16d1cb98,0x85e184e7768795d1,0x29a6f8ac91d35e09,0xb778d52817341912,1.918,1.935211,87012,0,PASS
+1401164998,floating-islands,clang19-on,12,27,12,25478,-25.199219,-76.433594,-133.500000,0xa22b8a0f16d1cb98,0x85e184e7768795d1,0x29a6f8ac91d35e09,0xb778d52817341912,0.747,0.774451,299876,0,PASS
+1401164998,floating-islands,gcc14-default,1,27,12,25478,-25.199219,-76.433594,-133.500000,0xa22b8a0f16d1cb98,0x85e184e7768795d1,0x29a6f8ac91d35e09,0xb778d52817341912,1.962,1.978881,87376,0,PASS
+1401164998,floating-islands,gcc14-default,12,27,12,25478,-25.199219,-76.433594,-133.500000,0xa22b8a0f16d1cb98,0x85e184e7768795d1,0x29a6f8ac91d35e09,0xb778d52817341912,0.773,0.800827,300436,0,PASS
+1558879574,surface-world,clang19-off,1,27,12,30022,0.000000,-140.000000,-2026.257812,0x566bd8e41e9ce9de,0xd7344edfeac99334,0xffbfbdcc9b7796a9,0x0ab334df0eb60fd6,0.178,0.192933,83876,0,PASS
+1558879574,surface-world,clang19-off,12,27,12,30022,0.000000,-140.000000,-2026.257812,0x566bd8e41e9ce9de,0xd7344edfeac99334,0xffbfbdcc9b7796a9,0x0ab334df0eb60fd6,0.430,0.457703,298956,0,PASS
+1558879574,surface-world,clang19-on,1,27,12,30022,0.000000,-140.000000,-2026.257812,0x566bd8e41e9ce9de,0xd7344edfeac99334,0xffbfbdcc9b7796a9,0x0ab334df0eb60fd6,0.176,0.192307,83696,0,PASS
+1558879574,surface-world,clang19-on,12,27,12,30022,0.000000,-140.000000,-2026.257812,0x566bd8e41e9ce9de,0xd7344edfeac99334,0xffbfbdcc9b7796a9,0x0ab334df0eb60fd6,0.413,0.440116,297112,0,PASS
+1558879574,surface-world,gcc14-default,1,27,12,30022,0.000000,-140.000000,-2026.257812,0x566bd8e41e9ce9de,0xd7344edfeac99334,0xffbfbdcc9b7796a9,0x0ab334df0eb60fd6,0.182,0.197351,84408,0,PASS
+1558879574,surface-world,gcc14-default,12,27,12,30022,0.000000,-140.000000,-2026.257812,0x566bd8e41e9ce9de,0xd7344edfeac99334,0xffbfbdcc9b7796a9,0x0ab334df0eb60fd6,0.425,0.451513,299728,0,PASS
+1558879574,floating-islands,clang19-off,1,27,15,37078,0.000000,-15.878906,-116.753906,0x675134538e8ca09b,0x2e32a5444b8be6d7,0xa3945849da18e24a,0xda29fda6f39d36f9,0.864,0.880169,84868,0,PASS
+1558879574,floating-islands,clang19-off,12,27,15,37078,0.000000,-15.878906,-116.753906,0x675134538e8ca09b,0x2e32a5444b8be6d7,0xa3945849da18e24a,0xda29fda6f39d36f9,0.595,0.623192,301320,0,PASS
+1558879574,floating-islands,clang19-on,1,27,15,37078,0.000000,-15.878906,-116.753906,0x675134538e8ca09b,0x2e32a5444b8be6d7,0xa3945849da18e24a,0xda29fda6f39d36f9,0.898,0.914741,84904,0,PASS
+1558879574,floating-islands,clang19-on,12,27,15,37078,0.000000,-15.878906,-116.753906,0x675134538e8ca09b,0x2e32a5444b8be6d7,0xa3945849da18e24a,0xda29fda6f39d36f9,0.576,0.602221,300580,0,PASS
+1558879574,floating-islands,gcc14-default,1,27,15,37078,0.000000,-15.878906,-116.753906,0x675134538e8ca09b,0x2e32a5444b8be6d7,0xa3945849da18e24a,0xda29fda6f39d36f9,0.948,0.964253,85196,0,PASS
+1558879574,floating-islands,gcc14-default,12,27,15,37078,0.000000,-15.878906,-116.753906,0x675134538e8ca09b,0x2e32a5444b8be6d7,0xa3945849da18e24a,0xda29fda6f39d36f9,0.596,0.625674,301684,0,PASS
+1753015542,surface-world,clang19-off,1,27,9,27536,0.000000,-140.000000,-2004.562500,0x3557e0f7c1298c35,0x833da36dd2c02e13,0x656f82e69ccdecc2,0xac9935bb75fdb59c,0.157,0.174474,85136,0,PASS
+1753015542,surface-world,clang19-off,12,27,9,27536,0.000000,-140.000000,-2004.562500,0x3557e0f7c1298c35,0x833da36dd2c02e13,0x656f82e69ccdecc2,0xac9935bb75fdb59c,0.400,0.426649,295468,0,PASS
+1753015542,surface-world,clang19-on,1,27,9,27536,0.000000,-140.000000,-2004.562500,0x3557e0f7c1298c35,0x833da36dd2c02e13,0x656f82e69ccdecc2,0xac9935bb75fdb59c,0.157,0.173307,85120,0,PASS
+1753015542,surface-world,clang19-on,12,27,9,27536,0.000000,-140.000000,-2004.562500,0x3557e0f7c1298c35,0x833da36dd2c02e13,0x656f82e69ccdecc2,0xac9935bb75fdb59c,0.426,0.452773,295640,0,PASS
+1753015542,surface-world,gcc14-default,1,27,9,27536,0.000000,-140.000000,-2004.562500,0x3557e0f7c1298c35,0x833da36dd2c02e13,0x656f82e69ccdecc2,0xac9935bb75fdb59c,0.161,0.180130,85696,0,PASS
+1753015542,surface-world,gcc14-default,12,27,9,27536,0.000000,-140.000000,-2004.562500,0x3557e0f7c1298c35,0x833da36dd2c02e13,0x656f82e69ccdecc2,0xac9935bb75fdb59c,0.404,0.430695,296144,0,PASS
+1753015542,floating-islands,clang19-off,1,27,13,23050,-25.199219,-75.425781,-125.304688,0xd628ec790fd17bd2,0x5602b3e7ed3f852a,0x844b0f983d0a8dcb,0xdef4bef7bdf60b15,1.084,1.099925,85304,0,PASS
+1753015542,floating-islands,clang19-off,12,27,13,23050,-25.199219,-75.425781,-125.304688,0xd628ec790fd17bd2,0x5602b3e7ed3f852a,0x844b0f983d0a8dcb,0xdef4bef7bdf60b15,0.611,0.636921,299408,0,PASS
+1753015542,floating-islands,clang19-on,1,27,13,23050,-25.199219,-75.425781,-125.304688,0xd628ec790fd17bd2,0x5602b3e7ed3f852a,0x844b0f983d0a8dcb,0xdef4bef7bdf60b15,1.100,1.116086,85256,0,PASS
+1753015542,floating-islands,clang19-on,12,27,13,23050,-25.199219,-75.425781,-125.304688,0xd628ec790fd17bd2,0x5602b3e7ed3f852a,0x844b0f983d0a8dcb,0xdef4bef7bdf60b15,0.615,0.646016,299692,0,PASS
+1753015542,floating-islands,gcc14-default,1,27,13,23050,-25.199219,-75.425781,-125.304688,0xd628ec790fd17bd2,0x5602b3e7ed3f852a,0x844b0f983d0a8dcb,0xdef4bef7bdf60b15,1.222,1.237954,85648,0,PASS
+1753015542,floating-islands,gcc14-default,12,27,13,23050,-25.199219,-75.425781,-125.304688,0xd628ec790fd17bd2,0x5602b3e7ed3f852a,0x844b0f983d0a8dcb,0xdef4bef7bdf60b15,0.638,0.665451,300048,0,PASS
+1827697875,surface-world,clang19-off,1,27,12,29182,0.000000,-140.000000,-2018.507812,0xd945dc9d11f16156,0x59cd0f8103174807,0xbeae510e83e10bb9,0xe561cd4f1b5fc4a0,0.176,0.193003,86328,0,PASS
+1827697875,surface-world,clang19-off,12,27,12,29182,0.000000,-140.000000,-2018.507812,0xd945dc9d11f16156,0x59cd0f8103174807,0xbeae510e83e10bb9,0xe561cd4f1b5fc4a0,0.404,0.432768,301456,0,PASS
+1827697875,surface-world,clang19-on,1,27,12,29182,0.000000,-140.000000,-2018.507812,0xd945dc9d11f16156,0x59cd0f8103174807,0xbeae510e83e10bb9,0xe561cd4f1b5fc4a0,0.168,0.184638,86524,0,PASS
+1827697875,surface-world,clang19-on,12,27,12,29182,0.000000,-140.000000,-2018.507812,0xd945dc9d11f16156,0x59cd0f8103174807,0xbeae510e83e10bb9,0xe561cd4f1b5fc4a0,0.403,0.430151,301156,0,PASS
+1827697875,surface-world,gcc14-default,1,27,12,29182,0.000000,-140.000000,-2018.507812,0xd945dc9d11f16156,0x59cd0f8103174807,0xbeae510e83e10bb9,0xe561cd4f1b5fc4a0,0.171,0.187425,86968,0,PASS
+1827697875,surface-world,gcc14-default,12,27,12,29182,0.000000,-140.000000,-2018.507812,0xd945dc9d11f16156,0x59cd0f8103174807,0xbeae510e83e10bb9,0xe561cd4f1b5fc4a0,0.404,0.431313,301904,0,PASS
+1827697875,floating-islands,clang19-off,1,27,11,34624,0.000000,-19.441406,-116.312500,0x786671c16ae75f4f,0x2c0c94465b7da251,0x6bad3e5799515fde,0x7ff03f198fd07c37,1.637,1.653412,90444,0,PASS
+1827697875,floating-islands,clang19-off,12,27,11,34624,0.000000,-19.441406,-116.312500,0x786671c16ae75f4f,0x2c0c94465b7da251,0x6bad3e5799515fde,0x7ff03f198fd07c37,0.721,0.749622,306368,0,PASS
+1827697875,floating-islands,clang19-on,1,27,11,34624,0.000000,-19.441406,-116.312500,0x786671c16ae75f4f,0x2c0c94465b7da251,0x6bad3e5799515fde,0x7ff03f198fd07c37,1.650,1.665968,90588,0,PASS
+1827697875,floating-islands,clang19-on,12,27,11,34624,0.000000,-19.441406,-116.312500,0x786671c16ae75f4f,0x2c0c94465b7da251,0x6bad3e5799515fde,0x7ff03f198fd07c37,0.694,0.721945,306148,0,PASS
+1827697875,floating-islands,gcc14-default,1,27,11,34624,0.000000,-19.441406,-116.312500,0x786671c16ae75f4f,0x2c0c94465b7da251,0x6bad3e5799515fde,0x7ff03f198fd07c37,2.219,2.236609,90628,0,PASS
+1827697875,floating-islands,gcc14-default,12,27,11,34624,0.000000,-19.441406,-116.312500,0x786671c16ae75f4f,0x2c0c94465b7da251,0x6bad3e5799515fde,0x7ff03f198fd07c37,0.725,0.753570,306580,0,PASS
+1909311298,surface-world,clang19-off,1,27,13,28862,0.000000,-140.000000,-2007.000000,0x79cb6cf093ee2d27,0xa818f8c1904f73b0,0x529738f49021b6e2,0x22bd170f9b244b7c,0.181,0.196690,83948,0,PASS
+1909311298,surface-world,clang19-off,12,27,13,28862,0.000000,-140.000000,-2007.000000,0x79cb6cf093ee2d27,0xa818f8c1904f73b0,0x529738f49021b6e2,0x22bd170f9b244b7c,0.414,0.439403,298828,0,PASS
+1909311298,surface-world,clang19-on,1,27,13,28862,0.000000,-140.000000,-2007.000000,0x79cb6cf093ee2d27,0xa818f8c1904f73b0,0x529738f49021b6e2,0x22bd170f9b244b7c,0.183,0.197951,84020,0,PASS
+1909311298,surface-world,clang19-on,12,27,13,28862,0.000000,-140.000000,-2007.000000,0x79cb6cf093ee2d27,0xa818f8c1904f73b0,0x529738f49021b6e2,0x22bd170f9b244b7c,0.418,0.445146,297192,0,PASS
+1909311298,surface-world,gcc14-default,1,27,13,28862,0.000000,-140.000000,-2007.000000,0x79cb6cf093ee2d27,0xa818f8c1904f73b0,0x529738f49021b6e2,0x22bd170f9b244b7c,0.179,0.194761,84464,0,PASS
+1909311298,surface-world,gcc14-default,12,27,13,28862,0.000000,-140.000000,-2007.000000,0x79cb6cf093ee2d27,0xa818f8c1904f73b0,0x529738f49021b6e2,0x22bd170f9b244b7c,0.414,0.441193,299492,0,PASS
+1909311298,floating-islands,clang19-off,1,27,12,22040,-39.199219,18.164062,-122.738281,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543,0x9b01cc95b7b3358d,0xd049ccb5663e4449,1.229,1.245451,85180,0,PASS
+1909311298,floating-islands,clang19-off,12,27,12,22040,-39.199219,18.164062,-122.738281,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543,0x9b01cc95b7b3358d,0xd049ccb5663e4449,0.658,0.685935,299900,0,PASS
+1909311298,floating-islands,clang19-on,1,27,12,22040,-39.199219,18.164062,-122.738281,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543,0x9b01cc95b7b3358d,0xd049ccb5663e4449,1.261,1.277763,85712,0,PASS
+1909311298,floating-islands,clang19-on,12,27,12,22040,-39.199219,18.164062,-122.738281,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543,0x9b01cc95b7b3358d,0xd049ccb5663e4449,0.650,0.678722,299884,0,PASS
+1909311298,floating-islands,gcc14-default,1,27,12,22040,-39.199219,18.164062,-122.738281,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543,0x9b01cc95b7b3358d,0xd049ccb5663e4449,1.358,1.374066,86140,0,PASS
+1909311298,floating-islands,gcc14-default,12,27,12,22040,-39.199219,18.164062,-122.738281,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543,0x9b01cc95b7b3358d,0xd049ccb5663e4449,0.694,0.722178,300560,0,PASS
+2011898099,surface-world,clang19-off,1,27,9,28654,0.000000,-140.000000,-2005.066406,0x95f389e603d74998,0xff02d8e0b112c865,0xd5d0a255cb1b18be,0x1138243eba6d47a9,0.171,0.187716,86176,0,PASS
+2011898099,surface-world,clang19-off,12,27,9,28654,0.000000,-140.000000,-2005.066406,0x95f389e603d74998,0xff02d8e0b112c865,0xd5d0a255cb1b18be,0x1138243eba6d47a9,0.430,0.457289,296284,0,PASS
+2011898099,surface-world,clang19-on,1,27,9,28654,0.000000,-140.000000,-2005.066406,0x95f389e603d74998,0xff02d8e0b112c865,0xd5d0a255cb1b18be,0x1138243eba6d47a9,0.164,0.180262,85708,0,PASS
+2011898099,surface-world,clang19-on,12,27,9,28654,0.000000,-140.000000,-2005.066406,0x95f389e603d74998,0xff02d8e0b112c865,0xd5d0a255cb1b18be,0x1138243eba6d47a9,0.421,0.448994,296448,0,PASS
+2011898099,surface-world,gcc14-default,1,27,9,28654,0.000000,-140.000000,-2005.066406,0x95f389e603d74998,0xff02d8e0b112c865,0xd5d0a255cb1b18be,0x1138243eba6d47a9,0.162,0.178213,86360,0,PASS
+2011898099,surface-world,gcc14-default,12,27,9,28654,0.000000,-140.000000,-2005.066406,0x95f389e603d74998,0xff02d8e0b112c865,0xd5d0a255cb1b18be,0x1138243eba6d47a9,0.412,0.438827,296832,0,PASS
+2011898099,floating-islands,clang19-off,1,27,9,21292,39.199219,18.968750,-106.898438,0xb3ad433a09a0d127,0xdea39968a98e0861,0x53948649c6b2beee,0x908898f1ffc5bd9b,1.189,1.205816,88312,0,PASS
+2011898099,floating-islands,clang19-off,12,27,9,21292,39.199219,18.968750,-106.898438,0xb3ad433a09a0d127,0xdea39968a98e0861,0x53948649c6b2beee,0x908898f1ffc5bd9b,0.603,0.630257,302380,0,PASS
+2011898099,floating-islands,clang19-on,1,27,9,21292,39.199219,18.968750,-106.898438,0xb3ad433a09a0d127,0xdea39968a98e0861,0x53948649c6b2beee,0x908898f1ffc5bd9b,1.159,1.174149,88360,0,PASS
+2011898099,floating-islands,clang19-on,12,27,9,21292,39.199219,18.968750,-106.898438,0xb3ad433a09a0d127,0xdea39968a98e0861,0x53948649c6b2beee,0x908898f1ffc5bd9b,0.618,0.645079,302396,0,PASS
+2011898099,floating-islands,gcc14-default,1,27,9,21292,39.199219,18.968750,-106.898438,0xb3ad433a09a0d127,0xdea39968a98e0861,0x53948649c6b2beee,0x908898f1ffc5bd9b,1.289,1.305695,88604,0,PASS
+2011898099,floating-islands,gcc14-default,12,27,9,21292,39.199219,18.968750,-106.898438,0xb3ad433a09a0d127,0xdea39968a98e0861,0x53948649c6b2beee,0x908898f1ffc5bd9b,0.656,0.682775,302628,0,PASS
+2015768509,surface-world,clang19-off,1,27,18,51706,0.000000,-140.000000,-1918.304688,0x9506739f358ba5c5,0xaba43fe9407d51fb,0xb75c6eb38dcff774,0x76ccbd695880c541,0.325,0.339879,84052,0,PASS
+2015768509,surface-world,clang19-off,12,27,18,51706,0.000000,-140.000000,-1918.304688,0x9506739f358ba5c5,0xaba43fe9407d51fb,0xb75c6eb38dcff774,0x76ccbd695880c541,0.462,0.488815,300564,0,PASS
+2015768509,surface-world,clang19-on,1,27,18,51706,0.000000,-140.000000,-1918.304688,0x9506739f358ba5c5,0xaba43fe9407d51fb,0xb75c6eb38dcff774,0x76ccbd695880c541,0.327,0.342810,84232,0,PASS
+2015768509,surface-world,clang19-on,12,27,18,51706,0.000000,-140.000000,-1918.304688,0x9506739f358ba5c5,0xaba43fe9407d51fb,0xb75c6eb38dcff774,0x76ccbd695880c541,0.463,0.489510,300696,0,PASS
+2015768509,surface-world,gcc14-default,1,27,18,51706,0.000000,-140.000000,-1918.304688,0x9506739f358ba5c5,0xaba43fe9407d51fb,0xb75c6eb38dcff774,0x76ccbd695880c541,0.316,0.332179,84352,0,PASS
+2015768509,surface-world,gcc14-default,12,27,18,51706,0.000000,-140.000000,-1918.304688,0x9506739f358ba5c5,0xaba43fe9407d51fb,0xb75c6eb38dcff774,0x76ccbd695880c541,0.461,0.488549,301088,0,PASS
+2015768509,floating-islands,clang19-off,1,27,11,29426,39.199219,20.148438,-111.468750,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094,0xc520e4594055d037,0x1f0f86bd23a0ade4,1.597,1.614573,85204,0,PASS
+2015768509,floating-islands,clang19-off,12,27,11,29426,39.199219,20.148438,-111.468750,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094,0xc520e4594055d037,0x1f0f86bd23a0ade4,0.755,0.784367,300176,0,PASS
+2015768509,floating-islands,clang19-on,1,27,11,29426,39.199219,20.148438,-111.468750,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094,0xc520e4594055d037,0x1f0f86bd23a0ade4,1.623,1.646497,85312,0,PASS
+2015768509,floating-islands,clang19-on,12,27,11,29426,39.199219,20.148438,-111.468750,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094,0xc520e4594055d037,0x1f0f86bd23a0ade4,0.734,0.761770,300316,0,PASS
+2015768509,floating-islands,gcc14-default,1,27,11,29426,39.199219,20.148438,-111.468750,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094,0xc520e4594055d037,0x1f0f86bd23a0ade4,1.884,1.901163,85704,0,PASS
+2015768509,floating-islands,gcc14-default,12,27,11,29426,39.199219,20.148438,-111.468750,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094,0xc520e4594055d037,0x1f0f86bd23a0ade4,0.782,0.808616,300972,0,PASS
+2070776516,surface-world,clang19-off,1,27,10,26952,0.000000,-140.000000,-2010.421875,0x28df1e26bab2140f,0x4af65af7af7045c3,0x9832cc0f7fef9416,0xcc5b3fd5040e7c87,0.192,0.206509,84096,0,PASS
+2070776516,surface-world,clang19-off,12,27,10,26952,0.000000,-140.000000,-2010.421875,0x28df1e26bab2140f,0x4af65af7af7045c3,0x9832cc0f7fef9416,0xcc5b3fd5040e7c87,0.437,0.465311,295796,0,PASS
+2070776516,surface-world,clang19-on,1,27,10,26952,0.000000,-140.000000,-2010.421875,0x28df1e26bab2140f,0x4af65af7af7045c3,0x9832cc0f7fef9416,0xcc5b3fd5040e7c87,0.193,0.209540,83692,0,PASS
+2070776516,surface-world,clang19-on,12,27,10,26952,0.000000,-140.000000,-2010.421875,0x28df1e26bab2140f,0x4af65af7af7045c3,0x9832cc0f7fef9416,0xcc5b3fd5040e7c87,0.456,0.482411,295584,0,PASS
+2070776516,surface-world,gcc14-default,1,27,10,26952,0.000000,-140.000000,-2010.421875,0x28df1e26bab2140f,0x4af65af7af7045c3,0x9832cc0f7fef9416,0xcc5b3fd5040e7c87,0.190,0.206251,84608,0,PASS
+2070776516,surface-world,gcc14-default,12,27,10,26952,0.000000,-140.000000,-2010.421875,0x28df1e26bab2140f,0x4af65af7af7045c3,0x9832cc0f7fef9416,0xcc5b3fd5040e7c87,0.453,0.479961,296012,0,PASS
+2070776516,floating-islands,clang19-off,1,27,8,15728,39.199219,16.496094,-110.636719,0x486603470bf1e852,0xaa6022efbc268013,0xd3227a7e0b6e8b9e,0xefb848cb7eb47d5c,1.112,1.128854,86188,0,PASS
+2070776516,floating-islands,clang19-off,12,27,8,15728,39.199219,16.496094,-110.636719,0x486603470bf1e852,0xaa6022efbc268013,0xd3227a7e0b6e8b9e,0xefb848cb7eb47d5c,0.567,0.594910,299448,0,PASS
+2070776516,floating-islands,clang19-on,1,27,8,15728,39.199219,16.496094,-110.636719,0x486603470bf1e852,0xaa6022efbc268013,0xd3227a7e0b6e8b9e,0xefb848cb7eb47d5c,1.115,1.131163,86004,0,PASS
+2070776516,floating-islands,clang19-on,12,27,8,15728,39.199219,16.496094,-110.636719,0x486603470bf1e852,0xaa6022efbc268013,0xd3227a7e0b6e8b9e,0xefb848cb7eb47d5c,0.613,0.639860,299736,0,PASS
+2070776516,floating-islands,gcc14-default,1,27,8,15728,39.199219,16.496094,-110.636719,0x486603470bf1e852,0xaa6022efbc268013,0xd3227a7e0b6e8b9e,0xefb848cb7eb47d5c,1.167,1.183633,86500,0,PASS
+2070776516,floating-islands,gcc14-default,12,27,8,15728,39.199219,16.496094,-110.636719,0x486603470bf1e852,0xaa6022efbc268013,0xd3227a7e0b6e8b9e,0xefb848cb7eb47d5c,0.637,0.663327,300240,0,PASS

Standalone/Research/WorldAssemblerM3/Linux3/seed_mesh_coverage_per_seed.csv

@@ -0,0 +1,97 @@
+seed,recipe,camera_x_vox,camera_y_vox,camera_z_vox,nonempty_mesh_tiles,indexed_triangles,density_hash,mesh_hash
+-1990830953,floating-islands,-39.199219,16.363281,-121.039062,12,23386,0xc04ef8acd44d8736,0x00e92c97d841dfe5
+-1900684165,floating-islands,39.199219,17.675781,-116.339844,10,23186,0xfc7386c15431e2e1,0x46ce25dfb3745f53
+-1766412538,floating-islands,-25.199219,-73.816406,-135.394531,12,23618,0xdb6557b98f29060e,0x3b3147a1d020ca02
+-1721984596,floating-islands,64.398438,74.085938,-128.433594,10,23728,0xbb7777932cd3328a,0x5d7243f5afb8902a
+-1239598758,floating-islands,39.199219,19.425781,-116.691406,12,28162,0x9ee03f2326224bbc,0x0ea03da61381b41a
+-1085993262,floating-islands,-39.199219,16.968750,-116.531250,11,25186,0x8dec867557d4e27c,0x13de3a8f9465573d
+-1033703345,floating-islands,-25.199219,-75.605469,-128.097656,10,17406,0x6edfcf6b89aee9cd,0xc7b92cd1b8a58590
+-854671705,floating-islands,0.000000,-19.800781,-116.507812,13,39000,0xbb5718ca3ad4c181,0x3250d2591365d443
+-713963806,floating-islands,64.398438,74.308594,-120.453125,8,16002,0xd590c16395cc515f,0x3a62d63b76bdd260
+-621039221,floating-islands,0.000000,-18.796875,-116.769531,15,46224,0x8bf4ceae8c1ddbf6,0x61557967c37529fe
+-474448608,floating-islands,-39.199219,20.921875,-121.671875,12,26122,0x2a634b2a3d2e38ef,0x52d2036bf1406614
+-432690581,floating-islands,-39.199219,16.421875,-114.292969,7,20532,0xd8b65942bf1c005c,0xe6557b8cadfb3356
+-380556572,floating-islands,39.199219,17.386719,-117.285156,10,25334,0x118f50002e1af1b1,0x57d82fed86d7545c
+-238925630,floating-islands,-39.199219,16.394531,-123.812500,10,20680,0x36a07bf8d4383533,0x12f59de7f06e5270
+-216679974,floating-islands,39.199219,20.230469,-108.953125,9,25284,0x79bb86763243b67e,0x7fd748d3021d506d
+-133096164,floating-islands,-39.199219,16.050781,-118.000000,11,26248,0xad7be7cd6b0dbffc,0x06d2caf87f019f22
+-112366806,floating-islands,39.199219,16.867188,-114.605469,9,21148,0xda065c33dc944d23,0x3c27d1ee8688fec9
+0,floating-islands,-25.199219,-76.226562,-105.089844,9,20740,0x7fd1e3389642e6f6,0x577e52a5ba8d96be
+5808593,floating-islands,39.199219,16.003906,-114.574219,10,21000,0xb96bffb27bc457e0,0x1f867a2add682123
+28573228,floating-islands,0.000000,-18.683594,-116.187500,12,32456,0x25ed5f499f9bf7ab,0x1c8e67c20374b473
+70955227,floating-islands,-39.199219,18.582031,-121.785156,12,17426,0xbe4b9c0ebadde344,0xa9a52cc49ade0f23
+75274690,floating-islands,64.398438,72.199219,-121.019531,8,19760,0x045c98172a573800,0x86618a983d61425d
+81375760,floating-islands,-39.199219,20.589844,-119.359375,12,24146,0x69b66261833e4676,0x75e6b0f427e7698a
+146979566,floating-islands,39.199219,16.625000,-109.785156,9,22370,0x93d0d67042bb05d2,0xe7f4981f907e316e
+244951180,floating-islands,0.000000,-18.179688,-116.664062,13,32272,0x0b22965681c5b482,0x582ef8c1d263bedb
+245433414,floating-islands,0.000000,-17.574219,-116.296875,11,32838,0x2e75a175d1005e4e,0x8f45449d7125c041
+277442974,floating-islands,39.199219,19.328125,-117.750000,13,28088,0x8cb55c56b1629d42,0xc6532d9d3b8a987d
+297746112,floating-islands,39.199219,20.609375,-119.089844,15,29396,0x2425273f1a174c04,0x204be5cda8d98412
+336768467,floating-islands,0.000000,-20.933594,-116.355469,12,33652,0xfa8249483c186760,0xc42acd7c93e1525c
+512532080,floating-islands,0.000000,-20.355469,-116.640625,14,34900,0xb098abe6a38cfe3a,0x436a6541192ed00e
+821120640,floating-islands,39.199219,18.121094,-108.417969,11,27034,0x3db9226404527944,0xb3328f1c88e96c70
+853538490,floating-islands,64.398438,75.593750,-125.132812,12,21100,0x7e568fc03c907914,0x6a9fc36512216056
+861026696,floating-islands,-39.199219,16.035156,-124.882812,12,20194,0xcb6792ec32335dc5,0x195efb6c80156e4a
+1026251636,floating-islands,-25.199219,-74.664062,-109.117188,8,19958,0xe62d0a684fcd1398,0xca0e1740a58cafbd
+1077415394,floating-islands,39.199219,20.472656,-109.757812,9,25992,0x76ffc67a9d410089,0x712f9bef468c36e1
+1130999017,floating-islands,-39.199219,19.199219,-119.304688,14,25686,0x9fc0c1b33da03fc0,0xc0dafe8b2a4570f1
+1156488597,floating-islands,-39.199219,16.464844,-121.550781,14,22928,0x080c04f591e988da,0x7d2e52b446efd9d1
+1172304228,floating-islands,-39.199219,16.859375,-120.363281,12,25280,0xa4ceaef6289c2778,0xac854a5846adc6cb
+1370340570,floating-islands,-39.199219,17.164062,-114.296875,8,20458,0xfe631978312f065a,0xc41cdcb438a98b86
+1383925073,floating-islands,64.398438,76.132812,-101.687500,8,17340,0x20a6d43f24557065,0xace78f99c63a90bc
+1401164998,floating-islands,-25.199219,-76.433594,-133.500000,12,25478,0xa22b8a0f16d1cb98,0x85e184e7768795d1
+1558879574,floating-islands,0.000000,-15.878906,-116.753906,15,37078,0x675134538e8ca09b,0x2e32a5444b8be6d7
+1753015542,floating-islands,-25.199219,-75.425781,-125.304688,13,23050,0xd628ec790fd17bd2,0x5602b3e7ed3f852a
+1827697875,floating-islands,0.000000,-19.441406,-116.312500,11,34624,0x786671c16ae75f4f,0x2c0c94465b7da251
+1909311298,floating-islands,-39.199219,18.164062,-122.738281,12,22040,0x7bdc9a6cccc15b70,0x14e5e1428a1a5543
+2011898099,floating-islands,39.199219,18.968750,-106.898438,9,21292,0xb3ad433a09a0d127,0xdea39968a98e0861
+2015768509,floating-islands,39.199219,20.148438,-111.468750,11,29426,0x92d4f0690eaa02fd,0x5cea2b8d8ae9a094
+2070776516,floating-islands,39.199219,16.496094,-110.636719,8,15728,0x486603470bf1e852,0xaa6022efbc268013
+-1990830953,surface-world,0.000000,-140.000000,-2021.785156,9,26366,0x125d085ff63ece8a,0x3f219420ffe76ceb
+-1900684165,surface-world,0.000000,-140.000000,-2011.214844,10,27890,0xcc9819b02bd2f880,0x8cbe19f740d2b408
+-1766412538,surface-world,0.000000,-140.000000,-2004.851562,9,27572,0x4d04ec633754c4ec,0xca8833dcfe9639d3
+-1721984596,surface-world,0.000000,-140.000000,-2006.878906,9,27374,0x65b6ae0a3a1fdd35,0x117d40e403c960bc
+-1239598758,surface-world,0.000000,-140.000000,-2001.816406,15,38978,0x8aaf7c7c610e550f,0xeaa948233176c456
+-1085993262,surface-world,0.000000,-140.000000,-2018.355469,13,30779,0x6dd63983ab04ee63,0x606e6964e1b2bfa0
+-1033703345,surface-world,0.000000,-140.000000,-1585.519531,16,50890,0xe2f8c4b421a9402a,0x730fd7c4692eaff3
+-854671705,surface-world,0.000000,-140.000000,-2018.242188,10,26198,0x0a9e017447ffff3d,0x807299923966d5be
+-713963806,surface-world,0.000000,-140.000000,-2018.582031,16,30292,0x0bdd79cefc1c4003,0x9807c528ec8ea0e6
+-621039221,surface-world,0.000000,-140.000000,-2015.613281,17,30168,0xa27c25107de22a4d,0xde2ffe789eb7fb05
+-474448608,surface-world,0.000000,-140.000000,-2020.160156,11,28424,0x0d40ad842a0123ea,0x273fb800c1246cac
+-432690581,surface-world,0.000000,-140.000000,-1699.710938,16,44640,0x3a23c958501ee719,0x45e154a2ee8b0f36
+-380556572,surface-world,0.000000,-140.000000,-2015.980469,15,27832,0x54c47dd125294a9d,0x6e95e2a4fb185b89
+-238925630,surface-world,0.000000,-140.000000,-2021.289062,9,26908,0x01debb25b2642a4d,0xd316a4d6bbbdceee
+-216679974,surface-world,0.000000,-140.000000,-2025.835938,9,26538,0x04339f7c537f8920,0xb6d8dab4a5cd82ca
+-133096164,surface-world,0.000000,-140.000000,-2023.140625,9,26182,0x1dadb5c6440181c0,0x4681d673371781ba
+-112366806,surface-world,0.000000,-140.000000,-1699.476562,16,46567,0x7aafaa55fce58f77,0x84c7d73393ccdb09
+0,surface-world,0.000000,-140.000000,-2003.089844,9,27910,0x2339a02328c5ffa6,0x83d31e15bf9161b0
+5808593,surface-world,0.000000,-140.000000,-2014.406250,14,29050,0x355972d90ab29593,0x563daf944391ab7c
+28573228,surface-world,0.000000,-140.000000,-2016.695312,13,27054,0x57cb2fe09976dc54,0x35ac4f38b432e8b7
+70955227,surface-world,0.000000,-140.000000,-2047.484375,13,29926,0xb205ad43941e41d8,0x722e775c7e0735bc
+75274690,surface-world,0.000000,-140.000000,-2019.648438,15,28342,0x84af4380d33164a6,0xa18d6de0f9267e9f
+81375760,surface-world,0.000000,-140.000000,-1894.296875,18,48305,0x20c34733457b090d,0x9a6b57b63637db1f
+146979566,surface-world,0.000000,-140.000000,-2014.601562,14,31096,0x2d27daeb8c1c8b7c,0x2218ed732f71ca53
+244951180,surface-world,0.000000,-140.000000,-1798.816406,18,52468,0xfb0ba5f3b28b306d,0x2d5f650a41b8b2bd
+245433414,surface-world,0.000000,-140.000000,-2022.468750,14,32860,0xcc51a567f61f812d,0xc59dc3105dd493b2
+277442974,surface-world,0.000000,-140.000000,-2004.875000,9,27060,0x8bfa82ca5e492c37,0x1630487dbcc54469
+297746112,surface-world,0.000000,-140.000000,-2010.195312,13,38252,0x00c869b6875b7ef5,0x085684513feca8f2
+336768467,surface-world,0.000000,-140.000000,-2014.343750,15,29748,0x2756e6dc388ddf57,0x66344082236c5630
+512532080,surface-world,0.000000,-140.000000,-2011.875000,14,28800,0xa5ad29a27d991d10,0x060bc1fca8569368
+821120640,surface-world,0.000000,-140.000000,-2017.054688,17,29100,0xb6424f19c272b61c,0xe4f7308d87cb3bc2
+853538490,surface-world,0.000000,-140.000000,-2000.957031,13,41529,0xbe1224f297dc7ad0,0x7e10918947195940
+861026696,surface-world,0.000000,-140.000000,-2015.378906,14,29214,0xb04a05c6e8c488dc,0x28706d092bd82c9a
+1026251636,surface-world,0.000000,-140.000000,-2001.500000,9,28584,0xf6bb5ab0a9e2307d,0x4767f425e56543f4
+1077415394,surface-world,0.000000,-140.000000,-2018.636719,12,27666,0xb65f4acca21a93d8,0x0a3cddad02604438
+1130999017,surface-world,0.000000,-140.000000,-1885.390625,15,38852,0xd4fee006d89064ec,0xc2e722815c510b8d
+1156488597,surface-world,0.000000,-140.000000,-2012.031250,10,26660,0xf918cd1d254bf5ad,0x93e291c7e8ab3281
+1172304228,surface-world,0.000000,-140.000000,-2030.214844,9,28078,0x466d74beb6a3c43f,0x935c08e020dbe116
+1370340570,surface-world,0.000000,-140.000000,-2026.738281,9,26888,0xb71aa861999e9064,0x5e6eb187fe7aa3d1
+1383925073,surface-world,0.000000,-140.000000,-2018.113281,13,27826,0x564bb6a29953fc31,0x891c57b01dc509f8
+1401164998,surface-world,0.000000,-140.000000,-1923.625000,14,33671,0x539b7c44ed2d40c4,0x2daa8cf5e08fb16e
+1558879574,surface-world,0.000000,-140.000000,-2026.257812,12,30022,0x566bd8e41e9ce9de,0xd7344edfeac99334
+1753015542,surface-world,0.000000,-140.000000,-2004.562500,9,27536,0x3557e0f7c1298c35,0x833da36dd2c02e13
+1827697875,surface-world,0.000000,-140.000000,-2018.507812,12,29182,0xd945dc9d11f16156,0x59cd0f8103174807
+1909311298,surface-world,0.000000,-140.000000,-2007.000000,13,28862,0x79cb6cf093ee2d27,0xa818f8c1904f73b0
+2011898099,surface-world,0.000000,-140.000000,-2005.066406,9,28654,0x95f389e603d74998,0xff02d8e0b112c865
+2015768509,surface-world,0.000000,-140.000000,-1918.304688,18,51706,0x9506739f358ba5c5,0xaba43fe9407d51fb
+2070776516,surface-world,0.000000,-140.000000,-2010.421875,10,26952,0x28df1e26bab2140f,0x4af65af7af7045c3

Standalone/Research/WorldAssemblerM3/Linux3/seed_mesh_coverage_summary.txt

@@ -0,0 +1 @@
+runs=576 seeds=48 recipes=2 builds=3 workers=1,12 cross_build_checks=192 cross_build_mismatches=0 worker_checks=288 worker_mismatches=0 empty_mesh_rows=0 max_peak_rss_kib=306580 elapsed_s=432.977

Standalone/Research/WorldAssemblerM3/Linux4/REPORT.md

@@ -0,0 +1,114 @@
+# WorldAssemblerM3 Linux4 — lazy worker caches
+
+## Change
+
+Added `VoxelForgeCoreThreadLocal::FLazy<T>`: each cache now has a thread-local pointer, allocates its private table on first use, and deletes it when that thread exits. The same helper is used by the namespaced Core and legacy source copies. No cache locks or cross-thread cache sharing were added. The L3 FP-contract preamble and self-test are unchanged.
+
+The change covers the heightfield and island caches in Core, plus the large surface, relief, room-graph, tunnel-density, and diff caches in the shared generator sources. Tunnel-density lookup is now restricted to its `TunnelNetwork` and `Underwater` routes, which are the only routes that populate that table. The standalone TLS probe reports spawn time, RSS and per-thread minor faults, and can touch synthetic SurfaceWorld or FloatingIslands samples. Worker stacks are now 8 MiB.
+
+## Where the baseline TLS came from
+
+Sizes are from the S14 / `046f2af` Clang binary's TLS symbols. The two raw and namespaced source copies are both linked into the standalone executable; both occupy TLS even though a Core call uses the namespaced copy and the legacy/reference route uses the raw copy. The raw legacy cache is not used by the Core API route. `Standalone/Core/core_sources.txt` describes this dual build.
+
+| Cache | Section | Bytes per copy | Copies | Total bytes | Route / use |
+|---|---:|---:|---:|---:|---|
+| `HeightfieldColumnCache` | `.tbss` | 6,815,744 | 1 | 6,815,744 | Core SurfaceWorld height samples; S14 hot path, any LOD that queries the heightfield |
+| `GFloorReliefCache` | `.tdata` | 1,310,720 | 2 | 2,621,440 | Cave room/tunnel/landing floor-relief queries |
+| `GRoomGraphCache` | `.tdata` | 970,752 | 2 | 1,941,504 | Room-graph SDF windows; fine/coarse region banks |
+| `GSurfColCache` | `.tbss` | 827,000 | 2 | 1,654,000 | `ClassifyTile` surface-column pass; classifier is opt-in in runtime streaming |
+| `FSurfaceColumnSource` column table | `.tbss` | 826,856 | 2 | 1,653,712 | Surface operator-stack integer XY columns |
+| `PassageReliefCache` | `.tdata` | 655,360 | 2 | 1,310,720 | Passage-relief samples when that feature is queried |
+| `IslandColumnCache` | `.tbss` | 1,114,112 | 1 | 1,114,112 | Core FloatingIslands column density, all LOD sample paths |
+| `CP_TunnelDensityCache` | `.tbss` | 401,408 | 2 | 802,816 | Native TunnelNetwork/Underwater density chunks |
+| `RootLobeCache` | `.tdata` | 155,648 | 1 | 155,648 | Core FloatingIslands root density |
+| `HeightfieldColumnCacheNextWay` | `.tbss` | 16,384 | 1 | 16,384 | Heightfield cache replacement metadata |
+| `DiffSlots` | `.tdata` | 10,752 | 2 | 21,504 | Only when a sampled chunk has player modifications |
+| `RoomGraphCacheSlots` | `.tdata` | 10,240 | 2 | 20,480 | Room-graph generator route |
+
+The listed `.tdata` cache symbols total 6,071,296 bytes of the 6,093,024-byte image; the remaining 21,728 bytes are small TLS state. Their nonzero defaults explain the initialized image: for example, room-graph keys start at `INT32_MIN` / `0xFFFFFFFF`, passage and floor-relief keys use `INDEX_NONE`, diff slots use `INT32_MAX` chunk coordinates, and root-lobe radii default to `1.0`. Zero-default large arrays such as the heightfield and island column tables account for the listed `.tbss` bytes. The listed `.tbss` symbols total 12,056,768 bytes; 21,997 bytes remain for small TLS state and alignment.
+
+The caches have no universal per-LOD allocation: a thread allocates a table only if it reaches that route. Heightfield and island tables are keyed by recipe/plan or island identity and sampled coordinates; surface columns can be reused by repeated XY queries. Room-graph and classifier paths carry region/tile data in their keys, so coarse and fine requests can occupy distinct entries. Relief, tunnel and diff caches are likewise conditional on those features or modified chunks. All preserve the existing thread-local ownership and eviction behavior.
+
+## TLS and per-thread cost
+
+`PT_TLS` was read with `readelf -lW`. The baseline is the committed `046f2af` build; the after builds use this tree.
+
+| Build | `PT_TLS` FileSiz (initialized) | `PT_TLS` MemSiz (per-thread block) |
+|---|---:|---:|
+| Clang 19 before | 6,093,024 B (5.81 MiB) | 18,171,789 B (17.33 MiB) |
+| Clang 19 after | 21,728 B (21.2 KiB) | 43,977 B (42.95 KiB) |
+| GCC 14 before | 6,060,396 B (5.78 MiB) | 18,172,504 B (17.33 MiB) |
+| GCC 14 after | 9,580 B (9.36 KiB) | 44,696 B (43.65 KiB) |
+
+Serial 12-worker no-touch, SurfaceWorld, and FloatingIslands probes compared baseline and L4. Spawn timing and resident delta use 32 MiB stacks on both sides to isolate TLS cost; the separately tested L4 tool uses 8 MiB stacks. Spawn medians/ranges use the per-worker samples; first-touch fault medians/ranges use each worker's `getrusage(RUSAGE_THREAD)` delta.
+
+| Measurement | Before | After |
+|---|---:|---:|
+| Median time to start one worker | 5.175 ms | 0.119 ms |
+| Median RSS added per new worker, no cache query | 17,756 KiB | 52 KiB |
+| 12-worker no-touch probe peak RSS | 268,168 KiB | 32,328 KiB |
+| First SurfaceWorld use: RSS increase per worker | 20 KiB | 6,691 KiB |
+| First SurfaceWorld use: minor faults per worker | median 1 (range 1–4) | median 331 (range 8–649) |
+| First FloatingIslands use: RSS increase per worker | 27–30 KiB | 1,283 KiB |
+| First FloatingIslands use: minor faults per worker | median 0 (range 0–7) | median 314 (range 313–319) |
+
+The baseline's first-use deltas are small because its large static TLS cost was already incurred at worker creation. After L4, a SurfaceWorld first use adds about 6.54 MiB per worker, while a FloatingIslands first use adds about 1.25 MiB. The no-touch worker increase is about 99.7% lower. These first-use probes call Core directly with four synthetic samples per worker; the full-view benchmark below measures the hot generation path.
+
+The baseline binary's first `pthread_create` with an 8 MiB worker stack fails with `pthread_create: Invalid argument`; the 17.33 MiB static TLS block cannot fit that stack configuration. Baseline probes succeeded with 32 MiB stacks. L4 passed the 8 MiB worker-stack probe and the L1 checks, so the 32 MiB wrapper is no longer needed. Keep the normal 8 MiB worker stack; these runs provide no reason to retain 32 MiB as a safety margin.
+
+## Generation speed and output
+
+Three interleaved W12 whole-view runs per binary used the 2,553-tile L1 view. `Before` is the exact `046f2af` Clang-off executable.
+
+| Build | Whole-view times | Median (range) |
+|---|---|---:|
+| `046f2af` baseline | 2.347, 2.399, 2.432 s | 2.399 s (2.347–2.432) |
+| L4 Clang 19 off | 2.139, 2.197, 2.207 s | 2.197 s (2.139–2.207) |
+
+L4 is 0.202 s (8.4%) faster at the median; no generation-speed regression was measured. The speed runs also changed the worker stack from 32 to 8 MiB, so the timing difference is not attributed solely to the cache indirection. Peak process RSS was 550,856 KiB before and 410,052 KiB after.
+
+The L1 hashes match at W1 and W12 for both requested compiler settings:
+
+| Build | Density / mesh / payload / topology |
+|---|---|
+| Clang 19 off, W1 and W12 | `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724` |
+| GCC 14 default, W1 and W12 | same |
+
+FloatingIslands seed 0 also matches at W1 and W12: `7fd1e3389642e6f6 / 577e52a5ba8d96be / 7c6ffe9f5bbbb450 / b4d308de116f4657` (density / mesh / payload / topology). It covers 27 tiles, with 9 nonempty mesh tiles and 20,740 indexed triangles; the existing L3 seed-0 hashes match.
+
+## Unreal Linux TLS: documented and inferred
+
+**Documented by glibc:** Its dynamic-linker guidance describes the `dlopen`/TLS compatibility issue and recommends global-dynamic TLS for general shared-object use. In glibc's current `dl-tls.c`, DTV slots for dynamically loaded TLS modules are marked for deferred allocation; `tls_get_addr_tail` performs the allocation when that thread first resolves the TLS address. The new-thread path calls `_dl_allocate_tls_init`, which also records deferred allocation for dynamically loaded modules. Thus, for the dynamic path, the large module block is allocated on first access, per thread that touches the module; a thread that never accesses it does not get that module's payload block. [glibc dynamic-linker guidance](https://www.sourceware.org/glibc/manual/latest/html_node/Dynamic-Linker-Hardening.html), [glibc TLS implementation](https://codebrowser.dev/glibc/glibc/elf/dl-tls.c.html#L599), [glibc thread creation path](https://codebrowser.dev/glibc/glibc/nptl/allocatestack.c.html#L141).
+
+**Inference for Unreal:** This machine did not build or inspect the owner's UE `.so`, so the Core module's TLS model and load timing are unverified. GCC documents global-dynamic as the default model with `-fPIC`, but compiler/linker relaxation and UBT's exact flags can change the emitted access sequence. If Unreal loads Core after engine threads exist and the module uses general-dynamic TLS, any engine thread that first accesses a Core TLS symbol can incur the module's whole static TLS block once; it is not limited to generation workers. The L4 pointer handles reduce that block to about 43 KiB, with each large cache allocated only when its own route runs. Verify the actual `.so` `PT_TLS`, TLS relocations, and UBT compile commands on the owner's Linux build; `LD_DEBUG=tls` can show loader TLS activity. [GCC TLS model options](https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options).
+
+## Windows/MSVC to-do
+
+1. Build the updated standalone: `powershell -ExecutionPolicy Bypass -File Standalone\Build.ps1 -Target All -CompileWorkers 12`. Confirm the Core response file still carries `/fp:precise` and the shared header is included.
+2. Run the L1 view at W1 and W12 with `--world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0`. Require the four L1 hashes above and no self-test error.
+3. Run the seed-0 FloatingIslands check at W1 and W12 with mesh coverage enabled; require matching density/mesh/payload/topology hashes and nonempty mesh coverage.
+4. Build the owner's UE 5.7 Windows target with the plugin, inspect the actual `cl.exe` options, and exercise worker creation/use/shutdown. MSVC-specific risks are `/fp:precise` versus any `/fp:fast` or `/fp:contract` override, `thread_local` destructor handling on engine task threads, and allocator/container construction and destruction when a thread first touches or exits a cache. Linux ELF sizes do not predict Windows TLS costs.
+
+## Machine and run record
+
+Builds and benchmarks used CPUs 0–11, at most 12 build jobs, a 6 GiB address-space limit, and normal priority. Governor remained `powersave`; EPP remained `balance_performance`. Clang build: 29.06 s, peak RSS 431,732 KiB. GCC build: 46.14 s, peak RSS 896,076 KiB. Largest benchmark RSS was 550,856 KiB. Logs are in `Saved/Linux/linux4-*.log`; artifacts are under `Standalone/Build/linux-*` and `Standalone/bin/linux/`.
+
+Failed or retried runs:
+
+- The first baseline probes with an 8 MiB worker stack failed for `none`, `surface-world`, and `floating-islands` (`pthread_create: Invalid argument`, exit `-6`, three attempts each). They were rerun serially at 32 MiB and passed. L4 passed all three probes at 8 MiB.
+- An early before/after probe batch ran the six probe types concurrently, so its timings and RSS were discarded. Each type was rerun serially; the final before/after comparison uses those serial logs. The discarded logs are retained with `linux4-discarded-parallel-` names.
+- No build or world/hash run failed. Both Clang and GCC final builds succeeded.
+
+## Note for the owner
+
+The shared cache change reduces standalone static TLS from 17.33 MiB to about 43 KiB and preserves the L1 and FloatingIslands hashes; the W12 median moved from 2.399 s to 2.197 s. Please run the listed standalone and Unreal checks on Windows/MSVC before merging, especially worker-thread TLS destruction and the actual UBT FP/TLS options.
+
+## Orchestrator review (Claude)
+
+- Re-run by me: interleaved W12, L1 view: `046f2af` (L3) 2.212/2.256/2.307 s vs L4 2.063/2.091/2.125 s
+  (medians 2.256 → 2.091 s, -7%). Density `c10697a8f48380c7` throughout. L4 `PT_TLS` MemSiz 0xabc9 = 43,977 B.
+- Checked the tunnel-cache route gate in `VoxelGenerator.cpp`: entries are only *stored* when `CP_GenType`
+  is TunnelNetwork/Underwater, so for any other route the old lookup could only miss. Gating skips
+  guaranteed misses, so no output change is possible. The legacy cave route is not exercised by the
+  headless tool, so this rests on code reading, not a hash.
+- Windows: `thread_local` destructors on UE task threads are the MSVC risk. Luna's to-do list covers it.

Standalone/Research/WorldAssemblerM3/Linux4/TlsProbeMain.cpp

@@ -0,0 +1,11 @@
+#include "StandaloneTlsProbe.h"
+
+#include <cstdlib>
+#include <string_view>
+
+int main(int argc,char** argv)
+{
+    const int workers=argc>1?std::atoi(argv[1]):12;
+    const std::string_view touch=argc>2?argv[2]:"none";
+    return StandaloneTlsProbe::Run(workers,touch);
+}

Standalone/Research/WorldAssemblerM3/Linux5/MeasureProcess.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+import os
+import signal
+import subprocess
+import sys
+import time
+
+if len(sys.argv) < 4 or sys.argv[2] != "--":
+    raise SystemExit("usage: MeasureProcess.py LOG -- COMMAND [ARGS...]")
+
+log_path = sys.argv[1]
+command = sys.argv[3:]
+os.makedirs(os.path.dirname(log_path) or ".", exist_ok=True)
+start = time.monotonic()
+with open(log_path, "wb") as log_file:
+    process = subprocess.Popen(command, stdout=log_file, stderr=subprocess.STDOUT,
+                               start_new_session=True)
+    max_hwm_kib = 0
+    max_rss_kib = 0
+    max_pid = process.pid
+    max_name = ""
+    deadline = start + 1800.0
+    while process.poll() is None:
+        if time.monotonic() >= deadline:
+            os.killpg(process.pid, signal.SIGTERM)
+            try:
+                process.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                os.killpg(process.pid, signal.SIGKILL)
+                process.wait()
+            print("MONITOR_TIMEOUT_SECONDS=1800", file=log_file, flush=True)
+            break
+        stat_by_pid = {}
+        for entry in os.scandir("/proc"):
+            if not entry.name.isdigit():
+                continue
+            pid = int(entry.name)
+            try:
+                with open(f"/proc/{pid}/stat", "r", encoding="ascii") as stat_file:
+                    fields = stat_file.read().rsplit(")", 1)[1].split()
+                ppid = int(fields[1])
+                stat_by_pid[pid] = ppid
+            except (OSError, ValueError, IndexError):
+                continue
+        descendants = {process.pid}
+        changed = True
+        while changed:
+            changed = False
+            for pid, ppid in stat_by_pid.items():
+                if ppid in descendants and pid not in descendants:
+                    descendants.add(pid)
+                    changed = True
+        for pid in descendants:
+            try:
+                with open(f"/proc/{pid}/status", "r", encoding="ascii") as status_file:
+                    status = status_file.read().splitlines()
+                values = {line.split(":", 1)[0]: line.split(":", 1)[1].strip()
+                          for line in status if ":" in line}
+                hwm = int(values.get("VmHWM", "0 kB").split()[0])
+                rss = int(values.get("VmRSS", "0 kB").split()[0])
+                name = values.get("Name", "")
+            except (OSError, ValueError, IndexError):
+                continue
+            if hwm > max_hwm_kib:
+                max_hwm_kib, max_pid, max_name = hwm, pid, name
+            max_rss_kib = max(max_rss_kib, rss)
+        time.sleep(0.05)
+    result = process.wait()
+    elapsed = time.monotonic() - start
+    for line in (
+        f"MONITOR_EXIT_CODE={result}",
+        f"MONITOR_WALL_SECONDS={elapsed:.3f}",
+        f"MONITOR_PEAK_PROCESS_HWM_KIB={max_hwm_kib}",
+        f"MONITOR_PEAK_PROCESS_PID={max_pid}",
+        f"MONITOR_PEAK_PROCESS_NAME={max_name}",
+        f"MONITOR_MAX_SAMPLED_PROCESS_RSS_KIB={max_rss_kib}",
+    ):
+        log_file.write((line + "\n").encode("utf-8"))
+raise SystemExit(result)
+

Standalone/Research/WorldAssemblerM3/Linux5/REPORT.md

@@ -0,0 +1,165 @@
+# World Assembler M3 — Linux L5
+
+**Result:** no octave tail is safely removable under the declared bounds. The exact far meshes already exceed the 1 px field-error and LOD-swap budgets, and the cutoff flag is 2.2% slower in the W12 view. The candidate therefore generated the exact same meshes; recipe version stays 1.
+
+## Build and machine
+
+Built `VoxelForgeCoreHeadless-linux5-l5-final7` and its capture target on `assembler/world` at `7770074` with Clang 19 `-ffp-contract=off`, then GCC 14 default contraction, both with 12 jobs. W1/W12 hashes match across both compilers; the L3 FP-contract preamble and runtime self-test remain active. Runs used CPUs 0–11, normal priority, and the 6 GiB process limit. Maximum process HWM was 898,692 KiB (GCC compile); the largest runtime process was 454,828 KiB. CPU governor stayed `powersave`. `/dev/dri/renderD128` was absent, so EGL used Mesa llvmpipe with `LP_NUM_THREADS=12`. No packages or system settings were changed.
+
+## Capture and gate
+
+`LinuxOffscreenCapture.cpp` reads the `.vfmesh` export from the headless streaming pipeline, creates a surfaceless EGL/GLES3 pbuffer, and writes 2560×1440 PNGs with libpng. `ffmpeg` made 1280×720 review JPEGs; the largest is 73,923 bytes. The shader combines surface normals and 80 m height bands. Only the small JPEGs were opened for review.
+
+The gate samples a 65×65 XY grid on the closest native-surface tile at each LOD, excluding skirts. It reports two comparisons: displayed mesh against exact `Heightfield2D` ground/cap roots, and against a regenerated exact same-LOD mesh. The second is the zero-delta regression control; the first measures the actual field error. Swap error compares the coarse tile with its fine children at those same field roots. Full missing-surface, 2 m floating-surface, and missing fine-ring injections were rejected at every LOD3–8; so were both S13 controls.
+
+This is a sampled heightfield gate, not a full camera-ray rasterizer. It can miss cracks narrower than one grid cell (1 m at LOD3, growing to 32 m at LOD8), and its direct-field row does not model tunnel walls or other non-heightfield faces. The same-LOD mesh comparison covers extra and missing mesh intersections at sampled points; a denser or full-screen geometry pass would be needed to certify sub-cell cracks and non-heightfield surfaces.
+
+## Closest display distances and budgets
+
+The code sweeps clipmap desired sets across X-boundary phases and measures tile AABB distance. The result matches the clipmap ring formula `3 × 32 chunks × 2^(LOD−1) × 0.25 m`; LOD0 is the player tile. The pixel angle is `90° / 2560 = 0.000613592 rad`.
+
+| LOD | Closest display distance | 1 px at that distance | Active rule |
+|---:|---:|---:|---:|
+| 0 | 0 m | 0 cm | exact, 2 cm |
+| 1 | 24.001 m | 1.473 cm | exact, 2 cm |
+| 2 | 48.001 m | 2.945 cm | exact, 2 cm |
+| 3 | 96.001 m | 5.891 cm | 1 px |
+| 4 | 192.001 m | 11.781 cm | 1 px |
+| 5 | 384.001 m | 23.562 cm | 1 px |
+| 6 | 768.001 m | 47.124 cm | 1 px |
+| 7 | 1,536.001 m | 94.248 cm | 1 px |
+| 8 | 3,072.001 m | 188.496 cm | 1 px |
+
+## Exact-field error and swap pop
+
+Baseline and cutoff values are identical. The exact same-LOD regression control is 0.0000 px p50/p99/max at all LOD3–8, with no missing or floating samples. Against the continuous `Heightfield2D` roots, however, the current exact meshes already exceed 1 px at every LOD. The owner’s expected near-zero control holds for exact-versus-exact mesh output, not for the true-field comparison.
+
+| LOD | Exact field p50 / p99 / max px (baseline → cutoff) | Swap p50 / p99 / max px | Swap cracks / floating |
+|---:|---:|---:|---:|
+| 3 → 2 | 0.9035 / 4.5839 / 7.3277 → same | 0.6714 / 4.1861 / 7.3277 | 0 / 0 |
+| 4 → 3 | 1.1170 / 5.6056 / 8.3307 → same | 0.8269 / 5.1958 / 8.2105 | 0 / 0 |
+| 5 → 4 | 1.5667 / 45.3010 / 126.2667 → same | 0.0000 / 20.7227 / 63.2266 | 0 / 0 |
+| 6 → 5 | 0.5870 / 21.2445 / 82.3615 → same | 0.0000 / 21.2445 / 82.3615 | 0 / 0 |
+| 7 → 6 | 0.3393 / 16.4341 / 47.9760 → same | 0.0000 / 16.4341 / 47.9760 | 0 / 0 |
+| 8 → 7 | 0.9616 / 24.9479 / 50.0934 → same | 0.9616 / 24.9479 / 50.0934 | 0 / 0 |
+
+The baseline gate rejects on the field row and every swap row. The cutoff run returns the same rejection. Fault injections also rejected: missing-surface samples were 4,225–13,642; floating-surface samples 4,225–13,641; missing fine-ring cracks 4,225–8,450.
+
+| LOD | S13 octave-drop p99 / max px | Stride-2 column interpolation p99 / max px |
+|---:|---:|---:|
+| 3 | 960.2333 / 998.8654 | 9.3917 / 13.9093 |
+| 4 | 3.7405 / 5.1103 | 9.2115 / 15.3435 |
+| 5 | 105.7114 / 129.3089 | 125.1435 / 191.6424 |
+| 6 | 218.7777 / 749.9535 | 82.1098 / 148.9485 |
+| 7 | 95.1867 / 129.1796 | 40.6881 / 80.6012 |
+| 8 | 38.1461 / 282.3288 | 28.8473 / 278.6236 |
+
+Both controls were rejected at every LOD3–8. The octave-drop case produced missing samples at LOD3, 5–8 and floating samples at LOD5–8; stride-2 interpolation produced missing/floating samples at LOD5, 7 and 8.
+
+## Cutoff contract and detail cost
+
+The version-2 shared visual-detail contract declares stable octave terms with wavelength, octave count, displacement bound, and noise bound. A suffix is eligible only when its wavelengths are undersampled and its full displacement bound fits within one sixty-fourth of the tile’s pixel budget. Skipped zero-mean terms retain the original normalization denominator. Recipes with no terms keep the exact path; `FloatingIslandFieldV1` declares none, and its baseline/cutoff LOD hashes match. This is separate from content recipe version 1, which stays unchanged because output did not change.
+
+SurfaceWorld declares 17 terms per LOD. No term or octave tail qualifies at LOD3–8. Sample steps are 16, 32, 64, 128, 256, and 512 voxels respectively. The bounds explain the result: even the smallest declared maximum displacement is 256 voxels, against a 0.2356-voxel 1 px budget at LOD3. The cutoff skips zero octaves, so eligible octave time is 0 ms.
+
+| Octave | Terms | Wavelength range (voxels) | Max displacement range (voxels) |
+|---:|---:|---:|---:|
+| 0 | 17 | 25–10,000 | 1,024–640,000 |
+| 1 | 17 | 12.5–5,000 | 512–320,000 |
+| 2 | 15 | 6.25–1,250 | 256–160,000 |
+| 3 | 4 | 41.664–250 | 3,968–24,800 |
+
+W12 profile from the exact baseline; octave milliseconds are summed across evaluated calls/workers. They are all measured detail work, not removable work under the bound above.
+
+| LOD | Worker sum s | Octave 0 ms | Octave 1 ms | Octave 2 ms | Octave 3 ms | Detail total ms (% worker sum) | Eligible ms |
+|---:|---:|---:|---:|---:|---:|---:|---:|
+| 3 | 1.660 | 71.585 | 69.911 | 68.535 | 15.407 | 225.437 (13.58%) | 0 |
+| 4 | 3.321 | 135.512 | 131.224 | 128.645 | 26.506 | 421.887 (12.70%) | 0 |
+| 5 | 2.283 | 82.131 | 80.450 | 77.545 | 16.262 | 256.388 (11.23%) | 0 |
+| 6 | 3.587 | 153.409 | 148.854 | 144.175 | 29.984 | 476.422 (13.28%) | 0 |
+| 7 | 1.447 | 35.301 | 34.493 | 33.138 | 7.069 | 110.001 (7.60%) | 0 |
+| 8 | 2.685 | 58.763 | 57.751 | 56.277 | 11.848 | 184.638 (6.88%) | 0 |
+
+The cutoff is recipe-generic, display-mesh-only, and activated only for LOD3+. Exact density, detail, collision, edit, and walkability paths remain outside it. LOD0–2 keep the 2 cm path. ARCHITECTURE §8.10 invariants remain: lazy thread-local caches, two-pass MC, SSE noise, and clipmap streaming. The cutoff state is scoped to mesh generation under the async-safety rules.
+
+## W12 speed, interleaved with L4
+
+Three L4/candidate pairs, all W12, measured on the L1 camera. The candidate is the final build with `--visual-detail-cutoff`.
+
+| Measure (median) | L4 binary | Candidate | Change |
+|---|---:|---:|---:|
+| Whole-view ready | 2.183 s | 2.232 s | +2.2% |
+| Stream wall | 1.895 s | 1.963 s | +3.6% |
+| Far worker sum, LOD3–8 | 12.247 s | 12.458 s | +1.7% |
+
+| LOD | L4 worker sum s | Candidate worker sum s |
+|---:|---:|---:|
+| 0 | 3.799 | 4.094 |
+| 1 | 5.304 | 5.573 |
+| 2 | 1.281 | 1.340 |
+| 3 | 1.102 | 1.138 |
+| 4 | 2.723 | 2.719 |
+| 5 | 1.898 | 1.976 |
+| 6 | 2.875 | 2.944 |
+| 7 | 1.243 | 1.282 |
+| 8 | 2.355 | 2.400 |
+
+There is no speed benefit because nothing qualifies for skipping; the small regression is cutoff setup and bookkeeping.
+
+## Hashes and captures
+
+Baseline and cutoff hashes match for all LOD0–8. The old L4 binary’s aggregate hashes also match: whole view `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724` and full detail `0ee0579bd15cbbe4 / 32e5d4964d610fee / 1932b96ee4b1d910 / 69743c6bad3447dc`. The recipe stays version 1 because output did not change.
+
+| LOD | Density | Mesh | Payload | Topology |
+|---:|---|---|---|---|
+| 0 | 769f2a706d585a72 | 33eeeb39fa443816 | 645621a1d968983f | c2457ed905036c9d |
+| 1 | 69cc5a5c0a2c60af | b48335f5410c57d5 | d15c5480162ab8ba | feca1bd025823604 |
+| 2 | 85deed5683a77202 | 53469895987aeea2 | e55f8ae7e1532033 | d5feb12a0e85c09b |
+| 3 | 6518caefb3be7e7f | ec513c90b853a614 | f62fa1137ff17f82 | ccf1dcf681965816 |
+| 4 | 62d4be96021992f4 | f1e4c6efcc2615a9 | 9dc5f9c88be02f33 | fe6f55125a07c3bf |
+| 5 | 5e4a8c38b8cea6fc | 08ee56998aaf21e5 | 541eea8558f26cc8 | 6539374a8b3336d8 |
+| 6 | e036e95b9006945b | 624a33f941a99b02 | 81b73e14f68bdf86 | 4de4c63ce1f80a56 |
+| 7 | 8ee358af56a30d8d | 46ab3c6184048b7c | 0a6164b7e68e80c5 | 0c26b85bb03bc831 |
+| 8 | c3458e1cbdb9c471 | 46c03d0994d75192 | 8f89fc5bde12d230 | d16dc0cf62031898 |
+
+Nine direct-Core query probes also match baseline/cutoff and W1/W12 Clang/GCC: density and unclamped `e4d4a8eb95b35933`, detail `efcba20c0c70c415`, collision `e604823a249029bf`.
+
+| Before / after pair | View |
+|---|---|
+| `before_l1.jpg` / `after_l1.jpg` | Exact L1 camera `0,-35,-487.94,0,-22` |
+| `before_horizon.jpg` / `after_horizon.jpg` | Same position, pitch −2° |
+| `before_boundary_lod2_3.jpg` / `after_boundary_lod2_3.jpg` | 20 m above local heightfield, aimed at the 96 m LOD3 entry band |
+
+The boundary camera is `0,-35,-480.77246,0,-12`; the local heightfield is at −500.77246 m, placing the ground intersection about 96 m away.
+
+The six review JPEGs are byte-identical within each pair. PNGs are in `Saved/Linux/captures/`; JPEGs are in `Linux5/captures/`.
+
+## Failed and retried runs
+
+- The first headless invocation omitted required streaming flags; the next used the default binary-relative data path and could not open the owner JSON. Both were retried with all flags and the explicit `Standalone/data/owner_world.json` path.
+- The first process-monitor wrapper errored after its Clang build had completed; the run was repeated with `MeasureProcess.py` to record process HWM and duration.
+- The first capture named a nonexistent mesh path and exited 2; the exported `.vfmesh` path was corrected.
+- The first gate build failed on a duplicate `Distances` local; the corrected build passed. A first stride-2 control changed the MC lattice instead of reproducing S13’s every-second-column interpolation; the final control uses bilinear column interpolation.
+- Initial comparison against only the continuous field mixed surface interpolation with unrelated tunnel intersections. The final instrument reports exact heightfield roots separately from the exact-mesh regression and ring checks.
+- Early W12 cutoff candidates took 2.70–2.91 s. The zero-eligible path and distance setup were moved off the expensive profiling/phase-sweep path; the final interleaved candidate median is 2.232 s. It still does not improve L4.
+- One final GCC W12 command omitted `--stream-pipeline` and exited 2; the corrected rerun passed. The initial −50° boundary capture mostly showed near ground; the final pair uses the camera listed above.
+- The final baseline and cutoff gate commands exit 6 by design: both correctly reject the exact-field error and swap pops. No process exceeded 30 minutes or stalled for 15 minutes.
+
+Core/API changes are in `VoxelForgeCore.h`, `WorldAssemblerInternal.h`, `FloatingIslandsInternal.h`, and `VoxelForgeCore.cpp`. Standalone changes are in `StreamingWorld.h`, `StreamBenchmarkPipeline.h`, `StreamBenchmarkHeadless.cpp`, `LinuxScreenSpaceGate.h`, `LinuxOffscreenCapture.cpp`, and `BuildLinux.sh`; process measurements are in `MeasureProcess.py`.
+
+**For the owner:** Far terrain will look exactly as it does now because no octave tail met the bound. Existing far LOD swaps exceed the 1 px target, so the mesh sampling and transition error need attention before octave skipping can be used.
+
+## Orchestrator review (Claude)
+
+- **Not merged into `assembler/world`:** kept on side branch `wip/l5-far-cutoff`. With the cutoff flag OFF,
+  the L5 build is slower than L4. My interleaved W12 runs: L4 2.054/2.097/2.179 s vs L5 `final7`
+  2.127/2.193/2.208 s (medians 2.097 → 2.193, +4.6%), same world. Cost and no benefit.
+- **Instrument caveat:** the gate prints `metric=vertical_height_error`. On steep slopes and cliffs, a
+  small horizontal offset becomes a large vertical error, so vertical error overstates screen
+  displacement. p50 is ~1 px but p99/max reach 20–126 px, the pattern such an artifact produces. The
+  claims "today's far meshes exceed 1 px" and "LOD swaps pop by up to 126 px" are therefore NOT yet
+  established. They need a screen-space measure: error along the surface normal or along camera rays,
+  projected at the display distance.
+- The cutoff criterion (full displacement supremum ≤ 1/64 px) cannot pass for any SurfaceWorld octave
+  (smallest bound 256 voxels vs 0.24), so the null result was decided by the criterion, not measured.
+- The capture path (EGL/GLES pbuffer; llvmpipe, since the sandbox hides `/dev/dri`) works and is worth keeping.

Standalone/Research/WorldAssemblerM3/Linux6/REPORT.md

@@ -0,0 +1,102 @@
+# Linux6 report
+
+## Result
+
+The screen-space gate rejects today’s far meshes at every sampled LOD3–8: the largest measured same-field error is 92.0 px, and the largest sampled swap pop is 70.3 px at LOD6→5. Same-LOD regeneration is exact, the reported swaps have no cracks or floaters, and no display mesh changed in this round.
+
+Source base: `wip/l5-far-cutoff` at `b21a19d`; L4 reference: `7770074`.
+
+## Screen-space method
+
+For one surface tile nearest the L1 camera at each LOD, the gate rasterizes triangles on a 65×65 XY grid, excluding skirts. It compares the mesh hit to direct `Heightfield2D` ground/cap roots; slopes use ±1-voxel finite differences. For vertical residual `Δz` and slopes `sx,sy`, it computes normal distance `|Δz|/sqrt(1+sx²+sy²)`, projects that normal onto the camera’s screen plane, then divides by the one-pixel world distance at that LOD’s closest display distance. The view uses 90° horizontal FOV, 2560 px, yaw 0°, pitch −22°; one pixel is 0.000613592 rad. Same-LOD regeneration is the mesh reference for swaps; direct field roots are the reference for true surface error.
+
+The known failure control is a 1 m cell on an 89.427° plane, shifted sideways by 5 mm (0.005 cell): its vertical metric says 8.488 px, while its true normal distance is 5 mm and projected screen error is 0.0849 px. This confirms that vertical height can badly overstate visible displacement.
+
+| LOD | Closest distance (m) | Field error p50 / p99 / max (px) | Max normal distance (m) |
+|---:|---:|---:|---:|
+| 3 | 96 | 0.81 / 4.16 / 6.00 | 0.423 |
+| 4 | 192 | 1.01 / 5.12 / 7.93 | 0.952 |
+| 5 | 384 | 0.79 / 16.37 / 92.02 | 25.122 |
+| 6 | 768 | 0.51 / 9.75 / 70.34 | 37.644 |
+| 7 | 1,536 | 0.29 / 9.04 / 42.36 | 42.714 |
+| 8 | 3,072 | 0.83 / 18.03 / 47.18 | 93.175 |
+
+| Swap | Distance (m) | Pop p50 / p99 / max (px) | Max normal distance (m) |
+|---|---:|---:|---:|
+| 3→2 | 96 | 0.61 / 3.77 / 6.05 | 0.367 |
+| 4→3 | 192 | 0.75 / 4.63 / 7.51 | 0.896 |
+| 5→4 | 384 | 0.00 / 9.58 / 31.78 | 8.139 |
+| 6→5 | 768 | 0.00 / 9.75 / 70.34 | 37.644 |
+| 7→6 | 1,536 | 0.00 / 9.04 / 42.36 | 42.714 |
+| 8→7 | 3,072 | 0.83 / 18.03 / 47.18 | 93.175 |
+
+The tails are not confined to cliffs. The field maximum slopes at LOD5–8 are 8.34°, 14.09°, 6.76°, and 9.33°; LOD5’s p99 is 19.8 px below 30° and 21.1 px at 45–60°. The sampled LOD6→5 maximum is at `(-472, -1432, -463.151) m`; [the marked offscreen capture](captures/lod6_to_5_max_pop.jpg) shows that location at the 768 m swap distance. This is a sampled-tile result, not a whole-world supremum.
+
+All same-LOD mesh comparisons at LOD3–8 pass with zero error. The S13 octave-drop and corrected stride-2 column-interpolation controls are rejected at every LOD3–8, as are missing displayed surface, 2 m floating surface, and missing fine-ring injections. The measured swap rows have zero cracks and floaters; they reject solely on displacement.
+
+## Far worker time, W12
+
+The L1 view has 2553 tiles. Clean-run phase totals for LOD3–8 are shown below. A separate temporary timer measured complete `FractalNoiseQ16` calls; “column outside” is clean column time minus that subtotal. The timer added 3–6% to worker time, so the split between those two column subphases is approximate; it has been removed from the final tree.
+
+| LOD | Worker (s) | Column outside noise (ms) | Fractal/noise calls (ms) | MC (ms) | Ground refine (ms) | Cap refine (ms) | Skirts (ms) | Assembly (ms) |
+|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 3 | 1.084 | 171 | 276 | 473 | 0 | 0 | 118 | 33 |
+| 4 | 2.581 | 1,000 | 534 | 440 | 0 | 304 | 196 | 102 |
+| 5 | 1.829 | 658 | 358 | 100 | 464 | 22 | 161 | 70 |
+| 6 | 2.761 | 1,608 | 284 | 59 | 385 | 58 | 162 | 70 |
+| 7 | 1.192 | 234 | 198 | 32 | 275 | 202 | 153 | 96 |
+| 8 | 2.224 | 264 | 469 | 256 | 424 | 299 | 333 | 177 |
+| **Total** | **11.671** | **3,934** | **2,119** | **1,360** | **1,548** | **885** | **1,123** | **548** |
+
+Column work outside the fractal calls is the largest single phase (33.7% of far worker time); all column work is 51.9%. Ground and cap refinement total 2.43 worker-s, skirts 1.12 worker-s, MC 1.36 worker-s, and assembly 0.55 worker-s. The earlier 7–13% profile timed individual Perlin calls; the L6 subtotal times complete fractal calls, including their octave accumulation.
+
+The listed subphases total 11.52 worker-s; about 0.15 worker-s remains in timer and per-tile residuals.
+
+The overlap scan counted about 411,000 cross-worker neighboring duplicate XY evaluations at LOD3–8 (about 166,000 at LOD4 alone). Exact column reuse is the largest plausible lever because it targets the largest phase. I did not build it: no candidate has yet shown a screen-gated, greater-than-3% whole-view win. Stride-2 interpolation is not a safe substitute; its control fails at every far LOD.
+
+## Cost with the feature off
+
+Three interleaved W12 runs per binary, same L1 camera and forced generation. `whole_view_ready` is the comparison metric; the six whole-view hashes matched exactly.
+
+| Binary | Runs (s) | Median |
+|---|---|---:|
+| L4 reference | 2.082, 2.180, 2.183 | 2.180 s |
+| L6 cleaned tree | 2.127, 2.185, 2.223 | 2.185 s (+0.2%) |
+
+Run-to-run spread was about 0.10 s, so the 5 ms median difference is within noise. The no-op visual cutoff contract, plan, and CLI flag were removed. The opt-in research gate retains its negative controls; skirt timing uses the existing optional stage-timing pointer, which is null on the default path. Governor stayed `powersave`; runs used CPUs 0–11, W12, 6 GiB address-space limits, and normal priority. Peak runtime RSS was 403 MiB; peak build process RSS was 874 MiB (GCC).
+
+## Determinism and hashes
+
+Clang 19 `-ffp-contract=off` W1/W12 and GCC default W1/W12 produced the same hashes. LOD0–2, exact queries, and all whole-view hashes equal L4; no recipe bump is needed.
+
+- Recipe / plan / manifest: `83b616a3f4fe781d` / `1ca84619c8600ee5` / `e55991385bf0ca29` (recipe version 1).
+- Whole view (density / mesh / payload / topology): `c10697a8f48380c7` / `e75c9119a1498cd5` / `49a9a8d1835a6c8c` / `edcb23288b5e8724`.
+- Full detail (density / mesh / payload / topology): `0ee0579bd15cbbe4` / `32e5d4964d610fee` / `1932b96ee4b1d910` / `69743c6bad3447dc`.
+- Exact queries (density / unclamped / detail / collision): `e4d4a8eb95b35933` / `e4d4a8eb95b35933` / `efcba20c0c70c415` / `e604823a249029bf`.
+- SHA-256 L4 binary / Clang L6 binary / GCC L6 binary: `6efb8f19a41ca3cd23aca9294ceee1e9cdd1d3dc8da23b3ee61ef8ae943aa763` / `3f5a4f88b0d911e8e66af9ef72e294926a5507a73d44fcfe868df27c666bf01e` / `de872e8fdaa9f40e8a6c096700fd998bcf35f232b06f2b4e35a374b4b0e9fa07`.
+- Capture JPEG SHA-256: `483b434f3ad752dd09b82cd1c78fe81ee8cd31803ecf4dcd3c2918a8ae5d66b1` (156 KiB).
+
+## Failed or retried runs
+
+- First Clang build failed on a missing view argument in `LinuxScreenSpaceGate.h`; fixed and rebuilt successfully.
+- First gate pass paired extra mesh hits incorrectly and reported same-LOD floaters at LOD5–8. The reference pairing was corrected; the final gate reports zero same-LOD displacement and no floaters.
+- A `/usr/bin/time -v` wrapper attempt exited 127 because that binary is unavailable; the runs were retried with `/proc` RSS monitoring.
+- The final quality gates exit 6 by design because measured displacement exceeds the 1 px rule. Builds, captures, determinism runs, and cost runs completed successfully. EGL could not write `~/.cache` in this environment, disabled shader caching, and rendered successfully on llvmpipe.
+
+## Note for the owner
+
+Today’s `assembler/world` remains at L4; this sampled view measures up to 92.0 px from the field and a 70.3 px LOD6→5 pop at the tested display distances, with the largest point marked in the capture. This round changes no default mesh or recipe output, removes the no-op cutoff, and leaves W12 cost within run-to-run noise.
+
+## Orchestrator review (Claude)
+
+- Cost re-run by me (interleaved W12, L1 view): L4 2.098/2.138/2.171 s vs L6 2.116/2.150/2.197 s
+  (median +0.6%, within noise), density `c10697a8f48380c7`; the L6 binary SHA matches the report.
+  Merged into `assembler/world` with L5 squashed in.
+- The marked LOD6→5 maximum sits on the **rim of a flat-topped hill (mesa edge)**, not on open gentle
+  ground: the "8–14° slope" is the field slope at the sample, on the plateau top beside the drop. The
+  coarse mesh rounds the rim by about a cell (16–32 m at LOD5–6), so the pop is a real **silhouette snap
+  at sharp rims** (tens of px at 768 m), while p50 stays at 0 px. That is ordinary LOD-switch behaviour
+  without geomorphing or cross-fade, so a fix belongs in rendering (Unreal), not in generation. The
+  owner decides whether it is visible enough to matter.
+- Next speed lever, per the far breakdown: exact cross-tile column reuse (column work outside noise is
+  34% of far worker time; ~411k duplicate XY evaluations at LOD3–8).

Standalone/Research/WorldAssemblerM3/Linux7/REPORT.md

@@ -0,0 +1,171 @@
+# Linux7 — shared terrain columns
+
+**Decision: keep the shared second tier.** On the L1 view it cut median W12 whole-view time by
+19.0%, well above the 3% threshold, and the 8 m camera crossing was also faster. All final output
+hashes match the `9898e05` binary.
+
+Runs used the `linux6` base, Clang 19 with FP contraction off, GCC 14 defaults, CPUs 0–11, normal
+priority, a 6 GiB address-space cap, and the unchanged `powersave` governor. Static timings below
+are three alternating base/candidate W12 runs of 2,553 tiles.
+
+## 1. What was recomputed
+
+Three complete W12 captures per mode on the L1 view. Counts below are medians of actual column
+formula executions after worker-local cache misses, grouped by LOD. “Same worker” means the worker
+had computed that XY before and later missed its local entry. Halo/normal repeats are separated
+before worker attribution; the parenthesized value is the total computed halo/normal probes,
+including unique ones. Each field's median is independent, so row medians can differ slightly from
+their sums.
+
+| LOD | Base total / unique XY | Same worker | Different worker | Halo repeats / probes | Shared total / unique XY |
+|---:|---:|---:|---:|---:|---:|
+| 0 | 556,134 / 128,240 | 22,307 | 358,908 | 46,679 / 70,972 | 135,720 / 127,370 |
+| 1 | 452,626 / 104,284 | 16,393 | 287,791 | 39,245 / 59,082 | 85,658 / 85,479 |
+| 2 | 144,251 / 32,274 | 14,667 | 74,377 | 22,933 / 30,942 | 28,019 / 28,019 |
+| 3 | 91,158 / 33,256 | 0 | 46,387 | 11,564 / 20,339 | 16,213 / 16,213 |
+| 4 | 272,776 / 91,325 | 100 | 167,083 | 14,266 / 28,089 | 90,105 / 90,065 |
+| 5 | 178,511 / 71,957 | 1 | 98,687 | 7,892 / 20,042 | 70,932 / 70,930 |
+| 6 | 342,763 / 280,334 | 20 | 56,204 | 6,205 / 19,977 | 279,266 / 279,202 |
+| 7 | 79,400 / 71,468 | 1 | 4,951 | 2,980 / 14,329 | 70,492 / 70,492 |
+| 8 | 137,062 / 106,219 | 0 | 22,138 | 8,704 / 22,609 | 106,219 / 106,219 |
+
+Across the per-LOD medians, the base made 2.255 million formula evaluations: 919 thousand unique
+XYs and 1.336 million repeats. Of the repeats, 83.6% were from another worker, 4.0% were same-worker
+evictions, and 12.0% were halo/normal probes. The shared candidate made 883 thousand evaluations,
+60.9% fewer; about 8.6 thousand repeats remained. This is mostly a worker-sharing problem, not a
+local-cache-capacity problem.
+
+## 2. Design
+
+`SharedColumnCache.h` is a bounded, four-way second-tier value cache used by both `Heightfield2D`
+and FloatingIslands. Its key includes recipe and plan pointer identity plus content hash, exact XY,
+and an optional exact sub-domain identity; FloatingIslands supplies the island stable ID because
+different anchors can use the same XY. LOD is omitted because the column value is LOD-independent.
+The heightfield table has 524,288 slots and the island table has 65,536. Both are allocated with
+the `World::Impl` and destroyed with it. The Standalone streamer stops and joins workers before
+world teardown; engine shutdown must keep the same drain-before-destroy ordering as the existing
+generator state.
+
+The S14 `FLazy` thread-local caches stay first, so their hits remain worker-private. Shared hits read
+versioned atomic entries without taking a lock; a miss takes a set-local spin lock, rechecks, then
+computes and publishes. A hit racing with a slot replacement can fall through as a miss. Fixed
+capacity bounds memory and replacement bounds reuse as the player moves. No page ring, prefetch, or
+neighbor affinity was needed. The shared table is not an immutable page store; atomic fields and
+version checks give readers a consistent value while a slot can be replaced. Workers only read
+recipe/plan identity and content hashes; they do not mutate generator state or call UObject/engine
+APIs. Epoch, shutdown, and MPSC result handling were not changed. The L3 FP-contract preamble and
+self-test remain intact, as does the `FLazy` rule for large thread-local storage.
+
+## 3. Speed and memory
+
+| W12 static whole view | Base | Shared | Change |
+|---|---:|---:|---:|
+| `whole_view_ready` median | 2.165 s | 1.754 s | −19.0% |
+| Peak RSS median (max) | 401.5 MiB (402.6) | 467.8 MiB (468.0) | +66.3 MiB median |
+
+Per-LOD worker sum is the sum of tile worker seconds, not wall time. Values are medians across the
+same three static runs.
+
+| LOD | Base worker sum | Shared worker sum | Change |
+|---:|---:|---:|---:|
+| 0 | 3.830 s | 2.667 s | −30.4% |
+| 1 | 5.301 s | 4.085 s | −22.9% |
+| 2 | 1.296 s | 0.795 s | −38.7% |
+| 3 | 1.116 s | 0.725 s | −35.1% |
+| 4 | 2.692 s | 1.674 s | −37.8% |
+| 5 | 1.911 s | 1.459 s | −23.7% |
+| 6 | 2.903 s | 2.621 s | −9.7% |
+| 7 | 1.242 s | 1.227 s | −1.2% |
+| 8 | 2.318 s | 2.271 s | −2.0% |
+
+The moving trial warmed the first view, moved the camera 8 m, then generated 144 entering tiles
+(128 LOD0, 16 LOD1) on the same world and worker pool. It ran three times per cache mode.
+
+| Moving check | Shared | Thread-local | Change |
+|---|---:|---:|---:|
+| New-tile wall median | 52.39 ms | 82.00 ms | −36.1% |
+| LOD0 worker sum median | 403.44 ms | 693.67 ms | −41.8% |
+| LOD1 worker sum median | 138.34 ms | 182.29 ms | −24.1% |
+| Peak RSS median (max) | 466.1 MiB (466.9) | 466.1 MiB (467.6) | Same cache allocation in both modes |
+
+## 4. Hashes
+
+Every W1/W12 result matched the base for Clang FP contraction off and GCC default: full detail,
+whole view, each LOD, and exact queries. The L1 base hashes are:
+
+| Scope | Density | Mesh | Payload | Topology |
+|---|---|---|---|---|
+| Full detail, 960 tiles | `0x0ee0579bd15cbbe4` | `0x32e5d4964d610fee` | `0x1932b96ee4b1d910` | `0x69743c6bad3447dc` |
+| Whole view, 2,553 tiles | `0xc10697a8f48380c7` | `0xe75c9119a1498cd5` | `0x49a9a8d1835a6c8c` | `0xedcb23288b5e8724` |
+
+| LOD | Density | Mesh | Payload | Topology |
+|---:|---|---|---|---|
+| 0 | `0x769f2a706d585a72` | `0x33eeeb39fa443816` | `0x645621a1d968983f` | `0xc2457ed905036c9d` |
+| 1 | `0x69cc5a5c0a2c60af` | `0xb48335f5410c57d5` | `0xd15c5480162ab8ba` | `0xfeca1bd025823604` |
+| 2 | `0x85deed5683a77202` | `0x53469895987aeea2` | `0xe55f8ae7e1532033` | `0xd5feb12a0e85c09b` |
+| 3 | `0x6518caefb3be7e7f` | `0xec513c90b853a614` | `0xf62fa1137ff17f82` | `0xccf1dcf681965816` |
+| 4 | `0x62d4be96021992f4` | `0xf1e4c6efcc2615a9` | `0x9dc5f9c88be02f33` | `0xfe6f55125a07c3bf` |
+| 5 | `0x5e4a8c38b8cea6fc` | `0x08ee56998aaf21e5` | `0x541eea8558f26cc8` | `0x6539374a8b3336d8` |
+| 6 | `0xe036e95b9006945b` | `0x624a33f941a99b02` | `0x81b73e14f68bdf86` | `0x4de4c63ce1f80a56` |
+| 7 | `0x8ee358af56a30d8d` | `0x46ab3c6184048b7c` | `0x0a6164b7e68e80c5` | `0x0c26b85bb03bc831` |
+| 8 | `0xc3458e1cbdb9c471` | `0x46c03d0994d75192` | `0x8f89fc5bde12d230` | `0xd16dc0cf62031898` |
+
+Exact queries (9 probes): density and unclamped `0xe4d4a8eb95b35933`, detail
+`0xefcba20c0c70c415`, collision `0xe604823a249029bf`. The FloatingIslands seed-0 fixture also
+passes at Clang/GCC W1/W12 with recipe hash `0x39a24198ad8cf88f`; its whole-view hash matches the
+base: density `0xa8fc5f8f4eaf77a3`, mesh `0xfff7d8ac8923eb9a`, payload `0xd730c51d959c1c59`,
+topology `0xbb33ddb76cd386be`.
+
+## 5. Transfer estimate and Windows work
+
+The majority of the opportunity is cross-worker, so it does not disappear just because the 5800X3D
+has a larger L3. Same-worker evictions are only 4% of baseline repeats; that capacity-driven part
+may shrink. The candidate adds about 66 MiB peak RSS, and a 96 MiB L3 could keep much of the shared
+table resident, though other game data will compete for it. I expect the win to transfer and clear
+3%, likely landing in the mid-single to low-double digits; that percentage is an estimate until the
+5800X3D run.
+
+Windows to-do:
+
+1. Build the Core route with MSVC `/fp:precise`; keep the FP-contract self-test and check the
+   64-bit atomic slot path on the supported Windows target.
+2. Run the W1/W12 whole-view, full-detail, per-LOD, exact-query, and seed-0 FloatingIslands checks
+   against the base binary.
+3. Interleave three static W12 A/B runs on the 5800X3D, then repeat the 8 m camera crossing; record
+   peak RSS and the machine's unchanged governor.
+4. Exercise real streaming shutdown/profile changes and confirm workers drain before world/cache
+   destruction, with Epoch checks and MPSC result queues still intact.
+
+## 6. Failed and corrected runs
+
+- The first Clang W1 hash invocation omitted the explicit data path; it exited 2 after resolving
+  `Standalone/bin/data/owner_world.json`. The retry passed with
+  `Standalone/data/owner_world.json` supplied.
+- The first moving step was 32 m and failed the shape interval 160-million-node safety bound. The
+  benchmark was retried at 8 m, which completed three times in each cache mode.
+- The first shared FloatingIslands cache key omitted the island stable ID. The W12 fixture exposed
+  an LOD4 hash mismatch. Adding the exact sub-domain ID fixed it; final hashes match at W1/W12 for
+  both compilers.
+- An early fixture command passed `--seed=0`, which also overrode the surface-world seed. The final
+  fixture comparison omits that override; FloatingIslands itself still runs its seed-0 check.
+- No run exceeded 30 minutes or remained stuck for 15 minutes. All final Clang and GCC builds
+  succeeded with 12 jobs.
+
+## Owner note
+
+Linux measured a 19.0% W12 whole-view gain and a 36.1% gain on the 8 m crossing, at about 66 MiB
+more peak RSS. Please run the Windows hash matrix and static/moving A/B on the 5800X3D before using
+the laptop percentage as an owner-machine estimate.
+
+## Orchestrator review (Claude)
+
+- **Concurrency read:** a seqlock over all-atomic fields (seq_cst), with the version checked before
+  and after the key/value loads; readers fall back to a miss on any mismatch. Writers hold the set
+  spin lock and mark the version odd while writing. There is no non-atomic shared access, so a
+  reader can't return a torn value. The per-tile scoped `setThreadActive`/restore binds each thread
+  to its own world's table. Default on (`useSharedColumnCache = true`).
+- **Re-run by me** (W12, L1 view, interleaved): base `linux6` 2.014/2.059/2.092 s vs L7 `linux7shared`
+  1.657/1.730/1.729 s, then 1.718/1.705/1.722 s (median 2.059 → 1.722 s, -16%). The whole-view hash was
+  identical in all 8 L7 runs at W12, plus W1 (8.036 s) and W8 (1.799 s).
+- Luna's island-key bug was caught by the W12 hash fixture before review, so the determinism check
+  works as intended.

Standalone/Research/WorldAssemblerM3/Linux8/REPORT.md

@@ -0,0 +1,69 @@
+# Linux8: work remaining after the shared cache
+
+## Per-LOD profile
+
+W12 work and stage times below are medians of five interleaved timing runs. Cache columns are call counts (`worker-local hit / shared hit / shared miss`); cache outcomes were not timed separately. Unique XY per tile is the median across three W12 coordinate-capture runs. Skirt time needs the optional mesher timer, so those values come from the final gated profile; mesh assembly is the five-run median. Stage timers do not add exactly to worker time because they omit classification and other work, and some are inclusive of column computation.
+
+| LOD | Tiles | Work (s) | Columns (ms) | MC (ms) | Ground/cap (ms) | Far shell (ms) | Skirt/assembly (ms) | Samples/tile | Local/shared/miss calls | Unique XY/tile |
+|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 0 | 512 | 2.649 | 462 | 1,348 | 0/0 | 0.09 | 281/80 | 10,383.8 | 9.400M/405k/136k | 265 |
+| 1 | 448 | 4.064 | 309 | 3,487 | 0/0 | 0.08 | 186/76 | 42,875.0 | 19.354M/357k/86k | 191 |
+| 2 | 448 | 0.781 | 133 | 575 | 0/0 | 0.08 | 99/35 | 4,133.8 | 1.743M/115k/28k | 63 |
+| 3 | 384 | 0.730 | 89 | 591 | 0/0 | 0.07 | 108/33 | 6,859.0 | 2.130M/73k/16k | 42 |
+| 4 | 320 | 1.640 | 508 | 651 | 0/372 | 0.06 | 187/102 | 6,859.0 | 1.718M/182k/90k | 282 |
+| 5 | 144 | 1.419 | 397 | 275 | 650/22 | 0.03 | 157/72 | 6,859.0 | 698k/109k/71k | 493 |
+| 6 | 96 | 2.551 | 1,569 | 237 | 409/58 | 1,379 | 161/71 | 6,859.0 | 418k/63k/279k | 2,909 |
+| 7 | 48 | 1.201 | 393 | 200 | 294/208 | 0.00 | 149/99 | 6,859.0 | 258k/9k/70k | 1,469 |
+| 8 | 153 | 2.186 | 584 | 661 | 447/308 | 0.01 | 263/182 | 6,859.0 | 508k/30k/106k | 694 |
+
+## LOD6 and LOD1
+
+LOD6 generated 279,207 distinct XY columns across 96 tiles (2,909 per tile), close to the 280,334 L7 count. A bracket around `AppendFarConnectorShells` measured 206,849 formula evaluations there, about 74% of LOD6's column evaluations, and 1.379 worker-seconds; MC used about 35k evaluations, ground refinement about 37k, and cap none. The repair runs at LOD6 while stratum-shell repair starts at LOD7. The final gate profile recorded 13,291 halo/normal probes and only 16 repeated halo columns, so they do not explain the spike. The gate samples native terrain and does not certify dropping connector-shell geometry; no connector-shell work was shown to be screen-inert.
+
+LOD1 has zero feature-refined tiles: it uses the normal 32-cell lattice at step 2. Its 448 tiles each consumed 42,875 density samples (35³); LOD0 averaged 10,383.8, or 5.32M total versus LOD1's 19.21M. The mesher's 8-cell proof-block early-outs are enabled at step 1 and step 8, but deliberately disabled at step 2, so LOD0 can skip uniform blocks while LOD1 fills each tile's grid. MC is LOD1's cost: 3.487 worker-seconds, with 3.345 seconds in density-grid fill in the detailed run. Cell classification was 123 ms, normals 13 ms, interpolation 8 ms, and dedup/stream 59 ms. Column computation was 309 ms; halo/normal work is not the cause.
+
+## Wall time and levers
+
+The median W12 tile work was 17.299 worker-seconds, or 1.442 seconds at ideal use of 12 workers. Measured stream wall was 1.446 seconds, only 4 ms above that estimate. Whole-view readiness was 1.727 seconds: shape compilation was 215 ms and another 67 ms elapsed before stream work began in owner/plan/setup. The residual is startup, not an idle worker or a long tile tail.
+
+The largest lever is LOD1 density-grid filling: 3.345 worker-seconds, a theoretical ceiling of 279 ms (16.2% of a 1.72-second view) if eliminated at perfect 12-way scaling. Next are LOD6 connector-shell repair at 1.379 worker-seconds (115 ms, 6.7%), LOD0 MC at 1.348 (112 ms, 6.5%), then LOD4 MC and LOD5 ground refinement at about 0.65 each (54 ms, 3.1%). These are upper bounds, not expected savings, and the work overlaps other stages. No product optimization was built: the candidates above threshold either produce required geometry or need an exact, output-preserving kernel change that this count round did not prove.
+
+The L6 gate on the final W12 profile passed same-LOD regeneration at LOD3–8 and rejected all negative controls. The existing far mesh still fails its direct-field 1 px comparison at every LOD3–8 (maxima: 6.00, 7.93, 92.02, 70.34, 42.36, 47.18 px); this round changes no geometry. No recipe bump is needed.
+
+## Interleaved W12 timing and hashes
+
+`linux8` is the Clang 19 `-ffp-contract=off` measurement build; `linux8gcc` is GCC 14 default. Neither changes geometry. SHA256: L7 baseline `fbbd468e351c8a0e00c903a7988a3765158e9400ed6a0111898da4d7f5ae6c85`; Clang `linux8` `82b159359a754fb33c38a93c8b7cafe5d4cfc08c41582cbfd21328307f5e3c19`; GCC `linux8gcc` `5614db5158a3f404383eea27c3748d7cf05b3a0c545b9e95f272e09bed0ee300`.
+
+| Pair | L7 `linux7shared` (s) | Clang `linux8` (s) | Delta |
+|---:|---:|---:|---:|
+| 1 | 1.733 | 1.677 | −56 ms |
+| 2 | 1.670 | 1.702 | +32 ms |
+| 3 | 1.685 | 1.727 | +42 ms |
+| 4 | 1.692 | 1.727 | +35 ms |
+| 5 | 1.725 | 1.741 | +16 ms |
+| Median | 1.692 | 1.727 | +35 ms (+2.1%) |
+
+Pair deltas range from −56 to +42 ms, so this diagnostic build shows no separable speed change. Every W12 pair had the same whole-view hashes: density `0xc10697a8f48380c7`, mesh `0xe75c9119a1498cd5`, payload `0x49a9a8d1835a6c8c`, topology `0xedcb23288b5e8724`. W1/W8/W12 and Clang/GCC also agreed on all nine per-LOD hashes and exact-query hashes: density/unclamped `0xe4d4a8eb95b35933`, detail `0xefcba20c0c70c415`, collision `0xe604823a249029bf`. Thus LOD0–2 and exact queries are unchanged from L7.
+
+The final Clang and GCC builds took 29.876 s and 45.562 s; peak build RSS was 437,844 KiB and 901,892 KiB. Highest measured runtime RSS was 587,344 KiB. Runs used CPUs 0–11, `-j12`, a 6 GiB address-space limit, normal priority, and the unchanged `powersave` governor.
+
+## Failed or retried runs
+
+- `l8_build_clang.log` failed after 27.608 s: the first print patch referenced local phase sets outside their scope. The corrected `l8_build_clang_retry.log` and `l8_build_clang_retry2.log` succeeded; the later phase-instrumented `l8_build_clang_final.log` and `l8_build_gcc_final.log` also succeeded.
+- The initial no-camera probes in `l8_hash_clang_w1.log`, `l8_hash_clang_w8.log`, `l8_hash_clang_w12.log`, and `l8_baseline_l7_hash_w1.log` generated 2,370 tiles, not this 2,553-tile fixture. They were discarded and rerun with `--camera=0,-35,-487.94,0,-22`.
+- `l8_profile_gate_w12.log` and `l8_profile_gate_final.log` returned exit 6 because the gate correctly rejects the existing far-mesh field error. Same-LOD checks passed and all fault/negative controls were rejected as required. All corrected hash, profile-repeat, and speed runs exited 0; none timed out.
+
+Build and runtime logs are in `Saved/Linux/l8_*.log`. No commit, push, or stash was made.
+
+**Owner note:** LOD6's extra columns are predominantly connector-shell repair work, while LOD1 is expensive because all 448 tiles fill the normal density grid; neither points to wasted halo or normal work. The next useful experiment is a bit-exact LOD1 density-grid optimization, while any LOD6 resolution change needs a connector-specific screen gate first.
+
+## Orchestrator review (Claude)
+
+- **Why LOD1 fills every sample:** `VoxelMarchingCubesMesher.cpp` gates the 8-cell proof blocks to
+  `Step == 1 || Step == 8`, and its comment says steps 2/16/32 skip them because "their meshing work is
+  already smaller than repeating a full tile classifier per block" and to keep "the established
+  coarse-LOD latency profile". That tuning predates the Core heightfield path; on the owner's
+  SurfaceWorld view, LOD1's grid fill is now the largest single cost (3.35 worker-s). Next round: L9.
+- Only this report is committed. Luna's L8 instrumentation (Core and pipeline diffs) stays uncommitted
+  in the tree for L9 to reuse or remove; its cost against L7 was +2.1% median with pair deltas from
+  -56 to +42 ms, which is not separable, so it doesn't go in until proven free.

Standalone/Research/WorldAssemblerM3/Linux9/REPORT.md

@@ -0,0 +1,149 @@
+# Linux9: LOD1 uniform-block proof
+
+LOD1 now omits density fills only for 8-cell blocks proved uniform by the Core SurfaceWorld heightfield. It fills 924,232 samples across the 448 tiles (2,063 per tile), down from 19,208,000 (42,875 per tile): 95.2% fewer. All output hashes match the `4b1108b` baseline.
+
+## Why the old gate excluded steps
+
+`git blame` points to the original mesher gate: steps 2, 16 and 32 were disabled because the per-block classifier was expected to cost more than the smaller grids saved, and to preserve the old coarse-LOD latency. It gives no correctness reason at step 2; the history does not cite block edges, normal halos or skirts. Step 1 and step 8 were already enabled (step 8 is LOD2). This round enables step 2 for native SurfaceWorld tiles; steps 16/32 remain off pending a separate cost profile.
+
+## Proof and fallback
+
+The tile and each proof box must stay inside one native SurfaceWorld stratum, with no overlapping edit. For every XY lattice point in the padded 8-cell box, `Heightfield2D::classifyLatticeBox` evaluates the exact ground and cap columns at the step-2 stride. For density `min(z-ground, cap-z)`, `minZ > maxGround && maxZ < minCap` proves air; `maxZ < minGround || minZ > maxCap` proves solid. These extrema bound every discrete MC density sample; the box includes the cell samples and the one-sample normal halo (`-1..+9`). No nominal noise parameter is used as a bound.
+
+Feature boxes that can add volume, edits, invalid input, mixed strata, and any Mixed/Unknown verdict stay on the exact fill path. The default FloatingIslands view does not use this Step-2 tile gate; its Unknown whole boxes (1,635) remain filled. The native classifier path is shared, and a W12 island audit also forced 9,216 uniform Step-2 candidates through fill-and-check.
+
+The generic `Heightfield2D::interval` was sound but too broad here: it gave bounds `[-2,883,809, 1,032,090]` subvoxels around z=-2,114, so all 28,672 Step-2 blocks were Mixed. The exact lattice-column extrema produced useful verdicts instead.
+
+## Soundness sweep
+
+The audit bypassed block skipping and explicitly evaluated every density sample in each candidate's padded block, asserting that none contradicted the verdict. It covered three SurfaceWorld seeds and one FloatingIslands audit:
+
+| Recipe / seed | Blocks checked | Density samples checked | Mixed fallbacks | Unknown | Violations |
+|---|---:|---:|---:|---:|---:|
+| SurfaceWorld 0 | 27,479 | 36,574,549 | 1,193 | 0 | 0 |
+| SurfaceWorld 1 | 26,069 | 34,697,839 | 1,451 | 0 | 0 |
+| SurfaceWorld 17 | 26,954 | 35,875,774 | 1,718 | 0 | 0 |
+| SurfaceWorld total | 80,502 | 107,148,162 | 4,362 | 0 | 0 |
+| FloatingIslands 0 | 9,216 | 12,266,496 | 0 | 0 | 0 |
+
+A violation would be possible if the native density dispatch or `point()` stopped matching this column formula, if a new volume/edit overlay bypassed the Mixed guard, or if the padded lattice/normal halo changed without updating the proof bounds. Zero density is treated as Mixed by the audit.
+
+## W12 samples and worker time
+
+Sample counts compare L8's SurfaceWorld profile with the final L9 profile. Worker seconds are medians of five W12 no-hash runs against `linux7shared` and the Clang candidate. They are per-LOD sums across workers.
+
+| LOD | L9 filled samples | Worker seconds baseline → L9 | Change |
+|---:|---:|---:|---:|
+| 0 | 5,316,500 | 2.398 → 2.395 | -0.1% |
+| 1 | 924,232 | 1.213 → 0.920 | -24.1% |
+| 2 | 932,824 | 0.452 → 0.456 | +0.8% |
+| 3 | 1,858,789 | 0.540 → 0.549 | +1.6% |
+| 4 | 2,085,136 | 1.535 → 1.545 | +0.6% |
+| 5 | 987,696 | 1.378 → 1.395 | +1.2% |
+| 6 | 658,464 | 2.559 → 2.564 | +0.2% |
+| 7 | 329,232 | 1.134 → 1.139 | +0.4% |
+| 8 | 1,049,427 | 2.055 → 2.082 | +1.3% |
+
+LOD1 per tile is 42,875 → 2,063 samples.
+
+LOD0 and LOD2–8 stayed within 1.6% of baseline worker time. LOD1's 4.064 worker-seconds in the L8 profile did not reproduce in the specified `linux7shared` binary's worker diagnostics: the five-run median there was 1.213 seconds. The exact-binary interleaved timing below is the comparable whole-view measure.
+
+## W12 interleaved stream time
+
+Baseline is `Standalone/bin/linux/VoxelForgeCoreHeadless-linux7shared`, SHA256 `fbbd468e351c8a0e00c903a7988a3765158e9400ed6a0111898da4d7f5ae6c85`. Each pair used the same seed, camera, 2,553 tiles and W12 settings.
+
+| Pair | Baseline | Clang `-ffp-contract=off` | Delta |
+|---:|---:|---:|---:|
+| 1 | 1.079 s | 1.066 s | -1.2% |
+| 2 | 1.109 s | 1.083 s | -2.3% |
+| 3 | 1.145 s | 1.100 s | -3.9% |
+| 4 | 1.125 s | 1.099 s | -2.3% |
+| 5 | 1.126 s | 1.113 s | -1.2% |
+| Median | 1.125 s | 1.099 s | -2.3% |
+
+| Pair | Baseline | GCC 14 default | Delta |
+|---:|---:|---:|---:|
+| 1 | 1.073 s | 1.100 s | +2.5% |
+| 2 | 1.091 s | 1.136 s | +4.1% |
+| 3 | 1.104 s | 1.129 s | +2.3% |
+| 4 | 1.123 s | 1.140 s | +1.5% |
+| 5 | 1.123 s | 1.150 s | +2.4% |
+| Median | 1.104 s | 1.136 s | +2.9% |
+
+The baseline ELF contains GCC 14 and Clang 19 objects; the candidate GCC binary is GCC-only. As a compiler-matched control, five W12 pairs against the GCC-only `linux7gcc` baseline measured 1.154 s → 1.116 s (-3.3%). Thus the specified-binary GCC comparison is slower, while the matched GCC control is faster; the mixed-toolchain delta cannot be attributed to this change. The Clang candidate is faster than the specified binary.
+
+FloatingIslands seed 0 hashes match at W1/W12 for both compilers. Five W12 no-hash pairs against `linux7shared` gave Clang 10.836 → 11.005 s (+1.6%, pair range -0.5% to +3.0%). GCC was 11.223 → 12.618 s (+12.4%), while five compiler-matched GCC pairs against `linux7gcc` were 12.498 → 12.529 s (+0.25%, pair range -0.5% to +1.3%). The default island path has no measurable same-compiler slowdown; the large `linux7shared` GCC delta is the same toolchain mismatch.
+
+## Hashes
+
+Every SurfaceWorld hash below matched the baseline at W1/W8/W12 for both compilers; W12 was repeated five times per compiler. FloatingIslands seed 0 matched at W1/W12 for both compilers. Per-LOD tuples are density / mesh / payload / topology.
+
+SurfaceWorld full detail: density `0x0ee0579bd15cbbe4`, mesh `0x32e5d4964d610fee`, payload `0x1932b96ee4b1d910`, topology `0x69743c6bad3447dc`.
+
+SurfaceWorld whole view: density `0xc10697a8f48380c7`, mesh `0xe75c9119a1498cd5`, payload `0x49a9a8d1835a6c8c`, topology `0xedcb23288b5e8724`.
+
+SurfaceWorld exact queries (9 probes): density/unclamped `0xe4d4a8eb95b35933`, detail `0xefcba20c0c70c415`, collision `0xe604823a249029bf`.
+
+| LOD | Density | Mesh | Payload | Topology |
+|---:|---|---|---|---|
+| 0 | `0x769f2a706d585a72` | `0x33eeeb39fa443816` | `0x645621a1d968983f` | `0xc2457ed905036c9d` |
+| 1 | `0x69cc5a5c0a2c60af` | `0xb48335f5410c57d5` | `0xd15c5480162ab8ba` | `0xfeca1bd025823604` |
+| 2 | `0x85deed5683a77202` | `0x53469895987aeea2` | `0xe55f8ae7e1532033` | `0xd5feb12a0e85c09b` |
+| 3 | `0x6518caefb3be7e7f` | `0xec513c90b853a614` | `0xf62fa1137ff17f82` | `0xccf1dcf681965816` |
+| 4 | `0x62d4be96021992f4` | `0xf1e4c6efcc2615a9` | `0x9dc5f9c88be02f33` | `0xfe6f55125a07c3bf` |
+| 5 | `0x5e4a8c38b8cea6fc` | `0x08ee56998aaf21e5` | `0x541eea8558f26cc8` | `0x6539374a8b3336d8` |
+| 6 | `0xe036e95b9006945b` | `0x624a33f941a99b02` | `0x81b73e14f68bdf86` | `0x4de4c63ce1f80a56` |
+| 7 | `0x8ee358af56a30d8d` | `0x46ab3c6184048b7c` | `0x0a6164b7e68e80c5` | `0x0c26b85bb03bc831` |
+| 8 | `0xc3458e1cbdb9c471` | `0x46c03d0994d75192` | `0x8f89fc5bde12d230` | `0xd16dc0cf62031898` |
+
+FloatingIslands full detail: density `0x6d842d2878b08ef6`, mesh `0x4b868a3184f08035`, payload `0x2cedf2236788752d`, topology `0xeac17d5e0cb5044a`.
+
+FloatingIslands whole view: density `0x5be4d8cde79b2a76`, mesh `0x96f75041f6861b3a`, payload `0x3700a516cc89d50c`, topology `0x6b99948d6eab4f21`.
+
+FloatingIslands exact queries (9 probes): density/unclamped `0x61daded9c303becb`, detail `0xefcba20c0c70c415`, collision `0x84d37463be9b0573`.
+
+| LOD | Density | Mesh | Payload | Topology |
+|---:|---|---|---|---|
+| 0 | `0xf2524906044ef994` | `0x15b2828701a06591` | `0x4cbbf7ade54321f7` | `0x2c0382f590d69610` |
+| 1 | `0x71b4c8327ad91da7` | `0xfd2280177adb70c9` | `0xc6f695b969ca8573` | `0xb7b026366bc5b627` |
+| 2 | `0x23925de354d86f14` | `0xd4b470b6aae75cab` | `0x38c39feddc72ca0c` | `0x8496f76d94d0e578` |
+| 3 | `0x4cb68a60bc8a5103` | `0x30514ad73d41fd87` | `0x39a209d2ec7695b1` | `0xa2ffa199ba1e1215` |
+| 4 | `0x0e95c8abbcf6fb37` | `0x966b891fbe67794a` | `0xf01627522109d362` | `0xd7bfb2fea0137c0c` |
+| 5 | `0xf444ffed34a1bd20` | `0x7f3073ed3a711113` | `0xad32e4ea4a1b4d50` | `0x6fdba8d6e549193c` |
+| 6 | `0x6a6b4f75b9583ec7` | `0xdbb540e17a46b981` | `0xe2374a66e9d12b22` | `0xd384b7c0c0247982` |
+| 7 | `0x5c4e824aaa7e5f73` | `0x44857e6de8e89645` | `0xa4ac0bf1da59e406` | `0x94f425b0d77004c8` |
+| 8 | `0x8ce5f96cb24bc365` | `0xa1406a9a6dcae02b` | `0x8b5e182d38fe352b` | `0x098f65c1a8cde739` |
+
+## Instrumentation, builds and limits
+
+Removed the L8 phase/stage probes from the normal path. Kept `--profile-lod-work` for per-LOD density sample counts and added `--audit-uniform-block-proofs`; both are off by default. Normal runs do not perform the audit fill-and-check pass or sample-count aggregation. The optional LOD0 MC (1.348 worker-s) and shape compile (215 ms) were counted in L8 and not changed.
+
+No async task or epoch path changed. The L3 FP-contract preamble/self-test, L4 `FLazy`, L7 shared cache, ARCHITECTURE §8.10 two-pass MC/SSE noise/clipmap-streaming invariants, and generator density output remain unchanged.
+
+Clang 19 (`-ffp-contract=off`) and GCC 14 default builds used `-j12`; SHA256s are `0cd3f0ef993ced2c615418c6e2b37b83f57eff6d024d7d1568c30ea51490384a` and `23fe40de558b1b6931469cc5e976a0e4f2ed5fb6c362bc746dcc64a38fa40e08`. Peak build RSS was 901,940 KiB; highest measured runtime RSS was 623,928 KiB. Runs used CPUs 0–11, a 6 GiB address-space limit, normal priority, and the unchanged `powersave` governor. No run exceeded 30 minutes or remained stuck for 15 minutes.
+
+## Failed and retried runs
+
+- The first build wrapper failed because `/usr/bin/time` is absent; direct builds succeeded. One RSS sampling wrapper hung on zombie handling and was interrupted; later measurements used a corrected monitor.
+- Initial proof-audit commands exited 2 because the positional data file and required stream modes were missing. Corrected commands completed. The first broad global interval returned Mixed for all 28,672 blocks and was replaced by the exact lattice-column proof.
+- An early all-step audit found two legacy step-8 uniform candidates whose exact filled-grid signs disagreed; the existing post-fill validator cleared them before skip. The new audit is scoped to the native step-2 proof; step 8 is unchanged.
+- The first Clang retry failed to compile because `SampleGridPoint` was outside its lambda scope; it was corrected to call `DensityAtLattice` directly and rebuilt.
+- The first hash comparison differed because a uniform-tile early return bypassed debug density capture. Step-2 hash runs now refill omitted samples after exercising sparse MC. A separate FloatingIslands mismatch came from changing `>= 0` to `> 0`; the legacy `>= 0` comparison was restored and both compiler hashes then matched.
+
+**Owner note:** LOD1 now fills 95% fewer samples with zero proof violations, and all SurfaceWorld and FloatingIslands hashes match. The GCC W12 comparison against `linux7shared` is toolchain-confounded; GCC-to-GCC controls are flat or faster, while the Clang candidate is faster than the requested baseline.
+
+## Orchestrator review (Claude)
+
+- **Re-run by me, 5 interleaved W12 pairs, L1 view.** Without `--stream-hash` (game-like):
+  whole view L7 1.379/1.485/1.430/1.439/1.449 s vs L9 1.390/1.409/1.401/1.423/1.429 s (median
+  1.439 → 1.409 s, −2.1%); stream wall 1.140 → 1.112 s (−2.5%). With hashing on, the difference is
+  inside noise (1.748 vs 1.744 s), because hashing adds ~0.3 s. The whole-view hash is identical in
+  all runs.
+- **The L8 lever was inflated by L8's own instrumentation.** L8's profile build reported LOD1 at
+  4.06 worker-s; the plain `linux7shared` binary spends 1.21. Per-LOD shares from instrumented builds
+  must be re-checked on a plain build before they're ranked.
+- The "baseline ELF contains GCC and Clang objects" remark is expected: crt/libstdc++ objects always
+  come from GCC. The compiler-matched controls are the right comparison, as Luna did.
+- Proof read: for native SurfaceWorld step-2 tiles the verdict uses exact column extrema over the
+  padded block (cells plus the −1..+9 normal halo) for density `min(z−ground, cap−z)`. Features, edits,
+  mixed strata and Unknown verdicts all fill. The 80,502-block audit found 0 violations.

Standalone/Research/WorldAssemblerM3/Round10/REPORT.md

@@ -0,0 +1,218 @@
+# World assembler S6 / M3 Round 10 — in-game cold-view time
+
+**Result:** the 251 ms staircase was trace sampling cadence, not a scheduler tick. On the staged
+2,578-key SurfaceWorld actor, the default legacy path reached full residency in 17.412 s. Gated
+coarse-first admission reached it in 11.704 s while the walkable ring time stayed at 0.627 s versus
+0.632 s. A 12-mesh / 14 ms startup apply budget did not improve the legacy timeline. The remaining
+floor is on worker-side work supply/admission, not the game-thread apply budget; the trace does not
+isolate why available worker slots stay idle. The 1.57 s aim remains unmet.
+This is null-RHI residency evidence, not rendered enclosure proof.
+
+## 1. Cadence and comparison with S5
+
+`AVoxelWorld::UpdateChunksAroundPosition` emits `streaming_sample` only when at least 0.25 s has
+elapsed since its previous sample. S5’s near-251 ms per-LOD staircase was quantized by that observer;
+it was not a one-LOD-per-tick scheduler throttle. S6 records direct tile-result/apply timestamps and
+per-frame `ProcessPendingChunks` samples, so the completion table below does not depend on that
+sampler.
+
+S5 reported 3.352–6.367 s for its per-LOD residency samples. The Round 9 report did not retain the
+exact BuildHost command line, executable hash, or raw direct-tile trace for that run. S6 uses the
+same staged `DA_Settings` SurfaceWorld plan, 25 cm Core scale, 2,578 desired keys, 12-task host setup,
+and legacy-order controls, but its direct full-set result is 17.412 s. The 250 ms sampling interval
+cannot explain this larger difference. Treat S5’s 3.35–6.37 s values as a different/unidentified
+measurement route, not a matched baseline; S6 preserves the direct command lines and hashes below.
+The Standalone 3.58–3.64 s S5 measurement was CPU-only over 2,553 keys, so it is also not a matched
+BuildHost apply/collision measurement.
+
+## 2. Matched BuildHost actor runs
+
+Fresh sequential processes used the staged owner plan, `CoreVoxelSizeCm=25`, 2,578 desired tiles,
+`-corelimit=12` (10 active task slots in the actor trace), null RHI, a manually ticked `UWorld` with
+a 16 ms step, and a +Y 600 cm/s move beginning at 30 s. There was no overlapping Unreal process or
+build. Full-set time is the actor’s initial desired-set milestone. “LOD0 full” means all 512 visual
+LOD0 keys, separate from the 9/9 collision walkable gate.
+
+| Configuration | Full set ready | Walkable ring 9/9 | Full 512-key LOD0 | Count-cap frames / backlog frames | Visible meshes/frame p95/max | Apply CPU p95/max | `UWorld::Tick` spawn p95/max | `UWorld::Tick` walk p95/max |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| Legacy order, authored 4 / 2 ms budget | 17.412 s | 0.632 s | 2.252 s | 78 / 22 | 4 / 4 | 0.77 / 1.62 ms | 1.406 / 5.059 ms | 1.771 / 29.247 ms |
+| Legacy order, startup boost on (12 / 14 ms) | 17.346 s | 0.611 s | 2.190 s | 0 / 0 | 4 / 6 | 0.70 / 1.49 ms | 1.301 / 5.429 ms | 1.798 / 28.489 ms |
+| Coarse-first after ring gate, authored 4 / 2 ms | **11.704 s** | **0.627 s** | 10.201 s | 118 / 48 | 4 / 4 | 0.82 / 1.44 ms | 1.396 / 5.027 ms | 1.911 / 28.276 ms |
+
+Coarse-first shortened the full desired-set tail by 5.708 s (32.8%) without a walkable-gate
+regression. It did not make all near detail ready sooner: full LOD0 moved from 2.252 s to 10.201 s.
+The option therefore stays opt-in pending a rendered view/enclosure check. The apply boost removed
+cap frames but changed full-set time by only 66 ms (0.4%), so it also stays opt-in. Normal play
+continues to use the authored 4 visible-mesh / 2 ms limit. These are `UWorld::Tick` CPU samples in a
+manual null-RHI harness, not full rendered frame times. Walk p95 stayed below 2 ms, but the observed
+~28–29 ms maxima remain and were not isolated to a single subsystem. Per-frame apply maxima were
+1.62 ms legacy and 1.44 ms gated coarse-first.
+
+### Per-LOD cold set
+
+Each pair is **legacy → gated coarse-first**, from direct tile completion events up to the initial
+desired-set milestone. Queue values are cumulative tile-seconds, not elapsed wall seconds. The
+initial set contains 2,578 tile results; empty results are included in the result count and apply
+time.
+
+| LOD | Last tile apply (s) | Worker task (s) | Worker queue (tile-s) | Result queue (tile-s) | GT apply (ms) / results |
+|---:|---:|---:|---:|---:|---:|
+| 0 | 2.252 → 10.201 | 3.39 → 3.39 | 0.028 → 0.033 | 5.94 → 5.87 | 27.9 → 35.0 / 512 |
+| 1 | 4.785 → 11.765 | 3.21 → 3.05 | 0.007 → 0.006 | 4.43 → 4.79 | 17.0 → 20.4 / 448 |
+| 2 | 6.609 → 8.567 | 0.70 → 0.71 | 0.012 → 0.006 | 4.77 → 4.90 | 10.9 → 13.0 / 320 |
+| 3 | 8.162 → 7.460 | 1.81 → 1.78 | 0.005 → 0.005 | 2.86 → 3.07 | 10.5 → 11.8 / 272 |
+| 4 | 10.317 → 6.530 | 6.02 → 6.08 | 0.004 → 0.006 | 2.16 → 2.62 | 26.5 → 24.9 / 272 |
+| 5 | 11.494 → 5.182 | 1.42 → 1.42 | 0.003 → 0.003 | 2.20 → 2.40 | 18.4 → 15.9 / 208 |
+| 6 | 12.483 → 4.438 | 1.85 → 1.90 | 0.002 → 0.002 | 1.58 → 1.65 | 15.2 → 12.8 / 144 |
+| 7 | 13.198 → 3.852 | 1.74 → 1.75 | 0.001 → 0.001 | 0.88 → 1.02 | 16.7 → 13.5 / 96 |
+| 8 | 17.476 → 3.432 | 17.50 → 19.29 | 0.005 → 0.465 | 2.59 → 2.62 | 95.0 → 87.0 / 306 |
+
+Per-frame visible mesh counts and the largest per-LOD apply sample were:
+
+| LOD | Visible meshes/frame p95/max, legacy → coarse | Max LOD apply/frame, legacy → coarse |
+|---:|---:|---:|
+| 0 | 2 / 4 → 3 / 4 | 0.762 → 0.934 ms |
+| 1 | 1 / 4 → 1 / 4 | 0.630 → 0.809 ms |
+| 2 | 0 / 4 → 1 / 4 | 0.533 → 0.639 ms |
+| 3 | 0 / 4 → 1 / 4 | 0.515 → 0.570 ms |
+| 4 | 2 / 4 → 3 / 4 | 0.605 → 1.354 ms |
+| 5 | 1 / 3 → 2 / 4 | 1.272 → 0.742 ms |
+| 6 | 0 / 4 → 1 / 4 | 0.687 → 0.708 ms |
+| 7 | 0 / 4 → 0 / 4 | 0.974 → 0.732 ms |
+| 8 | 2 / 4 → 3 / 4 | 1.625 → 1.439 ms |
+
+The 10-task-slot slack estimate was 132.1 slot-seconds on legacy order and 73.3 on coarse-first,
+computed as ten slots × (first request to full-set ready) minus measured worker-task seconds. The
+shared pool averaged 3.27 / 4.21 running workers on frames with estimated pending results; one
+legacy backlog frame had no running worker, versus none in the coarse-first run. Idle worker time
+and apply-cap frames are shared-pool/world properties, so a per-LOD split would double-count them.
+Legacy used 37.64 worker-seconds and coarse-first 39.36; pre-start worker-queue wait was only
+0.067 / 0.527 tile-seconds. Result-queue wait summed to 27.41 / 28.94 tile-seconds. Game-thread
+tile-apply time was about 0.24 / 0.23 seconds for the cold set. The boost run had no apply-cap or
+result-backlog frames and still took 17.346 s. Thus the apply cap is not the end-to-end floor. The
+remaining floor is worker-side work supply/admission; the trace does not isolate why available
+worker slots stay idle or identify a safe single worker-side change for this round.
+
+Collision is currently required only on the LOD0 path. The trace captured 60 body-update events in
+each cold run; 60 of 125 collision-desired entries were ready by the full-set milestone, while
+non-required/empty entries were classified separately. RealtimeMesh submit-to-body-update latency
+(not isolated Chaos CPU cooking) was legacy p50/p95/max 17.02 / 17.89 / 18.04 ms, boost 16.80 /
+17.51 / 17.70 ms, and coarse-first 17.08 / 18.01 / 18.30 ms. The nine required ring tiles were ready
+at the gate times above. LOD1–8 had no collision-ready events in this trace.
+
+## 3. Shared change and standalone crossing instrument
+
+`voxel.StreamingCoarseFirst=1` now starts far-level admissions only after all nine required
+walkable-ring collision gates are ready. `voxel.StreamingDynamicNearReserve=1` keeps the authored
+near reserve while moving or before that gate; after a stationary gate it lets coarse work use the
+reserved slots. Both are explicit, default-off controls. `voxel.StreamingStartupApplyBoost=1` allows
+12 visible-mesh applies / 14 ms during the initial desired-set and walkable-ring phase, with a 30 s
+ceiling; zero keeps the authored budget. It is not preemptive within one apply, so it remains opt-in.
+This behavior is in shared `AVoxelWorld::UpdateChunksAroundPosition` / `ProcessPendingChunks` and
+does not change density, tile output, or collision policy.
+
+The standalone 60 m/s flight instrument now counts forward +Y chunk crossings using the actual
+center delta, including multi-chunk jumps. The valid viewer route completed 250/250 center samples,
+with 226 center updates and max forward delta +2. It reports `crossing_deltas=forward-+Y`,
+resident 2,553/2,553 and no missing tiles. Latency still **fails**: nearest-ready p50/p95/max was
+9.087 / 20.594 / 128.785 ms and maximum crossing wall time 42.931 s. The earlier
+`--stream-benchmark` and `--stream-pipeline` invocations emitted no Flight markers; only the viewer
+route is used for this result.
+
+## 4. Hashes, regression checks and async audit
+
+Standalone W1/W8/W16 fresh processes produced identical full-world and all nine per-LOD hashes;
+all match S5. Full world identity: density `c10697a8f48380c7`, mesh `430d2be2bdd8b988`, payload
+`b7b33e14092225c9`, topology `c5c46d66606a819e`.
+
+- Core-off legacy at 12.5 cm: **PASS**, `VOXELFORGE_CORE_OFF_LEGACY_PASS`.
+- M2 V1 and V2: **PASS**, five fixtures plus same-LOD border for each.
+- SurfaceWorld and FloatingIslands BuildHost at 25 cm: **PASS**. FloatingIslands W1/W8/W16
+  matched Standalone; the final Standalone W1/W8/W16 matrix also matched across all nine LODs and S5.
+- S4 cap census/agreement and ray coverage: **PASS**; 551 requested/emitted cap bands, 1,584/1,584
+  coverage rays, 128-point cap agreement max 0.0504 cm against 2 cm tolerance, negative control
+  detected.
+- S3 ground and S4 LOD7/8 ground agreement: **PASS**; max ground delta 0.0427 cm, cross-LOD 0.0 cm,
+  and the negative control was detected.
+- Water remains fixed for the season; player carve/fill stays unrestricted.
+
+Diff audit: `GenerationEpoch` is carried and stale epochs are rejected; the four result queues remain
+`EQueueMode::Mpsc`; `EndPlay` sets shutdown, waits for active work and drains the queues; workers
+check `bShuttingDown`; `ModsLock` behavior is unchanged; all UObject/RealtimeMesh component creation
+and mutation stays on the game thread. No density-sign or determinism path changed. The added C++
+comments are French and English. No generated header, `Binaries/`, or `Intermediate/` source edits.
+
+## 5. Exact commands, binaries and run ledger
+
+BuildHost actor runs used `E:\Program Files\Epic Games\UE_5.7\Engine\Binaries\Win64\UnrealEditor-Cmd.exe`
+with `-nullrhi -unattended -corelimit=12 -run=VoxelForgeExplore -seed=0 -archetype=TunnelNetwork
+-coreworldtest=1 -corevoxelsizecm=25 -settingsref=/Game/VoxelForge/DA_Settings.DA_Settings
+-coreworldstreamtrace=1 -voxel.TestMove=1 -voxel.TestMoveSpeedCmPerSecond=600
+-voxel.TestMoveStartSeconds=30 -voxel.TestMoveDirection=0,1,0
+-voxel.StartupTraceUntilEndPlay=1 -voxel.CollisionGate=0`. The exact expanded `LogInit: Command Line:`
+including project, DDC, trace and output paths is preserved verbatim in each [legacy run](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_legacy_order_trace.stdout.log),
+[boost run](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_1_legacy_order_trace.stdout.log),
+and [gated coarse run](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_coarse_first_trace.stdout.log).
+Their CVar overrides were respectively:
+
+| Run | `StreamingCoarseFirst` | `StreamingDynamicNearReserve` | `StreamingStartupApplyBoost` |
+|---|---:|---:|---:|
+| Legacy negative control | 0 | 0 | 0 |
+| Apply-budget A/B | 0 | 0 | 1 |
+| Gated coarse-first | 1 | 1 | 0 |
+
+Standalone 60 m/s exact command (also in [commands.txt](../../../../Saved/BuildHost/S6/standalone/commands.txt)):
+
+```text
+Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-prototype --force-generate --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --test-flight-crossings=250 --flight-speed-mps=60 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+| Executable / module | SHA-256 |
+|---|---|
+| BuildHost `UnrealEditor-Cmd.exe` | `ECCE9996191F7F7E69B3D104EECDD0E678AE69176FDCCD79828C3E75A0654D6D` |
+| BuildHost `UnrealEditor-VoxelForge.dll` | `1C083446ED360FBD798EAE4C4D3CA9E5994E906770B5017A51418BFEF46C30FA` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `54259552340FE81EA05640C622E9E5E5C0AC68C95F87DC718326D25EF133B2AC` |
+| Standalone `VoxelForgeCoreStandalone.exe` | `1F445760AFDE264E2F28F8F2FB4CB68DBD0C8988AACD5A493B065E74C1827529` |
+
+BuildHost UBT passed twice at 12 actions / Normal priority. `& .\Standalone\Build.ps1 -Target All
+-CompileWorkers 12 -BuildPriority Normal` passed. Existing vswhere/C4838 warnings did not fail the
+Standalone build. The S6 hash and 60 m/s logs are in [Saved/BuildHost/S6/standalone](../../../../Saved/BuildHost/S6/standalone/).
+
+Failed/retried attempts, including setup failures:
+
+- An earlier full actor attempt reached its 600 s timeout in the Standalone-reference preamble; it
+  left a partial trace. A first trace-only command omitted its required startup-trace output path
+  and exited before the actor run; the helper now makes `StreamingTraceOnly` imply trace output.
+- Two fresh-shell memory preflights lacked the local `Add-Type` helper and stopped before launching
+  Unreal. The corrected `GlobalMemoryStatusEx` preflight ran before later launches.
+- Early coarse-first attempts did not parse the requested CVar in headless `BeginPlay`; trace values
+  showed legacy LOD0-first order. Explicit CVar parsing fixed the A/B. An ungated coarse-first run
+  then delayed the walkable gate to 1.653 s; admission was changed to wait for 9/9 and rerun.
+- FloatingIslands at 25 cm hit its 120 s test timeout; the bounded 600 s retry passed in 192 s.
+- The first `--stream-benchmark` and `--stream-pipeline` sprint commands emitted no Flight markers.
+  The corrected viewer command above produced valid crossing deltas, with the latency failure
+  reported rather than hidden.
+- Unsupported `-RunName`, a fresh-shell type reuse, and one PowerShell metric-parser expression
+  failed before/after measurement without changing an Unreal run. The corrected command/parser
+  produced the data above.
+
+Every Unreal launch was sequential, with more than 17 GiB free memory at the final launch checks;
+actor-harness peak was about 3.5 GiB and all measured processes stayed under 8 GiB. No run returned
+`0xC0000142`. Crash audit found no new UECC folder; the only folder is the pre-existing
+`UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000` dated 2026-09-17. Test stdout and JSONL traces
+remain under `Saved/BuildHost/...`; none were copied into `Research/`.
+
+## 6. Files and compile spots
+
+No new C++ source file was added. Modified source files and likely compile spots:
+
+- `Source/VoxelForge/Private/VoxelWorld.cpp`, `Source/VoxelForge/Public/VoxelWorld.h`,
+  `Source/VoxelForge/Private/VoxelStartupTrace.cpp`,
+  `Source/VoxelForge/Public/VoxelStartupTrace.h` — VoxelForge runtime module; BuildHost UBT.
+- `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp` — editor module; BuildHost UBT.
+- `Standalone/Source/StandaloneViewer.cpp` — `Standalone/Build.ps1 -Target All`.
+- `Tools/TestVoxelForgeCoreWorldHost.ps1` — harness argument/default changes; no C++ compile.
+- `CODEMAP.md` §3, `ARCHITECTURE.md` §8.27, this report, and
+  `Standalone/Research/OwnerShapeWorld/gpu_field_port/LUNA_DIALOGUE.md` — documentation.
+
+No owner file or asset was touched; no commit, push or stash was made.

Standalone/Research/WorldAssemblerM3/Round11/REPORT.md

@@ -0,0 +1,261 @@
+# World assembler S7 / M3 Round 11 — scheduler admission and RMC review
+
+**Result:** the cold full set fell from 17.595 s on the S7 legacy control to 7.762 s with
+the shared scheduler change. The 0.581 s walkable ring and 1.437 s full LOD0 meet the
+0.63 s and 2.25 s targets. The 7.76 s full set still misses the roughly 4.2 s
+worker-seconds / 10-slots estimate. RMC section-update batching was reviewed but not
+implemented: measured game-thread tile apply is only about 0.24 s for the whole set, and
+the null-RHI run cannot measure render-proxy cost.
+
+## 1. What the trace says
+
+`UpdateChunksAroundPosition` runs each world tick. For the 2,578-key spawn, the per-frame
+trace found the decline after that call, in admission accounting:
+
+| Admission evidence | Count / example | Meaning |
+|---|---:|---|
+| Legacy near reserve after no LOD0 keys remained, with LOD1+ still missing | 876 frames | The four reserved near slots stayed unused while coarse keys were eligible. |
+| Those frames with a positive finished-result estimate | 806 / 877 | `PendingTiles` included completed results waiting for game-thread apply. |
+| Representative legacy frame | t=3.292474 s: active=4, completed estimate=2, cap occupancy=6/10 | The old pending-result count hit the coarse cap although only four tasks were queued/running. |
+| Dynamic admission passes before the initial full-set milestone | 409 | Ten ended with missing keys and a post-pass sample below the 10-task count. All ten recorded a submission stop at cap 10. |
+| Declines in those ten dynamic passes | 0 reserve, 0 all-loaded, 0 walkable-gate failure, 0 inner `LoadTile` rejection | A worker could finish between the full-cap stop and the end-of-pass sample, leaving occupancy at 9/10; the stop fields show that the pass had hit cap 10. |
+
+The two old blockers were independent: the near reserve capped coarse admission at six,
+and completed-but-unapplied results occupied the old `PendingTiles` cap. The scheduler now
+counts `ActiveTaskCount` (queued and running tasks); `PendingTiles` remains through apply
+for duplicate suppression and result bookkeeping. The default `voxel.StreamingDynamicNearReserve=1`
+keeps the near reserve while moving or before the stationary walkable gate, then releases
+it to coarse work. `voxel.StreamingLegacyPendingResultCap=1` and the harness legacy mode
+restore both old behaviors for the negative control.
+
+Across the complete 45 s trace (including movement from t=30 s), the end-of-update records
+contained both missing keys and observed capacity below 10 in 1,236 legacy and 280 dynamic
+frames. Per-LOD reason codes classify the legacy set as reserve in 1,226 frames and inner
+loader return in 10. The dynamic trace has reserve in 259, full-cap stop in 12 and inner
+loader return in 11; codes can overlap when different LODs hit different rules in one
+update. No free-capacity frame had an unclassified missing LOD. The four additional legacy
+`scheduler_skip` records with missing keys were region-compile gates, described below.
+In `declined_rule_by_lod`, codes are 1=full task cap, 2=near reserve, 3=all-loaded latch,
+4=inner `LoadTile`/`LoadCoreTile` return, and 5=work still missing with apparent capacity.
+Dynamic code-2 frames include the intentional near reserve held while moving; the trace
+keeps this distinct from a worker-pool or result-accounting stall.
+
+Admission itself is no longer the measured source of idle slots on the dynamic spawn: each
+pass submitted work or recorded a stop at the 10-task cap. The ten end-of-pass samples that
+showed missing keys and occupancy 9/10 had already recorded that full-cap stop; a worker
+finished before the trace snapshot. Cumulative task intervals show
+5.63 busy-worker equivalents over first request to ready, with eight sustained overlapping
+tile tasks; one zero-duration endpoint tie counts nine. This does not identify whether the
+remaining gap comes from UE task-pool dispatch or work within a tile. Boundary samples of
+`running_workers` alias short task bursts and are not a time average.
+
+The same 45 s actor run also includes a +Y move beginning at t=30 s. On that moving path,
+`LoadCoreTile`'s `bCoreRegionCompilePending` early return (`VoxelWorld.cpp:12224`) is a
+separate gate. The trace recorded four top-level region-compile skips in the legacy control
+with 116–187 desired keys missing and only 0–1 active tasks. It also recorded 10 legacy and
+11 dynamic admission passes with inner load declines; every one had
+`core_region_compile_pending=1`, zero submissions, and 108–190 legacy or 92–144 dynamic tile
+attempts.
+This explains idle slots during those region rebuilds, but it occurs after the cold initial
+set and is separate from the reserve/result-count fix. The initial 20 `core_not_ready`
+skips had zero missing desired keys; no all-loaded latch skip had missing work.
+
+## 2. Matched BuildHost result
+
+Fresh sequential null-RHI processes used the staged owner `SurfaceWorld` plan, seed 0,
+25 cm Core scale, 2,578 desired keys, 10 actor task slots, a manually ticked world at 16 ms,
+and a +Y 600 cm/s move beginning at 30 s. Apply boost and coarse-first were off in both S7
+runs. “Idle slot-s” is `10 × (first request to full ready) − cumulative worker task time`;
+busy equivalents use the same interval. S6's 3.27 average was sampled only on frames with
+pending results and is not directly comparable to the integrated S7 value.
+
+| Run | Full set | Walkable 9/9 ring | Full LOD0 (512) | Worker task-s | Integrated busy equivalents | Idle slot-s | Tick spawn p95/max | Tick walk p95/max |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| S6 legacy reference | 17.412 s | 0.632 s | 2.252 s | 37.64 | 3.27 sampled on pending-result frames | 132.1 | 1.406 / 5.059 ms | 1.771 / 29.247 ms |
+| S7 old-path negative control | 17.527 s | 0.650 s | 2.281 s | 37.696 | 2.208 | 133.012 | 1.437 / 5.286 ms | 1.957 / 29.244 ms |
+| S7 dynamic reserve + active-task cap | **7.780 s** | **0.581 s** | **1.439 s** | 41.364 | **5.634** | **32.056** | 2.262 / 5.230 ms | 2.512 / 28.893 ms |
+
+The negative control reproduces S6 legacy within 0.7% in full-set time and 0.2% in worker
+task-seconds. Dynamic admission cuts full-set time by 55.3%, reduces idle slots by about
+76% against S6, and meets both near-work targets. It does not meet the roughly 4.14 s
+`41.364 / 10` estimate. Measured worker task time rose about 9.7% versus the S7 negative
+control (about 16.04 ms per initial tile versus 14.62 ms). Geometry hashes did not change
+and the density/mesh recipe was untouched; the trace measures task elapsed time, not CPU
+cycles, so it cannot separate contention from other elapsed-time variation. This is a
+measured tile-cost increase to watch in a rendered/profiled run, not evidence of a content
+quality change.
+
+The largest walk `UWorld::Tick` sample remains about 29 ms. The trace wraps aggregate
+`TestWorld->Tick()` at `VoxelForgeExploreCommandlet.cpp:17495–17501`; it has no subsystem
+marker at the maximum, so the owner cannot be named from this trace. Null RHI also means
+these are not rendered frame times.
+
+## 3. RealtimeMeshComponent review
+
+VoxelForge creates plain `FRealtimeMeshStreamSet` data in `BuildTileStreamSet`
+(`Source/VoxelForge/Private/VoxelWorld.cpp:616`, called from worker paths at 12441 and
+12876). Component mutation stays on the game thread in `ApplyMeshToTile` (13064): each tile
+removes and recreates one section group and sets its material slots (13273–13288). Ground
+and cap are material/polygroup sections in that tile group; the world uses clipmap tiles,
+not an RMC multi-LOD chain. The whole cold set's measured game-thread apply was about
+0.24 s in S6 (roughly 3% of the S7 7.76 s wall time).
+
+Ranked opportunities, with this round's evidence:
+
+1. **Batch a tile's RMC writes.** RMC's `Public/Data/RealtimeMeshUpdateBuilder.h:390–406`
+   documents grouping mesh, LOD, section-group, section and collision updates behind one
+   write lock and proxy publish; `Private/Data/RealtimeMeshUpdateBuilder.cpp:222` commits,
+   with render work queued at 64–67. This could trim game-thread update overhead, but the
+   measured apply ceiling is only ~0.24 s for 2,578 tiles. It is not the cold-set floor.
+2. **Measure fast collision cooking.** RMC `Public/Core/RealtimeMeshCollision.h:32–55`
+   exposes async cook, fast cook, complex-as-simple, normal flipping, deformable collision
+   and mesh merging. The current BuildHost trace reports async=1, complex-as-simple=1,
+   fast-cook=0, merge=0; async cooking is dispatched in
+   `Private/RealtimeMeshManaged.cpp:695–707`. Cook CPU is not isolated by the existing
+   submit-to-body-update measurement, and changing cook mode could affect collision
+   quality, so defer until collision timing and walkability are audited together.
+3. **Batch across tiles / share mesh components.** This might reduce component and proxy
+   overhead, but RMC builder commits target a mesh and VoxelForge's per-tile collision,
+   unload and transition ownership would change. Larger risk than the measured apply cost.
+4. **Use RMC's LOD/section-group structure more broadly.** RMC has explicit LOD and section
+   group update operations (builder header above); VoxelForge currently creates one group
+   per tile and changes clipmap tiles between LODs. A multi-LOD mesh would be an architectural
+   change, with no null-RHI timing evidence for a payoff.
+5. **Render resource/proxy work.** `Private/RenderProxy/RealtimeMeshGPUBuffer.cpp:49–60`
+   creates resources asynchronously only when the RHI supports multithreaded resources;
+   otherwise it falls back to the render thread. RMC's proxy publish path is in the builder
+   implementation above. Null RHI cannot measure either path, so no change was made.
+
+No RMC files were modified. Its source was read only at
+`E:\Projet Unreal\VoxelM\Plugins\RealtimeMeshComponent`.
+
+## 4. Quality and determinism
+
+- Standalone W1/W8/W16 produce identical full and LOD0–8 hashes: density
+  `c10697a8f48380c7`, mesh `430d2be2bdd8b988`, payload `b7b33e14092225c9`, topology
+  `c5c46d66606a819e`. The parser's first ad-hoc comparison was corrected; a direct per-LOD
+  comparison shows all nine levels equal.
+- BuildHost SurfaceWorld at 25 cm passed the full actor/collision/anchor/carve check and
+  W1/W8/W16 matrix. Hashes: density `0cd2a1a4152ee4aa`, mesh `80a5b054b904b1a2`, payload
+  `bf2f1b40dff38acc`, topology `56074198682d5e18`.
+- Core-off legacy at 12.5 cm passed. M2 V1 and V2 each passed five fixtures plus same-LOD
+  border checks. FloatingIslands at 25 cm passed W1/W8/W16, fixed water, edits, collision,
+  LOD0 and LOD1.
+- S3 ground / S4 LOD7–8 agreement passed: maximum ground delta 0.0427 cm, cross-LOD delta
+  0.0 cm, and the 100 cm datum-offset negative control was detected.
+- S4 Standalone far-cap audit passed: 385/385 requested cap bands emitted; 128 agreement
+  points had 0.0504 cm maximum error against 2 cm tolerance; the 100 cm bad-datum control
+  was detected; 2,520/2,520 rays covered all 35 view points.
+- Three Standalone spawn captures are under `Saved/BuildHost/S7/captures/`; each is
+  4,097,178 bytes. Sampled terrain surfaces show no obvious opening. The capture window
+  reported hidden/occluded, so these back-buffer submissions are not an owner-visible
+  enclosure sign-off. The standalone does not mirror the shared Unreal actor scheduler.
+  [Frame 00](../../../../Saved/BuildHost/S7/captures/s7_spawn_view_00.png),
+  [frame 01](../../../../Saved/BuildHost/S7/captures/s7_spawn_view_01.png), and
+  [frame 02](../../../../Saved/BuildHost/S7/captures/s7_spawn_view_02.png).
+- Scheduler changes did not alter tile output hashes, so the recipe/version is unchanged.
+  Water remains fixed for the season; player carve/fill remains unrestricted.
+
+## 5. Build, commands and run record
+
+BuildHost compilation passed with 12 actions and normal priority:
+
+```powershell
+& '.\Tools\BuildVoxelForgeCoreHost.ps1' -MaxParallelActions 12 -TimeoutSeconds 900
+```
+
+The first build attempt failed on duplicate `TraceNow` declarations (`C2374` / `C2086`); I
+removed the duplicate and rebuilt successfully. The final build's async-safety checks passed.
+The standalone full build passed:
+
+```powershell
+& '.\Standalone\Build.ps1' -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+It warned that `vswhere.exe` was not recognized and reported existing C4838 conversions in
+`VoxelStrateManager.cpp:3974–3975`; it still completed successfully.
+
+BuildHost quality commands (all passed):
+
+```powershell
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+The final extra trace fields only report Core readiness/region-compile state; they do not
+change tile generation. After adding them I rebuilt and reran both matched actor modes.
+
+Matched BuildHost actor commands:
+
+```powershell
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Legacy -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+& '.\Tools\TestVoxelForgeCoreWorldHost.ps1' -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+Standalone W1/W8/W16 command template (substitute `1`, `8`, `16`; each was a fresh process):
+
+```powershell
+Standalone\bin\VoxelForgeCoreStandalone.exe --workers=1 --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+Standalone S4 audit command:
+
+```powershell
+Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-audit --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+The first capture attempt added `--stream-benchmark` to the viewer capture command. It exited
+0 but generated no PNG because the benchmark path exits before the viewer capture loop. The
+corrected command was:
+
+```powershell
+Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-prototype --force-generate --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60 --capture-spawn-sequence-prefix=E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\S7\captures\s7_spawn_view --quit-after-spawn-captures
+```
+
+The three capture outputs and standalone logs are under `Saved/BuildHost/S7/`. BuildHost
+stdout and JSONL traces are under
+`Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/`; the
+expanded Unreal command lines are preserved in those stdout logs: [legacy stdout](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_legacy_order_nearreserve_legacy_trace.stdout.log),
+[legacy JSONL](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_legacy_order_nearreserve_legacy_trace.trace.jsonl),
+[dynamic stdout](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_legacy_order_nearreserve_dynamic_trace.stdout.log),
+and [dynamic JSONL](../../../../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_legacy_order_nearreserve_dynamic_trace.trace.jsonl). The legacy/dynamic pair
+used the wrapper commands above, staged `DA_Settings`, `-nullrhi -unattended -nop4
+-nosplash -NoSound -corelimit=12 -run=VoxelForgeExplore -seed=0 -archetype=TunnelNetwork
+-coreworldtest=1 -corevoxelsizecm=25 -settingsref=/Game/VoxelForge/DA_Settings.DA_Settings
+-coreworldstreamtrace=1 -voxel.TestMove=1 -voxel.TestMoveSpeedCmPerSecond=600
+-voxel.TestMoveStartSeconds=30 -voxel.TestMoveDirection=0,1,0
+-voxel.StartupTraceUntilEndPlay=1 -voxel.CollisionGate=0`, and the recorded mode CVars.
+
+SHA-256 of the executables/modules used for these runs:
+
+| Binary | SHA-256 |
+|---|---|
+| UE 5.7 `UnrealEditor-Cmd.exe` | `ECCE9996191F7F7E69B3D104EECDD0E678AE69176FDCCD79828C3E75A0654D6D` |
+| BuildHost `UnrealEditor-VoxelForge.dll` | `29CFC3AB0BDF0B6048029660160D38F8AC3E9FF59ED057BD06D4CA42C3FFBBD2` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `54259552340FE81EA05640C622E9E5E5C0AC68C95F87DC718326D25EF133B2AC` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `5FF5FCF82EC59A61319CBF979EC9A7BA081971B4D35088082BBF7A81C4C4794D` |
+| `Standalone/bin/VoxelForgeCoreStandalone.exe` | `0F1610730D9BC038E9E60B5ECBF84BA8AD562748E2737F7C1C288F8CE0FE0CED` |
+
+All runs were sequential at normal priority, with at most 12 build/Standalone workers;
+BuildHost tests used the harness's 12-core limit. Free memory was at least 17.4 GB before
+each actor launch; the largest BuildHost quality process stayed below 3.58 GB (the final A/B
+actors stayed below 3.53 GB; Standalone capture below 1.14 GB). No process exceeded 8 GB.
+The WMI memory query was denied, so preflight used `GlobalMemoryStatusEx`. No new `UECC-*`
+folder or `0xC0000142` occurred; the
+only crash directory is the pre-existing 2026-09-17 `UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000`.
+
+Async diff audit: `GenerationEpoch` still rejects stale work; the result queues remain
+`EQueueMode::Mpsc`; `EndPlay` sets shutdown, waits for tasks and drains queues; workers check
+`bShuttingDown`; `ModsLock` is unchanged; UObject and RMC component mutation remains on the
+game thread. No generated header, `Binaries/`, or `Intermediate/` source was edited. No new
+source file was added. Modified compile spots are `Source/VoxelForge/Private/VoxelWorld.cpp`
+(CVar setup, admission accounting, task lifetime accounting and trace) and
+`Source/VoxelForge/Public/VoxelWorld.h` (scheduler/task bookkeeping comments and declarations);
+the expected compile target is the VoxelForge runtime module for Win64 Development in the
+BuildHost. `Tools/TestVoxelForgeCoreWorldHost.ps1` changed only the harness controls.
+
+No owner project/editor or asset was opened, built or edited. RealtimeMeshComponent was
+read-only; no external source was changed. No commit, push or stash was made.

Standalone/Research/WorldAssemblerM3/Round12/REPORT.md

@@ -0,0 +1,233 @@
+# World assembler S8 / M3 Round 12 — moving region admission and bounded results
+
+**Result:** the S7 region-pending stop is removed for independent tiles. At 6 m/s, the matched
+negative control logged 11 global admission skips; the new mode logged none and admitted 110
+independent tiles during those windows. All 11 changed support centers had a ready 9/9 walkable
+ring. This did not materially change overall moving worker occupancy: about 110 of 150 moving
+slot-seconds remained idle. A 60 m/s teleport run admitted unrelated tiles too, but most centers
+still outran their walkable ring.
+
+The result queue is now separately bounded at 256 queued results + admitted tile tasks + held
+prequeue results. Under one-result-per-frame apply with a 60 m/s run and 400 m teleport, the tracked
+result payload peak was 76.2 MB; the uncapped control reached 125.1 MB. Spawn remains about 7.7 s,
+not the roughly 4.1 s ideal from 41 worker-seconds / 10 slots. The timeline shows a broad LOD8 tail,
+not one abnormally long tile. No safe low-cost spawn fix was supported by this measurement.
+
+## 1. Region gate measurement and change
+
+`BuildCoreDesiredTiles` asks for region pages when the desired tile center changes or its initial
+desired region set is established. The old `bCoreRegionCompilePending` path stopped the whole Core
+submission pass. The new default `voxel.CoreRegionConcurrentAdmission=1` continues through
+`LoadCoreTile` and refuses only keys in `PendingCoreRegionTileSet` or
+`CoreRegionCompileTilesInFlight`. `voxel.CoreRegionConcurrentAdmission=0` restores the old global
+gate as the negative control. Core tile arithmetic and recipes are unchanged.
+
+Region pages are constructed away from the lookup map and published under `tileRegionMutex` as
+immutable shared owners. `generateTile` copies the matching `shared_ptr` while holding the map's
+shared lock, then keeps it for the complete read. Map eviction cannot free a page while an already
+running tile task holds it. The actor's shared `WorldLock` prevents edits/resets from mutating the
+Core world while readers or a region compile are active.
+
+Matched fresh BuildHost processes used the staged owner `SurfaceWorld` settings, seed 0, 25 cm Core
+scale, 2,578-key desired set, Legacy order, Dynamic near reserve, apply boost 0, 10 task slots,
+Normal priority, `-corelimit=12`, and a +Y move starting at 30 s. Both modes used backlog cap 256.
+
+| Moving 6 m/s | Region CVar 0 | Region CVar 1 |
+|---|---:|---:|
+| Region requests / completions | 11 / 11 | 11 / 11 |
+| Reasons | 1 initial set, 10 center moves | 1 initial set, 10 center moves |
+| Whole-scheduler region skips | 11 | 0 |
+| Pending interval sum / worst interval | 426.3 / 40.9 ms | 433.1 / 41.4 ms |
+| Compile wall sum / slowest compile | 10.8 / 2.5 ms | 10.5 / 2.4 ms |
+| Independent tile submissions / dependent declines | 0 / 0 | 110 / 0 |
+| Changed support centers ready 9/9 at the change | 11 / 11 | 11 / 11 |
+| Walkable lag at those centers | 0 ms | 0 ms |
+| Moving frames with an LOD0 key missing | 173 | 163 |
+| Moving worker busy / idle slot-seconds (15 s × 10 slots) | 39.7 / 110.3 s | 39.9 / 110.1 s |
+
+The pending interval is the request-to-completion time recorded for each compile; it is not all
+global blocking in the new mode. The compiler's measured wall time summed to only about 11 ms over
+the run. The default mode removes the full-pass skip and submits keys independent of the entering
+region. Its total worker supply remains low: moving work averages about 2.66 of 10 busy workers.
+Each of the 11 negative-control whole-pass skips had 92–144 desired keys missing and zero active
+tile tasks. The CVar1 run has no corresponding global skip.
+Per-LOD counts added to `scheduler_skip` make the LOD0-missing-frame count include the 6 globally
+gated frames that had LOD0 work missing in the negative control.
+
+The fast trace used 60 m/s and teleported 400 m after 2 s of the move. It recorded 113 region
+requests (initial set plus 112 center moves), all completed, with 381.4 ms aggregate compile wall
+time (30.8 ms worst) and 4,523.7 ms accumulated pending interval (69.9 ms worst). Concurrent
+admission recorded 782 independent submissions, 983 dependent-key declines, and zero global
+region skips. Of 113 changing support centers, 8 were already 9/9 ready on the change event, 3
+became ready before the next center change, and 102 did not reach 9/9 before leaving or test end.
+The worst resolved lag was 106.3 ms. LOD0 was missing on 480 of 488 moving scheduler frames. This
+speed is beyond what the current collision ring can follow.
+
+## 2. Spawn, worker timeline and tail
+
+| Fresh owner-plan spawn | S7 Dynamic reference | Round12 region CVar 0 | Round12 region CVar 1 |
+|---|---:|---:|---:|
+| Full set (2,578 keys, from BeginPlay) | 7.780 s | 7.820 s | 7.706 s |
+| Walkable 9/9 ring | 0.581 s | 0.583 s | 0.566 s |
+| Full LOD0 (512 tiles) | 1.439 s | 1.442 s | 1.424 s |
+| Worker task-seconds to full set | 41.364 | 41.966 | 41.229 |
+| Integrated busy workers / 10 (first request → ready) | 5.63 | 5.63 | 5.60 |
+| Idle slot-seconds (same interval) | 32.056 | 32.63 | 32.37 |
+| `UWorld::Tick` spawn p95 / max | 2.262 / 5.230 ms | 2.387 / 5.273 ms | 2.359 / 5.383 ms |
+| `UWorld::Tick` move p95 / max | 2.512 / 28.893 ms | 2.472 / 28.257 ms | 2.377 / 28.967 ms |
+
+The CVar A/B changes the spawn full-set time by only 0.11 s; the region issue occurs during the
+later move. The Round12 CVar1 first-request-to-ready span was 7.360 s with 41.229 worker-seconds.
+In one-second bins its worker task time was 3.94, 3.91, 3.34, 6.51, 5.73, 7.75 and 7.81 worker-
+seconds, followed by 2.24 worker-seconds in the final 0.36 s. Average occupancy was 5.60/10 and
+idle capacity was 32.37 slot-seconds. No sustained ten-worker plateau appears. That is about
+16.0 ms of elapsed task time per initial tile, similar to S7's 16.04 ms and still about 9% above
+the S7 old-path control's 14.62 ms. It does not show whether the difference is CPU contention or
+other elapsed-time variation.
+
+The 306 LOD8 jobs consumed 18.798 worker-seconds (45.6% of total), averaging 61.4 ms each; their
+worker-time p95 was 79.8 ms and max 94.7 ms. The final 20 completed tile records were all LOD8 and
+landed between 7.587 and 7.765 s. This is a group tail of ordinary large jobs, not one serial tile
+to split. Across the initial set, worker queue wait averaged 1.71 ms per tile (p95 9.71 ms, max
+41.44 ms), and game-thread mesh apply totaled 0.250 s. The trace records elapsed time, not CPU
+cycles, cache misses or task-pool wakeup causes; it cannot identify memory bandwidth or thread-local
+cache contention. The 10-slot cap reflects 12 logical cores with two cores reserved by
+`GetMaxConcurrentTasks`; I left that reserve in place without evidence that using all 12 improves
+the spawn while retaining tick time.
+
+The optional actor-tick subsystem markers were not added. The matched run reports the 28.967 ms
+maximum walk tick, but this trace has no per-call marker at that maximum, so it remains unattributed.
+These are headless/null-RHI actor tick measurements, not rendered frame timings.
+
+## 3. Result backlog bound
+
+`voxel.StreamingResultBacklogCap` defaults to 256 and counts queued results, active tile tasks, and
+held visible-LOD0 prequeue results. It is distinct from worker-slot admission; finished results
+still do not occupy slots. Zero disables the cap and is the safety negative control.
+
+| Run | Queue cap | Peak result count | Peak payload bytes | Cap stops | Peak private memory |
+|---|---:|---:|---:|---:|---:|
+| 6 m/s normal move | 256 | 116 | 17,024,546 | 0 | 3.48 GB |
+| 60 m/s + 400 m teleport | 256 | 114 | 17,153,276 | 0 | 3.80 GB |
+| 60 m/s + teleport, one mesh apply/frame | 256 | 256 | 76,201,412 | 843,198 | 3.60 GB |
+| Same slow-apply control, cap disabled | 0 | 1,577 | 125,098,792 | 0 | 3.63 GB |
+
+The slow-apply test still reached its initial set: 23.890 s capped versus 23.493 s uncapped. The
+cap reduced the tracked peak by 1,321 results and 48.9 MB of payload, at a 0.397 s startup
+difference in this pair. `cap_stops` counts repeated admission attempts, not unique tile keys. The
+atomic peak tracker saw 256 / 1,577 results; periodic `result_queue_frame` samples saw 255 / 1,576,
+respectively, because a frame sample can miss the brief peak. Bytes are result payload estimates,
+excluding queue-node and allocator overhead. The default stops new admissions as work drains; it
+does not reduce active task capacity when the queue is below the cap.
+
+## 4. Quality, determinism and async audit
+
+- BuildHost Core Off legacy passed at 12.5 cm. HybridV1 and HybridV2 each passed five fixtures and
+  same-LOD border checks at 25 cm.
+- Final-module SurfaceWorld passed the full actor, collision, anchor-move and carve checks at 25 cm.
+  Its W1/W8/W16 worker matrix matched: density `0cd2a1a4152ee4aa`, mesh `80a5b054b904b1a2`, payload
+  `bf2f1b40dff38acc`, topology `56074198682d5e18`. S3 ground agreement passed 128 points: far7/8
+  maximum error 0.0427 cm, cross-LOD 0.0000 cm, 2 cm tolerance; the 100 cm offset control was
+  detected.
+- FloatingIslands passed the final BuildHost W1/W8/W16 actor matrix at 25 cm, with fixed water,
+  collision, edits and LOD0/1 coverage. The standalone W1/W8/W16 `--stream-hash` runs matched on all
+  nine LODs. Its host scheduler clamps `parallel_for` to at most eight actual workers; W16 is the
+  requested worker-limit input routed through that eight-thread executor. The S4 audit passed:
+  385/385 far-cap bands emitted, 128 agreement points within 0.0504 cm (2 cm tolerance), 100 cm
+  offset detected, and 2,520/2,520 coverage rays hit.
+- No field, mesh or recipe output changed; recipe version remains unchanged. Water remains fixed
+  for the season, and player carve/fill remains unrestricted.
+
+Async review of the diff:
+
+- `FChunkResult::Epoch` and desired/modification epochs remain carried and checked. The region task
+  captures generation and desired epochs plus its compile serial.
+- All four result queues remain `EQueueMode::Mpsc`; result insertion is centralized in
+  `EnqueueStreamingResult`.
+- Tile and region workers check `bShuttingDown`; `EndPlay` sets both shutdown flags, waits for
+  `ActiveTaskCount` to reach zero, then drains all four result queues.
+- `ModsLock` is unchanged. Workers generate data only; UObject and RMC mutation remains on the game
+  thread. The region map has its own shared mutex, and readers retain immutable pages with
+  `shared_ptr` until their tile job ends.
+
+## 5. Build, commands and run record
+
+BuildHost compiled at Normal priority with 12 actions. Link-safety passed (96,279 dumpbin lines
+checked against 421 names); the five staged asset hashes and 18 manifest shims passed. The final
+SurfaceWorld quality run took about 10 minutes and peaked at 3.896 GB private memory. The standalone
+full build passed with the existing `vswhere.exe` lookup warning and existing C4838 conversions in
+`VoxelStrateManager.cpp:3974–3975`.
+
+Build commands:
+
+```powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+Matched region-gate commands (cap held at 256 for both sides):
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -CoreRegionConcurrentAdmission 0 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 6000 -TestTeleportAfterSeconds 2 -TestTeleportDistanceCm 40000 -TimeoutSeconds 900
+```
+
+Slow-apply backlog controls used these commands; the cap-off run is the backlog negative control:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 6000 -TestTeleportAfterSeconds 2 -TestTeleportDistanceCm 40000 -Step1MaxMeshApplies 1 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 0 -TestMoveSpeedCmPerSecond 6000 -TestTeleportAfterSeconds 2 -TestTeleportDistanceCm 40000 -Step1MaxMeshApplies 1 -TimeoutSeconds 900
+```
+
+Other BuildHost checks were:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+Standalone determinism used three fresh processes (`--workers=1`, `8`, and `16`), each with:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=1 --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+The S4 standalone audit command was:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-audit --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+SHA-256 of the executables/modules used by the final runs:
+
+| Binary | SHA-256 |
+|---|---|
+| UE 5.7 `UnrealEditor-Cmd.exe` | `ECCE9996191F7F7E69B3D104EECDD0E678AE69176FDCCD79828C3E75A0654D6D` |
+| BuildHost `UnrealEditor-VoxelForge.dll` | `8B82EE6C6FBB511AE766EB3D8646A7E9491952F41445CB62D49D71D0B9783418` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `0A1EB7BB27C3C74A4AA0996E0A24E74224D7B8FFFFF113B1071FA42E18E8375A` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `B3BC5E61172C5B21D928A5ACB5F22F8D9E00179B481B675804838DE9A620010D` |
+| `Standalone/bin/VoxelForgeCoreStandalone.exe` | `9C1601D7FCACCAAC16A2BA9DF0E7826E18746028A4D08FD23EEC479D2F5745BE` |
+
+Trace logs and queue records are under
+`Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/`. The final quality
+logs and standalone determinism/audit stdout are under `Saved/BuildHost/Round12/`. No new file over
+300 KB was placed in `Research/`.
+
+BuildHost and standalone launch guards checked free physical memory before each process and waited
+for at least 4 GiB. Explicit preflights for the final matched run and SurfaceWorld actor test saw
+17.33 and 17.11 GiB free. All processes stayed under 8 GiB and used Normal priority / at most 12
+threads. The only crash-folder entry is the pre-existing
+`UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000` from 2026-09-17; no new UECC or
+`0xC0000142` occurred. Three exploratory PowerShell RAM-probe definitions failed before launching
+Unreal; after correcting the interop declaration, the probe and all actual build/test runs passed
+on attempt 1. There were no failed Unreal runs or retries.
+
+No new source file was added. Likely compile spots are `Source/VoxelForge/Private/VoxelWorld.cpp`,
+`Source/VoxelForge/Public/VoxelWorld.h`, `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp`,
+`Standalone/Core/src/VoxelForgeCore.cpp` and its public header, plus the PowerShell harness. I did
+not open the owner's editor, build `VoxelM.uproject`, edit any `.uasset`, or modify
+RealtimeMeshComponent. No commit, push or stash was made.

Standalone/Research/WorldAssemblerM3/Round13/REPORT.md

@@ -0,0 +1,226 @@
+# World assembler S9 / M3 Round 13 — support-ring lookahead
+
+**Result:** the support ring is ready at all tested center arrivals through 40 m/s horizontally,
+and through a scripted 50 m/s vertical descent. At 40 m/s the matched CVar-off control reached
+the ring at only 15/74 arrivals; lookahead reached it at 74/74. Initial readiness was 7.743 s with
+lookahead and 7.778 s without it. I did not reserve more workers, and I left the LOD8 geometry
+unchanged; its counted optimization plan is in §5.
+
+The lookahead is default-on through `voxel.StreamingCollisionLookahead=1`; `0` disables prediction.
+It follows the support tile, predicts 350 ms ahead (rounded up to one or two 8 m LOD0 tiles at the
+25 cm owner scale), and promotes only rings already inside the desired clipmap. I first predicted
+from the stream center. The trace showed that this was one tile above the walkable center on this
+SurfaceWorld plan. I corrected both scheduler branches to predict and prioritize from
+`GetPlayerSupportTile`. No field or mesh arithmetic changed, so the recipe versions remain as-is.
+
+## 1. Speed sweep
+
+Fresh BuildHost commandlets used the staged owner SurfaceWorld plan, seed 0, 25 cm Core scale,
+Legacy streaming order, Dynamic near reserve, apply boost 0, region concurrent admission 1, result
+backlog cap 256, Normal process priority, a 12-action host limit, and movement from 30 to 45 s.
+The S8 traces are the pre-lookahead baseline. Arrival readiness is the `walkable_gate.ready` value
+on the support-center-change event. Lag is the maximum time to a later 9/9 sample before the next
+support-center change; unresolved centers are counted separately. LOD0 missing is the number of
+`scheduler_admission` samples with any desired LOD0 key missing during 30–45 s.
+
+| Motion | S8 arrival-ready | S8 worst resolved lag / unresolved | S8 LOD0-missing frames | S9 arrival-ready | S9 worst lag / unresolved | S9 LOD0-missing frames |
+|---|---:|---:|---:|---:|---:|---:|
+| +Y 6 m/s | 11/11 (100%) | 0 ms / 0 | 168/838 (20.0%) | 11/11 (100%) | 0 ms / 0 | 165/839 (19.7%) |
+| +Y 12 m/s | 22/22 (100%) | 0 ms / 0 | 431/776 (55.5%) | 22/22 (100%) | 0 ms / 0 | 436/775 (56.3%) |
+| +Y 25 m/s | 46/46 (100%) | 0 ms / 0 | 625/677 (92.3%) | 46/46 (100%) | 0 ms / 0 | 627/679 (92.3%) |
+| +Y 40 m/s | 25/74 (33.8%) | 191.1 ms / 8 | 579/595 (97.3%) | 74/74 (100%) | 0 ms / 0 | 576/593 (97.1%) |
+| −Z 50 m/s | — | — | — | 93/93 (100%) | 0 ms / 0 | 605/626 (96.6%) |
+
+The matched 40 m/s CVar-negative control on the corrected source reached 15/74 centers (20.3%),
+with 196.3 ms worst resolved lag, 7 unresolved centers, and 574/590 LOD0-missing samples (97.3%).
+This isolates prediction from the support-center correction. The old S8 60 m/s + 400 m teleport
+remains a separate discontinuity case: 8/113 centers were ready at arrival, 3 more became ready
+before the next center, and 102/113 never reached 9/9.
+
+At 40 m/s the current run therefore supports **40 m/s as the highest tested horizontal speed**;
+it does not establish a higher horizontal ceiling. The 50 m/s trace used the harness's scripted
+downward actor movement through the staged owner plan, not a Chaos free-fall simulation in a shaft.
+The ring remained ready through all 93 center changes.
+
+Spawn did not regress in the matched 40 m/s pair: `initial_ready_s` was 7.743349 s on and 7.777605 s
+off, with spawn-tick p95 2.288 ms and 2.292 ms respectively. The S9 on-run initial-ready values
+at 6/12/25/40 m/s were 7.813133/7.815265/7.821660/7.743349 s. Movement begins at 30 s, and the
+lookahead adds no stationary-spawn requests.
+
+## 2. Critical path at 40 m/s
+
+For 108 traced critical LOD0 jobs with complete tile-event joins, p50/p95 were:
+
+| Stage | p50 | p95 |
+|---|---:|---:|
+| Request → worker start | 0.02 ms | 9.59 ms |
+| Worker generation | 66.6 ms | 84.0 ms |
+| Result queue → game-thread apply | 9.3 ms | 17.7 ms |
+| Game-thread apply → mesh submit | 0.17 ms | 0.24 ms |
+| Mesh → collision submit | 0.01 ms | 0.02 ms |
+| RMC submit → body-update event | 37.6 ms | 85.9 ms |
+
+The body-update interval is the observable collision-ready delay; it is not an isolated Chaos CPU
+cook timer. Generation and body update dominate. Request-to-worker delay is small at the median,
+and game-thread apply/submission is below a quarter millisecond at p95. The lookahead gives the
+generation and body-update stages time to finish before support-center arrival.
+
+At 40 m/s the trace reported two lookahead tiles and three newly collision-promoted keys per
+scheduler rebuild, with zero desired keys outside the clipmap. Worker occupancy hit the 10-task
+limit, while the result queue peaked at 113 entries / 16.8 MB under the 256 cap and recorded no cap
+stops. Region compile time was 1.74 ms p50, 22.16 ms p95, 33.32 ms max; concurrent admission
+recorded no global scheduler skips. Those systems still consume time, but the matched CVar test
+shows prediction is sufficient at this plan's 40 m/s horizontal limit without adding reserved
+slots.
+
+## 3. Output quality and determinism
+
+- BuildHost Core-off legacy passed at 12.5 cm. M2 HybridV1 and HybridV2 each passed five analytic
+  fixtures plus border checks at 25 cm.
+- SurfaceWorld passed at 25 cm with collision, anchor movement, carve and travel checks. Its
+  W1/W8/W16 actor hash matrix was stable: density `0cd2a1a4152ee4aa`, mesh `80a5b054b904b1a2`,
+  payload `bf2f1b40dff38acc`, topology `56074198682d5e18`. Peak commandlet private memory was
+  3.90 GB.
+- FloatingIslands passed at 25 cm with fixed water, edits, collision and LOD0/1 coverage; the
+  BuildHost actor matrix reported W1/W8/W16. Peak private memory was 3.25 GB.
+- The current Standalone W1/W8/W12 full-clipmap and per-LOD 0–8 density, mesh, payload and topology
+  hashes match. Full-clipmap hash tuple: density `c10697a8f48380c7`, mesh `430d2be2bdd8b988`,
+  payload `b7b33e14092225c9`, topology `c5c46d66606a819e`. Full-detail hashes also match.
+- The Standalone S4 audit passed: 385/385 far-cap bands, 128 agreement points (maximum 0.0504 cm
+  under the 2 cm gate), the 100 cm offset negative control, and 2,520/2,520 cap-coverage rays.
+  The current BuildHost SurfaceWorld S3 check passed 128 points with 0.0427 cm maximum far/near
+  error and detected its 100 cm offset control.
+- A sampled Standalone W12 benchmark process peaked at 0.68 GB private memory.
+
+I did **not** run Standalone `--workers=16`: that implementation constructs 16 worker threads,
+which conflicts with the explicit 12-thread launch cap. Current Standalone W1/W8/W12 match, and
+the BuildHost SurfaceWorld and FloatingIslands W1/W8/W16 matrices passed. I requested whether the
+owner wants a one-run W16 exception; until then the 12-thread cap stands. No new `UECC-*` folder
+was present; the only folder was the existing 2026-09-17 crash.
+
+No geometry, field, density or recipe output changed. The far-horizon recipe stays at v2 and the
+SurfaceWorld plan identity stays unchanged. Water remains fixed for the season; player carve/fill
+remains unrestricted.
+
+## 4. Goal 2 — counted LOD8 plan, optimization deferred
+
+The S8 cold owner trace measured 306 LOD8 jobs at 18.798 worker-seconds total (61.4 ms average,
+79.8 ms p95, 94.7 ms max), 45.6% of worker time. Its full set reached readiness in about 7.7 s.
+The current 25 cm BuildHost feature-cost probe warmed eight LOD8 keys and reported p95 per-tile
+diagnostics: full/candidate feature path 59.508/59.585 ms, column computation 30.771 ms, marching
+cubes 6.018 ms, native ground+cap horizon refinement 48.205 ms, classification 0.0046 ms, feature
+list 0.0007 ms, and shell work 0.0001 ms (repair skipped). The profile counters are overlapping
+inclusive measurements, so they must not be summed. The same probe reported 15,529 field calls,
+9,679 column-cache misses, 8,192 refined ground triangles, 531 ground triangles removed, and
+6,732 cap triangles at the sampled high-cost LOD8 tile.
+
+`HeightfieldColumnCache` is a 65,536-entry thread-local cache keyed by global XY. It reuses columns
+within a worker, but does not share cache entries across workers. The current probe does not count
+cross-tile duplicate samples by worker, and does not split ground-refinement time from cap-refinement
+time. The next measurement should add exclusive counters for column evaluation, MC, ground refine,
+cap refine, classification, and cache hits/misses per tile and worker, then trace duplicate global
+columns across neighboring LOD8 jobs.
+
+No LOD8 optimization or far-mesh change was made this round, so no before/after far-horizon/cap
+captures were produced and the below-7.7 s Goal 2 target remains open. The counted next step is to
+prototype shared immutable heightfield-column pages for planar families, compare against sampling
+at displayed resolution and tolerance-based refinement skips, then rerun S3 ground/S4 cap gates
+(2 cm agreement, 100% coverage) and matched viewer captures at VSync/60 fps, closing the viewer
+right after each capture. Do not relax tolerances without a metre-scale error bound.
+
+## 5. Builds, commands, binaries and run record
+
+BuildHost and Standalone builds passed on their first attempt. Standalone build printed the existing
+`vswhere.exe` lookup warning and C4838 conversions in `VoxelStrateManager.cpp:3974–3975`, then
+built both targets successfully. All commandlets were fresh, serial, Normal priority and below
+8 GB; the largest sampled BuildHost private memory was 3.90 GB. No process exceeded the 15-minute
+step limit.
+
+Build commands:
+
+```powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+The final horizontal trace command (repeat with speeds `600`, `1200`, `2500`, and `4000` cm/s):
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+```
+
+The pre-S9 baseline used the same staged plan and settings with the S8 binary, before the lookahead
+CVar existed; repeat with the same four speed values:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+```
+
+Vertical descent and the matched 40 m/s CVar-negative control:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,0,-1' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 5000 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 0 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -TimeoutSeconds 900
+```
+
+Quality commands:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-audit --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+Standalone determinism command template (fresh process, `--workers=1`, `8`, and `12`; `16` was
+not launched under the thread cap):
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=1 --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+One initial CVar-off command was rejected by PowerShell before launch because the movement vector
+was not quoted (`Cannot convert value to type System.String`). I retried with
+`-TestMoveDirection '0,1,0'`; the BuildHost run passed. No Unreal process launched for the rejected
+attempt. No other test/build attempt failed or retried.
+
+Binary SHA-256:
+
+| Binary | SHA-256 |
+|---|---|
+| UE 5.7 `UnrealEditor-Cmd.exe` | `ECCE9996191F7F7E69B3D104EECDD0E678AE69176FDCCD79828C3E75A0654D6D` |
+| S8 baseline BuildHost `UnrealEditor-VoxelForge.dll` | `8B82EE6C6FBB511AE766EB3D8646A7E9491952F41445CB62D49D71D0B9783418` |
+| S8 baseline BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `B3BC5E61172C5B21D928A5ACB5F22F8D9E00179B481B675804838DE9A620010D` |
+| BuildHost `UnrealEditor-VoxelForge.dll` | `F542FC1F014190798485CC088470FD498D368D2E369639EAD32A0EEE8FDB1193` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `0A1EB7BB27C3C74A4AA0996E0A24E74224D7B8FFFFF113B1071FA42E18E8375A` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `15B6460FD4E48D14CBE751C99447F06B62B44CF35FFD440AED106585AECEDC79` |
+| `Standalone/bin/VoxelForgeCoreStandalone.exe` | `FD4CD39CD49BB0E8429250295BD16FACA0A6FBE412240522AB79C086245978C0` |
+
+Trace JSONL and actor stdout remain under
+`Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/`. The initial
+lookahead results are retained in `Saved/BuildHost/Round13/BeforeSupportTileCorrection/`; Standalone
+hash logs and the S4 audit log are under `Saved/BuildHost/Round13/`. No file over 300 KB was added
+outside `Saved/BuildHost/`. No `.uproject`, editor, `.uasset`, RealtimeMeshComponent source, commit,
+push or stash was touched.
+
+Modified source files:
+
+- `Source/VoxelForge/Private/VoxelWorld.cpp` — CVar, support-centered lookahead and critical ring ordering; BuildHost `VoxelForge` runtime compile.
+- `Source/VoxelForge/Public/VoxelWorld.h` — private helper declarations; same runtime compile.
+- `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp` — movement-vector harness; BuildHost `VoxelForgeEditor` compile.
+- `Tools/TestVoxelForgeCoreWorldHost.ps1` — movement-vector and CVar arguments.
+
+New source files: none. Standalone source files were not changed. Documentation updated:
+`CODEMAP.md` §3.16 and `ARCHITECTURE.md` §8.30.
+
+Async-safety diff review: `Epoch` propagation/checks are untouched; all result queues remain
+`EQueueMode::Mpsc`; `EndPlay` still drains after active tasks finish; workers still check
+`bShuttingDown`; `ModsLock` and immutable region-page lifetime are unchanged; UObject and RMC
+mutation remain on the game thread.
+
+### Dialogue
+
+**User:** Continue S9 from the 6 and 12 m/s lookahead traces after the service interruption.  
+**Luna:** Resumed at the 25 m/s run, found and fixed the support/stream-center mismatch, then measured the corrected speed sweep and matched 40 m/s CVar control.

Standalone/Research/WorldAssemblerM3/Round14/REPORT.md

@@ -0,0 +1,213 @@
+# World assembler S10 / M3 Round 14 — cheaper far ring
+
+Date: 2026-10-19. Base: S9 / `e7586a1`. No commit, push or stash.
+
+## Result
+
+The planar far path now samples the LOD8 interior at the spacing that LOD8 marching cubes can
+represent. At 25 cm, that is 512 voxels / 128 m per MC cell. Globally aligned 128-voxel (32 m)
+strips remain along tile boundaries. LOD4–LOD7 coordinates and the 2 cm agreement tolerances are
+unchanged. Far recipe version is 3; far mesh hashes change, while density and LOD0–LOD3 remain
+unchanged.
+
+On the owner SurfaceWorld plan, the warmed eight-tile BuildHost LOD8 full-tile p95 fell 76.7%,
+from 59.848 ms to 13.933 ms. In the fresh 6 m/s actor spawn trace, the 2,578 initial tile jobs
+used 26.870 worker-seconds; the LOD8 share was 4.288 seconds. Round13’s S8 spawn reference was
+about 41 worker-seconds, with 18.798 seconds in its 306 LOD8 jobs. Initial readiness was 7.117 s,
+below the 7.7 s target. The active 3×3 walkable ring was ready in 0.490 s, and all 512 LOD0 tiles
+were ready at 1.428 s.
+
+## Count first — exclusive cost and duplicate columns
+
+The counters are measured per tile. Column evaluation is timed only around uncached column work.
+MC, ground and cap counters subtract column time from their respective wall intervals. The mesh
+assembly window covers final payload flattening and optional diagnostic hashing. Each p95 is
+computed independently, so these p95 values are not additive.
+
+| LOD8 warmed p95, BuildHost 25 cm | S9 | S10 | Change |
+|---|---:|---:|---:|
+| Full tile | 59.848 ms | 13.933 ms | −76.7% |
+| Column evaluation | 31.319 ms | 7.478 ms | −76.1% |
+| Marching cubes | 2.667 ms | 2.359 ms | −11.6% |
+| Ground refinement | 11.666 ms | 1.690 ms | −85.5% |
+| Cap refinement | 10.029 ms | 1.330 ms | −86.7% |
+| Mesh assembly and diagnostic hash | 5.445 ms | 1.095 ms | −79.9% |
+| Column-cache misses | 9,679 | 2,287 | −76.4% |
+
+The high-cost S9 sample generated 8,192 ground triangles, removed 531 coarse ground triangles,
+and generated 6,732 cap triangles. S10 generated 968 ground triangles, removed 534, and generated
+840 cap triangles. The geometric checks below pass at the same tolerance.
+
+The fresh W12 Standalone overlap capture counted 153 LOD8 tiles. S10 evaluated 106,219 unique XY
+columns and repeated 32,738 neighboring tile evaluations, including 30,446 cross-worker repeats.
+The same-binary step-128 control counted 660,283 unique columns, 44,319 neighboring repeats and
+41,665 cross-worker repeats. This confirms that cross-worker duplicates remain, while the coarser
+interior removes most column work without sharing cache state between workers.
+
+| Fresh W12 Standalone pipeline | Default step 0 | Negative control step 128 |
+|---|---:|---:|
+| LOD8 worker sum | 3.206 s | 13.534 s |
+| LOD8 unique XY columns | 106,219 | 660,283 |
+| Repeated neighboring evaluations | 32,738 | 44,319 |
+| Cross-worker neighboring repeats | 30,446 | 41,665 |
+
+Both runs used the current v3 binary. Step 128 restores S9 sampling density, but retains the v3
+hash salt; its far mesh hash is therefore expected to differ from S9’s v2 hash.
+
+## BuildHost actor spawn and ring
+
+The fresh 6 m/s trace used the S9 movement, collision and backlog settings: Legacy order, Dynamic
+near reserve, collision lookahead on, 256 result cap, and a 12-CPU affinity mask. Per-LOD worker
+generation sums for the 2,578 initial generation ordinals were:
+
+| LOD | Initial tiles | Worker seconds |
+|---:|---:|---:|
+| 0 | 512 | 3.840 |
+| 1 | 448 | 3.781 |
+| 2 | 320 | 0.811 |
+| 3 | 272 | 2.093 |
+| 4 | 272 | 6.688 |
+| 5 | 208 | 1.535 |
+| 6 | 144 | 1.988 |
+| 7 | 96 | 1.846 |
+| 8 | 306 | 4.288 |
+| **Total** | **2,578** | **26.870** |
+
+At 6 m/s, initial readiness was 7.116525 s (2,578 desired, 2,617 loaded); spawn-tick p95/max was
+1.824/4.993 ms. The support ring became ready at 0.490 s (9/9). The complete LOD0 set was ready at
+1.427630 s, with a 0.990836 s measured build interval. Round13’s S9 6 m/s initial-ready value was
+7.813133 s.
+
+At 40 m/s (4,000 cm/s), all 75 moving support-center arrivals from 30.205 s through 45.011 s had
+the full 9/9 walkable ring ready: 75/75, 100%. A stationary startup gate event before movement is
+excluded from that moving-center denominator. Initial readiness was 7.087272 s. Spawn-tick
+p95/max was 1.833/5.365 ms; the trace passed.
+
+## Quality and determinism
+
+- S3 ground agreement: 72 shared route points; far LOD7 and LOD8 maximum error 0.0427 cm, cross-LOD
+  error 0 cm, within 2 cm. The 100 cm datum-offset control measured 100.0427 cm and was detected.
+- S4 cap agreement: 128 shared points; maximum error 0.0504 cm, within 2 cm. The 100 cm datum-offset
+  control measured 100.0015 cm and was detected. Cap census emitted all 385/385 requested bands.
+- Cap coverage: 2,520/2,520 upward rays hit the cap (100%); no profile-roof, mesh or clip-edge misses.
+- Core-off legacy passed at 12.5 cm. The M2 Hybrid V1 and V2 fixture sets each passed five analytic
+  fixtures and border checks. SurfaceWorld and FloatingIslands passed BuildHost actor validation at
+  25 cm. Water stayed fixed; carve and fill remained unrestricted.
+- Standalone W1/W8/W12 produced identical hashes for the full 2,553-tile view: density
+  `c10697a8f48380c7`, mesh `e75c9119a1498cd5`, payload `49a9a8d1835a6c8c`, topology
+  `edcb23288b5e8724`.
+- BuildHost SurfaceWorld W1/W8/W16 matrix was stable: density `0cd2a1a4152ee4aa`, mesh
+  `a06243aee16b65d5`, payload `c700162935c262d7`, topology `0af901aa42b452bc`. FloatingIslands
+  W1/W8/W16 was stable: density `4dcfb37585d7d986`, mesh `f14f76fbf065c6ed`, payload
+  `53035c45fd1a082e`, topology `23550100654a4ec3`. W16 was a logical partition with the process
+  still capped to 12 executing CPUs.
+
+Far mesh hashes differ from S9 as expected under recipe version 3; current-build determinism passes.
+
+## Matched captures
+
+All captures are 640×400 and under 22 KB. Each was produced at 60 fps with VSync on, then the
+Standalone viewer was closed after its back-buffer capture. Raw 1280×800 PNGs and run logs are under
+`Saved/BuildHost/Round14/CaptureRaw/`.
+
+| View | S9 sampling control, 128 voxels | S10 default, MC spacing |
+|---|---|---|
+| Far horizon, camera 0,-35,-487.94,0,-22 | [s9_far_horizon.jpg](captures/s9_far_horizon.jpg) (21.9 KB) | [s10_far_horizon.jpg](captures/s10_far_horizon.jpg) (18.0 KB) |
+| Cap, camera 0,-35,-487.94,0,22.42 | [s9_cap.jpg](captures/s9_cap.jpg) (10.8 KB) | [s10_cap.jpg](captures/s10_cap.jpg) (10.8 KB) |
+
+The cap is low contrast in this view, as in Round8; the 2 cm agreement, triangle census and ray
+coverage provide the cap acceptance evidence.
+
+## Builds, commands and hashes
+
+Builds on the final source:
+
+~~~powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+~~~
+
+The fresh Standalone determinism processes used the same command with workers 1, 8 and 12:
+
+~~~powershell
+foreach ($workers in @(1, 8, 12)) {
+    .\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=$workers --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+}
+~~~
+
+The current-build duplicate count and same-binary step-128 control used:
+
+~~~powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=12 --world-assembler-prototype --stream-pipeline --stream-hash --profile-far-column-overlap --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=12 --world-assembler-prototype --stream-pipeline --stream-hash --profile-far-column-overlap --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=128 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+~~~
+
+Quality and BuildHost actor commands:
+
+~~~powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-audit --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+~~~
+
+The two fresh actor traces differed only in speed, 600 or 4,000 cm/s:
+
+~~~powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -TimeoutSeconds 900
+~~~
+
+Final binary SHA-256:
+
+| Binary | SHA-256 |
+|---|---|
+| BuildHost UnrealEditor-VoxelForgeCore.dll | `D87CC56BACCDE6559705EEAEA7DB73D1A6ABF79484D37A3887B94A9FD62BABD3` |
+| BuildHost UnrealEditor-VoxelForge.dll | `9D0522ECC9A6AC52D9F3ACC2FD44399FE70F557C5F11D0203AB4C4B8EE75C198` |
+| BuildHost UnrealEditor-VoxelForgeEditor.dll | `AA196DA5A6DB3C84B5EC4F002AEBC787386DBB8F2798F5D1EEC03010BF642BBA` |
+| Standalone VoxelForgeCoreStandalone.exe | `E316D7E3E0B3D3639DAE61D6E2D1091F38C59A210B3B7DD8124928D21A8119A5` |
+
+## Run notes, files and safety review
+
+- BuildHost and Standalone ran at Normal priority with no more than 12 executing CPUs; free memory
+  was above 17 GB before the final launches. BuildHost peak private memory was 3.76 GiB for
+  SurfaceWorld, 3.27 GiB for FloatingIslands, 3.39 GiB for the 6 m/s trace and 3.67 GiB for the
+  40 m/s trace. The Standalone overlap/control processes peaked below 0.72 GiB. No process exceeded
+  8 GiB, and no launch overlapped another Unreal/Standalone process.
+- Standalone’s first compile attempt failed in `StandaloneViewer.cpp` because one helper referred to
+  `App` outside its scope; that reference was corrected and the final build passed. The existing
+  `vswhere.exe` lookup warning and `VoxelStrateManager.cpp` C4838 warnings remained.
+- Three BuildHost CVar attempts (direct argument and two `ExecCmds` forms) read back zero and did not
+  change the worker grid; that no-op CVar/harness path was removed. An early Standalone step-128
+  attempt also did not reach the pipeline; CLI pass-through was corrected and the final same-binary
+  step-128 control above is effective. No CVar remains in the final source.
+- One high-pitch cap capture was black and was discarded. A separate early capture shell lacked its
+  memory-probe type because the PowerShell session was fresh; that capture completed without a
+  pre-launch memory gate. The matched final captures were rerun with the gate active. No
+  `0xC0000142` occurred and no run needed retrying.
+- The only UECC directory was the pre-existing
+  `UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000`, timestamped 2026-09-17; no new UECC folder
+  was created.
+- No new source files. Changed source files and compile spots:
+
+| File | Compile spot |
+|---|---|
+| `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`, `Standalone/Core/src/VoxelForgeCore.cpp`, `Standalone/Core/src/WorldAssemblerInternal.h` | VoxelForgeCore in Standalone and BuildHost |
+| `Standalone/Source/StreamingWorld.h`, `Standalone/Source/StandaloneViewer.cpp` | StandaloneViewer / VoxelForgeCoreStandalone.exe |
+| `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp` | BuildHost VoxelForgeEditor module |
+| `Tools/TestVoxelForgeCoreWorldHost.ps1` | PowerShell harness only; recipe-specific fixture logs |
+
+Async-safety review: no actor async source changed. Epoch checks, MPSC queues, EndPlay draining,
+worker `bShuttingDown` checks and `ModsLock` remain unchanged. Region-page publication, shared_ptr
+lifetime and concurrent eviction remain unchanged. New duplicate capture stays thread-local and is
+copied into the tile result; its worker-id hash is diagnostic only. UObject and RealtimeMeshComponent
+mutation remain on the game thread. No owner `.uproject`, editor, `.uasset`, or RealtimeMeshComponent
+file was modified. `git diff --check` passed. No commit, push or stash.
+
+### Dialogue
+
+**User:** Keep the 12-thread cap; count exclusive LOD8 costs first, optimize the planar far path, and verify quality and determinism.
+
+**Codex:** The LOD8 interior now follows the MC spacing, with 128-voxel boundary strips preserved. The owner-plan LOD8 p95 fell from 59.848 ms to 13.933 ms; cap and ground gates, both BuildHost actor matrices, current-build worker hashes, and the 40 m/s support ring passed.

Standalone/Research/WorldAssemblerM3/Round15/REPORT.md

@@ -0,0 +1,181 @@
+# World Assembler M3 — Round 15 (S11)
+
+Date: 2026-10-19  
+Starting revision: `b90d63d` (S10)  
+Result: shared spawn-phase apply budget enabled by default; geometry and recipe unchanged.
+
+## Finding
+
+The old 7.1 s result was an apply backlog layered on top of generation. In the matched authored-budget control, 2,578 initial tiles were generated. The four-visible-mesh cap was reached on 305 of 399 apply frames; the result backlog peaked at 252/256 and eight result-backlog-cap declines were recorded (decline rule 6). Dynamic near-reserve holds (rule 2) appeared on three frames in both runs; full task-cap holds (rule 1) appeared on 312 control frames and 309 default frames while the ten-task guard was occupied. Rule 6 (result backlog cap) appeared on two control frames, with eight declined tile attempts, and on zero default frames. Result-wait p95/max was 847.5/1,119.2 ms. LOD8's last worker finished at 6.068 s, but its result was not applied until 7.182 s.
+
+I enabled the existing bounded startup apply mode in the shared `AVoxelWorld::ProcessPendingChunks` path: up to 12 visible applies or 14 ms per frame, capped at 30 seconds. It ends when the initial desired set and stationary walkable ring are ready, the desired epoch changes, a per-step override is active, or the duration expires. The regular authored budget (4 meshes/2 ms in this test) resumes for normal play. A trace record now reads back the CVar and resolved budgets. With the mode enabled, the peak backlog was 10/256, there were no backlog-cap declines, and result-wait p95/max fell to 16.6/19.3 ms. LOD8's last worker/apply were 6.015/6.019 s. The full set fell from 7.118 to 5.960 s, a 1.158 s (16.3%) improvement.
+
+The remaining floor is generation/admission, not result application, collision cooking, or LOD4. The set's worker span was 5.581 s after the first request, with 26.786 worker-seconds total. Ten perfectly occupied slots would need 2.679 s, but the actor issued 2,578 requests over 310 submission passes (8.32 submissions/pass); sampled active-task guards averaged 9.90/10 while sampled running workers averaged 7.95 and peaked at 8. Across the request-to-ready interval, the trace integrates 4.78 busy-worker equivalents and 29.24 idle slot-seconds. The initial-set trace records one `scheduler_admission` on every actor frame from the first desired pass through ready, with no frame gaps. The control took 379 frames (6.758 s from first request), including 314 frames that submitted work and 65 drain-only frames; the default took 312 frames (5.602 s), 310 with submissions and two drain-only. That is about 56 admission frames/s, with 8.3 submissions per non-empty pass. The remaining floor is frame-paced admission/refill, with effective worker supply also below the ten task slots (running workers peaked at eight). The trace shows this occupancy limit but does not establish why the task backend tops out at eight.
+
+Collision was not the startup floor: the 60 initial non-empty body updates had an 18.4 ms p95 submit-to-body-update interval, while the walkable ring was ready in 0.486 s. RMC section updates were not changed. LOD4 used the most aggregate worker time (6.590 s), but completed by 4.276 s; LOD8 remained the final LOD at 6.019 s. LOD4 averaged about 24.2 ms over the 272 tiles in the owner's count, but it did not set the tail, so I left its generation path alone.
+
+## Matched spawn results
+
+Fresh BuildHost processes, same binary, same 25 cm SurfaceWorld plan and streaming options; only the startup apply CVar differed. Both generated/drained 2,578 initial tiles and applied 1,333 visible meshes.
+
+| Metric | Authored budget: CVar 0 | Startup budget: default 1 |
+|---|---:|---:|
+| Full set ready | 7.118 s | 5.960 s |
+| Walkable ring, 9/9 | 0.495 s | 0.486 s |
+| Full LOD0 | 1.444 s | 1.403 s |
+| Worker-seconds | 27.077 s | 26.786 s |
+| Worker span from first request | 5.626 s | 5.581 s |
+| First request to full ready | 6.758 s | 5.603 s |
+| Ideal worker time, total / 10 slots | 2.708 s | 2.679 s |
+| Integrated busy equivalents over worker span | 4.01/10 | 4.78/10 |
+| Idle slot-seconds to full ready | 40.50 | 29.24 |
+| Scheduler admission frames through ready | 379 | 312 |
+| Non-empty submit passes / submissions per pass | 314 / 8.21 | 310 / 8.32 |
+| Sampled active task guards, average / 10 | 8.24 | 9.90 |
+| Sampled running workers, average / max | 6.62 / 8 | 7.95 / 8 |
+| Worker queue p95 / max | 6.15 / 26.57 ms | 6.17 / 20.33 ms |
+| Result queue p50 / p95 / max | 34.66 / 847.53 / 1,119.15 ms | 10.69 / 16.62 / 19.26 ms |
+| Peak result backlog / cap | 252 / 256 | 10 / 256 |
+| Backlog-cap declined tile attempts | 8 | 0 |
+| Near-reserve decline frames | 3 | 3 |
+| Apply frames through initial-ready | 399 | 332 |
+| Apply-count cap frames | 305 | 0 |
+| Max visible applies in one frame | 4 | 10 (12 allowed) |
+| Total measured Apply time | 235.80 ms | 236.14 ms |
+| Maximum Apply time in one frame | 1.576 ms | 2.357 ms |
+| Initial non-empty body updates | 60 | 60 |
+| Submit-to-body-update p95 / max | 17.69 / 17.81 ms | 18.37 / 18.45 ms |
+
+The control spent 65 scheduler frames draining after its final non-empty submit pass; the default spent two. The startup CVar negative control is effective: `startup_apply_config` read back `0` for the control and `1` when omitted for the default run. Both records reported the authored budget as 4 meshes/2 ms and the startup budget as 12 meshes/14 ms. `startup_apply_budget` showed the default run entering and leaving the bounded phase. The cap, collision, reserve, order, speed and backlog settings were matched.
+
+### Worker timeline
+
+Busy worker slot-seconds are integrated from the first request, in elapsed one-second bins (the last bin is approximately 0.6 s). Each value is CVar 0 / default 1.
+
+| Time from first request | Busy worker slot-seconds, CVar 0 / default 1 |
+|---|---:|
+| 0–1 s | 3.93 / 3.97 |
+| 1–2 s | 3.92 / 3.92 |
+| 2–3 s | 3.35 / 3.39 |
+| 3–4 s | 6.63 / 6.48 |
+| 4–5 s | 5.47 / 5.52 |
+| 5–~5.6 s | 3.78 / 3.51 |
+
+The apply change does not materially change generation occupancy. It removes the long post-generation queue wait, especially for the far LODs. Last visible apply per LOD, measured from the same spawn origin:
+
+| LOD | Worker-seconds CVar 0 / default 1 | Last apply CVar 0 / default 1 |
+|---|---:|---:|
+| 0 | 3.827 / 3.725 | 1.444 / 1.403 s |
+| 1 | 3.792 / 3.895 | 2.292 / 2.283 s |
+| 2 | 0.813 / 0.806 | 2.857 / 2.849 s |
+| 3 | 2.139 / 2.064 | 3.355 / 3.330 s |
+| 4 | 6.685 / 6.590 | 4.352 / 4.276 s |
+| 5 | 1.599 / 1.528 | 4.930 / 4.660 s |
+| 6 | 2.076 / 2.077 | 5.383 / 5.060 s |
+| 7 | 1.865 / 1.928 | 5.802 / 5.338 s |
+| 8 | 4.280 / 4.171 | 7.182 / 6.019 s |
+
+LOD8 last worker/apply were 6.068/7.182 s in the control and 6.015/6.019 s with the startup budget. That 1.114 s control-side wait nearly vanishes under the higher budget. LOD4 remains the highest total worker cost but not the completion tail.
+
+### Tick and 40 m/s ring
+
+`UWorld::Tick` p95/max from the matched 6 m/s spawn and subsequent normal-walk windows:
+
+| Window | CVar 0 spawn | Default 1 spawn | CVar 0 walk | Default 1 walk |
+|---|---:|---:|---:|---:|
+| Tick p95 / max | 1.805 / 5.374 ms | 2.740 / 5.175 ms | 2.364 / 28.993 ms | 2.483 / 28.876 ms |
+
+The normal-walk p95 changed by 0.119 ms and max by -0.117 ms; the normal authored budget is restored after startup. In a separate fresh 40 m/s default run, 75/75 moving support-center samples had the full 9/9 ring (100%); first/last sample were 30.207/45.015 s. That high-speed stress run measured spawn tick p95/max 2.426/14.061 ms and walk tick p95/max 31.428/56.628 ms. It is a 40 m/s stress measure, not the normal-walk comparison.
+
+## Quality and determinism
+
+No density, mesh generation, collision arithmetic or recipe output changed, so no recipe version bump is needed. The apply pacing change is shared by all world families. All requested gates passed:
+
+- Core off at 12.5 cm: legacy path passed.
+- M2 Hybrid V1 and V2 fixtures: all analytic fixtures and border checks passed.
+- SurfaceWorld BuildHost at 25 cm: passed; actor collision, anchors and carve/fill checks passed; water remains fixed for the season.
+- FloatingIslands BuildHost at 25 cm: passed; capsule contact, island/span height, carve/fill and switch-off legacy checks passed.
+- S3/S4 standalone audit: S3 72 samples, max 0.0427 cm; S4 128 samples, max 0.0504 cm; both within 2 cm. The 100 cm negative control was detected for both. Cap census 385/385, coverage 2,520/2,520 (100%), no misses.
+- 40 m/s walkable ring: 75/75 samples at 9/9 (100%).
+
+Current-build worker hash matrices were stable:
+
+| Run family / workers | Density | Mesh | Payload | Topology |
+|---|---|---|---|---|
+| Standalone W1/W8/W12 | `c10697a8f48380c7` | `e75c9119a1498cd5` | `49a9a8d1835a6c8c` | `edcb23288b5e8724` |
+| SurfaceWorld BuildHost W1/W8/W16 | `0cd2a1a4152ee4aa` | `a06243aee16b65d5` | `c700162935c262d7` | `0af901aa42b452bc` |
+| FloatingIslands BuildHost W1/W8/W16 | `4dcfb37585d7d986` | `f14f76fbf065c6ed` | `53035c45fd1a082e` | `23550100654a4ec3` |
+
+## Commands and artifacts
+
+Fresh matched 6 m/s pair (the first command is the CVar negative control; the second omits the override to exercise the code default):
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StartupApplyBoost 0 -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -TimeoutSeconds 900
+```
+
+40 m/s ring confirmation:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -TimeoutSeconds 900
+```
+
+Quality commands:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-audit --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+Determinism commands were run serially at Normal priority and affinity 4095. Standalone used the same command for workers 1, 8 and 12:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=$workers --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+BuildHost W1/W8/W16 matrices were part of the SurfaceWorld and FloatingIslands 25 cm gates above. Build commands:
+
+```powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+The BuildHost trace JSONL files remain under `Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/`; paired names begin `CoreWorldValidation-owner_surface_stream_trace_only_applyboost_0_...move_600...` and `...applyboost_default_...move_600...`. The 40 m/s trace uses `...applyboost_default_...move_4000...`. They remain in Saved, including files over 300 KB. Standalone stdout logs are in `Saved/BuildHost/Round15/`.
+
+Final binary SHA-256:
+
+| Binary | SHA-256 |
+|---|---|
+| BuildHost `UnrealEditor-VoxelForge.dll` | `E2744E97F3690A4B125E01E4AC89CD21D6771BFD70F72B71301411FDDAEFA56C` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `D87CC56BACCDE6559705EEAEA7DB73D1A6ABF79484D37A3887B94A9FD62BABD3` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `C7F00CD4BD150236C1BAD2BB2D54E6617A9F4313C1CFE64487928CD400442459` |
+| Standalone `VoxelForgeCoreStandalone.exe` | `68C81625911DF9764354C3D75A059B8A735423110D66EF3D50916199F066E9ED` |
+
+## Build, run and async-safety notes
+
+- BuildHost compiled successfully with 12 max parallel actions. Standalone `All` compiled successfully with 12 workers at Normal priority. The existing `vswhere.exe` lookup warnings and `VoxelStrateManager.cpp` C4838 conversion warnings remain.
+- Fresh processes were run serially, at Normal priority, with a 12-thread maximum. Free memory was above 17 GiB before the final launches; measured BuildHost peak private memory stayed below 3.7 GiB. No Unreal/Standalone process is running now. Each step stayed under the 15-minute limit.
+- A first Standalone determinism launcher invocation had a PowerShell parse error from `W$workers:` interpolation before launching any process. The launcher was corrected to `${workers}` and all W1/W8/W12 runs passed. No binary run failed, no `0xC0000142` occurred and no retry was needed.
+- `Saved/BuildHost/HostProject/Saved/Crashes/` contains only the pre-existing `UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000` (2026-09-17); no new UECC folder appeared.
+- Async safety was checked in the source diff: no worker or queue behavior changed. Epoch validation, MPSC queue modes, EndPlay drain, worker `bShuttingDown` checks, `ModsLock`, region-page lifetime, and game-thread UObject/RMC mutation are untouched. The only new actor field records whether the first trace config record has been emitted.
+- No new source file. Compile spots: `Source/VoxelForge/Private/VoxelWorld.cpp` and `Source/VoxelForge/Public/VoxelWorld.h` compile in the BuildHost VoxelForge module; the harness edit is PowerShell only. No generated header, recipe core, or `.uasset` changed. Owner `.uproject` and editor were not opened or built. RealtimeMeshComponent was read-only.
+- No commit, push or stash.
+
+## Files changed
+
+- `Source/VoxelForge/Private/VoxelWorld.cpp` — default-on bounded startup budget and trace readback of the effective CVar/budgets.
+- `Source/VoxelForge/Public/VoxelWorld.h` — per-world one-time trace guard, with French and English comment.
+- `Tools/TestVoxelForgeCoreWorldHost.ps1` — `-1` means no override (exercise code default); explicit `0` remains the negative control.
+- `CODEMAP.md` section 3 — shared drain and trace behavior.
+- `ARCHITECTURE.md` section 8.32 — behavior and measured floor.
+
+### Dialogue
+
+**User:** Count first, identify the new 7.1 s floor from the trace, move shared behavior only when the CVar control proves it, and retain every quality/determinism gate.
+
+**Codex:** The 4-mesh cap was holding completed LOD8 results for up to 1.1 s. The bounded 12-mesh/14 ms startup budget removed that backlog and brought the set to 5.96 s while preserving the 0.486 s walkable ring and all quality gates. The remaining measured span is 5.58 s of generation/admission; the trace narrows it to frame-paced refill and worker supply but cannot isolate actor tick refill from task-backend dispatch variation.

Standalone/Research/WorldAssemblerM3/Round16/REPORT.md

@@ -0,0 +1,302 @@
+# World Assembler S12 — Round 16
+
+**2026-10-19 · worker supply and tick-independent task pickup**
+
+## Result
+
+The matched 25 cm SurfaceWorld run completed its 2,578-tile set in **4.911 s** on the actor startup
+clock, down from Round15's **5.960 s**. From the first tile submission to readiness it took **4.537 s**,
+down from **5.603 s**. Full LOD0's last apply moved from 1.403 s to **1.087 s**. The stationary
+walkable ring measured **0.509 s** (Round15: 0.488 s). The 40 m/s trace kept the 3×3 collision-ready
+ring at 9/9 for every moving gate sample.
+
+The measured ceiling was eight tile workers, not ten: with 12 CPUs in the process affinity, Unreal
+reported 10 TaskGraph workers split into two foreground and eight background workers. Tile tasks
+use background priorities, so I sized their admission slots to the eight background workers. A
+short, ordered TaskGraph queue keeps those workers supplied between actor ticks. No density,
+triangulation, collision, or Core recipe output changed; recipe versions stay unchanged.
+
+## Pool count and priority
+
+| Measurement | BuildHost result |
+|---|---:|
+| Process affinity / priority | `0xFFF` (12 CPUs) / Normal |
+| `UE::Tasks` scheduler workers / reported maximum | 10 / 20 |
+| `FTaskGraphInterface` workers | 10 total: 2 foreground, 8 background |
+| `GThreadPool` workers | 10; separate from TaskGraph |
+| Step1 cook pool | 0 threads |
+| Tile task API / priority | `UE::Tasks::Launch`; near `BackgroundHigh`, horizon `BackgroundNormal` |
+| Scheduler worker / background priority fields | 5 / 2 in `worker_backend_config` |
+| Unique tile worker thread IDs / peak simultaneous tile tasks | 8 / 8 |
+
+RMC's inspected async collision path calls `DoOnAllowedThread(AsyncThread)`; that implementation
+queues work on `GThreadPool` (`RealtimeMeshFuture.h:147–165`,
+`RealtimeMeshManaged.cpp:703–707`). It therefore does not consume the eight TaskGraph background
+worker IDs used by tile generation. Other UE background work can share TaskGraph's workers; this
+trace attributes tile work by OS thread ID but does not label every unrelated engine task. The
+external process sampler counted 40 OS threads after initialization and 58–60 while running,
+including engine service threads. The 12-CPU affinity limits simultaneous CPU execution; it is not
+a 12-OS-thread process cap. VoxelForge tile generation itself peaked at eight workers, and the
+BuildHost process priority stayed Normal.
+
+## Shared scheduler and trace
+
+Two read-back CVars control the shipped behavior:
+
+| CVar | Default | Negative control | Effect |
+|---|---:|---:|---|
+| `voxel.StreamingReadyQueueDepth` | 8 | 0 | Admit up to one extra worker-set of prioritized tasks |
+| `voxel.StreamingBackgroundWorkerCap` | 1 | 0 | Size streaming slots to TaskGraph background workers; 0 restores the logical-core cap |
+
+With the selected defaults, effective tile slots are 8 and the total admission cap is 16. Near
+tasks retain `BackgroundHigh`; horizon tasks retain `BackgroundNormal`. While moving, the dynamic
+near reserve is 7, the near admission cap is 8, and the coarse cap is 9. Collision look-ahead and
+critical/edit admission retain their existing precedence. The game-thread scheduler continues to
+select and submit from the desired-tile ordering; there is no worker-owned continuation list. UE
+dispatches an already-admitted task as a background worker becomes free. `bStreamingPlayerMoving` is
+a game-thread snapshot shared by `LoadTile` and `LoadCoreTile`.
+
+Queued tasks retain `GenerationEpoch`, `DesiredEpoch`, and per-request cancellation checks. A desired
+set change obsoletes stale queued work, workers still check `bShuttingDown`, and results still return
+through the MPSC queues for game-thread application. No UObject or RMC component mutation moved to a
+worker. The trace records CVar readbacks in `worker_backend_config` and
+`streaming_worker_cap_readback`, and records each tile's submission, worker start/end, thread ID,
+next scheduler pass, next submission, and next task start on that worker.
+
+### Initial-set timeline
+
+The following busy-worker equivalents integrate the 2,578 tile intervals in 500 ms bins from the
+first submission (`submitted_t_s=0.456843` on the trace clock). The final short bin is 10.7 ms.
+
+| Time from first submission | Busy worker equivalents, out of 8 |
+|---|---:|
+| 0–0.5 s | 6.16 |
+| 0.5–1.0 s | 5.94 |
+| 1.0–1.5 s | 4.82 |
+| 1.5–2.0 s | 4.38 |
+| 2.0–2.5 s | 7.83 |
+| 2.5–3.0 s | 7.98 |
+| 3.0–3.5 s | 6.58 |
+| 3.5–4.0 s | 7.47 |
+| 4.0–4.5 s | 7.67 |
+| 4.5–4.511 s | 1.75 |
+
+All eight worker IDs were used. The initial set accumulated **29.432 worker-seconds**; the first
+worker started at 0.456872 and the last ended at 4.967520 on the trace clock, a 4.511 s worker
+span. That workload has a 3.679 s ideal at eight fully occupied slots (2.943 s at ten); the
+measured worker span was 4.511 s. Per-slot idle gaps between one tile ending and that worker's next tile starting summed to
+**6.573 slot-seconds** over 2,570 gaps: p50 0.006 ms, p95 13.604 ms, max 16.800 ms.
+
+| Worker thread ID | Tiles | Inter-task idle seconds | Gap p95 / max |
+|---:|---:|---:|---:|
+| 20144 | 324 | 0.838 | 13.780 / 15.607 ms |
+| 21468 | 318 | 0.829 | 13.489 / 16.800 ms |
+| 21536 | 304 | 0.830 | 13.237 / 15.902 ms |
+| 23392 | 327 | 0.832 | 13.476 / 15.691 ms |
+| 23572 | 331 | 0.821 | 13.365 / 15.916 ms |
+| 23616 | 331 | 0.847 | 13.765 / 15.773 ms |
+| 2716 | 321 | 0.734 | 13.486 / 15.801 ms |
+| 5392 | 322 | 0.843 | 13.657 / 15.556 ms |
+
+The scheduler recorded 247 admission passes, 243 with submissions, averaging 10.61 tiles per
+non-empty pass. Peak initial scheduler backlog was 32; the whole trace's result-backlog peak was
+35 tiles / 1,620,010 bytes against the 256-tile cap, with zero cap stops. The completed-result
+queue itself peaked at five during initial readiness.
+
+`Saved/BuildHost/Round16/initial_tile_worker_timeline.csv` contains one row per initial tile,
+including submitted/start/end, next scheduler admission, next submission, same-thread next start,
+and the calculated idle gap. The 500 ms busy bins, per-LOD totals, and per-thread idle table are
+also saved there. Files larger than 300 KB remain under `Saved/BuildHost/`.
+
+### Per-LOD completion and work
+
+S12 worker-end/apply values below are normalized to the actor startup clock; S11 apply values are
+from the Round15 matched report. S12 worker task totals were higher in this sample even though the
+set finished sooner; the scheduler changes do not change tile contents.
+
+| LOD | Tiles | Worker seconds S11 → S12 | S11 last apply | S12 last worker / last apply |
+|---:|---:|---:|---:|---:|
+| 0 | 512 | 3.725 → 4.018 | 1.403 s | 1.084 / 1.087 s |
+| 1 | 448 | 3.895 → 4.099 | 2.283 s | 1.749 / 1.757 s |
+| 2 | 320 | 0.806 → 0.825 | 2.849 s | 2.107 / 2.122 s |
+| 3 | 272 | 2.064 → 2.296 | 3.330 s | 2.469 / 2.484 s |
+| 4 | 272 | 6.590 → 7.682 | 4.276 s | 3.431 / 3.440 s |
+| 5 | 208 | 1.528 → 1.732 | 4.660 s | 3.706 / 3.709 s |
+| 6 | 144 | 2.077 → 2.160 | 5.060 s | 4.048 / 4.062 s |
+| 7 | 96 | 1.928 → 2.044 | 5.338 s | 4.289 / 4.293 s |
+| 8 | 306 | 4.171 → 4.576 | 6.019 s | 4.885 / 4.894 s |
+
+LOD4 remains the largest worker-cost group: 7.682 s across 272 tiles, or 28.24 ms per tile.
+The tile trace attributes this to the overall generation task (`generation_s`); it does not break
+the worker interval into density/classification/meshing stages (`classify_s` and `mesh_s` are not
+populated for these rows). Its last apply was 3.440 s, so it did not set the tail. I made no LOD4
+content optimization without the requested stage attribution and quality-capture work.
+
+## Apply, tick, and motion results
+
+| Metric | Round15 S11 | Round16 S12 |
+|---|---:|---:|
+| Full set ready, actor startup clock | 5.960 s | 4.911 s |
+| First submission to full ready | 5.603 s | 4.537 s |
+| Worker span from first submission | 5.581 s | 4.511 s |
+| Worker-seconds | 26.786 s | 29.432 s |
+| Walkable ring, 9/9 | 0.488 s | 0.509 s |
+| Full LOD0 last apply | 1.403 s | 1.087 s |
+| Apply frames through readiness | 332 | 268 |
+| Apply-count limit frames | 0 | 11 |
+| Max visible mesh applies / frame | 10 | 12 |
+| Total measured apply time | 236.14 ms | 255.17 ms |
+| Max apply time / frame | 2.357 ms | 2.697 ms |
+| Result-wait p95 / max | 16.62 / 19.26 ms | 16.90 / 21.03 ms |
+| Result backlog peak / cap | 10 / 256 | 35 / 256 |
+
+`UWorld::Tick` spawn and normal-walk windows were measured in fresh processes:
+
+| Window | S11 p95 / max | S12 p95 / max | Change |
+|---|---:|---:|---:|
+| Spawn | 2.740 / 5.175 ms | 3.344 / 5.219 ms | +0.604 / +0.044 ms |
+| Normal walk | 2.483 / 28.876 ms | 2.744 / 28.752 ms | +0.261 / −0.124 ms |
+
+The maxima stayed effectively flat or lower, while p95 rose by 0.60 ms at spawn and 0.26 ms while
+walking. I record this as a small p95 increase rather than claiming strict p95 non-regression. Both
+candidate p95 values remained below 3.4 ms.
+
+The 40 m/s run used the same queue and slot defaults. It completed the initial set in 4.919 s;
+all **75/75** moving `walkable_gate` events reported 9/9, and all 58 moving streaming samples
+reported the ring ready. Spawn tick p95/max was 3.173/8.071 ms; the accelerated walk window was
+29.562/39.227 ms. The 40 m/s trace's collision look-ahead, dynamic reserve, and moving near cap
+readbacks are present in the JSONL.
+
+### Negative controls and rejected variants
+
+| Read-back settings | Effective slots / actual worker IDs | Full set ready | Result |
+|---|---:|---:|---|
+| Queue depth 0, worker cap 1 | 8 / 8 | 7.024 s | Disabling the ready queue removes the speedup |
+| Queue depth 8, worker cap 0 | 10 / 8 | 4.669 s | Restores logical-core admission; still only eight background IDs ran |
+| Queue depth 8, worker cap 1 | 8 / 8 | 4.911 s | Selected default, sized to actual background workers |
+
+The first 40 m/s queue prototype lacked the queue-aware moving reserve and LOD0 admission cap; it
+missed the ring in 56/77 gate events and 47/57 streaming samples. Adding the reserve alone was
+insufficient. The final moving near cap and reserve passed 75/75 gate events. Reducing the shared
+Core task cap itself to eight increased per-tile generation cost and made the full set 5.30 s, so
+that change was reverted; only streaming admission is background-worker-capped.
+
+Foreground-priority variants were also rejected. Raising all tile work to foreground priorities
+used ten worker IDs but produced 39.422/50.432 ms spawn and 49.137/83.184 ms walk p95/max, with a
+5.215 s set. Raising only near work produced an 86.225 ms walk maximum. The final build keeps the
+original background priorities.
+
+## Determinism and quality gates
+
+- Standalone W1/W8/W12 all passed with identical full-clipmap hashes: density
+  `c10697a8f48380c7`, mesh `e75c9119a1498cd5`, payload `49a9a8d1835a6c8c`, topology
+  `edcb23288b5e8724`.
+- BuildHost SurfaceWorld W1/W8/W16 passed with stable density/mesh/payload/topology hashes
+  `0cd2a1a4152ee4aa / a06243aee16b65d5 / c700162935c262d7 / 0af901aa42b452bc`.
+- BuildHost FloatingIslands passed at 25 cm; W1/W8/W16 were stable with hashes
+  `4dcfb37585d7d986 / f14f76fbf065c6ed / 53035c45fd1a082e / 23550100654a4ec3`.
+- Core-off legacy gate passed at 12.5 cm (`legacy_unchanged=PASS`). M2 Hybrid V1 and V2 analytic
+  fixture and border suites passed at 25 cm.
+- The current Standalone far-cap audit passed S4 agreement: 128 shared points, maximum far/near
+  difference 0.0504 cm against a 2 cm tolerance; the 100 cm negative control was detected. Coverage
+  was 2520/2520 (100%), with zero missing mesh/profile crossings. S3's prior 72-point audit remains
+  at 0.0427 cm; scheduler changes do not touch that Core content path.
+- The 25 cm SurfaceWorld and FloatingIslands gates both passed. No world recipe version changed.
+
+## Builds, commands, and hashes
+
+Builds completed:
+
+```powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+The matched SurfaceWorld trace command was:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -TimeoutSeconds 900
+```
+
+The 40 m/s and negative-control commands were:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -StreamingReadyQueueDepth 0 -StreamingBackgroundWorkerCap 1 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 0 -TimeoutSeconds 900
+```
+
+Quality commands:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+The S3/S4 Standalone agreement and coverage audit command was:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --world-assembler-audit --workers=12 --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --process-priority=Normal --process-affinity=4095 --frame-limit=60 > Saved/BuildHost/Round16/standalone_S3S4_audit.stdout.log 2> Saved/BuildHost/Round16/standalone_S3S4_audit.stderr.log
+```
+
+Standalone determinism ran serially at Normal priority, affinity `4095`, and frame limit 60. Each
+worker count used the same remaining arguments and output paths below:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=1 --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60 > Saved/BuildHost/Round16/standalone_W1.stdout.log 2> Saved/BuildHost/Round16/standalone_W1.stderr.log
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=8 --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60 > Saved/BuildHost/Round16/standalone_W8.stdout.log 2> Saved/BuildHost/Round16/standalone_W8.stderr.log
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=12 --world-assembler-prototype --stream-benchmark --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60 > Saved/BuildHost/Round16/standalone_W12.stdout.log 2> Saved/BuildHost/Round16/standalone_W12.stderr.log
+```
+
+SHA-256 records. Streaming and quality runs used the first VoxelForge module hash. After those runs,
+I added the French half of one inline comment and rebuilt the current tree; that comment-only rebuild
+produced the second module hash. The executable code did not change between those two hashes.
+
+| Binary | SHA-256 |
+|---|---|
+| BuildHost `UnrealEditor-VoxelForge.dll` used for timing and gates | `C9D5DA90B48C5C1F844221C4A6A195947016C522F6A296EBC488A1AD8CCC6EEF` |
+| Current rebuilt BuildHost `UnrealEditor-VoxelForge.dll` | `12E7883DFB8825012890F1A2B5BACD038AA40FD1C342AA70711EC55AABF9057F` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `D87CC56BACCDE6559705EEAEA7DB73D1A6ABF79484D37A3887B94A9FD62BABD3` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `805FB845F00D013B48E29D4FD5D56EF1531E43F68047AE499DC617B04864DF80` |
+| Standalone `VoxelForgeCoreStandalone.exe` | `4EBE946E4D7B245458CD4FD0FBC3FCD6988B98000685C0043B25CD629AFC0F30` |
+
+## Failed attempts and safety review
+
+- One intermediate BuildHost compile failed because `PlayerHeading` was out of scope in two loader
+  admission helpers. I replaced those reads with the game-thread `bStreamingPlayerMoving` snapshot;
+  the final BuildHost and Standalone builds passed.
+- Two early external-sampler attempts failed before launching Unreal (a PowerShell job argument
+  was flattened, then `Get-Counter` requested an unsupported counter). The later sampler ran. No
+  Unreal run failed; no `0xC0000142` occurred and no retry was needed.
+- The final SurfaceWorld command completed under 15 minutes with 3.75 GB peak private memory;
+  FloatingIslands completed with 3.26 GB. The Windows free-memory query was denied during the latter
+  launch, but the BuildHost runner's preflight guard allowed it. No Unreal process remains running.
+- Standalone compiled with existing warnings: `vswhere.exe` was not found on `PATH`, and
+  `VoxelStrateManager.cpp` emitted C4838 double-to-float conversion warnings. The `All` build
+  completed successfully.
+- `Saved/BuildHost/HostProject/Saved/Crashes/` contains only the pre-existing
+  `UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000`; no new crash folder appeared.
+- Diff review confirmed the result queues remain `EQueueMode::Mpsc`; `EndPlay` waits for active
+  tasks and drains queues; workers check `bShuttingDown`; epoch and cancellation checks remain;
+  `ModsLock` still guards mod data; core pages retain shared ownership through readers; and UObject
+  / RMC component mutation remains on the game thread. No queue mode or page ownership changed.
+- No source file was added. C++ compile spots are `Source/VoxelForge/Private/VoxelWorld.cpp`,
+  `Source/VoxelForge/Public/VoxelWorld.h`, `Source/VoxelForge/Private/VoxelStartupTrace.cpp`, and
+  `Source/VoxelForge/Public/VoxelStartupTrace.h` in the BuildHost VoxelForge module. The test-harness
+  change is PowerShell in `Tools/TestVoxelForgeCoreWorldHost.ps1`; no Core source, generated header,
+  `.uasset`, owner `.uproject`, or editor was modified or built.
+- No commit, push, or stash was created. RealtimeMeshComponent was read-only.
+
+### Dialogue
+
+**User:** Count the workers and their idle gaps, preserve the streaming priorities and safety rules,
+and get the full set under six seconds without losing the 40 m/s walkable ring.
+
+**Codex:** The actor had ten TaskGraph workers available but only eight background workers for its
+background-priority tile tasks. A queue of eight plus an eight-slot admission cap reduced the
+2,578-tile startup to 4.911 s; the moving 3×3 ring stayed ready in all 75 gate samples. The process
+remains Normal priority and limited to 12 CPUs. The measured p95 tick increase is small but recorded,
+and the worker pool shows why this round did not reach the 3 s ideal for ten workers.

Standalone/Research/WorldAssemblerM3/Round17/REPORT.md

@@ -0,0 +1,277 @@
+# World Assembler S13 — Round 17
+
+**2026-10-19 · What does a tile actually cost?**
+
+## Result
+
+No generation optimization shipped. The measurements show that owner-plan tile time is mostly
+column evaluation plus MC, that LOD4 is dominated by column-cache misses, and that cross-worker XY
+reuse is common. The interpolation and global octave-drop probes fail the 2 cm quality bar. A shared
+column page still needs a measured candidate with bounded memory, synchronization, and lifecycle
+proof, so I did not add one. Density, mesh, collision, and recipe output are unchanged; no recipe
+version bump is needed.
+
+The current BuildHost 40 m/s trace passed the support gate **75/75**. It reported a 4.825 s
+initial-set ready time, 28.760 worker-seconds, and a 0.510 s stationary ring. The last initial LOD0
+tile applied at 1.146 s. At 40 m/s, `UWorld::Tick` was 3.133/5.426 ms p95/max at spawn and
+30.314/43.142 ms while walking. The worker-second and full-set targets passed in this trace; the
+LOD0 and strict S12 tick-tail targets did not. Startup-clock measurements and worker-task intervals
+use different origins from the S12 actor report, so I do not treat 4.825 s as an apples-to-apples
+replacement for S12's 4.911 s.
+
+## 1. Exclusive tile cost on the owner plan
+
+The BuildHost audit measures eight cold, no-hash tiles per requested LOD, with a separate hashed
+full-feature-list versus per-tile-list parity check (`hashes_identical=1`). The table gives p95
+stage time and the p95 of each tile's `stage time / density samples`, in `ms / ns per sample`.
+Percentiles are computed independently, so stage p95 values do not add to the full-tile p95. The
+sample denominator includes the normal halo: LOD0–1 are 32 MC cells / 35³ = 42,875 samples;
+LOD3–8 are 16 coarse cells / 19³ = 6,859 samples. The owner configuration is not a 32³ lattice at
+every LOD.
+
+| LOD | Full scan → per-tile list p95 (ms) | Classify excl. | MC column eval. | MC excl. | Ground column eval. | Ground excl. | Cap column eval. | Cap excl. | Mesh assembly |
+|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 0 | 13.806 → 14.160 | 0.0064 / 0.15 | 3.708 / 86.48 | 10.436 / 243.40 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0.0251 / 0.59 |
+| 1 | 9.616 → 9.584 | 0.0821 / 0.02 | 4.096 / 95.52 | 7.191 / 167.72 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0.0314 / 0.73 |
+| 3 | 6.952 → 6.878 | 0.0286 / 9.90 | 3.989 / 1,090.54 | 2.879 / 419.80 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0.0075 / 2.97 |
+| 4 | 36.445 → 35.790 | 0.0015 / 0.22 | 29.361 / 4,280.71 | 2.948 / 429.84 | 0 / 0 | 0.0001 / 0.01 | 4.865 / 709.35 | 1.259 / 183.61 | 0.0231 / 3.37 |
+| 5 | 10.586 → 10.420 | 0.0010 / 0.15 | 2.958 / 431.27 | 1.195 / 174.25 | 4.894 / 713.57 | 2.234 / 325.63 | 0.405 / 59.06 | 0.241 / 35.08 | 0.0054 / 0.79 |
+| 8 | 14.778 → 14.507 | 0.0046 / 0.67 | 5.671 / 826.84 | 2.366 / 345.01 | 1.775 / 258.74 | 1.652 / 240.87 | 1.823 / 265.78 | 1.348 / 196.50 | 0.0252 / 3.67 |
+
+The paired full/candidate timings are the feature-query negative control: the full plan scans feature
+bounds; the candidate builds the per-tile feature lists used by Core. All tested hashes matched.
+Their timing differences are small and mixed in sign. Feature-list p95 itself was only 0.0009–
+0.0015 ms on this owner sample.
+
+There is no separate volumetric 3D density-noise stage in native SurfaceWorld. Its surface recipe
+does call `FractalNoiseQ16`/Perlin while evaluating 2D XY columns, so that work is included in
+column evaluation. Material/color assignment is not a separate timer; it is included in meshing and
+the final mesh/payload path. The current route has no tunnel, room, shaft, or route-density stage.
+Classification-exclusive time subtracts column work done while classifying; MC/ground/cap column
+time is reported beside the corresponding non-column exclusive time. The `horizon_p95_ms` counter
+wraps ground and cap refinement and is inclusive, so it is not another exclusive stage. Far-shell
+repair was negligible in this sample (at most 0.0003 ms p95).
+
+### Why LOD4 is expensive
+
+LOD4 full tile p95 is 35.790 ms, versus 6.878 ms at LOD3 and 10.420 ms at LOD5. LOD4 is the first
+cap-refined level: it samples cap at 16 voxels (4 m); LOD3 has no cap refinement, and LOD5 cap uses
+the 128-voxel (32 m) boundary grid. Ground refinement starts at LOD5. LOD4's cap work costs
+4.865 ms of column evaluation and 1.259 ms exclusive at p95.
+
+That cap difference does not explain most of the spike. LOD4 MC performs 29.361 ms p95 of column
+evaluation, and its sampled tile has 8,224 column misses versus 1,634 at LOD3 and 1,916 at LOD5.
+Thus the measured anomaly is primarily poor column reuse at LOD4, with cap refinement adding a
+smaller separate cost. The data does not isolate why the thread-local direct-mapped cache misses
+rise at LOD4; tile extent, halo/normal probes, and XY spread all differ with LOD.
+
+## 2. Do far tiles evaluate detail they cannot show?
+
+The LOD8 tile p95 spends 9.203 ms in column evaluation out of 14.507 ms. There is no volumetric
+cave-noise loop in this path, but the 2D heightfield recipe still evaluates its full configured
+noise octaves at every requested XY column. A measurement-only probe dropped the highest one or two
+octaves globally on two LOD8 tiles. It reported 26.50% / 40.31% less column time, but ground-height
+p95 errors of 7,545 / 7,581 cm and cap-height errors of 2,427 / 7,859 cm; all 578 cap samples were
+over 2 cm. Near LOD0–1 the same probe was slower than baseline, so its timing is not a reliable
+frequency cost estimate. It also renormalizes the remaining octaves and does not implement a
+per-recipe wavelength cutoff at half the MC cell size.
+
+This rejects global octave removal. A frequency-aware cutoff could change appearance while keeping
+determinism, but this probe does not justify a cutoff or quantify its screen-space result. It was
+measurement-only and did not affect tile hashes.
+
+## 3. Per-tile feature lists and 2D cache reuse
+
+Core's `World::generateTile` builds bounded per-tile query lists for overlapping
+`Heightfield2D` strata and `FloatingIslandFieldV1` plans, including the normal halo. Those two
+WorldAssembler families share the scoped feature-list route. The legacy Unreal `UVoxelGenerator`
+room/tunnel/shaft families use their own room, tunnel, and generator caches; Round 1's Core tile list
+is not one shared list for all legacy generator families. On the owner SurfaceWorld tiles, list-build
+time is under 0.002 ms p95.
+
+`Heightfield2D::point(x,y,z)` may be called at many Z/normal samples, but the thread-local XY cache
+normally evaluates a column once per worker-cache miss. The cold BuildHost sample shows:
+
+| LOD | Field-point calls p95 | Column misses p95 | Approx. hit rate |
+|---:|---:|---:|---:|
+| 0 | 44,100 | 2,244 | 94.9% |
+| 1 | 44,100 | 2,289 | 94.8% |
+| 3 | 4,191 | 1,634 | 61.0% |
+| 4 | 9,405 | 8,224 | 12.6% |
+| 5 | 8,197 | 1,916 | 76.6% |
+| 8 | 4,441 | 2,708 | 39.0% |
+
+The Standalone W8 capture recorded all tiles and all LODs. `repeated` means an XY coordinate was
+re-evaluated by a different same-LOD tile; the neighbor count includes any prior adjacent tile,
+and the cross-worker column counts a neighbor repeat observed on a different worker.
+
+| LOD | Tiles | Unique XY | Repeated tile evaluations | Neighbor repeats | Cross-worker neighbor repeats |
+|---:|---:|---:|---:|---:|---:|
+| 0 | 512 | 128,240 | 347,280 | 280,233 | 276,658 |
+| 1 | 448 | 103,302 | 300,242 | 249,825 | 244,941 |
+| 2 | 448 | 32,274 | 102,713 | 84,318 | 79,402 |
+| 3 | 384 | 33,279 | 87,158 | 81,680 | 78,272 |
+| 4 | 320 | 91,325 | 230,492 | 229,811 | 202,684 |
+| 5 | 144 | 71,950 | 118,630 | 118,580 | 112,191 |
+| 6 | 96 | 280,313 | 63,523 | 63,523 | 63,435 |
+| 7 | 48 | 71,529 | 7,780 | 7,780 | 7,138 |
+| 8 | 153 | 106,219 | 32,879 | 32,879 | 30,956 |
+
+This makes immutable shared column pages worth a candidate A/B, especially for LOD0–5. The counts
+do not measure synchronization, page compilation, eviction, memory, or resulting wall-time savings.
+No page cache was added on counts alone. The column capture is opt-in, worker-local, and read back
+after generation.
+
+## 4. Coarse-lattice interpolation probe
+
+The measurement-only probe evaluated exact ground/cap columns at every MC XY sample, then sampled
+every second MC sample and bilinearly interpolated the rest. No near-zero or thin-feature fallback
+was included, so this is a lower-cost bound and a failure screen, not a production candidate. The
+table is two tiles per LOD. Errors are p95 over sampled columns; counts over 2 cm are explicit.
+
+| LOD | Measured column-compute time saved at stride 2 | Ground p95 / >2 cm | Cap p95 / >2 cm |
+|---:|---:|---:|---:|
+| 0 | 73.48% | 0.78 cm / 0 of 2,178 | 1.32 cm / 25 of 2,178 |
+| 1 | 73.96% | 2.54 cm / 236 of 2,178 | 3.00 cm / 375 of 2,178 |
+| 3 | 71.99% | 388.62 cm / 405 of 578 | 37.70 cm / 397 of 578 |
+| 4 | 71.39% | 702.29 cm / 403 of 578 | 68.92 cm / 401 of 578 |
+| 5 | 71.27% | 1,248.85 cm / 411 of 578 | 87.74 cm / 395 of 578 |
+| 8 | 72.81% | 4,369.95 cm / 414 of 578 | 2,201.17 cm / 415 of 578 |
+
+At stride two, exact column evaluations fell from 2,178 to 578 at LOD0–1 and from 578 to 162 at
+LOD3–8. The measured column-compute time reduction is shown above; it was 71–74%. Stride four
+reduced exact evaluations from 2,178 to 162 at LOD0–1 and from 578 to 50 at LOD3–8, roughly
+90–92%. It already gives LOD0 ground/cap p95 errors of 2.72/2.09 cm (293/2,178 and 123/2,178
+samples over 2 cm). At LOD1, stride two fails the
+2 cm threshold in both fields; coarse LOD errors are much larger. A near-zero exact fallback could
+recover surface crossings, but it was not simulated here and could erase much of the nominal saving.
+This probe does not exercise volumetric tunnel/wall thickness or the arrival-to-departure route
+law. No interpolation was enabled; exact sampled outputs, walkability, and route behavior are
+unchanged.
+
+## 5. S12 worker-cap follow-up and current trace
+
+The matched cap comparison kept `voxel.StreamingReadyQueueDepth=8` and changed only
+`voxel.StreamingBackgroundWorkerCap`. Both controls were recorded in the JSONL trace, as were the
+effective slots and the eight actual background worker count.
+
+| Speed | Background cap | Effective slots / actual tile workers | Initial set ready | Spawn tick p95/max | Walk tick p95/max | Ring |
+|---:|---:|---:|---:|---:|---:|---:|
+| 6 m/s | 0 | 10 / 8 | 4.669 s | 3.483 / 5.184 ms | 2.708 / 28.581 ms | — |
+| 6 m/s | 1 | 8 / 8 | 4.745 s | 3.283 / 14.945 ms | 2.696 / 28.535 ms | — |
+| 40 m/s | 0 | 10 / 8 | 4.633 s | 3.455 / 5.468 ms | 32.345 / 55.115 ms | 75/75 |
+| 40 m/s | 1, matched | 8 / 8 | 4.712 s | 3.031 / 5.364 ms | 30.541 / 41.598 ms | 75/75 |
+| 40 m/s | 1, final build | 8 / 8 | 4.825 s | 3.133 / 5.426 ms | 30.314 / 43.142 ms | 75/75 |
+
+Cap 0 gained only 76 ms at 6 m/s and about 79 ms in the matched 40 m/s pair, while its 40 m/s
+walk tick tail was substantially worse. The final cap-1 run confirms the ring at 75/75 gates. Keep
+cap 1 as the default; the latest tick p95/max is still 0.752/3.915 ms above Round 16's 29.562 /
+39.227 ms 40 m/s result, so the strict tick-tail target is not claimed.
+
+On the final cap-1 40 m/s trace, the initial set contains 2,578 tiles and totals 28.760 worker-
+seconds. The worker-seconds by LOD were: LOD0 3.81, LOD1 3.94, LOD2 0.81, LOD3 2.36, LOD4 7.73,
+LOD5 1.68, LOD6 2.17, LOD7 1.97, LOD8 4.31. The ring was ready at 0.510 s; full initial set
+ready at 4.825 s. LOD0's last worker ended at 1.131 s and its last apply was at 1.146 s.
+
+## Builds, quality, determinism, and files
+
+Build commands:
+
+```powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+Measurement commands (each was a fresh process; BuildHost runs were serial, Normal priority, and
+limited to the 12-CPU affinity):
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -SharedFeatureAuditOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 0 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 600 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 0 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -TimeoutSeconds 900
+```
+
+The final Standalone commands used the same options for each worker count; W8 also enabled the
+all-LOD overlap capture:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=8 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --profile-column-overlap --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+Current-build compatibility gates:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+The current BuildHost SurfaceWorld actor run passed and reported stable W1/W8/W16 hashes:
+density/mesh/payload/topology `0cd2a1a4152ee4aa / a06243aee16b65d5 / c700162935c262d7 /
+0af901aa42b452bc`. The current BuildHost cap audit passed S4 agreement (128 points, max 0.0504 cm
+against 2 cm) and 1,584/1,584 cap rays (100%). The BuildHost actor run also passed S3 far-horizon
+agreement at max 0.0427 cm against 2 cm. Current Standalone W1/W8/W12 each matched full-view hashes:
+density/mesh/payload/topology `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c /
+edcb23288b5e8724`. W8's final full-view pipeline was 3.518 s for 2,553/2,553 tiles.
+
+The current-build Core-off gate passed `legacy_unchanged=PASS` at 12.5 cm. M2 Hybrid V1 and V2
+each passed all five analytic fixtures and the border suite at 25 cm. FloatingIslands passed at
+25 cm with stable W1/W8/W16 hashes `4dcfb37585d7d986 / f14f76fbf065c6ed / 53035c45fd1a082e /
+23550100654a4ec3`; its island and span capsule contacts, content anchors, and carve/fill checks
+passed. These runs used the current BuildHost binaries. No density output changed, so paired
+near/far captures and a recipe bump were not required. No runtime CVar or behavior change was
+introduced; the cap-0 negative controls above were trace-read back.
+
+Full BuildHost logs are under
+`Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/` with stems
+`CoreWorldValidation-core_off_voxel_12.5_applyboost_default_legacy_order_nearreserve_auto`,
+`CoreWorldValidation-owner_surface_applyboost_default_legacy_order_nearreserve_auto_worldassemblerhybridv1`,
+`CoreWorldValidation-owner_surface_applyboost_default_legacy_order_nearreserve_auto_worldassemblerhybridv2`,
+and `CoreWorldValidation-floating_islands_applyboost_default_legacy_order_nearreserve_auto`.
+
+Current binary SHA-256:
+
+| Binary | SHA-256 |
+|---|---|
+| BuildHost `UnrealEditor-VoxelForge.dll` | `811F83D43EDE47EE870DD608F25C9F902422E1B264901917726CDBECE0EC0A37` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `AA74A8BC8E1C9C59FB7EA94D5A6BA71341EF8208EDE2458A7B5FAC0045FF2520` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `A851836ED435E8795AF860EBFB49AD84B603FF0D94600637D9B8CE52E0710EE3` |
+| Standalone `VoxelForgeCoreStandalone.exe` | `704F433791AF0D483D082CCBB2043DB4194323F40A986DA72F338FC424BF82F3` |
+
+Round 17 changed these existing source files; no new source file was added:
+
+| File | Likely compile spot |
+|---|---|
+| `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`, `Standalone/Core/src/VoxelForgeCore.cpp`, `Standalone/Core/src/WorldAssemblerInternal.h` | BuildHost VoxelForgeCore and Standalone Core |
+| `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp` | BuildHost VoxelForgeEditor commandlet |
+| `Standalone/Source/StreamingWorld.h`, `Standalone/Source/StandaloneViewer.cpp` | Standalone viewer executable |
+
+Async-safety review: no actor queues or worker mutation code changed. `Epoch`, MPSC queue modes,
+`EndPlay` draining, worker `bShuttingDown` checks, `ModsLock`, and shared region-page lifetime are
+unchanged. Coordinate capture is opt-in thread-local diagnostic data copied into each tile result;
+UObject and RMC mutation remains on the game thread. RealtimeMeshComponent was read-only. No
+`.uproject`, owner editor, `.uasset`, generated header, `Binaries/`, or `Intermediate/` source was
+edited. Files over 300 KB are under `Saved/BuildHost/`. No `0xC0000142` occurred and no new
+`UECC-*` crash folder appeared.
+
+The first BuildHost compile failed because two probe lambdas omitted the configured tile-size
+capture; that was fixed and the next build passed. The Standalone build passed with the existing
+`vswhere.exe` lookup warning and `VoxelStrateManager.cpp` C4838 warnings. A final source check and
+both current targets passed. No commit, push, or stash.
+
+### Dialogue
+
+**User:** Shouldn't a tile be way cheaper? Measure the stages and explain LOD4 before choosing a fix.
+
+**Codex:** The largest measured cost is XY column evaluation, and LOD4 has a sharp spike in cache
+misses plus its first fine cap pass. Two-step interpolation reduced measured column-compute time by
+roughly 72%, but moved far ground by tens of meters; global octave dropping also fails badly.
+Cross-worker column
+reuse is a strong candidate for a future measured page-cache experiment, so Round 17 keeps output
+unchanged and records the floor instead of shipping an unproven approximation.

Standalone/Research/WorldAssemblerM3/Round18/REPORT.md

@@ -0,0 +1,340 @@
+# World Assembler S14 — Round 18
+
+## Decision
+
+Shipped two output-preserving changes justified by the measurements:
+
+1. Keep the 65,536-entry XY column cache worker-local. Use the old direct-map route at LOD0–2,
+   where conflict counts are low, and deterministic four-way sets at LOD3–8. The LOD4 miss spike
+   falls from 8,224 to 1,437, with conflict misses falling from 7,407 to zero.
+2. Memoize exact step-1 ShapeWorld MC grid gradients per worker and tile. The MC two-pass loop,
+   density grid, halo, central differences, and output values stay intact. LOD0 MC-exclusive cost
+   falls from 241.87 to 201.48 ns/sample in the corrected-source audit; the original S13 figure was
+   243.40 ns/sample.
+
+No shared XY page was built: cross-worker repeats show opportunity, but no measured page-cache A/B
+shows a net cold-path win after the cache fix. The primary cold trace used 21.722 worker-seconds against
+the 28.8 s target. Output hashes remain unchanged, so the recipe stays `MarchingCubesV1`; no recipe
+bump or matched captures were required.
+
+## 1. What the 243 ns/sample contains
+
+The S13 “MC-exclusive” timer excludes MC column evaluation; it does **not** mean “triangle loop
+only.” For LOD0, the corrected-source eight-tile audit measured 8.638 ms MC-exclusive plus 3.852 ms
+MC column evaluation at the tuned setting. Each LOD0 tile has 35³ = 42,875 density samples. The
+exclusive result is 201.48 ns/sample. The cell loop itself is only one part of it.
+
+In the sampled stage audit, tuned LOD0 p95 was: density grid 8.971 ms (7.071 ms excluding column
+evaluation), cell classification 0.143 ms, grid-gradient normals 1.036 ms, edge interpolation
+0.080 ms, vertex dedup/stream 0.545 ms, and about 2.168 ms of unassigned remainder. The stage
+profiler samples one in eight cells; these are independently calculated p95 values and do not add
+to a measured total. Its `Other`/setup-finalization and unassigned-residual fields are computed
+remainder buckets from different inclusive/exclusive timers, not separately isolated setup or
+allocator timers.
+
+The 164.93 ns/sample grid remainder is not a standalone `height - z` timer. Every lattice sample
+still enters the exact `Heightfield2D::point` path: fixed-coordinate conversion, recipe/plan lookup,
+the worker-local XY cache probe, the Z-dependent ground/cap composition, and any applicable exact
+feature/edit checks. Column generation itself is counted separately: LOD0 records 44,100 field
+calls, 2,244 cache misses (about 94.9% hits), and 89.89 ns/sample of column computation. The audit
+does not split cache-hit lookup from Z composition and call overhead. Those Z/feature checks cannot
+all move to one XY-column operation. The MC gradient work can be shared per lattice point and is
+now memoized exactly; edge interpolation is already limited to crossed edges and the vertex map
+deduplicates shared edge vertices. Material and allocation have no separate timers; the mesher's
+thread-local grids and dedup map retain capacity between tiles.
+
+The MC route still uses the protected two-pass loop: pass one rejects empty cells from the eight
+cached corners; pass two computes positions, gradients, and emitted triangles only for surface
+cells. Classification is per cell; exact gradients are reused per lattice point; interpolation and
+deduplication are limited to crossed edges and their shared vertex keys. The stage measurements
+place classification in the first pass and interpolation plus dedup/stream in the second.
+Material/ground-cap grouping and vertex attributes are folded into
+vertex creation and streaming; material work has no separate timer. The 35 edge-midpoint density
+probes are negligible beside the gradient fallback calls.
+
+| LOD | Density grid incl. | Grid excl. columns | Cell classification | Gradient normals | Edge interpolation | Dedup/stream | Unassigned residual |
+|---:|---:|---:|---:|---:|---:|---:|---:|
+| 0 | 210.11→209.22 | 168.04→164.93 | 3.28→3.32 | 65.10→24.16 | 1.91→1.86 | 12.96→12.72 | 50.40→50.56 |
+| 1 | 163.74→164.91 | 163.74→164.91 | 3.82→3.55 | 4.20→4.01 | 2.14→2.10 | 13.47→13.56 | 54.77→55.06 |
+| 2 | 390.55→395.47 | 0.00→0.00 | 2.84→2.89 | 11.62→11.51 | 6.14→5.47 | 68.70→69.15 | 277.12→306.20 |
+| 3 | 777.21→437.15 | 120.00→131.99 | 3.15→2.97 | 15.37→15.37 | 6.77→6.25 | 604.40→407.99 | 46.97→110.89 |
+| 4 | 4,603.98→425.25 | 210.50→178.79 | 2.92→3.32 | 10.15→10.96 | 5.60→5.48 | 565.21→309.90 | 95.44→109.50 |
+| 5 | 385.90→434.09 | 135.75→155.07 | 3.02→3.48 | 5.13→7.00 | 1.78→3.50 | 155.02→38.26 | 96.38→137.65 |
+| 6 | 366.38→371.92 | 88.76→101.46 | 2.97→3.09 | 18.66→18.11 | 9.72→8.39 | 431.20→185.07 | 124.84→171.70 |
+| 7 | 361.29→447.14 | 115.03→102.64 | 3.13→2.99 | 20.47→17.75 | 9.69→8.84 | 443.10→239.22 | 99.92→254.21 |
+| 8 | 367.98→377.58 | 95.55→96.05 | 4.05→3.05 | 14.90→19.08 | 7.48→7.92 | 513.15→213.89 | 159.02→234.19 |
+
+All stage values are p95 **ns/sample**, before→after. “Before” is this build with the direct-map
+cache and gradient memo off (`1/0`); “after” is this build's tuned default (`0/1`). Each side measured eight
+tiles per LOD, with `hashes_identical=1`. LOD0/1 use 42,875 samples; LOD2–8 use 6,859. Large
+variation in dedup/stream and residual is content/triangle-count and sampling noise, not a new
+approximation. The last column is the commandlet's unassigned-residual bucket; the separately
+reported setup-finalization field is also computed as a remainder and is not an allocator timer.
+These warmed-route stage probes explain the hot path; the cold production timings are the
+fresh-process trace in section 4.
+
+| LOD | Candidate tile p95 ms | MC column p95 ms | MC-exclusive p95 ms / ns per sample | Column misses / conflicts |
+|---:|---:|---:|---:|---:|
+| 0 | 14.079→12.492 | 3.777→3.852 | 10.370→8.638 / 241.87→201.48 | 2,244/33→2,244/33 |
+| 1 | 9.824→9.842 | 4.187→4.197 | 7.183→7.307 / 167.53→170.43 | 2,289/28→2,289/28 |
+| 2 | 4.715→4.709 | 3.080→3.066 | 1.606→1.616 / 281.61→282.71 | 681/4→681/4 |
+| 3 | 6.945→5.393 | 4.016→2.477 | 2.917→2.903 / 425.28→423.27 | 1,634/1,119→574/0 |
+| 4 | 36.854→9.227 | 30.216→2.257 | 2.970→2.946 / 432.93→429.54 | 8,224/7,407→1,437/0 |
+| 5 | 11.055→9.129 | 3.029→2.278 | 1.279→1.269 / 186.43→184.98 | 1,916/1,476→1,351/0 |
+| 6 | 30.703→26.872 | 5.148→3.841 | 2.142→2.000 / 312.23→291.57 | 6,403/2,094→5,570/1 |
+| 7 | 20.831→15.390 | 4.725→3.460 | 2.411→2.689 / 351.52→391.97 | 3,472/2,926→1,822/0 |
+| 8 | 14.948→9.829 | 5.715→3.358 | 2.534→2.770 / 369.38→403.82 | 2,708/2,215→1,162/0 |
+
+For LOD0 specifically, the S13 audit row was 14.160 ms candidate, 3.708 ms column evaluation,
+10.436 ms MC-exclusive, and 243.40 ns/sample. The tuned corrected-source 35³ route is 12.492 ms
+candidate and 8.638 ms MC-exclusive. Subtracting the measured density-grid p95 from candidate p95
+leaves about 3.52 ms for the remaining work (about 82 ns/sample); the independently sampled stage
+subtotal is about 3.97 ms (about 93 ns/sample). This is the measured in-world estimate for the
+MC/classification/normal/interpolation/streaming work after density-grid evaluation, not a direct
+pre-filled-grid benchmark. Treat the p95 subtraction as an estimate, not an additive percentile.
+
+Gradient memoization reduces LOD0 fallback density probes from 11,474 to 3,018 per sampled p95
+(−73.7%) and normal cost from 65.10 to 24.16 ns/sample. It records 5,610 memo hits. The memo stores
+the exact central-difference vector at each grid lattice point, is worker-local, and resets its
+validity bytes per tile. The existing grid and per-worker capacities are reused. No material
+approximation or altered gradient arithmetic is involved.
+
+## 2. Why LOD4 had the cache spike
+
+The old cache already holds 65,536 `HeightfieldPointSample`s per worker, but its direct-map index
+uses pointer identity and coordinate bits. Coarse LOD coordinates share sparse low-bit patterns;
+the LOD4 16-voxel cap grid interleaves different XY probes with the MC grid and its halo/normal
+lookups. The measured direct-map conflict count (7,407 of 8,224 misses) shows this is mostly
+eviction, rather than 8,224 necessary unique columns. The audit did not tag every miss by probe
+source, so the individual halo-versus-cap contribution is not claimed.
+
+The new default keeps the same total entries and exact key verification. Its avalanched coordinate
+hash selects one of 16,384 four-way sets; deterministic round-robin replacement only changes
+residency, never values. Exact recipe/plan identities, content hashes, and XY coordinates are
+checked on every hit, so fill order cannot affect output. LOD0–2 keep the fast original path because
+they have only 33, 28, and 4 direct-map conflict misses in the audit. LOD6 remains at 5,570 misses
+but only one conflict, showing that its remaining cost comes largely from its larger real XY
+footprint and connector-shell work, not direct-map collision.
+
+`voxel.CoreColumnCacheDirectMapped=1` is the direct-map negative control and was read back as `1`
+in the trace. With gradient memo still on, the initial set took 6.624 s and 43.493 worker-seconds;
+LOD4 used 11.071 worker-seconds. The tuned default took 4.238 s and 21.722 worker-seconds, with
+LOD4 at 1.862 worker-seconds. The isolated audit also reports the per-LOD miss deltas above.
+
+The separate memo negative control was `voxel.CoreMCGradientMemoization=0` with the four-way
+column cache still enabled; both values were read back as `0/0`. It took 4.908 s and 27.609
+worker-seconds, versus 4.238 s and 21.722 s at the `0/1` default. Its 3×3 support ring was 0.602 s
+versus 0.447 s, and LOD0 last apply was 1.453 s versus 1.171 s. This cold-path A/B supports keeping
+the exact gradient memo. The direct-map control is `1/1` and isolates the cache behavior; the memo
+control is `0/0` and isolates the gradient behavior.
+
+## 3. Shared XY pages
+
+The corrected-source Standalone W8 overlap capture counted 281,910 cross-worker neighboring
+duplicate columns at LOD0 and 123,803 at LOD4. Against Round17 (276,658 and 202,684), LOD0 is up
+about 2%, while LOD4 is down about 39% after fixing intra-worker cache conflicts. The counters are
+schedule-dependent work counts, not world output. Multiplying those counts by the current stage
+audit's p95 column-time-per-miss ratios gives a rough estimate of 0.68 worker-seconds across the
+LOD0/LOD4 repeats if each repeat avoided a recomputation and the shared lookup had zero cost. That
+is about 3.1% of the measured 21.722 worker-seconds, before synchronization and memory costs. This
+is an estimate, not a cold-path A/B win measurement.
+
+After the four-way change, the remaining upper bound is too small to justify adding an unmeasured
+synchronized page in this round. It would also add ownership/lifetime and bounded-memory work under
+the S8 rules. The page was therefore not built. Existing immutable region pages and their S8
+lifetime are unchanged; no new page lifetime needs proving.
+
+## 4. Cold 40 m/s trace
+
+Fresh BuildHost process, 25 cm SurfaceWorld, 40 m/s along +Y, background worker cap 1, ready queue
+8, dynamic reserve, collision lookahead 1, `CoreColumnCacheDirectMapped=0`, and
+`CoreMCGradientMemoization=1`. The `worker_backend_config` JSONL row reads back all these controls.
+Round17 and Round18 use the same trace command and post-`BeginPlay` `elapsed_s` origin. In this run
+`elapsed_s=4.238189`; raw trace `t_s` is 4.320372. Trace `t_s` begins 0.082022 s before the
+end-of-BeginPlay origin. The 3×3 walkable support ring is measured at its first ready gate using
+that same origin. S12's actor report uses a different clock origin; its comparisons are stated as
+references, not clock-normalized samples.
+
+| Metric | Round17 S13 | S14 primary | S14 fresh repeat |
+|---|---:|---:|---:|
+| Initial set | 2,578 tiles / 4.825 s | 2,578 / 4.238 s | 2,578 / 5.151 s |
+| Initial-set worker seconds | 28.760 | 21.722 | 29.969 |
+| 3×3 walkable support ring | 0.510 s | 0.447 s | 0.971 s |
+| LOD0 last worker end | 1.131 s | 1.156 s | 1.524 s |
+| LOD0 last apply | 1.146 s | 1.171 s | 1.532 s |
+| 40 m/s moving readiness | 75/75 ready | 75/75 ready | 57/57 logged samples ready |
+| Spawn `UWorld::Tick` p95/max | 3.133 / 5.426 ms | 4.200 / 5.571 ms | 4.601 / 6.682 ms |
+| Walk `UWorld::Tick` p95/max | 30.314 / 43.142 ms | 32.218 / 45.720 ms | 33.986 / 41.654 ms |
+
+| Initial-set LOD | Tiles | S14 primary worker s | S14 repeat worker s |
+|---:|---:|---:|---:|
+| 0 | 512 | 4.520 | 6.319 |
+| 1 | 448 | 4.696 | 6.304 |
+| 2 | 320 | 0.870 | 1.241 |
+| 3 | 272 | 0.829 | 1.193 |
+| 4 | 272 | 1.862 | 2.634 |
+| 5 | 208 | 1.478 | 2.121 |
+| 6 | 144 | 2.179 | 3.168 |
+| 7 | 96 | 1.723 | 2.206 |
+| 8 | 306 | 3.565 | 4.782 |
+| **Total** | **2,578** | **21.722** | **29.969** |
+
+The same-build LOD0 candidate-tile p95 fell 11.3% (14.079 to 12.492 ms). In the cold trace, LOD0
+worker time fell 3.3% (4.672 to 4.520 s across 512 tiles, or 9.13 to 8.83 ms per tile).
+
+The primary cold trace meets the 4.8 s full-set, 28.8 worker-second, and 0.51 s support-ring
+targets, with all 75 moving samples ready. LOD0 is materially cheaper per tile. LOD0 last apply is
+81 ms over the ~1.09 s target. I made one more fresh default trace to check the tick regression;
+the same binary and `0/1` CVar readback passed the commandlet but took 5.151 s and 29.969
+worker-seconds for all 2,578 tiles, 0.971 s for the support ring, and 1.532 s for the last LOD0
+apply. Peak private memory was 3.29 GiB. Its spawn tick was 4.601/6.682 ms and walking tick was
+33.986/41.654 ms p95/max; all 57 logged 40 m/s streaming samples stayed walkable-ready. Thus the
+full-set, worker-second, support-ring, and LOD0 apply targets pass in the primary run but fail on
+this repeat. Spawn tick p95/max is worse than S13 and matched S12 in both runs; walking p95 is
+worse than both in both runs. The first-run walking max is worse than both references; the repeat
+is worse than S12 but below S13. The strict no-worse tick goal therefore fails. I kept the S13
+worker cap at 1; the measurements do not justify raising it.
+
+## 5. Quality and determinism
+
+- BuildHost W1/W8/W16 stable: density/mesh/payload/topology
+  `0cd2a1a4152ee4aa / a06243aee16b65d5 / c700162935c262d7 / 0af901aa42b452bc`.
+- Standalone W1/W8/W12, fresh `--force-generate`: whole-view 2,553-tile hashes all match:
+  `c10697a8f48380c7 / e75c9119a1498cd5 / 49a9a8d1835a6c8c / edcb23288b5e8724`.
+  Full-detail 960-tile hashes also match:
+  `0ee0579bd15cbbe4 / 32e5d4964d610fee / 1932b96ee4b1d910 / 69743c6bad3447dc`.
+- Core-off at 12.5 cm: `VOXELFORGE_CORE_OFF_LEGACY_PASS`.
+- M2 Hybrid V1 and V2 at 25 cm: five analytic fixtures and borders passed.
+- SurfaceWorld at 25 cm: BuildHost W1/W8/W16, geometry scale and height agreement, carve/fill,
+  native/bridge, and collision checks passed.
+- S3 far-horizon agreement: max 0.0427 cm against 2 cm.
+- S4 far-cap agreement: 128 shared points, max 0.0504 cm against 2 cm; negative control detected.
+  Cap rays: 1,584/1,584 (100%), no misses.
+- FloatingIslands at 25 cm: W1/W8/W16 stable:
+  `4dcfb37585d7d986 / f14f76fbf065c6ed / 53035c45fd1a082e / 23550100654a4ec3`;
+  island and span contacts, anchors, carve/fill passed; water remained fixed.
+
+No density, mesh, topology, payload, or collision output changed. No recipe bump or paired near/far
+captures are needed.
+
+## 6. Build, commands, and evidence
+
+Builds (Normal priority, maximum 12 parallel workers):
+
+```powershell
+.\Tools\BuildVoxelForgeCoreHost.ps1 -MaxParallelActions 12 -TimeoutSeconds 900
+.\Standalone\Build.ps1 -Target All -CompileWorkers 12 -BuildPriority Normal
+```
+
+BuildHost feature-stage controls:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -SharedFeatureAuditOnly -CoreMCStageAudit -CoreColumnCacheDirectMapped 1 -CoreMCGradientMemoization 0 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -SharedFeatureAuditOnly -CoreMCStageAudit -CoreColumnCacheDirectMapped 0 -CoreMCGradientMemoization 1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+Cold stream command:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -CoreColumnCacheDirectMapped 0 -CoreMCGradientMemoization 1 -TimeoutSeconds 900
+```
+
+The cold-path negative controls held every other argument fixed; the trace JSONL recorded the CVar
+readbacks (`0/0` for memo-off, `1/1` for direct-map):
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -CoreColumnCacheDirectMapped 0 -CoreMCGradientMemoization 0 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -StreamingTraceOnly -StreamingOrder Legacy -NearReserveMode Dynamic -CoreVoxelSizeCm 25 -StreamingCollisionLookahead 1 -TestMoveDirection '0,1,0' -CoreRegionConcurrentAdmission 1 -StreamingResultBacklogCap 256 -TestMoveSpeedCmPerSecond 4000 -StreamingReadyQueueDepth 8 -StreamingBackgroundWorkerCap 1 -CoreColumnCacheDirectMapped 1 -CoreMCGradientMemoization 1 -TimeoutSeconds 900
+```
+
+Standalone processes were sequential, Normal priority, 12-CPU affinity, and used `--force-generate`:
+
+```powershell
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=1 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=8 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --profile-column-overlap --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+.\Standalone\bin\VoxelForgeCoreStandalone.exe --workers=12 --world-assembler-prototype --stream-benchmark --stream-pipeline --stream-hash --force-generate --clip-radius=3 --max-clip-level=8 --camera=0,-35,-487.94,0,-22 --far-horizon-lod8-step=0 --process-priority=Normal --process-affinity=4095 --frame-limit=60
+```
+
+Other BuildHost gate commands:
+
+```powershell
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreOffTest -CoreVoxelSizeCm 12.5 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -HybridFixturesOnly -CoreMesherRecipe WorldAssemblerHybridV2 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+.\Tools\TestVoxelForgeCoreWorldHost.ps1 -FloatingIslandsOnly -CoreVoxelSizeCm 25 -TimeoutSeconds 900
+```
+
+Measured binaries and SHA-256:
+
+| Binary | SHA-256 |
+|---|---|
+| UE `UnrealEditor-Cmd.exe` | `ECCE9996191F7F7E69B3D104EECDD0E678AE69176FDCCD79828C3E75A0654D6D` |
+| BuildHost `UnrealEditor-VoxelForge.dll` | `4E55A38547B96221562AEC84D61B0FFC7E455E21420C51E14D2BEACA88217A07` |
+| BuildHost `UnrealEditor-VoxelForgeCore.dll` | `1F34F96208FC0E0A72CE2CE80014EBFB110C29C8333053A90735DF9C7BEE7949` |
+| BuildHost `UnrealEditor-VoxelForgeEditor.dll` | `9B35350BBA3E7CE4F8D8DA617C216B21CB4CF9869FE5903FD84AAC6906B8187B` |
+| Standalone `VoxelForgeCoreStandalone.exe` | `91D29D8BA421304F085BFAB4CCE5EC9DDD32C40BE13F15E118E0DC9606D21B84` |
+
+Full logs, traces, and Standalone stdout/stderr are under `Saved/BuildHost/`; the current 40 m/s
+trace files are in `Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/`.
+The fresh repeat uses the same CVar-derived JSONL path as the primary trace, so its JSONL is the
+current trace; the faster primary run's engine log summary is retained in that Logs directory as
+`CoreWorldValidation-owner_surface_stream_trace_only_applyboost_default_bgcap_1_readyq_8_legacy_order_colcache_4way_gradientmemo_on_nearreserve_dynamic_trace_move_4000_lookahead_1_dir_0_1_0_region_1_backlog_256-backup-2026.10.19-15.44.14.log`.
+Per-run Standalone command records and logs are in `Saved/BuildHost/WorldAssemblerM3/Round18/Standalone/`.
+
+## 7. Failed probes, retries, and safety review
+
+- `-coremcstageaudit=1` was ignored by Unreal’s boolean argument parser; the audit was repeated
+  with the bare `-coremcstageaudit` flag.
+- An early direct-map control did not read back `1`, and an early audit binary did not log either
+  new CVar. Those measurements were rejected. I added the S11-style explicit BeginPlay parse and
+  trace readback, rebuilt BuildHost, then reran the direct/off baseline and tuned audit; the JSONL
+  readbacks are `1/0` and `0/1` respectively.
+- The first corrected shared-audit command was rejected by a harness guard before launch because
+  it treated audit CVars as trace-only controls. The guard now allows them in shared-feature
+  audits; the rerun passed.
+- The first W8 Standalone wrapper could not resolve its process-local memory helper type. That
+  run exited 0 and its process peak was 0.70 GiB, but its free-memory preflight was invalid. I
+  repeated W8 with the helper defined in that process: free-before 17.12 GiB, peak 0.71 GiB,
+  exit 0, and the whole-view hashes matched W1/W12.
+- `Get-CimInstance` was denied and `Get-Counter` lacked the requested counter. I used
+  `GlobalMemoryStatusEx` instead; the initial available-memory reading was 15.85 GiB. BuildHost
+  scripts also enforce the 4 GiB preflight, Normal priority, 12-CPU affinity, 8 GiB process cap,
+  and 900 s timeout.
+- Standalone build printed that `vswhere.exe` was not recognized and emitted existing
+  `VoxelStrateManager.cpp` C4838 narrowing warnings, but built both targets and exited successfully.
+- BuildHost UBT passed on its first attempt; the 18 Core link shims passed link-safety inspection.
+  No `0xC0000142` occurred. No new `UECC-*` folder appeared (the only matching folder predates
+  this round, from 2026-09-17).
+- Final diff review made the gradient memo's per-tile validity reset explicit by clearing every
+  validity byte after resizing the scratch array. Both targets were rebuilt and the corrected-source
+  stage, determinism, quality, and cold-trace gates were rerun; hashes stayed identical.
+
+Diff review: no edits to `Epoch`, either MPSC queue, `EndPlay` draining, worker shutdown checks,
+`ModsLock`, immutable region-page lifetime, or game-thread UObject/RMC mutation. The new cache and
+gradient scratch remain thread-local. The readable RealtimeMeshComponent source was not modified.
+No owner project, editor, asset, generated header, `Binaries/`, or `Intermediate/` source was edited.
+No commit, push, or stash.
+
+## 8. Files and compile spots
+
+No new source file was added.
+
+| Changed file | Likely compile/build spot |
+|---|---|
+| `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`, `Standalone/Core/src/VoxelForgeCore.cpp`, `Standalone/Core/src/WorldAssemblerInternal.h` | Standalone Core and BuildHost `VoxelForgeCore` |
+| `Standalone/Source/VoxelForge/Public/VoxelMarchingCubesMesher.h`, `Standalone/Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp` | Standalone executable and BuildHost `VoxelForge` runtime |
+| `Source/VoxelForge/Private/VoxelWorld.cpp` | BuildHost `VoxelForge` runtime |
+| `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp` | BuildHost `VoxelForgeEditor` |
+| `Tools/TestVoxelForgeCoreWorldHost.ps1` | BuildHost validation harness; no compile |
+| `ARCHITECTURE.md`, `CODEMAP.md` | Documentation; no compile |
+
+### Dialogue
+
+**Owner:** What is inside the LOD0 MC-exclusive cost, why does LOD4 miss, and is a shared page worth it?
+
+**Codex:** LOD0’s dominant measured MC-exclusive stage is density-grid evaluation excluding XY
+column work (about 165 ns/sample), followed by grid-gradient normals (24 ns/sample after exact
+memoization). The cache counters show LOD4’s direct-map spike was chiefly conflicts; four-way sets
+remove those while keeping exact samples. Cross-worker repeats remain, but no shared-page A/B
+measured a net cold-path win, so I left the S8 page lifetime unchanged.

Standalone/Research/WorldAssemblerM3/Round9/CaptureViewerSequence.ps1

@@ -0,0 +1,175 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)][string]$Label,
+    [Parameter(Mandatory = $true)][string[]]$ViewerArguments,
+    [ValidateSet('Spawn', 'Flight')][string]$CaptureMode = 'Spawn',
+    [switch]$WaitForFlightDrain
+)
+
+# Capture through the viewer's D3D back buffer; no desktop or window capture is used.
+# Capturer le tampon D3D du viewer; aucune capture du bureau ou de la fenetre n'est utilisee.
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Drawing
+
+$PluginRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../../..'))
+$ViewerExe = Join-Path $PluginRoot 'Standalone/bin/VoxelForgeCoreStandalone.exe'
+$CaptureRoot = Join-Path $PSScriptRoot 'captures'
+$LogRoot = Join-Path $PSScriptRoot 'viewer_logs'
+[IO.Directory]::CreateDirectory($CaptureRoot) | Out-Null
+[IO.Directory]::CreateDirectory($LogRoot) | Out-Null
+
+if (-not ('VoxelForgeR9MemoryProbe' -as [type])) {
+    Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class VoxelForgeR9MemoryProbe {
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    private struct MEMORYSTATUSEX {
+        public uint dwLength, dwMemoryLoad;
+        public ulong ullTotalPhys, ullAvailPhys, ullTotalPageFile, ullAvailPageFile;
+        public ulong ullTotalVirtual, ullAvailVirtual, ullAvailExtendedVirtual;
+    }
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX status);
+    public static ulong AvailablePhysicalBytes() {
+        var status = new MEMORYSTATUSEX();
+        status.dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX));
+        if (!GlobalMemoryStatusEx(ref status)) throw new InvalidOperationException("GlobalMemoryStatusEx failed.");
+        return status.ullAvailPhys;
+    }
+}
+'@
+}
+
+if ([VoxelForgeR9MemoryProbe]::AvailablePhysicalBytes() -lt 4GB) {
+    throw 'Viewer launch skipped: less than 4 GiB of free physical memory.'
+}
+if (Get-Process UnrealEditor* -ErrorAction SilentlyContinue) {
+    throw 'Viewer launch skipped: an UnrealEditor process is still running.'
+}
+if (-not (Test-Path -LiteralPath $ViewerExe -PathType Leaf)) {
+    throw "Standalone viewer is missing: $ViewerExe"
+}
+
+Add-Type -AssemblyName System.Drawing
+$SafeLabel = $Label -replace '[^A-Za-z0-9_-]', '_'
+$SequenceSuffix = if ($CaptureMode -eq 'Spawn') { 'spawn' } else { 'mid_sprint' }
+$CapturePrefix = Join-Path $CaptureRoot "${SafeLabel}_${SequenceSuffix}"
+$RunArguments = [Collections.Generic.List[string]]::new()
+foreach ($Argument in $ViewerArguments) { $RunArguments.Add($Argument) }
+if ($CaptureMode -eq 'Spawn') {
+    $RunArguments.Add("--capture-spawn-sequence-prefix=$CapturePrefix")
+    $RunArguments.Add('--quit-after-spawn-captures')
+    $ExpectedIndices = @(0, 1, 2)
+    $TimeLimitSeconds = 60
+} else {
+    $RunArguments.Add("--capture-flight-sequence-prefix=$CapturePrefix")
+    if (-not $WaitForFlightDrain) { $RunArguments.Add('--flight-capture-close-index=1') }
+    $ExpectedIndices = @(1)
+    $TimeLimitSeconds = if ($WaitForFlightDrain) { 900 } else { 45 }
+}
+$StdoutPath = Join-Path $LogRoot "$SafeLabel`_$SequenceSuffix.stdout.log"
+$StderrPath = Join-Path $LogRoot "$SafeLabel`_$SequenceSuffix.stderr.log"
+$QuotedArguments = @($RunArguments | ForEach-Object { '"' + $_.Replace('"', '\"') + '"' })
+$ArgumentLine = $QuotedArguments -join ' '
+$Process = Start-Process -FilePath $ViewerExe -ArgumentList $ArgumentLine `
+    -WorkingDirectory (Split-Path -Parent $ViewerExe) -PassThru -WindowStyle Normal `
+    -RedirectStandardOutput $StdoutPath -RedirectStandardError $StderrPath
+$Started = [Diagnostics.Stopwatch]::StartNew()
+try {
+    $Process.PriorityClass = [Diagnostics.ProcessPriorityClass]::Normal
+    $Process.ProcessorAffinity = [IntPtr]0xFFF
+    while ($true) {
+        $Process.Refresh()
+        if ($Process.HasExited) { break }
+        if ($Process.PrivateMemorySize64 -gt 8GB) {
+            throw "Owned viewer PID $($Process.Id) exceeded the 8 GiB private-memory limit."
+        }
+        if ($Started.Elapsed.TotalSeconds -gt $TimeLimitSeconds) {
+            throw "Owned viewer PID $($Process.Id) exceeded the $TimeLimitSeconds-second capture limit."
+        }
+        Start-Sleep -Milliseconds 200
+    }
+    $Process.WaitForExit()
+    $Process.Refresh()
+    if ($Process.ExitCode -ne 0) {
+        throw "Owned viewer PID $($Process.Id) exited with code $($Process.ExitCode)."
+    }
+} catch {
+    $Process.Refresh()
+    if (-not $Process.HasExited) {
+        [void]$Process.CloseMainWindow()
+        if (-not $Process.WaitForExit(3000)) {
+            Stop-Process -Id $Process.Id -Force -ErrorAction SilentlyContinue
+            $Process.WaitForExit()
+        }
+    }
+    throw
+}
+
+function Save-DownscaledJpeg([string]$Source, [string]$Destination, [long]$Quality) {
+    $Original = [Drawing.Image]::FromFile($Source)
+    try {
+        $Width = [Math]::Min(960, $Original.Width)
+        $Height = [int][Math]::Round($Original.Height * $Width / $Original.Width)
+        $Small = New-Object Drawing.Bitmap($Width, $Height)
+        $Graphics = [Drawing.Graphics]::FromImage($Small)
+        try {
+            $Graphics.InterpolationMode = [Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
+            $Graphics.PixelOffsetMode = [Drawing.Drawing2D.PixelOffsetMode]::HighQuality
+            $Graphics.DrawImage($Original, 0, 0, $Width, $Height)
+            $Codec = [Drawing.Imaging.ImageCodecInfo]::GetImageEncoders() |
+                Where-Object { $_.MimeType -eq 'image/jpeg' } | Select-Object -First 1
+            $Parameters = New-Object Drawing.Imaging.EncoderParameters(1)
+            try {
+                $Parameters.Param[0] = New-Object Drawing.Imaging.EncoderParameter(
+                    [Drawing.Imaging.Encoder]::Quality, $Quality)
+                $Small.Save($Destination, $Codec, $Parameters)
+            } finally {
+                $Parameters.Dispose()
+            }
+        } finally {
+            $Graphics.Dispose()
+            $Small.Dispose()
+        }
+    } finally {
+        $Original.Dispose()
+    }
+}
+
+$ViewerLog = Get-Content -LiteralPath $StdoutPath -Raw
+foreach ($Index in $ExpectedIndices) {
+    $PngPath = '{0}_{1:D2}.png' -f $CapturePrefix, $Index
+    if (-not (Test-Path -LiteralPath $PngPath -PathType Leaf)) {
+        throw "Viewer exited normally but did not write required back-buffer capture index $Index."
+    }
+    if ($CaptureMode -eq 'Spawn') {
+        $CaptureTime = @('0.5s', '1.0s', '2.0s')[$Index]
+        $JpegPath = Join-Path $CaptureRoot "${SafeLabel}_spawn_$CaptureTime.jpg"
+    } else {
+        $JpegPath = Join-Path $CaptureRoot "${SafeLabel}_mid_sprint.jpg"
+    }
+    Save-DownscaledJpeg $PngPath $JpegPath 72
+    if ((Get-Item -LiteralPath $JpegPath).Length -ge 300KB) {
+        Save-DownscaledJpeg $PngPath $JpegPath 48
+    }
+    $Jpeg = Get-Item -LiteralPath $JpegPath
+    if ($Jpeg.Length -ge 300KB) { throw "Downscaled capture exceeds 300 KB: $($Jpeg.Name)" }
+    Remove-Item -LiteralPath $PngPath -Force
+    $Timing = [regex]::Match($ViewerLog, "\[(Spawn|Flight)SequenceCapture\] index=$Index elapsed_s=([0-9.]+)")
+    $Elapsed = if ($Timing.Success) { $Timing.Groups[2].Value } else { 'missing' }
+    Write-Host ('capture={0} elapsed_s={1} size={2} bytes' -f $Jpeg.Name, $Elapsed, $Jpeg.Length)
+}
+if ($CaptureMode -eq 'Flight') {
+    # Keep only the reviewed mid-flight JPG; remove this run's unused raw D3D frames.
+    # Garder uniquement le JPG de vol examine ; supprimer les tampons D3D bruts inutilises de ce run.
+    foreach ($Index in 0..4) {
+        $PngPath = '{0}_{1:D2}.png' -f $CapturePrefix, $Index
+        if (Test-Path -LiteralPath $PngPath -PathType Leaf) {
+            Remove-Item -LiteralPath $PngPath -Force
+        }
+    }
+}
+Write-Host ('viewer_closed=1 pid={0} exit_code={1} elapsed_s={2:0.000} priority=Normal affinity=0xFFF' -f
+    $Process.Id, $Process.ExitCode, $Started.Elapsed.TotalSeconds)

Standalone/Research/WorldAssemblerM3/Round9/REPORT.md

@@ -0,0 +1,147 @@
+# World Assembler S5 / M3 Round 9 — measured result
+
+**Status:** Standalone and BuildHost compile. Regression checks pass. The S5 scheduler is retained as an opt-in experiment; legacy order is the default again. S5 did not demonstrate an enclosure or walkability win, and the viewer could not confirm what was presented to the screen. The 60 m/s result also had invalid center deltas.
+
+## Count, binaries and timing protocol
+
+The owner clipmap is 2,553 tiles: 960 LOD0/1 and 1,593 coarse tiles. The final Standalone executable is Standalone/bin/VoxelForgeCoreStandalone.exe.
+
+The matched CPU protocol used a fresh process, the staged owner_world.json, 12 workers, normal priority, affinity 0xFFF, radius 3, max LOD 8, camera 0,-35,-487.94,0,-22, world-assembler-prototype, force-generate, stream-benchmark and stream-hash. Same mode and settings for before/after:
+
+| Run | 2,553 tiles | Hashes |
+|---|---:|---|
+| Legacy order | 3.641 s | Same as candidate |
+| Coarse-first | 3.620 s | Same as legacy |
+| Final coarse-first repeat | 3.579 s | Same as legacy |
+| Final rebuilt default (legacy) smoke | 3.592 s | Same as legacy |
+
+This is a 0.6–1.7% difference, within run noise. The 27-tile CPU mesh-ready measurement was 55 ms legacy / 22 ms coarse-first; Standalone has no collision cooking, so this is not a walkability result.
+
+Round 7/8 report 2.975/3.107 s. The saved reproduction log, s4_protocol_reproduce_ffff.stdout.log, reproduces the 3.1 s result at 3.146 s with the prototype route, 2,553 tiles, 12 workers, hash on, normal priority and affinity 0xFFFF. The Round 7/8 reports did not preserve the exact executable hash or full launch command, so the historical binary identity cannot be established. Their Round 8 p95 run also inherited 0xFFFF, while the main S5 before/after protocol pins 0xFFF.
+
+The reported 16.685 s run has no raw command log. A later run without the prototype route took 18.668 s, produced a different density hash, and emitted no LOD8 cap triangles; the correct prototype route produces density hash c10697a8f48380c7 and the 385-tile cap. This makes a different generation route the likely cause of the 16.685 s result, but the missing original log prevents proving its exact flags. It was not a matched comparison based on tile count alone. CPU-idle state was not controlled.
+
+## Capture and cap instruments
+
+The old black sequence logged three Presents with zero tile geometry and zero draw batches before its screenshots. That points to clear-only startup frames, not a capture-before-first-present race. Its logger did not tie each image to a frame index, so the exact capture frame cannot be proven. The matched S5 captures record frame index, prior presents, resident meshes, draw batches and triangle counts at capture:
+
+| Sample | Legacy frame / tiles / batches / triangles | Coarse-first frame / tiles / batches / triangles |
+|---|---|---|
+| Spawn 0.5 s | 4 / 451 / 6 / 151,020 | 5 / 76 / 4 / 834,954 |
+| Spawn 1.0 s | 13 / 1,801 / 41 / 446,090 | 12 / 133 / 4 / 1,804,858 |
+| Spawn 2.0 s | 25 / 2,308 / 70 / 904,353 | 27 / 559 / 44 / 3,240,081 |
+
+The capture reads the D3D back buffer pre-present after earlier frames have presented. The candidate Presents returned DXGI_STATUS_OCCLUDED even though the window was visible, so the images prove rendered back-buffer geometry but cannot establish player-visible pixels. The coarse-first images are visibly much sparser at spawn; treat that as a possible early visual regression, not a confirmed screen result.
+
+Matched JPEGs are 9.7–21.8 KB, all below 300 KB. The viewer was capped at 60 fps with VSync and closed after capture. Coarse-first is now opt-in with --coarse-first-stream-order; legacy is the default:
+
+| Capture | Legacy | Coarse-first |
+|---|---|---|
+| Spawn 0.5 s | [JPG](captures/s5_before_legacy_spawn_0.5s.jpg) | [JPG](captures/s5_after_coarse_spawn_0.5s.jpg) |
+| Spawn 1.0 s | [JPG](captures/s5_before_legacy_spawn_1.0s.jpg) | [JPG](captures/s5_after_coarse_spawn_1.0s.jpg) |
+| Spawn 2.0 s | [JPG](captures/s5_before_legacy_spawn_2.0s.jpg) | [JPG](captures/s5_after_coarse_spawn_2.0s.jpg) |
+| 10 m/s mid-sprint | [JPG](captures/s5_before_legacy_10ms_mid_sprint.jpg) | [JPG](captures/s5_after_coarse_10ms_mid_sprint.jpg) |
+| 60 m/s mid-sprint | [JPG](captures/s5_before_legacy_mid_sprint.jpg) | [JPG](captures/s5_after_coarse_mid_sprint.jpg) |
+
+The S4 low-angle ray audit used the same owner camera at voxel origin (0,-140,-1951.8): all 72 upward rays at that view hit the roof, and all 2,520/2,520 audit rays hit. The dark “sky” region is the cap underside, not uncovered sky. S4 reports 385 refined LOD8 cap tiles; the final band census requested 413 cap bands, emitted 411, and classified the remaining two as zero-area boundary touches, with no unexplained empty bands. Far/near agreement was 0.0504 cm against a 2 cm tolerance.
+
+## Gates and sprint results
+
+The BuildHost actor trace reports collision readiness for the support tile and required 3×3 ring. Both orderings reached 9/9 ready at cold spawn:
+
+| Gate interval | Legacy | Coarse-first |
+|---|---:|---:|
+| Cold spawn | 0.583→0.624 s (41.2 ms) | 0.577→0.618 s (41.6 ms) |
+| Teleport to center (-5,0,-26) | 6.427→6.642 s (215 ms) | 6.389→6.598 s (208 ms) |
+| Teleport to center (-2,8,-47) | 15.066→15.349 s (283 ms) | 14.943→15.504 s (561 ms) |
+
+The actor test teleported between centers and logged speed 0; it is not a 10/60 m/s actor walk. Two separate enforced-collision-gate runs, one per order, reached the 900 s limit while support requests kept recentering. Thus the readiness counter passed at cold spawn, but physical gate enforcement during movement remains unverified.
+
+Standalone cannot measure collision readiness. Its logged full LOD0/1 set completed at 0.889 s in the legacy spawn run. Coarse-first had not completed that set by the 2.053 s capture; its 10 m/s run logged completion at 3.450 s. The 1.57 s refinement target therefore failed for coarse-first in this viewer workload.
+
+BuildHost full-set residency samples were spaced about 250 ms apart. These are per-LOD total residency times from trace start, not per-tile time-in-range:
+
+| LOD | Legacy seconds | Coarse-first seconds |
+|---:|---:|---:|
+| 8 | 3.352 | 3.338 |
+| 7 | 3.603 | 3.589 |
+| 6 | 3.854 | 3.841 |
+| 5 | 4.105 | 4.092 |
+| 4 | 4.858 | 4.847 |
+| 3 | 5.108 | 5.099 |
+| 2 | 5.360 | 5.351 |
+| 0 | 5.865 | 5.853 |
+| 1 | 6.367 | 6.354 |
+
+The largest difference is 13 ms, below the sample interval. The full desired LOD sets arrive after the 1.57 s goal in both orders. Enclosure gap frames/time were not measured: DXGI reported occlusion, and no reliable screen-visible gap counter exists. The static S4 ray audit proves roof coverage after generation, not startup or moving enclosure.
+
+The S5 full-view tile p95 probe used the same 12 workers, normal priority, inherited affinity 0xFFFF, 60 fps/VSync and no timeline trace for both orderings. Each viewer was closed immediately after InitialClipmapReady:
+
+| LOD | Legacy p95 ms | Coarse-first p95 ms |
+|---:|---:|---:|
+| 0 | 16.398 | 17.456 |
+| 1 | 15.665 | 15.804 |
+| 2 | 4.393 | 4.292 |
+| 3 | 17.263 | 18.055 |
+| 4 | 59.038 | 58.867 |
+| 5 | 17.649 | 17.915 |
+| 6 | 51.086 | 57.610 |
+| 7 | 29.419 | 32.116 |
+| 8 | 82.782 | 85.041 |
+
+The coarse-first full view took 3.309 s versus 3.187 s legacy. LOD6/7 p95 rose 12.8%/9.2% in this one pair; the result cannot establish “within noise.” S4’s p95 check was a separate eight-key staged test (LOD7 19.801/19.807 ms, LOD8 58.346/58.411 ms for S3/S4) and was not replayed on those exact keys in S5. Do not claim an apples-to-apples S3/S4 p95 pass.
+
+Standalone sprint benchmark results:
+
+| Speed | Order | Requests incl. 2,553 spawn | Queued cancellations | Discarded stale results | Nearest-ready p95 / max | Max lag p95 / max | Status |
+|---:|---|---:|---:|---:|---|---|---|
+| 10 m/s | Legacy | 33,730 | 3 | 10 | 126.628 / 171.452 ms | 1.27 / 1.71 m | FAIL |
+| 10 m/s | Coarse-first | 33,730 | 0 | 0 | 129.812 / 148.705 ms | 1.30 / 1.49 m | FAIL |
+| 60 m/s | Legacy | 39,632 | 29,809 | 138 | 93.101 / 114.475 ms | 5.59 / 6.87 m | FAIL, invalid deltas |
+| 60 m/s | Coarse-first | 38,679 | 22,662 | 120 | 68.748 / 182.143 ms | 4.12 / 10.93 m | FAIL, invalid deltas |
+
+The 10 m/s route had valid unit-+Y center deltas: coarse-first slightly worsened p95 lag but improved worst lag. At 60 m/s the center deltas were invalid, so the apparent p95/crossing-wall improvement is not a valid matched gate win; its worst nearest-ready lag was worse by 67.7 ms. Request/cancellation counts cover the initial cold request set and crossings 1–250; stale discards include initial work and crossings 1–250.
+
+The actor trace’s UpdateChunks sample is not an isolated scheduler timer. Legacy mean/p95/max was 0.549/0.683/5.480 ms; optimized coarse-first was 0.116/0.269/4.860 ms. The pre-optimization candidate had 79.073 and 35.510 ms spikes from sorting each level repeatedly while at capacity. The final candidate skips full queues and only sorts missing, nonpending tiles. No blocking wait was added to Tick.
+
+## Determinism, regression checks and async safety
+
+Standalone final 2,553-tile hashes match S4: density c10697a8f48380c7, mesh 430d2be2bdd8b988, payload b7b33e14092225c9, topology c5c46d66606a819e. LOD0–3 hashes also match S4 exactly:
+
+| LOD | Density | Mesh | Payload | Topology |
+|---:|---|---|---|---|
+| 0 | 769f2a706d585a72 | 33eeeb39fa443816 | 645621a1d968983f | c2457ed905036c9d |
+| 1 | 69cc5a5c0a2c60af | b48335f5410c57d5 | d15c5480162ab8ba | feca1bd025823604 |
+| 2 | 85deed5683a77202 | 53469895987aeea2 | e55f8ae7e1532033 | d5feb12a0e85c09b |
+| 3 | 6518caefb3be7e7f | ec513c90b853a614 | f62fa1137ff17f82 | ccf1dcf681965816 |
+
+BuildHost SurfaceWorld at 25 cm passed W1/W8/W16 with density 0cd2a1a4152ee4aa, mesh 80a5b054b904b1a2, payload bf2f1b40dff38acc, topology 56074198682d5e18. FloatingIslands at 25 cm passed W1/W8/W16, collision, edits and switch-off. Core-off legacy passed at 12.5 cm; M2 V1 and V2 each passed five focused fixtures plus border. S4 roof coverage/agreement and S3 ground agreement passed; final ground delta was 0.000 cm and final far-horizon agreement max was 0.0427 cm.
+
+Async safety audit: all four result queues remain EQueueMode::Mpsc; EndPlay sets bShuttingDown, waits ActiveTaskCount to zero, then drains queues. Generation workers check shutdown state. Both LoadTile and LoadCoreTile carry GenerationEpoch in the result and reject stale results; ModsLock behavior is unchanged. No async path or generated header was removed or rewritten.
+
+## Builds, run ledger and changed files
+
+Final Standalone Build.ps1 -Target All and BuildVoxelForgeCoreHost.ps1 builds passed. BuildHost link safety checked 96,244 dumpbin lines against 421 copied type names, verified five staged asset hashes, and linked/audited 18 Core shims. Recent launches had over 17 GiB free RAM; recorded runtime peaks stayed below 4 GiB. No run returned 0xC0000142. No new UECC-* folder appeared; the only crash folder is dated 2026-09-17.
+
+Failed, retried or capped attempts:
+- The first baseline used the default camera and generated 2,226 tiles in 6.521 s; the owner-camera run restored 2,553.
+- One standalone hash launch omitted stream-benchmark and entered the viewer; it was stopped after 146 s and rerun correctly. A later clip-radius 6 request hit the standalone safety bound.
+- A generic horizon test targeted invalid /Game/Untitled and failed; it was not an owner-world result. Initial headless/GDI captures did not read the D3D frame; the viewer back-buffer path replaced them.
+- Get-CimInstance memory preflight was denied; subsequent checks used GlobalMemoryStatusEx. A fresh-shell helper/preflight attempt failed before process launch and was corrected. Two tile-profile command strings also had PowerShell parse errors before launch; the corrected pairs produced complete metrics.
+- Both enforced-collision-gate actor runs timed out at 900 s while support requests recentered. All four tile-profile viewers reached InitialClipmapReady, were closed deliberately, and returned exit -1 on WM_CLOSE; their timing output was complete.
+
+**Habits:** Counted 2,553 tiles and checked the executable/mode; evaluated the staged owner plan and walk; used fresh matched before/after settings; explained the Round 7/8 timing discrepancy and affinity difference; kept the result report bounded to measured outcomes.
+
+## Source files and compile spots
+
+No new C++ source file was added. Modified C++:
+- Source/VoxelForge/Private/VoxelWorld.cpp and Source/VoxelForge/Public/VoxelWorld.h — VoxelForge runtime module; BuildHost UBT.
+- Source/VoxelForge/Private/VoxelStartupTrace.cpp and Source/VoxelForge/Public/VoxelStartupTrace.h — VoxelForge runtime module; BuildHost UBT.
+- Standalone/Source/StandaloneViewer.cpp and Standalone/Source/StreamingWorld.h — Standalone/Build.ps1 -Target All.
+
+Modified supporting scripts/docs: Standalone/Build.ps1, Tools/VoxelForgeTest.ps1, Tools/TestVoxelForgeCoreWorldHost.ps1, Standalone/Research/WorldAssemblerM3/Round9/CaptureViewerSequence.ps1, CODEMAP.md §3, ARCHITECTURE.md §8.26. The capture helper is the only new helper source.
+
+### Dialogue
+
+**User:** Check the instrument before judging the scheduler.  
+**Luna:** The 3.1 s prototype result reproduced; the matched gates did not justify a default-on order, so coarse-first remains opt-in.