# World assembler M1 report

M1 has five implementation rounds. The gates at the end of the milestone remain the agreed
two-biome SurfaceWorld in the owner's game, including coast, cliff/overhang, cap and a walkable
route; conservative bound audits; route sweep; identical evaluator hashes at W1/W8/W16; separate
local query/collision readiness and full-view timings; faster matched workload than the 23.085 s
legacy bridge; and server field queries that do not depend on render meshes. The approximately
1.57 s whole-view aim (2 × the 0.785 s cave-only Core measurement) is an aim, not an acceptance gate.

## Round 1 of 5 — native foundations

- Define the fixed-scale, versioned, hashed recipe and shipped-plan payload, including the Core
  field-block contract and explicit field channels.
- Add a brute-force interval audit with a deliberately false bound as a negative control.
- Implement the first native `Heightfield2D` block with biome-map input and compare it with the
  SurfaceWorld legacy bridge in the standalone viewer.
- Record current hashes, timings, audit results and a small owner/native capture pair. This round
  establishes a heightfield baseline; it does not claim the final two-biome/coast/cliff/route gate.

## Round 2 of 5 — complete the surface recipe

- Add output-space biome blending, coast and beach shaping, cap detail, cliffs and bounded 3D
  overhang exceptions with stable feature IDs and certified influence bounds.
- Keep unknown or intersecting exception intervals on the evaluation path. Expand the brute-force
  audit across biome borders, cliffs, caps, negative coordinates and exception bounds.
- Measure surface field query cost separately from cave compilation and full-view rendering; tune
  caches only after the workload and cache identity are fixed.

## Round 3 of 5 — repair the shipped surface before routes

- Diagnose and repair the raised rectangular surface patch and the floating cliff shard from
  round 2. Add a negative-control regression for the former box feature and a seam/classification
  continuity check.
- Profile plan setup, column-cache hits/misses, classifier outcomes, native field call types and
  meshing by LOD. Improve native readiness until it beats legacy on the same matched workload;
  measure the remaining distance to the approximately 1.57 s aim.
- Keep the bounds audit and its negative control, W1/W8/W16 evaluator and mesh hashes, legacy
  mismatch metrics, and no-manifest cave path green. Save fresh matched surface, border, coast and
  cliff captures.

## Round 4 of 5 — route and query readiness

- Ship the finite-strate plan with route points, support constraints and stable IDs. Sweep the actual
  player capsule over the final composed field and repair/reject any failing candidate.
- Verify W1/W8/W16 evaluator hashes, route clearance/support and deterministic plan serialization.
- Keep the capsule-swept, supported route valid through generation and automatic/scripted changes.
  Player carve/fill edits are unrestricted and may break or plug the route. Seas and rivers stay fixed
  for the season, with shore behavior under edits measured separately.
- Report local field-query and collision readiness separately from render mesh readiness, and show
  a server-side field query path that does not build or require render meshes.

## Round 5 of 5 — Unreal delivery and owner review

- Import the reviewed manifest into the season asset/content hash path and connect the native Core
  evaluator behind `bUseVoxelForgeCore`, preserving the legacy path when the flag is off.
- Build only the isolated BuildHost target here; the owner builds the project. Review the two-biome
  surface and route in-game, then publish matched workload timings, hashes, audit logs and captures.
- Close every M1 gate or name the failed gate, its evidence and the additional repair round needed.

## Round 1 results

### Deliverables

- Added the public recipe, shipped-plan, hash, channel, block-contract, interval, influence and
  detail-envelope types in `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`. Recipe and
  evaluator schemas are version 1. All recipe, plan, feature, route and field coordinates use signed
  1/256-voxel integers; the plugin's Core voxel remains 25 cm.
- Added manifest parse/finalize/validate/serialize and canonical FNV-1a 64 hashing in
  `Standalone/Core/src/WorldAssemblerInternal.h`. Fields hash in declared order as little-endian
  4/8-byte words. Hashes are 16 lowercase hex digits; JSON key order and whitespace are ignored.
  The optional owner-snapshot `world_assembly` field matches the payload shape planned for the
  season manifest. The current review artifact is
  [`round1-manifest.json`](Research/WorldAssemblerM1/round1-manifest.json); season asset/hash-path
  integration remains for round 4.
- Added native `Heightfield2D`: deterministic warped Voronoi biome selection with Q16 border blend,
  fixed integer profile noise, ground and cap heights, signed density (`negative = solid`), declared
  channels, a conservative global interval, unbounded XY/finite-stratum-Z influence and an explicit
  detail envelope. The current block reads `biome` and writes `height` and `rock`. Water, route and
  surface-tag channels are declared for later blocks, not yet emitted by this block.
- Connected that block to native Core density queries and added the standalone audit/viewer switches.
  `API.md` documents the current data format and its limits.

### Sample manifest and hashes

The viewer builds a sample from the owner's `type_4_SurfaceWorld.json` probe: one finite strate
(index 1, chunk Z -16 through -79), two synthetic stable biome IDs (4097 and 4098), no planned
features, and no route points yet. The compact manifest is 972 bytes.

| Content | Hash |
|---|---|
| Recipe | `5cc6cfb49073d366` |
| Plan | `9aa8b4c29a69233a` |
| Manifest | `c87ae279b0e26f53` |
| Heightfield sample stream, 4096 points | `fae2721c052aec5c` |

The sample block reports influence Z `[-2528, -480]` voxels, maximum displacement envelope
`247` voxels, and minimum feature size `25` voxels. These prototype ranges are not the final
composer-supported recipe envelope.

### Bounds and determinism audit

The brute-force audit tested 256 randomized boxes with a 3×3×3 sample grid per box (6,912 points).
It found zero missed bounds and zero unknown bounds. Its deliberately false one-sided interval was
rejected, so the negative control passed. This is evidence for the current Heightfield2D
implementation and audit path, not a proof for future field blocks or the final cliff/overhang
composition.

The 4,096-point evaluator output hash matched at W1, W8 and W16 (`fae2721c052aec5c`). The timing
scope was point evaluation only: W1 2.059 ms, W8 6.851 ms, W16 12.626 ms. W8 and W16 were slower
on this small batch, likely from thread-startup overhead; no parallel speedup was measured. These
numbers are not a full view or tile benchmark.

### Legacy comparison and captures

For the same 4,096 points, the direct legacy density query took 62.115 ms. The prototype's mean
absolute density error was 274.0383 voxels, maximum error 841.4257 voxels, with 2,261 sign
mismatches (55.2%). The prototype is therefore not yet a parity replacement for the legacy field.
The current biome map and two-profile output need further shaping against the reference.

The small top-down pair uses the same 3200-voxel XY span and one color ramp fitted to the observed
owner and native heights together (range `[-2273.12, -1410.26]` voxels): owner `GetSurfaceHeightAt`
reference and native Heightfield2D ground height. Each JPEG is below 6 KB.

| Owner reference | Native prototype |
|---|---|
| ![Owner SurfaceWorld height reference](Research/WorldAssemblerM1/owner-reference-height.jpg) | ![Native Heightfield2D prototype](Research/WorldAssemblerM1/native-prototype-height.jpg) |

The pair shows a large visible mismatch; it is a height-map comparison, not an in-game render. A
separate D3D window-backbuffer capture attempt was invalid: both viewer windows reported
`DXGI_STATUS_OCCLUDED`, the saved backbuffers were black, and the native prototype produced zero
mesh vertices/indices. The reduced diagnostic images were inspected only after downscaling. Do not
use those D3D files as visual evidence.

### Query, collision and view readiness

The audit compiled a Core world around the sample heightfield, queried 45 positions through
`World::densityAt`, and compared them with direct Heightfield2D evaluation. Maximum error was zero;
the sample Core compile took 35.608 ms; no tile mesh was generated
(`render_meshes_generated=0`). This verifies the local Core field-query path without render meshes
for this sample. It does not yet verify a dedicated-server build or the Unreal adapter.

The no-manifest cave Core path also passed a constrained regression smoke on the existing
`type_3_Maze.json` fixture: the 5,642-point walkability audit passed, all 27 player-neighborhood
tiles and all 64 requested LOD0 tiles generated, and full-detail readiness was 0.157 s at W16.
The shape compile was 0.100 s. This small 64-tile LOD0 run confirms the additive no-plan path still
works; it is not the 23.085 s matched workload or the 0.785 s cave-only whole-view baseline.

Collision cooking is not available in the standalone audit and was not measured. Full-view time was
also not measured by audit mode. Earlier small-view D3D attempt timings (owner 0.236 s, native
0.309 s) are not a valid full-view comparison because presentation was occluded and the native
view had no geometry. The 23.085 s matched-workload gate remains open. The ~1.57 s aim remains
reasonable, but round 1 has no valid full-view evidence to support or reject it.

## Round 2 results

### Round 1 mismatch diagnosis

Round 1 was structurally underfit, not mis-scaled or shifted by a constant height datum. The sample
used two synthetic biome profiles (IDs 4097 and 4098) and a reduced height model. The owner export
uses four resolved surface profiles and relief/moisture climate ranges; the baseline also omitted
the mountain and relief response, height warp, output-space profile blend, coast/beach and cliff
shaping, and per-biome cap detail added in evaluator 2. Both sides use 25 cm voxels, and the current
4,096-column check finds only a -1.366-voxel mean height offset. The owner and Core biome IDs now match on all 4,096
diagnostic columns. These measurements point to missing structure and profile assignment rather
than a unit conversion, datum offset, detail-noise phase, or biome-ID selection error.

This round changed those terms as a group, so the before/after result does not isolate each term's
individual contribution. On the same 4,096 density-query points, mean absolute error fell from
274.0383 to 17.2262 voxels, maximum density error from 841.4257 to 392.4136 voxels, and sign
mismatches from 2,261/4,096 (55.2%) to 743/4,096 (18.14%). The separate 4,096-column height
diagnostic now reports MAE 13.060 voxels, maximum error 203.728 voxels, correlation 0.96496 and
linear-fit slope 0.95136. Residual peaks and sign errors remain visible; this is not parity.

### Evaluator, manifest and audit

Evaluator 2 keeps schema 1 and fixed signed 1/256-voxel units while adding deterministic
climate-based assignment across the owner's four profiles, output-space ground and cap blending,
per-profile relief/height warp/beach/cliff/cap settings, fixed-season water outputs, and stable-ID
bounded 3D overhang exceptions. Player carve/fill edits remain unrestricted; route constraints only
apply to automatic system generation or changes. This sample has one bounded exception
(`09812c26310b90c9`) and no route yet; route planning and capsule sweep remain round 4.

The evaluator-v2 review manifest is 4,514 bytes. Recipe hash is `dbe949967c0dfbce`, plan hash is
`165a00c4a77ebae0`, and manifest hash is `203d7043158069f6`. The 4,096-sample evaluator hash is
`c5e0371612e927af` at W1, W8 and W16. Bounds audit passed with 298 boxes and 8,046 points: zero
missed and zero unknown bounds; 16 biome-border boxes, 16 cliff boxes, 9 cap boxes, 248
negative-coordinate boxes, and one exception box with 27 exception samples. The deliberately
wrong one-sided bound was detected.

The final interval audit followed one failed audit with 102 missed bounds. Inspection found the cap
range was overwritten by a global plan range and that plateau/beach and cliff envelopes were
incomplete. Those envelopes were corrected before the final run. The current result is a sampled
audit of this evaluator and recipe, not a mathematical proof for arbitrary future inputs.

### Matched 3D captures

Each pair uses the same camera for owner and native Core, with full-detail tiles ready before
capture. Images are 640×400 JPEGs; each file is 9,089–17,961 bytes. The native surface, border and
coast pairs broadly agree in silhouette. The cliff pair shows a remaining large difference: the
owner has an extreme noisy overhang, while the prototype currently emits the bounded, smoother
shelf. Water height/fill is emitted as a field sample, but a water overlay mesh is not implemented,
so the coast captures do not show rendered water.

| Site and shared viewer camera (x, y, z; yaw, pitch) | Owner reference | Native Core |
|---|---|---|
| Surface `(0, -35, -487.943; 0, -22)` | ![Surface owner reference](Research/WorldAssemblerM1/round2/captures/surface-owner.jpg) | ![Surface native Core](Research/WorldAssemblerM1/round2/captures/surface-native.jpg) |
| Biome border `(128, -243, -492.912; 0, -22)` | ![Biome border owner reference](Research/WorldAssemblerM1/round2/captures/border-owner.jpg) | ![Biome border native Core](Research/WorldAssemblerM1/round2/captures/border-native.jpg) |
| Coast `(336, -67, -477.755; 0, -22)` | ![Coast owner reference](Research/WorldAssemblerM1/round2/captures/coast-owner.jpg) | ![Coast native Core](Research/WorldAssemblerM1/round2/captures/coast-native.jpg) |
| Cliff `(-168, 70, -445.712; 0, 34)` | ![Cliff owner reference](Research/WorldAssemblerM1/round2/captures/cliff-owner.jpg) | ![Cliff native Core](Research/WorldAssemblerM1/round2/captures/cliff-native.jpg) |

`Present` continued to return `DXGI_STATUS_OCCLUDED`, including after bringing the viewer forward.
The first surface back-buffer file was black and was excluded. The foreground retry's copied
back-buffer was nonblack and visibly contained generated geometry; the final pairs above use that
verified capture path. This validates the native mesh/viewer path for these captures, but the
presentation status itself remains unresolved.

### Query, cave compile and full-view timings

| Measurement | Result | Scope |
|---|---:|---|
| Surface point queries W1 | 13.569 ms | 4,096 evaluator points, point evaluation only |
| Surface point queries W8 | 8.085 ms | same points, same field hash |
| Surface point queries W16 | 12.396 ms | same points, same field hash |
| Legacy owner density queries | 61.974 ms | same 4,096 points; reference timing, not a performance gate |
| Core world compile and query bridge | 36.295 ms; 45/45 exact | Surface recipe; `World::densityAt`, no render mesh |
| Existing cave-only shape compile | 0.100 s | no-manifest `type_3_Maze.json` smoke, from round 1 |
| Owner full-detail readiness | mean 2.882 s | 120 near tiles (64 LOD0 + 56 LOD1), 16 workers, four capture sites |
| Native Core full-detail readiness | mean 5.227 s | same tile count, workers and sites; range 4.401–6.636 s |

| Capture site | Owner | Native Core |
|---|---:|---:|
| Surface | 2.873 s | 4.401 s |
| Biome border | 2.904 s | 4.907 s |
| Coast | 2.877 s | 4.962 s |
| Cliff | 2.874 s | 6.636 s |

The cave compile and surface query figures are separate workloads. The surface viewer took longer:
the native 5.227 s mean is 81% above the owner's 2.882 s on these matched views. This 120-tile
clip-radius-1 workload is not the agreed 23.085 s matched-workload gate. All viewer runs used 16
workers; maximum observed full-detail time was 6.636 s at the upward-facing cliff camera.

### Round 2 run log

- The first evaluator build failed because the JSON parser version has no `IsBool`/`IsNull` methods.
  The parser was changed to inspect the JSON value variant, and the next isolated build passed.
- The first expanded interval audit failed with 102 escaped samples. The envelope fixes described
  above were applied and the final audit passed. No failing result was discarded from the report.
- The initial native D3D surface capture was black with an occluded presentation status. A
  foreground recapture still reported the same status but its back-buffer contained visible mesh
  geometry; only the verified foreground copy was used. All four final owner/native pairs are
  downscaled and below 18 KB per image.
- Successful final standalone builds completed in under one minute with `/MP16`, Normal priority
  and 16 CPUs. Existing `vswhere.exe` lookup output and C4838 narrowing warnings at
  `VoxelStrateManager.cpp:3974-3975` remain nonfatal. No process exceeded the 15-minute limit or
  8 GB cap; no `0xC0000142` retry occurred. The crash-folder check found only the pre-existing
  `UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000` from 2026-09-17 and no new UECC folder.
- No owner project or BuildHost project was built. No `.uasset` was opened or changed. No new source
  files were added.

## Round 3 results — repair before routes

### Defects and repairs

The raised block and the floating cliff shard came from the same shipped-plan feature: type 2 was
interpreted as a full solid AABB. The round-2 plan placed it at x `[-708,-636]`, y `[380,460]` and
z `[-1695,-1680]` voxels, so its flat top and vertical walls were expected consequences of the
recipe rather than a tile cache or seam error. The prototype now emits a type-4 terrain-following
tapered shelf. It samples the native base-height range over its footprint for finite Z bounds,
smoothly unions the shelf into the height field, and retains type-2 semantics for older plans.

The regression audit samples 25 points in baseline air above the shelf: the type-2 negative control
blocks all 25 while type 4 blocks zero. The audit also requires the negative control to be detected.
The tile-seam classifier check covers 50 boxes and 900 lattice points across 32-voxel seams with
zero false solid/air classifications. The former broad type-2 box would fail the shape audit.

The new cliff capture shows a single attached, tapered shelf without the floating slab and debris
trail from round 2. It is a coherent procedural cliff rather than a reproduction of the legacy
overhang's noisy, stair-stepped surface; visual and density parity with the owner is still not
claimed.

### Bounds, determinism and legacy comparison

The final bounds audit passed 298 boxes and 8,046 point samples with zero missed or unknown bounds;
its deliberately wrong-bound negative control was detected. W1/W8/W16 evaluator hashes all match
at `6d249c9e3b7c7a03`. The 120 full-detail tile set also has matching worker-count hashes:

| Hash | W1, W8 and W16 |
|---|---|
| Density | `66a43186eedce63d` |
| Mesh | `7a47273589966250` |
| Payload | `2488a207c3103f67` |
| Topology | `8a17eced70a37323` |

The 4,096-point owner comparison is unchanged to reported precision: biome mismatches `0/4096`,
height MAE `13.060` voxels, density MAE `17.2259` voxels, maximum density error `392.4136`, and
sign mismatches `743/4096` (`18.14%`). The residual errors are still visible and remain a later
parity task. The Core field query bridge remains exact at `45/45` points and generated no render
meshes.

The no-manifest `type_3_Maze.json` smoke passed: the cave shape compiled with 16 workers, the
walkability scan passed `5642/5642`, and the LOD0 stream benchmark generated `64/64` tiles. This
checks that the additive surface path leaves the existing Core cave path operational.

### Matched timing and stage profile

All timings below use the current standalone binary, Normal process priority, all 16 CPUs and the
same owner JSON. Full-detail comparisons use the same 120 tiles at each camera; the full-view pair
uses the same 529-tile surface clipmap.

| Site | Legacy 120 tiles | Native 120 tiles |
|---|---:|---:|
| Surface | 0.597 s | 0.063 s |
| Biome border | 0.630 s | 0.090 s |
| Coast | 0.611 s | 0.077 s |
| Cliff | 0.660 s | 0.124 s |
| Mean | **0.625 s** | **0.089 s** |

Native averages 7.1× faster for these matched full-detail tiles. On the full clipmap the legacy
run took `11.687 s` and native took `3.858 s` (`3.03×` faster, a 67.0% reduction). The `1.57 s`
whole-view aim remains unmet: this native stream-generation measurement is `2.288 s` over the aim,
or `2.46×` the aim. The separate cold viewer capture reached its initial 529-tile clipmap in
`4.35 s`.

The current native run reports plan construction at `6.928 ms` and the shape compile at about
`0.200 s`. Across the 529 streamed tiles, classification reported 29 solid, 196 air, 223 mixed and
273 unknown box outcomes, with 141 whole-tile meshing skips. Native field calls totaled 16,012,931:
13,438,461 float, 2,409,044 lattice and zero unclamped calls. The per-thread column cache recorded
4,281,385 hits and 11,731,564 misses; its column-compute worker-time sum was `53.450 s`. Classifier
worker time summed to `0.403 s` and mesher worker time to `4.372 s`. Worker-time sums include all
workers and are not wall-clock stages. `field_calls` includes direct classifier point probes;
float/lattice subtype counters count density callback routes and are a subset, not an additive split.

Per-LOD counts and worker-time sums from the same run:

| LOD | Tiles | Solid/air/mixed/unknown outcomes | Tile skips | Field calls | Column hits/misses | Column ms | Classify ms | Mesh ms |
|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| 0 | 64 | 0/145/111/0 | 61 | 213,514 | 143,665/69,849 | 175.241 | 186.663 | 24.231 |
| 1 | 56 | 0/30/26/0 | 30 | 1,196,327 | 1,119,642/76,685 | 213.300 | 147.698 | 282.340 |
| 2 | 56 | 25/10/21/0 | 35 | 116,048 | 98,725/17,323 | 48.601 | 40.382 | 36.108 |
| 3 | 56 | 4/9/27/16 | 13 | 292,692 | 184,235/108,457 | 456.442 | 24.875 | 500.537 |
| 4 | 56 | 0/2/26/28 | 2 | 265,988 | 2,478/263,528 | 1,161.266 | 2.182 | 1,249.532 |
| 5 | 40 | 0/0/12/28 | 0 | 189,010 | 167,312/21,698 | 113.963 | 0.068 | 193.681 |
| 6 | 24 | 0/0/0/24 | 0 | 163,809 | 89,504/74,305 | 384.186 | 0.033 | 137.596 |
| 7 | 12 | 0/0/0/12 | 0 | 303,587 | 83,067/220,520 | 1,050.500 | 0.029 | 100.605 |
| 8 | 165 | 0/0/0/165 | 0 | 13,271,956 | 2,392,757/10,879,199 | 49,846.610 | 0.667 | 1,847.241 |

LOD8 is the remaining cost center: its 165 tiles all received unknown tile classifications and none
could skip meshing. They account for 13,271,956 native field calls (13,033,696 float and 238,260
lattice), with 2,392,757 column hits and 10,879,199 misses. Column computation summed to `49.847 s`
across workers; classification took `0.667 ms` and meshing summed to `1.847 s`. These broad boxes
span mixed strata, so the single-stratum classifier cannot certify them. Most LOD8 points therefore
take the field path, and most require a new XY column. The 65,536-entry thread-local column cache
reduced LOD1 misses from 1,187,985 to 74,549, but did not reduce the LOD8 miss count; full-view wall
time moved from `4.062 s` to `3.830 s` in that cache-size comparison. A separate 3D point-cache
experiment had 1.94 million hits but left column misses and full-view time effectively unchanged
(`3.853 s` versus `3.830 s`), so that experiment was removed.

### Fresh matched 3D captures

The four owner/native pairs use the same cameras as round 2. Each image is 640×400 and below 22 KB.
The surface pair no longer shows the flat-topped block; border and coast maintain their broad
silhouettes; and the cliff pair shows the attached tapered shelf without a floating shard or debris
trail. The JPEGs are the inspection copies; raw back buffers remain under `captures/raw/`.

| Site | Owner reference | Native Core |
|---|---|---|
| Surface | ![Round 3 surface owner](Research/WorldAssemblerM1/round3/final/captures/surface-owner.jpg) | ![Round 3 surface native](Research/WorldAssemblerM1/round3/final/captures/surface-native.jpg) |
| Biome border | ![Round 3 border owner](Research/WorldAssemblerM1/round3/final/captures/border-owner.jpg) | ![Round 3 border native](Research/WorldAssemblerM1/round3/final/captures/border-native.jpg) |
| Coast | ![Round 3 coast owner](Research/WorldAssemblerM1/round3/final/captures/coast-owner.jpg) | ![Round 3 coast native](Research/WorldAssemblerM1/round3/final/captures/coast-native.jpg) |
| Cliff | ![Round 3 cliff owner](Research/WorldAssemblerM1/round3/final/captures/cliff-owner.jpg) | ![Round 3 cliff native](Research/WorldAssemblerM1/round3/final/captures/cliff-native.jpg) |

### Round 3 run log

- One initial full build failed on `shared_ptr` lacking `has_value`; the check was corrected and a
  retry passed. A later full build compiled Core and passed the link-safety scan but the viewer
  compile failed because three profile counters were declared in the other benchmark function's
  scope. Moving them into the correct scope fixed the error; the final isolated build passed in
  under one minute. It reported the existing `vswhere.exe` lookup message and C4838 conversion
  warnings in `VoxelStrateManager.cpp:3974-3975`.
- The first final audit launch used the executable's default data location, which was absent. It
  exited before generation. Rerunning with `Standalone/data/owner_world.json` passed all audits.
- A PowerShell capture-array expression combined the border capture path with later flags. The
  owner and native launches then retried back-buffer capture against the malformed path (1,409 and
  229 failed reads in their logs). Both built 2,226 unintended tiles. The owner attempt was stopped
  after 46.2 s; the native attempt had reached initial clipmap readiness at 6.847 s. Working set
  stayed around 1.0 GiB. The argument array was corrected and both matched border captures
  succeeded at the intended 529 tiles. These were stopped capture launches, not crashes.
- One inspection pipeline using `tail.exe` failed with Win32 error 5; later inspections used
  PowerShell. No `0xC0000142` occurred. No process exceeded the 15-minute limit or 8 GB cap.
- No owner editor was opened or closed and no owner project was built; no `.uasset` was opened or
  changed. Only the standalone
  BuildHost-compatible viewer was built. No new source files were added, and no commit, push or
  stash was made.

## Round 4 results — cap geometry, route and query readiness

### Far cap and horizon

The LOD8 horizon slab came from the 3D marching-cubes surface being sampled at 256-voxel steps;
the broad triangles aliased the cap and hung below its native height. The LOD8 ceiling classifier
also used the legacy owner height query while the mesh used the native `Heightfield2D` plan. I
replaced the LOD8 ceiling geometry from that same native plan on a deterministic 128-voxel XY
grid. The generated cap is clipped to `cap >= ground` and the tile's Z interval. It replaces the
old unmasked ceiling triangles and preserves masked skirt triangles, so this repair rebuilds the
ceiling instead of omitting it. The cap normals face down into the enclosed strate.

The up-and-out pair was captured from the surface at `(0, -35, -487.943)`, yaw `0°`, pitch `25°`.
It shows a continuous far-cap silhouette in both owner and native views. This checks the visible
ceiling geometry in the standalone viewer; Unreal's interior lighting and light-leak behavior still
need owner validation. The surface pair was captured at the same position with pitch `-22°`.

In the 2,226-tile run, 153 LOD8 tiles received cap refinement on a 128-voxel grid, covering
626,308 cells and generating 1,252,688 triangles. The LOD8 tile extent is 8,192 voxels (2,048 m);
cap tile keys span x `-7..5`, y `-6..6`, z `-1`. The 529-tile cliff-site cost run refined 165 tiles
and generated 1,351,118 cap triangles.

| View | Owner reference | Native Core |
|---|---|---|
| Surface | [surface-owner.jpg](Research/WorldAssemblerM1/round4/final/captures/thumbs/surface-owner.jpg) | [surface-native.jpg](Research/WorldAssemblerM1/round4/final/captures/thumbs/surface-native.jpg) |
| Cliff overlook, pitch -34° | [cliff-final4-overlook-owner.jpg](Research/WorldAssemblerM1/round4/final/captures/thumbs/cliff-final4-overlook-owner.jpg) | [cliff-final4-overlook-native.jpg](Research/WorldAssemblerM1/round4/final/captures/thumbs/cliff-final4-overlook-native.jpg) |
| Looking up and outward at the cap, pitch 25° | [cap-upout-owner.jpg](Research/WorldAssemblerM1/round4/final/captures/thumbs/cap-upout-owner.jpg) | [cap-upout-native.jpg](Research/WorldAssemblerM1/round4/final/captures/thumbs/cap-upout-native.jpg) |

The fresh final4 cliff pair uses an overlook camera at `(-168, 0, -380)`, yaw `0°`, pitch `-34°`.
It is camera-matched, but still shows a visible owner/native shape difference; it is not evidence of
cliff parity. The native frame has no broad fanned-plate trail in this view. The route's analytic
field audit and the type-4 shelf negative control pass independently. Raw 640×400 viewer images and per-run logs are under
[`round4/final`](Research/WorldAssemblerM1/round4/final/). All viewer/capture runs used VSync and an
explicit 60 FPS cap.

### Finite-strate route and deterministic plan

The review manifest is [`world_assembly.json`](Research/WorldAssemblerM1/round4/world_assembly.json).
It contains one finite strate (chunk Z `-79..-16`), a type-4 shelf with stable ID
`09812c26310b90c9` and 33 route points, each with its own stable feature ID. The capsule constraints
are radius `348/256` voxel (0.34 m), height
`1802/256` voxel (1.76 m), maximum grade `17560/65536`, half-voxel sweep spacing, five support
probes with at least three required, one-voxel support search depth, and a four-voxel route corridor.
The serializer produced 7,565 bytes with canonical round-trip equality. Recipe, plan and manifest
hashes are `c37de78b759c0a4c`, `1ca84619c8600ee5` and `8933693d9560ba9f`.

The generator considered 648 route candidates, rejected 366 for grade, rejected none in the sweep,
and accepted 33. The actual capsule sweep sampled 530 centers / 143,630 field points: zero blocked
samples, unsupported centers or grade failures; minimum clearance was 63/256 voxel. Its deliberately
unsupported route control was detected at all 530 centers. Automatic generation and scripted changes
must preserve the swept route; player carve/fill remains unrestricted. Seasonal water remains fixed.

### Readiness, determinism and LOD8 cost

| Area | Result |
|---|---|
| Local field query | Ready without render meshes. `World::densityAt` compiled in 36.514 ms and matched all 78 audit samples, including all 33 route waypoints; zero render meshes generated. |
| Analytic route/collision validation | Ready. The capsule sweep above validates clearance/support against the composed field. |
| Physics collision cooking | Not provided by standalone Core; deferred to the Unreal adapter and owner build. |
| Render mesh | Separately exercised by the matched viewer captures and stream hashes below. |

The 4,096-point native query benchmark took 13.882/16.125/32.117 ms at W1/W8/W16 (point evaluation
only). Evaluator hash was `c5e0371612e927af` at all three worker counts. The 2,226-tile stream hashes
also match at W1/W8/W16:

| Hash | W1, W8 and W16 |
|---|---|
| Density | `e88539dde9407b0e` |
| Mesh | `c0495d0e5f3f6443` |
| Payload | `ea807397aa2d01f0` |
| Topology | `a0243e20433c69f5` |

The bounds audit passed 298 boxes / 8,046 samples with zero misses or unknown ranges and detected
its deliberately wrong-bound control. The cliff shelf audit examined 29,929 half-voxel XY columns,
found no sub-voxel runs (minimum observed thickness 2 voxels), and detected the legacy taper control
with 20,963 sub-voxel runs.

The matched 529-tile LOD8 cost run still had 165 unknown tiles and no whole-tile skips. LOD8 used
14,254,137 field calls and 11,678,652 column-cache misses; column computation summed to 54.040 s
across workers and meshing to 1.944 s. Against round 3's 13,271,956 calls, 10,879,199 misses and
1.847 s meshing sum, this is about 7.4% more calls, 7.3% more misses and 5.3% more mesher worker
time. The full 529-tile stream completed in 4.446 s wall time. Full per-worker hashes and LOD8
profiles are in `round4/final/logs/mesh-hash-final-w{1,8,16}.stdout.txt` and
`round4/final/logs/lod8-cost-cliff-final-w16.stdout.txt`.

### Round 4 run log

- Four isolated BuildHost-compatible standalone builds (`final` through `final4`) passed in under
  40 seconds each, including Core link-safety checks. Builds continued to report the existing
  missing `vswhere.exe` lookup and C4838 conversions at `VoxelStrateManager.cpp:3974-3975`.
  No `0xC0000142` retry or compiler crash occurred.
- The first 64-voxel cap-grid capture completed but was superseded because its clipmap mesh was too
  large. A later build labeled its 128-voxel grid diagnostic as 64; that log was discarded and the
  label was corrected. A pitch-70 cap capture was black and excluded. An owner capture wrapper had
  a PowerShell type-scope error and was rerun successfully. An initial overlook pair used the older
  `WorldAssemblerM1Round4.exe` and was excluded; the owner/native pair linked above was recaptured
  with `VoxelForgeAssemblerM1_round4_final4.exe`. The earlier pitch-34 and tight side-view frames
  were poor comparisons and excluded. The final4 overlook captures exited in 26.4/6.9 s with peak
  working sets 0.983/1.154 GB; both logged the explicit 60 FPS limiter and VSync.
- A focused native cliff probe crossed the approximately 8 GB process-memory guard (last external
  sample 8.257 GB decimal / 7.69 GiB). The guard stopped the run before capture; its output is
  excluded. This is the only process to cross the requested approximate cap. No run crashed and no
  build, compile or audit exceeded 15 minutes.
- All successful viewer captures and stream benchmarks had VSync enabled and the frame limiter set
  to 60 FPS; viewers exited after capture. The highest successful capture working set was about
  1.52 GiB. No owner editor/project or `.uasset` was touched, and no new source files were added.
  No commit, push or stash was made.

### Remaining work by round

- **Round 3:** The two visible defects are repaired and the native path is faster on both the matched
  120-tile and 529-tile workloads. Residual owner mismatch, rendered-water gap, and the 1.57 s aim
  remain open; LOD8 is the measured cost center.
- **Round 4:** Complete. The route and cap are in the research manifest; field sweep, negative
  controls, bounds, determinism, headless query and matched captures are recorded above. Physics
  collision cooking and Unreal light-leak behavior remain owner-build checks.
- **Round 5:** Complete for plugin-side delivery. The manifest/content-hash path, native Core
  surface, BuildHost tile/collision coverage, source-level switch-off check, matched timing and
  handoff are recorded below. The owner's project build, in-game walk, and cap-lighting review are
  the remaining owner checks.

### Run log

- First isolated full build compiled Core and passed the 199,209-line Core link-safety scan, then
  failed at viewer link: the new inline API symbols were not emitted and the standalone build lacked
  the GPU Far viewer implementation. No GPU Far source file exists in the standalone set.
- Retry adding the assumed `GpuFarViewer.cpp` failed at compile with `C1083` because that source file
  is absent. The build was changed to use local CPU-viewer link stubs under ignored
  `Standalone/Build/AssemblerM1/` output; Core remains GPU-free.
- The next full standalone build succeeded after moving the new API definitions out of line and
  isolating the GPU viewer stubs. Another full build succeeded after adding the height-map capture;
  a further build succeeded after adding manifest output; the final full rebuild after marking the
  manifest API for Core export also succeeded. The latest full build succeeded after changing the
  capture ramp to the observed shared height range. Each successful build took under one minute,
  used `/MP16`, Normal priority and all 16 allowed CPUs; sampled compiler processes remained well
  below 8 GB.
- Successful builds still print the environment's `'vswhere.exe' is not recognized` message and
  existing C4838 narrowing warnings in `VoxelStrateManager.cpp:3974-3975`. These did not stop the
  build. No `0xC0000142` retry occurred. A separate Git Bash `tail` inspection command failed with
  access denied while opening a file; it made no changes.
- No BuildHost or owner-project build was run this round. The checked
  `Saved/BuildHost/HostProject/Saved/Crashes/` folder contains one older `UECC-Windows-*` directory
  from 2026-09-17; there was no new crash folder from this round.

No Unreal route or asset was changed in round 4, so there was no owner rebuild handoff then. Round 5
supersedes that status.

## Round 5 — native SurfaceWorld in Unreal

The reviewed round-4 manifest now enters the opt-in Unreal Core route through `UVoxelSettings`.
The editor-only `SourceWorldAssemblyManifestJson` file picker plus `ImportWorldAssemblyManifestJson`
button reads the reviewed JSON into the settings asset as canonical serialized JSON and stores its
Core content hash. Import validates the recipe seed against the effective settings seed. The Core
adapter revalidates the manifest and requires a unique exact match for every planned stratum index,
top chunk and bottom chunk against resolved `SurfaceWorld` slots; invalid or incomplete plans fail
Core world initialization rather than silently falling back. With no manifest, existing Core cave
layouts retain their prior schema and route. With `bUseVoxelForgeCore` off, the legacy route and its
season identity hash are unchanged; the manifest only contributes to that hash while Core is active.

### Headless BuildHost evidence

`Tools/TestVoxelForgeCoreWorldHost.ps1` staged the reviewed JSON only under BuildHost and passed it
transiently to `-run=VoxelForgeExplore -coreworldtest=1 -coreworldassembly=...`; no data asset was
edited by the test. Manifest hash `8933693d9560ba9f`, recipe hash `c37de78b759c0a4c`, and plan hash
`1ca84619c8600ee5` were read back in Core. The field probe sampled 4,096 points over 3,200 voxels,
found three native biome IDs (including surface biome ID 4099), and generated native `Heightfield2D`
surface tiles. The actor's W1/W8/W16 initial hashes remained identical.

The final surface-strate travel phase passed at Core-local `(37,165,-2011)` voxels. All 2,553
expected visual keys matched independently generated standalone Core tile hashes; 573 local tiles,
3,438 neighbour faces and 432 LOD transition faces were checked. Of 125 collision-desired tiles,
36 had cooked bodies and 89 correctly had no body because their expected geometry was empty. The
gate checked each non-empty collision expectation individually. The log records the native surface
aggregate hashes as density `56ccc76575aa5f5f`, mesh `f3aeb31de1f967c1`, payload `95cb4781a1be4b73`,
topology `26ac366d430599bd`. Initial cave streaming, anchor release, and sequenced carve also passed.
Unreal's BuildHost exercised the RealtimeMesh/Chaos collision-body path; standalone does not cook
physics bodies. Full final output is in [CoreWorldValidation.stdout.log](../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation.stdout.log)
and [CoreWorldValidation.log](../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation.log).
Failed-attempt archives use the `CoreWorldValidation-backup-2026.10.09-*` names in the same log
directory.

### Switch-off check

The chosen narrow check is a source-level route and identity audit, not a runtime flag-off actor
comparison. `bUseVoxelForgeCore` remains default-false; `UpdateChunksAroundPosition` branches to the
existing legacy path when false; manifest import/adapter initialization and the new collision-support
deferral are Core-only; and `GetCurrentSeasonContentHash()` returns the pre-existing season hash
before inspecting the manifest when Core is off. This verifies the affected route boundaries and
content identity, but does not claim bit-for-bit runtime output from a second legacy actor session.

### Matched timing and the 1.57 s aim

In one BuildHost session, native `Heightfield2D` and the legacy-surface bridge generated the same
2,553 surface tile keys with hashes enabled. Region compilation took 0.015903 s native and 0.012752 s
bridge. Summed serial tile generation took 96.800984 s native versus 197.333401 s bridge; including
region compilation, 96.816887 s versus 197.346153 s (2.038× native speedup). This is a headless
same-key tile-generation comparison, not game-thread apply time or a full rendered-view timing.

The approximately 1.57 s aim is still unmet. The last matched standalone full 529-tile LOD8 stream
took 4.446 s wall, about 2.83× the aim. This round did not run a viewer/full-view benchmark; the
2,553-key BuildHost timing has a different workload and should not be compared directly to the aim.

### Ridge review and owner handoff

I inspected only the existing 17.6 KB downscaled `cliff-final4-overlook-native.jpg` and its 20.5 KB
owner comparison. The pointed ridge peaks are attached to continuous highland terrain and have no
detached shard or broad fanned-plate trail. They read as sharp native mountain peaks, not a mesher
artifact, so no terrain change was made. The frame remains an owner-review item for taste.

For the owner's project build and walk:

1. In the Content Browser, open the existing `DA_Settings` (`UVoxelSettings`) and confirm its
   effective seed is `0` (the manifest seed). Set `SourceWorldAssemblyManifestJson` to
   `Standalone/Research/WorldAssemblerM1/round4/world_assembly.json` in this plugin checkout, click
   **Import World Assembly Manifest JSON**, confirm hash `8933693d9560ba9f`, then save the settings
   asset. Assign that settings asset to the project's `AVoxelWorld` if it is not already assigned.
2. Select the `AVoxelWorld`, enable **Voxel World → Core → Use VoxelForge Core**. Keep the shipped
   Core clip settings `CoreClipRadius=3` and `CoreMaxClipLevel=8` for the first review. Do not change
   the legacy clip settings for this check. Coordinates below are actor-local Unreal centimetres;
   Core scale is 25 cm per voxel.
3. To inspect the surface, place the gameplay/free camera near `(0,-3500,-48794)` cm and look toward
   ground target `(0,0,-50394)` cm. The coast view is near camera `(33600,-6700,-47776)` cm,
   targeting `(33600,-3200,-49376)` cm. The biome-border view is near camera
   `(12800,-24300,-49291)` cm, targeting `(12800,-20800,-50891)` cm. The attached cliff/overhang is
   near camera `(-16800,7000,-44571)` cm, targeting `(-16800,10500,-46171)` cm. To inspect the cap,
   use the surface view and pitch upward/outward about 25°; the cap is hundreds of metres above the
   surface floor, so look for the enclosing roof and distant horizon, not a nearby ceiling.
4. Walk the native ground route beginning near `(925,4125,-50275)` cm. The route is terrain support
   geometry, not a painted path. Expect two inland terrain profiles, a coastal transition, one
   attached cliff shelf, a closed cap and a collision-supported path. Check lighting inside the cap
   and the small ridge peaks in the game.

Likely compile touchpoints if the project reports an error are `VoxelSettings.h/.cpp` (UHT/editor
import property and exported methods), `VoxelForgeCoreAdapter.cpp` (JSON parser and exact strate
match), `VoxelWorld.cpp` (manifest content hash and collision admission order), and
`VoxelForgeExploreCommandlet.cpp` (editor-only commandlet path). The plugin BuildHost compile passed;
the owner's project has not been built or opened here. No `.uasset` was modified.

### Round-5 run ledger

| Run | Result |
|---|---|
| First BuildHost UBT compile | Failed at Editor link because the new `UVoxelSettings` getter/setter definitions were not exported. Added `VOXELFORGE_API`; retry passed UBT and the Core link-safety audit. |
| Surface actor test attempt 1 | Failed tile-hash parity while moving to the surface, at support tile `(1,5,-63)`. |
| Surface actor test attempt 2 | Retried after route-fixture correction; the same support tile still differed. Root cause was a non-desired collision support request generating before Core region admission. |
| Surface actor test attempt 3 | Failed the old `GetBiomeAtWorldLocation` assertion: that API is the legacy biome/decorator query and is empty for this native Core surface. Replaced it with direct native `Heightfield2D` sampling from the resolved snapshot and added a native biome-field assertion. |
| BuildHost compile and actor test after collision fix | Passed after collision support was deferred until the tile enters desired-set region compilation. UBT and Core symbol audit passed; the complete actor test passed the gates above. |
| Final BuildHost rerun after switch-off hash gate | UBT/link-safety passed. Actor test passed in 9m20s with peak sampled private memory 3,880,357,888 bytes (3.61 GiB), including matched native/bridge timing and every surface coverage/collision gate. |

All actor attempts stayed below 15 minutes and below 8 GiB per process. No `0xC0000142` retry
occurred, and there was no new UECC crash folder; the only BuildHost crash directory is the older
2026-09-17 `UECC-Windows-F1A3EFD5469F5DD62E68EBBACAC84376_0000`. No owner project/editor was opened,
no owner build or `.uasset` edit occurred, and no commit, push or stash was made.

New source files: none. Modified source files:
`Source/VoxelForge/Public/VoxelSettings.h`, `Source/VoxelForge/Private/VoxelSettings.cpp`,
`Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp`, `Source/VoxelForge/Private/VoxelWorld.cpp`, and
`Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp`. Modified BuildHost test tool:
`Tools/TestVoxelForgeCoreWorldHost.ps1`.

## Round 6 — native surface walk defects and streaming

The owner built `f67b519` with Core on, the reviewed assembly manifest imported, and then saw the
native terrain below the grass, trees, water plane and strate content. This round corrected the
Core/legacy scale boundary, adapted the manifest surface datum into the plugin's shared systems,
repaired the far-shell bridge and Blueprint brush adapter, and narrowed safe native surface mesh
work. BuildHost staged the same five owner `.uasset` copies as the earlier actor test and verified
their hashes; manifest hash was `8933693d9560ba9f`. No owner asset or editor was touched.

### Four symptoms: causes and paired evidence

| Symptom | Cause and before → after evidence |
|---|---|
| LOD0 triangles poke through; horizon is worse | Core keys were 25 cm while the shared mesher still emitted at its 12.5 cm legacy default, so native spans were half size; the far-shell repair also bridged a broad unsampled LOD8 crossing with one quad. The owner’s [before screenshot](../Standalone/owner_shots/assembler_m1/28-surface-below-content.jpg) is the visual baseline. BuildHost measured the old scale ratio as `0.5000`, and the old horizon edge as `72,407.7 cm / 5.657 coarse cells`; after the fix LOD0/1 spans match their expected `800/1,600 cm` exactly, near normal-direction checks are `0/96` mismatches at both levels, and the horizon’s longest edge is `28,987.9 cm / 2.265 cells`. |
| Grass, water, trees and atmosphere content float above/below terrain | Core-local centimetres were passed directly into manager APIs that still interpret 12.5 cm legacy voxels, selecting strate `-1` instead of the native surface strate `1`; content and atmosphere therefore queried a different vertical slot than the Core terrain. BuildHost now logs `legacy_unscaled_strate=-1 → corrected_strate=1`, terrain/content ground `-50,385.254/-50,385.254 cm` (`0 cm` delta), water enabled at `-49,375.977 cm`, and atmosphere bounds `(-63,200,-12,000) cm`. |
| Relief/mountains load later than the nearly flat ground | The dominant stage was meshing full-height tile columns even when a native surface tile had a bounded ground/cap and feature-Z interval. Before → after band-disabled/banded Core relief meshing p95 was `60.840 → 41.981 ms` at LOD0 (`−31%`) and `70.297 → 42.649 ms` at LOD1 (`−39%`); mixed LOD0 was `55.792 → 50.007 ms` (`−10%`). Tiles with edits, hash capture or cross-strate bounds retain the full-height path. |
| Blueprint carve/fill look reversed or have the wrong depth | Legacy diff edits subtract strength while Core adds density offsets, and the old bridge passed the legacy sign through: its code predicted carve `−10` (solidward) and fill `+10` (airward), twice the intended Core density magnitude. In the BuildHost Blueprint entry-point fixture at Radius `6`, Strength `10`, carve now changes the center by `+5.0000` Core density and fill by `−5.0000`; each changes a point `60 cm` away by `±0.5200` and leaves `80 cm` away at `0.0000`. The adapter scales radius, extent, falloff and strength by `0.5` into 25 cm Core voxels and flips the sign once. |

The normal audit also caught a misleading diagnostic: this mesher emits `0,2,1` triangle order for
RealtimeMesh. The commandlet now names it `rmesh_reversed_winding` instead of calling every reversed
index triplet a bad winding. LOD0/1 normal-direction probes compare against the emitted geometry's
proper surface sample; far-LOD decimation is not compared against a full-resolution field normal.
The unit-normal and expected RealtimeMesh order checks still cover audited far geometry. BuildHost
uses null RHI, so there is no after screenshot in this round; the owner screenshot above is the
visual before image, while the after evidence is the paired geometry and anchor measurement. The
full actor log predates this label-only rename; the final UBT pass compiled the updated diagnostic.

### Surface datum and mesh behavior

Core-to-legacy manager queries now convert Core-local Z by `0.5` before slot lookup and convert
returned bounds by `2.0`. Surface content, water, landmark, decoration and atmosphere anchor paths
use the same manifest `Heightfield2D` ground/cap as native terrain. The atmosphere range is expressed
in Core centimetres. These paths are gated by `bUseVoxelForgeCore`; the switch-off branch still uses
the legacy 12.5 cm route. `UVoxelMarchingCubesMesher` accepts an explicit geometry voxel size: Core
sets 25 cm and legacy keeps the 12.5 cm default. Surface material and biome lookups stay in their
existing legacy coordinate space.

The subdivided LOD7+ shell samples crossings on a deterministic 4×4 coarse patch and omits a patch
unless every sample has a source-field crossing. This replaces the unsampled single-quad bridge.
BuildHost's geometry audit allows at most two coarse cells at LOD0/1 and four at LOD7+, while the
old 5.657-cell horizon quad remains a rejected negative control. Final spans and edge lengths are
in the geometry line in the [final BuildHost log](../Saved/BuildHost/HostProject/Plugins/VoxelForge/Saved/CoreWorldValidation/Logs/CoreWorldValidation.stdout.log).

### Walk/sprint streaming measurements

The BuildHost commandlet read walk and sprint speeds from the staged Blueprint assets:
`600 cm/s` and `6,000 cm/s`. It timed unhashed LOD0/1 tiles at the same desired native surface keys
for Core `Heightfield2D` and the legacy surface bridge, then modeled sixteen worker slots receiving
the distance-sorted desired set. `ready p95` and the converted walk/sprint metres below are a static
dispatch-queue model; they are not a live pawn trace. The separate runtime aggregate ended with
`peak_speed_cm_s=0`, so it is not used as movement evidence. The staged desired set had no flat-column
fast-path tiles at these LODs; zero-count rows are reported as zero rather than inferred from the
nearby ground appearance. “Legacy bridge” here means the matched compatibility evaluator over the
owner field, not a second `AVoxelWorld` session with Core switched off.

| Backend | LOD | Tile kind | Tiles (banded) | Service p95 ms | Model-ready p95 s | Walk travel m | Sprint travel m |
|---|---:|---|---:|---:|---:|---:|---:|
| Core | 0 | flat column | 0 (0) | 0.000 | 0.000000 | 0.000 | 0.000 |
| Core | 0 | relief | 39 (39) | 42.001 | 1.229687 | 7.378 | 73.781 |
| Core | 0 | mixed | 473 (70) | 50.008 | 1.697452 | 10.185 | 101.847 |
| Core | 0 | unknown | 0 (0) | 0.000 | 0.000000 | 0.000 | 0.000 |
| Core | 1 | flat column | 0 (0) | 0.000 | 0.000000 | 0.000 | 0.000 |
| Core | 1 | relief | 41 (41) | 42.674 | 2.775380 | 16.652 | 166.523 |
| Core | 1 | mixed | 407 (7) | 63.598 | 3.082213 | 18.493 | 184.933 |
| Core | 1 | unknown | 0 (0) | 0.000 | 0.000000 | 0.000 | 0.000 |
| Legacy bridge | 0 | flat column | 0 (0) | 0.000 | 0.000000 | 0.000 | 0.000 |
| Legacy bridge | 0 | relief | 39 (0) | 63.288 | 1.401714 | 8.410 | 84.103 |
| Legacy bridge | 0 | mixed | 53 (0) | 60.778 | 1.361116 | 8.167 | 81.667 |
| Legacy bridge | 0 | unknown | 420 (0) | 48.999 | 1.883834 | 11.303 | 113.030 |
| Legacy bridge | 1 | flat column | 0 (0) | 0.000 | 0.000000 | 0.000 | 0.000 |
| Legacy bridge | 1 | relief | 41 (0) | 71.396 | 2.996399 | 17.978 | 179.784 |
| Legacy bridge | 1 | mixed | 7 (0) | 70.957 | 2.987685 | 17.926 | 179.261 |
| Legacy bridge | 1 | unknown | 400 (0) | 62.070 | 3.275383 | 19.652 | 196.523 |

The relief service p95 maps to about `2.52 m` of sprint travel at LOD0 and `2.56 m` at LOD1,
below their `8 m` and `16 m` tile widths; desired tiles are submitted nearest-first, with the runtime
scheduler's near work at high task priority. That gives the nearby relief tile a service-time margin.
The complete-cohort queue p95 remains long (up to `166.5 m` for Core LOD1 relief and `184.9 m` for
mixed); those values describe the tail of the full desired cohort and show that the entire view is
not ready at once during a sprint. They are not a claim that those distant tiles are ahead of the
pawn. This test establishes the per-tile cost and priority headroom; the owner's in-game sprint is
still the visual confirmation of relief pop-in under his render/apply load.

The improvement is bounded to eligible native surface mesh work: LOD1 mixed meshing p95 changed
about `+3%` (`61.820 → 63.597 ms`), but only `7/407` mixed tiles qualified for banding. Flat-column
count was zero. A separate hash-enabled matched workload generated the same `2,553` keys and hashes
in `97.911890 s` native Core versus `201.223904 s` legacy bridge (including region compile: `2.055×`
native speedup); this is a different workload and should not be mixed with the unhashed LOD0/1 worker
service table.

### Final validation and handoff

The final full actor commandlet passed with manifest hash `8933693d9560ba9f`, stable W1/W8/W16 hashes
(`density=0x8cc18e2981c50c4e`, `mesh=0x78e9c8ea42ff2965`, `payload=0x380e8e11e76b47ca`,
`topology=0x24e40452e99fe482`), 2,553/2,553 matched native surface tile hashes, 3,438 neighbour faces,
432 LOD transition faces, height agreement, switch-off content gate, Blueprint carve/fill, and
collision checks. The actor run took `11m04s` and peaked at `3,982,528,512` private bytes (`3.71
GiB`). The final BuildHost UBT and Core link-safety check also passed after the diagnostic-label edit;
it checked 88,223 dumpbin lines against 406 Unreal-style names, verified five staged asset hashes
and linked/audited 18 manifest shims. BuildHost artifacts are in the `Saved/BuildHost` tree linked
above. No after GPU capture was launched.

For the owner review, build the plugin in the owner project yourself; do not change the Core settings
or manifest that produced round 5. Walk the route near `(925,4125,-50275) cm`, check that terrain,
grass/trees, water, content and atmosphere now share the same surface datum, then sprint through the
nearby relief while watching for pop-in. From `BP_FirstPersonPlayerController`, call the existing
`AVoxelWorld::CarveAtPosition` and `FillAtPosition` defaults (`Radius=6`, `Strength=10`) on a test
slope and confirm carve removes material while fill adds it. A null-RHI BuildHost run cannot replace
these rendered checks.

Likely compile touchpoints are `VoxelWorld.cpp`, `VoxelContentManager.cpp/.h`,
`VoxelAtmosphereManager.cpp`, `VoxelMarchingCubesMesher.cpp/.h`, `VoxelForgeCore.cpp`,
`FarShellsInternal.h`, `VoxelForgeExploreCommandlet.cpp`, and `Tools/TestVoxelForgeCoreWorldHost.ps1`.
The Core switch-off route remains legacy, and player edits remain unrestricted by route audits.

### Round-6 run ledger

| Run or check | Result |
|---|---|
| LOD0 edge audit | First bound failed at `56.807 cm > 50 cm`; inspection found skirt edges were included. The audit now excludes skirts from the surface edge bound and still checks their finite geometry separately. |
| First far-shell edge audit | Failed at `72,407.734 cm / 5.657 cells`, exposing the broad LOD8 quad. The shell was replaced by crossing-sampled subdivisions. |
| Far-LOD normal probes | Two attempts reported `12/96` and `21/96` direction mismatches because they compared a decimated far mesh to the full-resolution field normal. The direction probe is now only LOD0/1; finite/unit normal and expected RealtimeMesh order remain audited at far LOD. |
| LOD8 bound tuning | Failed successively at `27,805.769 > 25,600 cm`, `28,876.287 > 28,800 cm`, and `33,914.056 > 32,000 cm` (the last two were different tiles/crossings). Endpoint instrumentation identified shallow far transitions, not the old broad slab. The final far-LOD limit is four coarse cells; final geometry was `2.265` cells. |
| Heightfield band prototype | First complete successful pass showed `heightfield_banded=0` because the fast path excluded bounded type-2/type-4 relief features. Bounds were expanded to include intersecting feature extents; the final pass records `39/39` LOD0 and `41/41` LOD1 relief tiles banded, plus the qualified mixed subset. |
| Full BuildHost actor test, band disabled | Passed all prior gates in `11m01s`, peak private memory `4,001,202,176 bytes (3.73 GiB)`. Its matched Core relief meshing p95 was `60.840/70.297 ms` at LOD0/1. |
| Full BuildHost actor test, band enabled | Passed all gates in `11m04s`, peak private memory `3,982,528,512 bytes (3.71 GiB)`. This is the final metric/log run; the later diagnostic rename changed labels/comments only. |
| Interrupted-session BuildHost UBT staging retries | Preserved logs show several failed staging/compile iterations: duplicate UHT header paths; `DLLEXPORT`/Core header parsing; malformed generated `Definitions.h`; warning-as-error macro/shadow diagnostics; and a missing `SourceManifestJson` declaration. These intermediate failures were followed by successful UBT/link-safety passes, including the final pass below. |
| Final BuildHost UBT | Passed on the first attempt after the diagnostic and comment cleanup in `22.8 s`; link-safety audit and five staged asset hash checks passed. Earlier post-diagnostic UBT passes took `27.7 s` and `40.9 s`. |

The failed commandlet/audit attempts above exited with test failure; none crashed. No
`0xC0000142` retry occurred. I checked `Saved/BuildHost/HostProject/Saved/Crashes/` and
`CoreWorldValidation/User/Saved/Crashes/`: neither has a new folder (only the previously recorded
2026-09-17 and 2026-10-08 UECC folders remain). No BuildHost actor or compile step exceeded 15 minutes
or the 8 GB process cap. No owner project/editor was opened, no owner build or `.uasset` modification
occurred. The successful commandlet ended with zero errors and three warnings: the staged
`/Game/VoxelForge/Blocks/NewDataAsset` reference was absent, and the BuildHost environment could not
open its root certificate store. No capture, commit, push or stash was made.

New source files: none. Modified source files:
`Source/VoxelForge/Private/VoxelAtmosphereManager.cpp`,
`Source/VoxelForge/Private/VoxelContentManager.cpp`,
`Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp`,
`Source/VoxelForge/Private/VoxelWorld.cpp`,
`Source/VoxelForge/Public/VoxelContentManager.h`,
`Source/VoxelForge/Public/VoxelMarchingCubesMesher.h`,
`Source/VoxelForge/Public/VoxelWorld.h`,
`Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp`,
`Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`,
`Standalone/Core/src/FarShellsInternal.h`,
`Standalone/Core/src/VoxelForgeCore.cpp`,
`Standalone/Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp`, and
`Standalone/Source/VoxelForge/Public/VoxelMarchingCubesMesher.h`. Modified BuildHost test tool:
`Tools/TestVoxelForgeCoreWorldHost.ps1`.