experiment: LivingPlane repeatable + standalone UE runtime module (L164)

Readback barrier fix (GL_TEXTURE_UPDATE_BARRIER_BIT before glGetTexImage); check_repeatability.py compares full-field
checksums across query/capture settings - Intel GPU PASS (3b9d45905c7aafff), llvmpipe PASS, mismatch control fails.
New runtime module VoxelForgeLivingPlane (separate from generation): RDG global shader (Shaders/LivingPlane.usf),
ping-pong RGBA32F render targets, actor with WPO plane and object inputs, no CPU readback. Compiles in Linux UE 5.7.
Windows build: Source/VoxelForgeLivingPlane/*, Shaders/LivingPlane.usf, VoxelForge.uplugin. Setup: UE-SETUP.md.

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

.gitignore

@@ -9,12 +9,20 @@
 !/Source/
 !/Source/**
 
+# Plugin runtime shader source.
+!/Shaders/
+!/Shaders/**
+
 # Portable CPU generator and D3D11 viewer.
 !/Standalone/
 !/Standalone/**
 /Standalone/Build/
 /Standalone/bin/
 
+# Research and prototype experiments.
+!/Experiments/
+!/Experiments/**
+
 # The guarded single-entry test harness is source, not generated output.
 !/Tools/
 !/Tools/**
@@ -32,3 +40,7 @@
 /Standalone/data/*.err
 /Standalone/data/*.vfmesh
 /Standalone/Research/**/*.log
+
+# Web viewer world exports (regenerate with Standalone/Tools/webviewer/export_world.py)
+/Standalone/Tools/webviewer/meshes/*-arrival.glb
+/Standalone/Tools/webviewer/meshes/*-passage.glb

AGENTS.md

@@ -0,0 +1,57 @@
+# AGENTS.md — VoxelForge (read automatically by Codex)
+
+You are the implementation agent. The orchestrator (Claude) writes each round's brief, reviews your diff against the
+code, and commits. The owner decides direction. Be warm and direct; credit what worked; say plainly what didn't.
+
+Read first, as the task needs: `CURRENT-STATE.md` (what ships, reference numbers, **closed experiments: don't reopen
+them without new evidence**), then `CODEMAP.md` and `ARCHITECTURE.md`. Round reports live in
+`Standalone/Research/WorldAssemblerM3/Linux*/REPORT.md`.
+
+## Standing rules (every round, unless the brief says otherwise)
+
+- Run as user `jahni`. Write only inside this plugin, plus `/home/jahni/VFHost` and `/home/jahni/UnrealEngine` when
+  the brief asks for a UE build. No installs, no system changes.
+- **No `git commit`, `push` or `stash`.** Leave changes in the working tree; the orchestrator reviews and commits.
+- Headless processes and builds: `taskset -c 0-11 prlimit --as=6442450944` (12 P-core threads, 6 GiB). Never use all
+  cores.
+- Unreal (UBT, the editor, commandlets): `taskset -c 0-11` only, **never `prlimit`** (CoreCLR fails). UE builds use
+  `-NoUBA -MaxParallelActions=4`, never while timing.
+- Stop any single run that passes 30 minutes. Logs go in `Saved/Linux/l<round>/`.
+- **Timing:** quiet machine only (check `uptime` first; load < ~1.5, nothing else building). L80 protocol: one warm-up
+  per binary, ≥5 interleaved runs, W8 and W12, all four owner layers. Every number states the window that produced it.
+- **Same world for everyone:** a seed must give the same world on every machine and worker count (Clang and GCC,
+  W1/W8/W12). Byte-identity with older versions is NOT required. If the output changes: bump
+  `WorldAssemblyEvaluatorVersion`, add baselines, and show captures.
+- Density sign: negative = solid, positive = air. Core voxels are 25 cm. Never mix metres and voxels without an
+  explicit conversion (v225 shipped a reach bug from exactly that).
+- The fast tier (`Standalone/Tools/verify/verify.py fast`) must stay green. Don't loosen an audit to make a change pass.
+
+## How to work
+
+1. **Count before you build.** Measure where the time or the failure actually is (stack sampler, census, counters).
+   State which parts are measured and which are inferred.
+2. **Suspect the measurement first.** An alarming or contradictory number is the instrument until a control rules it
+   out (A/A runs, an ablation that verifiably removes the work).
+3. **No fix without a root cause.** Reproduce it, trace it to its source, fix the cause. A guard that hides the symptom
+   is not a fix.
+4. **One change at a time,** each with its own check.
+5. **Subtract before you add.** Prefer removing work to reorganising it. The smallest edit that solves the problem.
+6. **Attack the premise.** When two fixes sharing one premise fail the same gate, write that premise in one sentence
+   and question it before trying a third. **After three failed fixes, stop:** it is probably the design, not the
+   hypothesis. Report it instead of trying fix #4.
+7. **Tests must be able to fail.** Name what would make each check fail. Add a negative control when you add an audit.
+8. **Refactors:** pin the behaviour (hashes), change the structure, prove nothing changed.
+9. **Verify before you claim.** Don't report a check as passed unless it ran on the final source. Say which checks
+   didn't run and why.
+10. Changes that speed things up go in the shared layer, so every generator benefits.
+
+## Report
+
+Write the round's `REPORT.md`, short and plain:
+- the result first;
+- what changed and why;
+- the measurements, with their windows;
+- the checks run, and those not run;
+- remaining risks.
+
+List any changed Unreal `Source/` files, because the owner compiles them on Windows.

ARCHITECTURE.md

@@ -1522,11 +1522,12 @@ collision ring became walkable at 0.632 s. `voxel.StreamingCoarseFirst=1` with
 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 separate `voxel.StreamingStartupApplyBoost` switch is default-on in the current code. At `1`, it
+temporarily allows up to 24 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.
+The historical matched S6 run 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. These current defaults are defined in
+`Source/VoxelForge/Private/VoxelWorld.cpp`; the S6 measurement remains historical context.
 
 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
@@ -1556,8 +1557,8 @@ by its RAII guard when the worker lambda exits. This still counts queued and run
 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.
+defaults to `1`; `StreamingCoarseFirst` remains `0`. That historical S6 matched measurement disabled
+the startup apply boost (`voxel.StreamingStartupApplyBoost=0`); the current default is on (§8.27).
 
 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,
@@ -1883,8 +1884,9 @@ Each record separates the nominal ceiling, content, and bedrock bands. A strict
 sequence for every strate and requires bedrock(N) to touch the next strate's ceiling(N+1). The two
 bands remain separately owned. Gradient and Interleaved interfaces may declare interpenetration only
 inside their explicit transition zone; Hard has zero effective width. The manager's `TransitionBlendChunks`
-is expressed in owner-chunk metres. Interleaved's existing two-chunk domain warp extends its possible
-fingers beyond the blend width and is recorded separately. Compatibility validation reports current
+is expressed in owner-chunk metres. L21 recorded the older Interleaved allowance as blend width plus
+warp amplitude; L29 now treats the declared blend width as the complete physical crossing allowance.
+Domain warp changes finger placement, but cannot extend overlap beyond that width. Compatibility validation reports current
 gaps, overlaps, ambiguities, inactive/missing bands, and unhonoured transitions while accepting them;
 strict validation rejects them. Core dispatches per-strate recipe fields without applying that
 parameter blend, even though the legacy manager helper implements it. Both band types default diggable,
@@ -1943,6 +1945,7 @@ opens a band; the support strip stays below the player capsule. The lower mouth
 monotone descent from the short route-bound landing tail, whose height may vary with the route.
 Both route and passage audits sample the 0.34 m by 1.76 m capsule, support probes, and grade; the
 negative control compiles the same world without passage carving and must detect a blocked capsule.
+
 The L23 shared-field change is `WorldAssemblyEvaluatorVersion=9`. It does not change the L22 bands
 or any generator's field away from a passage. The L23 report includes exact-query/hash comparisons,
 the blocked control, captures, and the Windows adapter checklist. §8.10's cache, proof, streaming,
@@ -2051,6 +2054,269 @@ proof bounds preserve the L27 output.
 [Linux28 report](Standalone/Research/WorldAssemblerM3/Linux28/REPORT.md)
 records counts, parity, costs and audit caveats.
 
+### 8.46 Honored bedrock/ceiling transitions — World Assembler L29
+
+The upper strate's `EVoxelStrateTransition` controls the shared interface between its bedrock band
+and the next strate's ceiling band in the Core composition path. `TransitionBlendChunks` is converted
+using the resolved layout chunk width (8 m by default). Hard preserves the flat interface. Gradient
+moves the shared surface with a smooth 2D hash field whose peak-to-peak range is at most one quarter
+of the declared width. Interleaved uses a seed/interface/coordinate-keyed, domain-warped 3D hash field
+to set actual overlap between the facing bands from zero to the declared width. The two faces move
+inward by half that overlap; the warp changes finger placement without increasing the crossing
+allowance. Both bands keep authored thickness, and their solid intervals touch or overlap in every
+XY column. Core does not blend unrelated generator fields.
+
+Each boundary band keeps at least **two Core voxels** of solid thickness (0.5 m at the default 25 cm
+voxel size). Strict validation rejects thinner bands and declared interpenetration beyond the
+transition width. The world audit samples a 512 m square XY area, measures actual crossing depth and
+minimum band thickness, and sweeps every non-passage column through both bands at half-voxel spacing.
+Passage columns are excluded from the hole sweep. Near an interface mouth, the shared face returns to
+its nominal height inside the mouth radius plus a 1 m support margin, then fades back to the selected
+transition over 2 m so the authored landing floor remains supported. Negative controls reject a
+transition one micrometre wider than declared and a band one micrometre below the minimum. See
+[`Standalone/Research/WorldAssemblerM3/Linux29/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux29/REPORT.md)
+for audit measurements, hashes, timings, captures and run history.
+
+### 8.47 Ground-bound SurfaceWorld departure routes — World Assembler M3 Linux L33
+
+An intra-strate SurfaceWorld route follows the resolved terrain ground profile. Its route-point Z
+is the ground height plus the player's half-height; the route does not descend to the strate's
+bedrock boundary. Bedrock belongs to the separate inter-strate passage, which begins at the
+SurfaceWorld departure mouth on the ground and tunnels outward and down through native rock and
+the boundary into the next strate.
+
+The old fixed candidate envelope used a 64 m chord and 16 m centre spacing. On the L33 upper-SW
+fixture, replaying that envelope sampled ground from −507.767 to −464.857 m; 366/648 candidate paths
+exceeded the 15° grade limit. The worst failures clustered near the outer west/northwest terrain
+shoulder (up to 79.971°) and the steep approach slopes around the origin. Candidate diagnostics
+separate grade failures from endpoints outside the bounded arrival/departure placement disks.
+The bounded search now limits its longest chord to the two mouth radii minus a 3 m clearance
+margin, checks centres every 8 m, and ranks endpoints near the route anchors. It finds a 21.5 m
+route from (−2.75, 0) to (18.75, 0), sampled on ground and accepted by the full capsule/support/
+grade audit.
+
+The SurfaceWorld departure passage starts at the ground mouth with a 1.5 m portal, then smoothsteps
+to a 3.5 m rock tunnel over 9 m. Its ring is sized and oriented outward from the mouth, so the
+approach does not cut back under the walk route. The `FloatingIslands → SurfaceWorld → TunnelNetwork`
+fixture passes all four passage styles, including both interfaces, capsule clearance, support,
+grade, walkability, naturalness, open-air, column ends, long-bridge and route-binding audits.
+
+`FloorProfileBlend` previously compared each curved floor profile with its straight chord and
+applied a 2-voxel limit. That is a curvature measurement, not a seam measurement. It now checks
+endpoint height and tangent continuity at 0.01 voxel and 0.001 voxel/m; the 3-voxel step and
+0.25 voxel/m tangent-step controls are both detected. SurfaceWorld owner hashes remain identical
+to L32 because the route-mouth, expanded column sizing and short-span support changes apply only
+when SurfaceWorld is the upper strate. No evaluator or recipe version changed.
+
+[`Standalone/Research/WorldAssemblerM3/Linux33/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux33/REPORT.md)
+records the four-style audits, captures, determinism, owner hashes, costs and retries.
+
+### 8.48 Irregular passage-wall relief and grounded tread shoulders — World Assembler M3 L35
+
+L34's owner-SW profile had a 7.438 m radius repeat with 0.0361 m (3.61 cm) amplitude; an independent
+mesh-normal scan also found a 4.750 m period at 0.02682 (1.537°). The geometry came from piecewise
+capsule joins, while broad value-noise bands added a second regular pattern. The shared carve now
+uses Catmull–Rom centerline interpolation on eligible interior segments, excluding short spans and
+terminal controls. Passage walls use deterministic, rotated 43/29/19 m relief with reduced terrain
+band contribution; other `VF_FieldSurfaceRelief` users, including grounded bridge columns, are
+unchanged. The shared evaluator is version 21.
+
+The residual radius scan on owner-SW style 0 measures a 7.062 m period at 0.0109 m (1.09 cm),
+with 0.0044 m (0.44 cm) coherent amplitude. The independent L35 mesh-normal scan passes at 8 m
+and 0.02496 axial amplitude, below its 0.0255 threshold. The ripple audit samples both side-wall
+radii every 0.125 m in 32 m windows, scans 0.5–8 m periods, and rejects amplitudes of 0.035 m or
+more. Its synthetic control uses 2 m radius spheres spaced every 1.5 m; it measures 0.0599 m and
+must fail.
+
+At the FI mouth, the flat apron is the shared passage support tread, not `LandingExtensionQ`, a tile
+edge or a separate support layer. The tread is required by capsule and support probes. L35 gives its
+outer entry shoulder a shallow taper and seeded grain while preserving the supported walk core and
+lower-mouth overlap width. The shallow quarter-weight support-height/radius spline keeps the tread
+continuous without moving its XY footprint.
+
+Cascade routes also replace identical full-depth cosine lobes with a seeded shallow profile on each
+turn. Passage, capsule, support, open-air, bridge, binding, strict layout, capture, determinism, ring,
+and cost evidence are recorded in
+[`Standalone/Research/WorldAssemblerM3/Linux35/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux35/REPORT.md).
+
+### 8.49 Walk-floor washboard and FI mouth naturalness — World Assembler M3 L36
+
+L35's exported owner-SW mid-tunnel floor measured a 7.250 m repeat at 0.02252 m amplitude; its
+upper-SW fixture arrival measured a 1.438 m repeat at 0.02482 m. Both came from segment-built,
+one-sided support treads meeting the native terrain zero crossing at per-segment joins. The floor
+probe samples the exported walk mesh along the resolved route, separately from the wall-radius scan.
+Eligible tread sections overlap by up to 2 m and all sparse route segments now use a bounded
+signed-distance slab, including SurfaceWorld-to-TunnelNetwork routes. This keeps the tread top stable
+across segment joins while capsule-clearance and native-solid gates retain walkability and open air.
+Regular tread tops remain seated 5 cm lower and ease back to 0.20 m within 20 m of a lower landing;
+seeded shoulder grain is removed, and gravity-facing relief is reduced while side-wall and ceiling
+relief remain irregular.
+
+On v23, the same mesh probes measure 7.188 m / 0.00067 m (0.067 cm) on owner-SW and 6.500 m /
+0.00057 m (0.057 cm) on the upper fixture. The density audit checks five 32 m walk-floor windows at
+0.125 m spacing, rejects amplitudes of 0.015 m or more, and detects its beaded control. The FI mouth
+uses a local 2 m symmetric signed-field filter with the route protected and joins route-mouth support
+to native terrain with a 1.5 m smooth signed-distance union. Its mesh audit reduces the L35
+42.27° fade-ring jump to 27.13° and finds no detached component above the 0.0001 m² area floor; one
+8-triangle subthreshold component at 0.0000266 m² is recorded. The evaluator is version 23. Full
+recipe/style audits, route support, open-air, strict layout, legacy validators, determinism, capture and
+paired-cost results are in
+[`Standalone/Research/WorldAssemblerM3/Linux36/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux36/REPORT.md).
+
+### 8.50 Immutable field binding — World Assembler M3 L40
+
+`FStandaloneShapeWorld` now keeps a sorted `FBoundStratumField` table built from the resolved layout
+at world construction. Each entry owns a concrete SurfaceWorld, FloatingIslands, or legacy adapter
+in `FGeneratorFieldAdapterV1`, plus the resolved bounds and native plan pointer. The adapters share
+the immutable `densityAt(x,y,z,out)` shape, while `std::variant` keeps dispatch concrete instead of
+adding a virtual call to every density sample. FloatingIslands keeps its original fixed-point entry
+point for sample evaluation and its boundary parameter table is captured when the adapter is bound.
+
+`DensityAt`, native SurfaceWorld/FloatingIslands evaluation, legacy SurfaceWorld bridging and
+`ClassifyBoxDetailed` select from the bound table. The native adapters no longer ask the manager
+which generator or plan to use per sample; box proof reuses the bound field objects. The existing
+float-to-fixed conversion order, density arithmetic and shared boundary composition remain intact.
+The manager's layout-width value is captured once for the legacy-compatible chunk-index projection.
+
+The legacy adapter is still a compatibility bridge: `UVoxelGenerator::GetDensityAt` retains its
+own manager routing when invoked for legacy SurfaceWorld fields or out-of-plan fallback queries.
+Other shared-composition policy branches and passage/boundary planning remain outside this slice.
+No Unreal adapter or `VoxelWorld.cpp` change was needed, and the evaluator version is unchanged.
+L37/L39 owner hashes are the parity baseline; the L40 report records fast, medium, full and paired
+cost evidence.
+
+### 8.51 Resolved metre layout authority — World Assembler M3 L41
+
+`UVoxelStrateManager::Initialize` now resolves the layout in integer micrometres before passages or
+Core work are scheduled. The configured layout width is rounded once to micrometres; legacy height
+and inter-strate gap counts are multiplied by that width. Each slot stores its half-open physical
+interval `[bottom, top)`, height, transition mode/width, copied passage settings and their physical
+dimensions. The effective world seed is captured in the manager before passage generation.
+
+The historical 8 m layout keeps its old placement: the first upper edge is +8 m, and each authored
+chunk of height or gap is exactly 8 m. `TopChunkZ` and `BottomChunkZ` are floor-based projections of
+the resolved interval, including mathematical floor for negative Z. Season schema v2 still validates
+its aligned top/bottom chunk values and stacked order as before, then maps those accepted projections
+to the same physical intervals. L29's facing ceiling/bedrock bands are derived from these physical
+intervals and the copied transition width, so their metre bounds retain the prior chunk-based values.
+
+The Core adapter builds SurfaceWorld and FloatingIslands bounds, shared-layout bands, and resolved
+passage dimensions from the micrometre fields. FI and SW both receive the same
+`LayoutChunkWidthSubvoxels = round(layoutWidthMicrometres * 256 / coreVoxelMicrometres)`; layout
+conversion does not use the owner/Core scale. Owner/Core ratios remain in the legacy FloatingIslands
+parameter adapter for generator dimensions that are still authored in owner voxels. The manager's
+legacy passage builder converts resolved passage micrometres back to owner voxels only at its legacy
+geometry API boundary.
+
+Chunk coordinates remain in `GetStrateForChunk`, `GetGeneratorTypeForChunk`, chunk-parameter queries,
+season-v2 validation, and legacy generator dispatch because those interfaces accept layout-chunk
+indices. Their values are cached projections from the physical slot bounds. World-Z queries and the
+Core snapshot use the half-open metre intervals. L40's bound Core field table remains the native
+per-sample dispatch path; this migration adds no manager lookup to it. The Unreal manager and adapter
+cannot be compiled in this Linux workspace, so their small source changes still need the Windows
+Unreal build before integration.
+
+### 8.52 Resolved boundary and landing capabilities — World Assembler M3 L42
+
+`ResolvedLayoutSnapshotV3::finalize` materializes runtime capability records from the immutable
+strate/interface fields before sampling begins. The upper interface records whether its Gradient FI
+bedrock air gap remains open and whether a SurfaceWorld-to-TunnelNetwork passage gets the special
+landing support profile. Per-strate passage records carry the existing SurfaceWorld landing profile,
+FloatingIslands route-support behavior, and passage-anchor column center policy. Shared boundary and
+passage composition reads these records; it no longer compares generator-kind strings.
+
+The records are deterministic derivatives of `generator_kind`, `transition_mode`, and the resolved
+adjacent strate, and are omitted from canonical JSON. Those source fields remain in the hashed layout,
+so owner layout IDs and density hashes retain their L41 identity. The upper strate still controls
+Hard/Gradient/Interleaved evaluation; each strate still composes ceiling, content, then breakable
+bedrock. L29 transition samples and the passage-mouth fade arithmetic are unchanged.
+
+`BindResolvedStratumFields` still tests the resolved generator kind once to bind the concrete
+SurfaceWorld, FloatingIslands, or legacy evaluator. Passage planning in `ResolvedLayoutInternal.h`
+also retains generator-specific anchor and default-mouth placement rules; those are outside the
+shared composition boundary policy. No Unreal source changed. See the L42 report for hashes, tier
+results and paired cost measurements.
+
+### 8.53 Shared Core landmark SDF stamps — World Assembler M3 L43
+
+`ResolvedLayoutStampV1` adds a small, version-1 SDF vocabulary to the shared resolved layout:
+carve ellipsoid, carve arch, fill pillar and fill dais. Requests and resolved records use integer
+micrometres and carry a stable ID, strate, position, conservative bounds, half extents, smooth-CSG
+width, bounded irregularity amplitude/wavelength and quarter-turn orientation. A stamp's seeded
+noise and bounded placement offsets derive from `(world seed, strate, stable ID)`; records are
+sorted by stable ID before the layout identity is finalized. If no request is made, the stamp fields
+are omitted from canonical JSON, preserving the no-stamp layout identity and density hashes.
+
+Resolution retries a finite, deterministic set of candidates and rejects a record if its complete
+bound intersects a passage mouth or walk corridor, reaches a strate content face, or overlaps the
+ceiling or bedrock band. The director reports failure if no safe candidate exists. The strict-layout
+negative control forces a candidate onto a route and into a ceiling band and expects both rejections.
+
+`FStandaloneShapeWorld` applies stamps after the shared resolved-strate boundary and passage
+composition. Carves use smooth maximum with the negated stamp SDF; fills use smooth minimum. Seeded
+trilinear value noise adds low-frequency relief without changing the conservative bound. The tile
+query scope builds a BVH candidate list from each tile's sample bounds. Samples in a tile outside
+every stamp box do no stamp SDF evaluation. Box classification marks stamp-intersecting boxes mixed,
+and native-only readiness refuses to skip them.
+
+The `--landmark-chamber-demo` recipe flag adds an irregular ellipsoid chamber, a separate arched
+entrance and a low fill dais in the owner SurfaceWorld strate, about 31 m from the passage arrival
+mouth and off the walk route. It stays disabled by default. Active records carry vocabulary version
+1 in the layout identity, making the demo an explicit world change; no Unreal adapter was added.
+L43's report records the off/on hashes, walk and interface audits, outside-stamp timing, tier
+results, captures and any failed runs.
+
+### 8.54 Opt-in native lattice field — World Assembler M3 R26 slice 1 (Linux L58)
+
+`Core.Lattice.PrimitiveField` is a version-1 recipe selected only for one Maze or VerticalShafts
+strate by `--recipe=lattice --lattice-strate=N`. The legacy generator assets and their default
+dispatch stay unchanged. Planning first binds the actual incoming lower mouth and outgoing upper
+mouth from the resolved passage records, then creates arrival/exit overlap corridors, a mandatory
+four-turn helix and the maze spine; two deterministic dead ends are added after that route. The
+resolved room and edge seeds use `(world seed, strate, recipe version, stable ID)`. An audit control
+translates the helix 20 m away from both route junctions to make the shaft network orphaned.
+
+The prototype helix uses a 6 m centreline radius, 3 m clear width, 5 m pitch, four turns and 2.6 m
+finished floor-to-soffit height. Its centreline descends 20 m over roughly 151 m; the inner-edge
+grade is about 10.0 degrees. The 2.4 m floor-wall smooth-max gives an isolated ideal fillet radius
+of 0.8485 m. A separate 0.4 m feature-union blend prevents adjoining ramps from erasing the tread.
+The swept-clear diameter is 15 m; the conservative padded feature envelope is about 20.6 m (the
+approved approximately 21 m site envelope).
+
+The layout reuses the resolved cavern graph vocabulary. A per-strate opt-in selects the native
+negative-solid/positive-air field; canonical feature order is stable-ID order. Room/corridor bounds
+are indexed by the graph BVH and polyline segments have a nested deterministic BVH for density and
+interval queries. Box classification stays conservative, and `isTileShapeFree` refuses any tile
+that intersects the graph. The L58 pipeline audits the composed field from actual mouth to mouth
+with a 0.34 m by 1.76 m capsule, per-station support, 2.2 m clearance and a 15 degree grade limit;
+it also checks the orphan control, brute-force interval samples and the composed wall-foot fillet.
+The Linux58 report contains the measured reachability, surface, peer-determinism, timing and capture
+results; the code path is not promoted to legacy Maze/VerticalShafts generation.
+
+### 8.55 Unreal CoreGeometry asset bridge and U1 asset version
+
+`UVoxelStrateDefinition::CoreGeometry` is optional and defaults to recipe `None` with no stamps,
+rooms, or tunnels. The Unreal adapter preserves the established passage planner, then resolves
+authored stamps and cavern graph records, then finalizes the layout. Stable names are required and
+are scoped by strate in Core; landmarks may target a stamp, room, or tunnel by that stable name.
+Core profile heightfields are restricted to SurfaceWorld. Native caves require the TunnelNetwork or
+Underwater archetype; native lattice requires Maze or VerticalShafts. Core recipe/version fields
+enter the resolved layout identity when selected. An imported manifest cannot be mixed with a
+per-strate profiled heightfield.
+
+The checked-out Core API contains stamp vocabularies V1, V2, and V3. Unreal uses V1 for the original
+stamp kinds and V3 for monolith/platform motifs, then combines and strictly validates the result.
+Research17 names V2, but the source API and motif vocabulary require V3; source was followed.
+Research27 water remains out of scope for U1.
+
+The shared VoxelForge custom asset version is 2: version 1 records the tunnel-floor slope migration;
+version 2 adds load-time conversion for inter-strate gap, strate height, and transition width. The
+saved strate-layout width is used, currently 8 m. Old packages are converted in memory and marked
+dirty, but U1 does not save them. This does not yet migrate the rest of Research8's reflected
+spatial-property inventory: legacy chunk distances, owner/Core voxel lengths and frequencies,
+placement vectors, and other centimetre fields remain in their prior units. The U1 report records
+the five BuildHost asset values, hashes, and remaining work.
+
 ## 9. Multiplayer model (listen-server first, dedicated-friendly)
 
 > **Status: transport is DESIGN ONLY — nothing is networked in-tree yet** (no `Replicated`/`HasAuthority`/RPCs; a

CLAUDE.md

@@ -10,6 +10,7 @@ then wait for his results / pasted errors. Same for in-editor checks — ask for
 try to run anything.
 
 ## Read first (in order, load only what the task needs)
+- **[CURRENT-STATE.md](CURRENT-STATE.md) — current shipping snapshot and verification entry point.**
 - **[CODEMAP.md](CODEMAP.md) — ALWAYS.** Navigation: what it is, data-flow (§2), symbol→`file:line`
   index (§3), "I want to change X → go here" (§5), conventions & gotchas (§6). Trust **symbol names
   over line numbers** (lines drift).

CODEMAP.md

@@ -30,7 +30,7 @@ A **density-field voxel terrain** plugin for Unreal Engine, built around undergr
 | Term | Meaning |
 |------|---------|
 | Legacy chunk | 32×32×32 voxels (`CHUNK_SIZE`). At the legacy 12.5 cm voxel size it spans 4 m; it is not the strate-layout unit or the Core tile. |
-| Strate-layout chunk | World-level `StrateLayoutChunkSizeMeters`, default 8 m, shared by all generators and independent of voxel size. The director resolves it once and Core reads the resolved snapshot. At 25 cm it is 32 Core voxels; at 20 cm it is 40 Core voxels. |
+| Strate-layout chunk | World-level `StrateLayoutChunkSizeMeters`, default 8 m, shared by all generators and independent of voxel size. `UVoxelStrateManager::Initialize` resolves it to integer micrometres; slot bounds, heights, gap and transition widths use those physical values. Core derives the common `LayoutChunkWidthSubvoxels` from that same width. At 25 cm it is 32 Core voxels; at 20 cm it is 40 Core voxels. |
 | Core tile | Internal 32×32×32 Core voxel tile. Its metre size follows the Core voxel size and stays separate from the configurable layout chunk. |
 | Density | Scalar field. `< 0` solid, `> 0` air, `0` = surface (`IsoLevel`). |
 | Strate | Vertical layer of the world, stacked downward. Has its own generator + params. |
@@ -70,8 +70,10 @@ A **density-field voxel terrain** plugin for Unreal Engine, built around undergr
                                                                    (RealtimeMeshComponent)
 ```
 
-`UVoxelStrateManager` is the side oracle: "what strate is at this Z, what params,
-what generator type, and is there a passage/elevator SDF near here?"
+`UVoxelStrateManager` owns resolved half-open metre intervals (`[bottom, top)`) and is the side
+oracle: "what strate is at this Z, what params, what generator type, and is there a passage/elevator
+SDF near here?" Integer chunk bounds on each slot are compatibility projections for existing chunk
+dispatch APIs.
 
 ---
 
@@ -86,19 +88,22 @@ therefore **128 m**, and a 64-chunk strate is **512 m**. Core still stores work
 at 25 cm those tiles happen to span 8 m, but they are not the layout unit. The gameplay capsule remains
 **0.34 m radius / 1.76 m tall** (**2.72 / 14.08 legacy voxels**). Research-field dimensions are authored
 in metres and converted at runtime. The live
-strate generator continues to read voxel-valued parameters from its assets, so those authored
-dimensions become half as large in metres unless their asset values are doubled.
+strate generator continues to read voxel-valued shape parameters from its assets, so those authored
+dimensions become half as large in metres unless their asset values are doubled. U1 adds a
+versioned in-memory conversion for strate height, transition width, and inter-strate gap only; the
+broader Research8 voxel/chunk/centimetre inventory is not yet migrated.
 
 The intended metre-scale families remain: room diameters **8-20 m**, origin hub **24 m**, room cells
 **32 m**, round tunnel bores **3-4 m**, maze cells **16 m** with a **6.25 m nominal bore** (**3.125 m**
 radius; **3.0625 m** worst-case usable floor after roughness), slab open span **22.4 m**, shaft
 diameters **4-7 m**, island diameters **12-24 m**, and ordinary inter-strate bores **3-4 m**. Source
 new fixed physical dimensions are authored in metres and converted to voxel counts at the boundary.
-The owner's voxel-valued live strate assets are not migrated by C++: unchanged saved values therefore
-produce half-size rooms, tunnels, features and noise periods in metres. See the step-3 migration list
-in the handoff report for the exact `DA_Settings` fields and values.
+The owner's voxel-valued live strate shape settings are not migrated by U1: unchanged saved values
+therefore produce half-size rooms, tunnels, features and noise periods in metres. See the U1 report
+for the conversion coverage and remaining Research8 fields.
 
-**Owner asset migration (no packages were edited):** preserve `DA_Settings` distances by changing
+**Prior reauthoring recommendation (not applied in U1; no packages were edited):** preserve
+`DA_Settings` distances by changing
 `ViewDistanceXY 32→64`, `ViewDistanceUp/Down 10→20`, `PawnCollisionRadiusChunks 2→4`,
 `StrateViewMarginChunks 6→12`, `ClipRadius 6→12`, `RenderDistanceChunks 1536→3072`,
 `EdgeSealThickness 128→256 voxels`, decoration radius/near radius `12/6→24/12 chunks`, region
@@ -108,8 +113,9 @@ size `8→16 cells`, spacing/far spacing `8→16 voxels`, march step `4→8 voxe
 `12→24 cells`; it is currently disabled. Keep `MaxClipLevel=6` and zero-valued disabled/unbounded
 limits unchanged; double finite world radii and gaps, and multiply finite voxel-volume caps by 8.
 The loaded `Crystal Cave` slot in `DA_Strate3` is 64 chunks tall; use 128 chunks to preserve its
-former 512 m span. Its voxel-authored live-generator lengths remain half-size until that asset is
-re-authored; the editor-only research field is the step-3 target.
+former 512 m span. U1 automatically converts only strate height and transition widths and the
+settings gap at load; the remaining recommendations above are pending. Its voxel-authored
+live-generator lengths remain half-size until their asset fields are migrated.
 
 Step-3 six-worker scale benchmark (idle machine, `Saved/Research/step3/scale/step3_scale_cacheperf_v1`):
 the 519³ field took **7.133834–7.825292 s** across three runs (median **7.347496 s**); the 259³
@@ -167,14 +173,17 @@ remains `0`, and lateral regions remain gated off.
 | `../../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/include/VoxelForgeCore/VoxelForgeCore.h` / `../../Standalone/Core/src/ResolvedLayoutInternal.h` | `ResolvedLayoutSnapshotV3`: physical layout-chunk width, versioned micrometre intervals, owned ceiling/content/bedrock bands, transition and dispatch provenance, recipe anchors, director-planned passages, canonical JSON/FNV identity, compatibility/strict validators, and negative-control audit. Built once from the director-resolved plan and consumed by bounds planning, Core dispatch, composition, and validation. §8.40–8.41. |
+| `../../Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h` / `../../Standalone/Core/src/ResolvedLayoutInternal.h` | `ResolvedLayoutSnapshotV3`: physical layout-chunk width, versioned micrometre intervals, owned ceiling/content/bedrock bands, honored transition settings, deterministic per-column transition bands, recipe anchors, director-planned passages, canonical JSON/FNV identity, compatibility/strict validators, and negative-control audit. Built once from the director-resolved plan and consumed by bounds planning, Core dispatch, composition, and validation. §8.40–8.42, §8.46. |
+| `ResolvedLayoutStratePassageCapabilitiesV1::{hasNativeCaveField,hasNativeLatticeField}`, `IsNativeLatticeFieldStratum`, `HasNativeGraphField` | `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h` / `Standalone/Core/src/ResolvedLayoutInternal.h` | Explicit per-strate native graph capability; `Core.Lattice.PrimitiveField` is restricted to Maze/VerticalShafts recipe version 1. Lattice seeds include world seed, strate, recipe version and stable feature ID; explicit polyline records keep their endpoints and receive conservative bounds. §8.54. |
+| `FCavernRuntimeFeature::FSegmentNode`, `ApplyResolvedNativeCavesField`, `ClassifyNativeCaveFieldBox` | `Standalone/Core/src/ShapeWorldInternal.h` | A deterministic nested segment BVH accelerates native graph distance and conservative interval evaluation; the outer graph BVH still supplies tile candidates and protects `isTileShapeFree`. The 0.4 m feature-union width is separate from the floor fillet width. §8.54. |
 | `../../Standalone/Core/src/FloatingIslandsInternal.h` | Canonical standalone/Core floating-island planner, geometry-versioned field, manifest serializer, influence bounds, capsule-route checks, and thickness audit. |
-| `Tools/VoxelForgeTest.ps1` | The single guarded test entry point. `-Scenario canonical|owner|probe|perf|tests|surface-fall|crossing|gate-stress|visual-edit|visual-lod|visual-gap-walk|visual-gap-inject|dig-motion|parity|horizon|horizon-render|determinism|region-eval|step2d|step2e|step2f|step2f-capture|step3-scale|step3-game`, optional `-Build`, `-Assets owner|default`, `-Cvars`, absolute `-Out`, `-Label`, `-HorizonLevel`, `-HorizonRenderDistanceChunks`, `-Step2fProfile=0..7`, `-Step2fCaptureView=inside|wall-closeup`, `-ParityExportSize=32|64|128`, `-ParityExportTile=x,y,z`, `-SharedDDC`, `-SampleDensityStacks`, `-StackSampleIntervalUs`, and `-RegionHashProbe -RegionWorkers N -RegionReferenceHash HASH`; stages the host/assets, isolates user/DDC/config state, serializes one Unreal launch at a time, enforces the 8 GiB/30-minute guards, waits for 6 GiB free RAM before launches, and emits compact `result.json`/`summary.txt` plus full logs. Parity can render its game leg with `-EnableRender` and compares the selected export region against the exact streamed tile hashes. `visual-gap-walk` records camera-frustum surface-point coverage at 6000 cm/s; `visual-gap-inject` proves an early component hide is detected; `dig-motion` logs per-frame vertical velocity, gate, support readiness, and movement mode. `-Cvars @{ 'voxel.TestGapAuditLegacyHandoff'=1 }` replays the old visibility handoff for A/B audit baselines. Horizon traces report desired/loaded tiles, resident stream geometry, worker seconds, steady wall time, and peak private memory; `horizon-render` captures the owner view; `step2f-capture` selects one of eight parameter sets, finds a positive-density camera point and aims at a sampled rock wall for an inside or wall-closeup view, then saves it under `Saved/Research/step2f/captures` (pass the persistent render DDC with `-SharedDDC`); `determinism` compares per-tile hashes across the default CRT path and `-voxel.CrtFma3=0`; `region-eval` compares the live path with the default-off editor chunk program on the 259³ lattice and five-seed probe set; `step2d` retains the earlier independent field; `step2e` retains its earlier benchmark; `step2f` compares frozen step 2e and the coherent field for all eight profiles on the same 259³ ring, applies geometry gates, and checks sound bounds, seams, and 1-vs-6-worker hashes. `-RegionHashProbe -RegionWorkers N -RegionReferenceHash HASH` checks a full-ring hash at another partition count. `-SampleDensityStacks` captures profiles, and `-StackSampleIntervalUs` sets the sampling interval.
+| `ApplyOwnerFourStratePlan` | `Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp` | BuildHost-only transient fixed-slot plan from the four staged owner strate assets; leaves the authored settings and strate packages untouched. |
+| `Tools/VoxelForgeTest.ps1` | The single guarded test entry point. `-Scenario canonical|owner|probe|perf|tests|surface-fall|crossing|gate-stress|visual-edit|visual-lod|visual-gap-walk|visual-gap-inject|dig-motion|parity|horizon|horizon-render|determinism|region-eval|standalone-export|compile-only|step2d|step2e|step2f|step2f-capture|step3-scale|step3-game`, optional `-Build`, `-Assets owner|default`, `-Cvars`, absolute `-Out`, `-Label`, `-HorizonLevel`, `-HorizonRenderDistanceChunks`, `-Step2fProfile=0..7`, `-Step2fCaptureView=inside|wall-closeup`, `-ParityExportSize=32|64|128`, `-ParityExportTile=x,y,z`, `-SharedDDC`, `-SampleDensityStacks`, `-StackSampleIntervalUs`, and `-RegionHashProbe -RegionWorkers N -RegionReferenceHash HASH`; stages the host/assets, isolates user/DDC/config state, allows the owner's interactive editor while refusing overlapping `UnrealEditor-Cmd` launches, runs owned processes at Normal priority with a 12-logical-CPU cap, enforces the 8 GiB/30-minute guards, waits for 6 GiB free RAM before launches, and emits compact `result.json`/`summary.txt` plus full logs. Parity can render its game leg with `-EnableRender` and compares the selected export region against the exact streamed tile hashes. `visual-gap-walk` records camera-frustum surface-point coverage at 6000 cm/s; `visual-gap-inject` proves an early component hide is detected; `dig-motion` logs per-frame vertical velocity, gate, support readiness, and movement mode. `-Cvars @{ 'voxel.TestGapAuditLegacyHandoff'=1 }` replays the old visibility handoff for A/B audit baselines. Horizon traces report desired/loaded tiles, resident stream geometry, worker seconds, steady wall time, and peak private memory; `horizon-render` captures the owner view; `step2f-capture` selects one of eight parameter sets, finds a positive-density camera point and aims at a sampled rock wall for an inside or wall-closeup view, then saves it under `Saved/Research/step2f/captures` (pass the persistent render DDC with `-SharedDDC`); `determinism` compares per-tile hashes across the default CRT path and `-voxel.CrtFma3=0`; `region-eval` compares the live path with the default-off editor chunk program on the 259³ lattice and five-seed probe set; `step2d` retains the earlier independent field; `step2e` retains its earlier benchmark; `step2f` compares frozen step 2e and the coherent field for all eight profiles on the same 259³ ring, applies geometry gates, and checks sound bounds, seams, and 1-vs-6-worker hashes. `-RegionHashProbe -RegionWorkers N -RegionReferenceHash HASH` checks a full-ring hash at another partition count. `-SampleDensityStacks` captures profiles, and `-StackSampleIntervalUs` sets the sampling interval.
 | Step-3 scale and game validation | `step3-scale` measures the same 519³ and 259³ six-worker lattices at 12.5 cm. The cached medians are 7.347496 s and 1.169567 s respectively; determinism and brick sound-proof audits pass. `step3-game` routes in-game generation through the brick evaluator and records tile timings, spawn fill, moving frames, and profile-switch rebuilds. The visible D3D12 run measured tile generation p50/p95/max 3.326/31.045/169.867 ms, full-detail L0 fill 12.369 s for 2,765 tiles, and moving-frame p50/p95/p99/max 4.856/8.922/13.090/80.575 ms. Switching profiles rebuilt 5,815 loaded tiles. Both high-resolution screenshot requests were logged, but the harness found only one fresh PNG and it is a blank pale viewport; no lit comparison capture is accepted. Raw output: `Saved/TestHarness/step3_game_visible_final`; scale output: `Saved/Research/step3/scale/step3_scale_cacheperf_v1`. |
 | `Public/VoxelForgeModule.h` / `Private/VoxelForgeModule.cpp` | `FVoxelForgeModule` boilerplate (Startup/Shutdown just log). |
 | `Source/VoxelForgeEditor/VoxelForgeEditor.Build.cs` / `Private/VoxelForgeExploreCommandlet.*` | Editor/commandlet-only `-run=VoxelForgeExplore`; schema-v1 owner-asset export check and BuildHost Core actor tests. `-coreworldassembly=PATH` supplies a reviewed manifest transiently to `-coreworldtest=1`; it does not save a data asset. `FStandaloneCoreAdapterScheduler` runs Core work at 1/8/16 workers; `VerifyStandaloneCoreAdapter` checks hashes and walkability. Existing bounded render/`VF_` walk/OBJ orchestration and research options remain editor/commandlet-only and are not linked by Game/Shipping. |
 | `Source/VoxelForge/Public/VoxelSettings.h` / `Private/VoxelSettings.cpp` | `UVoxelSettings` owns optional canonical world-assembly JSON and its Core digest. The editor file picker plus `ImportWorldAssemblyManifestJson` imports the reviewed manifest into the cooked settings asset and validates the recipe seed against the effective settings seed. |
-| `Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp` | Validates the optional manifest against each resolved `SurfaceWorld` slot (unique strate index and exact top/bottom chunks), then exports canonical `resolved_layout` separately from `world_assembly` and its hash. The layout digest does not alter recipe hashes. Invalid plans fail Core initialization. |
+| `Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp` | Resolves Core's common `LayoutChunkWidthSubvoxels` from the manager's physical layout width; builds SurfaceWorld/FloatingIslands bounds, L29 bands and passage settings from resolved micrometre slot fields; keeps owner/Core ratios in the legacy FloatingIslands parameter adapter. Chunk fields validate imported plans as compatibility projections. Exports canonical `resolved_layout` separately from `world_assembly` and its hash. Invalid plans fail Core initialization. |
 | `Source/VoxelForgeEditor/Private/VoxelForgeRegionEvalExperiment.*` | Six-worker lattice drivers for step 2c through step 2f. The original path still compares live `GetDensityAt` with the editor chunk program. Research modes assign contiguous batches dynamically so surface-heavy work balances across workers; steps 2e and 2f use 4³ proof bricks and stage each evaluated brick before copying contiguous X rows, while step 2d retains 8³. Each skip requires a macro Lipschitz bound plus the complete final-detail supremum; uncertain bricks retain every 12.5 cm detail sample. Timings split classification, point evaluation, and uniform fill; step 2f compares all profiles and hashes workers 1 and 6. |
 | `Public/VoxelRedefinedDensityField.h` / `Private/VoxelRedefinedDensityField.cpp` | Two default-off `WITH_EDITOR` research fields, selected by `voxel.ResearchRedefinedDensityField` (step 2d) and `voxel.ResearchParameterizedCave` (steps 2e/2f). Step 2f retains a metre-scaled 2e baseline for its rejection audit. New profiles use strongly jittered, individually rotated elliptical rooms capped against nearest neighbors and curved cubic-Bezier passages with deterministic centerline and width variation along each edge. Room heights and feature rolls vary by cell; ledges, occasional pillars, stalactites/stalagmites, basin floors, and bounded hanging masses remain features. Point and brick detail sampling share independently rotated 96/48/24-sample bands and a smooth ridge response, preserving 12/6/3 m wavelengths at 12.5 cm per sample. The parameterized mesher evaluates the exact field through prepared 4³ bricks and the same sound skip proof in commandlet and editor-game meshing. In-editor and in-game profile changes invalidate and rebuild all loaded tiles. In an editor game with this field enabled, sealed-solid, out-of-layout, and outer-classifier verdicts are declined without changing their console switches. |
 | `Private/Tests/VoxelForgeParameterizedGenerationTest.cpp` | Separate three-seed functional sweep for the step 2f parameterized field; passage landing air/floor brackets and arrival-to-exit walking routes are checked without changing the live-world tests. |
@@ -379,7 +388,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 `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`. |
+| `ProcessPendingChunks` | 7435 | Drains `CriticalProcessQueue`, `EditedProcessQueue`, `NearProcessQueue`, then `ProcessQueue`; applies under the authored 4-mesh/2 ms budget during normal play and the default-on bounded startup budget (24 meshes/14 ms, at most 30 s) 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). |
@@ -387,7 +396,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` / `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. |
+| `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 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. `voxel.StreamingFarApplySupplement=1` is the default L121 lane: after the visible-apply cap, at most one far result is admitted when under half the apply-time budget and startup boost is inactive. `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. |
@@ -598,13 +607,16 @@ content lists, audio, `GameplayTags`(393). EditConditions show/hide param groups
 type.
 
 **`Public/VoxelStrateManager.h` + `.cpp`** — `UVoxelStrateManager : UObject` (h:152).
-Maps depth→strate at runtime; owns passages.
+Resolves each slot's physical metre interval, layout gap, transition width, world seed and passage
+settings during `Initialize`, then owns passages. World-Z APIs query the physical intervals; legacy
+chunk APIs use the cached integer projection.
 - `FVoxelPassage` (h:46): standing endpoints, radius, type, wandering control points, and
   upper/lower local landing descriptors (room, floor, and door; no root connector).
-- `FStrateSlot` (h:128): definition + chunk-Z range + index.
+- `FStrateSlot` (h:128): content definition, resolved micrometre bounds/height, resolved transition
+  and passage inputs, and compatibility chunk-Z projection + strate index.
 | Method | .cpp line | Role |
 |--------|-----------|------|
-| `Initialize` | 1164 | Keeps the existing sequencing through `GeneratePassages`, but selects one slot source: a validated cooked season (exact ordered bounds/vector/recipe) or the unchanged authored fixed+sorted/shuffled pool. Assigned-invalid seasons fail closed. Authored source definitions are duplicated as content bags; generated slots use deterministic C++ defaults and zero auto-passages because schema 2 does not store passage configuration. |
+| `Initialize` | 1186 | Keeps the existing sequencing through `GeneratePassages`, but selects one slot source: a validated cooked season (exact ordered bounds/vector/recipe) or the unchanged authored fixed+sorted/shuffled pool. Assigned-invalid seasons fail closed. Authored source definitions are duplicated as content bags; generated slots use deterministic C++ defaults and zero auto-passages because schema 2 does not store passage configuration. |
 | `GeneratePassages` | 1659 | Deterministic passages between consecutive strates (per-strate `PassageConfig::Style` control points; auto passages retain the existing `EVoxelPassageType` default); placement and shape values are independently salted hashes of seed + boundary slot + connection index. Each mouth independently queries its own strate's pure player-fit `VF_SuggestLandingPoint` with its contract seed (cave room salt, otherwise world seed), may move within its archetype-specific budget, then receives a body-sized local room/floor. The origin landing is reserved for the future shaft; no landing-to-root road is generated. Unsupported/no-fit answers preserve the old random reach; a deterministic level dog-leg is inserted when the final ramp needs it to stay ≤44°. All descriptors and bounds are generated without reading another passage. |
 | `EvaluateModifierSDF` | 2643 | SDF of passage tubes plus local landing rooms at a point. A per-chunk `thread_local` shortlist (`PassagesVersion`-stamped) → far chunks return `FLT_MAX` without walking `Passages`; the same cache serves floor membership. `FPassageEvaluationCache::FloorProjections` reuses native/generic floor projections and walkable-air results once per `(sample, passage)` using exact double XYZ equality and unchanged float outputs; `voxel.FloorRound1PassageProjectionCache=0` disables only this A/B cache. §8.10. |
 | `ApplyPassageModifier` | 2772 | Shared legacy/op-stack passage post: carves tube and local landing air through the idempotent landing primitive, then restores the local landing support slab in internal positive-solid density. |
@@ -612,18 +624,18 @@ Maps depth→strate at runtime; owns passages.
 | `ApplyPassageLandingFloorMC` | 2983 | Reasserts the same support slab after MC-space disturbances and before the final XY edge seal. |
 | `AnyPassageNearBox` | — | Conservative sphere-vs-AABB test of every passage's bound against a voxel box (+carve blend pad). Per TILE (ClassifyTile guard), never per voxel. |
 | `AnyPassageLandingFloorNearBox` | — | Conservative local-landing-floor AABB guard. It kills the `AllAir` hypothesis wherever a proved landing floor can occur; the op-stack returns `Both` for the same box. |
-| `FindSlotIndexForChunkZ` | 6111 | Z → layout index. |
-| `GetStrateAt` / `GetStrateIndex` | 6127 / 6139 | World-Z queries. |
+| `FindSlotIndexForChunkZ` / `FindSlotIndexForWorldZCentimetres` | 6239 / 6251 | Chunk callers use the cached compatibility projection; world-Z callers search physical half-open micrometre intervals. |
+| `GetStrateAt` / `GetStrateIndex` | 6276 / 6287 | World-Z queries against half-open micrometre intervals. |
 | `GetLayoutVersion` | h:250 (inline) | Layout/passage generation counter (= `PassagesVersion`, bumped by every `Initialize` and by the editor composer override). Hot-path callers key `thread_local` memos on it (strate-index memo in `GetDensityWithParams`, passage shortlist) so live changes never serve stale data. |
-| `GetStrateForChunk` | 6150 | Chunk → definition. |
-| `GetGeneratorTypeForChunk` | 6176 | Chunk → generator type. |
-| `UsesOperatorStackForChunk` | 6203 | Chunk → does its slot have an operator stack? True for any in-layout slot with a definition whose archetype is one of the 8 (Maze, FlatPlain, CrystalChamber, SurfaceWorld, VerticalShafts, FloatingIslands, TunnelNetwork, Underwater); false outside the layout. **That list is written down here and nowhere else.** `ClassifyTile` guards on it; `GetDensityAt` uses it to share TunnelNetwork stacks by chunk Z. |
+| `GetStrateForChunk` | 6298 | Chunk → definition via the compatibility projection. |
+| `GetGeneratorTypeForChunk` | 6324 | Chunk → generator type via the compatibility projection. |
+| `UsesOperatorStackForChunk` | 6351 | Chunk → does its slot have an operator stack? True for any in-layout slot with a definition whose archetype is one of the 8 (Maze, FlatPlain, CrystalChamber, SurfaceWorld, VerticalShafts, FloatingIslands, TunnelNetwork, Underwater); false outside the layout. **That list is written down here and nowhere else.** `ClassifyTile` guards on it; `GetDensityAt` uses it to share TunnelNetwork stacks by chunk Z. |
 | `GetRecipeForChunk` | — | Runtime immutable recipe/vector/strate-seed copy for cooked seasons; editor slot overrides use the same worker hand-off. |
-| `GetSlabParamsForChunk` | 6263 | Slab params with runtime Z bounds (no blend — slabs use Hard). |
+| `GetSlabParamsForChunk` | 6415 | Slab params with runtime Z bounds (no blend — slabs use Hard). |
 | `GetBiomeContextForChunk` | — | Flatten the strate's `Biomes[]` + `BiomeMapParams` into a POD `FBiomeContext` for the biome field. Empty ⇒ biomes disabled. §8.14. |
-| `GetGenerationParams` | 6509 | **Blended** TunnelNetwork params (handles Gradient/Hard/Interleaved transitions). |
+| `GetGenerationParams` | 6661 | **Blended** TunnelNetwork params (handles Gradient/Hard/Interleaved transitions). |
 | `SetComposerOverrideForStrate` / `GetComposerOverrideForChunk` | editor-only | Temporary density-only candidate overlay for one existing slot. Copies immutable params/recipe into the worker refetch path, leaves layout/content/passages intact, and bumps `PassagesVersion` to invalidate generator memos. |
-| `BuildParamsFromDefinition` (static) | 6815 | Returns the definition's base `GenerationParams` only. Terrain-op assets are passed separately to `BuildChunkCache`, which applies one selected op per room and pre-bakes Column/Pit/Chimney features. |
+| `BuildParamsFromDefinition` (static) | 6985 | Returns the definition's base `GenerationParams` only. Terrain-op assets are passed separately to `BuildChunkCache`, which applies one selected op per room and pre-bakes Column/Pit/Chimney features. |
 
 **`Public/VoxelTerrainOpDefinition.h` + `.cpp`** — `UVoxelTerrainOpDefinition : UPrimaryDataAsset`
 (h:67). One asset = one terrain op. `EVoxelTerrainOpType` (h:36): Terrace, LayerLines,
@@ -1160,7 +1172,7 @@ and [`Standalone/Research/WorldAssemblerM3/Linux18/REPORT.md`](Standalone/Resear
 | Symbol | Canonical file | Role |
 |---|---|---|
 | `PlanResolvedLayoutPassagesV1`, `ResolvedLayoutPassageV1::lowerMouthControlIndex` | `Standalone/Core/src/ResolvedLayoutInternal.h`, public record in `VoxelForgeCore.h` | Plans deterministic fixed-metre passages from adjacent director-resolved strata, binds route departure/arrival mouths, and records the derived split between the monotone descent and route-bound landing tail. |
-| `FStandaloneShapeWorld::ApplyResolvedStrateComposition`, `ApplyResolvedStratePassageCarves` | `Standalone/Core/src/ShapeWorldInternal.h` | Applies boundary bands first, then opens the passage capsule and supported floor along the passage for every native generator. |
+| `FStandaloneShapeWorld::ApplyResolvedStrateComposition`, `ApplyResolvedStratePassageCarves` | `Standalone/Core/src/ShapeWorldInternal.h` | Applies resolved boundary bands first, then opens the passage capsule and supported floor along the passage for every native generator. |
 | `--audit-resolved-layout-passages` | `Standalone/Source/StreamBenchmarkPipeline.h` | Samples passage capsules, floor support, mouth ownership/radius, in-strate route bindings, and a blocked-passage negative control. |
 
 The evaluator version is 9. See ARCHITECTURE §8.41 and
@@ -1217,6 +1229,129 @@ schema V3 is unchanged. See ARCHITECTURE §8.44 and
 See ARCHITECTURE §8.45 and
 [Linux28 report](Standalone/Research/WorldAssemblerM3/Linux28/REPORT.md).
 
+### 3.29 Honored bedrock/ceiling transitions — World Assembler L29
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `EvaluateResolvedLayoutTransitionBandsV1`, `AuditResolvedStrateTransitions` | Public Core header / `Standalone/Core/src/ResolvedLayoutInternal.h`; `Standalone/Source/StreamBenchmarkPipeline.h` | Resolve the deterministic mode field from seed, interface and coordinates; audit actual crossing depth, minimum band thickness, passage-excluded holes, and strict negative controls. |
+| `FStandaloneShapeWorld::ApplyResolvedStrateBoundaryBand` | `Standalone/Core/src/ShapeWorldInternal.h` | Applies Hard, Gradient or Interleaved to both facing bands in the shared Core composition path; tapers locally at passage mouths to preserve landing support. |
+
+The shared evaluator is version 15. Recipe and resolved-layout schema versions are unchanged.
+The Unreal adapter now forwards the authored transition type and chunk width; those Unreal edits
+were not compiled here. See ARCHITECTURE §8.46 and
+[`Standalone/Research/WorldAssemblerM3/Linux29/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux29/REPORT.md).
+
+### 3.30 SurfaceWorld as an upper strate and floor-profile joins — World Assembler L33
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `BuildFiniteStrateRoute` | `Standalone/Source/WorldAssemblyPrototype.h` | Samples route heights from the composed terrain ground; bounds candidate chords by the arrival/departure placement radii and records per-segment grade failures. |
+| `PlanResolvedLayoutPassagesV1` | `Standalone/Core/src/ResolvedLayoutInternal.h` | Starts an upper-SurfaceWorld departure at its terrain mouth, opens a small portal and smoothsteps to the rock tunnel while orienting the ring outward. |
+| `BuildPassageVoidCrossingPlan`, `PassageBridgeSignedDistance` | `Standalone/Core/src/ShapeWorldInternal.h` | Sizes unsupported ranges from the full control-segment window only for upper SurfaceWorld; other upper generators keep the previous bracketing-sample bounds. |
+| `--audit-resolved-layout-passages` | `Standalone/Source/StreamBenchmarkPipeline.h` | Uses floor height rather than bore-centre height for naturalness and records failed-only wall probes for column audits. |
+| `FloorProfileBlend` | `Standalone/Core/src/ShapeWorldInternal.h` | Measures endpoint height/tangent continuity; chord deviation is informational, with step and tangent-step negative controls. |
+
+The owner SurfaceWorld hashes match L32 and evaluator/recipe versions are unchanged. See
+ARCHITECTURE §8.47 and
+[`Standalone/Research/WorldAssemblerM3/Linux33/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux33/REPORT.md).
+
+### 3.31 Passage-wall ripple and FI tread-shoulder audit — World Assembler M3 L35
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `VF_FieldPassageWallRelief` | `Standalone/Core/src/VoxelForgeFieldShared.h` | Supplies passage-only irregular wall relief at rotated 43/29/19 m scales. Other `VF_FieldSurfaceRelief` users stay unchanged. |
+| `ApplyResolvedStratePassageCarves` | `Standalone/Core/src/ShapeWorldInternal.h` | Catmull–Rom smooths eligible interior sweep joins, applies passage-only wall relief, and tapers/grains the entry support shoulder below the capsule/support probe footprint. |
+| `PlanResolvedLayoutPassagesV1` | `Standalone/Core/src/ResolvedLayoutInternal.h` | Gives each Cascade turn a seeded shallow radial profile instead of identical repeated full-depth cosine lobes. |
+| `auditPassageRipples` / `PassageRippleAudit` | `Standalone/Source/StreamBenchmarkPipeline.h` | Samples wall radii and walk-floor zero crossings at 0.125 m spacing, scans periods 0.5–8 m in 32 m windows, and rejects wall/floor amplitudes ≥0.035/0.015 m. Sphere and beaded-floor controls must be detected. |
+
+`WorldAssemblyEvaluatorVersion=21`. See ARCHITECTURE §8.48 and
+[`Standalone/Research/WorldAssemblerM3/Linux35/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux35/REPORT.md).
+
+### 3.32 Walk-floor washboard and FI mouth blend — World Assembler M3 L36
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `ApplyResolvedStratePassageCarves` | `Standalone/Core/src/ShapeWorldInternal.h` | Extends eligible tread sections by up to 2 m and uses bounded signed-distance support on every sparse route, including SurfaceWorld-to-TunnelNetwork, removes seeded shoulder grain, and seats regular tread tops 5 cm lower with a smooth return at the lower landing. Capsule/open-air gates remain. Gravity-facing wall relief is reduced; side and ceiling relief remain. |
+| `ApplyResolvedStratePassageCarves` mouth support | `Standalone/Core/src/ShapeWorldInternal.h` | Builds exact signed-distance route-mouth tread boxes and smooth-unions them with native terrain over 1.5 m. |
+| `NativeFloatingIslandDensityAt` | `Standalone/Core/src/ShapeWorldInternal.h` | Applies a local 2 m symmetric signed-field filter around FI passage mouths, exempts resolved route support, and removes isolated negative samples thinner than 2 m on all axes. |
+| `auditPassageRipples` / `PassageRippleAudit` | `Standalone/Source/StreamBenchmarkPipeline.h` | Keeps the wall-radius audit and adds walk-floor zero-crossing profiles at 0.125 m, with five 32 m windows and a 0.015 m limit plus a beaded-floor negative control. |
+| `RunMouthFragmentAuditL36.py`, `ProbeWalkFloorProfileL36.py` | `Standalone/Research/WorldAssemblerM3/Linux36/` | Compare L35 floor and FI-mouth controls with L36; the mouth check fails on detached components at or above 0.0001 m² and checks normal jumps across the fade ring. |
+
+`WorldAssemblyEvaluatorVersion=23`. See ARCHITECTURE §8.49 and
+[`Standalone/Research/WorldAssemblerM3/Linux36/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux36/REPORT.md).
+
+### 3.33 Immutable field binding — World Assembler M3 L40
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `FSurfaceWorldFieldAdapter`, `FFloatingIslandFieldAdapter`, `FLegacyGeneratorFieldAdapter`, `FGeneratorFieldAdapterV1` | `Standalone/Core/src/ShapeWorldInternal.h` | Concrete, immutable density adapters with one shared `densityAt(x,y,z,out)` call shape; the variant avoids per-sample virtual dispatch. FI retains its fixed-point entry point and prebound legacy boundary parameters. |
+| `FBoundStratumField`, `BindResolvedStratumFields`, `FindBoundStratumForChunk` | `Standalone/Core/src/ShapeWorldInternal.h` | Bind a resolved strate's plan, evaluator and chunk interval once during world initialization; native field and classification queries select this table. |
+| `NativeSurfaceDensityAt`, `NativeFloatingIslandDensityAt`, `ClassifyBoxDetailed` | `Standalone/Core/src/ShapeWorldInternal.h` | Consume the prebound adapters and plan pointers instead of looking up strate type/parameters through the manager per query. |
+
+Hash parity is unchanged from L37/L39; see ARCHITECTURE §8.50 and
+[`Standalone/Research/WorldAssemblerM3/Linux40/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux40/REPORT.md).
+
+### 3.34 Resolved boundary and landing capabilities — World Assembler M3 L42
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `ResolvedLayoutStratePassageCapabilitiesV1`, `ResolvedLayoutInterfaceCapabilitiesV1` | `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h` | Runtime-only resolved records for surface/island landing, passage-column anchoring, the FI Gradient air gap, and SW-to-TunnelNetwork support. They are derived during layout finalization from fields already included in the canonical layout identity. |
+| `ResolvedLayoutSnapshotV3::finalize` | `Standalone/Core/src/ResolvedLayoutInternal.h` | Resolves those capabilities once before sampling; canonical JSON and stable layout IDs stay unchanged. |
+| `FStandaloneShapeWorld::ApplyResolvedStrateBoundaryBand`, `ApplyResolvedStratePassageCarves`, `BuildPassageVoidCrossingPlan`, `PassageBridgeSignedDistance` | `Standalone/Core/src/ShapeWorldInternal.h` | Consume resolved capability records. Generator-kind selection remains only in `BindResolvedStratumFields`, where it binds the concrete evaluator once. |
+
+Owner hashes match L41; see ARCHITECTURE §8.52 and
+[`Standalone/Research/WorldAssemblerM3/Linux42/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux42/REPORT.md).
+
+### 3.35 Core landmark SDF stamps — World Assembler M3 L43
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `ResolvedLayoutStampRequestV1`, `ResolvedLayoutStampV1`, `ResolvedSdfStampKindV1` | `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h` | Version-1 bounded stamp vocabulary and integer-micrometre request/resolved records shared by all Core generators. |
+| `ResolveResolvedLayoutStampsV1`, `AuditResolvedLayoutStampPlacementV1` | `Standalone/Core/src/ResolvedLayoutInternal.h` | Seed/strate/stable-ID placement with bounded retries; rejects passage-mouth, walk-corridor, content-face, ceiling and bedrock conflicts. Empty requests preserve the old canonical layout payload. |
+| `BuildStampSpatialIndex`, `ApplyResolvedSdfStamps`, `StampSdf` | `Standalone/Core/src/ShapeWorldInternal.h` | BVH-built conservative bounds select stamps once per tile; shared density composition applies smooth carve/fill SDFs with seeded value-noise relief. Box classification and native-only readiness decline boxes touched by a stamp. |
+| `--landmark-chamber-demo` | `Standalone/Source/StreamBenchmarkHeadless.cpp` | Opt-in owner-world recipe: one SW ellipsoid chamber, arched entrance and low fill dais, placed beside the passage arrival. Off by default. |
+
+See ARCHITECTURE §8.53 and
+[`Standalone/Research/WorldAssemblerM3/Linux43/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux43/REPORT.md)
+for layout identities, owner hashes, outside-box timing, audits and captures.
+
+### 3.36 Native lattice field — World Assembler M3 R26 slice 1 (Linux L58)
+
+| Symbol | Canonical file | Role |
+|---|---|---|
+| `IsNativeLatticeFieldStratum`, `LayoutLatticeFeatureSeed`, `ResolvedCavernRoomV1::unionWidthMicrometres`, `ResolvedCavernEdgeV1::unionWidthMicrometres` | `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`, `Standalone/Core/src/ResolvedLayoutInternal.h` | Versioned Maze/VerticalShafts opt-in and deterministic seed from `(seed, strate, recipe version, stable ID)`; optional union width preserves prior cave JSON when unset. |
+| `MakeNativeLatticeSpine`, `--recipe=lattice`, `--lattice-strate=N` | `Standalone/Source/StreamBenchmarkHeadless.cpp` | Resolves actual adjacent mouths, builds a mandatory four-turn helix and maze spine, then adds two seeded dead ends; `--lattice-orphan-control` moves the helix away from both junctions. |
+| `AuditNativeLatticeField` | `Standalone/Source/StreamBenchmarkPipeline.h` | Samples the final field along the mouth-to-mouth capsule route, checking support, headroom, grade, orphan rejection, composed fillet, interval signs and feature-tile exclusion. |
+| `BuildLatticeFixtureL58.py`, `CaptureNativeLatticeL58.py`, `AuditLatticeSurfaceL58.py` | `Standalone/Research/WorldAssemblerM3/Linux58/` | Isolated Maze strate fixture, four reviewed captures and the L54 whole-surface triangle audit adapted to explicit native polylines. |
+
+See ARCHITECTURE §8.54 and
+[`Standalone/Research/WorldAssemblerM3/Linux58/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux58/REPORT.md)
+for resolved records, final-field reachability, controls, timing, hashes and captures.
+
+### 3.37 Unreal CoreGeometry assets and partial metre upgrade — World Assembler U1
+
+`Public/VoxelStrateTypes.h` declares optional `FVoxelForgeCoreGeometry`. Its default recipe is Off
+and its stamp, room, and tunnel arrays are empty. `Private/VoxelForgeCoreAdapter.cpp` maps authored
+metres to Core layout requests after passage planning and before finalizing the layout. Stamps use
+the V1 resolver for original stamp kinds and V3 for monolith/platform motifs because the checked-out
+Core API exposes V3; authored cavern records use `ResolveResolvedCavernGraphV1`. Stable feature
+names are namespaced by strate in the resolved layout. `FStrateLandmark::CoreGeometryStableName`
+binds one landmark to such a resolved record, and `VoxelContentManager.cpp` builds its lookup from
+the finalized snapshot. `VoxelWorld.cpp` retains resolved layout identity in content hashing.
+
+`Private/VoxelForgeAssetVersion.h` sets the shared custom version to 2. `UVoxelSettings::Serialize`
+and `UVoxelStrateDefinition::Serialize`/`PostLoad` upgrade only inter-strate gap, strate height,
+and transition width using the saved 8 m layout chunk. These conversions are version-guarded and
+idempotent. No package save is performed by the audit. Other Research8 chunks, owner-voxel lengths,
+Core-voxel lengths/frequencies, and centimetre fields remain on their existing units and need a
+separate migration.
+
+Likely compile/UHT touchpoints are the reflected nested fields in `VoxelStrateTypes.h`, Core snapshot
+and resolver signatures in `VoxelForgeCoreAdapter.cpp`, `FCustomVersionRegistration` and the old
+tunnel-slope version in `VoxelStrateDefinition.cpp`, plus the standalone `VoxelForgeExplore` audit
+in `VoxelForgeExploreCommandlet.cpp`. `GetStrateForChunk` still receives layout-chunk Z, not a Core
+tile index. See `Standalone/Research/WorldAssemblerM3/Unreal1/REPORT.md` for BuildHost evidence.
+
 ## 4. The density pipeline (most-edited hot path)
 
 ### 4.1 `GetDensityWithParams` (TunnelNetwork) — VoxelGenerator.cpp:3749

CURRENT-STATE.md

@@ -0,0 +1,57 @@
+# VoxelForge current state
+
+As of 2026-10-31. L131 is on `assembler/world` as `8107196`; this L132 worktree is on `wip/l132-dispatch-truth`, starting at `ebae71b`. Current-state claims below point to their code or measured report.
+
+## What ships today
+
+- **Core:** evaluator version **227**. Unreal's `AVoxelWorld::bUseVoxelForgeCore` is opt-in and defaults to `false`; the legacy generator remains the default runtime path. [Core version](Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h), [runtime switch](Source/VoxelForge/Public/VoxelWorld.h), [L130 report](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
+- **Verified owner4 generator dispatch (L132):** SW binds `SurfaceWorld-native` because the owner export contains a matching `SurfaceWorld.Heightfield2D` v2 plan. FI binds `compiled-analytic/FloatingIslands` because its `FloatingIslands.ClusterField` v0 layout has no matching native island plan. TN and VS bind `compiled-analytic/TunnelNetwork` and `compiled-analytic/VerticalShafts`; their legacy recipe IDs provide neither a `NativeCaves`/`NativeLattice` graph recipe nor native field capability. The L132 fast-tier report prints the binding and generated tile-center share at each owner strate. [Dispatch](Standalone/Core/src/ShapeWorldInternal.h), [adapter recipe checks](Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h), [L132 report](Standalone/Research/WorldAssemblerM3/Linux132/REPORT.md).
+- **Passages:** continuous smooth swept tubes with a continuous floor profile. L125 stamps conservative route slabs and outside sentinels into the tile cache; exact route geometry is still evaluated. All 21,425 route samples passed the open-air walk check; the nine-station floor probe's maximum root offset was 7.884 mm. L130 sets the shared influence reach to **1.0533 m** (0.75 m shell + 0.21 m relief + 0.50 m smooth-max support / 6 + 0.01 m margin), converted once from metres to Core voxels for the proof, feature, fallback, and off-grid bounds. [L125](Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md), [L130](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
+- **Streaming:** arrival uses a bounded startup apply burst: `voxel.StreamingStartupApplyBoost=1` by default, up to 24 visible meshes or 14 ms per frame for at most 30 seconds, until the initial desired set and walkable ring are ready. `voxel.StreamingFarApplySupplement=1` is also default-on: after the normal visible apply cap, at most one far result applies when under half the apply-time budget; it is inactive during the startup burst. Dynamic near reserve defaults on; coarse-first remains off; the legacy pending-result cap defaults off. The far-apply lane is Unreal-only. [CVar source](Source/VoxelForge/Private/VoxelWorld.cpp), [L121 report](Standalone/Research/WorldAssemblerM3/Linux121/REPORT.md), [architecture](ARCHITECTURE.md).
+- **Determinism:** proven on Linux with Clang and GCC at W1/W8/W12. L131's unchanged-output comparison covers owner4's SW/FI/TN/VS views in 24 compiler/worker cases; the canonical owner4/owner2 recipe matrix also passes. Windows determinism is unverified. [L131 checks](Standalone/Research/WorldAssemblerM3/Linux131/REPORT.md), [v227 canonical hashes](Standalone/Tools/verify/baselines/owner-hash/canonical/).
+
+## Current performance references
+
+Headless medians in seconds, five interleaved L80-style measurements per version in each cell. Near-ready means the complete LOD0–2 set; whole-view is the full requested view. Values below are the edited L131 binary; the paired pre-cleanup comparison is in the [L131 report](Standalone/Research/WorldAssemblerM3/Linux131/REPORT.md) and [timing summary](Saved/Linux/l131/timing/summary.json).
+
+| Stratum | Near-ready W8 / W12 | Whole-view W8 / W12 |
+|---|---:|---:|
+| S0 | 0.804 / 0.848 | 1.811 / 1.832 |
+| S1 | 1.014 / 1.002 | 1.993 / 1.886 |
+| S2 | 1.060 / 1.012 | 1.960 / 1.865 |
+| S3 | 0.917 / 0.884 | 1.887 / 1.782 |
+
+Across 40 paired runs per metric, the mean relative change from pre-cleanup L130 was −0.22% near-ready (95% CI −1.02% to +0.57%) and −0.29% whole-view (−1.04% to +0.46%); neither indicates a measurable slowdown. The machine gate was load 0.81 and 99.2% idle. [L80 protocol](Standalone/Research/WorldAssemblerM3/Linux80/REPORT.md), [runner and raw runs](Standalone/Research/WorldAssemblerM3/Linux131/RunL131Timing.py).
+
+The latest recorded Linux Unreal start-to-LOD0–2 values are L127's one run per stratum: S0 2.456 s, S1 2.231 s, S2 2.514 s, S3 2.221 s. L130 did not rerun UE startup or movement. Five L127 runs at 30 m/s, 12 s moving plus 5 s dwell, had median moving near coverage **40.22%**, far holes **3.46%**, tick p99 **10.80 ms**, and worst tick **13.27 ms**. After stopping, near coverage reached 100% and far holes reached 0%. These are the latest UE references, not v227 UE measurements. [L127 report](Standalone/Research/WorldAssemblerM3/Linux127/REPORT.md), [L127 movement summary](Saved/Linux/l127/ue/movement-pairs-summary.json), [L127 start summaries](Saved/Linux/l127/ue/merge/start-summary.json).
+
+## Open gaps
+
+- Multiplayer world lifecycle is unfinished: seed/layout replication, authoritative modification RPCs, and serialized diff replay for late join are still open. See [ARCHITECTURE §9.5 and §9.7](ARCHITECTURE.md).
+- Determinism has not been verified on Windows. Linux Clang/GCC agreement does not establish MSVC agreement.
+- NullRHI measures residency and apply timing, not the first presented pixel or rendered enclosure. L127 also found four low-contrast views among 23 otherwise verified captures. [L121](Standalone/Research/WorldAssemblerM3/Linux121/REPORT.md), [L127](Standalone/Research/WorldAssemblerM3/Linux127/REPORT.md).
+- UE startup/movement numbers above predate L130's v227 reach change; there is no L130/L131 UE movement comparison.
+
+## How to verify
+
+- Build standalone Clang or GCC with [`Standalone/BuildLinux.sh`](Standalone/BuildLinux.sh), for example `bash Standalone/BuildLinux.sh --compiler=clang++-19 --variant=l132-clang --fp-contract=off --jobs=4`. The script pins CPUs 0–11 and applies `prlimit --as=6442450944` itself.
+- Fast tier: `python3 Standalone/Tools/verify/verify.py fast --out Saved/Linux/l132 --overall-timeout 1740`. It includes the L132 four-pose owner density-dispatch report; per-run logs and the summary stay under `Saved/Linux/l132`.
+- Canonical output baselines are the v227 files in `Standalone/Tools/verify/baselines/owner-hash/canonical/`. L131 also provides reproducible pre-cleanup identity matrices for owner4 tile hashes and owner4/owner2 canonical hashes under `Standalone/Research/WorldAssemblerM3/Linux131/`.
+- Timing follows L80: quiet machine, no overlapping build, one warm-up per version, five interleaved runs per stratum and worker count, W8/W12. Each headless run uses `taskset -c 0-11`, `prlimit --as=6442450944`, and a 1,740 s timeout. See [`RunL131Timing.py`](Standalone/Research/WorldAssemblerM3/Linux131/RunL131Timing.py).
+- Linux host build: `/home/jahni/UnrealEngine/Engine/Build/BatchFiles/Linux/Build.sh VFHostEditor Linux Development -Project=/home/jahni/VFHost/VFHost.uproject -NoUBA -MaxParallelActions=4 -Log=/home/jahni/VoxelM/Plugins/VoxelForge/Saved/Linux/l131/ubt.log`. Run Unreal without `prlimit`.
+
+## Closed experiments
+
+These rejected speed/streaming proposals stay closed unless new evidence changes their measured failure. Reports and surviving patches are linked in the [L131 inventory](Standalone/Research/WorldAssemblerM3/Linux131/REPORT.md).
+
+| Line | Result |
+|---|---|
+| L116 tunnel chord bound and z cache | Pair count fell 20.8%, but stayed 1.96× L109 and readiness was 15–30% slower. Patch: [`chord-bound-zcolumn-not-merged.patch`](Standalone/Research/WorldAssemblerM3/Linux116/patches/chord-bound-zcolumn-not-merged.patch), commit `89504ec`; see [report](Standalone/Research/WorldAssemblerM3/Linux116/REPORT.md). |
+| L118 pair pruning / deferred floor work | Pruned 17–18% of candidate pairs but remained 17.2–25.7% behind L109 near-ready. [Report](Standalone/Research/WorldAssemblerM3/Linux118/REPORT.md); patch: [`l118-designs.patch`](Standalone/Research/WorldAssemblerM3/Linux118/l118-designs.patch). |
+| L126 floor-call filters | Cut floor calls 20–23% without reducing pair counts; all eight cells missed L109. Candidate source was restored and no standalone patch was kept; see [report](Standalone/Research/WorldAssemblerM3/Linux126/REPORT.md) and commit `01a5094`. |
+| L128 half-open slab ownership | Ownership audit passed, but readiness was 14.8–28.0% behind L109 and moving coverage dropped. Report and patch `l128-slab-ownership.patch` are in archived commit `7022d02`. |
+| L129 2 m physical reach | v225's metre/Core-voxel bounds mismatch made the correctly bounded candidate do more work; it was slower and failed UE movement gates. Report and patch `l129-reach-2m.patch` are in archived commit `0d1140c`. |
+| L120 priority split / extra worker slots | Neither met coverage and tick gates; 10 slots reached a 16.67 ms worst tick against 15.43 ms baseline. [Report](Standalone/Research/WorldAssemblerM3/Linux120/REPORT.md); no production patch retained. |
+| L122 admission relaxation | Early admission missed p99 or far-hole gates; no behavior retained. [Report](Standalone/Research/WorldAssemblerM3/Linux122/REPORT.md); patch: [`l122-trace.patch`](Standalone/Research/WorldAssemblerM3/Linux122/l122-trace.patch). |
+| L123 lookahead / completion gate | Lookahead failed p99 and worsened near/far coverage; queue-only also failed p99. [Report](Standalone/Research/WorldAssemblerM3/Linux123/REPORT.md); patch: [`l123-queue-lookahead.patch`](Standalone/Research/WorldAssemblerM3/Linux123/l123-queue-lookahead.patch). |
+| L124 early LOD0 pages | Optimistic gain stayed below 100 ms except negative cases; no publication/scheduling implementation was made. [Report](Standalone/Research/WorldAssemblerM3/Linux124/REPORT.md). |

Experiments/LivingPlane/REPORT.md

@@ -0,0 +1,201 @@
+# L162 — Living Plane
+
+The EGL/OpenGL 4.3 runner builds and passes its llvmpipe correctness and frame checks. The sandbox has no accessible DRM render node, so it did not run or report Intel GPU performance. The runner refuses `--device=gpu` here instead of falling back to software.
+
+## Implementation
+
+`LivingPlane.cpp` runs a ping-pong `RG32F` height/velocity field through a runtime-compiled GLSL compute shader. The damped wave update includes a weak foundation spring, a Gaussian sphere push, and an optional slow breathing force. The spring is needed because a persistent local push otherwise accelerates the zero-frequency height mode and sinks the whole plane. The sphere moves across the plane, stops, and bobs. A vertex-displaced mesh and lit sphere render to an EGL pbuffer-backed framebuffer and save as PNGs.
+
+The timestep is selected from the largest 2D grid eigenfrequency:
+
+`dt = 1.30 / sqrt(8*c*c/(dx*dx) + foundationStiffness)`
+
+The resulting spectral step ratio is 1.30, below the explicit update's 2.0 stability limit. The runner warms the compute kernel for eight unmeasured dispatches, then records one `GL_TIME_ELAPSED` query per requested simulation step in `timing.json`.
+
+The first-step equation audit also caught a GL state error during bring-up: frame rendering left the graphics program active before the next compute dispatch. `Dispatch` now binds the compute program before every step, so the audit fails if a frame silently stops simulation.
+
+Device selection enumerates EGL devices and uses `EGL_EXT_platform_device` for an accessible Intel render node first. On this host, the known integrated device is Intel on `renderD128`. Automatic mode falls back to a surfaceless Mesa context with `LIBGL_ALWAYS_SOFTWARE=1`; explicit GPU mode fails when no accessible hardware node is present. EGL does not expose Vulkan's integrated/discrete enum, so Intel vendor/render-node identity is the selection heuristic.
+
+The Unreal handoff is in [UNREAL-MAPPING.md](UNREAL-MAPPING.md). It keeps the prototype render-only and describes the density mapping if the surface later needs to affect voxel queries. No Unreal `Source/` files changed.
+
+## Measurements and checks
+
+- Built with `Experiments/LivingPlane/build.sh` using the installed EGL, desktop GL, and libpng development files; no shader compiler or package install was needed.
+- Final llvmpipe run: 128² field, 360 steps, `dt=9.56814 ms`, spectral ratio 1.30. The first-step equation audit and finite-field/dynamics audit passed. Final field range was −0.139533 m to +0.0366704 m. It wrote 16 128×128 PNGs and a JSON file containing 360 per-step query samples. The frames were inspected; the moving sphere and wake are visible.
+- Auto-selection smoke check: 32², 12 steps; selected llvmpipe and passed both audits. Breathing smoke check: 64², 180 steps with `--breathing=on`; passed both audits.
+- Negative device-selection control: `--device=gpu` returned an error because the sandbox has no accessible EGL DRM render node.
+- Existing fast verification tier passed: 278.9 seconds, ending in `SUMMARY PASS`. Its build and logs are under `Saved/Linux/l162/verify/` and `Saved/Linux/l162/`.
+- The llvmpipe `GL_TIME_ELAPSED` samples are preserved in JSON but are software-driver query values, not GPU timings. The requested hardware timing pass remains to be run outside the sandbox.
+- No Unreal build was run; no Unreal `Source/` files changed.
+
+## Intel GPU pass
+
+Run these from the plugin root as `jahni`. The frame run writes 512×512 PNGs to `Saved/Linux/l162/gpu-frames-512/`; the two timing runs write `timing.json` with one GPU query per step and skip PNG capture. They still read the field for the first-step and final-state correctness audits.
+Before the timing runs, check `uptime` and run them on a quiet machine (load below about 1.5, with no other build active).
+
+```sh
+uptime
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l162/living-plane --device=gpu --size=512 --steps=1800 --capture-every=12 --out=Saved/Linux/l162/gpu-frames-512
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l162/living-plane --device=gpu --size=512 --steps=1800 --capture-every=0 --out=Saved/Linux/l162/gpu-timing-512
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l162/living-plane --device=gpu --size=1024 --steps=1800 --capture-every=0 --out=Saved/Linux/l162/gpu-timing-1024
+```
+
+Encode the captured sequence as MP4 with:
+
+```sh
+ffmpeg -y -framerate 30 -i Saved/Linux/l162/gpu-frames-512/frame_%06d.png -c:v libx264 -pix_fmt yuv420p Saved/Linux/l162/living-plane-512.mp4
+```
+
+## Files and remaining risk
+
+The only changed file outside `Experiments/LivingPlane/` is `.gitignore`, which now allows `Experiments/` and its contents. GPU timings and Intel render-node selection remain unverified until the commands above run on the host outside this sandbox.
+
+## Intel GPU pass (run by the orchestrator outside the sandbox, 2026-11-02)
+
+- The device was selected correctly: `Mesa Intel(R) Graphics (ADL GT2)`, OpenGL 4.6, `/dev/dri/renderD128`. 512²,
+  1,800 steps, 151 frames; the equation audit passes. MP4: `Saved/Linux/l162/living-plane-512.mp4` (local).
+- **The `GL_TIME_ELAPSED` per-dispatch values (~0.0001 ms) are not credible** for 262k cells, so they aren't
+  reported as timings.
+- Wall-time difference between 1,800 and 200 steps, divided by the 1,600 steps (start-up cancels out; this includes
+  submission, so it's an upper bound): **0.080 ms/step at 512²** and **0.292 ms/step at 1024²**.
+- Visual read: the effect is very subtle in the current render (a slight dip under the sphere, faint rings). It needs
+  a larger push amplitude, grazing light or height colouring, and a closer camera to read.
+
+## L163 — readable, living plane
+
+The plane now reads as rolling terrain, and the objects leave visible troughs and wakes. `alive` adds travelling
+breathing and a viscoelastic imprint that remains after lift-off. The simulation still runs in one GPU dispatch per
+step; CPU work only supplies the two object states.
+
+`LivingPlane.cpp` now keeps the dynamic displacement, velocity, and imprint in an `RGBA32F` ping-pong field. The
+surface shader adds broad static terrain relief, calculates normals from relief plus displacement, and uses grazing
+light, elevation colours, slope tint, and 7.5 cm contour bands. The camera follows the first sphere at a closer angle.
+The wake scene rolls the first sphere, pauses and wobbles it, lifts it, then sends a second sphere through the wake.
+The alive scene runs that same sequence with low-frequency travelling swells and a decaying contact imprint. Its
+defaults are breathing strength 4.8 m/s², imprint capture 0.15 m/s, recovery time 6 s, and maximum imprint depth
+0.34 m. These values have command-line overrides.
+
+The timer query check found no early read or reuse in L162: it allocated a unique query per step, called `glFinish`,
+then read every result. The saved Intel/Mesa 25.0.7 samples are 0 or 52 ns for most dispatches (512² median 0,
+p95 52 ns; largest sample 17.552 µs), which cannot be a credible per-dispatch cost. The old usage did not reuse
+query objects, so lifetime is not the cause; the saved data point to Intel/Mesa's timer-query reporting or timing
+scope, but the sandbox cannot isolate which. L163 uses a 64-query ring, reads each query before reusing its slot,
+checks availability after `glFinish`, and records `GL_QUERY_COUNTER_BITS`. On llvmpipe the availability check passed
+with 64 counter bits and zero waits. The Intel query result still needs the GPU diagnostic command below.
+
+### Measurements and checks
+
+- llvmpipe wake: 128², 600 steps (`dt=9.56814 ms`, 5.741 s simulation window), 151 frames at 30 fps. First-step
+  equation audit and timer-query lifetime check passed; final displacement range was −0.177488 m to +0.104854 m.
+- llvmpipe alive: same grid, steps, and window; equation audit and timer-query lifetime check passed. Final
+  displacement range was −0.200437 m to +0.115904 m, with a −0.111667 m stored imprint.
+- llvmpipe cost: 512², 1,800 steps, `--queries=off`, no frame capture: **0.767473 ms/step** in one timed
+  simulation-loop window. `timing.json` includes dispatch submission, the step-0 equation readback, and final
+  `glFinish`, but excludes setup and frame capture. This is a software-renderer measurement, not the Intel GPU cost.
+- Both five-second llvmpipe previews are in `Saved/Linux/l163/llvmpipe-wake.mp4` and
+  `Saved/Linux/l163/llvmpipe-alive.mp4`. They are 128² review previews; use the GPU commands below for the owner
+  videos.
+- Equation-audit negative control: a temporary copy with its expected first-step height forced to zero exited FAIL
+  at actual −0.0488777 m. The final source passes that same check.
+- The fast verification tier passed in 278.5 s. Build and logs are under `Saved/Linux/l163/verify/`.
+- No Unreal `Source/` files changed and no Unreal build ran.
+
+### Intel GPU run
+
+Run from the plugin root as `jahni`. First build the runner. For timed runs, check `uptime` and keep the machine
+quiet. The wall-time field is valid only when `--capture-every=0`; use `--queries=off` for the step-cost measurement.
+
+```sh
+bash Experiments/LivingPlane/build.sh
+uptime
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=wake --size=512 --steps=2400 --capture-every=16 --queries=off --out=Saved/Linux/l163/gpu-wake-512
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=alive --size=512 --steps=2400 --capture-every=16 --queries=off --out=Saved/Linux/l163/gpu-alive-512
+ffmpeg -y -framerate 30 -i Saved/Linux/l163/gpu-wake-512/frame_%06d.png -c:v libx264 -pix_fmt yuv420p Saved/Linux/l163/living-plane-wake-512.mp4
+ffmpeg -y -framerate 30 -i Saved/Linux/l163/gpu-alive-512/frame_%06d.png -c:v libx264 -pix_fmt yuv420p Saved/Linux/l163/living-plane-alive-512.mp4
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=alive --size=512 --steps=1800 --capture-every=0 --queries=off --out=Saved/Linux/l163/gpu-timing-512
+taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=alive --size=512 --steps=1800 --capture-every=0 --queries=on --out=Saved/Linux/l163/gpu-query-check-512
+```
+
+`gpu-timing-512/timing.json` reports the 512² batch wall time per step, including dispatch submission and completion.
+`gpu-query-check-512/timing.json` contains query counter bits, waits before slot reuse, availability status, and raw
+per-step query samples. The sandbox has no accessible Intel DRM node, so the current Intel step cost and new query
+diagnostic remain unmeasured here.
+
+### L163 Intel GPU pass (run by the orchestrator, 2026-11-02)
+
+- Intel ADL GT2 (Mesa 25.0.7, `renderD128`): wake and alive scenes, 512², 2,400 steps, 151 frames each; equation
+  audits PASS. Videos (local): `Saved/Linux/l163/living-plane-wake-512.mp4`, `living-plane-alive-512.mp4`.
+- Step cost, alive scene, 512², 1,800 steps, no capture: **0.172 ms/step** with queries off, 0.152 ms/step with
+  queries on (batch wall time per step).
+- The Intel `GL_TIME_ELAPSED` median is still 0 with 64 counter bits and the ring/availability checks passing. That
+  looks like a Mesa/Intel reporting issue; use wall time.
+- **Open issue:** the same scene with the same steps gave different final fields (min −0.637 m with queries off vs
+  −0.327 m with queries on). Something depends on more than the step index (e.g. wall-clock time); investigate.
+
+## L164 — repeatable field readback and UE runtime actor
+
+**Result:** the repeatability check passes on llvmpipe, and the new `VoxelForgeLivingPlane` runtime module compiles
+in the Linux UE 5.7 host. The surface actor is independent of VoxelForge generation and sends no field readback to
+the CPU.
+
+### Repeatability finding
+
+`uTime` is `Step * dt`, and `GetBodiesAt` receives that same value. Neither the object schedule nor the breathing
+force uses wall time or a rendered-frame counter. Every compute step already issued an image-access barrier before
+the next ping-pong image read. The defect was on the diagnostic side: the step-zero and final `glGetTexImage`
+readbacks followed shader image writes without `GL_TEXTURE_UPDATE_BARRIER_BIT`. The Khronos OpenGL specification
+requires that barrier for `GetTexImage` to observe earlier shader writes ([§7.12](https://registry.khronos.org/OpenGL/specs/gl/glspec44.compatibility.pdf)). Query/capture pacing could therefore affect the reported field values without changing any simulation input. The barrier is now issued before both readbacks.
+
+`check_repeatability.py` runs the same 512² alive scene for 1,800 steps twice: queries off with no captures, then
+queries on with captures every 900 steps. The checksum covers every final RGBA32F field value using canonical
+little-endian float bytes.
+
+- llvmpipe, queries off/capture off: field range −0.637382 m to +0.109308 m; checksum
+  `1ba08f5dafc01f82`.
+- llvmpipe, queries on/capture every 900: the same range and checksum; equation and timer-query audits pass; three
+  frames written.
+- Negative control: changing one saved checksum made the comparison exit 1 with `FAIL field checksum mismatch`.
+- The llvmpipe runs were each one 1,800-step simulation-loop window. Logs and JSON are under
+  `Saved/Linux/l164/repeatability/`.
+
+The Intel run is not available in this sandbox. The owner should repeat the checksum comparison on the GPU to
+confirm that the missing transfer-readback barrier accounts for the earlier Intel min mismatch:
+
+```sh
+python3 Experiments/LivingPlane/check_repeatability.py --device=gpu --out=Saved/Linux/l164/gpu-repeatability
+```
+
+### Unreal implementation and checks
+
+The plugin descriptor adds a separate `VoxelForgeLivingPlane` runtime module. Its RDG global shader is in
+`Shaders/LivingPlane.usf`; module startup maps `/Plugin/VoxelForgeLivingPlane` to the plugin shader directory. The
+actor owns two UAV-capable RGBA32F render targets, advances them at the stable fixed step, and supplies the current
+texture to a movable plane mesh material. Its Blueprint/C++ object input includes world position, radius, velocity,
+base push, and active state. The CPU converts those values to plane-local metres and uploads uniforms; it does not
+read the field back. The ignore rules now include `Shaders/` so that the shader ships in the worktree diff.
+`Experiments/LivingPlane/UE-SETUP.md` gives level setup, the full material graph, and object driving steps.
+
+- Linux UE 5.7 `VFHostEditor Linux Development`: **PASS**, final incremental build compiled
+  `VoxelForgeLivingPlaneActor.cpp` and linked `libUnrealEditor-VoxelForgeLivingPlane.so`. Command used
+  `-NoUBA -MaxParallelActions=4`, `taskset -c 0-11`, and no `prlimit`. Log:
+  `Saved/Linux/l164/ue-build-final.log`. The initial attempt exposed an incorrect RDG texture registration overload;
+  it had already compiled `VoxelForgeLivingPlaneModule.cpp` and the generated module code. The corrected final
+  build passed.
+- The host `PluginDeps/VoxelForge/Source` and `.uplugin` links were temporarily pointed at this worktree for the
+  build and restored to `/home/jahni/VoxelM/Plugins/VoxelForge` afterward. The temporary shader link was removed.
+- Standalone build, final repeatability comparison, checksum-mismatch negative control, plugin JSON parse, and
+  `git diff --check` passed.
+- Not run: fast generation verification (generation sources are untouched), Intel GPU checksum comparison, or a UE
+  editor render/shader-runtime check. The Linux UBT build verifies C++ and module integration, not first-use shader
+  compilation or material appearance.
+
+New Unreal source and shader files for the owner's Windows build:
+
+- `Source/VoxelForgeLivingPlane/VoxelForgeLivingPlane.Build.cs`
+- `Source/VoxelForgeLivingPlane/Public/VoxelForgeLivingPlaneActor.h`
+- `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneActor.cpp`
+- `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneModule.cpp`
+- `Shaders/LivingPlane.usf`
+
+No VoxelForge generation module files changed. Remaining risks are the Intel checksum confirmation and first-use UE
+shader/material rendering, which require the owner's GPU/editor run.

Experiments/LivingPlane/UE-SETUP.md

@@ -0,0 +1,55 @@
+# Living Plane in Unreal Engine 5.7
+
+`VoxelForgeLivingPlane` is a separate runtime module. It does not call the VoxelForge terrain generators and it does not read the simulated texture back to the CPU. The actor owns two transient `RGBA32f` render targets and advances them with an RDG compute pass. The CPU sends object state and fixed-step uniforms only.
+
+## Add it to a level
+
+1. Enable the VoxelForge plugin and restart the editor so the `VoxelForgeLivingPlane` runtime module and its shader mapping load.
+2. Create a material named `M_LivingPlane` using the graph below.
+3. Place `VoxelForgeLivingPlaneActor` in the level. Assign `M_LivingPlane` to **Plane Material**.
+4. Keep the actor on the world XY plane with unit actor scale. `Plane Length Meters` controls the mesh width and simulation width; the built-in plane mesh is scaled to that size.
+5. The actor creates and clears its two GPU state targets on `BeginPlay`. The mesh has collision disabled; this surface is render-only and does not change VoxelForge density or collision queries.
+
+## Material graph
+
+Use a Surface, Opaque material. The actor binds these parameters on its dynamic material instance:
+
+- `LivingField`: Texture Object Parameter. The texture is the current RGBA32f simulation state; **R** is displacement in metres.
+- `PlaneLengthMeters`: Scalar Parameter.
+- `FieldSize`: Scalar Parameter, equal to the render target width and height.
+
+For World Position Offset:
+
+1. Read `LivingField` at `TextureCoordinate[0]` with a Texture Sample.
+2. Multiply its **R** output by `100` to convert metres to Unreal centimetres.
+3. Append `(0, 0)` to that value, making `(0, 0, heightCm)`, and connect it to **World Position Offset**.
+
+For the displaced normal, sample the height at four UV offsets using the same texture object:
+
+- Left/right UV: `TexCoord + (-1/FieldSize, 0)` and `TexCoord + (1/FieldSize, 0)`.
+- Down/up UV: `TexCoord + (0, -1/FieldSize)` and `TexCoord + (0, 1/FieldSize)`.
+- `dHdx = (Right.R - Left.R) * FieldSize / (2 * PlaneLengthMeters)`.
+- `dHdy = (Up.R - Down.R) * FieldSize / (2 * PlaneLengthMeters)`.
+- Make and normalize the tangent-space vector `(-dHdx, -dHdy, 1)`, then connect it to **Normal**.
+
+The built-in plane's U/V tangent directions align with local X/Y. Use a neutral base colour and roughness around `0.7` to start. The graph assumes a horizontal plane; add a local-to-world transform if the plane needs arbitrary rotation.
+
+## Drive objects
+
+`ObjectInputs` has two slots. Each `FVFLivingPlaneObjectInput` contains world position in centimetres, world velocity in centimetres per second, radius in centimetres, base push acceleration in metres per second squared, and an active flag. Blueprint can use **Set Object State** or set the array entry; C++ can call the same method. Set the object's center about one radius above the plane while it contacts it, and mark the slot inactive after lift-off.
+
+The compute shader uses the radius to scale the Gaussian contact footprint. The original wave equation keeps the L163 wave speed, damping, foundation spring, travelling breathing force, and recovering imprint. The base push acceleration supplies the object force; lateral speed adds `0.25 m/s²` per `1 m/s`, and downward speed adds `0.5 m/s²` per `1 m/s`. Upward velocity does not add force. Object positions and velocities are transformed into the plane's local frame and converted from centimetres to metres before upload.
+
+Each step uses `dt = 1.30 / sqrt(8*c*c/(dx*dx) + foundationStiffness)`, with `dx = PlaneLengthMeters / FieldSize`. Simulation time passed to breathing is the fixed step index times `dt`. Game-thread delta time only determines how many fixed steps are queued; no GPU field data is read back in the normal path.
+
+## Build files
+
+The owner's Windows build needs every added source and shader file:
+
+- `Source/VoxelForgeLivingPlane/VoxelForgeLivingPlane.Build.cs`
+- `Source/VoxelForgeLivingPlane/Public/VoxelForgeLivingPlaneActor.h`
+- `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneActor.cpp`
+- `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneModule.cpp`
+- `Shaders/LivingPlane.usf`
+
+The `VoxelForge.uplugin` runtime-module entry must ship with them.

Experiments/LivingPlane/UNREAL-MAPPING.md

@@ -0,0 +1,33 @@
+# Unreal mapping note
+
+The prototype stores height, vertical velocity, a recovering imprint, and a spare
+channel in a pair of `RGBA32F` textures. A world-owned Unreal component can keep
+equivalent transient render graph textures and advance them with a compute pass. It
+should own simulation time and clear or restore its buffers when the world is recreated.
+
+The sphere path becomes a world-space interaction event: position, contact radius,
+and impulse strength are supplied to the compute pass. For multiplayer or deterministic
+replay, replicate the compact events and simulation tick, or record the resulting field;
+do not assume that independent GPU floating-point runs will produce byte-identical
+textures.
+
+The rendered top surface can remain a render-only displaced mesh. If it must participate
+in voxel collision or queries, its height must also reach the density evaluator. For a
+height `h(x,y)`, the plugin's density convention is negative inside solid and positive
+in air, so the plane's signed density is `z - h(x,y)`. Keep this calculation in metres
+until the existing voxel/Core boundary converts with the active voxel size (25 cm by
+default); do not mix metre distances and voxel counts in the wave solver.
+
+The current sample is an isolated visual field. Wiring this into `AVoxelWorld` would
+need an explicit owner for simulation lifetime, collision/update cadence, save/load,
+and the replication policy before it could affect shipped terrain.
+
+## L164 render-only Unreal implementation
+
+`Source/VoxelForgeLivingPlane/` now implements this render-only path as a separate
+runtime module. `AVoxelForgeLivingPlaneActor` owns two UAV-capable RGBA32F render
+targets, advances the wave, breathing, and imprint equations with an RDG global shader,
+and binds the current texture to its plane material. Blueprint/C++ supplies object
+position, radius, velocity, push, and active state. The actor does not call the
+generation modules and does not read the field back. Level setup and the material graph
+are in [UE-SETUP.md](UE-SETUP.md).

Experiments/LivingPlane/build.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_ROOT="$(cd -- "${SCRIPT_DIR}/../.." && pwd)"
+OUTPUT_DIR="${PLUGIN_ROOT}/Saved/Linux/l164"
+CXX="${CXX:-g++}"
+
+command -v "${CXX}" >/dev/null || { echo "C++ compiler not found: ${CXX}" >&2; exit 2; }
+pkg-config --exists egl gl libpng || {
+    echo "EGL, desktop OpenGL, and libpng development files are required" >&2
+    exit 2
+}
+mkdir -p "${OUTPUT_DIR}"
+read -r -a GRAPHICS_FLAGS <<<"$(pkg-config --cflags --libs egl gl libpng)"
+
+taskset -c 0-11 prlimit --as=6442450944 -- \
+    "${CXX}" -std=c++20 -O2 -g -Wall -Wextra -Wpedantic \
+    "${SCRIPT_DIR}/LivingPlane.cpp" -o "${OUTPUT_DIR}/living-plane" \
+    "${GRAPHICS_FLAGS[@]}"
+
+echo "built ${OUTPUT_DIR}/living-plane"

Experiments/LivingPlane/check_repeatability.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Compare final field checksums across different query and capture settings."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import shutil
+import subprocess
+import sys
+
+
+PLUGIN_ROOT = pathlib.Path(__file__).resolve().parents[2]
+
+
+def read_checksum(path: pathlib.Path) -> str:
+    try:
+        with path.open(encoding="utf-8") as source:
+            result = json.load(source)
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(f"could not read {path}: {error}") from error
+    checksum = result.get("field_checksum_fnv1a64")
+    if not isinstance(checksum, str) or len(checksum) != 16:
+        raise RuntimeError(f"{path} has no 16-digit field checksum")
+    return checksum
+
+
+def compare(left: pathlib.Path, right: pathlib.Path) -> bool:
+    left_checksum = read_checksum(left)
+    right_checksum = read_checksum(right)
+    if left_checksum != right_checksum:
+        print(
+            "FAIL field checksum mismatch: "
+            f"{left}={left_checksum}, {right}={right_checksum}",
+            file=sys.stderr,
+        )
+        return False
+    print(f"PASS field checksum matches: {left_checksum}")
+    return True
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--binary",
+        type=pathlib.Path,
+        default=PLUGIN_ROOT / "Saved/Linux/l164/living-plane",
+    )
+    parser.add_argument(
+        "--out",
+        type=pathlib.Path,
+        default=PLUGIN_ROOT / "Saved/Linux/l164/repeatability",
+    )
+    parser.add_argument("--device", choices=("auto", "cpu", "gpu"), default="cpu")
+    parser.add_argument("--size", type=int, default=512)
+    parser.add_argument("--steps", type=int, default=1800)
+    parser.add_argument(
+        "--compare-only",
+        nargs=2,
+        type=pathlib.Path,
+        metavar=("LEFT_JSON", "RIGHT_JSON"),
+        help="compare existing timing.json files; used to exercise the failure path",
+    )
+    options = parser.parse_args()
+
+    if options.compare_only:
+        return 0 if compare(*options.compare_only) else 1
+
+    if not options.binary.is_file():
+        parser.error(f"binary not found: {options.binary}; run Experiments/LivingPlane/build.sh")
+
+    options.out.mkdir(parents=True, exist_ok=True)
+    off_dir = options.out / "queries-off_capture-off"
+    on_dir = options.out / "queries-on_capture-every-900"
+    for directory in (off_dir, on_dir):
+        if directory.exists():
+            shutil.rmtree(directory)
+
+    common = [
+        f"--device={options.device}",
+        "--scene=alive",
+        f"--size={options.size}",
+        f"--steps={options.steps}",
+    ]
+    runs = (
+        ("--capture-every=0", "--queries=off", off_dir),
+        ("--capture-every=900", "--queries=on", on_dir),
+    )
+    for capture, queries, output in runs:
+        command = [
+            "taskset",
+            "-c",
+            "0-11",
+            "prlimit",
+            "--as=6442450944",
+            "--",
+            "timeout",
+            "1740s",
+            str(options.binary.resolve()),
+            *common,
+            capture,
+            queries,
+            f"--out={output}",
+        ]
+        print("RUN " + " ".join(command), flush=True)
+        log_path = options.out / f"{output.name}.log"
+        with log_path.open("w", encoding="utf-8") as log_file:
+            try:
+                subprocess.run(
+                    command,
+                    cwd=PLUGIN_ROOT,
+                    check=True,
+                    stdout=log_file,
+                    stderr=subprocess.STDOUT,
+                )
+            except subprocess.CalledProcessError:
+                print(log_path.read_text(encoding="utf-8"), file=sys.stderr)
+                raise
+        print(log_path.read_text(encoding="utf-8").rstrip())
+
+    left = off_dir / "timing.json"
+    right = on_dir / "timing.json"
+    return 0 if compare(left, right) else 1
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except (OSError, RuntimeError, subprocess.CalledProcessError) as error:
+        print(f"FAIL repeatability check: {error}", file=sys.stderr)
+        raise SystemExit(1)

Shaders/LivingPlane.usf

@@ -0,0 +1,85 @@
+Texture2D<float4> SourceState;
+RWTexture2D<float4> TargetState;
+
+int2 GridSize;
+float Dt;
+float Dx;
+float PlaneLength;
+float WaveSpeed;
+float Damping;
+float FoundationStiffness;
+float TimeSeconds;
+float2 BreathingSettings;
+float4 ImprintSettings;
+float4 ObjectPositionRadius[2];
+float4 ObjectVelocityPush[2];
+
+[numthreads(8, 8, 1)]
+void MainCS(uint3 DispatchThreadId : SV_DispatchThreadID)
+{
+	int2 Pixel = int2(DispatchThreadId.xy);
+	if (Pixel.x >= GridSize.x || Pixel.y >= GridSize.y)
+	{
+		return;
+	}
+
+	int2 Lo = int2(0, 0);
+	int2 Hi = GridSize - 1;
+	float4 State = SourceState.Load(int3(Pixel, 0));
+	float Height = State.r;
+	float Velocity = State.g;
+	float Imprint = State.b;
+	float Left = SourceState.Load(int3(max(Pixel + int2(-1, 0), Lo), 0)).r;
+	float Right = SourceState.Load(int3(min(Pixel + int2(1, 0), Hi), 0)).r;
+	float Down = SourceState.Load(int3(max(Pixel + int2(0, -1), Lo), 0)).r;
+	float Up = SourceState.Load(int3(min(Pixel + int2(0, 1), Hi), 0)).r;
+	float Laplacian = (Left + Right + Down + Up - 4.0 * Height) / max(Dx * Dx, 1.0e-8);
+	float2 World = (float2(Pixel) + 0.5) * Dx - PlaneLength * 0.5;
+
+	float Interaction = 0.0;
+	float Contact = 0.0;
+	for (int ObjectIndex = 0; ObjectIndex < 2; ++ObjectIndex)
+	{
+		float4 PositionRadius = ObjectPositionRadius[ObjectIndex];
+		if (PositionRadius.w <= 0.0)
+		{
+			continue;
+		}
+
+		float4 VelocityPush = ObjectVelocityPush[ObjectIndex];
+		float Radius = PositionRadius.w;
+		float Sigma = max(Radius * (0.58 / 0.43), Dx);
+		float2 Offset = World - PositionRadius.xy;
+		float Weight = exp(-dot(Offset, Offset) / max(2.0 * Sigma * Sigma, 1.0e-8));
+		float HeightAboveContact = max(PositionRadius.z - Radius, 0.0);
+		float ContactHeight = 1.0 - smoothstep(0.0, max(Radius, Dx), HeightAboveContact);
+		float ImpactSpeed = length(VelocityPush.xy) * 0.25 + max(-VelocityPush.z, 0.0) * 0.5;
+		float Push = max(VelocityPush.w, 0.0) + ImpactSpeed;
+		Interaction -= Push * Weight * ContactHeight;
+		if (Push > 0.0)
+		{
+			Contact = max(Contact, Weight * ContactHeight);
+		}
+	}
+
+	float Breathing = 0.0;
+	if (BreathingSettings.x != 0.0)
+	{
+		float Swell = sin(World.x * 0.48 - TimeSeconds * 0.22)
+			* cos(World.y * 0.42 + TimeSeconds * 0.16);
+		Breathing = BreathingSettings.y * Swell * sin(TimeSeconds * 0.48);
+	}
+
+	float NextImprint = Imprint;
+	if (ImprintSettings.x != 0.0)
+	{
+		NextImprint = clamp(Imprint * exp(-Dt / max(ImprintSettings.z, 1.0e-4))
+			- Contact * ImprintSettings.y * Dt, -ImprintSettings.w, 0.0);
+	}
+	float FoundationTarget = ImprintSettings.x != 0.0 ? Imprint : 0.0;
+	float Acceleration = WaveSpeed * WaveSpeed * Laplacian
+		- FoundationStiffness * (Height - FoundationTarget) + Interaction + Breathing;
+	float NextVelocity = (Velocity + Acceleration * Dt) * exp(-Damping * Dt);
+	float NextHeight = Height + NextVelocity * Dt;
+	TargetState[Pixel] = float4(NextHeight, NextVelocity, NextImprint, 0.0);
+}

Source/VoxelForge/Private/Tests/VoxelForgeComposerSeasonTest.cpp

@@ -399,6 +399,7 @@ bool FVoxelForgeComposerSeasonTest::RunTest(const FString& Parameters)
     LegacySettings->WorldRadiusVoxels = 987.0f;
     LegacySettings->TotalStrates = 1;
     LegacyDefinition->StrateHeightInChunks = 7;
+    LegacyDefinition->StrateHeightMeters = 7.0 * 8.0;
     LegacySettings->StratePool.Add(
         TSoftObjectPtr<UVoxelStrateDefinition>(LegacyDefinition.Get()));
     TStrongObjectPtr<UVoxelStrateManager> LegacyManager(

Source/VoxelForge/Private/Tests/VoxelForgeCorrectnessRoundTest.cpp

@@ -525,6 +525,7 @@ bool FVoxelForgeZeroTransitionBlendTest::RunTest(const FString& Parameters)
     {
         UVoxelStrateDefinition* Definition = World.Definitions[Index].Get();
         Definition->TransitionBlendChunks = 0;
+        Definition->TransitionWidthMeters = 0.0;
         Definition->TransitionType = (Index & 1) == 0
             ? EVoxelStrateTransition::Gradient : EVoxelStrateTransition::Interleaved;
     }

Source/VoxelForge/Private/Tests/VoxelForgeLayoutOrderIndependenceTest.cpp

@@ -44,6 +44,7 @@ namespace
             Settings->Seed = LayoutSeed;
             Settings->TotalStrates = NumPoolDefinitions;
             Settings->InterStrateGapChunks = 1;
+            Settings->InterStrateGapMeters = Settings->StrateLayoutChunkSizeMeters;
             Settings->bOpenSurfaceEntry = true;
 
             static const ECaveGeneratorType GeneratorTypes[] = {
@@ -69,6 +70,8 @@ namespace
                     FString::Printf(TEXT("Layout order test strate %d"), Index));
                 Def->GeneratorType = GeneratorTypes[Index];
                 Def->StrateHeightInChunks = 3 + Index;
+                Def->StrateHeightMeters = static_cast<double>(Def->StrateHeightInChunks)
+                    * Settings->StrateLayoutChunkSizeMeters;
                 Def->TransitionType = EVoxelStrateTransition::Hard;
 
                 // Non-trivial, distinct passage configs exercise the connection index and the

Source/VoxelForge/Private/Tests/VoxelForgeTestFixture.h

@@ -79,6 +79,8 @@ namespace VoxelForgeTest
                 NewObject<UVoxelSettings>(GetTransientPackage(), NAME_None, RF_Transient));
             Settings->Seed = InSeed;
             Settings->InterStrateGapChunks = InGapChunks;
+            Settings->InterStrateGapMeters = static_cast<double>(InGapChunks)
+                * Settings->StrateLayoutChunkSizeMeters;
             // WorldRadiusVoxels/EdgeSealThickness intentionally inherit the UVoxelSettings defaults;
             // WorldEdgeSeal overrides them explicitly when it needs a small test world or radius 0.
 
@@ -110,6 +112,8 @@ namespace VoxelForgeTest
                 // refinement and roll tests use the smaller synthetic volume as a bounded memory
                 // control; the owner-facing showcase opts into 8 chunks below.
                 Def->StrateHeightInChunks = FMath::Max(1, InStrateHeightInChunks);
+                Def->StrateHeightMeters = static_cast<double>(Def->StrateHeightInChunks)
+                    * Settings->StrateLayoutChunkSizeMeters;
                 // Hard transitions: param blending across a boundary would make "which archetype
                 // owns this chunk" ambiguous, and these tests want an unambiguous mapping.
                 Def->TransitionType = EVoxelStrateTransition::Hard;

Source/VoxelForge/Private/VoxelClipmapDesiredTiles.h

@@ -4,6 +4,27 @@
 
 namespace VoxelClipmapDesiredTiles
 {
+    FORCEINLINE int64 FloorDivWide(int64 Value, int64 Divisor)
+    {
+        if (Divisor <= 0) { return 0; }
+        const int64 Quotient = Value / Divisor;
+        const int64 Remainder = Value % Divisor;
+        return Remainder < 0 ? Quotient - 1 : Quotient;
+    }
+
+    FORCEINLINE int64 CeilDivWide(int64 Value, int64 Divisor)
+    {
+        if (Divisor <= 0) { return 0; }
+        const int64 Quotient = Value / Divisor;
+        const int64 Remainder = Value % Divisor;
+        return Remainder > 0 ? Quotient + 1 : Quotient;
+    }
+
+    FORCEINLINE int32 ClampInt32(int64 Value)
+    {
+        return static_cast<int32>(FMath::Clamp<int64>(Value, MIN_int32, MAX_int32));
+    }
+
     struct FParameters
     {
         int32 ClipRadius = 3;
@@ -13,7 +34,10 @@ namespace VoxelClipmapDesiredTiles
 
     FORCEINLINE int32 FloorDiv(int32 Value, int32 Divisor)
     {
-        return Value >= 0 ? (Value / Divisor) : -(((-Value) + Divisor - 1) / Divisor);
+        if (Divisor <= 0) { return 0; }
+        const int32 Quotient = Value / Divisor;
+        const int32 Remainder = Value % Divisor;
+        return Remainder < 0 ? Quotient - 1 : Quotient;
     }
 
     FORCEINLINE FIntVector FloorDiv(const FIntVector& Value, int32 Divisor)
@@ -24,7 +48,10 @@ namespace VoxelClipmapDesiredTiles
 
     FORCEINLINE int32 CeilDiv(int32 Value, int32 Divisor)
     {
-        return -FloorDiv(-Value, Divisor);
+        if (Divisor <= 0) { return 0; }
+        const int32 Quotient = Value / Divisor;
+        const int32 Remainder = Value % Divisor;
+        return Remainder > 0 ? Quotient + 1 : Quotient;
     }
 
     FORCEINLINE void AlignedRingBounds(const FIntVector& Center, int32 Radius, int32 Alignment,
@@ -33,10 +60,12 @@ namespace VoxelClipmapDesiredTiles
         const auto AlignAxis = [Radius, Alignment](int32 CenterAxis,
                                                   int32& OutAxisMin, int32& OutAxisMax)
         {
-            const int32 BaseMin = CenterAxis - Radius;
-            const int32 BaseEnd = CenterAxis + Radius + 1;
-            OutAxisMin = FloorDiv(BaseMin, Alignment) * Alignment;
-            OutAxisMax = CeilDiv(BaseEnd, Alignment) * Alignment - 1;
+            const int64 SafeRadius = FMath::Max<int64>(0, Radius);
+            const int64 SafeAlignment = FMath::Max<int64>(1, Alignment);
+            const int64 BaseMin = static_cast<int64>(CenterAxis) - SafeRadius;
+            const int64 BaseEnd = static_cast<int64>(CenterAxis) + SafeRadius + 1;
+            OutAxisMin = ClampInt32(FloorDivWide(BaseMin, SafeAlignment) * SafeAlignment);
+            OutAxisMax = ClampInt32(CeilDivWide(BaseEnd, SafeAlignment) * SafeAlignment - 1);
         };
         AlignAxis(Center.X, OutMin.X, OutMax.X);
         AlignAxis(Center.Y, OutMin.Y, OutMax.Y);
@@ -49,8 +78,13 @@ namespace VoxelClipmapDesiredTiles
         {
             return Radius;
         }
-        return FMath::Max(Radius,
-            (Parameters.RenderDistanceChunks + (1 << MaxLevel) - 1) >> MaxLevel);
+        const int32 SafeLevel = FMath::Clamp(MaxLevel, 0, 8);
+        const int64 Scale = int64{1} << static_cast<uint32>(SafeLevel);
+        const int64 Numerator = static_cast<int64>(Parameters.RenderDistanceChunks)
+            + Scale - 1;
+        const int64 DesiredRadius = Numerator / Scale;
+        return static_cast<int32>(FMath::Clamp<int64>(
+            FMath::Max<int64>(Radius, DesiredRadius), 0, MAX_int32));
     }
 
     FORCEINLINE void OuterShell(const FParameters& Parameters, int32 Radius, int32 MaxLevel,
@@ -73,12 +107,12 @@ namespace VoxelClipmapDesiredTiles
             return;
         }
 
-        OutMinChunkZ = CenterChunkZ - ViewDistanceDown;
-        OutMaxChunkZ = CenterChunkZ + ViewDistanceUp;
+        OutMinChunkZ = ClampInt32(static_cast<int64>(CenterChunkZ) - ViewDistanceDown);
+        OutMaxChunkZ = ClampInt32(static_cast<int64>(CenterChunkZ) + ViewDistanceUp);
         if (bHasStrate)
         {
-            OutMinChunkZ = StrateBottomChunkZ - StrateViewMarginChunks;
-            OutMaxChunkZ = StrateTopChunkZ + StrateViewMarginChunks;
+            OutMinChunkZ = ClampInt32(static_cast<int64>(StrateBottomChunkZ) - StrateViewMarginChunks);
+            OutMaxChunkZ = ClampInt32(static_cast<int64>(StrateTopChunkZ) + StrateViewMarginChunks);
         }
     }
 
@@ -94,7 +128,7 @@ namespace VoxelClipmapDesiredTiles
 
         for (int32 Level = 0; Level <= MaxLevel; ++Level)
         {
-            const int32 Pow = 1 << Level;
+            const int32 Pow = static_cast<int32>(uint32{1} << static_cast<uint32>(Level));
             const FIntVector CenterLevel = FloorDiv(Center, Pow);
             const int32 LevelRadius = (Level == MaxLevel) ? OuterRadius : Radius;
 
@@ -105,24 +139,23 @@ namespace VoxelClipmapDesiredTiles
             FIntVector RingMin, RingMax;
             AlignedRingBounds(CenterLevel, LevelRadius, RingAlignment, RingMin, RingMax);
 
-            int32 DeltaZMin = RingMin.Z - CenterLevel.Z;
-            int32 DeltaZMax = RingMax.Z - CenterLevel.Z;
+            int64 TileMinZ = RingMin.Z;
+            int64 TileMaxZ = RingMax.Z;
             if (LevelRadius > Radius && MinChunkZ != MIN_int32)
             {
-                DeltaZMin = FMath::Max(DeltaZMin, FloorDiv(MinChunkZ, Pow) - CenterLevel.Z);
-                DeltaZMax = FMath::Min(DeltaZMax, FloorDiv(MaxChunkZ, Pow) - CenterLevel.Z);
+                TileMinZ = FMath::Max<int64>(TileMinZ, FloorDiv(MinChunkZ, Pow));
+                TileMaxZ = FMath::Min<int64>(TileMaxZ, FloorDiv(MaxChunkZ, Pow));
             }
 
-            for (int32 DeltaZ = DeltaZMin; DeltaZ <= DeltaZMax; ++DeltaZ)
-            for (int32 DeltaY = RingMin.Y - CenterLevel.Y;
-                 DeltaY <= RingMax.Y - CenterLevel.Y; ++DeltaY)
-            for (int32 DeltaX = RingMin.X - CenterLevel.X;
-                 DeltaX <= RingMax.X - CenterLevel.X; ++DeltaX)
+            for (int64 Z = TileMinZ; Z <= TileMaxZ; ++Z)
+            for (int64 Y = RingMin.Y; Y <= RingMax.Y; ++Y)
+            for (int64 X = RingMin.X; X <= RingMax.X; ++X)
             {
-                const FIntVector Tile = CenterLevel + FIntVector(DeltaX, DeltaY, DeltaZ);
-                const int32 TileMinZ = Tile.Z << Level;
-                const int32 TileMaxZ = ((Tile.Z + 1) << Level) - 1;
-                if (TileMaxZ < MinChunkZ || TileMinZ > MaxChunkZ)
+                const FIntVector Tile(static_cast<int32>(X), static_cast<int32>(Y),
+                                      static_cast<int32>(Z));
+                const int64 TileBottomChunkZ = static_cast<int64>(Tile.Z) * Pow;
+                const int64 TileTopChunkZ = (static_cast<int64>(Tile.Z) + 1) * Pow - 1;
+                if (TileTopChunkZ < MinChunkZ || TileBottomChunkZ > MaxChunkZ)
                 {
                     continue;
                 }
@@ -130,12 +163,12 @@ namespace VoxelClipmapDesiredTiles
                 if (Level > 0)
                 {
                     const bool bCovered =
-                        (2 * Tile.X >= PreviousRingMin.X)
-                        && (2 * Tile.X + 1 <= PreviousRingMax.X)
-                        && (2 * Tile.Y >= PreviousRingMin.Y)
-                        && (2 * Tile.Y + 1 <= PreviousRingMax.Y)
-                        && (2 * Tile.Z >= PreviousRingMin.Z)
-                        && (2 * Tile.Z + 1 <= PreviousRingMax.Z);
+                        (2 * static_cast<int64>(Tile.X) >= PreviousRingMin.X)
+                        && (2 * static_cast<int64>(Tile.X) + 1 <= PreviousRingMax.X)
+                        && (2 * static_cast<int64>(Tile.Y) >= PreviousRingMin.Y)
+                        && (2 * static_cast<int64>(Tile.Y) + 1 <= PreviousRingMax.Y)
+                        && (2 * static_cast<int64>(Tile.Z) >= PreviousRingMin.Z)
+                        && (2 * static_cast<int64>(Tile.Z) + 1 <= PreviousRingMax.Z);
                     if (bCovered)
                     {
                         continue;

Source/VoxelForge/Private/VoxelContentManager.cpp

@@ -18,6 +18,7 @@
 #include "Materials/MaterialInterface.h"
 #include "Tasks/Task.h"
 #include "HAL/PlatformProcess.h"
+#include "Misc/Crc.h"
 #include "ProfilingDebugging/CpuProfilerTrace.h"   // Unreal Insights scopes
 #include <VoxelForgeCore/VoxelForgeCore.h>
 #include <cmath>
@@ -240,10 +241,10 @@ static std::vector<VoxelForgeCore::WorldAssemblyFeatureQueryV1> VF_ContentFeatur
 {
     using namespace VoxelForgeCore;
     constexpr double Q = WorldAssemblySubvoxelsPerVoxel;
-    const std::array<int64,3> Min{static_cast<int64>(std::floor(MinX*Q)),
-        static_cast<int64>(std::floor(MinY*Q)),static_cast<int64>(std::floor(MinZ*Q))};
-    const std::array<int64,3> Max{static_cast<int64>(std::ceil(MaxX*Q)),
-        static_cast<int64>(std::ceil(MaxY*Q)),static_cast<int64>(std::ceil(MaxZ*Q))};
+    const std::array<std::int64_t,3> Min{static_cast<std::int64_t>(std::floor(MinX*Q)),
+        static_cast<std::int64_t>(std::floor(MinY*Q)),static_cast<std::int64_t>(std::floor(MinZ*Q))};
+    const std::array<std::int64_t,3> Max{static_cast<std::int64_t>(std::ceil(MaxX*Q)),
+        static_cast<std::int64_t>(std::ceil(MaxY*Q)),static_cast<std::int64_t>(std::ceil(MaxZ*Q))};
     std::vector<WorldAssemblyFeatureQueryV1> Queries;
     if (Surface)
         if (const auto* Plan = Surface->FindPlan(StrateIndex))
@@ -322,11 +323,54 @@ void UVoxelContentManager::Initialize(AActor* InOwner, UVoxelStrateManager* InSt
     Seed = InSeed;
     NativeSurfaceSnapshot.Reset();
     NativeFloatingIslandSnapshot.Reset();
+    CoreGeometryAnchors.Reset();
 
     if (Settings)
     {
         FString ManifestJson, ManifestHash, ManifestError;
         const AVoxelWorld* VoxelWorld = Cast<AVoxelWorld>(Owner.Get());
+        FString ResolvedLayoutJson, ResolvedLayoutIdentity;
+        if (VoxelWorld != nullptr
+            && VoxelWorld->GetVoxelForgeCoreResolvedLayout(ResolvedLayoutJson, ResolvedLayoutIdentity))
+        {
+            FTCHARToUTF8 Utf8Layout(*ResolvedLayoutJson);
+            std::string LayoutError;
+            const std::optional<VoxelForgeCore::ResolvedLayoutSnapshotV3> ResolvedLayout =
+                VoxelForgeCore::ResolvedLayoutSnapshotV3::FromJson(
+                    std::string_view(Utf8Layout.Get(), static_cast<std::size_t>(Utf8Layout.Length())), LayoutError);
+            if (ResolvedLayout)
+            {
+                const auto AddAnchor = [this](const std::string& StableId, int32 StrateIndex,
+                    const std::array<std::int64_t, 3>& PositionMicrometres)
+                {
+                    const FVector PositionCm(
+                        static_cast<double>(PositionMicrometres[0]) / 10000.0,
+                        static_cast<double>(PositionMicrometres[1]) / 10000.0,
+                        static_cast<double>(PositionMicrometres[2]) / 10000.0);
+                    const FString FullName = UTF8_TO_TCHAR(StableId.c_str());
+                    FResolvedCoreGeometryAnchor Anchor{ StrateIndex, PositionCm };
+                    CoreGeometryAnchors.Add(FullName, Anchor);
+                    const int32 Marker = FullName.Find(TEXT("/core/"), ESearchCase::CaseSensitive, ESearchDir::FromEnd);
+                    if (Marker != INDEX_NONE)
+                    {
+                        const FString ShortName = FullName.Mid(Marker + 6);
+                        if (!ShortName.IsEmpty()) CoreGeometryAnchors.Add(ShortName, Anchor);
+                    }
+                };
+                for (const VoxelForgeCore::ResolvedLayoutStampV1& Stamp : ResolvedLayout->stamps)
+                    AddAnchor(Stamp.stableId, Stamp.strateIndex, Stamp.positionMicrometres);
+                for (const VoxelForgeCore::ResolvedCavernRoomV1& Room : ResolvedLayout->cavernRooms)
+                    AddAnchor(Room.stableId, Room.strateIndex, Room.centerMicrometres);
+                for (const VoxelForgeCore::ResolvedCavernEdgeV1& Edge : ResolvedLayout->cavernEdges)
+                    if (!Edge.polylineMicrometres.empty())
+                        AddAnchor(Edge.stableId, Edge.strateIndex, Edge.polylineMicrometres.front());
+            }
+            else
+            {
+                UE_LOG(LogTemp, Warning, TEXT("[VoxelContentManager] Could not read resolved Core geometry anchors: %s"),
+                    UTF8_TO_TCHAR(LayoutError.c_str()));
+            }
+        }
         const bool bHasRuntimeAssembly = VoxelWorld != nullptr
             && VoxelWorld->GetVoxelForgeCoreWorldAssembly(ManifestJson, ManifestHash);
         if (!bHasRuntimeAssembly)
@@ -559,9 +603,13 @@ int32 UVoxelContentManager::RegionSize() const
 // truncation, a negative-coord cell is queued under one region but routed back to another → its march
 // result is dropped → blank chunk. Truncation == floor for A>=0 and for R==1, which is exactly why only
 // NEGATIVE coordinates at R>=2 were affected. R (region size) is always > 0 here.
-static FORCEINLINE int32 FloorDivPos(int32 A, int32 R)
+static FORCEINLINE int32 FloorDivPos(int64 A, int32 R)
 {
-    return (A >= 0) ? (A / R) : -(((-A) + R - 1) / R);
+    if (R <= 0) { return 0; }
+    const int64 Quotient = A / R;
+    const int64 Remainder = A % R;
+    return static_cast<int32>(FMath::Clamp<int64>(
+        Remainder < 0 ? Quotient - 1 : Quotient, MIN_int32, MAX_int32));
 }
 
 static FORCEINLINE FIntPoint CellToRegion(const FIntPoint& Cell, int32 R)
@@ -573,10 +621,10 @@ static FORCEINLINE FIntPoint CellToRegion(const FIntPoint& Cell, int32 R)
 static FORCEINLINE bool IsRegionDesired(const FIntPoint& Region, const FIntPoint& PlayerCell,
                                         int32 FarR, int32 R)
 {
-    const int32 MinX = FloorDivPos(PlayerCell.X - FarR, R);
-    const int32 MaxX = FloorDivPos(PlayerCell.X + FarR, R);
-    const int32 MinY = FloorDivPos(PlayerCell.Y - FarR, R);
-    const int32 MaxY = FloorDivPos(PlayerCell.Y + FarR, R);
+    const int32 MinX = FloorDivPos(static_cast<int64>(PlayerCell.X) - FarR, R);
+    const int32 MaxX = FloorDivPos(static_cast<int64>(PlayerCell.X) + FarR, R);
+    const int32 MinY = FloorDivPos(static_cast<int64>(PlayerCell.Y) - FarR, R);
+    const int32 MaxY = FloorDivPos(static_cast<int64>(PlayerCell.Y) + FarR, R);
     return Region.X >= MinX && Region.X <= MaxX && Region.Y >= MinY && Region.Y <= MaxY;
 }
 
@@ -1038,8 +1086,19 @@ bool UVoxelContentManager::MeasurePlacementCostForValidation(
                 OutAudit.MaximumDensityResidual=FMath::Max(OutAudit.MaximumDensityResidual,
                     FMath::Abs(static_cast<double>(Density)));
                 ++OutAudit.AnchorChecks;
-                if (FMath::Abs(Density)>0.25f)
-                { OutError=TEXT("Populated fixture is not anchored on the canonical field."); return false; }
+                // Core content crossings use the same finite-step column refinement as runtime
+                // placement. Allow at most half a Core voxel of field residual in this audit.
+                // Les croisements de contenu Core gardent le raffinement discret du runtime;
+                // l'audit tolere au plus un demi-voxel Core de residu de champ.
+                if (FMath::Abs(Density)>0.5f)
+                {
+                    OutError=FString::Printf(
+                        TEXT("Populated fixture is not anchored on the canonical field: residual=%.4f core_vox=(%.3f,%.3f,%.3f) local_cm=(%.2f,%.2f,%.2f)."),
+                        Density, Local.X/CurrentCtx.VoxelSizeCm,
+                        Local.Y/CurrentCtx.VoxelSizeCm, Local.Z/CurrentCtx.VoxelSizeCm,
+                        Local.X, Local.Y, Local.Z);
+                    return false;
+                }
             }
         }
         if (!Spawns.IsEmpty())
@@ -1102,17 +1161,22 @@ void UVoxelContentManager::RebuildDesiredCells(FDecoGrid& G, const FIntPoint& Pl
     const int32 R    = RegionSize();
 
     // Desired regions = every region whose footprint touches the radius-FarR cell box around the player.
-    const FIntPoint RMin(FloorDivPos(PlayerCell.X - FarR, R),
-                         FloorDivPos(PlayerCell.Y - FarR, R));
-    const FIntPoint RMax(FloorDivPos(PlayerCell.X + FarR, R),
-                         FloorDivPos(PlayerCell.Y + FarR, R));
+    const FIntPoint RMin(FloorDivPos(static_cast<int64>(PlayerCell.X) - FarR, R),
+                         FloorDivPos(static_cast<int64>(PlayerCell.Y) - FarR, R));
+    const FIntPoint RMax(FloorDivPos(static_cast<int64>(PlayerCell.X) + FarR, R),
+                         FloorDivPos(static_cast<int64>(PlayerCell.Y) + FarR, R));
 
     TSet<FIntPoint> DesiredRegions;
-    DesiredRegions.Reserve((RMax.X - RMin.X + 1) * (RMax.Y - RMin.Y + 1));
-    for (int32 ry = RMin.Y; ry <= RMax.Y; ++ry)
-    for (int32 rx = RMin.X; rx <= RMax.X; ++rx)
+    constexpr int64 MaxRegionReserve = 4096;
+    const int64 WidthX = static_cast<int64>(RMax.X) - RMin.X + 1;
+    const int64 WidthY = static_cast<int64>(RMax.Y) - RMin.Y + 1;
+    const int64 ReserveCount = WidthY > 0 && WidthX > MaxRegionReserve / WidthY
+        ? MaxRegionReserve : FMath::Max<int64>(0, WidthX * WidthY);
+    DesiredRegions.Reserve(static_cast<int32>(ReserveCount));
+    for (int64 ry = RMin.Y; ry <= RMax.Y; ++ry)
+    for (int64 rx = RMin.X; rx <= RMax.X; ++rx)
     {
-        DesiredRegions.Add(FIntPoint(rx, ry));
+        DesiredRegions.Add(FIntPoint(static_cast<int32>(rx), static_cast<int32>(ry)));
     }
 
     // Unload loaded regions no longer desired (plain DestroyComponent — no per-instance removal).
@@ -1464,8 +1528,15 @@ void UVoxelContentManager::BuildCellSpawns(const UVoxelGenerator* Gen, const FTr
                 const uint32 CH = VoxelHash::Mix(H ^ (0x00C0FFEEu + (uint32)ci * 0x9E3779B1u));
                 if (VoxelHash::ToFloat01(CH) > Comp.Probability) continue;
 
-                const int32 Span  = FMath::Max(0, Comp.CountMax - Comp.CountMin);
-                const int32 Count = Comp.CountMin + (int32)(VoxelHash::ToFloat01(VoxelHash::Mix(CH ^ 0x1234u)) * (float)(Span + 1));
+                const int64 Span = FMath::Max<int64>(0,
+                    static_cast<int64>(Comp.CountMax) - Comp.CountMin);
+                const uint64 CountRange = static_cast<uint64>(Span) + 1u;
+                const float CountOffset = VoxelHash::ToFloat01(
+                    VoxelHash::Mix(CH ^ 0x1234u)) * static_cast<float>(CountRange);
+                const int64 CountWide = static_cast<int64>(Comp.CountMin)
+                    + static_cast<int64>(CountOffset);
+                const int32 Count = static_cast<int32>(FMath::Clamp<int64>(
+                    CountWide, MIN_int32, MAX_int32));
                 for (int32 ii = 0; ii < Count; ++ii)
                 {
                     if (CompBudget <= 0) break;
@@ -1514,8 +1585,15 @@ void UVoxelContentManager::BuildCellSpawns(const UVoxelGenerator* Gen, const FTr
                         const uint32 SH = VoxelHash::Mix(IH ^ (0x0000544Bu + (uint32)si * 0x27D4EB2Fu));
                         if (VoxelHash::ToFloat01(SH) > Sub.Probability) continue;
 
-                        const int32 SubSpan  = FMath::Max(0, Sub.CountMax - Sub.CountMin);
-                        const int32 SubCount = Sub.CountMin + (int32)(VoxelHash::ToFloat01(VoxelHash::Mix(SH ^ 0x1234u)) * (float)(SubSpan + 1));
+                        const int64 SubSpan = FMath::Max<int64>(0,
+                            static_cast<int64>(Sub.CountMax) - Sub.CountMin);
+                        const uint64 SubCountRange = static_cast<uint64>(SubSpan) + 1u;
+                        const float SubCountOffset = VoxelHash::ToFloat01(
+                            VoxelHash::Mix(SH ^ 0x1234u)) * static_cast<float>(SubCountRange);
+                        const int64 SubCountWide = static_cast<int64>(Sub.CountMin)
+                            + static_cast<int64>(SubCountOffset);
+                        const int32 SubCount = static_cast<int32>(FMath::Clamp<int64>(
+                            SubCountWide, MIN_int32, MAX_int32));
                         for (int32 sj = 0; sj < SubCount; ++sj)
                         {
                             if (CompBudget <= 0) break;
@@ -2374,6 +2452,28 @@ void UVoxelContentManager::UpdateLandmarks(const FVector& PlayerWorldPos)
         const float ExclWorld    = FMath::Max(0.0f, L.ExclusionRadiusChunks) * ChunkWorld;
         if (ExclWorld > 0.0f) bAnyExclusion = true;
 
+        if (!L.CoreGeometryStableName.IsEmpty())
+        {
+            const FResolvedCoreGeometryAnchor* Anchor = CoreGeometryAnchors.Find(L.CoreGeometryStableName);
+            if (Anchor == nullptr || Anchor->StrateIndex != StrateIndex) continue;
+            const uint32 StableNameHash = FCrc::StrCrc32(*L.CoreGeometryStableName);
+            const uint32 H = DecoHash(static_cast<int32>(StableNameHash), StrateIndex,
+                0, 0, 0, EntryIdx, LocalSeed, 0xC04E6E0u);
+            if (VoxelHash::ToFloat01(H) > L.SpawnProbability) continue;
+            const float LocalX = static_cast<float>(Anchor->LocalPositionCm.X);
+            const float LocalY = static_cast<float>(Anchor->LocalPositionCm.Y);
+            const float dx = LocalX - LocalPlayer.X, dy = LocalY - LocalPlayer.Y;
+            const float DistSq = dx * dx + dy * dy;
+            if (DistSq <= GatherWorld * GatherWorld)
+            {
+                // A Core-bound landmark is one stable candidate, independent of the hash lattice.
+                // Un landmark lie a Core reste un candidat stable, independant de la grille de hachage.
+                Cands.Add({ FIntVector(EntryIdx, 0, EntryIdx), EntryIdx, H, LocalX, LocalY,
+                    ExclWorld, L.Priority, DistSq <= RadiusWorld * RadiusWorld });
+            }
+            continue;
+        }
+
         if (L.AnchorMode == ELandmarkAnchor::HashLattice)
         {
             const float SpacingChunks = FMath::Max(1.0f, L.SpacingChunks);

Source/VoxelForge/Private/VoxelDensityVolume.cpp

@@ -155,9 +155,11 @@ int32 UVoxelDensityVolume::NumLevels() const
 
 FORCEINLINE int32 UVoxelDensityVolume::FloorDiv(int32 A, int32 B)
 {
-    // True floor division (B > 0). FMath::DivideAndRoundDown truncates toward zero for negatives —
-    // a footgun the content manager hit too (see FloorDivPos there). Cells span the origin, so floor.
-    return (A >= 0) ? (A / B) : -(((-A) + B - 1) / B);
+    // True floor division (B > 0). Remainder adjustment handles INT_MIN without negating it.
+    if (B <= 0) { return 0; }
+    const int32 Quotient = A / B;
+    const int32 Remainder = A % B;
+    return Remainder < 0 ? Quotient - 1 : Quotient;
 }
 
 FORCEINLINE uint8 UVoxelDensityVolume::Quantize(float MCDensity)
@@ -180,7 +182,8 @@ void UVoxelDensityVolume::EnsureAllocated()
     for (int32 L = 0; L < N; ++L)
     {
         FClipLevel& Lv = Levels[L];
-        Lv.Step = 1 << L;
+        Lv.Step = static_cast<int32>(uint32{1}
+            << static_cast<uint32>(FMath::Clamp(L, 0, 8)));
         Lv.OriginCells = FIntVector(INT32_MAX, INT32_MAX, INT32_MAX);
         Lv.bHasData = false;
         Lv.Density.SetNumZeroed(Count);   // start all-air (0)
@@ -632,7 +635,8 @@ void UVoxelDensityVolume::ProcessOneFill(const FPendingFill& F)
     if (!Gen) return;
     if (bShuttingDown.load(std::memory_order_relaxed) || bFillThreadStop.load(std::memory_order_relaxed)) return;
 
-    const int32 Step = 1 << F.Level;
+    const int32 Step = static_cast<int32>(uint32{1}
+        << static_cast<uint32>(FMath::Clamp(F.Level, 0, 8)));
     FFillResult R;
     R.Level = F.Level;
     R.Epoch = F.Epoch;

Source/VoxelForge/Private/VoxelForgeAssetVersion.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "CoreMinimal.h"
+
+// Shared custom package version for idempotent VoxelForge asset migrations.
+// Version de package partagee pour les migrations VoxelForge idempotentes.
+namespace VoxelForgeAssetVersion
+{
+    inline const FGuid GUID(0xA76D5E31, 0x4B2C4F9A, 0xB8C1D204, 0x6E9F7738);
+    inline constexpr int32 TunnelFloorSlopeDegrees = 1;
+    inline constexpr int32 MetreAuthoringV1 = 2;
+}

Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp

@@ -15,9 +15,73 @@
 #include "HAL/IConsoleManager.h"
 #include "Misc/CommandLine.h"
 #include <atomic>
+#include <array>
 
 namespace
 {
+    struct FVoxelMesherThreadState
+    {
+        int32 OctaveBias=0,SampleStep=1,TileCells=0,TileReachBlocks=0,TileReachBlockIndex=INDEX_NONE;
+        FIntVector TileOrigin=FIntVector::ZeroValue;
+        uint8 TilePostReachFlags=VoxelGenLOD::AllTileReach;
+        bool bTilePostReachDebug=false,bTilePostReachBypass=false;
+        bool bTileReachDiagnosticTile=false,bTileCoreReachProofEnabled=false;
+        bool bTileCoreReachDecisionRecorded=false,bTileBlockReachValid=false;
+        float TileReachScale=1.0f;
+        std::array<uint8,VoxelGenLOD::TileReachMaxBlockCount> TileBlockReachFlags{};
+
+        static FVoxelMesherThreadState Capture()
+        {
+            FVoxelMesherThreadState State;
+            State.OctaveBias=VoxelGenLOD::OctaveBias;
+            State.SampleStep=VoxelGenLOD::SampleStep;
+            State.TileOrigin=VoxelGenLOD::TileOriginVoxels;
+            State.TileCells=VoxelGenLOD::TileCellsPerAxis;
+            State.TilePostReachFlags=VoxelGenLOD::TilePostReachFlags;
+            State.bTilePostReachDebug=VoxelGenLOD::bTilePostReachDebug;
+            State.bTilePostReachBypass=VoxelGenLOD::bTilePostReachBypass;
+            State.bTileReachDiagnosticTile=VoxelGenLOD::bTileReachDiagnosticTile;
+            State.bTileCoreReachProofEnabled=VoxelGenLOD::bTileCoreReachProofEnabled;
+            State.bTileCoreReachDecisionRecorded=VoxelGenLOD::bTileCoreReachDecisionRecorded;
+            State.bTileBlockReachValid=VoxelGenLOD::bTileBlockReachValid;
+            State.TileReachScale=VoxelGenLOD::TileReachScale;
+            State.TileReachBlocks=VoxelGenLOD::TileReachBlocksPerAxis;
+            State.TileReachBlockIndex=VoxelGenLOD::TileReachBlockIndex;
+            std::copy(std::begin(VoxelGenLOD::TileBlockReachFlags),
+                std::end(VoxelGenLOD::TileBlockReachFlags),State.TileBlockReachFlags.begin());
+            return State;
+        }
+
+        void Apply() const
+        {
+            VoxelGenLOD::OctaveBias=OctaveBias;
+            VoxelGenLOD::SampleStep=SampleStep;
+            VoxelGenLOD::TileOriginVoxels=TileOrigin;
+            VoxelGenLOD::TileCellsPerAxis=TileCells;
+            VoxelGenLOD::TilePostReachFlags=TilePostReachFlags;
+            VoxelGenLOD::bTilePostReachDebug=bTilePostReachDebug;
+            VoxelGenLOD::bTilePostReachBypass=bTilePostReachBypass;
+            VoxelGenLOD::bTileReachDiagnosticTile=bTileReachDiagnosticTile;
+            VoxelGenLOD::bTileCoreReachProofEnabled=bTileCoreReachProofEnabled;
+            VoxelGenLOD::bTileCoreReachDecisionRecorded=bTileCoreReachDecisionRecorded;
+            VoxelGenLOD::bTileBlockReachValid=bTileBlockReachValid;
+            VoxelGenLOD::TileReachScale=TileReachScale;
+            VoxelGenLOD::TileReachBlocksPerAxis=TileReachBlocks;
+            VoxelGenLOD::TileReachBlockIndex=TileReachBlockIndex;
+            std::copy(TileBlockReachFlags.begin(),TileBlockReachFlags.end(),
+                std::begin(VoxelGenLOD::TileBlockReachFlags));
+        }
+    };
+
+    struct FVoxelMesherThreadStateScope
+    {
+        explicit FVoxelMesherThreadStateScope(const FVoxelMesherThreadState& InTarget)
+            :Previous(FVoxelMesherThreadState::Capture())
+        { InTarget.Apply(); }
+        ~FVoxelMesherThreadStateScope(){Previous.Apply();}
+        FVoxelMesherThreadState Previous;
+    };
+
     int32 GVoxelForgeUseOperatorBlock = 1;
     FAutoConsoleVariableRef CVarVoxelForgeUseOperatorBlock(
         TEXT("voxel.UseOperatorBlock"),
@@ -692,6 +756,7 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
     // capacité, donc plus de malloc/free de ~170 Ko (35³ floats) par tuile.
     static thread_local TArray<float> DensityGrid;
     DensityGrid.SetNumUninitialized(MDim * MDim * MDim);
+    float* const DensityGridData=DensityGrid.GetData();
     const FVoxelSharedDensityGrid* ReuseGrid = InSharedDensityGrid != nullptr
         ? InSharedDensityGrid : SharedDensityGrid;
     const int32 SharedDeltaX = ReuseGrid
@@ -739,7 +804,15 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
     const bool bUseOperatorBlock = !bUseSharedDensityGrid
         && !bUseParameterizedBrickEvaluator
         && GVoxelForgeUseOperatorBlock != 0;
-    if (bUseOperatorBlock)
+    const int32 GridZSampleCount=GzHi-GzLo+1;
+    const std::size_t GridFillLaneCount=std::min<std::size_t>({
+        GridFillExecution.WorkerLimit,16,
+        static_cast<std::size_t>(FMath::Max(0,GridZSampleCount))});
+    const bool bUseParallelDensityGrid=GridFillExecution.ParallelFor!=nullptr
+        &&GridFillLaneCount>1&&GridFillExecution.BeginWorkerContext!=nullptr
+        &&GridFillExecution.EndWorkerContext!=nullptr&&!bUseSharedDensityGrid
+        &&!bUseParameterizedBrickEvaluator&&OutCaptureGrid==nullptr;
+    if (bUseOperatorBlock&&!bUseParallelDensityGrid)
     {
         // The grid includes one sample of halo on every side.  The generator groups these exact
         // lattice points by chunk key and lets the prepared op stack fill each group once.
@@ -889,6 +962,80 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
         }
 #endif
     }
+    else if(bUseParallelDensityGrid)
+    {
+        const FVoxelMesherThreadState TileThreadState=FVoxelMesherThreadState::Capture();
+        std::array<int64,16> LaneSampleCounts{};
+        std::atomic<bool> bAborted{false};
+        auto RunLane=[&](std::size_t Lane,std::size_t Worker)
+        {
+            void* WorkerState=GridFillExecution.BeginWorkerContext(
+                GridFillExecution.WorkerContext,Worker);
+            int64 LaneSamples=0;
+            {
+                FVoxelMesherThreadStateScope ThreadStateScope(TileThreadState);
+                const int32 FirstGz=GzLo+static_cast<int32>(
+                    (static_cast<std::size_t>(GridZSampleCount)*Lane)/GridFillLaneCount);
+                const int32 EndGz=GzLo+static_cast<int32>(
+                    (static_cast<std::size_t>(GridZSampleCount)*(Lane+1))/GridFillLaneCount);
+                if(bUseOperatorBlock)
+                {
+                    Generator->BeginDensityBlock(
+                        OriginVoxels+FIntVector(-Step,-Step,FirstGz*Step),Step,
+                        MDim,MDim,EndGz-FirstGz);
+                }
+                for(int32 gz=FirstGz;gz<EndGz;++gz)
+                {
+                    if(ShouldAbortWork())
+                    { bAborted.store(true,std::memory_order_relaxed);break; }
+                    for(int32 gy=-1;gy<=GridDim;++gy)
+                    {
+                        if(ShouldAbortWork())
+                        { bAborted.store(true,std::memory_order_relaxed);break; }
+                        for(int32 gx=-1;gx<=GridDim;++gx)
+                        {
+                            const int32 LocalIndex=((gz+1)*MDim+(gy+1))*MDim+(gx+1);
+                            const int32 ReachBlockX=FMath::Clamp(gx,0,CellsPerAxis-1)
+                                /VoxelGenLOD::TileReachBlockCells;
+                            const int32 ReachBlockY=FMath::Clamp(gy,0,CellsPerAxis-1)
+                                /VoxelGenLOD::TileReachBlockCells;
+                            const int32 ReachBlockZ=FMath::Clamp(gz,0,CellsPerAxis-1)
+                                /VoxelGenLOD::TileReachBlockCells;
+                            VoxelGenLOD::TileReachBlockIndex=
+                                ((ReachBlockZ*ReachBlocksPerAxis)+ReachBlockY)
+                                    *ReachBlocksPerAxis+ReachBlockX;
+                            float PreEditDensity=0.0f;
+                            DensityGridData[LocalIndex]=Generator->GetDensityAt(
+                                OriginVoxels.X+gx*Step,OriginVoxels.Y+gy*Step,
+                                OriginVoxels.Z+gz*Step,
+                                bCapturePreEditGrid?&PreEditDensity:nullptr);
+                            if(bCapturePreEditGrid)
+                                OutPreEditDensityGrid->Samples[LocalIndex]=PreEditDensity;
+                            ++LaneSamples;
+                        }
+                    }
+                    if(bAborted.load(std::memory_order_relaxed))break;
+                }
+                if(bUseOperatorBlock)Generator->EndDensityBlock();
+            }
+            LaneSampleCounts[Lane]=LaneSamples;
+            GridFillExecution.EndWorkerContext(
+                GridFillExecution.WorkerContext,WorkerState,Worker);
+        };
+        struct FDispatchContext{decltype(RunLane)* Run=nullptr;};
+        FDispatchContext DispatchContext{&RunLane};
+        const auto DispatchLane=[](void* RawContext,std::size_t Lane,std::size_t Worker)
+        {
+            auto& Context=*static_cast<FDispatchContext*>(RawContext);
+            (*Context.Run)(Lane,Worker);
+        };
+        GridFillExecution.ParallelFor(GridFillExecution.SchedulerContext,
+            GridFillLaneCount,GridFillLaneCount,&DispatchContext,DispatchLane);
+        if(OutDensitySampleCount)
+            for(std::size_t Lane=0;Lane<GridFillLaneCount;++Lane)
+                *OutDensitySampleCount+=LaneSampleCounts[Lane];
+        if(bAborted.load(std::memory_order_relaxed))return FVoxelMeshData();
+    }
     else for (int32 gz = GzLo; gz <= GzHi; gz++)
     {
         if (ShouldAbortWork())
@@ -959,7 +1106,7 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
                 GridSampleCount * sizeof(float));
         }
     }
-    if (bUseOperatorBlock)
+    if (bUseOperatorBlock&&!bUseParallelDensityGrid)
     {
         Generator->EndDensityBlock();
     }

Source/VoxelForge/Private/VoxelRedefinedDensityField.cpp

@@ -2590,8 +2590,8 @@ static float EvaluateInternal(const UVoxelGenerator& Generator,
     {
         EnsurePlan(Generator);
     }
-    const bool bChunkResolved = Context != nullptr && Context->bChunkResolved
-        || ParameterizedContext != nullptr && ParameterizedContext->bChunkResolved;
+    const bool bChunkResolved = (Context != nullptr && Context->bChunkResolved)
+        || (ParameterizedContext != nullptr && ParameterizedContext->bChunkResolved);
     const FIntVector Chunk = Context != nullptr && Context->bChunkResolved
         ? Context->Chunk
         : ParameterizedContext != nullptr && ParameterizedContext->bChunkResolved

Source/VoxelForge/Private/VoxelSeasonManifest.cpp

@@ -1958,10 +1958,11 @@ namespace VoxelSeasonCompositionPrivate
     }
 
     void CopyDefinitionParams(const UVoxelStrateDefinition& Definition,
-                              FVoxelSeasonFixedStrate& OutFixed)
+                              double LayoutChunkMeters, FVoxelSeasonFixedStrate& OutFixed)
     {
         OutFixed = FVoxelSeasonFixedStrate();
-        OutFixed.HeightInChunks = Definition.StrateHeightInChunks;
+        OutFixed.HeightInChunks = FMath::Max(1, FMath::RoundToInt(
+            Definition.StrateHeightMeters / FMath::Max(0.001, LayoutChunkMeters)));
         OutFixed.Archetype = Definition.GeneratorType;
         OutFixed.SourceDefinitionPath = Definition.GetPathName();
         OutFixed.bUsesRecipe = false;
@@ -1999,7 +2000,9 @@ namespace VoxelSeasonCompositionPrivate
                 return false;
             }
             FVoxelSeasonFixedStrate Fixed;
-            CopyDefinitionParams(*Definition, Fixed);
+            const double LayoutChunkMeters = Settings.WorldSettings != nullptr
+                ? Settings.WorldSettings->StrateLayoutChunkSizeMeters : 8.0;
+            CopyDefinitionParams(*Definition, LayoutChunkMeters, Fixed);
             Fixed.Seed = SeasonSeed;
             if (Fixed.SourceDefinitionPath.IsEmpty())
             {
@@ -2974,7 +2977,9 @@ FVoxelSeasonManifest VF_ComposeSeason(int32 SeasonSeed, const UVoxelSettings* Wo
     if (WorldSettings != nullptr)
     {
         Settings.SelectedStrateCount = WorldSettings->TotalStrates;
-        Settings.InterStrateGapChunks = WorldSettings->InterStrateGapChunks;
+        Settings.InterStrateGapChunks = FMath::Max(0, FMath::RoundToInt(
+            WorldSettings->InterStrateGapMeters * 1000000.0
+                / FMath::Max(1.0, static_cast<double>(WorldSettings->StrateLayoutChunkSizeMeters) * 1000000.0)));
         Settings.OriginSpineRadius = WorldSettings->OriginSpineRadius;
         Settings.WorldRadiusVoxels = WorldSettings->WorldRadiusVoxels;
         Settings.SeasonNumber = WorldSettings->CurrentSeason;

Source/VoxelForge/Private/VoxelSettings.cpp

@@ -1,5 +1,7 @@
 #include "VoxelSettings.h"
 
+#include "VoxelForgeAssetVersion.h"
+#include "VoxelStrateDefinition.h"
 #include "VoxelSeasonAsset.h"
 
 #if WITH_EDITOR
@@ -9,6 +11,74 @@
 #include <VoxelForgeCore/VoxelForgeCore.h>
 #include <string>
 
+void UVoxelSettings::Serialize(FArchive& Ar)
+{
+    Ar.UsingCustomVersion(VoxelForgeAssetVersion::GUID);
+    Super::Serialize(Ar);
+    if (Ar.IsLoading() && Ar.CustomVer(VoxelForgeAssetVersion::GUID)
+        < VoxelForgeAssetVersion::MetreAuthoringV1)
+    {
+        const double LayoutChunkMeters = FMath::IsFinite(StrateLayoutChunkSizeMeters)
+            ? FMath::Max(0.001, static_cast<double>(StrateLayoutChunkSizeMeters)) : 8.0;
+        InterStrateGapMeters = static_cast<double>(FMath::Max(0, InterStrateGapChunks))
+            * LayoutChunkMeters;
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeAssetUpgrade] type=Settings asset=%s gap_chunks=%d gap_m=%.6f layout_chunk_m=%.6f"),
+            *GetPathName(), InterStrateGapChunks, InterStrateGapMeters, LayoutChunkMeters);
+    }
+}
+
+void UVoxelSettings::PostLoad()
+{
+    Super::PostLoad();
+    if (GetLinkerCustomVersion(VoxelForgeAssetVersion::GUID)
+        >= VoxelForgeAssetVersion::MetreAuthoringV1)
+    {
+        return;
+    }
+
+    // Resolve the legacy count against this settings asset's saved physical layout width.
+    // Convertit les anciens comptes avec la largeur physique sauvegardee dans ces reglages.
+    const double LayoutChunkMeters = FMath::IsFinite(StrateLayoutChunkSizeMeters)
+        ? FMath::Max(0.001, static_cast<double>(StrateLayoutChunkSizeMeters)) : 8.0;
+    InterStrateGapMeters = static_cast<double>(FMath::Max(0, InterStrateGapChunks))
+        * LayoutChunkMeters;
+
+    TSet<UVoxelStrateDefinition*> Migrated;
+    const auto MigrateStrate = [this, LayoutChunkMeters, &Migrated](
+        const TSoftObjectPtr<UVoxelStrateDefinition>& SoftDefinition)
+    {
+        UVoxelStrateDefinition* Definition = SoftDefinition.LoadSynchronous();
+        if (Definition == nullptr || Migrated.Contains(Definition)
+            || Definition->GetLinkerCustomVersion(VoxelForgeAssetVersion::GUID)
+                >= VoxelForgeAssetVersion::MetreAuthoringV1)
+        {
+            return;
+        }
+        Migrated.Add(Definition);
+        const int32 OldHeightChunks = Definition->StrateHeightInChunks;
+        const int32 OldTransitionChunks = Definition->TransitionBlendChunks;
+        Definition->StrateHeightMeters = static_cast<double>(FMath::Max(1, OldHeightChunks))
+            * LayoutChunkMeters;
+        Definition->TransitionWidthMeters = static_cast<double>(FMath::Max(0, OldTransitionChunks))
+            * LayoutChunkMeters;
+        Definition->MarkPackageDirty();
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeAssetUpgrade] type=Strate asset=%s height_chunks=%d height_m=%.6f transition_chunks=%d transition_m=%.6f effective_layout_chunk_m=%.6f"),
+            *Definition->GetPathName(), OldHeightChunks, Definition->StrateHeightMeters,
+            OldTransitionChunks, Definition->TransitionWidthMeters, LayoutChunkMeters);
+    };
+    for (const TSoftObjectPtr<UVoxelStrateDefinition>& Definition : StratePool)
+    {
+        MigrateStrate(Definition);
+    }
+    for (const TPair<int32, TSoftObjectPtr<UVoxelStrateDefinition>>& Definition : FixedStrates)
+    {
+        MigrateStrate(Definition.Value);
+    }
+    MarkPackageDirty();
+}
+
 int32 UVoxelSettings::GetEffectiveWorldSeed() const
 {
     if (!Season.IsNull())

Source/VoxelForge/Private/VoxelStartupTrace.cpp

@@ -1,9 +1,12 @@
 #include "VoxelStartupTrace.h"
 
 #include "HAL/FileManager.h"
+#include "HAL/PlatformTLS.h"
 #include "HAL/PlatformTime.h"
+#include "CoreGlobals.h"
 #include "Misc/CommandLine.h"
 #include "Misc/Parse.h"
+#include "UObject/UObjectGlobals.h"
 
 #include <atomic>
 
@@ -15,7 +18,13 @@ namespace
     {
         FArchive* Archive = nullptr;
         FString Path;
+        uint32 GameThreadId = 0;
         double StartSeconds = 0.0;
+        double GameThreadJsonWriteSeconds = 0.0;
+        double GameThreadArchiveSerializeSeconds = 0.0;
+        double GarbageCollectionStartSeconds = 0.0;
+        FDelegateHandle PreGarbageCollectHandle;
+        FDelegateHandle PostGarbageCollectHandle;
         int32 TileRecordCap = 4096;
         int32 TileRecordsSeen = 0;
         int32 TileRecordsWritten = 0;
@@ -50,15 +59,22 @@ namespace
     void WriteLineLocked(FState& State, const FString& Line)
     {
         if (State.Archive == nullptr) return;
+        const uint64 StartCycles = FPlatformTime::Cycles64();
         const FString WithNewline = Line + TEXT("\n");
         FTCHARToUTF8 Utf8(*WithNewline);
         State.Archive->Serialize(const_cast<ANSICHAR*>(Utf8.Get()), Utf8.Length());
+        if (FPlatformTLS::GetCurrentThreadId() == State.GameThreadId)
+        {
+            State.GameThreadArchiveSerializeSeconds += FPlatformTime::ToSeconds64(
+                FPlatformTime::Cycles64() - StartCycles);
+        }
         // 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)
     {
+        const uint64 StartCycles = FPlatformTime::Cycles64();
         FString Line = FString::Printf(
             TEXT("{\"type\":\"%s\",\"t_s\":%s"),
             Type,
@@ -70,6 +86,11 @@ namespace
         }
         Line += TEXT("}");
         WriteLineLocked(State, Line);
+        if (FPlatformTLS::GetCurrentThreadId() == State.GameThreadId)
+        {
+            State.GameThreadJsonWriteSeconds += FPlatformTime::ToSeconds64(
+                FPlatformTime::Cycles64() - StartCycles);
+        }
     }
 
     double Percentile(TArray<double> Values, double Fraction)
@@ -198,6 +219,7 @@ void BeginFromCommandLine()
 
     TUniquePtr<FState> NewState = MakeUnique<FState>();
     NewState->Path = Path;
+    NewState->GameThreadId = FPlatformTLS::GetCurrentThreadId();
     FParse::Value(FCommandLine::Get(), TEXT("voxel.StartupTraceMaxTiles="), NewState->TileRecordCap);
     NewState->TileRecordCap = FMath::Clamp(NewState->TileRecordCap, 64, 16384);
     NewState->Samples.Reserve(NewState->TileRecordCap);
@@ -211,6 +233,32 @@ void BeginFromCommandLine()
     NewState->bActive = true;
     GState = MoveTemp(NewState);
     GTraceActive.store(true, std::memory_order_release);
+    GState->PreGarbageCollectHandle = FCoreUObjectDelegates::GetPreGarbageCollectDelegate()
+        .AddLambda([]()
+        {
+            FScopeLock CallbackLock(&GTraceLock);
+            if (GState.IsValid() && GState->bActive)
+            {
+                GState->GarbageCollectionStartSeconds = FPlatformTime::Seconds();
+            }
+        });
+    GState->PostGarbageCollectHandle = FCoreUObjectDelegates::GetPostGarbageCollect()
+        .AddLambda([]()
+        {
+            FScopeLock CallbackLock(&GTraceLock);
+            if (!GState.IsValid() || !GState->bActive
+                || GState->GarbageCollectionStartSeconds <= 0.0)
+            {
+                return;
+            }
+            const double DurationMilliseconds = FMath::Max(
+                0.0, FPlatformTime::Seconds() - GState->GarbageCollectionStartSeconds) * 1000.0;
+            GState->GarbageCollectionStartSeconds = 0.0;
+            WriteEventLocked(*GState, TEXT("garbage_collect"), FString::Printf(
+                TEXT("\"frame\":%llu,\"duration_ms\":%s"),
+                static_cast<unsigned long long>(GFrameCounter),
+                *Number(DurationMilliseconds)));
+        });
     WriteEventLocked(*GState, TEXT("header"), FString::Printf(
         TEXT("\"schema\":1,\"path\":\"%s\",\"tile_record_cap\":%d"),
         *JsonEscape(GState->Path), GState->TileRecordCap));
@@ -221,6 +269,21 @@ bool IsActive()
     return GTraceActive.load(std::memory_order_acquire);
 }
 
+FWriteMetrics ConsumeCurrentThreadWriteMetrics()
+{
+    FWriteMetrics Metrics;
+    FScopeLock Lock(&GTraceLock);
+    if (!GState.IsValid() || FPlatformTLS::GetCurrentThreadId() != GState->GameThreadId)
+    {
+        return Metrics;
+    }
+    Metrics.JsonWriteMilliseconds = GState->GameThreadJsonWriteSeconds * 1000.0;
+    Metrics.ArchiveSerializeMilliseconds = GState->GameThreadArchiveSerializeSeconds * 1000.0;
+    GState->GameThreadJsonWriteSeconds = 0.0;
+    GState->GameThreadArchiveSerializeSeconds = 0.0;
+    return Metrics;
+}
+
 void RecordEvent(const TCHAR* Type, const FString& FieldsJson)
 {
     FScopeLock Lock(&GTraceLock);
@@ -228,15 +291,16 @@ void RecordEvent(const TCHAR* Type, const FString& FieldsJson)
     WriteEventLocked(*GState, Type, FieldsJson);
 }
 
-void RecordRequest(const FTileSample& Sample, uint32 Epoch)
+void RecordRequest(const FTileSample& Sample, uint32 Epoch, uint32 DesiredEpoch)
 {
     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"),
+             "\"request_ordinal\":%llu,\"epoch\":%u,\"desired_epoch\":%u,"
+             "\"resident_at_request\":%d"),
         Sample.TileX, Sample.TileY, Sample.TileZ, Sample.Level, Sample.WorkPriority,
-        static_cast<unsigned long long>(Sample.RequestOrdinal), Epoch,
+        static_cast<unsigned long long>(Sample.RequestOrdinal), Epoch, DesiredEpoch,
         Sample.bResidentAtRequest ? 1 : 0));
 }
 
@@ -297,7 +361,11 @@ void RecordTile(const FTileSample& Sample)
              "\"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"),
+             "\"generation_s\":%s,"
+#if PLATFORM_LINUX
+             "\"core_generate_s\":%s,\"mesh_copy_s\":%s,\"rmc_stream_build_s\":%s,"
+#endif
+             "\"classify_s\":%s,\"mesh_s\":%s,\"stream_s\":%s,\"apply_s\":%s"),
         Sample.TileX, Sample.TileY, Sample.TileZ,
         Sample.Level, Sample.WorkPriority,
         static_cast<unsigned long long>(Sample.RequestOrdinal),
@@ -312,8 +380,12 @@ void RecordTile(const FTileSample& Sample)
         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.WorkerTaskSeconds), *Number(Sample.GenerationSeconds),
+#if PLATFORM_LINUX
+        *Number(Sample.CoreGenerateSeconds), *Number(Sample.MeshCopySeconds),
+        *Number(Sample.StreamBuildSeconds),
+#endif
+        *Number(Sample.ClassifySeconds),
         *Number(Sample.MeshSeconds), *Number(Sample.StreamSeconds), *Number(Sample.ApplySeconds)));
 }
 
@@ -351,6 +423,7 @@ void RecordApplyFrame(const FApplyFrameSample& Sample)
              "\"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,"
+             "\"supplemental_far_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"),
@@ -360,7 +433,8 @@ void RecordApplyFrame(const FApplyFrameSample& Sample)
         Sample.RunningWorkerTasks, Sample.TaskCap, Sample.PendingTiles,
         Sample.PendingResultsEstimate, Sample.ResultsDrained, Sample.ApplyResultsByLevelTotal,
         Sample.MeshesApplied,
-        Sample.MaxApplies, *Number(Sample.ApplyBudgetMilliseconds),
+        Sample.MaxApplies, Sample.SupplementalFarApplies,
+        *Number(Sample.ApplyBudgetMilliseconds),
         Sample.bCountLimitReached ? 1 : 0, Sample.bTimeLimitReached ? 1 : 0,
         *PendingByLevel, *ApplyResultsByLevel, *MeshesByLevel, *ApplyMillisecondsByLevel));
 }
@@ -370,6 +444,18 @@ void Finish(const TCHAR* Reason)
     FScopeLock Lock(&GTraceLock);
     if (!GState.IsValid() || !GState->bActive) return;
     GTraceActive.store(false, std::memory_order_release);
+    if (GState->PreGarbageCollectHandle.IsValid())
+    {
+        FCoreUObjectDelegates::GetPreGarbageCollectDelegate().Remove(
+            GState->PreGarbageCollectHandle);
+        GState->PreGarbageCollectHandle.Reset();
+    }
+    if (GState->PostGarbageCollectHandle.IsValid())
+    {
+        FCoreUObjectDelegates::GetPostGarbageCollect().Remove(
+            GState->PostGarbageCollectHandle);
+        GState->PostGarbageCollectHandle.Reset();
+    }
 
     // Close any stage left open by an abnormal early exit so the summary remains useful.
     const double Now = FPlatformTime::Seconds();
@@ -379,7 +465,19 @@ void Finish(const TCHAR* Reason)
     }
     GState->StageStarts.Reset();
     WriteEventLocked(*GState, TEXT("summary"), BuildSummaryFieldsLocked(*GState, Reason));
+    const uint64 FlushStartCycles = FPlatformTime::Cycles64();
     GState->Archive->Flush();
+    const double FlushMilliseconds = FPlatformTime::ToSeconds64(
+        FPlatformTime::Cycles64() - FlushStartCycles) * 1000.0;
+    WriteEventLocked(*GState, TEXT("trace_finish_flush"), FString::Printf(
+        TEXT("\"first_flush_ms\":%s"), *Number(FlushMilliseconds)));
+    const uint64 FinalFlushStartCycles = FPlatformTime::Cycles64();
+    GState->Archive->Flush();
+    const double FinalFlushMilliseconds = FPlatformTime::ToSeconds64(
+        FPlatformTime::Cycles64() - FinalFlushStartCycles) * 1000.0;
+    UE_LOG(LogTemp, Display,
+        TEXT("[VoxelForgeStartupTrace] finish_flush_ms=%.3f final_flush_ms=%.3f"),
+        FlushMilliseconds, FinalFlushMilliseconds);
     delete GState->Archive;
     GState->Archive = nullptr;
     GState->bActive = false;

Source/VoxelForge/Private/VoxelStrateDefinition.cpp

@@ -1,20 +1,17 @@
 // Serialized strate-definition migrations.
 
 #include "VoxelStrateDefinition.h"
+#include "VoxelForgeAssetVersion.h"
 
 #include "Serialization/CustomVersion.h"
 #include "VoxelPassageGeometry.h"
 
 namespace
 {
-    // The field name is retained for package compatibility, but version 1 changes its meaning
-    // from a raw tangent/gradient to authored degrees. This GUID is local to the plugin.
-    const FGuid GVoxelForgeStrateSerializationVersion(
-        0xA76D5E31, 0x4B2C4F9A, 0xB8C1D204, 0x6E9F7738);
-    constexpr int32 GVoxelForgeStrateGentleSlopeDegreesVersion = 1;
+    constexpr int32 GVoxelForgeStrateGentleSlopeDegreesVersion = VoxelForgeAssetVersion::TunnelFloorSlopeDegrees;
     FCustomVersionRegistration GVoxelForgeStrateSerializationRegistration(
-        GVoxelForgeStrateSerializationVersion,
-        GVoxelForgeStrateGentleSlopeDegreesVersion,
+        VoxelForgeAssetVersion::GUID,
+        VoxelForgeAssetVersion::MetreAuthoringV1,
         TEXT("VoxelForgeStrateSerialization"));
 
     float LegacyGradientToDegrees(float LegacyGradient)
@@ -58,6 +55,31 @@ namespace
     }
 }
 
+void UVoxelStrateDefinition::Serialize(FArchive& Ar)
+{
+    Ar.UsingCustomVersion(VoxelForgeAssetVersion::GUID);
+    Super::Serialize(Ar);
+
+    if (Ar.IsLoading() && Ar.CustomVer(VoxelForgeAssetVersion::GUID)
+        < VoxelForgeAssetVersion::MetreAuthoringV1)
+    {
+        // A stand-alone strate has no owning settings object during Serialize. Convert using the
+        // current 8 m layout default here; UVoxelSettings corrects referenced old strates using
+        // their saved effective width during its own load upgrade.
+        // Une strate seule n'a pas ses reglages proprietaires ici; UVoxelSettings corrige ensuite
+        // les references avec leur largeur physique sauvegardee.
+        constexpr double LegacyDefaultLayoutChunkMeters = 8.0;
+        StrateHeightMeters = static_cast<double>(FMath::Max(1, StrateHeightInChunks))
+            * LegacyDefaultLayoutChunkMeters;
+        TransitionWidthMeters = static_cast<double>(FMath::Max(0, TransitionBlendChunks))
+            * LegacyDefaultLayoutChunkMeters;
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeAssetUpgrade] type=Strate asset=%s height_chunks=%d height_m=%.6f transition_chunks=%d transition_m=%.6f fallback_layout_chunk_m=%.6f"),
+            *GetPathName(), StrateHeightInChunks, StrateHeightMeters,
+            TransitionBlendChunks, TransitionWidthMeters, LegacyDefaultLayoutChunkMeters);
+    }
+}
+
 void UVoxelStrateDefinition::PostLoad()
 {
     Super::PostLoad();
@@ -67,7 +89,7 @@ void UVoxelStrateDefinition::PostLoad()
     // is normalized to the ignored compatibility default before any runtime copy is made.
     GenerationParams.bTunnelFloorEnabled = true;
 
-    if (GetLinkerCustomVersion(GVoxelForgeStrateSerializationVersion)
+    if (GetLinkerCustomVersion(VoxelForgeAssetVersion::GUID)
         >= GVoxelForgeStrateGentleSlopeDegreesVersion)
     {
         return;

Source/VoxelForge/Private/VoxelStrateManager.cpp

@@ -13,6 +13,7 @@
 #include "VoxelTerrainOpDefinition.h"  // For UVoxelTerrainOpDefinition::ApplyTo
 #include "VoxelBiomeDefinition.h"  // For UVoxelBiomeDefinition (biome context flatten)
 #include "HAL/IConsoleManager.h"
+#include <cmath>  // std::llround
 #include "Misc/CommandLine.h"
 #include "Misc/Crc.h"
 #include "Misc/Parse.h"
@@ -24,6 +25,27 @@ namespace
 {
     std::atomic<uint64> GNextStrateManagerLifetimeId { 0 };
 
+    int64 VF_OwnerVoxelsToMicrometres(double OwnerVoxels)
+    {
+        return static_cast<int64>(std::llround(
+            OwnerVoxels * static_cast<double>(VOXEL_SIZE) * 10000.0));
+    }
+
+    float VF_ResolvedWorldMicrometresToOwnerVoxels(int64 WorldMicrometres)
+    {
+        return static_cast<float>(static_cast<double>(WorldMicrometres)
+            / (static_cast<double>(VOXEL_SIZE) * 10000.0));
+    }
+
+    int64 VF_FloorDivide64(int64 Numerator, int64 Denominator)
+    {
+        if (Denominator <= 0) return 0;
+        int64 Quotient = Numerator / Denominator;
+        const int64 Remainder = Numerator % Denominator;
+        if (Remainder < 0) --Quotient;
+        return Quotient;
+    }
+
     // Exact A/B switch for the repeated passage-floor projection item.  The other field-
     // preserving rewrites in this round are deliberately unconditional; this switch isolates
     // the projection reuse without changing any density arithmetic.
@@ -1233,7 +1255,8 @@ bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
         ? SeasonManifest.Strates.Num() : Settings->TotalStrates;
     const int32 LayoutGapChunks = bUseSeason
         ? SeasonManifest.InterStrateGapChunks
-        : FMath::Max(0, Settings->InterStrateGapChunks);
+        : FMath::Max(0, FMath::RoundToInt(static_cast<double>(Settings->InterStrateGapMeters)
+            * 1000000.0 / std::max<uint32>(1, StrateLayoutChunkSizeMicrometres)));
 
     //=========================================================================
     // STEP 1: Build shuffled pool (seed-based randomization)
@@ -1300,8 +1323,11 @@ bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
         }
     }
 
-    // Current Z position (in chunks). Starts at 0 and goes downward (negative).
-    int32 CurrentTopZ = 0;
+    // Resolve the stack in physical integer micrometres first. The historical chunk indices are
+    // projected from these half-open bounds only after each slot is complete.
+    int64 CurrentTopWorldMicrometres = StrateLayoutChunkSizeMicrometres;
+    const int64 ResolvedGapMicrometres = static_cast<int64>(LayoutGapChunks)
+        * StrateLayoutChunkSizeMicrometres;
 
     for (int32 i = 0; i < TotalStrates; i++)
     {
@@ -1344,7 +1370,8 @@ bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
             }
 
             Slot.Definition->GeneratorType = SeasonStrate.Archetype;
-            Slot.Definition->StrateHeightInChunks = SeasonStrate.HeightInChunks;
+            Slot.Definition->StrateHeightMeters = static_cast<double>(SeasonStrate.HeightInChunks)
+                * StrateLayoutChunkSizeMicrometres / 1000000.0;
             Slot.Definition->GenerationParams = SeasonStrate.Params.TunnelNetworkParams;
             Slot.Definition->SlabParams = SeasonStrate.Params.SlabParams;
             Slot.Definition->MazeParams = SeasonStrate.Params.MazeParams;
@@ -1356,16 +1383,28 @@ bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
             const int32 LayoutChunkVoxels=FMath::RoundToInt(StrateLayoutChunkWidthVoxels);
             Slot.TopChunkZ = SeasonStrate.TopWorldZ / LayoutChunkVoxels - 1;
             Slot.BottomChunkZ = SeasonStrate.BottomWorldZ / LayoutChunkVoxels;
+            Slot.TopWorldMicrometres = (static_cast<int64>(Slot.TopChunkZ) + 1)
+                * StrateLayoutChunkSizeMicrometres;
+            Slot.BottomWorldMicrometres = static_cast<int64>(Slot.BottomChunkZ)
+                * StrateLayoutChunkSizeMicrometres;
+            Slot.HeightMicrometres = Slot.TopWorldMicrometres - Slot.BottomWorldMicrometres;
+            const int64 ExpectedTopChunk = VF_FloorDivide64(
+                CurrentTopWorldMicrometres, StrateLayoutChunkSizeMicrometres) - 1;
+            const int64 ExpectedBottomChunk = ExpectedTopChunk - (Slot.HeightInChunks - 1);
             if (SeasonStrate.TopWorldZ % LayoutChunkVoxels != 0
                 || SeasonStrate.BottomWorldZ % LayoutChunkVoxels != 0
-                || Slot.TopChunkZ != CurrentTopZ
-                || Slot.BottomChunkZ != CurrentTopZ - (Slot.HeightInChunks - 1))
+                || Slot.TopChunkZ != ExpectedTopChunk
+                || Slot.BottomChunkZ != ExpectedBottomChunk
+                || Slot.TopWorldMicrometres != CurrentTopWorldMicrometres
+                || Slot.HeightMicrometres != static_cast<int64>(Slot.HeightInChunks)
+                    * StrateLayoutChunkSizeMicrometres)
             {
                 UE_LOG(LogTemp, Error,
                     TEXT("[StrateManager] Season slot %d bounds do not describe the declared stacked layout."), i);
                 RestorePreviousLayout();
                 return false;
             }
+            CurrentTopWorldMicrometres = Slot.BottomWorldMicrometres - ResolvedGapMicrometres;
             SeasonStrates.Add(SeasonStrate);
         }
         else
@@ -1388,15 +1427,54 @@ bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
                 continue;
             }
 
-            // Compute Z range from definition's height
-            Slot.HeightInChunks = Slot.Definition->StrateHeightInChunks;
-            Slot.TopChunkZ = CurrentTopZ;
-            Slot.BottomChunkZ = CurrentTopZ - (Slot.HeightInChunks - 1);
+            // Resolve the authored chunk height into an exact physical interval.
+            Slot.HeightInChunks = FMath::Max(1, FMath::RoundToInt(
+                Slot.Definition->StrateHeightMeters * 1000000.0
+                    / std::max<uint32>(1, StrateLayoutChunkSizeMicrometres)));
+            Slot.TopWorldMicrometres = CurrentTopWorldMicrometres;
+            Slot.HeightMicrometres = static_cast<int64>(Slot.HeightInChunks)
+                * StrateLayoutChunkSizeMicrometres;
+            Slot.BottomWorldMicrometres = Slot.TopWorldMicrometres - Slot.HeightMicrometres;
+            Slot.TopChunkZ = static_cast<int32>(VF_FloorDivide64(
+                Slot.TopWorldMicrometres, StrateLayoutChunkSizeMicrometres) - 1);
+            Slot.BottomChunkZ = static_cast<int32>(VF_FloorDivide64(
+                Slot.BottomWorldMicrometres, StrateLayoutChunkSizeMicrometres));
+            CurrentTopWorldMicrometres = Slot.BottomWorldMicrometres - ResolvedGapMicrometres;
         }
 
-        // Move the cursor down for the next strate, leaving a solid-bedrock gap of
-        // InterStrateGapChunks chunks between this strate and the next.
-        CurrentTopZ = Slot.BottomChunkZ - 1 - LayoutGapChunks;
+        Slot.ResolvedTransitionType = Slot.Definition->TransitionType;
+        Slot.ResolvedTransitionBlendChunks = FMath::Max(0, FMath::RoundToInt(
+            Slot.Definition->TransitionWidthMeters * 1000000.0
+                / std::max<uint32>(1, StrateLayoutChunkSizeMicrometres)));
+        Slot.TransitionWidthMicrometres = static_cast<int64>(Slot.ResolvedTransitionBlendChunks)
+            * StrateLayoutChunkSizeMicrometres;
+        Slot.ResolvedPassageConfig = Slot.Definition->PassageConfig;
+        Slot.PassageMouthRadiusMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.MouthRadius);
+        Slot.PassageMidRadiusMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.MidRadius);
+        Slot.PassageReachMinimumMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.ReachMin);
+        Slot.PassageReachMaximumMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.ReachMax);
+        Slot.PassageDistanceMinimumMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.DistanceMin);
+        Slot.PassageDistanceMaximumMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.DistanceMax);
+        Slot.PassageWanderMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.Wander);
+        Slot.PassageVerticalWobbleMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.VerticalWobble);
+        Slot.PassageSpiralRadiusMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.SpiralRadius);
+        Slot.PassageCascadeLedgeMicrometres = VF_OwnerVoxelsToMicrometres(
+            Slot.ResolvedPassageConfig.CascadeLedge);
+        Slot.LegacyTopWorldZVoxels = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Slot.TopWorldMicrometres);
+        Slot.LegacyBottomWorldZVoxels = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Slot.BottomWorldMicrometres);
+        Slot.LegacyHeightVoxels = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Slot.HeightMicrometres);
 
         StrateLayout.Add(Slot);
 
@@ -1429,6 +1507,7 @@ bool UVoxelStrateManager::Initialize(UVoxelSettings* Settings, int32 WorldSeed)
     OriginSpineRadius = bUseSeason
         ? SeasonManifest.OriginSpineRadius : Settings->OriginSpineRadius;
     InterStrateGapChunks = LayoutGapChunks;
+    ResolvedInterStrateGapMicrometres = ResolvedGapMicrometres;
     if (bUseSeason)
     {
         ActiveSeasonContentHash = SeasonManifest.ContentHash;
@@ -1537,8 +1616,8 @@ bool UVoxelStrateManager::SetComposerOverrideForStrate(
     }
     VF_SetComposerRuntimeBounds(
         Override->Params,
-        (float)(TargetSlot->TopChunkZ + 1) * StrateLayoutChunkWidthVoxels,
-        (float)TargetSlot->BottomChunkZ * StrateLayoutChunkWidthVoxels);
+        TargetSlot->LegacyTopWorldZVoxels,
+        TargetSlot->LegacyBottomWorldZVoxels);
     Override->bUseRecipe = bUseRecipe;
     if (Recipe != nullptr)
     {
@@ -1557,8 +1636,8 @@ bool UVoxelStrateManager::SetComposerOverrideForStrate(
         Override->bUseRegions = true;
         Override->Regions = *InRegions;
         VF_RekeyStrateRegionManifest(Override->Regions, CandidateSeed, StrateIndex);
-        Override->Regions.StrateTopWorldZ = (float)(TargetSlot->TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-        Override->Regions.StrateBottomWorldZ = (float)TargetSlot->BottomChunkZ * StrateLayoutChunkWidthVoxels;
+        Override->Regions.StrateTopWorldZ = TargetSlot->LegacyTopWorldZVoxels;
+        Override->Regions.StrateBottomWorldZ = TargetSlot->LegacyBottomWorldZVoxels;
         VF_SetStrateArchetypeRuntimeBounds(Override->Params,
                                            Override->Regions.StrateTopWorldZ,
                                            Override->Regions.StrateBottomWorldZ);
@@ -1805,14 +1884,36 @@ void UVoxelStrateManager::GeneratePassages()
         // that opens the next room rather than a second vertical spine.
         const UVoxelStrateDefinition* UpperDef = Upper.Definition;
         if (!UpperDef) continue;
-        const FStratePassageConfig& Cfg = UpperDef->PassageConfig;
+        // GeneratePassages is the legacy owner-voxel route adapter. Its immutable source is the
+        // physical passage record resolved during Initialize, converted back to owner voxels here.
+        FStratePassageConfig Cfg = Upper.ResolvedPassageConfig;
+        Cfg.MouthRadius = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageMouthRadiusMicrometres);
+        Cfg.MidRadius = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageMidRadiusMicrometres);
+        Cfg.ReachMin = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageReachMinimumMicrometres);
+        Cfg.ReachMax = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageReachMaximumMicrometres);
+        Cfg.DistanceMin = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageDistanceMinimumMicrometres);
+        Cfg.DistanceMax = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageDistanceMaximumMicrometres);
+        Cfg.Wander = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageWanderMicrometres);
+        Cfg.VerticalWobble = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageVerticalWobbleMicrometres);
+        Cfg.SpiralRadius = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageSpiralRadiusMicrometres);
+        Cfg.CascadeLedge = VF_ResolvedWorldMicrometresToOwnerVoxels(
+            Upper.PassageCascadeLedgeMicrometres);
 
         // Upper strate floor and lower strate ceiling (differ when there's a bedrock gap).
-        const float UpperTopZ    = (float)(Upper.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-        const float UpperBottomZ = (float)(Upper.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
-        const float LowerTopZ    = (float)(Lower.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-        const float UpperMax = (float)Upper.HeightInChunks * StrateLayoutChunkWidthVoxels * 0.9f;
-        const float LowerMax = (float)Lower.HeightInChunks * StrateLayoutChunkWidthVoxels * 0.9f;
+        const float UpperTopZ = Upper.LegacyTopWorldZVoxels;
+        const float UpperBottomZ = Upper.LegacyBottomWorldZVoxels;
+        const float LowerTopZ = Lower.LegacyTopWorldZVoxels;
+        const float UpperMax = Upper.LegacyHeightVoxels * 0.9f;
+        const float LowerMax = Lower.LegacyHeightVoxels * 0.9f;
 
         const float DistLo = FMath::Min(Cfg.DistanceMin, Cfg.DistanceMax);
         const float DistHi = FMath::Max(Cfg.DistanceMin, Cfg.DistanceMax);
@@ -1942,7 +2043,7 @@ void UVoxelStrateManager::GeneratePassages()
                     LowerDef->FloatingIslandParams,
                     LowerQuerySeed,
                     LowerTopZ,
-                    (float)(Lower.BottomChunkZ) * StrateLayoutChunkWidthVoxels,
+                    Lower.LegacyBottomWorldZVoxels,
                     PX,
                     PY,
                     MaxLateralSnap,
@@ -2002,7 +2103,7 @@ void UVoxelStrateManager::GeneratePassages()
             if (bAimedLowerAtPlayerFitPoint)
             {
                 const float LowerSealThickness = BoundarySealThicknessFor(*LowerDef);
-                const float LowerBottomZ = (float)(Lower.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+                const float LowerBottomZ = Lower.LegacyBottomWorldZVoxels;
                 const float InnerBottomZ = LowerBottomZ + LowerSealThickness;
                 const float InnerTopZ = LowerTopZ - LowerSealThickness;
                 if (VoxelMath::IsFinite(SuggestedLowerPoint.X)
@@ -2170,7 +2271,7 @@ void UVoxelStrateManager::GeneratePassages()
                 Cfg.MouthRadius,
                 LowerDoorDirection,
                 LowerTopZ,
-                (float)(Lower.BottomChunkZ) * StrateLayoutChunkWidthVoxels,
+                Lower.LegacyBottomWorldZVoxels,
                 LowerDef ? BoundarySealThicknessFor(*LowerDef) : 0.0f,
                 bAimedLowerAtPlayerFitPoint);
             Passage.UpperPoint = Passage.UpperLanding.StandingPoint;
@@ -2595,8 +2696,8 @@ void UVoxelStrateManager::GeneratePassages()
     if (bOpenSurfaceEntry && OriginSpineRadius > 0.0f && StrateLayout.Num() > 0)
     {
         const FStrateSlot& Top = StrateLayout[0];
-        const float TopZ = (float)(Top.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-        const float BottomZ = (float)Top.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+        const float TopZ = Top.LegacyTopWorldZVoxels;
+        const float BottomZ = Top.LegacyBottomWorldZVoxels;
         const float TopSeal = Top.Definition
             ? BoundarySealThicknessFor(*Top.Definition) : 0.0f;
         const VoxelPassageGeometry::FOriginLandingGeometry OriginLanding =
@@ -5921,8 +6022,8 @@ bool UVoxelStrateManager::AnyLandingFloorAtLattice(
         for (const FStrateSlot& Slot : StrateLayout)
         {
             if (Slot.Definition == nullptr) continue;
-            const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * StrateLayoutChunkWidthVoxels;
-            const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+            const float TopZ = Slot.LegacyTopWorldZVoxels;
+            const float BottomZ = Slot.LegacyBottomWorldZVoxels;
             const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
             const VoxelPassageGeometry::FOriginLandingGeometry Geometry =
                 VoxelPassageGeometry::BuildOriginLandingGeometry(
@@ -5964,8 +6065,8 @@ bool UVoxelStrateManager::AnyOriginLandingNearBox(
     for (const FStrateSlot& Slot : StrateLayout)
     {
         if (Slot.Definition == nullptr) continue;
-        const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * StrateLayoutChunkWidthVoxels;
-        const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+        const float TopZ = Slot.LegacyTopWorldZVoxels;
+        const float BottomZ = Slot.LegacyBottomWorldZVoxels;
         if (VoxelPassageGeometry::OriginLandingRoomTouchesBox(
                 VoxelBox, TopZ, BottomZ,
                 VF_BoundarySealThicknessForDefinition(*Slot.Definition),
@@ -5985,8 +6086,8 @@ bool UVoxelStrateManager::AnyOriginLandingFloorNearBox(
     for (const FStrateSlot& Slot : StrateLayout)
     {
         if (Slot.Definition == nullptr) continue;
-        const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * StrateLayoutChunkWidthVoxels;
-        const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+        const float TopZ = Slot.LegacyTopWorldZVoxels;
+        const float BottomZ = Slot.LegacyBottomWorldZVoxels;
         if (VoxelPassageGeometry::OriginLandingFloorTouchesBox(
                 VoxelBox, TopZ, BottomZ,
                 VF_BoundarySealThicknessForDefinition(*Slot.Definition),
@@ -6010,8 +6111,8 @@ bool UVoxelStrateManager::AnyOriginLandingNearLattice(
     for (const FStrateSlot& Slot : StrateLayout)
     {
         if (Slot.Definition == nullptr) continue;
-        const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * StrateLayoutChunkWidthVoxels;
-        const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+        const float TopZ = Slot.LegacyTopWorldZVoxels;
+        const float BottomZ = Slot.LegacyBottomWorldZVoxels;
         const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
         if (VoxelPassageGeometry::OriginLandingRoomTouchesLattice(
                 VoxelBox, LatticeOrigin, Step, TopZ, BottomZ, Seal, OriginSpineRadius,
@@ -6048,8 +6149,8 @@ bool UVoxelStrateManager::AnyOriginLandingAirNearLattice(
         {
             continue;
         }
-        const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * StrateLayoutChunkWidthVoxels;
-        const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+        const float TopZ = Slot.LegacyTopWorldZVoxels;
+        const float BottomZ = Slot.LegacyBottomWorldZVoxels;
         const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
         const VoxelPassageGeometry::FOriginLandingGeometry Geometry =
             VoxelPassageGeometry::BuildOriginLandingGeometry(
@@ -6125,8 +6226,8 @@ bool UVoxelStrateManager::AnyOriginLandingFloorNearLattice(
     for (const FStrateSlot& Slot : StrateLayout)
     {
         if (Slot.Definition == nullptr) continue;
-        const float TopZ = (static_cast<float>(Slot.TopChunkZ) + 1.0f) * StrateLayoutChunkWidthVoxels;
-        const float BottomZ = static_cast<float>(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+        const float TopZ = Slot.LegacyTopWorldZVoxels;
+        const float BottomZ = Slot.LegacyBottomWorldZVoxels;
         const float Seal = VF_BoundarySealThicknessForDefinition(*Slot.Definition);
         if (VoxelPassageGeometry::OriginLandingFloorTouchesLattice(
                 VoxelBox, LatticeOrigin, Step, TopZ, BottomZ, Seal, OriginSpineRadius))
@@ -6143,15 +6244,36 @@ bool UVoxelStrateManager::AnyOriginLandingFloorNearLattice(
 
 int32 UVoxelStrateManager::FindSlotIndexForChunkZ(int32 ChunkZ) const
 {
-    // Linear search through strate layout.
-    // With ~10-20 strates this is fine. If we ever have hundreds,
-    // switch to binary search (layout is sorted by Z).
-    for (int32 i = 0; i < StrateLayout.Num(); i++)
+    // Legacy chunk callers use the projected interval cached during Initialize. The source bounds
+    // are the slot's physical micrometre interval; these indices do not define or stack strates.
+    for (int32 i = 0; i < StrateLayout.Num(); ++i)
     {
         const FStrateSlot& Slot = StrateLayout[i];
-        if (ChunkZ <= Slot.TopChunkZ && ChunkZ >= Slot.BottomChunkZ)
+        if (ChunkZ <= Slot.TopChunkZ && ChunkZ >= Slot.BottomChunkZ) return i;
+    }
+    return -1;
+}
+
+int32 UVoxelStrateManager::FindSlotIndexForWorldZCentimetres(double WorldZCentimetres) const
 {
-            return i;
+    const double WorldZMicrometres = WorldZCentimetres * 10000.0;
+    int32 Low = 0;
+    int32 High = StrateLayout.Num() - 1;
+    while (Low <= High)
+    {
+        const int32 Mid = Low + (High - Low) / 2;
+        const FStrateSlot& Slot = StrateLayout[Mid];
+        if (WorldZMicrometres >= static_cast<double>(Slot.TopWorldMicrometres))
+        {
+            High = Mid - 1;
+        }
+        else if (WorldZMicrometres < static_cast<double>(Slot.BottomWorldMicrometres))
+        {
+            Low = Mid + 1;
+        }
+        else
+        {
+            return Mid;
         }
     }
     return -1;
@@ -6159,9 +6281,8 @@ int32 UVoxelStrateManager::FindSlotIndexForChunkZ(int32 ChunkZ) const
 
 UVoxelStrateDefinition* UVoxelStrateManager::GetStrateAt(float WorldZ) const
 {
-    // Convert world Z to chunk Z coordinate
-    int32 ChunkZ = FMath::FloorToInt((WorldZ / VOXEL_SIZE) / StrateLayoutChunkWidthVoxels);
-    int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
+    if (!FMath::IsFinite(WorldZ)) return nullptr;
+    const int32 SlotIdx = FindSlotIndexForWorldZCentimetres(WorldZ);
     if (SlotIdx >= 0)
     {
         return StrateLayout[SlotIdx].Definition;
@@ -6171,8 +6292,8 @@ UVoxelStrateDefinition* UVoxelStrateManager::GetStrateAt(float WorldZ) const
 
 int32 UVoxelStrateManager::GetStrateIndex(float WorldZ) const
 {
-    int32 ChunkZ = FMath::FloorToInt((WorldZ / VOXEL_SIZE) / StrateLayoutChunkWidthVoxels);
-    int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
+    if (!FMath::IsFinite(WorldZ)) return -1;
+    const int32 SlotIdx = FindSlotIndexForWorldZCentimetres(WorldZ);
     if (SlotIdx >= 0)
     {
         return StrateLayout[SlotIdx].StrateIndex;
@@ -6285,9 +6406,13 @@ bool UVoxelStrateManager::IsGapChunk(const FIntVector& ChunkCoord) const
     if (StrateLayout.Num() == 0) return false;
 
     // Above the top strate or below the bottom strate = open air, NOT a gap.
-    const int32 StackTop    = StrateLayout[0].TopChunkZ;
-    const int32 StackBottom = StrateLayout.Last().BottomChunkZ;
-    if (ChunkCoord.Z > StackTop || ChunkCoord.Z < StackBottom) return false;
+    const int64 ChunkCenterMicrometres = static_cast<int64>(ChunkCoord.Z)
+        * StrateLayoutChunkSizeMicrometres + StrateLayoutChunkSizeMicrometres / 2;
+    if (ChunkCenterMicrometres >= StrateLayout[0].TopWorldMicrometres
+        || ChunkCenterMicrometres < StrateLayout.Last().BottomWorldMicrometres)
+    {
+        return false;
+    }
 
     // Inside the stack's Z span but not in any strate slot → it's a bedrock gap.
     return FindSlotIndexForChunkZ(ChunkCoord.Z) < 0;
@@ -6331,8 +6456,8 @@ FSlabGenerationParams UVoxelStrateManager::GetSlabParamsForChunk(const FIntVecto
     // Fill in the runtime Z bounds (voxel coordinates, same convention as
     // FStrateGenerationParams::StrateTopWorldZ / StrateBottomWorldZ).
     // TopChunkZ+1 because the top chunk's CEILING is at (TopChunkZ+1)*StrateLayoutChunkWidthVoxels.
-    Result.StrateTopWorldZ    = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    Result.StrateBottomWorldZ = (float)(Slot.BottomChunkZ)  * StrateLayoutChunkWidthVoxels;
+    Result.StrateTopWorldZ    = Slot.LegacyTopWorldZVoxels;
+    Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
 
     return Result;
 }
@@ -6365,8 +6490,8 @@ FMazeGenerationParams UVoxelStrateManager::GetMazeParamsForChunk(const FIntVecto
         }
     }
 #endif
-    Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+    Result.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+    Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
     return Result;
 }
 
@@ -6392,8 +6517,8 @@ FSurfaceGenerationParams UVoxelStrateManager::GetSurfaceParamsForChunk(const FIn
         }
     }
 #endif
-    Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+    Result.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+    Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
     return Result;
 }
 
@@ -6419,8 +6544,8 @@ FVerticalShaftParams UVoxelStrateManager::GetVerticalShaftParamsForChunk(const F
         }
     }
 #endif
-    Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+    Result.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+    Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
     return Result;
 }
 
@@ -6446,8 +6571,8 @@ FFloatingIslandParams UVoxelStrateManager::GetFloatingIslandParamsForChunk(const
         }
     }
 #endif
-    Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+    Result.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+    Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
     return Result;
 }
 
@@ -6481,14 +6606,14 @@ FBiomeContext UVoxelStrateManager::GetBiomeContextForChunk(const FIntVector& Chu
 
 bool UVoxelStrateManager::GetStrateUnrealZRange(float WorldZ, float& OutTopZ, float& OutBottomZ) const
 {
-    const int32 ChunkZ = FMath::FloorToInt((WorldZ / VOXEL_SIZE) / StrateLayoutChunkWidthVoxels);
-    const int32 SlotIdx = FindSlotIndexForChunkZ(ChunkZ);
+    if (!FMath::IsFinite(WorldZ)) return false;
+    const int32 SlotIdx = FindSlotIndexForWorldZCentimetres(WorldZ);
     if (SlotIdx < 0) return false;
 
     const FStrateSlot& Slot = StrateLayout[SlotIdx];
-    // Voxel-space Z bounds → Unreal units. Ceiling = top chunk's upper edge.
-    OutTopZ    = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels * VOXEL_SIZE;
-    OutBottomZ = (float)(Slot.BottomChunkZ)  * StrateLayoutChunkWidthVoxels * VOXEL_SIZE;
+    // Return the resolved physical bounds in Unreal centimeters.
+    OutTopZ    = static_cast<float>(static_cast<double>(Slot.TopWorldMicrometres) / 10000.0);
+    OutBottomZ = static_cast<float>(static_cast<double>(Slot.BottomWorldMicrometres) / 10000.0);
     return true;
 }
 
@@ -6501,8 +6626,8 @@ FStrateDisturbanceParams UVoxelStrateManager::GetDisturbanceParamsForChunk(const
     }
     const FStrateSlot& Slot = StrateLayout[SlotIdx];
     FStrateDisturbanceParams Result = Slot.Definition->Disturbances;
-    Result.StrateTopWorldZ    = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    Result.StrateBottomWorldZ = (float)(Slot.BottomChunkZ)  * StrateLayoutChunkWidthVoxels;
+    Result.StrateTopWorldZ    = Slot.LegacyTopWorldZVoxels;
+    Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
     return Result;
 }
 
@@ -6534,8 +6659,8 @@ float UVoxelStrateManager::GetWaterLevelWorldZForChunk(const FIntVector& ChunkCo
     }
     if (Rel <= 0.0f) return -FLT_MAX;
 
-    const float BottomZ = (float)(Slot.BottomChunkZ)  * StrateLayoutChunkWidthVoxels;
-    const float TopZ    = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
+    const float BottomZ = Slot.LegacyBottomWorldZVoxels;
+    const float TopZ    = Slot.LegacyTopWorldZVoxels;
     return FMath::Lerp(BottomZ, TopZ, FMath::Clamp(Rel, 0.0f, 1.0f));
 }
 
@@ -6579,8 +6704,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
         FindComposerOverride(Slot.StrateIndex))
     {
         FStrateGenerationParams Result = Override->Params.TunnelNetworkParams;
-        Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-        Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+        Result.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+        Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
         // A candidate is a hard replacement of this slot. Do not blend its rolled vector with an
         // authored neighbour at a boundary; this is also how the offline fixture measures it.
         return ResolveFinalParams(Result);
@@ -6590,8 +6715,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
     if (SeasonStrates.IsValidIndex(SlotIdx))
     {
         FStrateGenerationParams Result = SeasonStrates[SlotIdx].Params.TunnelNetworkParams;
-        Result.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-        Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * StrateLayoutChunkWidthVoxels;
+        Result.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+        Result.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
         // Season vectors are already final, measured slot records. Vertical structural posts own
         // their boundary; blending them with another selected recipe would describe neither one.
         return ResolveFinalParams(Result);
@@ -6608,8 +6733,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
     //
     // TopChunkZ=0, CHUNK_SIZE=32: top of the strate = chunk 0's top edge = voxel Z=32
     // BottomChunkZ=-3: bottom of the strate = chunk -3's bottom edge = voxel Z=-3*32 = -96
-    BaseParams.StrateTopWorldZ = (float)(Slot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-    BaseParams.StrateBottomWorldZ = (float)(Slot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+    BaseParams.StrateTopWorldZ = Slot.LegacyTopWorldZVoxels;
+    BaseParams.StrateBottomWorldZ = Slot.LegacyBottomWorldZVoxels;
 
     // Core currently dispatches one generator field per resolved strate. Gradient and
     // interleaved metadata therefore use the explicitly declared Hard fallback for every
@@ -6656,18 +6781,23 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
     //---------------------------------------------------------------------
     // CHECK BOTTOM BOUNDARY (transitioning to strate below)
     //---------------------------------------------------------------------
-    // DistFromBottom = how many chunks above the bottom edge of this strate.
+    // Legacy chunk callers project their sample to a layout interval; physical distance and
+    // transition width are both resolved in micrometres before projecting the blend fraction.
     // When 0, we're right at the boundary. When == TransitionBlendChunks, we're at
     // the outer edge of the transition zone.
-    int32 DistFromBottom = ChunkCoord.Z - Slot.BottomChunkZ;
+    const int64 DistFromBottomMicrometres = static_cast<int64>(ChunkCoord.Z)
+        * StrateLayoutChunkSizeMicrometres - Slot.BottomWorldMicrometres;
+    const int32 DistFromBottom = static_cast<int32>(VF_FloorDivide64(
+        DistFromBottomMicrometres, StrateLayoutChunkSizeMicrometres));
 
     if (SlotIdx + 1 < StrateLayout.Num())
     {
         // The upper strate (this one) controls the transition type at its lower edge
-        const EVoxelStrateTransition TransType = Slot.Definition->TransitionType;
+        const EVoxelStrateTransition TransType = Slot.ResolvedTransitionType;
 
         // Per-definition blend distance.
-        const int32 EffectiveBlend = Slot.Definition->TransitionBlendChunks;
+        const int32 EffectiveBlend = static_cast<int32>(VF_FloorDivide64(
+            Slot.TransitionWidthMicrometres, StrateLayoutChunkSizeMicrometres));
 
         // Prepare the neighbor's params (only used for Gradient and Interleaved)
         const FStrateSlot& BelowSlot = StrateLayout[SlotIdx + 1];
@@ -6691,8 +6821,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
             if (EffectiveBlend > 0 && DistFromBottom < EffectiveBlend)
             {
                 FStrateGenerationParams BelowParams = BuildParamsFromDefinition(BelowSlot.Definition);
-                BelowParams.StrateTopWorldZ = (float)(BelowSlot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-                BelowParams.StrateBottomWorldZ = (float)(BelowSlot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+                BelowParams.StrateTopWorldZ = BelowSlot.LegacyTopWorldZVoxels;
+                BelowParams.StrateBottomWorldZ = BelowSlot.LegacyBottomWorldZVoxels;
 
                 // Linear alpha: 0 at EffectiveBlend chunks away, 1 at the boundary
                 float Alpha = 1.0f - ((float)DistFromBottom / (float)EffectiveBlend);
@@ -6729,8 +6859,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
             if (DistFromBottom < CheckRange)
             {
                 FStrateGenerationParams BelowParams = BuildParamsFromDefinition(BelowSlot.Definition);
-                BelowParams.StrateTopWorldZ = (float)(BelowSlot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-                BelowParams.StrateBottomWorldZ = (float)(BelowSlot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+                BelowParams.StrateTopWorldZ = BelowSlot.LegacyTopWorldZVoxels;
+                BelowParams.StrateBottomWorldZ = BelowSlot.LegacyBottomWorldZVoxels;
 
                 // Sample 3D Perlin noise to warp the boundary position.
                 // XY frequency 0.15 gives medium-scale variation (~6-7 chunks per cycle).
@@ -6768,14 +6898,18 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
     //---------------------------------------------------------------------
     // Mirror logic: the ABOVE strate's TransitionType controls its lower edge,
     // which is this strate's upper edge. So we read from StrateLayout[SlotIdx-1].
-    int32 DistFromTop = Slot.TopChunkZ - ChunkCoord.Z;
+    const int64 DistFromTopMicrometres = Slot.TopWorldMicrometres
+        - (static_cast<int64>(ChunkCoord.Z) + 1) * StrateLayoutChunkSizeMicrometres;
+    const int32 DistFromTop = static_cast<int32>(VF_FloorDivide64(
+        DistFromTopMicrometres, StrateLayoutChunkSizeMicrometres));
 
     if (SlotIdx > 0)
     {
         // The strate ABOVE controls the transition at its lower edge (= our upper edge)
         const FStrateSlot& AboveSlot = StrateLayout[SlotIdx - 1];
-        const EVoxelStrateTransition TransType = AboveSlot.Definition->TransitionType;
-        const int32 EffectiveBlend = AboveSlot.Definition->TransitionBlendChunks;
+        const EVoxelStrateTransition TransType = AboveSlot.ResolvedTransitionType;
+        const int32 EffectiveBlend = static_cast<int32>(VF_FloorDivide64(
+            AboveSlot.TransitionWidthMicrometres, StrateLayoutChunkSizeMicrometres));
 
         switch (TransType)
         {
@@ -6790,8 +6924,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
             if (EffectiveBlend > 0 && DistFromTop < EffectiveBlend)
             {
                 FStrateGenerationParams AboveParams = BuildParamsFromDefinition(AboveSlot.Definition);
-                AboveParams.StrateTopWorldZ = (float)(AboveSlot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-                AboveParams.StrateBottomWorldZ = (float)(AboveSlot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+                AboveParams.StrateTopWorldZ = AboveSlot.LegacyTopWorldZVoxels;
+                AboveParams.StrateBottomWorldZ = AboveSlot.LegacyBottomWorldZVoxels;
 
                 float Alpha = 1.0f - ((float)DistFromTop / (float)EffectiveBlend);
                 Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
@@ -6812,8 +6946,8 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
             if (DistFromTop < CheckRange)
             {
                 FStrateGenerationParams AboveParams = BuildParamsFromDefinition(AboveSlot.Definition);
-                AboveParams.StrateTopWorldZ = (float)(AboveSlot.TopChunkZ + 1) * StrateLayoutChunkWidthVoxels;
-                AboveParams.StrateBottomWorldZ = (float)(AboveSlot.BottomChunkZ) * StrateLayoutChunkWidthVoxels;
+                AboveParams.StrateTopWorldZ = AboveSlot.LegacyTopWorldZVoxels;
+                AboveParams.StrateBottomWorldZ = AboveSlot.LegacyBottomWorldZVoxels;
 
                 // Same noise function but with a different seed offset to avoid
                 // symmetry between top and bottom boundaries of adjacent strates

Source/VoxelForge/Public/VoxelCaveMorphology.h

@@ -261,8 +261,12 @@ namespace VoxelHash
     FORCEINLINE uint32 Cell(int32 CellX, int32 CellY, uint32 Seed)
     {
         uint32 H = Seed;
-        H ^= Mix((uint32)(CellX + 0x7FFFFFFF));
-        H ^= Mix((uint32)(CellY + 0x7FFFFFFF) * 2654435761u);
+        // Bias in unsigned arithmetic. Adding the signed cell coordinate first overflows for
+        // positive cells and makes the world hash compiler-dependent.
+        const uint32 BiasedX = static_cast<uint32>(CellX) + 0x7FFFFFFFu;
+        const uint32 BiasedY = static_cast<uint32>(CellY) + 0x7FFFFFFFu;
+        H ^= Mix(BiasedX);
+        H ^= Mix(BiasedY * 2654435761u);
         return Mix(H);
     }
 
@@ -274,10 +278,14 @@ namespace VoxelHash
         int32 MinX = FMath::Min(AX, BX), MinY = FMath::Min(AY, BY);
         int32 MaxX = FMath::Max(AX, BX), MaxY = FMath::Max(AY, BY);
         uint32 H = Seed ^ 0xDEADBEEF;
-        H ^= Mix((uint32)(MinX + 0x7FFFFFFF));
-        H ^= Mix((uint32)(MinY + 0x7FFFFFFF) * 2654435761u);
-        H ^= Mix((uint32)(MaxX + 0x7FFFFFFF) * 374761393u);
-        H ^= Mix((uint32)(MaxY + 0x7FFFFFFF) * 668265263u);
+        const uint32 BiasedMinX = static_cast<uint32>(MinX) + 0x7FFFFFFFu;
+        const uint32 BiasedMinY = static_cast<uint32>(MinY) + 0x7FFFFFFFu;
+        const uint32 BiasedMaxX = static_cast<uint32>(MaxX) + 0x7FFFFFFFu;
+        const uint32 BiasedMaxY = static_cast<uint32>(MaxY) + 0x7FFFFFFFu;
+        H ^= Mix(BiasedMinX);
+        H ^= Mix(BiasedMinY * 2654435761u);
+        H ^= Mix(BiasedMaxX * 374761393u);
+        H ^= Mix(BiasedMaxY * 668265263u);
         return Mix(H);
     }
 
@@ -477,10 +485,13 @@ namespace VoxelNoise
 
                     // Hash the neighbor cell to get a feature point position [0,1)
                     // Using three different hash mixes for X, Y, Z offsets
+                    const uint32 BiasedX = static_cast<uint32>(NX) + 0x7FFFFFFFu;
+                    const uint32 BiasedY = static_cast<uint32>(NY) + 0x7FFFFFFFu;
+                    const uint32 BiasedZ = static_cast<uint32>(NZ) + 0x7FFFFFFFu;
                     uint32 H = VoxelHash::Mix(
-                        (uint32)(NX + 0x7FFFFFFF)
-                        ^ VoxelHash::Mix((uint32)(NY + 0x7FFFFFFF) * 2654435761u)
-                        ^ VoxelHash::Mix((uint32)(NZ + 0x7FFFFFFF) * 374761393u)
+                        BiasedX
+                        ^ VoxelHash::Mix(BiasedY * 2654435761u)
+                        ^ VoxelHash::Mix(BiasedZ * 374761393u)
                     );
 
                     float FPX = (float)DX + VoxelHash::ToFloat01(H) - FracX;

Source/VoxelForge/Public/VoxelContentManager.h

@@ -340,6 +340,14 @@ private:
         float   SuppressRadiusWorld = 0.0f;
     };
 
+    // Game-thread lookup copied from the immutable resolved Core layout.
+    // Recherche game-thread copiee depuis la disposition Core resolue et immuable.
+    struct FResolvedCoreGeometryAnchor
+    {
+        int32 StrateIndex = INDEX_NONE;
+        FVector LocalPositionCm = FVector::ZeroVector;
+    };
+
     /** WORKER-THREAD surface find → fills OutSpawns for one cell. SurfaceWorld uses the height oracle
      *  (cheap, O(1)/column); other archetypes ray-march the density column. No UObject access except
      *  Generator (thread-safe). Determinism-critical. Resolves the dominant biome PER COLUMN
@@ -436,6 +444,7 @@ private:
     // (kept until the cell leaves range so the surface-find isn't repeated). Strate-bounded.
     // Keyed by FIntVector(cellX|passageIdx, cellY|side, entryIndex) — lattice cell OR passage endpoint.
     TMap<FIntVector, FLandmarkInstance> LandmarkInstances;
+    TMap<FString, FResolvedCoreGeometryAnchor> CoreGeometryAnchors;
     int32 LastLandmarkStrate = INT32_MIN;   // strate change → wipe + rebuild landmarks
 
     // Set in BeginDestroy; worker tasks check it before touching us.

Source/VoxelForge/Public/VoxelMarchingCubesMesher.h

@@ -13,6 +13,7 @@
 
 #include "CoreMinimal.h"
 #include <atomic>
+#include <cstddef>
 #include "VoxelTypes.h"   // Pour FVoxelMeshData, CHUNK_SIZE, VOXEL_SIZE, etc.
 #include "VoxelGenerator.h"
 #include "VoxelMarchingCubesMesher.generated.h"
@@ -38,6 +39,24 @@ struct FVoxelSharedDensityGrid
     }
 };
 
+// Host-owned scheduling hooks for a predicted-heavy density-grid fill. Each task owns one
+// deterministic Z slab and gets the source tile's worker-local sampling context.
+struct FVoxelGridFillExecution
+{
+    using FTask = void(*)(void* taskContext, std::size_t index, std::size_t workerIndex);
+    using FParallelFor = double(*)(void* schedulerContext, std::size_t count,
+        std::size_t workerLimit, void* taskContext, FTask task);
+    using FBeginWorkerContext = void*(*)(void* context, std::size_t workerIndex);
+    using FEndWorkerContext = void(*)(void* context, void* workerState,
+        std::size_t workerIndex);
+    void* SchedulerContext = nullptr;
+    FParallelFor ParallelFor = nullptr;
+    std::size_t WorkerLimit = 1;
+    void* WorkerContext = nullptr;
+    FBeginWorkerContext BeginWorkerContext = nullptr;
+    FEndWorkerContext EndWorkerContext = nullptr;
+};
+
 // Stable plan data copied onto one worker-owned mesher for hybrid LOD0 generation.
 // Donnees stables du plan copiees dans un mailleur de worker pour le mode hybride LOD0.
 struct FVoxelHybridSharpFeatureBox
@@ -111,6 +130,8 @@ public:
     // GenerateMesh calls finish.  A malformed/incomplete lattice is ignored and falls back to
     // the canonical generator path rather than changing geometry.
     void SetSharedDensityGrid(const FVoxelSharedDensityGrid* InGrid) { SharedDensityGrid = InGrid; }
+    void SetGridFillExecution(const FVoxelGridFillExecution& InExecution)
+    { GridFillExecution = InExecution; }
 
     // The caller owns this mesher instance for one tile task; no shared mutable feature state.
     // L'appelant possede cette instance pour une tuile; aucune donnee partagee modifiable.
@@ -137,6 +158,7 @@ private:
 
     const std::atomic<bool>* ShutdownFlag = nullptr;
     const FVoxelSharedDensityGrid* SharedDensityGrid = nullptr;
+    FVoxelGridFillExecution GridFillExecution;
     TArray<FVoxelHybridSharpFeatureBox> HybridSharpFeatures;
     bool bUseHybridSharpMesher = false;
     bool bUseHybridSharpFeatureSnap = false;

Source/VoxelForge/Public/VoxelSettings.h

@@ -21,6 +21,8 @@ class UVoxelSettings : public UPrimaryDataAsset
 	GENERATED_BODY()
 
 public:
+	virtual void Serialize(FArchive& Ar) override;
+	virtual void PostLoad() override;
 
     /** Season seed/radius replace the mutable authored values only when Season is assigned. */
     int32 GetEffectiveWorldSeed() const;
@@ -411,14 +413,16 @@ public:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Strates", meta = (ClampMin = "1"))
 	int32 TotalStrates = 10;
 
-	// Vertical SEPARATION between consecutive strates, in chunks of solid bedrock.
-	// 0 = strates touch (just the seals between them). Higher = a thick rock layer
-	// between each biome that the player must dig through at (0,0), and that the
-	// auto-carved passages tunnel across.
-	//   0 → adjacent layers (default) · 1-2 → a real bedrock band · 4+ → deep separation
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Strates", meta = (ClampMin = "0", ClampMax = "16"))
+	// Legacy count retained so pre-metre assets still deserialize during the upgrade.
+	// Ancien compte conserve pour lire les assets precedant les metres.
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Strates", meta = (DeprecatedProperty, DeprecationMessage = "Use InterStrateGapMeters."))
 	int32 InterStrateGapChunks = 0;
 
+	// Physical separation between strata; the layout remains aligned to whole layout chunks.
+	// Separation physique; la disposition reste alignee sur des chunks entiers.
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Voxel|Strates", meta = (Units = "m", ClampMin = "0", ClampMax = "1024"))
+	double InterStrateGapMeters = 0.0;
+
 	// Physical width of one vertical strate-layout chunk. This is independent of the
 	// Core tile width (32^3 voxels) and of the source generator's voxel resolution.
 	// 8 m preserves the owner's current SurfaceWorld extent at 25 cm Core voxels.

Source/VoxelForge/Public/VoxelStartupTrace.h

@@ -35,6 +35,9 @@ namespace VoxelForgeStartupTrace
         double ResultQueueSeconds = 0.0;
         double WorkerTaskSeconds = 0.0;
         double GenerationSeconds = 0.0;
+        double CoreGenerateSeconds = 0.0;
+        double MeshCopySeconds = 0.0;
+        double StreamBuildSeconds = 0.0;
         double ClassifySeconds = 0.0;
         double MeshSeconds = 0.0;
         double StreamSeconds = 0.0;
@@ -56,6 +59,7 @@ namespace VoxelForgeStartupTrace
         int32 ResultsDrained = 0;
         int32 ApplyResultsByLevelTotal = 0;
         int32 MeshesApplied = 0;
+        int32 SupplementalFarApplies = 0;
         int32 MaxApplies = 0;
         double ApplyBudgetMilliseconds = 0.0;
         bool bCountLimitReached = false;
@@ -66,15 +70,25 @@ namespace VoxelForgeStartupTrace
         TStaticArray<double, 9> ApplySecondsByLevel{};
     };
 
+    struct VOXELFORGE_API FWriteMetrics
+    {
+        double JsonWriteMilliseconds = 0.0;
+        double ArchiveSerializeMilliseconds = 0.0;
+    };
+
     /** Starts when -voxel.StartupTraceFile=<absolute path> is present. */
     VOXELFORGE_API void BeginFromCommandLine();
 
     VOXELFORGE_API bool IsActive();
 
+    /** Returns and resets startup-trace writes performed by the current game-thread frame. */
+    VOXELFORGE_API FWriteMetrics ConsumeCurrentThreadWriteMetrics();
+
     /** 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 RecordRequest(const FTileSample& Sample, uint32 Epoch,
+                                      uint32 DesiredEpoch = 0);
 
     VOXELFORGE_API void StageBegin(const TCHAR* Name);
     VOXELFORGE_API void StageEnd(const TCHAR* Name);

Source/VoxelForge/Public/VoxelStrateDefinition.h

@@ -48,6 +48,7 @@ class VOXELFORGE_API UVoxelStrateDefinition : public UPrimaryDataAsset
     GENERATED_BODY()
 
 public:
+    virtual void Serialize(FArchive& Ar) override;
     virtual void PostLoad() override;
 
     //=========================================================================
@@ -66,14 +67,14 @@ public:
     // DIMENSIONS
     //=========================================================================
 
-    // How many chunks tall this strate is.
-    // Each strate can have a different height!
-    // Human-scale defaults use 16 chunks = 64 m. This gives a 20 m+ vertical budget for
-    // cathedral rooms, tall shafts, and the surface sky cap without changing the lateral gate.
-    // 1 chunk = 32 voxels x 12.5cm = 4 m; 16 chunks preserves the 64 m authored default.
-    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Dimensions", meta = (ClampMin = "1", ClampMax = "256"))
+    // Legacy serialized chunk count kept for Blueprint/package compatibility during the unit migration.
+    // Ancien nombre de chunks conserve pour la compatibilite Blueprint/package pendant la migration.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Dimensions", meta = (DeprecatedProperty, DeprecationMessage = "Use StrateHeightMeters."))
     int32 StrateHeightInChunks = 16;
 
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Dimensions", meta = (Units = "m", ClampMin = "1", ClampMax = "2048"))
+    double StrateHeightMeters = 128.0;
+
     //=========================================================================
     // BOUNDARY TRANSITION
     //=========================================================================
@@ -99,9 +100,13 @@ public:
     //   2 → moderate (good default)
     //   4 → wide, gentle blend across many chunks
     UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Boundary",
-        meta = (ClampMin = "1", ClampMax = "8", EditCondition = "TransitionType != EVoxelStrateTransition::Hard"))
+        meta = (DeprecatedProperty, DeprecationMessage = "Use TransitionWidthMeters."))
     int32 TransitionBlendChunks = 2;
 
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Boundary",
+        meta = (Units = "m", ClampMin = "0", ClampMax = "512", EditCondition = "TransitionType != EVoxelStrateTransition::Hard"))
+    double TransitionWidthMeters = 16.0;
+
     //=========================================================================
     // GENERATOR TYPE
     //=========================================================================
@@ -115,6 +120,11 @@ public:
     UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Generation")
     ECaveGeneratorType GeneratorType = ECaveGeneratorType::TunnelNetwork;
 
+    // Optional native Core authoring; leaving it empty keeps the established generator path.
+    // Edition Core native facultative; laissez vide pour garder le generateur existant.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Core Geometry")
+    FVoxelForgeCoreGeometry CoreGeometry;
+
     /**
      * Authoritative per-strate worm switch. Existing assets default to enabled. The manager
      * resolves a disabled strate to WormStrength == 0 before any fused, stack, composer, or

Source/VoxelForge/Public/VoxelStrateManager.h

@@ -121,8 +121,8 @@ struct FVoxelPassage
  * FStrateSlot — Runtime info for one strate in the layout.
  *
  * Created during Initialize() and stored in the StrateLayout array.
- * Each slot knows its definition, its Z-range in chunk coordinates,
- * and its index in the sequence.
+ * Each slot owns its resolved half-open physical Z interval. Chunk coordinates and legacy
+ * authoring values below are projections kept for existing callers and assets.
  */
 USTRUCT()
 struct FStrateSlot
@@ -136,6 +136,33 @@ struct FStrateSlot
     // Strate index (0 = topmost, increases downward)
     int32 StrateIndex = 0;
 
+    // Resolved physical bounds, in micrometres, with interval [bottom, top). These are computed
+    // once during Initialize from the configured metre chunk width and legacy asset dimensions.
+    int64 TopWorldMicrometres = 0;
+    int64 BottomWorldMicrometres = 0;
+    int64 HeightMicrometres = 0;
+    float LegacyTopWorldZVoxels = 0.0f;
+    float LegacyBottomWorldZVoxels = 0.0f;
+    float LegacyHeightVoxels = 0.0f;
+
+    // Immutable transition and passage inputs copied when this slot is resolved. The width is
+    // physical; chunk counts and raw owner-voxel values remain compatibility projections for
+    // legacy parameter and route adapters.
+    EVoxelStrateTransition ResolvedTransitionType = EVoxelStrateTransition::Gradient;
+    int32 ResolvedTransitionBlendChunks = 2;
+    int64 TransitionWidthMicrometres = 0;
+    FStratePassageConfig ResolvedPassageConfig;
+    int64 PassageMouthRadiusMicrometres = 0;
+    int64 PassageMidRadiusMicrometres = 0;
+    int64 PassageReachMinimumMicrometres = 0;
+    int64 PassageReachMaximumMicrometres = 0;
+    int64 PassageDistanceMinimumMicrometres = 0;
+    int64 PassageDistanceMaximumMicrometres = 0;
+    int64 PassageWanderMicrometres = 0;
+    int64 PassageVerticalWobbleMicrometres = 0;
+    int64 PassageSpiralRadiusMicrometres = 0;
+    int64 PassageCascadeLedgeMicrometres = 0;
+
     // Z chunk range (inclusive). TopZ > BottomZ since Z decreases downward.
     // Example: TopZ = 0, BottomZ = -3 means this strate spans chunks Z=0 to Z=-3
     int32 TopChunkZ = 0;
@@ -248,7 +275,11 @@ public:
     // This is independent of Core's 32^3 tile width.
     float GetStrateLayoutChunkWidthVoxels() const { return StrateLayoutChunkWidthVoxels; }
     uint32 GetStrateLayoutChunkSizeMicrometres() const { return StrateLayoutChunkSizeMicrometres; }
-    void SetHardTransitionFallbackForAssembly(bool bEnabled)
+    int64 GetResolvedInterStrateGapMicrometres() const
+    { return ResolvedInterStrateGapMicrometres; }
+    // Called by the Core adapter through a const manager pointer; the flag is runtime routing
+    // state, not layout data, hence const + mutable.
+    void SetHardTransitionFallbackForAssembly(bool bEnabled) const
     { bHardTransitionFallbackForAssembly = bEnabled; }
 
     /** Layout/passage generation counter (bumped by every Initialize → GeneratePassages).
@@ -528,14 +559,15 @@ protected:
     // Copied from VoxelSettings::OriginSpineRadius.
     float OriginSpineRadius = 28.0f;
 
-    // Solid-bedrock gap between consecutive strates, in chunks. Copied from
-    // VoxelSettings::InterStrateGapChunks during Initialize().
+    // Compatibility gap projection, in layout chunks. Physical authority is the micrometre value
+    // resolved during Initialize below.
     int32 InterStrateGapChunks = 0;
+    int64 ResolvedInterStrateGapMicrometres = 0;
 
     // Resolved once from VoxelSettings::StrateLayoutChunkSizeMeters during Initialize().
     float StrateLayoutChunkWidthVoxels = 32.0f;
     uint32 StrateLayoutChunkSizeMicrometres = 8000000;
-    bool bHardTransitionFallbackForAssembly = false;
+    mutable bool bHardTransitionFallbackForAssembly = false;
 
     // Production keeps the legacy writer available only as a fail-closed fallback for a
     // non-native/malformed passage; native D-floors bypass it. This switch never changes the
@@ -552,6 +584,7 @@ protected:
     // Find which slot a chunk Z coordinate falls into.
     // Returns INDEX into StrateLayout, or -1 if not found.
     int32 FindSlotIndexForChunkZ(int32 ChunkZ) const;
+    int32 FindSlotIndexForWorldZCentimetres(double WorldZCentimetres) const;
 
 #if WITH_EDITOR
     const FVoxelStrateComposerSlotOverride* FindComposerOverride(int32 StrateIndex) const;

Source/VoxelForge/Public/VoxelStrateTypes.h

@@ -200,16 +200,222 @@ enum class ECaveGeneratorType : uint8
     Underwater      UMETA(DisplayName = "Underwater (flooded cavern system)"),
 };
 
+// Optional native-Core recipe selected independently for one strate.
+// Recette Core native facultative, choisie independamment pour chaque strate.
+UENUM(BlueprintType)
+enum class EVoxelForgeCoreGeneratorRecipe : uint8
+{
+    None UMETA(DisplayName = "Off (legacy recipe)"),
+    NativeCaves UMETA(DisplayName = "Native caves"),
+    NativeLattice UMETA(DisplayName = "Native lattice"),
+    ProfiledHeightfield UMETA(DisplayName = "Profiled heightfield")
+};
+
+UENUM(BlueprintType)
+enum class EVoxelForgeCoreHeightfieldProfile : uint8
+{
+    PeriodicHills,
+    MirroredRelief,
+    FlatField
+};
+
+UENUM(BlueprintType)
+enum class EVoxelForgeCoreStampKind : uint8
+{
+    CarveEllipsoid,
+    CarveArch,
+    FillPillar,
+    FillDais,
+    FillMonolith,
+    FillPlatform
+};
+
+// Stable authored volume stamp. All distances and positions are metres at the asset boundary.
+// Volume stable, defini par son auteur. Toutes les positions et distances sont en metres.
+USTRUCT(BlueprintType)
+struct VOXELFORGE_API FVoxelForgeCoreStampDefinition
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    FString StableName;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    EVoxelForgeCoreStampKind Kind = EVoxelForgeCoreStampKind::CarveEllipsoid;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    FVector AnchorPositionMeters = FVector::ZeroVector;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double PlacementRadiusMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0.5"))
+    FVector HalfExtentsMeters = FVector(2.0, 2.0, 2.0);
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double SmoothWidthMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double IrregularityAmplitudeMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double IrregularityWavelengthMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double RoundingRadiusMeters = 0.5;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double MinimumSpacingMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (ClampMin = "0", ClampMax = "3"))
+    uint8 YawQuarterTurns = 0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    bool bAttachToFloor = false;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    double FloorMeters = 0.0;
+};
+
+// Authored cavern chamber, in local world metres.
+// Salle cavernicole authored, en metres locaux du monde.
+USTRUCT(BlueprintType)
+struct VOXELFORGE_API FVoxelForgeCoreRoomDefinition
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    FString StableName;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    FVector CenterMeters = FVector::ZeroVector;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0.5"))
+    FVector HalfExtentsMeters = FVector(8.0, 8.0, 4.0);
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    double FloorMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double SmoothWidthMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double UnionWidthMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double IrregularityAmplitudeMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double IrregularityWavelengthMeters = 0.0;
+};
+
+// Authored cubic tunnel between a stable start anchor and a stable room name.
+// Tunnel cubique authored entre une ancre stable et une salle nommee.
+USTRUCT(BlueprintType)
+struct VOXELFORGE_API FVoxelForgeCoreTunnelDefinition
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    FString StableName;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    FString StartAnchorStableName;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    FString EndRoomStableName;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    FVector ControlPoint0Meters = FVector::ZeroVector;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    FVector ControlPoint1Meters = FVector::ZeroVector;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    FVector ControlPoint2Meters = FVector::ZeroVector;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m"))
+    FVector ControlPoint3Meters = FVector::ZeroVector;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0.5"))
+    double BoreRadiusMeters = 2.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "1"))
+    double BoreHeightMeters = 4.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double FloorSupportDepthMeters = 0.5;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double SmoothWidthMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double UnionWidthMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double IrregularityAmplitudeMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry", meta = (Units = "m", ClampMin = "0"))
+    double IrregularityWavelengthMeters = 0.0;
+
+    // Lattice tunnels require an explicit bounded polyline; cave tunnels use the cubic curve.
+    // Les tunnels en treillis exigent une polyligne bornee; les tunnels caves utilisent la courbe cubique.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    TArray<FVector> PolylineMeters;
+};
+
+// Optional Core authored recipe. Empty arrays and None preserve the prior asset output.
+// Recette Core authored facultative. None et les tableaux vides conservent la sortie historique.
+USTRUCT(BlueprintType)
+struct VOXELFORGE_API FVoxelForgeCoreGeometry
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    EVoxelForgeCoreGeneratorRecipe GeneratorRecipe = EVoxelForgeCoreGeneratorRecipe::None;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    EVoxelForgeCoreHeightfieldProfile HeightfieldProfile = EVoxelForgeCoreHeightfieldProfile::PeriodicHills;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry|Heightfield", meta = (Units = "m"))
+    double HeightfieldBaseMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry|Heightfield", meta = (Units = "m"))
+    FVector2D HeightfieldAmplitudeMeters = FVector2D(20.0, 20.0);
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry|Heightfield", meta = (Units = "m", ClampMin = "0"))
+    FVector2D HeightfieldWavelengthMeters = FVector2D(256.0, 256.0);
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry|Heightfield", meta = (ClampMin = "0.01", ClampMax = "4.0"))
+    double MirrorLambda = 1.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry|Heightfield", meta = (Units = "m", ClampMin = "0"))
+    double MinimumArenaClearanceMeters = 0.0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    TArray<FVoxelForgeCoreStampDefinition> Stamps;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    TArray<FVoxelForgeCoreRoomDefinition> Rooms;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Core Geometry")
+    TArray<FVoxelForgeCoreTunnelDefinition> Tunnels;
+};
+
 /**
- * EVoxelStrateTransition — How two adjacent strates blend at their shared boundary.
+ * EVoxelStrateTransition — How two adjacent strates meet at their shared boundary.
  *
  * Each strate boundary can use a different transition style. The transition type
  * is defined on the UPPER strate's definition and controls the boundary between
  * itself and the strate below it.
  *
- * Gradient:    Smooth linear interpolation of generation params across TransitionBlendChunks.
- *              This is the classic approach — no seam visible, but also no dramatic
- *              geological feature at the boundary. Best for similar-looking strates.
+ * In the Core composition path, TransitionBlendChunks defines the full permitted
+ * crossing depth between the upper bedrock and lower ceiling bands. Each band keeps
+ * its authored thickness and the solid bands always overlap or touch. The legacy manager
+ * may also blend generation parameters for Gradient; Core does not blend unrelated fields.
+ *
+ * Gradient:    A low-amplitude smooth height field moves the shared interface and both
+ *              content-facing band surfaces. Best for gentle geological variation.
  *
  * Hard:        No blending at all. The strate's params apply right up to the boundary,
  *              then instantly switch to the neighbor's params. The abrupt change in
@@ -217,26 +423,21 @@ enum class ECaveGeneratorType : uint8
  *              discontinuity at the boundary. Best for strates that should feel like
  *              distinct geological layers with a visible dividing line.
  *
- * Interleaved: The boundary position is warped by a 3D noise field, so "fingers"
- *              of one strate reach into the other. Some XY columns transition early,
- *              others late, creating an irregular, interlocking boundary. The warp
- *              amplitude is ~2 chunks, and Z frequency is lower than XY to produce
- *              horizontal finger-like intrusions. Best for strates that should feel
- *              like they grew into each other over geological time.
+ * Interleaved: A deterministic 3D domain-warped hash field sets the overlap depth per XY
+ *              column from zero to the declared width, creating irregular fingers.
+ *              Best for strates that should feel grown together.
  */
 UENUM(BlueprintType)
 enum class EVoxelStrateTransition : uint8
 {
-    // Smooth linear interpolation of all generation params across the blend zone.
-    // No visible boundary — params change gradually over TransitionBlendChunks distance.
+    // Smoothly undulates the shared bedrock/ceiling interface in the Core composition path.
     Gradient    UMETA(DisplayName = "Gradient (smooth blend)"),
 
     // No blending — params switch instantly at the boundary.
     // Creates natural cliffs, ledges, or material discontinuities.
     Hard        UMETA(DisplayName = "Hard (sharp boundary with cliff)"),
 
-    // 3D noise warps the boundary position per XY column.
-    // Creates finger-like intrusions of one strate into the other.
+    // A 3D domain-warped hash field creates finger-like intrusions within the declared width.
     Interleaved UMETA(DisplayName = "Interleaved (domain-warped fingers)")
 };
 
@@ -2290,6 +2491,11 @@ struct VOXELFORGE_API FStrateLandmark
     UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Landmark")
     ELandmarkAnchor AnchorMode = ELandmarkAnchor::HashLattice;
 
+    // Optional stable Core feature binding; an empty value keeps lattice/mouth placement unchanged.
+    // Liaison facultative vers une ancre Core stable; vide, le placement existant reste identique.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Landmark|Core Geometry")
+    FString CoreGeometryStableName;
+
     // ----- Hash lattice (AnchorMode == HashLattice — scattered placement; cheap at any radius) -----
 
     // Average spacing between instances, IN CHUNKS = the lattice cell size (one candidate per cell, so cost

Source/VoxelForge/Public/VoxelTypes.h

@@ -332,16 +332,33 @@ struct FVoxelTileKey
     FVoxelTileKey(const FIntVector& InCoord, int32 InLevel) : Coord(InCoord), Level(InLevel) {}
 
     // Cell size (sampling step) in voxels, and tile extent in voxels per axis.
-    int32 StepVoxels()   const { return 1 << Level; }
-    int32 ExtentVoxels() const { return CHUNK_SIZE << Level; }
+    int32 StepVoxels() const
+    {
+        const uint32 SafeLevel = static_cast<uint32>(FMath::Clamp(Level, 0, 8));
+        return static_cast<int32>(uint32{1} << SafeLevel);
+    }
+    int32 ExtentVoxels() const
+    {
+        const uint32 SafeLevel = static_cast<uint32>(FMath::Clamp(Level, 0, 8));
+        return static_cast<int32>(static_cast<uint32>(CHUNK_SIZE) * (uint32{1} << SafeLevel));
+    }
 
     // Min-corner of the tile in VOXEL coords (what the mesher takes).
-    FIntVector OriginVoxels() const { return Coord * (CHUNK_SIZE << Level); }
+    FIntVector OriginVoxels() const
+    {
+        const int64 Extent = ExtentVoxels();
+        const auto ScaleAxis = [Extent](int32 Axis)
+        {
+            return static_cast<int32>(FMath::Clamp<int64>(
+                static_cast<int64>(Axis) * Extent, MIN_int32, MAX_int32));
+        };
+        return FIntVector(ScaleAxis(Coord.X), ScaleAxis(Coord.Y), ScaleAxis(Coord.Z));
+    }
 
     // Tile centre in world cm (for distance sorting / LOD selection).
     FVector CenterCm() const
     {
-        const double Ext = (double)(CHUNK_SIZE << Level) * (double)VOXEL_SIZE;
+        const double Ext = static_cast<double>(ExtentVoxels()) * static_cast<double>(VOXEL_SIZE);
         return FVector((Coord.X + 0.5) * Ext, (Coord.Y + 0.5) * Ext, (Coord.Z + 0.5) * Ext);
     }
 

Source/VoxelForge/Public/VoxelWorld.h

@@ -52,6 +52,9 @@ struct FVoxelForgeCoreTileHashRecord
 struct FVoxelTileCancellationState
 {
     std::atomic<bool> bObsolete{false};
+    uint64 RequestOrdinal = 0;
+    uint32 RequestEpoch = 0;
+    int32 WorkPriority = 0;
 };
 
 /**
@@ -145,6 +148,10 @@ struct FChunkResult
     // per-tile profiling remains opt-in.
     uint64 GenerationStartCycles = 0;
     uint64 GenerationEndCycles = 0;
+    // Optional phase timings recorded only while the bounded startup trace is active.
+    double CoreGenerateSeconds = 0.0;
+    double MeshCopySeconds = 0.0;
+    double StreamBuildSeconds = 0.0;
     uint64 ApplyStartCycles = 0;
     EVoxelTileWorkPriority WorkPriority = EVoxelTileWorkPriority::Horizon;
     // Ordinals make admitted order and actual worker start order auditable across MPSC results.
@@ -352,6 +359,10 @@ public:
      *  the first resolved collidable support tile. */
     TSet<FVoxelTileKey> CollisionNotRequiredTiles;
 
+    /** Known-empty collision classifications survive unload for the tile's current edit epoch. */
+    TMap<FVoxelTileKey, uint32> KnownEmptyCollisionTileEpoch;
+    TSet<FVoxelTileKey> KnownEmptyCollisionSolidTiles;
+
     /** Subset of CollisionNotRequiredTiles proved all-solid. A support probe inside one of these
      *  tiles searches upward for the boundary tile; all-air/empty tiles search downward. */
     TSet<FVoxelTileKey> CollisionSolidTiles;
@@ -614,6 +625,7 @@ public:
     FVector GetVoxelForgeCoreDefaultCenterWorld() const;
     bool QueryVoxelForgeCoreDensityAt(FVector WorldLocation, float& OutDensity) const;
     bool GetVoxelForgeCoreWorldAssembly(FString& OutCanonicalJson, FString& OutContentHash) const;
+    bool GetVoxelForgeCoreResolvedLayout(FString& OutCanonicalJson, FString& OutStableIdentity) const;
 
     UFUNCTION(BlueprintPure, Category = "Voxel World|Strate")
     int32 GetStrateAtPosition(FVector WorldPosition) const;
@@ -778,7 +790,10 @@ private:
     TSharedPtr<FVoxelForgeCoreRuntimeState, ESPMode::ThreadSafe> VoxelForgeCoreState;
     FString VoxelForgeCoreWorldAssemblyJson;
     FString VoxelForgeCoreWorldAssemblyHash;
+    FString VoxelForgeCoreResolvedLayoutJson;
+    FString VoxelForgeCoreResolvedLayoutIdentity;
     FVector CoreFallbackCenterLocalCm = FVector::ZeroVector;
+    int32 CoreRenderDistanceChunks = 0;
     bool bCoreRegionCompilePending = false;
     TArray<FVoxelTileKey> PendingCoreRegionTiles;
     TSet<FVoxelTileKey> PendingCoreRegionTileSet;
@@ -1194,6 +1209,9 @@ public:
     // and records the ones ONLY a CollisionOnly anchor wants in CollisionOnlyTiles.
     void AddAnchorDesiredTiles();
     void ReconcileCollisionDesiredTiles();
+    void RestoreKnownEmptyCollisionTiles();
+    void RebaseKnownEmptyCollisionEpoch();
+    void InvalidateKnownEmptyCollisionTile(const FVoxelTileKey& Tile, const TCHAR* Reason);
     // Forces a desired-set rebuild next Tick even if neither the player nor an anchor crossed a tile
     // boundary (set by UnregisterStreamingAnchor so a removed anchor's tiles get culled).
     bool bForceDesiredRebuild = false;
@@ -1229,10 +1247,13 @@ public:
     bool bSampleStacksStarted = false;
     bool bStartupApplyBoostStarted = false;
     bool bStartupApplyBoostEnded = false;
+    uint64 StartupApplyBoostStartCycles = 0;
     // 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;
+    bool bSpeedAwareTravelMode = false;
+    bool bSpeedAwareFastMode = false;
     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
@@ -1340,6 +1361,7 @@ public:
     double HeadlessStreamingTestDistanceCm = 0.0;
     float HeadlessStreamingTestSpeedCmPerSecond = 0.0f;
     float HeadlessStreamingTestStartSeconds = 0.0f;
+    float HeadlessStreamingTestMoveDurationSeconds = 0.0f;
     float HeadlessStreamingTestExitSeconds = 0.0f;
     float HeadlessStreamingTestTeleportAtSeconds = 0.0f;
     float HeadlessStreamingTestTeleportDistanceCm = 0.0f;

Source/VoxelForge/VoxelForge.Build.cs

@@ -7,6 +7,13 @@ public class VoxelForge : ModuleRules
 {
 	public VoxelForge(ReadOnlyTargetRules Target) : base(Target)
 	{
+		if (Target.Platform == UnrealTargetPlatform.Linux)
+		{
+			// Test translation units have independent anonymous-namespace helpers that collide in
+			// Linux Unity batches. Keep Linux compilation one source per TU; Windows remains unchanged.
+			bUseUnity = false;
+		}
+
 		// PCH = Precompiled Headers - speeds up compilation
 		// UseExplicitOrSharedPCHs is the modern recommended setting
 		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

Source/VoxelForgeCore/VoxelForgeCore.Build.cs

@@ -39,6 +39,13 @@ public class VoxelForgeCore : ModuleRules
 
 		PublicDependencyModuleNames.Add("Core");
 		CppStandard = CppStandardVersion.Cpp20;
+		if (Target.Platform == UnrealTargetPlatform.Linux)
+		{
+			// The compatibility include directory contains Unreal-shaped placeholders. On Linux,
+			// let generated module TUs pass those names through to UE while Core shims opt in.
+			PrivateDefinitions.Add("VFCORE_COMPAT_FORWARD_HEADERS=1");
+			MinCpuArchX64 = MinimumCpuArchitectureX64.AVX2;
+		}
 		// Canonical Standalone code predates UE's stricter warning defaults; keep this narrow to legal local shadowing.
 		CppCompileWarningSettings.ShadowVariableWarningLevel = WarningLevel.Off;
 		FPSemantics = FPSemanticsMode.Precise;

Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp

@@ -878,6 +878,8 @@ struct FExploreArguments
     bool bPassageFloorWritesOverride = false;
     int32 PassageFloorWrites = 1;
     bool bStandaloneWorldExport = false;
+    bool bOwnerFourStratePlan = false;
+    bool bSkipStandaloneCoreAdapterParity = false;
     bool bCoreWorldTest = false;
     bool bCoreWorldStreamTraceOnly = false;
     bool bRenderCameraOverride = false;
@@ -922,6 +924,12 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
     int32 StandaloneWorldExport = 0;
     FParse::Value(*Params, TEXT("standaloneworldexport="), StandaloneWorldExport);
     OutArguments.bStandaloneWorldExport = StandaloneWorldExport != 0;
+    int32 OwnerFourStratePlan = 0;
+    FParse::Value(*Params, TEXT("ownerfourstrateplan="), OwnerFourStratePlan);
+    OutArguments.bOwnerFourStratePlan = OwnerFourStratePlan != 0;
+    int32 SkipStandaloneCoreAdapterParity = 0;
+    FParse::Value(*Params, TEXT("skipstandalonecoreadapterparity="), SkipStandaloneCoreAdapterParity);
+    OutArguments.bSkipStandaloneCoreAdapterParity = SkipStandaloneCoreAdapterParity != 0;
     int32 CoreWorldTest = 0;
     FParse::Value(*Params, TEXT("coreworldtest="), CoreWorldTest);
     OutArguments.bCoreWorldTest = CoreWorldTest != 0;
@@ -1266,12 +1274,11 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
         return false;
     }
 
-    // The historical explorer contract needs two adjacent mouths around an interior slot.  A
-    // parity export can instead target the game's authored single-strate layout, which has no
-    // such mouths and is valid for export-only mode.  Build() still validates the slot against
-    // the loaded settings layout.
-    const int32 MinimumSlot = OutArguments.bGameRuntimeConfig ? 0 : 1;
-    const int32 MaximumSlot = OutArguments.bGameRuntimeConfig
+    // Passage walks need both mouths; a render/export-only generation can inspect an end slot.
+    // Parity exports also accept the game's authored single-strate layout.
+    const bool bRequiresInteriorSlot = OutArguments.bWalk;
+    const int32 MinimumSlot = OutArguments.bGameRuntimeConfig || !bRequiresInteriorSlot ? 0 : 1;
+    const int32 MaximumSlot = OutArguments.bGameRuntimeConfig || !bRequiresInteriorSlot
         ? MaxSyntheticStrates - 1 : MaxSyntheticStrates - 2;
     if (OutArguments.Slot < MinimumSlot || OutArguments.Slot > MaximumSlot)
     {
@@ -1284,8 +1291,8 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
         else
         {
             OutError = FString::Printf(
-                TEXT("slot must be an interior slot in [1,%d] so arrival and departure mouths exist."),
-                MaxSyntheticStrates - 2);
+                TEXT("slot must be in [0,%d]; walk mode requires an interior slot in [1,%d] for both passage mouths."),
+                MaxSyntheticStrates - 1, MaxSyntheticStrates - 2);
         }
         return false;
     }
@@ -1498,6 +1505,17 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
         OutError = TEXT("standaloneworldexport requires modes=export and settingsref, and must omit strateref.");
         return false;
     }
+    if (OutArguments.bOwnerFourStratePlan
+        && (OutArguments.SettingsReference.IsEmpty() || !OutArguments.StrateReference.IsEmpty()))
+    {
+        OutError = TEXT("ownerfourstrateplan requires settingsref and must omit strateref.");
+        return false;
+    }
+    if (OutArguments.bSkipStandaloneCoreAdapterParity && !OutArguments.bStandaloneWorldExport)
+    {
+        OutError = TEXT("skipstandalonecoreadapterparity requires standaloneworldexport.");
+        return false;
+    }
     if (OutArguments.bCoreWorldTest
         && (OutArguments.SettingsReference.IsEmpty() || !OutArguments.StrateReference.IsEmpty()))
     {
@@ -1702,6 +1720,66 @@ struct FExploreMeshBvhNode
     }
 };
 
+bool ApplyOwnerFourStratePlan(UVoxelSettings* Settings,
+    TArray<TStrongObjectPtr<UVoxelStrateDefinition>>& OutDefinitions,
+    bool bDuplicateDefinitions, FString& OutError)
+{
+    if (Settings == nullptr)
+    {
+        OutError = TEXT("The transient owner plan has no settings object.");
+        return false;
+    }
+    if (!Settings->Season.IsNull())
+    {
+        OutError = TEXT("The transient four-strate owner plan cannot replace an assigned season manifest.");
+        return false;
+    }
+
+    static const TCHAR* AssetPaths[] = {
+        TEXT("/Game/VoxelForge/DA_Strate1.DA_Strate1"),
+        TEXT("/Game/VoxelForge/DA_Strate2.DA_Strate2"),
+        TEXT("/Game/VoxelForge/DA_Strate3.DA_Strate3"),
+        TEXT("/Game/VoxelForge/DA_Strate4.DA_Strate4")
+    };
+    Settings->TotalStrates = UE_ARRAY_COUNT(AssetPaths);
+    Settings->StratePool.Reset();
+    Settings->FixedStrates.Reset();
+    OutDefinitions.Reset();
+    OutDefinitions.Reserve(UE_ARRAY_COUNT(AssetPaths));
+
+    for (int32 Index = 0; Index < UE_ARRAY_COUNT(AssetPaths); ++Index)
+    {
+        UVoxelStrateDefinition* AuthoredDefinition = LoadObject<UVoxelStrateDefinition>(
+            nullptr, AssetPaths[Index]);
+        if (AuthoredDefinition == nullptr)
+        {
+            OutError = FString::Printf(
+                TEXT("Could not load staged owner strate asset '%s'."), AssetPaths[Index]);
+            return false;
+        }
+        UVoxelStrateDefinition* Definition = AuthoredDefinition;
+        if (bDuplicateDefinitions)
+        {
+            Definition = DuplicateObject<UVoxelStrateDefinition>(
+                AuthoredDefinition, GetTransientPackage(),
+                FName(*FString::Printf(TEXT("VoxelForgeOwnerPlan_Strate_%d"), Index)));
+            if (Definition == nullptr)
+            {
+                OutError = FString::Printf(
+                    TEXT("Could not make a transient copy of owner strate asset '%s'."), AssetPaths[Index]);
+                return false;
+            }
+        }
+        Settings->FixedStrates.Add(Index,
+            TSoftObjectPtr<UVoxelStrateDefinition>(Definition));
+        OutDefinitions.Add(TStrongObjectPtr<UVoxelStrateDefinition>(Definition));
+    }
+
+    UE_LOG(LogTemp, Display,
+        TEXT("[VoxelForgeOwnerPlan] transient fixed slots=4 assets=DA_Strate1,DA_Strate2,DA_Strate3,DA_Strate4 settings_asset_untouched=1"));
+    return true;
+}
+
 struct FExploreWorld
 {
     TStrongObjectPtr<UVoxelSettings> Settings;
@@ -1834,7 +1912,7 @@ struct FExploreWorld
                 Settings->InterStrateGapChunks, Settings->SkirtCells);
         }
 
-        const int32 NumStrates = bUseAuthoredSettings
+        const int32 NumStrates = Arguments.bOwnerFourStratePlan ? 4 : bUseAuthoredSettings
             ? (Arguments.bGameRuntimeConfig
                 ? FMath::Max(Settings->TotalStrates, 1)
                 : FMath::Max(Settings->TotalStrates, Arguments.Slot + 2))
@@ -1864,10 +1942,18 @@ struct FExploreWorld
         // loaded package remains untouched.
         Settings->TotalStrates = NumStrates;
 
+        if (Arguments.bOwnerFourStratePlan)
+        {
+            if (!ApplyOwnerFourStratePlan(Settings.Get(), Definitions, true, OutError))
+            {
+                return false;
+            }
+        }
+        else
+        {
             if (bUseAuthoredStrate)
             {
-            // The owner’s snapshot states that every slot uses DA_Strate3. Clone it per slot so
-            // commandlet overrides never mutate a loaded package or leak between slots.
+                // Keep the historical single-asset interior probe isolated from loaded packages.
                 Settings->StratePool.Reset();
                 Settings->FixedStrates.Reset();
             }
@@ -1923,6 +2009,7 @@ struct FExploreWorld
                 }
                 Definitions.Add(TStrongObjectPtr<UVoxelStrateDefinition>(Definition));
             }
+        }
 
         auto ApplyTargetOverrides = [&Arguments](UVoxelStrateDefinition* Definition) -> bool
         {
@@ -13472,14 +13559,16 @@ bool VerifyStandaloneCoreAdapter(const FString& Json, FString& OutError)
 
         const std::array<std::uint64_t, 4> Actual = StandaloneCoreAggregateHashes(Rows);
         const std::array<std::uint64_t, 4> Expected{
-            0xdb2991c73215af4cull, 0x8236c5edd7fc8e4full,
-            0x4c48fa75a543d58eull, 0xbea22e76b34a4dfcull};
+            0xde345030348f2c5dull, 0xcbf0888004618b87ull,
+            0x7a11e28e052d69a8ull, 0x52b88607e8dbcbfdull};
         const VoxelForgeCore::ShapeBuildStats Stats = CoreWorld.buildStats();
-        const bool bPassageWalkabilityPassed = Stats.walkSamples == 5642 && Stats.walkFailures == 0;
-        if (Rows.size() != 2226 || Actual != Expected || !bPassageWalkabilityPassed)
+        constexpr std::uint64_t ExpectedWalkSamples = 21425;
+        const bool bPassageWalkabilityPassed = Stats.walkSamples == ExpectedWalkSamples
+            && Stats.walkFailures == 0;
+        if (Rows.size() != 2578 || Actual != Expected || !bPassageWalkabilityPassed)
         {
             OutError = FString::Printf(
-                TEXT("Core adapter parity failed at workers=%llu: tiles=%llu density=0x%016llx mesh=0x%016llx payload=0x%016llx topology=0x%016llx walk=%llu/%llu expected=5642/5642"),
+                TEXT("Core adapter parity failed at workers=%llu: tiles=%llu density=0x%016llx mesh=0x%016llx payload=0x%016llx topology=0x%016llx walk=%llu/%llu expected_walk=%llu"),
                 static_cast<unsigned long long>(WorkerLimit),
                 static_cast<unsigned long long>(Rows.size()),
                 static_cast<unsigned long long>(Actual[0]),
@@ -13487,12 +13576,13 @@ bool VerifyStandaloneCoreAdapter(const FString& Json, FString& OutError)
                 static_cast<unsigned long long>(Actual[2]),
                 static_cast<unsigned long long>(Actual[3]),
                 static_cast<unsigned long long>(Stats.walkSamples - Stats.walkFailures),
-                static_cast<unsigned long long>(Stats.walkSamples));
+                static_cast<unsigned long long>(Stats.walkSamples),
+                static_cast<unsigned long long>(ExpectedWalkSamples));
             return false;
         }
 
         UE_LOG(LogTemp, Display,
-            TEXT("[VoxelForgeCoreAdapter] pass schema=1 workers=%llu asset_clip_radius=%d asset_max_level=%d reference_clip_radius=3 reference_max_level=8 tiles=%llu density=0x%016llx mesh=0x%016llx payload=0x%016llx topology=0x%016llx walk=5642/5642"),
+            TEXT("[VoxelForgeCoreAdapter] pass schema=2 workers=%llu asset_clip_radius=%d asset_max_level=%d reference_clip_radius=3 reference_max_level=8 tiles=%llu density=0x%016llx mesh=0x%016llx payload=0x%016llx topology=0x%016llx walk=%llu/%llu"),
             static_cast<unsigned long long>(WorkerLimit),
             OwnerClipRadius,
             OwnerMaxLod,
@@ -13500,7 +13590,9 @@ bool VerifyStandaloneCoreAdapter(const FString& Json, FString& OutError)
             static_cast<unsigned long long>(Actual[0]),
             static_cast<unsigned long long>(Actual[1]),
             static_cast<unsigned long long>(Actual[2]),
-            static_cast<unsigned long long>(Actual[3]));
+            static_cast<unsigned long long>(Actual[3]),
+            static_cast<unsigned long long>(Stats.walkSamples - Stats.walkFailures),
+            static_cast<unsigned long long>(ExpectedWalkSamples));
     }
     return true;
 }
@@ -13515,6 +13607,24 @@ bool RunStandaloneWorldExport(const FExploreArguments& Arguments, FString& OutEr
             *Arguments.SettingsReference);
         return false;
     }
+    TStrongObjectPtr<UVoxelSettings> OwnerPlanSettings;
+    TArray<TStrongObjectPtr<UVoxelStrateDefinition>> OwnerPlanDefinitions;
+    UVoxelSettings* ExportSettings = AuthoredSettings;
+    if (Arguments.bOwnerFourStratePlan)
+    {
+        OwnerPlanSettings = TStrongObjectPtr<UVoxelSettings>(
+            DuplicateObject<UVoxelSettings>(AuthoredSettings, GetTransientPackage()));
+        if (!OwnerPlanSettings.IsValid())
+        {
+            OutError = TEXT("Could not make a transient copy of owner settings for the four-strate plan.");
+            return false;
+        }
+        ExportSettings = OwnerPlanSettings.Get();
+        if (!ApplyOwnerFourStratePlan(ExportSettings, OwnerPlanDefinitions, false, OutError))
+        {
+            return false;
+        }
+    }
     UVoxelStrateManager* Manager = NewObject<UVoxelStrateManager>(
         GetTransientPackage(), NAME_None, RF_Transient);
     int32 Seed = AuthoredSettings->Seed;
@@ -13526,7 +13636,7 @@ bool RunStandaloneWorldExport(const FExploreArguments& Arguments, FString& OutEr
         OriginSpineRadius = Season->GetOriginSpineRadius();
         WorldRadiusVoxels = Season->GetWorldRadiusVoxels();
     }
-    if (!Manager->Initialize(AuthoredSettings, Seed))
+    if (!Manager->Initialize(ExportSettings, Seed))
     {
         OutError = TEXT("Owner settings did not produce a valid resolved strate layout.");
         return false;
@@ -13534,7 +13644,7 @@ bool RunStandaloneWorldExport(const FExploreArguments& Arguments, FString& OutEr
     Seed = Manager->GetWorldSeed();
     UVoxelGenerator* Generator = NewObject<UVoxelGenerator>(
         GetTransientPackage(), NAME_None, RF_Transient);
-    Generator->InitializeSettings(AuthoredSettings);
+    Generator->InitializeSettings(ExportSettings);
     Generator->SetStrateManager(Manager);
 
     TArray<FStandaloneExportSample> Samples;
@@ -13668,25 +13778,25 @@ bool RunStandaloneWorldExport(const FExploreArguments& Arguments, FString& OutEr
     Writer->WriteValue(TEXT("source"), TEXT("VoxelForgeExplore standalone base-world export"));
     Writer->WriteValue(TEXT("voxel_size_cm"), StandaloneCoreVoxelSizeCm);
     Writer->WriteValue(TEXT("seed"), Seed);
-    Writer->WriteValue(TEXT("open_surface_entry"), AuthoredSettings->bOpenSurfaceEntry);
+    Writer->WriteValue(TEXT("open_surface_entry"), ExportSettings->bOpenSurfaceEntry);
     Writer->WriteValue(TEXT("origin_spine_radius"), OriginSpineRadius);
     Writer->WriteValue(TEXT("world_radius_voxels"), WorldRadiusVoxels);
-    Writer->WriteValue(TEXT("edge_seal_thickness"), AuthoredSettings->EdgeSealThickness);
+    Writer->WriteValue(TEXT("edge_seal_thickness"), ExportSettings->EdgeSealThickness);
     Writer->WriteValue(TEXT("total_strates"), Manager->GetNumStrates());
-    Writer->WriteValue(TEXT("inter_strate_gap_chunks"), AuthoredSettings->InterStrateGapChunks);
-    Writer->WriteValue(TEXT("clip_radius"), AuthoredSettings->ClipRadius);
-    Writer->WriteValue(TEXT("max_clip_level"), AuthoredSettings->MaxClipLevel);
-    Writer->WriteValue(TEXT("full_res_clip_levels"), AuthoredSettings->FullResClipLevels);
-    Writer->WriteValue(TEXT("coarse_tile_cells"), AuthoredSettings->CoarseTileCells);
-    Writer->WriteValue(TEXT("render_distance_chunks"), AuthoredSettings->RenderDistanceChunks);
-    Writer->WriteValue(TEXT("generate_skirts"), AuthoredSettings->bGenerateSkirts);
-    Writer->WriteValue(TEXT("skirt_cells"), AuthoredSettings->SkirtCells);
-    Writer->WriteValue(TEXT("lod_octave_drop"), AuthoredSettings->LODOctaveDrop);
-    Writer->WriteValue(TEXT("strate_content_cut_min_level"), AuthoredSettings->GetEffectiveStrateContentCutMinLevel());
+    Writer->WriteValue(TEXT("inter_strate_gap_chunks"), ExportSettings->InterStrateGapChunks);
+    Writer->WriteValue(TEXT("clip_radius"), ExportSettings->ClipRadius);
+    Writer->WriteValue(TEXT("max_clip_level"), ExportSettings->MaxClipLevel);
+    Writer->WriteValue(TEXT("full_res_clip_levels"), ExportSettings->FullResClipLevels);
+    Writer->WriteValue(TEXT("coarse_tile_cells"), ExportSettings->CoarseTileCells);
+    Writer->WriteValue(TEXT("render_distance_chunks"), ExportSettings->RenderDistanceChunks);
+    Writer->WriteValue(TEXT("generate_skirts"), ExportSettings->bGenerateSkirts);
+    Writer->WriteValue(TEXT("skirt_cells"), ExportSettings->SkirtCells);
+    Writer->WriteValue(TEXT("lod_octave_drop"), ExportSettings->LODOctaveDrop);
+    Writer->WriteValue(TEXT("strate_content_cut_min_level"), ExportSettings->GetEffectiveStrateContentCutMinLevel());
     TSet<const UObject*> ActiveObjects;
     StandaloneWriteJsonValue(*Writer, TEXT("settings_asset"),
-        StandaloneSerializeStruct(AuthoredSettings->GetClass(), AuthoredSettings,
-            ActiveObjects, AuthoredSettings));
+        StandaloneSerializeStruct(ExportSettings->GetClass(), ExportSettings,
+            ActiveObjects, ExportSettings));
 
     Writer->WriteArrayStart(TEXT("strates"));
     for (const FStrateSlot& Slot : Manager->GetLayout())
@@ -13756,6 +13866,68 @@ bool RunStandaloneWorldExport(const FExploreArguments& Arguments, FString& OutEr
     Writer->WriteObjectEnd();
     Writer->Close();
 
+    // Export the exact Core manifest and resolved layout that the Unreal adapter just
+    // generated from these live settings and slots. The standalone research tools consume
+    // these snapshots instead of maintaining a second copy of the planning rules.
+    FString RuntimeSnapshotJson;
+    if (!VoxelForgeCoreAdapter::SerializeResolvedWorld(
+            ExportSettings, Manager, 3, 8, StandaloneCoreVoxelSizeCm,
+            RuntimeSnapshotJson, OutError))
+    {
+        return false;
+    }
+    FTCHARToUTF8 RuntimeSnapshotUtf8(*RuntimeSnapshotJson);
+    std::string CoreSnapshotError;
+    const std::optional<VoxelForgeCore::ResolvedWorldSnapshot> CoreSnapshot =
+        VoxelForgeCore::ResolvedWorldSnapshot::FromJson(
+            std::string_view(RuntimeSnapshotUtf8.Get(),
+                static_cast<std::size_t>(RuntimeSnapshotUtf8.Length())), CoreSnapshotError);
+    if (!CoreSnapshot || CoreSnapshot->worldAssembly() == nullptr
+        || CoreSnapshot->resolvedLayout() == nullptr)
+    {
+        OutError = FString::Printf(
+            TEXT("Core adapter export did not produce a complete manifest and resolved layout: %s"),
+            UTF8_TO_TCHAR(CoreSnapshotError.c_str()));
+        return false;
+    }
+
+    const std::string CoreAssemblyText = CoreSnapshot->worldAssembly()->ToJson();
+    const std::string CoreLayoutText = CoreSnapshot->resolvedLayout()->ToJson();
+    if (CoreAssemblyText.empty() || CoreLayoutText.empty())
+    {
+        OutError = TEXT("Core adapter export produced an empty canonical manifest or layout.");
+        return false;
+    }
+    const FString CanonicalAssemblyJson = UTF8_TO_TCHAR(CoreAssemblyText.c_str());
+    const FString CanonicalLayoutJson = UTF8_TO_TCHAR(CoreLayoutText.c_str());
+    TSharedPtr<FJsonObject> ExportRoot;
+    const TSharedRef<TJsonReader<>> ExportReader = TJsonReaderFactory<>::Create(Json);
+    if (!FJsonSerializer::Deserialize(ExportReader, ExportRoot) || !ExportRoot.IsValid())
+    {
+        OutError = TEXT("Could not reopen the owner export to attach the Core plan snapshots.");
+        return false;
+    }
+    TSharedPtr<FJsonObject> AssemblyObject;
+    const TSharedRef<TJsonReader<>> AssemblyReader =
+        TJsonReaderFactory<>::Create(CanonicalAssemblyJson);
+    if (!FJsonSerializer::Deserialize(AssemblyReader, AssemblyObject) || !AssemblyObject.IsValid())
+    {
+        OutError = TEXT("Could not parse the Core adapter's canonical manifest for export.");
+        return false;
+    }
+    ExportRoot->SetObjectField(TEXT("world_assembly"), AssemblyObject.ToSharedRef());
+    ExportRoot->SetStringField(TEXT("core_world_assembly_json"), CanonicalAssemblyJson);
+    ExportRoot->SetStringField(TEXT("resolved_layout_json"), CanonicalLayoutJson);
+    FString ExportedJson;
+    const TSharedRef<TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>> ExportWriter =
+        TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&ExportedJson);
+    if (!FJsonSerializer::Serialize(ExportRoot.ToSharedRef(), ExportWriter))
+    {
+        OutError = TEXT("Could not serialize the owner export with its canonical Core plan.");
+        return false;
+    }
+    Json = MoveTemp(ExportedJson);
+
     const FString Path = FPaths::Combine(Arguments.OutDirectory, TEXT("owner_world.json"));
     if (!FFileHelper::SaveStringToFile(
             Json, *Path, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
@@ -13764,11 +13936,16 @@ bool RunStandaloneWorldExport(const FExploreArguments& Arguments, FString& OutEr
         return false;
     }
     if (OutJson) *OutJson = Json;
-    if (!VerifyStandaloneCoreAdapter(Json, OutError))
+    if (!Arguments.bSkipStandaloneCoreAdapterParity && !VerifyStandaloneCoreAdapter(Json, OutError))
     {
         UE_LOG(LogTemp, Error, TEXT("[VoxelForgeCoreAdapter] %s"), *OutError);
         return false;
     }
+    if (Arguments.bSkipStandaloneCoreAdapterParity)
+    {
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeCoreAdapter] skipped legacy W1/W8/W16 fixture parity for this export-only update."));
+    }
     UE_LOG(LogTemp, Display,
         TEXT("[VoxelForgeStandaloneExport] seed=%d voxel_size_cm=%.3f strates=%d passages=%d samples=%d camera_found=%d file=%s"),
         Seed, StandaloneCoreVoxelSizeCm, Manager->GetNumStrates(), Manager->GetPassages().Num(),
@@ -14808,7 +14985,7 @@ bool CreateLoggedOwnerSurfaceSettingsCopy(
     UVoxelSettings* Source, int32 Seed,
     TStrongObjectPtr<UVoxelSettings>& OutSettings,
     TStrongObjectPtr<UVoxelStrateDefinition>& OutSurfaceDefinition,
-    FString& OutError)
+    FString& OutError, bool bCompactTracePlan = false)
 {
     if (Source == nullptr)
     {
@@ -14824,11 +15001,10 @@ bool CreateLoggedOwnerSurfaceSettingsCopy(
         nullptr, TEXT("/Game/VoxelForge/DA_Strate1.DA_Strate1"));
     if (SurfaceDefinition == nullptr
         || SurfaceDefinition->GeneratorType != ECaveGeneratorType::SurfaceWorld
-        || SurfaceDefinition->StrateHeightInChunks <= 0
-        || Source->TotalStrates != 1)
+        || SurfaceDefinition->StrateHeightInChunks <= 0)
     {
         OutError = FString::Printf(
-            TEXT("The staged owner assets do not describe the logged single SurfaceWorld (definition_loaded=%d type=%d height=%d settings_strates=%d)."),
+            TEXT("The staged owner assets do not contain a usable DA_Strate1 SurfaceWorld (definition_loaded=%d type=%d height=%d settings_strates=%d)."),
             SurfaceDefinition != nullptr ? 1 : 0,
             SurfaceDefinition != nullptr ? static_cast<int32>(SurfaceDefinition->GeneratorType) : INDEX_NONE,
             SurfaceDefinition != nullptr ? SurfaceDefinition->StrateHeightInChunks : INDEX_NONE,
@@ -14843,9 +15019,24 @@ bool CreateLoggedOwnerSurfaceSettingsCopy(
         return false;
     }
     OutSettings = TStrongObjectPtr<UVoxelSettings>(SettingsCopy);
+    if (bCompactTracePlan)
+    {
+        SurfaceDefinition = DuplicateObject<UVoxelStrateDefinition>(SurfaceDefinition,
+            GetTransientPackage(), TEXT("VoxelForgeCompactSurfaceTraceDefinition"));
+        if (SurfaceDefinition == nullptr)
+        {
+            OutError = TEXT("Could not make a transient DA_Strate1 copy for the compact common-plan trace.");
+            return false;
+        }
+        // L14's historical fixed-length SurfaceWorld route search cannot place the
+        // new trace fixture even at 16 chunks. Use the same simple, walkable FlatPlain
+        // plan in both host revisions so the streaming comparison reaches AVoxelWorld.
+        SurfaceDefinition->GeneratorType = ECaveGeneratorType::FlatPlain;
+        SurfaceDefinition->StrateHeightInChunks = 16;
+    }
     OutSurfaceDefinition = TStrongObjectPtr<UVoxelStrateDefinition>(SurfaceDefinition);
     SettingsCopy->Seed = Seed;
-    SettingsCopy->TotalStrates = Source->TotalStrates;
+    SettingsCopy->TotalStrates = 1;
     SettingsCopy->StratePool.Reset();
     SettingsCopy->FixedStrates.Reset();
     SettingsCopy->FixedStrates.Add(0,
@@ -14855,8 +15046,10 @@ bool CreateLoggedOwnerSurfaceSettingsCopy(
     SettingsCopy->bUseWorldAssemblyManifestOverride = false;
     const int32 BottomChunkZ = 1 - SurfaceDefinition->StrateHeightInChunks;
     UE_LOG(LogTemp, Display,
-        TEXT("[VoxelForgeCoreTestLayout] source=owner_asset_transient_copy definition=DA_Strate1 seed=%d strata=1 bounds=[0,%d] height_chunks=%d gap=%d imported_override=cleared"),
-        Seed, BottomChunkZ, SurfaceDefinition->StrateHeightInChunks, SettingsCopy->InterStrateGapChunks);
+        TEXT("[VoxelForgeCoreTestLayout] source=owner_asset_transient_copy definition=DA_Strate1 generator=%d seed=%d strata=1 bounds=[0,%d] height_chunks=%d compact_trace=%d gap=%d imported_override=cleared"),
+        static_cast<int32>(SurfaceDefinition->GeneratorType), Seed, BottomChunkZ,
+        SurfaceDefinition->StrateHeightInChunks,
+        bCompactTracePlan ? 1 : 0, SettingsCopy->InterStrateGapChunks);
     return true;
 }
 
@@ -16432,7 +16625,15 @@ bool RunCoreFloatingIslandActorIntegrationTest(
     }
     float StagedWalkSpeedCmPerSecond = 0.0f;
     float StagedSprintSpeedCmPerSecond = 0.0f;
-    if (!ReadStagedPlayerSpeeds(
+    if (Arguments.bCoreWorldStreamTraceOnly)
+    {
+        StagedWalkSpeedCmPerSecond = 600.0f;
+        StagedSprintSpeedCmPerSecond = 6000.0f;
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgePawnSpeedFixture] source=trace_fixture_defaults walk_cm_s=%.3f sprint_cm_s=%.3f"),
+            StagedWalkSpeedCmPerSecond, StagedSprintSpeedCmPerSecond);
+    }
+    else if (!ReadStagedPlayerSpeeds(
             StagedWalkSpeedCmPerSecond, StagedSprintSpeedCmPerSecond, OutError))
     {
         return false;
@@ -17065,7 +17266,8 @@ bool RunCoreFloatingIslandActorIntegrationTest(
     {
         if (World == nullptr || World->DesiredSorted.IsEmpty()) return false;
         for (const FVoxelTileKey& Key : World->DesiredSorted)
-            if (!World->LoadedTiles.Contains(Key)) return false;
+            if (!World->LoadedTiles.Contains(Key)
+                && !World->CollisionNotRequiredTiles.Contains(Key)) return false;
         return true;
     };
     const auto CollisionSetSettled = [](const AVoxelWorld* World)
@@ -17654,7 +17856,15 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
 
     float StagedWalkSpeedCmPerSecond = 0.0f;
     float StagedSprintSpeedCmPerSecond = 0.0f;
-    if (!ReadStagedPlayerSpeeds(
+    if (Arguments.bCoreWorldStreamTraceOnly)
+    {
+        StagedWalkSpeedCmPerSecond = 600.0f;
+        StagedSprintSpeedCmPerSecond = 6000.0f;
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgePawnSpeedFixture] source=trace_fixture_defaults walk_cm_s=%.3f sprint_cm_s=%.3f"),
+            StagedWalkSpeedCmPerSecond, StagedSprintSpeedCmPerSecond);
+    }
+    else if (!ReadStagedPlayerSpeeds(
                  StagedWalkSpeedCmPerSecond, StagedSprintSpeedCmPerSecond, OutError))
     {
         return false;
@@ -17663,8 +17873,26 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
     const int32 OwnerSeed = ResolveCoreTestWorldSeed(AuthoredSettings);
     TStrongObjectPtr<UVoxelSettings> OwnerSurfaceSettings;
     TStrongObjectPtr<UVoxelStrateDefinition> OwnerSurfaceDefinition;
-    if (!CreateLoggedOwnerSurfaceSettingsCopy(AuthoredSettings, OwnerSeed,
-            OwnerSurfaceSettings, OwnerSurfaceDefinition, OutError))
+    TArray<TStrongObjectPtr<UVoxelStrateDefinition>> OwnerPlanDefinitions;
+    if (Arguments.bOwnerFourStratePlan)
+    {
+        UVoxelSettings* PlanSettings = DuplicateObject<UVoxelSettings>(
+            AuthoredSettings, GetTransientPackage(), TEXT("VoxelForgeOwnerFourStrateTraceSettings"));
+        if (PlanSettings == nullptr)
+        {
+            OutError = TEXT("Could not duplicate owner settings for the transient four-strate Core trace.");
+            return false;
+        }
+        PlanSettings->Seed = OwnerSeed;
+        if (!ApplyOwnerFourStratePlan(PlanSettings, OwnerPlanDefinitions, true, OutError))
+        {
+            return false;
+        }
+        OwnerSurfaceSettings = TStrongObjectPtr<UVoxelSettings>(PlanSettings);
+    }
+    else if (!CreateLoggedOwnerSurfaceSettingsCopy(AuthoredSettings, OwnerSeed,
+            OwnerSurfaceSettings, OwnerSurfaceDefinition, OutError,
+            Arguments.bCoreWorldStreamTraceOnly))
     {
         return false;
     }
@@ -17822,6 +18050,25 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
             OutError = TEXT("Could not create the BuildHost stream-trace pawn.");
             return false;
         }
+        FVector StartupTraceSpawnCm = FVector::ZeroVector;
+        FString StartupTraceSpawnText;
+        if (FParse::Value(FCommandLine::Get(), TEXT("voxel.StartupTraceSpawnCm="),
+                          StartupTraceSpawnText, false))
+        {
+            TArray<FString> Components;
+            StartupTraceSpawnText.ParseIntoArray(Components, TEXT(","), true);
+            if (Components.Num() != 3
+                || !LexTryParseString(StartupTraceSpawnCm.X, *Components[0])
+                || !LexTryParseString(StartupTraceSpawnCm.Y, *Components[1])
+                || !LexTryParseString(StartupTraceSpawnCm.Z, *Components[2])
+                || !FMath::IsFinite(StartupTraceSpawnCm.X)
+                || !FMath::IsFinite(StartupTraceSpawnCm.Y)
+                || !FMath::IsFinite(StartupTraceSpawnCm.Z))
+            {
+                OutError = TEXT("voxel.StartupTraceSpawnCm must be finite X,Y,Z centimetres.");
+                return false;
+            }
+        }
         USceneComponent* PawnRoot = NewObject<USceneComponent>(PlayerPawn, NAME_None, RF_Transient);
         if (PawnRoot == nullptr)
         {
@@ -17830,7 +18077,7 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
         }
         PlayerPawn->SetRootComponent(PawnRoot);
         PawnRoot->RegisterComponent();
-        PlayerPawn->SetActorLocation(FVector::ZeroVector, false, nullptr, ETeleportType::TeleportPhysics);
+        PlayerPawn->SetActorLocation(StartupTraceSpawnCm, false, nullptr, ETeleportType::TeleportPhysics);
         PlayerController->Possess(PlayerPawn);
         if (TestWorld->GetFirstPlayerController() != PlayerController
             || PlayerController->GetPawn() != PlayerPawn)
@@ -17859,7 +18106,10 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
                 : EVoxelForgeCoreMesherRecipe::MarchingCubesV1);
         Actor->CoreClipRadius = 3;
         Actor->CoreMaxClipLevel = 8;
-        Actor->bCaptureVoxelForgeCoreHashesForValidation = true;
+        // A timing trace must use the production tile path. Core density hashing disables the
+        // native heightfield band shortcut and measures a different workload; hash validation
+        // remains enabled in the dedicated parity tests below.
+        Actor->bCaptureVoxelForgeCoreHashesForValidation = false;
         Actor->FinishSpawning(ActorTransform);
         TestWorld->InitializeActorsForPlay(FURL());
         TestWorld->BeginPlay();
@@ -17869,13 +18119,19 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
             return false;
         }
         Actor->SetActorTickEnabled(true);
+        VoxelForgeStartupTrace::RecordEvent(TEXT("trace_spawn_location"), FString::Printf(
+            TEXT("\"location_cm\":[%s,%s,%s]"),
+            *FString::SanitizeFloat(StartupTraceSpawnCm.X),
+            *FString::SanitizeFloat(StartupTraceSpawnCm.Y),
+            *FString::SanitizeFloat(StartupTraceSpawnCm.Z)));
 
         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;
+                if (!World->LoadedTiles.Contains(Key)
+                    && !World->CollisionNotRequiredTiles.Contains(Key)) return false;
             }
             return true;
         };
@@ -17916,11 +18172,60 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
         TArray<double> SpawnTickMilliseconds;
         TArray<double> WalkTickMilliseconds;
         TArray<TPair<double, double>> TickSamples;
+        double WorldTickStartedSeconds = 0.0;
+        double WorldActorPhaseStartedSeconds = 0.0;
+        double WorldPostActorStartedSeconds = 0.0;
+        double WorldPreActorMilliseconds = 0.0;
+        double WorldActorPhaseMilliseconds = 0.0;
+        double WorldPostActorMilliseconds = 0.0;
+        const FDelegateHandle WorldTickStartHandle = FWorldDelegates::OnWorldTickStart.AddLambda(
+            [&](UWorld* World, ELevelTick, float)
+            {
+                if (World == TestWorld)
+                {
+                    WorldTickStartedSeconds = FPlatformTime::Seconds();
+                }
+            });
+        const FDelegateHandle WorldPreActorTickHandle = FWorldDelegates::OnWorldPreActorTick.AddLambda(
+            [&](UWorld* World, ELevelTick, float)
+            {
+                if (World == TestWorld)
+                {
+                    const double NowSeconds = FPlatformTime::Seconds();
+                    WorldPreActorMilliseconds =
+                        (NowSeconds - WorldTickStartedSeconds) * 1000.0;
+                    WorldActorPhaseStartedSeconds = NowSeconds;
+                }
+            });
+        const FDelegateHandle WorldPostActorTickHandle = FWorldDelegates::OnWorldPostActorTick.AddLambda(
+            [&](UWorld* World, ELevelTick, float)
+            {
+                if (World == TestWorld)
+                {
+                    const double NowSeconds = FPlatformTime::Seconds();
+                    WorldActorPhaseMilliseconds =
+                        (NowSeconds - WorldActorPhaseStartedSeconds) * 1000.0;
+                    WorldPostActorStartedSeconds = NowSeconds;
+                }
+            });
+        const FDelegateHandle WorldTickEndHandle = FWorldDelegates::OnWorldTickEnd.AddLambda(
+            [&](UWorld* World, ELevelTick, float)
+            {
+                if (World == TestWorld)
+                {
+                    WorldPostActorMilliseconds =
+                        (FPlatformTime::Seconds() - WorldPostActorStartedSeconds) * 1000.0;
+                }
+            });
         bool bInitialSetReady = false;
         double InitialSetReadySeconds = -1.0;
         while (FPlatformTime::Seconds() - ActorBeginSeconds < RunDurationSeconds)
         {
             const double TickStartSeconds = FPlatformTime::Seconds();
+            const uint64 TickFrame = GFrameCounter;
+            WorldPreActorMilliseconds = 0.0;
+            WorldActorPhaseMilliseconds = 0.0;
+            WorldPostActorMilliseconds = 0.0;
             TestWorld->Tick(LEVELTICK_All, 0.016f);
             const double TickMilliseconds =
                 (FPlatformTime::Seconds() - TickStartSeconds) * 1000.0;
@@ -17928,6 +18233,7 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
             const double ElapsedSeconds = FPlatformTime::Seconds() - ActorBeginSeconds;
             TickSamples.Emplace(ElapsedSeconds, TickMilliseconds);
 
+            const double ReadinessCheckStartSeconds = FPlatformTime::Seconds();
             if (!bInitialSetReady && Actor->IsVoxelForgeCoreReady()
                 && Actor->bAllChunksLoaded && Actor->PendingTiles.IsEmpty()
                 && Actor->PendingCollisionCooks.IsEmpty() && Actor->PendingUnload.IsEmpty()
@@ -17942,8 +18248,30 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
                     Actor->LoadedTiles.Num(), Actor->CollisionDesiredTiles.Num(),
                     Actor->CollisionReadyTiles.Num()));
             }
+            const double ReadinessCheckMilliseconds =
+                (FPlatformTime::Seconds() - ReadinessCheckStartSeconds) * 1000.0;
+            const double SleepStartSeconds = FPlatformTime::Seconds();
             FPlatformProcess::Sleep(0.016f);
+            const double SleepMilliseconds =
+                (FPlatformTime::Seconds() - SleepStartSeconds) * 1000.0;
+            VoxelForgeStartupTrace::RecordEvent(TEXT("commandlet_world_tick_frame"), FString::Printf(
+                TEXT("\"frame\":%llu,\"world_tick_ms\":%s,"
+                     "\"world_pre_actor_ms\":%s,\"world_actor_phase_ms\":%s,"
+                     "\"world_post_actor_ms\":%s,"
+                     "\"readiness_check_ms\":%s,\"sleep_ms\":%s,\"loop_ms\":%s"),
+                static_cast<unsigned long long>(TickFrame),
+                *FString::SanitizeFloat(TickMilliseconds),
+                *FString::SanitizeFloat(WorldPreActorMilliseconds),
+                *FString::SanitizeFloat(WorldActorPhaseMilliseconds),
+                *FString::SanitizeFloat(WorldPostActorMilliseconds),
+                *FString::SanitizeFloat(ReadinessCheckMilliseconds),
+                *FString::SanitizeFloat(SleepMilliseconds),
+                *FString::SanitizeFloat((FPlatformTime::Seconds() - TickStartSeconds) * 1000.0)));
         }
+        FWorldDelegates::OnWorldTickStart.Remove(WorldTickStartHandle);
+        FWorldDelegates::OnWorldPreActorTick.Remove(WorldPreActorTickHandle);
+        FWorldDelegates::OnWorldPostActorTick.Remove(WorldPostActorTickHandle);
+        FWorldDelegates::OnWorldTickEnd.Remove(WorldTickEndHandle);
 
         for (const TPair<double, double>& Sample : TickSamples)
         {
@@ -18023,6 +18351,7 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
     const double CarveBrushRadiusCoreVoxels =
         CarveBrushRadiusLegacyVoxels * static_cast<double>(VOXEL_SIZE) / CoreVoxelSizeCm;
     const int32 CollisionRadius = FMath::Clamp(AuthoredSettings->PawnCollisionRadiusChunks, 1, 4);
+    FIntVector ColdStartCollisionCenter = FIntVector::ZeroValue;
     uint64 ExpectedEditDigest = 0;
     std::array<std::uint64_t, 4> InitialAggregates{};
     std::array<std::uint64_t, 4> TravelAggregates{};
@@ -18208,10 +18537,17 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
             BiomeProbeSpanVoxels);
 
         VoxelForgeCore::World ReferenceWorld(std::move(*Snapshot));
-        const std::vector<VoxelForgeCore::TileKey> Desired = ReferenceWorld.desiredTiles({});
+        // Match the actor's cold-start fallback camera when the transient world has no pawn.
+        // Aligner la reference sur la camera de repli de l'acteur sans pawn au demarrage.
+        const VoxelForgeCore::WorldConfiguration& ReferenceConfiguration =
+            ReferenceWorld.configuration();
+        const VoxelForgeCore::Vec3d InitialCameraVoxels = ReferenceConfiguration.viewerStartFound
+            ? ReferenceConfiguration.viewerStartVoxels : VoxelForgeCore::Vec3d{};
+        const std::vector<VoxelForgeCore::TileKey> Desired =
+            ReferenceWorld.desiredTiles(InitialCameraVoxels);
         if (Desired.empty())
         {
-            OutError = TEXT("Standalone Core returned an empty reference clipmap at the origin.");
+            OutError = TEXT("Standalone Core returned an empty reference clipmap at the cold-start camera.");
             return false;
         }
         ExpectedInitialTileCount = Desired.size();
@@ -18258,7 +18594,23 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
                 UTF8_TO_TCHAR(CoreError.c_str()));
             return false;
         }
-        ReferenceWorld.retainTileRegions(Desired);
+        // Match the runtime collision probe around the same cold-start viewer tile.
+        // Reproduire la sonde de collision autour de la meme tuile de depart a froid.
+        ColdStartCollisionCenter = FIntVector(
+            FMath::FloorToInt(InitialCameraVoxels.x / 32.0),
+            FMath::FloorToInt(InitialCameraVoxels.y / 32.0),
+            FMath::FloorToInt(InitialCameraVoxels.z / 32.0));
+        std::vector<VoxelForgeCore::TileKey> ColdStartCollisionTiles;
+        ColdStartCollisionTiles.reserve(static_cast<std::size_t>(2 * CollisionRadius + 1)
+            * static_cast<std::size_t>(2 * CollisionRadius + 1)
+            * static_cast<std::size_t>(2 * CollisionRadius + 1));
+        for (int32 Z = -CollisionRadius; Z <= CollisionRadius; ++Z)
+        for (int32 Y = -CollisionRadius; Y <= CollisionRadius; ++Y)
+        for (int32 X = -CollisionRadius; X <= CollisionRadius; ++X)
+            ColdStartCollisionTiles.push_back({
+                {ColdStartCollisionCenter.X + X,
+                 ColdStartCollisionCenter.Y + Y,
+                 ColdStartCollisionCenter.Z + Z}, 0});
 
         if (Arguments.bCoreHybridCliffOnly)
         {
@@ -18332,6 +18684,47 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
             Options.mesherRecipe = VoxelForgeCore::MesherRecipe::worldAssemblerHybridV1;
         else
             Options.mesherRecipe = VoxelForgeCore::MesherRecipe::marchingCubesV1;
+
+        // Keep collision hashes outside ExpectedInitialDesiredSet; the collision cube is an
+        // additional runtime request even where it overlaps the visual clipmap.
+        // Garder les hachages de collision hors de l'ensemble visuel initial, meme s'ils se
+        // recoupent avec le clipmap.
+        std::vector<VoxelForgeCore::TileKey> RetainedReferenceTiles = Desired;
+        RetainedReferenceTiles.insert(RetainedReferenceTiles.end(),
+            ColdStartCollisionTiles.begin(), ColdStartCollisionTiles.end());
+        ReferenceWorld.retainTileRegions(RetainedReferenceTiles);
+        if (!ReferenceWorld.compileTileRegion(ColdStartCollisionTiles, 16, Scheduler, CoreError))
+        {
+            OutError = FString::Printf(TEXT("Standalone collision reference compile failed: %s"),
+                UTF8_TO_TCHAR(CoreError.c_str()));
+            return false;
+        }
+        std::size_t CollisionBodyTiles = 0;
+        for (const VoxelForgeCore::TileKey& Key : ColdStartCollisionTiles)
+        {
+            const std::optional<VoxelForgeCore::TileMesh> Mesh =
+                ReferenceWorld.generateTile(Key, Options, CoreError);
+            if (!Mesh)
+            {
+                OutError = FString::Printf(TEXT("Standalone collision tile generation failed: %s"),
+                    UTF8_TO_TCHAR(CoreError.c_str()));
+                return false;
+            }
+            FVoxelForgeCoreTileHashRecord Record;
+            Record.bEmpty = Mesh->indices.empty();
+            Record.bHasHashes = Mesh->hasDensityHash && Mesh->hasMeshHash
+                && Mesh->hasPayloadHash && Mesh->hasTopologyHash;
+            if (!Record.bEmpty) ++CollisionBodyTiles;
+            ExpectedHashes.Add(FVoxelTileKey(
+                FIntVector(Key.coordinate.x, Key.coordinate.y, Key.coordinate.z), Key.lod), Record);
+        }
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeCoreWorldTest] standalone_collision_reference=1 center=(%d,%d,%d) tiles=%d body=%llu no_body=%llu"),
+            ColdStartCollisionCenter.X, ColdStartCollisionCenter.Y, ColdStartCollisionCenter.Z,
+            static_cast<int32>(ColdStartCollisionTiles.size()),
+            static_cast<unsigned long long>(CollisionBodyTiles),
+            static_cast<unsigned long long>(ColdStartCollisionTiles.size() - CollisionBodyTiles));
+
         std::vector<FStandaloneCoreAdapterTileHashes> AggregateRows;
         AggregateRows.reserve(Desired.size());
         bool bFoundCarveVertex = false;
@@ -19264,7 +19657,8 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
         if (World == nullptr || World->DesiredSorted.IsEmpty()) return false;
         for (const FVoxelTileKey& Key : World->DesiredSorted)
         {
-            if (!World->LoadedTiles.Contains(Key)) return false;
+            if (!World->LoadedTiles.Contains(Key)
+                && !World->CollisionNotRequiredTiles.Contains(Key)) return false;
         }
         return true;
     };
@@ -19367,7 +19761,7 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
     for (int32 Y = -CollisionRadius; Y <= CollisionRadius; ++Y)
     for (int32 X = -CollisionRadius; X <= CollisionRadius; ++X)
     {
-        const FVoxelTileKey Key(FIntVector(X, Y, Z), 0);
+        const FVoxelTileKey Key(ColdStartCollisionCenter + FIntVector(X, Y, Z), 0);
         ExpectedCollisionSet.Add(Key);
         const FVoxelForgeCoreTileHashRecord* Record = ExpectedHashes.Find(Key);
         if (Record == nullptr)
@@ -21361,6 +21755,44 @@ int32 RunBatch(const FString& Params)
 
 int32 UVoxelForgeExploreCommandlet::Main(const FString& Params)
 {
+    if (FParse::Param(*Params, TEXT("coreassetupgradeaudit")))
+    {
+        // Load the untouched BuildHost copies and emit their in-memory conversions; never save a package.
+        // Charge les copies BuildHost intactes et affiche les conversions en memoire, sans sauver de package.
+        UVoxelSettings* SettingsAsset = LoadObject<UVoxelSettings>(nullptr,
+            TEXT("/Game/VoxelForge/DA_Settings.DA_Settings"));
+        if (SettingsAsset == nullptr)
+        {
+            UE_LOG(LogTemp, Error, TEXT("[VoxelForgeAssetMigrationAudit] missing DA_Settings copy"));
+            return 2;
+        }
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeAssetMigrationAudit] asset=%s old_gap_chunks=%d new_gap_m=%.6f layout_chunk_m=%.6f"),
+            *SettingsAsset->GetPathName(), SettingsAsset->InterStrateGapChunks,
+            SettingsAsset->InterStrateGapMeters, SettingsAsset->StrateLayoutChunkSizeMeters);
+
+        const TCHAR* StratePaths[] = {
+            TEXT("/Game/VoxelForge/DA_Strate1.DA_Strate1"),
+            TEXT("/Game/VoxelForge/DA_Strate2.DA_Strate2"),
+            TEXT("/Game/VoxelForge/DA_Strate3.DA_Strate3"),
+            TEXT("/Game/VoxelForge/DA_Strate4.DA_Strate4")
+        };
+        for (const TCHAR* Path : StratePaths)
+        {
+            UVoxelStrateDefinition* Definition = LoadObject<UVoxelStrateDefinition>(nullptr, Path);
+            if (Definition == nullptr)
+            {
+                UE_LOG(LogTemp, Error, TEXT("[VoxelForgeAssetMigrationAudit] missing strate copy %s"), Path);
+                return 2;
+            }
+            UE_LOG(LogTemp, Display,
+                TEXT("[VoxelForgeAssetMigrationAudit] asset=%s old_height_chunks=%d new_height_m=%.6f old_transition_chunks=%d new_transition_m=%.6f"),
+                *Definition->GetPathName(), Definition->StrateHeightInChunks,
+                Definition->StrateHeightMeters, Definition->TransitionBlendChunks,
+                Definition->TransitionWidthMeters);
+        }
+        return 0;
+    }
     if (FParse::Param(*Params, TEXT("step2f")))
     {
         return RunStep2f(Params);

Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneActor.cpp

@@ -0,0 +1,303 @@
+#include "VoxelForgeLivingPlaneActor.h"
+
+#include "Engine/TextureRenderTarget2D.h"
+#include "Engine/TextureRenderTarget.h"
+#include "Engine/StaticMesh.h"
+#include "Engine/World.h"
+#include "Materials/MaterialInstanceDynamic.h"
+#include "Materials/MaterialInterface.h"
+#include "RenderGraphBuilder.h"
+#include "RenderGraphUtils.h"
+#include "RHICommandList.h"
+#include "RHIResources.h"
+#include "DataDrivenShaderPlatformInfo.h"
+#include "GlobalShader.h"
+#include "ShaderParameterStruct.h"
+#include "UObject/ConstructorHelpers.h"
+#include "Components/StaticMeshComponent.h"
+
+namespace
+{
+	constexpr int32 LivingPlaneThreadGroupSize = 8;
+
+	struct FLivingPlaneStepInput
+	{
+		FVector4f ObjectPositionRadius[2] = {FVector4f(0, 0, 0, -1), FVector4f(0, 0, 0, -1)};
+		FVector4f ObjectVelocityPush[2] = {FVector4f(0, 0, 0, 0), FVector4f(0, 0, 0, 0)};
+		float TimeSeconds = 0.0f;
+	};
+
+	class FVFLivingPlaneStepCS final : public FGlobalShader
+	{
+		DECLARE_GLOBAL_SHADER(FVFLivingPlaneStepCS);
+		SHADER_USE_PARAMETER_STRUCT(FVFLivingPlaneStepCS, FGlobalShader);
+
+		BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
+			SHADER_PARAMETER(FIntPoint, GridSize)
+			SHADER_PARAMETER(float, Dt)
+			SHADER_PARAMETER(float, Dx)
+			SHADER_PARAMETER(float, PlaneLength)
+			SHADER_PARAMETER(float, WaveSpeed)
+			SHADER_PARAMETER(float, Damping)
+			SHADER_PARAMETER(float, FoundationStiffness)
+			SHADER_PARAMETER(float, TimeSeconds)
+			SHADER_PARAMETER(FVector2f, BreathingSettings)
+			SHADER_PARAMETER(FVector4f, ImprintSettings)
+			SHADER_PARAMETER_ARRAY(FVector4f, ObjectPositionRadius, [2])
+			SHADER_PARAMETER_ARRAY(FVector4f, ObjectVelocityPush, [2])
+			SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D<float4>, SourceState)
+			SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D<float4>, TargetState)
+		END_SHADER_PARAMETER_STRUCT()
+
+	public:
+		static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
+		{
+			return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);
+		}
+	};
+
+	IMPLEMENT_GLOBAL_SHADER(FVFLivingPlaneStepCS,
+		"/Plugin/VoxelForgeLivingPlane/LivingPlane.usf", "MainCS", SF_Compute)
+
+	UTextureRenderTarget2D* CreateFieldTarget(UObject* Outer, int32 Size, FName Name)
+	{
+		UTextureRenderTarget2D* Target = NewObject<UTextureRenderTarget2D>(Outer, Name, RF_Transient);
+		Target->RenderTargetFormat = RTF_RGBA32f;
+		Target->bCanCreateUAV = true;
+		Target->bAutoGenerateMips = false;
+		Target->ClearColor = FLinearColor::Transparent;
+		Target->Filter = TF_Bilinear;
+		Target->AddressX = TA_Clamp;
+		Target->AddressY = TA_Clamp;
+		Target->InitAutoFormat(Size, Size);
+		Target->UpdateResourceImmediate(true);
+		return Target;
+	}
+}
+
+AVoxelForgeLivingPlaneActor::AVoxelForgeLivingPlaneActor()
+{
+	PrimaryActorTick.bCanEverTick = true;
+	PlaneMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("LivingPlaneMesh"));
+	SetRootComponent(PlaneMesh);
+	PlaneMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+	PlaneMesh->SetMobility(EComponentMobility::Movable);
+	static ConstructorHelpers::FObjectFinder<UStaticMesh> PlaneAsset(
+		TEXT("/Engine/BasicShapes/Plane.Plane"));
+	if (PlaneAsset.Succeeded())
+	{
+		PlaneMesh->SetStaticMesh(PlaneAsset.Object);
+	}
+
+	ObjectInputs.SetNum(2);
+}
+
+void AVoxelForgeLivingPlaneActor::OnConstruction(const FTransform& Transform)
+{
+	Super::OnConstruction(Transform);
+	if (PlaneMesh)
+	{
+		// /Engine/BasicShapes/Plane is 100 cm square; one Unreal scale unit
+		// therefore corresponds to one metre of authored plane length.
+		PlaneMesh->SetRelativeScale3D(FVector(PlaneLengthMeters, PlaneLengthMeters, 1.0));
+	}
+}
+
+float AVoxelForgeLivingPlaneActor::GetStableStepSeconds() const
+{
+	const float Dx = PlaneLengthMeters / static_cast<float>(FMath::Max(GridSize, 16));
+	const float EigenFrequencySquared = 8.0f * WaveSpeedMetersPerSecond * WaveSpeedMetersPerSecond
+		/ FMath::Max(Dx * Dx, 1.0e-8f) + FoundationStiffnessPerSecondSquared;
+	return 1.30f / FMath::Sqrt(FMath::Max(EigenFrequencySquared, 1.0e-8f));
+}
+
+void AVoxelForgeLivingPlaneActor::BeginPlay()
+{
+	Super::BeginPlay();
+	GridSize = FMath::Clamp(GridSize, 16, 2048);
+	PlaneLengthMeters = FMath::Max(PlaneLengthMeters, 1.0f);
+	FixedStepSeconds = GetStableStepSeconds();
+	CreateFieldTargets();
+
+	if (PlaneMaterial && PlaneMesh)
+	{
+		DynamicPlaneMaterial = PlaneMesh->CreateDynamicMaterialInstance(0, PlaneMaterial);
+		if (DynamicPlaneMaterial)
+		{
+			DynamicPlaneMaterial->SetScalarParameterValue(TEXT("PlaneLengthMeters"), PlaneLengthMeters);
+			DynamicPlaneMaterial->SetScalarParameterValue(TEXT("FieldSize"), static_cast<float>(GridSize));
+		}
+	}
+	UpdateMaterialField();
+}
+
+void AVoxelForgeLivingPlaneActor::CreateFieldTargets()
+{
+	FieldTargets[0] = CreateFieldTarget(this, GridSize, TEXT("LivingPlaneStateA"));
+	FieldTargets[1] = CreateFieldTarget(this, GridSize, TEXT("LivingPlaneStateB"));
+	CurrentFieldIndex = 0;
+	SimulationStepCount = 0;
+	SimulationAccumulatorSeconds = 0.0;
+}
+
+void AVoxelForgeLivingPlaneActor::SetObjectState(int32 ObjectIndex,
+	const FVFLivingPlaneObjectInput& State)
+{
+	if (!ObjectInputs.IsValidIndex(ObjectIndex) || ObjectIndex >= 2)
+	{
+		return;
+	}
+	ObjectInputs[ObjectIndex] = State;
+}
+
+void AVoxelForgeLivingPlaneActor::ResetSimulation()
+{
+	if (!IsInGameThread() || !FieldTargets[0] || !FieldTargets[1])
+	{
+		return;
+	}
+	CreateFieldTargets();
+	FixedStepSeconds = GetStableStepSeconds();
+	UpdateMaterialField();
+}
+
+void AVoxelForgeLivingPlaneActor::UpdateMaterialField()
+{
+	if (DynamicPlaneMaterial && FieldTargets[CurrentFieldIndex])
+	{
+		DynamicPlaneMaterial->SetTextureParameterValue(TEXT("LivingField"), FieldTargets[CurrentFieldIndex]);
+	}
+}
+
+void AVoxelForgeLivingPlaneActor::EnqueueSimulationSteps(int32 NumSteps)
+{
+	if (NumSteps <= 0 || !FieldTargets[0] || !FieldTargets[1])
+	{
+		return;
+	}
+
+	FTextureRenderTargetResource* ResourceA = FieldTargets[0]->GameThread_GetRenderTargetResource();
+	FTextureRenderTargetResource* ResourceB = FieldTargets[1]->GameThread_GetRenderTargetResource();
+	if (!ResourceA || !ResourceB)
+	{
+		return;
+	}
+
+	TArray<FLivingPlaneStepInput> Steps;
+	Steps.Reserve(NumSteps);
+	const FTransform PlaneTransform = GetActorTransform();
+	for (int32 Step = 0; Step < NumSteps; ++Step)
+	{
+		FLivingPlaneStepInput& Input = Steps.AddDefaulted_GetRef();
+		Input.TimeSeconds = static_cast<float>(SimulationStepCount + Step) * FixedStepSeconds;
+		for (int32 ObjectIndex = 0; ObjectIndex < 2; ++ObjectIndex)
+		{
+			if (!ObjectInputs.IsValidIndex(ObjectIndex) || !ObjectInputs[ObjectIndex].bActive)
+			{
+				continue;
+			}
+
+			const FVFLivingPlaneObjectInput& Object = ObjectInputs[ObjectIndex];
+			const FVector LocalPosition = PlaneTransform.InverseTransformPosition(Object.WorldPositionCm);
+			const FVector LocalVelocity = PlaneTransform.InverseTransformVector(Object.WorldVelocityCmPerSecond);
+			const float RadiusMeters = FMath::Max(Object.RadiusCm * 0.01f, 0.001f);
+			Input.ObjectPositionRadius[ObjectIndex] = FVector4f(
+				static_cast<float>(LocalPosition.X * 0.01),
+				static_cast<float>(LocalPosition.Y * 0.01),
+				static_cast<float>(LocalPosition.Z * 0.01),
+				RadiusMeters);
+			Input.ObjectVelocityPush[ObjectIndex] = FVector4f(
+				static_cast<float>(LocalVelocity.X * 0.01),
+				static_cast<float>(LocalVelocity.Y * 0.01),
+				static_cast<float>(LocalVelocity.Z * 0.01),
+				FMath::Max(Object.PushAccelerationMetersPerSecondSquared, 0.0f));
+		}
+	}
+
+	const int32 Resolution = GridSize;
+	const int32 InitialFieldIndex = CurrentFieldIndex;
+	const float Dt = static_cast<float>(FixedStepSeconds);
+	const float Dx = PlaneLengthMeters / static_cast<float>(Resolution);
+	const float PlaneLength = PlaneLengthMeters;
+	const float WaveSpeed = WaveSpeedMetersPerSecond;
+	const float Damping = DampingPerSecond;
+	const float Foundation = FoundationStiffnessPerSecondSquared;
+	const float BreathingStrength = bEnableBreathing ? BreathingStrengthMetersPerSecondSquared : 0.0f;
+	const FVector2f BreathingSettings(bEnableBreathing ? 1.0f : 0.0f, BreathingStrength);
+	const FVector4f ImprintSettings(bEnableImprint ? 1.0f : 0.0f,
+		ImprintCaptureMetersPerSecond, FMath::Max(ImprintRecoverySeconds, 1.0e-4f),
+		FMath::Max(ImprintMaxDepthMeters, 0.0f));
+
+	ENQUEUE_RENDER_COMMAND(VoxelForgeLivingPlaneStep)(
+		[ResourceA, ResourceB, Steps = MoveTemp(Steps), InitialFieldIndex, Resolution, Dt, Dx, PlaneLength,
+			WaveSpeed, Damping, Foundation, BreathingSettings, ImprintSettings]
+		(FRHICommandListImmediate& RHICmdList) mutable
+		{
+			FRDGBuilder GraphBuilder(RHICmdList, RDG_EVENT_NAME("VoxelForgeLivingPlane"));
+			FRDGTextureRef Fields[2] = {
+			RegisterExternalTexture(GraphBuilder, ResourceA->GetRenderTargetTexture().GetReference(), TEXT("LivingPlaneStateA")),
+			RegisterExternalTexture(GraphBuilder, ResourceB->GetRenderTargetTexture().GetReference(), TEXT("LivingPlaneStateB"))};
+			TShaderMapRef<FVFLivingPlaneStepCS> ComputeShader(GetGlobalShaderMap(GMaxRHIFeatureLevel));
+			int32 CurrentIndex = InitialFieldIndex;
+			for (const FLivingPlaneStepInput& StepInput : Steps)
+			{
+				const int32 TargetIndex = 1 - CurrentIndex;
+				FVFLivingPlaneStepCS::FParameters* PassParameters =
+					GraphBuilder.AllocParameters<FVFLivingPlaneStepCS::FParameters>();
+				PassParameters->GridSize = FIntPoint(Resolution, Resolution);
+				PassParameters->Dt = Dt;
+				PassParameters->Dx = Dx;
+				PassParameters->PlaneLength = PlaneLength;
+				PassParameters->WaveSpeed = WaveSpeed;
+				PassParameters->Damping = Damping;
+				PassParameters->FoundationStiffness = Foundation;
+				PassParameters->TimeSeconds = StepInput.TimeSeconds;
+				PassParameters->BreathingSettings = BreathingSettings;
+				PassParameters->ImprintSettings = ImprintSettings;
+				for (int32 ObjectIndex = 0; ObjectIndex < 2; ++ObjectIndex)
+				{
+					PassParameters->ObjectPositionRadius[ObjectIndex] = StepInput.ObjectPositionRadius[ObjectIndex];
+					PassParameters->ObjectVelocityPush[ObjectIndex] = StepInput.ObjectVelocityPush[ObjectIndex];
+				}
+				PassParameters->SourceState = GraphBuilder.CreateSRV(Fields[CurrentIndex]);
+				PassParameters->TargetState = GraphBuilder.CreateUAV(Fields[TargetIndex]);
+				FComputeShaderUtils::AddPass(GraphBuilder,
+					RDG_EVENT_NAME("LivingPlaneStep"),
+					ComputeShader, PassParameters,
+					FIntVector(FMath::DivideAndRoundUp(Resolution, LivingPlaneThreadGroupSize),
+						FMath::DivideAndRoundUp(Resolution, LivingPlaneThreadGroupSize), 1));
+				CurrentIndex = TargetIndex;
+			}
+			GraphBuilder.Execute();
+		});
+
+	CurrentFieldIndex = (InitialFieldIndex + NumSteps) & 1;
+	SimulationStepCount += NumSteps;
+	UpdateMaterialField();
+}
+
+void AVoxelForgeLivingPlaneActor::Tick(float DeltaSeconds)
+{
+	Super::Tick(DeltaSeconds);
+	if (FixedStepSeconds <= 0.0 || !FieldTargets[0] || !FieldTargets[1])
+	{
+		return;
+	}
+
+	SimulationAccumulatorSeconds += FMath::Max(static_cast<double>(DeltaSeconds), 0.0);
+	const int32 StepsToRun = FMath::Min(
+		static_cast<int32>(SimulationAccumulatorSeconds / FixedStepSeconds), 32);
+	if (StepsToRun > 0)
+	{
+		SimulationAccumulatorSeconds -= StepsToRun * FixedStepSeconds;
+		EnqueueSimulationSteps(StepsToRun);
+	}
+}
+
+void AVoxelForgeLivingPlaneActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+	DynamicPlaneMaterial = nullptr;
+	FieldTargets[0] = nullptr;
+	FieldTargets[1] = nullptr;
+}

Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneModule.cpp

@@ -0,0 +1,25 @@
+#include "Modules/ModuleManager.h"
+
+#include "Interfaces/IPluginManager.h"
+#include "Misc/Paths.h"
+#include "ShaderCore.h"
+
+class FVoxelForgeLivingPlaneModule final : public IModuleInterface
+{
+public:
+	virtual void StartupModule() override
+	{
+		const TSharedPtr<IPlugin> Plugin = IPluginManager::Get().FindPlugin(TEXT("VoxelForge"));
+		if (!Plugin.IsValid())
+		{
+			UE_LOG(LogTemp, Error, TEXT("VoxelForgeLivingPlane could not find its owning plugin."));
+			return;
+		}
+
+		AddShaderSourceDirectoryMapping(
+			TEXT("/Plugin/VoxelForgeLivingPlane"),
+			FPaths::Combine(Plugin->GetBaseDir(), TEXT("Shaders")));
+	}
+};
+
+IMPLEMENT_MODULE(FVoxelForgeLivingPlaneModule, VoxelForgeLivingPlane)

Source/VoxelForgeLivingPlane/Public/VoxelForgeLivingPlaneActor.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "VoxelForgeLivingPlaneActor.generated.h"
+
+class UMaterialInterface;
+class UMaterialInstanceDynamic;
+class UStaticMeshComponent;
+class UTextureRenderTarget2D;
+
+USTRUCT(BlueprintType)
+struct FVFLivingPlaneObjectInput
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
+	FVector WorldPositionCm = FVector(0.0, 0.0, 43.0);
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
+	FVector WorldVelocityCmPerSecond = FVector::ZeroVector;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object", meta=(ClampMin="0.1"))
+	float RadiusCm = 43.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object", meta=(ClampMin="0.0"))
+	float PushAccelerationMetersPerSecondSquared = 36.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
+	bool bActive = false;
+};
+
+/** A render-only, GPU-stepped heightfield plane. Object state is uploaded; the field is never read back. */
+UCLASS(BlueprintType, Blueprintable)
+class VOXELFORGELIVINGPLANE_API AVoxelForgeLivingPlaneActor : public AActor
+{
+	GENERATED_BODY()
+
+public:
+	AVoxelForgeLivingPlaneActor();
+
+	virtual void BeginPlay() override;
+	virtual void Tick(float DeltaSeconds) override;
+	virtual void OnConstruction(const FTransform& Transform) override;
+	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+
+	UFUNCTION(BlueprintCallable, Category="Living Plane|Object")
+	void SetObjectState(int32 ObjectIndex, const FVFLivingPlaneObjectInput& State);
+
+	UFUNCTION(BlueprintCallable, Category="Living Plane")
+	void ResetSimulation();
+
+	UFUNCTION(BlueprintPure, Category="Living Plane")
+	int64 GetSimulationStepCount() const { return SimulationStepCount; }
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Living Plane")
+	TObjectPtr<UStaticMeshComponent> PlaneMesh;
+
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Living Plane|Rendering")
+	TObjectPtr<UMaterialInterface> PlaneMaterial;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="16", ClampMax="2048"))
+	int32 GridSize = 256;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="1.0", ClampMax="100.0"))
+	float PlaneLengthMeters = 12.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0"))
+	float WaveSpeedMetersPerSecond = 4.5f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0"))
+	float DampingPerSecond = 1.35f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0"))
+	float FoundationStiffnessPerSecondSquared = 28.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation")
+	bool bEnableBreathing = true;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0", ClampMax="30.0"))
+	float BreathingStrengthMetersPerSecondSquared = 4.8f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint")
+	bool bEnableImprint = true;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint", meta=(ClampMin="0.0", ClampMax="1.0"))
+	float ImprintCaptureMetersPerSecond = 0.15f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint", meta=(ClampMin="0.1", ClampMax="60.0"))
+	float ImprintRecoverySeconds = 6.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint", meta=(ClampMin="0.0", ClampMax="1.0"))
+	float ImprintMaxDepthMeters = 0.34f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
+	TArray<FVFLivingPlaneObjectInput> ObjectInputs;
+
+private:
+	void CreateFieldTargets();
+	void EnqueueSimulationSteps(int32 NumSteps);
+	void UpdateMaterialField();
+	float GetStableStepSeconds() const;
+
+	UPROPERTY(Transient)
+	TObjectPtr<UTextureRenderTarget2D> FieldTargets[2];
+
+	UPROPERTY(Transient)
+	TObjectPtr<UMaterialInstanceDynamic> DynamicPlaneMaterial;
+
+	int32 CurrentFieldIndex = 0;
+	int64 SimulationStepCount = 0;
+	double SimulationAccumulatorSeconds = 0.0;
+	double FixedStepSeconds = 0.0;
+};

Source/VoxelForgeLivingPlane/VoxelForgeLivingPlane.Build.cs

@@ -0,0 +1,28 @@
+using UnrealBuildTool;
+
+public class VoxelForgeLivingPlane : ModuleRules
+{
+	public VoxelForgeLivingPlane(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		if (Target.Platform == UnrealTargetPlatform.Linux)
+		{
+			bUseUnity = false;
+		}
+
+		PublicDependencyModuleNames.AddRange(new string[]
+		{
+			"Core",
+			"CoreUObject",
+			"Engine"
+		});
+
+		PrivateDependencyModuleNames.AddRange(new string[]
+		{
+			"Projects",
+			"RenderCore",
+			"RHI"
+		});
+	}
+}

Standalone/BuildLinux.sh

@@ -7,10 +7,14 @@ fi
 
 SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$SCRIPT_DIR"
+PROJECT_ROOT="$(cd -- "$ROOT/.." && pwd)"
+VERIFY_DIR="$ROOT/Tools/verify"
 COMPILER="clang++-19"
 VARIANT="clang19"
 FP_CONTRACT="off"
 JOBS=12
+SANITIZERS=""
+EXCLUDE_UNSIGNED_OVERFLOW=0
 
 while (($#)); do
     case "$1" in
@@ -18,6 +22,8 @@ while (($#)); do
         --variant=*) VARIANT="${1#*=}" ;;
         --fp-contract=*) FP_CONTRACT="${1#*=}" ;;
         --jobs=*) JOBS="${1#*=}" ;;
+        --sanitize=*) SANITIZERS="${1#*=}" ;;
+        --exclude-unsigned-integer-overflow) EXCLUDE_UNSIGNED_OVERFLOW=1 ;;
         *) printf 'Unknown build option: %s\n' "$1" >&2; exit 2 ;;
     esac
     shift
@@ -41,6 +47,15 @@ BIN_DIR="${VOXELFORGE_BIN_DIR:-$ROOT/bin/linux}"
 BUILD_DIR="$BUILD_ROOT/linux-$VARIANT"
 mkdir -p "$BUILD_DIR/wrappers" "$BUILD_DIR/objects" "$BIN_DIR"
 
+STAMP_HELPER="$VERIFY_DIR/source_stamp.py"
+STAMP_ARGS=()
+if [[ "${VOXELFORGE_INCLUDE_UNREAL_ADAPTER:-0}" == "1" ]]; then
+    STAMP_ARGS+=(--include-unreal-adapter)
+fi
+SOURCE_STAMP="$(python3 -B "$STAMP_HELPER" stamp --root "$PROJECT_ROOT" "${STAMP_ARGS[@]}")"
+python3 -B "$STAMP_HELPER" write-manifest --root "$PROJECT_ROOT" --output "$BUILD_DIR/source-manifest.txt" "${STAMP_ARGS[@]}" >/dev/null
+printf 'Source stamp: %s\n' "$SOURCE_STAMP"
+
 INCLUDES=(
     "-I$ROOT/Core/include"
     "-I$ROOT/Core/src"
@@ -49,13 +64,32 @@ INCLUDES=(
     "-I$ROOT/Source/VoxelForge/Public"
     "-I$ROOT/Source/VoxelForge/Private"
 )
+OPT_LEVEL=-O2
+LINK_FLAGS=()
+if [[ -n "$SANITIZERS" ]]; then
+    OPT_LEVEL=-O1
+    LINK_FLAGS+=("-fsanitize=$SANITIZERS" -fno-sanitize-recover=undefined)
+    if ((EXCLUDE_UNSIGNED_OVERFLOW)); then
+        LINK_FLAGS+=(-fno-sanitize=unsigned-integer-overflow)
+    fi
+fi
+
 FLAGS=(
-    -std=c++20 -O2 -mavx2 -mfma -fno-fast-math
+    -std=c++20 "$OPT_LEVEL" -mavx2 -mfma -fno-fast-math
     -fexceptions -pthread "${INCLUDES[@]}"
+    "-DVOXELFORGE_SOURCE_STAMP=\"$SOURCE_STAMP\""
 )
+FLAGS+=("${LINK_FLAGS[@]}")
 if [[ "$FP_CONTRACT" != "default" ]]; then
     FLAGS+=("-ffp-contract=$FP_CONTRACT")
 fi
+if [[ "${VOXELFORGE_PROFILE_LEGACY_TERMS:-0}" == "1" ]]; then
+    FLAGS+=(-DVF_L76_PROFILE_LEGACY_TERMS=1)
+fi
+if [[ "${VOXELFORGE_PROFILE_L77:-0}" == "1" ]]; then
+    FLAGS+=(-DVF_L77_PROFILE=1 -g)
+    LINK_FLAGS+=(-no-pie)
+fi
 if [[ "$($COMPILER --version | head -n 1)" == *clang* ]]; then
     FLAGS+=(-Wno-c++11-narrowing)
 else
@@ -112,6 +146,11 @@ 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")
+if [[ "${VOXELFORGE_PROFILE_L77:-0}" == "1" ]]; then
+    l77_profiler_object="$BUILD_DIR/objects/Linux77Profiler.o"
+    compile_background "$ROOT/Source/Linux77Profiler.cpp" "$l77_profiler_object"
+    LEGACY_OBJECTS+=("$l77_profiler_object")
+fi
 
 for pid in "${PIDS[@]}"; do wait "$pid"; done
 PIDS=()
@@ -119,11 +158,19 @@ 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" -o "$OUTPUT"
+"$COMPILER" -pthread "${LINK_FLAGS[@]}" "${LEGACY_OBJECTS[@]}" "$CORE_LIBRARY" -o "$OUTPUT"
 CAPTURE_OUTPUT="$BIN_DIR/VoxelForgeOffscreenCapture-$VARIANT"
 "$COMPILER" -std=c++20 -O2 -fno-fast-math -pthread \
+    "-DVOXELFORGE_SOURCE_STAMP=\"$SOURCE_STAMP\"" -I"$ROOT/Source" \
     "$ROOT/Source/LinuxOffscreenCapture.cpp" -o "$CAPTURE_OUTPUT" \
     $(pkg-config --cflags --libs egl glesv2 libpng)
+
+POST_BUILD_STAMP="$(python3 -B "$STAMP_HELPER" stamp --root "$PROJECT_ROOT" "${STAMP_ARGS[@]}")"
+if [[ "$POST_BUILD_STAMP" != "$SOURCE_STAMP" ]]; then
+    printf 'Source changed during build: before=%s after=%s\n' "$SOURCE_STAMP" "$POST_BUILD_STAMP" >&2
+    exit 1
+fi
 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"
+printf 'Compiler: %s | variant: %s | fp-contract: %s | sanitizers: %s | jobs: %s\n' \
+    "$COMPILER" "$VARIANT" "$FP_CONTRACT" "${SANITIZERS:-off}" "$JOBS"

Standalone/Compat/AssetRegistry/AssetData.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <AssetRegistry/AssetData.h>
+#endif

Standalone/Compat/AssetRegistry/AssetRegistryModule.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <AssetRegistry/AssetRegistryModule.h>
+#endif

Standalone/Compat/Async/ParallelFor.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Async/ParallelFor.h>
+#endif

Standalone/Compat/CoreMinimal.h

@@ -1,5 +1,10 @@
 #pragma once
 
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <CoreMinimal.h>
+#else
+
 // Deliberately small UE-style surface used by the copied VoxelForge CPU sources.
 // This is a value/container compatibility layer; it does not start or link Unreal.
 #include <algorithm>
@@ -45,6 +50,9 @@
 #define GENERATED_UCLASS_BODY()
 #define VOXELFORGE_API
 #define FORCEINLINE inline
+#ifdef WITH_EDITOR
+#undef WITH_EDITOR
+#endif
 #define WITH_EDITOR 0
 #define TRACE_CPUPROFILER_EVENT_SCOPE(...)
 #define PRAGMA_DISABLE_SHADOW_VARIABLE_WARNINGS
@@ -705,3 +713,4 @@ struct FParse
 struct FCrc { static uint32 MemCrc32(const void*Data,int32 Length,uint32 Crc=0){const auto*P=static_cast<const uint8*>(Data);uint32 V=~Crc;for(int32 I=0;I<Length;++I){V^=P[I];for(int J=0;J<8;++J)V=(V>>1)^(0xEDB88320u&static_cast<uint32>(-static_cast<int32>(V&1)));}return ~V;} static uint32 StrCrc32(const char*S,uint32 Crc=0){return MemCrc32(S,static_cast<int32>(std::strlen(S)),Crc);} };
 template<class T> using TAtomic = std::atomic<T>;
 class FThreadSafeCounter { public:int32 Increment(){return ++Value;}int32 Decrement(){return --Value;}int32 GetValue()const{return Value.load();}void Reset(){Value.store(0);}private:std::atomic<int32>Value{0};};
+#endif

Standalone/Compat/Dom/JsonObject.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Dom/JsonObject.h>
+#endif

Standalone/Compat/Dom/JsonValue.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Dom/JsonValue.h>
+#endif

Standalone/Compat/Engine/DataAsset.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Engine/DataAsset.h>
+#endif

Standalone/Compat/GameplayTagContainer.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <GameplayTagContainer.h>
+#endif

Standalone/Compat/HAL/CriticalSection.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <HAL/CriticalSection.h>
+#endif

Standalone/Compat/HAL/Event.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <HAL/Event.h>
+#endif

Standalone/Compat/HAL/FileManager.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <HAL/FileManager.h>
+#endif

Standalone/Compat/HAL/IConsoleManager.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <HAL/IConsoleManager.h>
+#endif

Standalone/Compat/HAL/PlatformProcess.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <HAL/PlatformProcess.h>
+#endif

Standalone/Compat/HAL/PlatformTime.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <HAL/PlatformTime.h>
+#endif

Standalone/Compat/Json.h

@@ -1,5 +1,10 @@
 #pragma once
 
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Json.h>
+#else
+
 #include <charconv>
 #include <cmath>
 #include <cstddef>
@@ -162,3 +167,4 @@ namespace VFJson
         return Parser(std::move(Text)).Parse(Out, Error);
     }
 }
+#endif

Standalone/Compat/Math/RandomStream.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Math/RandomStream.h>
+#endif

Standalone/Compat/Misc/CommandLine.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/CommandLine.h>
+#endif

Standalone/Compat/Misc/Crc.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/Crc.h>
+#endif

Standalone/Compat/Misc/FileHelper.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/FileHelper.h>
+#endif

Standalone/Compat/Misc/Parse.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/Parse.h>
+#endif

Standalone/Compat/Misc/Paths.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/Paths.h>
+#endif

Standalone/Compat/Misc/ScopeLock.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/ScopeLock.h>
+#endif

Standalone/Compat/Misc/ScopeRWLock.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/ScopeRWLock.h>
+#endif

Standalone/Compat/Misc/SecureHash.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Misc/SecureHash.h>
+#endif

Standalone/Compat/Modules/ModuleManager.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Modules/ModuleManager.h>
+#endif

Standalone/Compat/ProfilingDebugging/CpuProfilerTrace.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <ProfilingDebugging/CpuProfilerTrace.h>
+#endif

Standalone/Compat/Serialization/CustomVersion.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Serialization/CustomVersion.h>
+#endif

Standalone/Compat/Serialization/JsonSerializer.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Serialization/JsonSerializer.h>
+#endif

Standalone/Compat/Serialization/JsonWriter.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Serialization/JsonWriter.h>
+#endif

Standalone/Compat/Stats/Stats.h

@@ -1,4 +1,9 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Stats/Stats.h>
+#else
 #define STATCAT_Advanced 0
 #define DECLARE_STATS_GROUP(Name,Group,Category) constexpr int32 Group=0
 #define DECLARE_DWORD_COUNTER_STAT_EXTERN(Name,Stat,Group,Api) constexpr int32 Stat=0
@@ -8,3 +13,4 @@
 #define SET_DWORD_STAT(Stat,Value) ((void)0)
 #define SCOPE_CYCLE_COUNTER(Stat) ((void)0)
 #define QUICK_SCOPE_CYCLE_COUNTER(Stat) ((void)0)
+#endif

Standalone/Compat/Templates/SubclassOf.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Templates/SubclassOf.h>
+#endif

Standalone/Compat/Templates/UniquePtr.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <Templates/UniquePtr.h>
+#endif

Standalone/Compat/UObject/EnumProperty.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <UObject/EnumProperty.h>
+#endif

Standalone/Compat/UObject/FieldIterator.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <UObject/FieldIterator.h>
+#endif

Standalone/Compat/UObject/Object.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <UObject/Object.h>
+#endif

Standalone/Compat/UObject/UObjectGlobals.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <UObject/UObjectGlobals.h>
+#endif

Standalone/Compat/UObject/UnrealType.h

@@ -1 +1,6 @@
 #pragma once
+
+#if defined(VFCORE_COMPAT_FORWARD_HEADERS) && !defined(VFCORE_USE_COMPAT) \
+	&& (defined(__clang__) || defined(__GNUC__))
+#include_next <UObject/UnrealType.h>
+#endif

Standalone/Core/include/VoxelForgeCore/CpuCycleCounter.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdint>
+#include <algorithm>
+#include <limits>
+
+#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+#include <intrin.h>
+#elif defined(__i386__) || defined(__x86_64__)
+#include <immintrin.h>
+#endif
+
+namespace VoxelForgeCoreShared
+{
+    inline std::uint64_t ReadCpuCycles() noexcept
+    {
+#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+        _mm_lfence();
+        const std::uint64_t value=__rdtsc();
+        _mm_lfence();
+        return value;
+#elif defined(__i386__) || defined(__x86_64__)
+        _mm_lfence();
+        const std::uint64_t value=__rdtsc();
+        _mm_lfence();
+        return value;
+#else
+        return 0;
+#endif
+    }
+
+    inline std::uint64_t CpuCycleReadPairOverhead() noexcept
+    {
+        static const std::uint64_t overhead=[]()
+        {
+            std::uint64_t minimum=std::numeric_limits<std::uint64_t>::max();
+            for(unsigned i=0;i<64;++i)
+            {
+                const std::uint64_t start=ReadCpuCycles();
+                const std::uint64_t end=ReadCpuCycles();
+                minimum=std::min(minimum,end-start);
+            }
+            return minimum==std::numeric_limits<std::uint64_t>::max()?0:minimum;
+        }();
+        return overhead;
+    }
+
+    inline std::uint64_t AdjustedCpuCycleDelta(std::uint64_t start,
+        std::uint64_t end) noexcept
+    {
+        const std::uint64_t delta=end-start;
+        const std::uint64_t overhead=CpuCycleReadPairOverhead();
+        return delta>overhead?delta-overhead:0;
+    }
+}

Standalone/Core/include/VoxelForgeCore/FloatingIslandInstrumentation.h

@@ -0,0 +1,201 @@
+#pragma once
+
+#include "VoxelForgeCore/CpuCycleCounter.h"
+
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+
+namespace VoxelForgeCore::floating_island_detail
+{
+    enum class EIslandFieldCaller : std::uint8_t
+    {
+        GridFill=0,Skirt=1,Boundary=2,PassageFilter=3,Other=4,Count=5
+    };
+
+    enum class EIslandAttributionBucket : std::uint8_t
+    {
+        Field=0,Island=1,Root=2,Connector=3,Helix=4,Column=5,
+        LocalProbe=6,SharedCache=7,MouthFilter=8,Boundary=9,CallerGrid=10,
+        CallerSkirt=11,CallerBoundary=12,CallerPassageFilter=13,CallerOther=14,
+        Count=15
+    };
+
+    struct FIslandFieldAttributionInstrumentation
+    {
+        static constexpr std::uint64_t SampleMask=255;
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandFieldCaller::Count)> sampledFieldCalls{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandFieldCaller::Count)> fieldCycles{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandFieldCaller::Count)> fieldNanoseconds{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandFieldCaller::Count)> sampledNativeCalls{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandFieldCaller::Count)> nativeCycles{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandFieldCaller::Count)> nativeNanoseconds{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandAttributionBucket::Count)> exclusiveCycles{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandAttributionBucket::Count)> exclusiveNanoseconds{};
+        std::array<std::uint64_t,static_cast<std::size_t>(EIslandAttributionBucket::Count)> scopeSamples{};
+        std::uint64_t traceSampledMisses=0,traceSeenBefore=0,traceEvictions=0,
+            traceReusedEvictions=0;
+        std::array<std::uint64_t,8> traceSet{};
+        std::array<std::int64_t,8> traceX{},traceY{},traceEvictedX{},traceEvictedY{};
+        std::array<std::uint64_t,8> traceIsland{},traceEvictedIsland{};
+        std::array<std::uint8_t,8> traceFlags{};
+        std::size_t traceCount=0;
+    };
+
+    inline FIslandFieldAttributionInstrumentation*& ActiveIslandFieldAttribution() noexcept
+    {
+        static thread_local FIslandFieldAttributionInstrumentation* active=nullptr;
+        return active;
+    }
+
+    inline FIslandFieldAttributionInstrumentation* SetActiveIslandFieldAttribution(
+        FIslandFieldAttributionInstrumentation* value) noexcept
+    {
+        auto* previous=ActiveIslandFieldAttribution();
+        ActiveIslandFieldAttribution()=value;
+        return previous;
+    }
+
+    inline EIslandFieldCaller& ActiveIslandFieldCaller() noexcept
+    {
+        static thread_local EIslandFieldCaller caller=EIslandFieldCaller::Other;
+        return caller;
+    }
+
+    struct FScopedIslandFieldCaller
+    {
+        explicit FScopedIslandFieldCaller(EIslandFieldCaller value) noexcept
+            :previous(ActiveIslandFieldCaller()),enabled(ActiveIslandFieldAttribution()!=nullptr)
+        {if(enabled)ActiveIslandFieldCaller()=value;}
+        ~FScopedIslandFieldCaller(){if(enabled)ActiveIslandFieldCaller()=previous;}
+        EIslandFieldCaller previous;
+        bool enabled=false;
+    };
+
+    inline std::array<std::uint64_t,
+        static_cast<std::size_t>(EIslandAttributionBucket::Count)>&
+        IslandComponentSampleSequence() noexcept
+    {
+        static thread_local std::array<std::uint64_t,
+            static_cast<std::size_t>(EIslandAttributionBucket::Count)> sequence{};
+        return sequence;
+    }
+
+    inline std::array<std::uint64_t,
+        static_cast<std::size_t>(EIslandFieldCaller::Count)>&
+        IslandFieldSampleSequence() noexcept
+    {
+        static thread_local std::array<std::uint64_t,
+            static_cast<std::size_t>(EIslandFieldCaller::Count)> sequence{};
+        return sequence;
+    }
+
+    inline std::array<std::uint64_t,
+        static_cast<std::size_t>(EIslandFieldCaller::Count)>&
+        IslandNativeSampleSequence() noexcept
+    {
+        static thread_local std::array<std::uint64_t,
+            static_cast<std::size_t>(EIslandFieldCaller::Count)> sequence{};
+        return sequence;
+    }
+
+    struct FScopedIslandAttributionTimer
+    {
+        explicit FScopedIslandAttributionTimer(EIslandAttributionBucket bucket) noexcept
+            :metrics(ActiveIslandFieldAttribution()),bucketIndex(static_cast<std::size_t>(bucket))
+        {
+            if(!metrics)return;
+            if(bucketIndex==static_cast<std::size_t>(EIslandAttributionBucket::Field))
+            {
+                const auto callerIndex=static_cast<std::size_t>(ActiveIslandFieldCaller());
+                const auto calls=++IslandFieldSampleSequence()[callerIndex];
+                const std::uint64_t phase=(callerIndex*43u+17u)
+                    &FIslandFieldAttributionInstrumentation::SampleMask;
+                sampled=(((calls+phase)&FIslandFieldAttributionInstrumentation::SampleMask)==0);
+            }
+            else
+            {
+                auto& calls=IslandComponentSampleSequence()[bucketIndex];
+                ++calls;
+                const std::uint64_t phase=(static_cast<std::uint64_t>(bucketIndex)*29u+17u)
+                    &FIslandFieldAttributionInstrumentation::SampleMask;
+                sampled=(((calls+phase)&FIslandFieldAttributionInstrumentation::SampleMask)==0);
+            }
+            if(sampled)
+            {
+                start=VoxelForgeCoreShared::ReadCpuCycles();
+                wallStart=std::chrono::steady_clock::now();
+            }
+        }
+        ~FScopedIslandAttributionTimer(){Stop();}
+        std::uint64_t Stop() noexcept
+        {
+            if(!sampled)return 0;
+            sampled=false;
+            const std::uint64_t raw=VoxelForgeCoreShared::ReadCpuCycles()-start;
+            const std::uint64_t overhead=VoxelForgeCoreShared::CpuCycleReadPairOverhead();
+            const std::uint64_t cycles=raw>overhead?raw-overhead:0;
+            const auto elapsed=std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::steady_clock::now()-wallStart).count();
+            metrics->exclusiveCycles[bucketIndex]+=cycles;
+            metrics->exclusiveNanoseconds[bucketIndex]+=elapsed>0
+                ?static_cast<std::uint64_t>(elapsed):0;
+            ++metrics->scopeSamples[bucketIndex];
+            if(bucketIndex==static_cast<std::size_t>(EIslandAttributionBucket::Field))
+            {
+                const std::size_t callerIndex=static_cast<std::size_t>(ActiveIslandFieldCaller());
+                metrics->fieldCycles[callerIndex]+=cycles;
+                metrics->fieldNanoseconds[callerIndex]+=elapsed>0
+                    ?static_cast<std::uint64_t>(elapsed):0;
+                ++metrics->sampledFieldCalls[callerIndex];
+            }
+            return cycles;
+        }
+        FIslandFieldAttributionInstrumentation* metrics=nullptr;
+        std::size_t bucketIndex=0;
+        std::uint64_t start=0;
+        std::chrono::steady_clock::time_point wallStart{};
+        bool sampled=false;
+    };
+
+    struct FScopedIslandAttributionSample
+    {
+        explicit FScopedIslandAttributionSample() noexcept
+        {
+            auto* attribution=ActiveIslandFieldAttribution();
+            if(!attribution)return;
+            const auto caller=ActiveIslandFieldCaller();
+            const std::size_t callerIndex=static_cast<std::size_t>(caller);
+            const std::uint64_t sequence=++IslandNativeSampleSequence()[callerIndex];
+            const std::uint64_t phase=(callerIndex*43u+93u)
+                &FIslandFieldAttributionInstrumentation::SampleMask;
+            if(((sequence+phase)&FIslandFieldAttributionInstrumentation::SampleMask)!=0)return;
+            sampledAttribution=attribution;
+            sampledCaller=caller;
+            sampled=true;
+            start=VoxelForgeCoreShared::ReadCpuCycles();
+            wallStart=std::chrono::steady_clock::now();
+            ++attribution->sampledNativeCalls[callerIndex];
+        }
+        ~FScopedIslandAttributionSample()
+        {
+            if(!sampled)return;
+            const std::uint64_t raw=VoxelForgeCoreShared::ReadCpuCycles()-start;
+            const std::uint64_t overhead=VoxelForgeCoreShared::CpuCycleReadPairOverhead();
+            const std::uint64_t duration=raw>overhead?raw-overhead:0;
+            const auto elapsed=std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::steady_clock::now()-wallStart).count();
+            const std::size_t callerIndex=static_cast<std::size_t>(sampledCaller);
+            sampledAttribution->nativeCycles[callerIndex]+=duration;
+            sampledAttribution->nativeNanoseconds[callerIndex]+=elapsed>0
+                ?static_cast<std::uint64_t>(elapsed):0;
+        }
+        FIslandFieldAttributionInstrumentation* sampledAttribution=nullptr;
+        EIslandFieldCaller sampledCaller=EIslandFieldCaller::Other;
+        std::uint64_t start=0;
+        std::chrono::steady_clock::time_point wallStart{};
+        bool sampled=false;
+    };
+
+}

Standalone/Core/include/VoxelForgeCore/Linux77Profiler.h

@@ -0,0 +1,159 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+
+namespace VoxelForgeCore::Linux77Profiler
+{
+    enum class ERoute : std::uint8_t
+    {
+        Dispatch=0,PackedScalar=1,PackedX8=2,AnalyticScalar=3,
+        AnalyticBatch=4,Native=5,LegacySurface=6,SharedSource=7,Count=8
+    };
+    enum class EStage : std::uint8_t
+    {
+        Other=0,GridFill=1,MarchingCubes=2,Skirt=3,Refine=4,Count=5
+    };
+    enum class EPhase : std::uint8_t
+    {
+        Dispatch=0,BaseField=1,CompositionGraph=2,Bands=3,Passage=4,
+        Support=5,Caps=6,Stamps=7,Edit=8,Other=9,Count=10
+    };
+    inline constexpr std::size_t RouteCount=static_cast<std::size_t>(ERoute::Count);
+    inline constexpr std::size_t StageCount=static_cast<std::size_t>(EStage::Count);
+    inline constexpr std::size_t PhaseCount=static_cast<std::size_t>(EPhase::Count);
+    inline thread_local bool ThreadContextActive=false;
+
+    struct FThreadContext
+    {
+        std::uint8_t lod=0xff;
+        ERoute route=ERoute::Count;
+        EStage stage=EStage::Other;
+        EPhase phase=EPhase::Other;
+        bool halo=false;
+    };
+
+#if defined(VF_L77_PROFILE)
+    bool IsEnabled() noexcept;
+    void SetEnabled(bool enabled) noexcept;
+    void RegisterThread();
+    void Start(std::uint32_t periodMicroseconds=1000);
+    void StopAndPrint();
+    inline thread_local FThreadContext CurrentContext{};
+
+    struct FScopedRoute
+    {
+        explicit FScopedRoute(ERoute value) noexcept
+            :active(ThreadContextActive),previous(CurrentContext.route)
+        {if(active)CurrentContext.route=value;}
+        ~FScopedRoute(){if(active)CurrentContext.route=previous;}
+        bool active=false;ERoute previous=ERoute::Dispatch;
+    };
+    struct FScopedStage
+    {
+        explicit FScopedStage(EStage value) noexcept
+            :active(ThreadContextActive),previous(CurrentContext.stage)
+        {if(active)CurrentContext.stage=value;}
+        ~FScopedStage(){Restore();}
+        void Restore() noexcept
+        {if(active){CurrentContext.stage=previous;active=false;}}
+        bool active=false;EStage previous=EStage::Other;
+    };
+    struct FScopedPhase
+    {
+        explicit FScopedPhase(EPhase value) noexcept
+            :active(ThreadContextActive),previous(CurrentContext.phase)
+        {if(active)CurrentContext.phase=value;}
+        ~FScopedPhase(){if(active)CurrentContext.phase=previous;}
+        bool active=false;EPhase previous=EPhase::Dispatch;
+    };
+    struct FScopedLod
+    {
+        explicit FScopedLod(int value) noexcept
+            :active(IsEnabled()),previous(CurrentContext.lod),previousContextActive(ThreadContextActive)
+        {
+            if(active)
+            {
+                ThreadContextActive=true;
+                RegisterThread();
+                CurrentContext.lod=static_cast<std::uint8_t>(value<0||value>8?0xff:value);
+            }
+        }
+        ~FScopedLod()
+        {if(active){CurrentContext.lod=previous;ThreadContextActive=previousContextActive;}}
+        bool active=false;std::uint8_t previous=0xff;
+        bool previousContextActive=false;
+    };
+    struct FScopedHalo
+    {
+        explicit FScopedHalo(bool value) noexcept
+            :active(ThreadContextActive),previous(CurrentContext.halo)
+        {if(active)CurrentContext.halo=value;}
+        ~FScopedHalo(){if(active)CurrentContext.halo=previous;}
+        bool active=false;bool previous=false;
+    };
+#else
+    inline bool IsEnabled() noexcept{return false;}
+    inline void SetEnabled(bool) noexcept{}
+    inline void RegisterThread(){}
+    inline void Start(std::uint32_t=1000){}
+    inline void StopAndPrint(){}
+    struct FScopedRoute{explicit FScopedRoute(ERoute) noexcept{}};
+    struct FScopedStage
+    {explicit FScopedStage(EStage) noexcept{}void Restore() noexcept{}};
+    struct FScopedPhase{explicit FScopedPhase(EPhase) noexcept{}};
+    struct FScopedLod{explicit FScopedLod(int) noexcept{}};
+    struct FScopedHalo{explicit FScopedHalo(bool) noexcept{}};
+#endif
+
+    struct FDispatchCounter
+    {
+        std::uint64_t calls=0;
+        std::uint64_t points=0;
+    };
+    using FDispatchCounters=std::array<std::array<FDispatchCounter,RouteCount>,StageCount>;
+
+    inline const char* RouteName(ERoute value) noexcept
+    {
+        switch(value)
+        {
+            case ERoute::Dispatch:return "dispatch_lookup";
+            case ERoute::PackedScalar:return "packed_scalar";
+            case ERoute::PackedX8:return "packed_x8";
+            case ERoute::AnalyticScalar:return "analytic_scalar";
+            case ERoute::AnalyticBatch:return "analytic_batch";
+            case ERoute::Native:return "native";
+            case ERoute::LegacySurface:return "legacy_surface";
+            case ERoute::SharedSource:return "shared_source";
+            default:return "unknown";
+        }
+    }
+    inline const char* StageName(EStage value) noexcept
+    {
+        switch(value)
+        {
+            case EStage::GridFill:return "grid_fill";
+            case EStage::MarchingCubes:return "marching_cubes";
+            case EStage::Skirt:return "skirt";
+            case EStage::Refine:return "refine";
+            default:return "other";
+        }
+    }
+    inline const char* PhaseName(EPhase value) noexcept
+    {
+        switch(value)
+        {
+            case EPhase::Dispatch:return "dispatch_lookup";
+            case EPhase::BaseField:return "base_field";
+            case EPhase::CompositionGraph:return "composition_graph";
+            case EPhase::Bands:return "composition_bands";
+            case EPhase::Passage:return "passages";
+            case EPhase::Support:return "support";
+            case EPhase::Caps:return "caps";
+            case EPhase::Stamps:return "stamps";
+            case EPhase::Edit:return "edits";
+            default:return "other";
+        }
+    }
+}

Standalone/Core/include/VoxelForgeCore/PassageSpline.h

@@ -0,0 +1,255 @@
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <span>
+#include <vector>
+
+namespace VoxelForgeCore::PassageSpline
+{
+    using FPoint = std::array<double,4>;
+    inline constexpr std::size_t ArcTableSteps = 32;
+    inline constexpr double UpperMouthFloorBlendRadiusMetres = 3.5;
+
+    struct FSegment
+    {
+        FPoint a{},b{};
+        double alongMetres=0.0,lengthMetres=0.0;
+        std::size_t controlSpan=0;
+        double tA=0.0,tB=1.0;
+        double plannedFloorA=0.0,plannedFloorB=0.0;
+    };
+
+    inline double KnotSpan(const FPoint& a,const FPoint& b,double unitsPerMetre)
+    {
+        const double dx=(b[0]-a[0])/unitsPerMetre;
+        const double dy=(b[1]-a[1])/unitsPerMetre;
+        return std::max(1.0e-6,std::sqrt(std::sqrt(dx*dx+dy*dy)));
+    }
+
+    inline FPoint EvaluateRaw(std::span<const FPoint> controls,std::size_t span,
+        double t,double unitsPerMetre)
+    {
+        const auto& p1=controls[span];
+        const auto& p2=controls[span+1];
+        const auto& p0=controls[span==0?0:span-1];
+        const auto& p3=controls[std::min(span+2,controls.size()-1)];
+        const double dt0=KnotSpan(p0,p1,unitsPerMetre);
+        const double dt1=KnotSpan(p1,p2,unitsPerMetre);
+        const double dt2=KnotSpan(p2,p3,unitsPerMetre);
+        const double t2=t*t,t3=t2*t;
+        FPoint result{};
+        for(const std::size_t axis:{0u,1u,3u})
+        {
+            const double m1=dt1*((p1[axis]-p0[axis])/dt0
+                -(p2[axis]-p0[axis])/(dt0+dt1)
+                +(p2[axis]-p1[axis])/dt1);
+            const double m2=dt1*((p2[axis]-p1[axis])/dt1
+                -(p3[axis]-p1[axis])/(dt1+dt2)
+                +(p3[axis]-p2[axis])/dt2);
+            result[axis]=(2.0*t3-3.0*t2+1.0)*p1[axis]
+                +(-2.0*t3+3.0*t2)*p2[axis]
+                +(t3-2.0*t2+t)*m1+(t3-t2)*m2;
+        }
+        result[2]=std::lerp(p1[2],p2[2],t);
+        result[3]=std::clamp(result[3],std::min(p1[3],p2[3]),
+            std::max(p1[3],p2[3]));
+        return result;
+    }
+
+    inline bool ClosestRouteHeightAtXY(std::span<const std::array<double,3>> route,
+        double x,double y,double& height,double& distanceSquared)
+    {
+        if(route.empty())return false;
+        distanceSquared=std::numeric_limits<double>::infinity();
+        const auto consider=[&](const std::array<double,3>& point)
+        {
+            const double dx=x-point[0],dy=y-point[1];
+            const double candidate=dx*dx+dy*dy;
+            if(candidate<distanceSquared)
+            {distanceSquared=candidate;height=point[2];}
+        };
+        if(route.size()==1)
+        {
+            consider(route.front());
+            return true;
+        }
+        for(std::size_t i=1;i<route.size();++i)
+        {
+            const auto& a=route[i-1];
+            const auto& b=route[i];
+            const double dx=b[0]-a[0],dy=b[1]-a[1];
+            const double lengthSquared=dx*dx+dy*dy;
+            const double t=lengthSquared>1.0e-12
+                ?std::clamp(((x-a[0])*dx+(y-a[1])*dy)/lengthSquared,0.0,1.0):0.0;
+            const std::array<double,3> point={a[0]+t*dx,a[1]+t*dy,
+                std::lerp(a[2],b[2],t)};
+            consider(point);
+        }
+        return std::isfinite(distanceSquared);
+    }
+
+    inline double BlendUpperMouthFloorAtXY(
+        std::span<const std::array<double,3>> receivingRoute,double x,double y,
+        double plannedFloor,double mouthX,double mouthY,double mouthFloor,
+        double tangentX,double tangentY,
+        double blendRadiusMetres,double playerCenterAboveFloorMetres,
+        double unitsPerMetre=1.0)
+    {
+        if(receivingRoute.empty()||!(blendRadiusMetres>0.0)
+            ||!(unitsPerMetre>0.0))return plannedFloor;
+        const double dx=(x-mouthX)/unitsPerMetre;
+        const double dy=(y-mouthY)/unitsPerMetre;
+        if(dx*tangentX+dy*tangentY>=0.0)return plannedFloor;
+        const double dz=(plannedFloor-mouthFloor)/unitsPerMetre;
+        const double distance=std::sqrt(dx*dx+dy*dy+dz*dz);
+        double routeHeight=0.0,routeDistanceSquared=0.0;
+        if(distance>blendRadiusMetres
+            ||!ClosestRouteHeightAtXY(receivingRoute,x,y,routeHeight,
+                routeDistanceSquared)
+            ||routeDistanceSquared>std::pow(2.0*blendRadiusMetres*unitsPerMetre,2.0))
+            return plannedFloor;
+        const double t=std::clamp(distance/blendRadiusMetres,0.0,1.0);
+        const double blend=t*t*(3.0-2.0*t);
+        const double receivingFloor=routeHeight
+            -playerCenterAboveFloorMetres*unitsPerMetre;
+        return std::lerp(plannedFloor,receivingFloor,blend);
+    }
+
+    inline std::vector<FSegment> BuildSegments(std::span<const FPoint> controls,
+        std::size_t spanCount,double spacingMetres,double unitsPerMetre=1.0,
+        std::span<const double> plannedFloorProfile={},
+        double maximumChordErrorMetres=0.0)
+    {
+        std::vector<FSegment> result;
+        if(controls.size()<2||!(spacingMetres>0.0)||!(unitsPerMetre>0.0))return result;
+        spanCount=std::min(spanCount,controls.size()-1);
+        double alongMetres=0.0;
+        for(std::size_t span=0;span<spanCount;++span)
+        {
+            std::array<double,ArcTableSteps+1> horizontalArc{};
+            auto previous=EvaluateRaw(controls,span,0.0,unitsPerMetre);
+            for(std::size_t step=1;step<=ArcTableSteps;++step)
+            {
+                const auto current=EvaluateRaw(controls,span,
+                    static_cast<double>(step)/ArcTableSteps,unitsPerMetre);
+                const double dx=(current[0]-previous[0])/unitsPerMetre;
+                const double dy=(current[1]-previous[1])/unitsPerMetre;
+                horizontalArc[step]=horizontalArc[step-1]+std::sqrt(dx*dx+dy*dy);
+                previous=current;
+            }
+            const double spanLength=horizontalArc.back();
+            const std::size_t baseSegmentCount=std::max<std::size_t>(1,
+                static_cast<std::size_t>(std::ceil(spanLength/spacingMetres)));
+            std::vector<FPoint> points;
+            std::vector<double> parameters;
+            points.reserve(baseSegmentCount+1);
+            parameters.reserve(baseSegmentCount+1);
+            const auto parameterAtArc=[&](double targetArc)
+            {
+                const auto upper=std::lower_bound(horizontalArc.begin()+1,
+                    horizontalArc.end(),targetArc);
+                const std::size_t upperIndex=static_cast<std::size_t>(
+                    upper-horizontalArc.begin());
+                const std::size_t lowerIndex=upperIndex-1;
+                const double arcSpan=horizontalArc[upperIndex]-horizontalArc[lowerIndex];
+                const double arcT=arcSpan>1.0e-12
+                    ?std::clamp((targetArc-horizontalArc[lowerIndex])/arcSpan,0.0,1.0):0.0;
+                return (static_cast<double>(lowerIndex)+arcT)/ArcTableSteps;
+            };
+            parameters.push_back(0.0);
+            const double chordError=std::max(0.0,maximumChordErrorMetres);
+            const auto appendAdaptive=[&](auto&& self,double tA,double tB,
+                const FPoint& a,const FPoint& b,unsigned depth)->void
+            {
+                constexpr std::array<double,3> CheckFractions={0.25,0.5,0.75};
+                double maximumError=0.0,polylineLength=0.0;
+                FPoint previous=a;
+                for(const double fraction:CheckFractions)
+                {
+                    const FPoint current=EvaluateRaw(controls,span,
+                        std::lerp(tA,tB,fraction),unitsPerMetre);
+                    const double chordX=std::lerp(a[0],b[0],fraction);
+                    const double chordY=std::lerp(a[1],b[1],fraction);
+                    const double dx=(current[0]-chordX)/unitsPerMetre;
+                    const double dy=(current[1]-chordY)/unitsPerMetre;
+                    const double dr=(current[3]-std::lerp(a[3],b[3],fraction))
+                        /unitsPerMetre;
+                    maximumError=std::max(maximumError,
+                        std::sqrt(dx*dx+dy*dy+dr*dr));
+                    const double segmentX=(current[0]-previous[0])/unitsPerMetre;
+                    const double segmentY=(current[1]-previous[1])/unitsPerMetre;
+                    polylineLength+=std::sqrt(segmentX*segmentX+segmentY*segmentY);
+                    previous=current;
+                }
+                const double finalX=(b[0]-previous[0])/unitsPerMetre;
+                const double finalY=(b[1]-previous[1])/unitsPerMetre;
+                polylineLength+=std::sqrt(finalX*finalX+finalY*finalY);
+                const bool split=(polylineLength>spacingMetres*(1.0+1.0e-9)
+                    ||(chordError>0.0&&maximumError>chordError))&&depth<12;
+                if(split)
+                {
+                    const double tMid=(tA+tB)*0.5;
+                    const FPoint middle=EvaluateRaw(controls,span,tMid,unitsPerMetre);
+                    self(self,tA,tMid,a,middle,depth+1);
+                    self(self,tMid,tB,middle,b,depth+1);
+                    return;
+                }
+                parameters.push_back(tB);
+            };
+            for(std::size_t segment=1;segment<=baseSegmentCount;++segment)
+            {
+                const double targetA=spanLength*static_cast<double>(segment-1)
+                    /baseSegmentCount;
+                const double targetB=spanLength*static_cast<double>(segment)
+                    /baseSegmentCount;
+                const double tA=parameterAtArc(targetA);
+                const double tB=parameterAtArc(targetB);
+                const FPoint a=EvaluateRaw(controls,span,tA,unitsPerMetre);
+                const FPoint b=EvaluateRaw(controls,span,tB,unitsPerMetre);
+                appendAdaptive(appendAdaptive,tA,tB,a,b,0);
+            }
+            points.reserve(parameters.size());
+            for(const double t:parameters)
+                points.push_back(EvaluateRaw(controls,span,t,unitsPerMetre));
+            std::vector<double> sampledHorizontalArc(points.size(),0.0);
+            for(std::size_t i=1;i<points.size();++i)
+            {
+                const double dx=(points[i][0]-points[i-1][0])/unitsPerMetre;
+                const double dy=(points[i][1]-points[i-1][1])/unitsPerMetre;
+                sampledHorizontalArc[i]=sampledHorizontalArc[i-1]
+                    +std::sqrt(dx*dx+dy*dy);
+            }
+            const double sampledSpanLength=sampledHorizontalArc.back();
+            for(std::size_t i=0;i<points.size();++i)
+            {
+                const double progress=sampledSpanLength>1.0e-12
+                    ?sampledHorizontalArc[i]/sampledSpanLength:parameters[i];
+                points[i][2]=std::lerp(controls[span][2],controls[span+1][2],progress);
+            }
+            for(std::size_t i=1;i<points.size();++i)
+            {
+                const double dx=(points[i][0]-points[i-1][0])/unitsPerMetre;
+                const double dy=(points[i][1]-points[i-1][1])/unitsPerMetre;
+                const double dz=(points[i][2]-points[i-1][2])/unitsPerMetre;
+                const double length=std::sqrt(dx*dx+dy*dy+dz*dz);
+                const auto floorAt=[&](std::size_t index)
+                {
+                    if(plannedFloorProfile.size()!=controls.size())
+                        return points[index][2];
+                    const double progress=sampledSpanLength>1.0e-12
+                        ?sampledHorizontalArc[index]/sampledSpanLength:parameters[index];
+                    return std::lerp(plannedFloorProfile[span],
+                        plannedFloorProfile[span+1],progress);
+                };
+                result.push_back({points[i-1],points[i],alongMetres,length,span,
+                    parameters[i-1],parameters[i],floorAt(i-1),floorAt(i)});
+                alongMetres+=length;
+            }
+        }
+        return result;
+    }
+}

Standalone/Core/include/VoxelForgeCore/SharedColumnCache.h

@@ -1,9 +1,12 @@
 #pragma once
 
+#include "VoxelForgeCore/CpuCycleCounter.h"
+
 #include <array>
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <chrono>
 #include <cstring>
 #include <memory>
 #include <thread>
@@ -12,6 +15,23 @@
 
 namespace VoxelForgeCoreShared
 {
+    struct FColumnCacheMetrics
+    {
+        std::uint64_t hits = 0;
+        std::uint64_t misses = 0;
+        std::uint64_t computes = 0;
+        std::uint64_t conflictReplacements = 0;
+        std::uint64_t lockWaitNanoseconds = 0;
+        std::uint64_t sampledInitialReadCycles = 0;
+        std::uint64_t sampledInitialReads = 0;
+        std::uint64_t sampledLockedReadCycles = 0;
+        std::uint64_t sampledLockedReads = 0;
+        std::uint64_t sampledLockCycles = 0;
+        std::uint64_t sampledLocks = 0;
+        std::uint64_t sampledBuildCycles = 0;
+        std::uint64_t sampledBuilds = 0;
+    };
+
     // 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
@@ -69,13 +89,28 @@ namespace VoxelForgeCoreShared
 
         struct FSpinGuard
         {
-            explicit FSpinGuard(std::atomic_flag& value) : Flag(value)
+            explicit FSpinGuard(std::atomic_flag& value, FColumnCacheMetrics* metrics,
+                bool sampleCycles)
+                : Flag(value), Metrics(metrics)
             {
+                const auto started = Metrics ? std::chrono::steady_clock::now()
+                    : std::chrono::steady_clock::time_point{};
+                const std::uint64_t cycleStart=sampleCycles?ReadCpuCycles():0;
                 while (Flag.test_and_set(std::memory_order_acquire))
                     std::this_thread::yield();
+                if (Metrics)
+                    Metrics->lockWaitNanoseconds += static_cast<std::uint64_t>(
+                        std::chrono::duration_cast<std::chrono::nanoseconds>(
+                            std::chrono::steady_clock::now() - started).count());
+                if(sampleCycles)
+                {
+                    Metrics->sampledLockCycles+=AdjustedCpuCycleDelta(cycleStart,ReadCpuCycles());
+                    ++Metrics->sampledLocks;
+                }
             }
             ~FSpinGuard() { Flag.clear(std::memory_order_release); }
             std::atomic_flag& Flag;
+            FColumnCacheMetrics* Metrics;
         };
 
     public:
@@ -94,7 +129,7 @@ namespace VoxelForgeCoreShared
 
         template <typename TFactory>
         TValue getOrCompute(const FColumnCacheKey& key, TFactory&& factory,
-            bool& computed)
+            bool& computed, FColumnCacheMetrics* metrics = nullptr)
         {
             computed = false;
             const FKeyWords keyWords = key.words();
@@ -102,13 +137,47 @@ namespace VoxelForgeCoreShared
             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;
+            static thread_local std::uint64_t timingSequence=0;
+            const bool sampleCycles=metrics&&((++timingSequence&127u)==0);
+            const std::uint64_t initialReadStart=sampleCycles?ReadCpuCycles():0;
+            const bool initialHit=TryReadSet(set, keyWords, tag, value);
+            if(sampleCycles)
+            {
+                metrics->sampledInitialReadCycles+=AdjustedCpuCycleDelta(
+                    initialReadStart,ReadCpuCycles());
+                ++metrics->sampledInitialReads;
+            }
+            if (initialHit)
+            {
+                if (metrics) ++metrics->hits;
+                return value;
+            }
+            if (metrics) ++metrics->misses;
 
-            FSpinGuard lock(set.Writer);
-            if (TryReadSet(set, keyWords, tag, value)) return value;
+            FSpinGuard lock(set.Writer, metrics,sampleCycles);
+            const std::uint64_t lockedReadStart=sampleCycles?ReadCpuCycles():0;
+            const bool lockedHit=TryReadSet(set, keyWords, tag, value);
+            if(sampleCycles)
+            {
+                metrics->sampledLockedReadCycles+=AdjustedCpuCycleDelta(
+                    lockedReadStart,ReadCpuCycles());
+                ++metrics->sampledLockedReads;
+            }
+            if (lockedHit)
+            {
+                if (metrics) ++metrics->hits;
+                return value;
+            }
 
+            const std::uint64_t buildStart=sampleCycles?ReadCpuCycles():0;
             value = std::forward<TFactory>(factory)();
+            if(sampleCycles)
+            {
+                metrics->sampledBuildCycles+=AdjustedCpuCycleDelta(buildStart,ReadCpuCycles());
+                ++metrics->sampledBuilds;
+            }
             computed = true;
+            if (metrics) ++metrics->computes;
             FValueWords valueWords{};
             std::memcpy(valueWords.data(), &value, sizeof(TValue));
 
@@ -118,6 +187,7 @@ namespace VoxelForgeCoreShared
                 { replacement = way; break; }
             if (replacement == Ways)
             {
+                if (metrics) ++metrics->conflictReplacements;
                 replacement = set.NextWay;
                 set.NextWay = static_cast<std::uint8_t>((set.NextWay + 1) % Ways);
             }

Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h

@@ -11,6 +11,9 @@
 #include <utility>
 #include <vector>
 
+#include "VoxelForgeCore/Linux77Profiler.h"
+#include "VoxelForgeCore/PassageSpline.h"
+
 // UBT supplies this export/import macro for the runtime module. The standalone target has no
 // module boundary, so leave it empty there. UBT fournit la macro; le viewer autonome reste neutre.
 #ifndef VOXELFORGECORE_API
@@ -81,6 +84,9 @@ namespace VoxelForgeCore
         Vec3d normal;
         Vec2f uv;
         ColorRgba8 color;
+        std::uint16_t hostMaterialId = 1;
+        std::array<std::uint16_t, 2> resourceMaterialIds{};
+        std::array<std::uint16_t, 2> resourceWeightsQ16{};
     };
 
     struct MeshGroups
@@ -128,14 +134,97 @@ namespace VoxelForgeCore
         std::uint64_t mixedBoxes = 0;
         std::uint64_t unknownBoxes = 0;
         std::uint64_t fieldCalls = 0;
+        // Opt-in composer diagnostics. These stay zero during ordinary generation.
+        bool passageComposerProfiled = false;
+        std::uint64_t passageTileFeatureCount = 0;
+        std::uint64_t passageTileRouteSegmentCandidates = 0;
+        std::uint64_t resolvedBoundaryBandQueries = 0;
+        std::uint64_t passageComposerQueries = 0;
+        std::uint64_t passageIterations = 0;
+        std::uint64_t passageCarveSegmentVisits = 0;
+        std::uint64_t passageReliefFieldCalls = 0;
+        // L99 tile-local swept-tube base and detail passes. These are populated only
+        // by the opt-in passage composer profile, except the mesh composition itself.
+        std::uint64_t passageSweepRouteSegmentCandidates = 0;
+        std::uint64_t passageSweepSegmentSamplePairs = 0;
+        std::uint64_t passageSweepPrepareNanoseconds = 0;
+        std::uint64_t passageSweepOutsideInfluencePairs = 0;
+        std::uint64_t passageSweepShellSupportSkips = 0;
+        std::uint64_t passageSweepMinimumUpdates = 0;
+        std::uint64_t passageSweepBaseInfluenceSamples = 0;
+        std::uint64_t passageSweepDetailShellSamples = 0;
+        std::uint64_t passageSweepGridSamples = 0;
+        std::uint64_t passageSweepNoInfluenceGridSamples = 0;
+        std::uint64_t passageSweepTouchedSamples = 0;
+        std::uint64_t passageSweepStampedOutsideSamples = 0;
+        std::uint64_t passageSweepCacheValidSamples = 0;
+        std::uint64_t passageSweepCacheValidUniqueSamples = 0;
+        std::uint64_t passageSweepUniqueTouchedSamples = 0;
+        std::uint64_t passageSweepBodyBandSamples = 0;
+        std::uint64_t passageSweepShellBandSamples = 0;
+        std::uint64_t passageSweepUniqueBandSamples = 0;
+        std::uint64_t passageSweepOverlapPairs = 0;
+        std::uint64_t passageSweepContributingPairs = 0;
+        std::uint64_t passageSweepCrossPassageOverlaps = 0;
+        std::uint64_t passageSweepFloorProfileCalls = 0;
+        std::uint64_t passageSweepAllocatedBytes = 0;
+        std::uint64_t passageSweepPrepareScratchBytes = 0;
+        std::uint64_t passageSweepLookups = 0;
+        std::uint64_t passageSweepCacheHits = 0;
+        std::uint64_t passageSweepBaseInfluenceHits = 0;
+        std::uint64_t passageSweepOutOfInfluenceHits = 0;
+        std::uint64_t passageSweepMissingSamples = 0;
+        std::uint64_t passageSweepOffGridMisses = 0;
+        std::uint64_t passageSweepUnpreparedMisses = 0;
+        std::array<std::uint64_t,12> passageSweepMissingLookupsByCaller{};
+        std::array<std::uint64_t,12> passageSweepExactRouteFallbacksByCaller{};
+        std::array<std::uint64_t,12> passageSweepFeatureBoundSkipsByCaller{};
+        std::array<std::uint64_t,12> passageSweepTileFreeSkipsByCaller{};
+        std::array<std::uint64_t,12> passageSweepVerticalBoundSkipsByCaller{};
+        std::array<std::uint64_t,12> passageSweepNegativeReachSkipsByCaller{};
+        std::array<std::uint64_t,12> passageSweepPositiveReachSkipsByCaller{};
         std::uint64_t floatFieldCalls = 0;
         std::uint64_t latticeFieldCalls = 0;
         std::uint64_t unclampedFieldCalls = 0;
+        std::uint64_t densityPointCalls = 0;
+        std::uint64_t densityFloatPointCalls = 0;
+        std::uint64_t densityLatticePointCalls = 0;
+        std::uint64_t densityUnclampedPointCalls = 0;
+        std::array<std::uint64_t,12> densityOffGridFloatByCaller{};
+        std::array<std::uint64_t,12> densityOffGridUnclampedByCaller{};
+        std::array<std::uint64_t,12> densityOffGridDetailByCaller{};
+        std::uint64_t densityX8PointCalls = 0;
+        std::uint64_t densityFieldEvalNanoseconds = 0;
+        std::uint64_t densityFieldEvalSamplePoints = 0;
+        std::uint64_t legacyFieldEvalCalls = 0;
+        std::array<std::uint64_t,9> legacyFieldTermCalls{};
+        std::array<std::uint64_t,9> legacyFieldTermNanoseconds{};
+        std::array<std::uint64_t,9> legacyFieldTermTimedCalls{};
+        // Linux77-only mutually-exclusive route counts, flattened as
+        // (stage * route_count + route) * 2 + {calls,points}.
+        std::array<std::uint64_t,
+            VoxelForgeCore::Linux77Profiler::StageCount
+                *VoxelForgeCore::Linux77Profiler::RouteCount*2> linux77DispatchCounters{};
+        std::uint64_t linux77GridInteriorSamples = 0;
+        std::uint64_t linux77GridHaloSamples = 0;
+        std::uint64_t legacyPrimitiveCandidateVisits = 0;
+        std::uint64_t legacyPrimitiveDistanceEvaluations = 0;
+        std::uint64_t legacySmoothMinCalls = 0;
+        std::uint64_t legacySmoothMinNanoseconds = 0;
+        std::uint64_t legacySmoothMinTimedCalls = 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 islandLocalCacheHits = 0;
+        std::uint64_t islandLocalCacheMisses = 0;
+        std::uint64_t islandLocalCacheConflictReplacements = 0;
+        std::uint64_t islandSharedCacheHits = 0;
+        std::uint64_t islandSharedCacheMisses = 0;
+        std::uint64_t islandSharedCacheComputes = 0;
+        std::uint64_t islandSharedCacheConflictReplacements = 0;
+        std::uint64_t islandSharedCacheLockWaitNanoseconds = 0;
         std::uint64_t uniformBlockProofsChecked = 0;
         std::uint64_t uniformBlockProofSamplesChecked = 0;
         std::uint64_t uniformBlockProofFallbackBlocks = 0;
@@ -150,6 +239,7 @@ namespace VoxelForgeCore
         double classificationExclusiveMilliseconds = 0.0;
         double marchingCubesExclusiveMilliseconds = 0.0;
         double marchingCubesDensityGridMilliseconds = 0.0;
+        std::uint32_t marchingCubesGridFillWorkers = 1;
         double marchingCubesCellClassificationMilliseconds = 0.0;
         double marchingCubesGradientNormalsMilliseconds = 0.0;
         double marchingCubesEdgeInterpolationMilliseconds = 0.0;
@@ -157,12 +247,32 @@ namespace VoxelForgeCore
         double marchingCubesSkirtMilliseconds = 0.0;
         double marchingCubesOtherMilliseconds = 0.0;
         std::uint64_t marchingCubesGradientFallbackDensityCalls = 0;
+        std::uint64_t marchingCubesGradientCalls = 0;
         std::uint64_t marchingCubesEdgeMidpointDensityCalls = 0;
+        std::uint64_t marchingCubesEdgeMidpointDensityMemoHits = 0;
         std::uint64_t marchingCubesGradientMemoHits = 0;
+        std::uint64_t marchingCubesX8DensityCalls = 0;
+        std::uint64_t marchingCubesX8ActiveLanes = 0;
+        std::uint64_t marchingCubesCandidateCells = 0;
+        std::uint64_t marchingCubesZBandRejectedCells = 0;
+        std::uint64_t marchingCubesCellClassificationCalls = 0;
+        std::uint64_t marchingCubesSurfaceCellCalls = 0;
+        std::uint64_t marchingCubesProofSkippedSolidCells = 0;
+        std::uint64_t marchingCubesProofSkippedAirCells = 0;
+        std::uint64_t marchingCubesProofSkippedDensitySamples = 0;
+        std::uint64_t marchingCubesSkirtEdgeCandidates = 0;
+        std::uint64_t marchingCubesSkirtBoundaryCandidates = 0;
+        std::uint64_t marchingCubesSkirtDensityProbes = 0;
+        std::array<std::uint64_t,5> marchingCubesSkirtDensityProbesByCaller{};
+        std::array<std::uint64_t,5> marchingCubesSkirtDensityOffGridProbesByCaller{};
         double groundRefinementExclusiveMilliseconds = 0.0;
         double capRefinementExclusiveMilliseconds = 0.0;
         double meshAssemblyMilliseconds = 0.0;
         double meshingMilliseconds = 0.0;
+        double materialQueryMilliseconds = 0.0;
+        std::uint64_t materialQueries = 0;
+        std::uint64_t materialCandidateChecks = 0;
+        bool materialTileOutsideEveryVein = true;
         double featureListMilliseconds = 0.0;
         double farShellMilliseconds = 0.0;
         double farStratumShellMilliseconds = 0.0;
@@ -191,6 +301,9 @@ namespace VoxelForgeCore
         std::uint32_t farHorizonVersion = 0;
         bool farShellRepairSkipped = false;
         bool tileWasClassified = false;
+        std::uint8_t tileProofVetoReason = 0;
+        bool tileProofSafe = false;
+        bool tileLegacyBlockProofRelevant = false;
         bool meshingSkipped = false;
         bool featureRefinedResolution = false;
         bool heightfieldBandLimited = false;
@@ -216,7 +329,9 @@ namespace VoxelForgeCore
         std::uint64_t densitySampleCount = 0;
         std::uint64_t meshPayloadAllocatedBytes = 0;
         std::uint64_t densityHash = 0, meshHash = 0, payloadHash = 0, topologyHash = 0;
-        bool hasDensityHash = false, hasMeshHash = false, hasPayloadHash = false, hasTopologyHash = false;
+        std::uint64_t materialHash = 0;
+        bool hasDensityHash = false, hasMeshHash = false, hasPayloadHash = false,
+            hasTopologyHash = false, hasMaterialHash = false;
     };
 
     struct WorldConfiguration
@@ -249,8 +364,140 @@ 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 = 2;
-    // Version 14 adds shared passage columns for long native open-air crossings.
-    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 14;
+    // Version 14 adds shared passage columns; version 16 smooths owner Gradient faces;
+    // version 20 restores full Gradient amplitude and uses a continuous signed-distance band union;
+    // version 22 overlaps tread sections and smooths FloatingIslands passage-mouth features;
+    // version 23 uses signed-distance support for sparse SurfaceWorld-to-TunnelNetwork treads;
+    // version 24 narrows passage-mouth support and filters native ground detail;
+    // version 25 joins open-mouth treads to native terrain relief before flattening inward;
+    // version 26 tapers mouth width and bounds the support to the native terrain surface;
+    // version 27 keeps the native blend through the entrance ramp and narrows its filter;
+    // version 28 tapers the open end to a worn path and blends it into walkable support;
+    // version 29 curves the supported and carved path through both mouth shoulders;
+    // version 30 narrows the flat core and blends support through a noisy natural shoulder;
+    // version 31 adds shared, capsule-safe field relief to both open-mouth walking surfaces;
+    // version 32 lowers the mouth core into the bore and removes thin filtered-field remnants;
+    // version 33 fades relief before small detached field remnants;
+    // version 34 keeps the open-mouth tread within native terrain curvature and noise;
+    // version 35 follows the native heightfield farther into the mouth ramp;
+    // version 36 protects the walking line with a gradual filter fade;
+    // version 37 lengthens that fade and restores the last capsule margin;
+    // version 38 keeps native ground at the lip and blends the tread in below it;
+    // version 39 bends the mouth tread across the native field and restores the open bore;
+    // version 40 uses broad route-only filtering and smooth, low-frequency tread relief;
+    // version 41 rounds the mouth tread and removes filter route masks;
+    // version 42 clips the mouth bore at the native walking surface;
+    // version 43 localizes the mouth field filter without masking the surface route;
+    // version 44 widens the natural shoulder blend and follows lower-frequency terrain;
+    // version 45 tests the passage tread independently of route-anchor support;
+    // version 46 fades the native filter broadly along the authored surface path;
+    // version 47 carries the full winding route with a narrow native-height tread;
+    // version 48 fades route support out before the surface mouth;
+    // version 49 keeps the mouth filtered and restores detail on the outer route;
+    // version 50 limits route-field restoration to 65% of the convolution weight;
+    // version 51 narrows the route fade to 8 m horizontal and 6 m vertical;
+    // version 52 evaluates mouth support in positive-density route tiles;
+    // version 53 fades the supported passage tread in from native ground at both mouths;
+    // version 54 tapers mouth-support width and depth;
+    // version 55 blends that tread from native ground and applies route support after carving;
+    // version 56 seats route support at the audited floor;
+    // version 57's raised lip overfilled the mouth;
+    // version 58 restores the native-height lip and explicitly covers route-support queries;
+    // version 59 fixes route-support distance units and lengthens the worn-mouth taper;
+    // version 60 brings the narrow terrain-following route tread in before the outer mouth lip;
+    // version 61 finishes that tread by five metres and preserves its exact walking boundary;
+    // version 62 fades the route tread along the authored path and seats it below the capsule;
+    // version 63 only adds that tread through native-air gaps and fades it over two path metres;
+    // version 64 rounds the path-to-ground join while keeping its top below the capsule;
+    // version 65 tests rounded tread cross-sections and softer native-height following;
+    // version 66 fades the mouth carve and support together so native crater ground forms the lip;
+    // version 67 follows the native route height more closely and completes the entrance fade sooner;
+    // version 68 narrows the flat walk core and eases a shallow worn ramp into the cave floor;
+    // version 69 lets capsule-cleared mouth treads bridge positive-density floor gaps;
+    // version 70 lowers the mouth tread enough to clear the capsule's toe margin;
+    // version 71 keeps its rounded top inside the route's shallow support-probe band;
+    // version 72 adds mouth support only below its signed floor, avoiding capsule-space fill;
+    // version 73 carries the terrain-following route tread to the actual passage mouth;
+    // version 74 seats that short connection in the audited shallow support band;
+    // version 75 keeps the rounded path edge outside the capsule's shallow floor probes;
+    // version 76 carries the endpoint tread through the passage's first support-probe depth;
+    // version 77 joins the mouth floor to native ground through a noisy walk ramp;
+    // version 78 rounds the ramp shoulder and clears its initial capsule envelope;
+    // version 79 tested the unbuilt native-ground mouth;
+    // version 80 narrows the walk tread;
+    // version 81 adds bounded path relief and a wavering, worn shoulder;
+    // version 82 lowers the relief into the tread to keep its capsule clearance;
+    // version 83 increases the natural edge warp and recessed surface variation;
+    // version 84 moves that variation to the actual mouth and restores support width;
+    // version 85 keeps the established lower-mouth capsule profile while shaping entry mouths;
+    // version 86 restricts route reinforcement to native solid and recesses the worn top;
+    // version 87 restores its pre-carve route placement.
+    // version 88 removes the independent mouth cap; the native crater surface forms the entry ramp.
+    // version 89 removes the one-sided entry tread band as well.
+    // version 90 lengthens the entrance floor-carve fade to retain native ground beneath the route.
+    // version 91 lets a narrow mouth support follow the full native surface relief.
+    // version 92 derives mouth floor alignment from the entrance path for first-segment samples too.
+    // version 93 blends the carve against native density so a zero fade really preserves ground.
+    // version 94 applies the mouth floor fade only beneath the walking surface.
+    // version 95 seats retained native ground just below the capsule's foot clearance.
+    // version 96 limits that preservation to the shallow support band, away from inner coils.
+    // version 97 extends the native support band down to the sampled rock envelope.
+    // version 98 raises the support band back to the route floor while keeping it below the capsule.
+    // version 99 restores native-solid route support after the passage carve;
+    // version 100 restores a shallow, noise-shaped entrance tread under its capsule gate;
+    // version 101 preserves the native FI field around the resolved walking line;
+    // version 102 tapers the mouth filter from its 1.5 m core to the same 12.5 m edge;
+    // version 103 blends route protection over a metre-scale shoulder;
+    // version 104 composes overlapping route masks once, by maximum influence;
+    // version 105 widens the route blend to soften the native/filter seam;
+    // version 106 preserves raw negative rock under the route without unfiltering its crown;
+    // version 107 softens that restore and broadens the narrow upper-coil walk core;
+    // version 108 deepens relief and lowers route restoration to soften the remaining crease;
+    // version 109 blended 60% of the two-metre mouth field convolution;
+    // version 110 restores the full filtered contour and widens the upper walk core;
+    // version 111 permits the capsule-cleared signed tread to bridge the upper mouth gap;
+    // version 112 adds a tenth-metre margin to the rounded upper tread edge.
+    // version 139 keeps native ground only in a capsule-scale mouth lane and carries
+    // the seeded terrain contour through the full upper-mouth support;
+    // versions 140-145 tested short-span decks, mouth fade length, route phase and tread SDF;
+    // versions 146-148 tested a sunk chord, near-side phase and all-style FI spiral.
+    // version 149 routes non-spiral FI mouths into a tight near-side ring.
+    // version 150 widened that ring but left a central pillar.
+    // version 151 keeps the ring half a metre outside the passage bore.
+    // version 152 fills capsule-clear positive-density gaps under the narrow mouth tread.
+    // version 153 tested a one-metre entry-turn sink; it left the raised route visible and rippled the floor.
+    // version 154 tightens the FI ring and uses a steeper, still walkable descent to separate hidden coils.
+    // version 155's tighter coil removed the fin but made sharp fragments and route collisions.
+    // version 156 keeps the 3 m ring, overlaps the bore by 0.25 m, and seats the native tread below the capsule.
+    // version 157 joins the near-side FI ring at a tangent so its entrance does not kink across the crater.
+    // version 158 tested a descending entry coil; its exposed canopy is rejected.
+    // version 159 keeps the tangent and uses a steeper sub-15-degree FI descent to separate its coils.
+    // version 160 removed the mouth walk lane; it left the bridge and lost one support sample.
+    // version 161 tapered the anchored entry radius to 3 m; a fin remained at the crater lip.
+    // version 162 disabled native-tread restoration alone; the carve fade still preserved the ridge.
+    // version 163 disabled both passage restorations; it removed the path support.
+    // version 164 narrowed the first two inner FI route points; it enlarged the lip fin.
+    // version 165 disabled native-rock blending around the FI stratum route; the ridge remained.
+    // version 166 disabled the FI mouth support handoff; route support failed on the island approach.
+    // version 167 tested centerline footing on the FI approach; its bridge remained and floor ripple rose.
+    // version 168 removed the connector's 1 m lift; the crater crossing remained exposed.
+    // version 169 sank every connector 2 m; it left four FI route support probes low.
+    // version 170 sinks only connectors touching the anchored root by 1 m.
+    // Version 208 keeps the crater tread scoped to style-zero FI mouths.
+    // Version 210 keeps bulk native-cave sampling on the scalar field path at strata edges.
+    // Version 211 makes coordinate biasing in the shared cell hash unsigned, removing signed-overflow UB.
+    // Version 212 balances generated entry routes against existing walk lanes and preserves their shared treads.
+    // Version 218 sweeps passages around a dense smooth spline and limits exposed shells to a trough.
+    // Version 219 smooths passage XY while mapping each planned height chord over its sampled horizontal arc.
+    // Version 220 adaptively samples passage curves and rounds open-air wall crests.
+    // Version 221 ranks passage segments before floor shaping and preserves their signed exterior distance.
+    // Version 223 projects the floor onto one continuous arc-length profile and groups
+    // dense passage samples into coarse tile candidates. Version 224 keeps the same
+    // continuous floor while relaxing the spline chord tolerance and bounding shell work.
+    // Version 226 unifies the passage influence reach in metres and converts it to core
+    // voxels for every broadphase and proof bound. Version 227 uses the exact smooth-max
+    // support width/6 when deriving that reach.
+    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 227;
 
     enum class FieldChannel : std::uint32_t
     {
@@ -297,6 +544,59 @@ namespace VoxelForgeCore
         std::int64_t capRidgeWavelengthSubvoxels = 256 * 64;
     };
 
+    enum class WorldAssemblySurfaceProfileKindV1 : std::uint32_t
+    {
+        natural = 0,
+        periodicHills = 1,
+        mirroredRelief = 2,
+        flatField = 3
+    };
+
+    // Version zero is the historical noise terrain and is intentionally omitted from
+    // canonical JSON and hashes. Version one uses metre-derived fixed-scale dimensions;
+    // phases are Q0.32 turns generated from the recipe seed during plan construction.
+    struct WorldAssemblySurfaceProfileV1
+    {
+        std::uint32_t version = 0;
+        WorldAssemblySurfaceProfileKindV1 kind = WorldAssemblySurfaceProfileKindV1::natural;
+        std::int64_t h0Subvoxels = 0;
+        std::int64_t amplitudeXSubvoxels = 0;
+        std::int64_t amplitudeYSubvoxels = 0;
+        std::int64_t wavelengthXSubvoxels = 0;
+        std::int64_t wavelengthYSubvoxels = 0;
+        std::uint32_t phaseXTurnsQ32 = 0;
+        std::uint32_t phaseYTurnsQ32 = 0;
+        std::int64_t mirrorLambdaQ16 = 0;
+        std::int64_t minimumArenaClearanceSubvoxels = 0;
+
+        friend bool operator==(const WorldAssemblySurfaceProfileV1&,
+            const WorldAssemblySurfaceProfileV1&) = default;
+    };
+
+    inline std::uint32_t WorldAssemblySurfaceProfileSeededPhaseQ32(
+        std::uint32_t seed, std::uint32_t axis) noexcept
+    {
+        std::uint64_t value = static_cast<std::uint64_t>(seed)
+            ^ (axis == 0 ? 0x706572696f645831ull : 0x706572696f645931ull);
+        value += 0x9E3779B97F4A7C15ull;
+        value = (value ^ (value >> 30)) * 0xBF58476D1CE4E5B9ull;
+        value = (value ^ (value >> 27)) * 0x94D049BB133111EBull;
+        value ^= value >> 31;
+        return static_cast<std::uint32_t>(value >> 32);
+    }
+
+    inline void ResolveWorldAssemblySurfaceProfilePhasesV1(
+        WorldAssemblySurfaceProfileV1& profile, std::uint32_t seed) noexcept
+    {
+        if (profile.version == 1
+            && (profile.kind == WorldAssemblySurfaceProfileKindV1::periodicHills
+                || profile.kind == WorldAssemblySurfaceProfileKindV1::mirroredRelief))
+        {
+            profile.phaseXTurnsQ32 = WorldAssemblySurfaceProfileSeededPhaseQ32(seed, 0);
+            profile.phaseYTurnsQ32 = WorldAssemblySurfaceProfileSeededPhaseQ32(seed, 1);
+        }
+    }
+
     struct WorldAssemblyRecipeV1
     {
         std::uint32_t schemaVersion = WorldAssemblySchemaVersion;
@@ -314,6 +614,7 @@ namespace VoxelForgeCore
         std::int64_t biomeClimateReliefWavelengthSubvoxels = 256 * 3333;
         std::int64_t biomeClimateMoistureWavelengthSubvoxels = 256 * 2500;
         std::int64_t biomeClimateReliefContrastQ16 = 2ll << 16;
+        WorldAssemblySurfaceProfileV1 surfaceProfile;
         std::vector<WorldAssemblyBiomeProfileV1> biomes;
         std::uint64_t contentHash = 0;
     };
@@ -373,6 +674,7 @@ namespace VoxelForgeCore
         std::int64_t capRidgeWavelengthSubvoxels = 256 * 64;
         std::int64_t waterSurfaceSubvoxels = 0;
         bool waterEnabled = false;
+        WorldAssemblySurfaceProfileV1 surfaceProfile;
         std::vector<WorldAssemblyFeatureV1> features;
         WorldAssemblyRouteConstraintsV1 routeConstraints;
         std::vector<WorldAssemblyRoutePointV1> route;
@@ -444,6 +746,8 @@ namespace VoxelForgeCore
         std::int64_t anchorIslandMinimumRadiusSubvoxels = 0;
         std::int64_t anchorRootBottomZSubvoxels = 0;
         std::int64_t anchorMouthOffsetSubvoxels = 0;
+        // Style-zero mouths follow the sampled island surface into the passage lip.
+        bool terrainFollowingRoute = false;
         WorldAssemblyRouteConstraintsV1 routeConstraints;
         std::uint64_t contentHash = 0;
     };
@@ -584,8 +888,139 @@ namespace VoxelForgeCore
     // Core adapter. Coordinates are half-open micrometre intervals; recipe anchors retain their
     // source fixed-point units so this record never rounds the recipe itself.
     inline constexpr std::uint32_t ResolvedLayoutSchemaVersionV3 = 3;
+    inline constexpr std::uint32_t ResolvedLayoutStampVocabularyVersionV1 = 1;
+    inline constexpr std::uint32_t ResolvedLayoutStampVocabularyVersionV2 = 2;
+    inline constexpr std::uint32_t ResolvedLayoutStampVocabularyVersionV3 = 3;
+    inline constexpr std::uint32_t ResolvedLayoutCavernGraphVocabularyVersionV1 = 1;
+    inline constexpr std::uint32_t ResolvedLayoutOreVeinVocabularyVersionV1 = 1;
     enum class ResolvedLayoutValidationModeV3 : std::uint8_t { compatibility, strict };
 
+    // Stable, bounded geometry edits composed into every Core field after the shared
+    // strate boundaries and passages. Coordinates and extents use integer micrometres.
+    enum class ResolvedSdfStampKindV1 : std::uint8_t
+    {
+        carveEllipsoid = 1,
+        carveArch = 2,
+        fillPillar = 3,
+        fillDais = 4,
+        fillMonolith = 5,
+        fillPlatform = 6
+    };
+
+    struct ResolvedLayoutStampRequestV1
+    {
+        std::string stableId;
+        std::int32_t strateIndex = -1;
+        ResolvedSdfStampKindV1 kind = ResolvedSdfStampKindV1::carveEllipsoid;
+        // A preferred center and a bounded deterministic search radius.
+        std::array<std::int64_t, 3> anchorPositionMicrometres{};
+        std::int64_t placementRadiusMicrometres = 0;
+        std::array<std::int64_t, 3> halfExtentsMicrometres{};
+        std::int64_t smoothWidthMicrometres = 0;
+        std::int64_t irregularityAmplitudeMicrometres = 0;
+        std::int64_t irregularityWavelengthMicrometres = 0;
+        std::int64_t roundingRadiusMicrometres = 0;
+        std::int64_t minimumSpacingMicrometres = 0;
+        // 0 = free placement, 1 = seated on the authored flat profile floor.
+        std::uint8_t attachmentPolicy = 0;
+        std::int64_t floorMicrometres = 0;
+        std::uint8_t yawQuarterTurns = 0;
+    };
+
+    struct ResolvedLayoutStampV1
+    {
+        std::string stableId;
+        std::int32_t strateIndex = -1;
+        ResolvedSdfStampKindV1 kind = ResolvedSdfStampKindV1::carveEllipsoid;
+        std::array<std::int64_t, 3> positionMicrometres{};
+        std::array<std::int64_t, 3> boundsMinimumMicrometres{};
+        std::array<std::int64_t, 3> boundsMaximumMicrometres{};
+        std::array<std::int64_t, 3> halfExtentsMicrometres{};
+        std::int64_t smoothWidthMicrometres = 0;
+        std::int64_t irregularityAmplitudeMicrometres = 0;
+        std::int64_t irregularityWavelengthMicrometres = 0;
+        std::int64_t roundingRadiusMicrometres = 0;
+        std::int64_t minimumSpacingMicrometres = 0;
+        std::uint8_t attachmentPolicy = 0;
+        std::int64_t floorMicrometres = 0;
+        std::uint64_t irregularitySeed = 0;
+        std::uint8_t yawQuarterTurns = 0;
+    };
+
+    // Optional room and swept-edge records for a resolved cavern graph. Geometry is stored
+    // in integer micrometres; bounds include smooth blending, relief, and floor support.
+    struct ResolvedCavernRoomV1
+    {
+        std::string stableId;
+        std::int32_t strateIndex = -1;
+        std::array<std::int64_t, 3> centerMicrometres{};
+        std::array<std::int64_t, 3> halfExtentsMicrometres{};
+        std::int64_t floorMicrometres = 0;
+        std::int64_t smoothWidthMicrometres = 0;
+        // Optional feature-to-feature union width. Zero preserves the historical
+        // behavior where smoothWidthMicrometres also controls the graph union.
+        std::int64_t unionWidthMicrometres = 0;
+        std::int64_t irregularityAmplitudeMicrometres = 0;
+        std::int64_t irregularityWavelengthMicrometres = 0;
+        std::uint64_t irregularitySeed = 0;
+        std::array<std::int64_t, 3> boundsMinimumMicrometres{};
+        std::array<std::int64_t, 3> boundsMaximumMicrometres{};
+    };
+
+    struct ResolvedCavernEdgeV1
+    {
+        std::string stableId;
+        std::string startAnchorStableId;
+        std::string endRoomStableId;
+        std::int32_t strateIndex = -1;
+        // A single cubic Bezier in XY. Its four Z values are the cubic floor profile.
+        std::array<std::array<std::int64_t, 3>, 4> controlPointsMicrometres{};
+        // Resolve-time, error-bounded approximation of the cubic centerline. Each
+        // consecutive pair is a physical segment used by the native cave field.
+        std::vector<std::array<std::int64_t, 3>> polylineMicrometres;
+        std::int64_t boreRadiusMicrometres = 0;
+        std::int64_t boreHeightMicrometres = 0;
+        std::int64_t floorSupportDepthMicrometres = 0;
+        std::int64_t smoothWidthMicrometres = 0;
+        // Optional feature-to-feature union width; floor fillets still use smoothWidth.
+        std::int64_t unionWidthMicrometres = 0;
+        std::int64_t irregularityAmplitudeMicrometres = 0;
+        std::int64_t irregularityWavelengthMicrometres = 0;
+        std::uint64_t irregularitySeed = 0;
+        std::array<std::int64_t, 3> boundsMinimumMicrometres{};
+        std::array<std::int64_t, 3> boundsMaximumMicrometres{};
+    };
+
+    // Immutable material-only deposits. The capsule and its conservative bounds are in
+    // micrometres; bounds include irregularity and the blend envelope.
+    struct ResolvedLayoutOreVeinRequestV1
+    {
+        std::string stableId;
+        std::int32_t strateIndex = -1;
+        std::uint16_t resourceMaterialId = 0;
+        std::array<std::array<std::int64_t, 3>, 2> anchorEndpointsMicrometres{};
+        std::int64_t placementRadiusMicrometres = 0;
+        std::int64_t radiusMicrometres = 0;
+        std::int64_t irregularityAmplitudeMicrometres = 0;
+        std::int64_t irregularityWavelengthMicrometres = 0;
+        std::int64_t blendWidthMicrometres = 0;
+    };
+
+    struct ResolvedLayoutOreVeinV1
+    {
+        std::string stableId;
+        std::int32_t strateIndex = -1;
+        std::uint16_t resourceMaterialId = 0;
+        std::array<std::array<std::int64_t, 3>, 2> endpointsMicrometres{};
+        std::array<std::int64_t, 3> boundsMinimumMicrometres{};
+        std::array<std::int64_t, 3> boundsMaximumMicrometres{};
+        std::int64_t radiusMicrometres = 0;
+        std::int64_t irregularityAmplitudeMicrometres = 0;
+        std::int64_t irregularityWavelengthMicrometres = 0;
+        std::int64_t blendWidthMicrometres = 0;
+        std::uint64_t irregularitySeed = 0;
+    };
+
     struct ResolvedLayoutAnchorV2
     {
         std::string kind;
@@ -608,6 +1043,23 @@ namespace VoxelForgeCore
         std::int64_t solidDensityQ16 = 1ll << 16;
     };
 
+    // Runtime policy resolved once from the director's immutable strate/interface
+    // description. These derived capabilities are deliberately omitted from canonical
+    // JSON: their source fields are already hashed and the records preserve that identity.
+    struct ResolvedLayoutStratePassageCapabilitiesV1
+    {
+        bool hasSurfaceLanding = false;
+        bool hasFloatingIslandLanding = false;
+        bool hasNativeCaveField = false;
+        bool hasNativeLatticeField = false;
+    };
+
+    struct ResolvedLayoutInterfaceCapabilitiesV1
+    {
+        bool preserveUpperBedrockAirGap = false;
+        bool surfaceToTunnelLandingSupport = false;
+    };
+
     struct ResolvedLayoutStratumV2
     {
         std::string stableId;
@@ -637,6 +1089,39 @@ namespace VoxelForgeCore
         std::int64_t managerChunkWidthMicrometres = 0;
         std::int64_t dispatchChunkWidthMicrometres = 0;
         std::vector<ResolvedLayoutAnchorV2> anchors;
+        ResolvedLayoutStratePassageCapabilitiesV1 passageCapabilities;
+        ResolvedLayoutInterfaceCapabilitiesV1 lowerInterfaceCapabilities;
+    };
+
+    inline bool IsNativeCaveFieldStratum(const ResolvedLayoutStratumV2& stratum) noexcept
+    {
+        return stratum.generatorKind=="Caves"
+            &&stratum.recipeId=="Core.Caves.PrimitiveField"
+            &&stratum.recipeVersion==1;
+    }
+
+    inline bool IsNativeLatticeFieldStratum(const ResolvedLayoutStratumV2& stratum) noexcept
+    {
+        return (stratum.generatorKind=="Maze"||stratum.generatorKind=="VerticalShafts")
+            &&stratum.recipeId=="Core.Lattice.PrimitiveField"
+            &&stratum.recipeVersion==1;
+    }
+
+    inline bool HasNativeGraphField(const ResolvedLayoutStratumV2& stratum) noexcept
+    {
+        return IsNativeCaveFieldStratum(stratum)||IsNativeLatticeFieldStratum(stratum);
+    }
+
+    /** Per-column resolved bands for one adjacent bedrock/ceiling interface.
+     * crossingDepthMicrometres is the actual overlap depth between the two facing bands.
+     */
+    struct ResolvedLayoutTransitionBandsV1
+    {
+        std::int64_t crossingDepthMicrometres = 0;
+        std::int64_t upperBedrockBottomMicrometres = 0;
+        std::int64_t upperBedrockTopMicrometres = 0;
+        std::int64_t lowerCeilingBottomMicrometres = 0;
+        std::int64_t lowerCeilingTopMicrometres = 0;
     };
 
     struct ResolvedLayoutIssueV2
@@ -656,6 +1141,8 @@ namespace VoxelForgeCore
         std::string stableId;
         std::int32_t upperStrateIndex = -1;
         std::int32_t lowerStrateIndex = -1;
+        // EVoxelPassageStyle numeric value used by style-specific passage support.
+        std::uint32_t style = 1;
         std::int64_t placementRadiusSubvoxels = 0;
         std::array<std::int64_t, 3> upperMouthSubvoxels{};
         std::array<std::int64_t, 3> lowerMouthSubvoxels{};
@@ -666,28 +1153,6 @@ namespace VoxelForgeCore
         std::vector<ResolvedLayoutPassagePointV1> controlPoints;
     };
 
-    struct PassageVoidCrossingAuditV1
-    {
-        std::size_t passageIndex = 0;
-        std::size_t firstSegment = 0;
-        std::size_t lastSegment = 0;
-        std::uint64_t unsupportedSamples = 0;
-        double unsupportedLengthMetres = 0.0;
-        std::array<double, 4> startPointSubvoxels{};
-        std::array<double, 4> endPointSubvoxels{};
-        bool needsColumn = false;
-        bool connectedAtStart = false;
-        bool connectedAtEnd = false;
-        std::array<std::int64_t, 2> columnAxisSubvoxels{};
-        std::int64_t columnTopZSubvoxels = 0;
-        std::int64_t columnBottomZSubvoxels = 0;
-        std::int64_t columnMinimumRadiusSubvoxels = 0;
-        std::int64_t columnNominalRadiusSubvoxels = 0;
-        std::int64_t columnMaximumRadiusSubvoxels = 0;
-        double maximumRouteOffsetMetres = 0.0;
-        double maximumBoreRadiusMetres = 0.0;
-    };
-
     struct ResolvedLayoutPassageConfigV1
     {
         std::int32_t upperStrateIndex = -1;
@@ -719,6 +1184,16 @@ namespace VoxelForgeCore
         std::int64_t strateLayoutChunkWidthSubvoxels = 8192;
         std::vector<ResolvedLayoutStratumV2> strates;
         std::vector<ResolvedLayoutPassageV1> passages;
+        // Kept absent from canonical layout identity when no feature requests stamps.
+        std::uint32_t stampVocabularyVersion = 0;
+        std::vector<ResolvedLayoutStampV1> stamps;
+        // Kept absent from canonical identity when there are no graph records.
+        std::uint32_t cavernGraphVocabularyVersion = 0;
+        std::vector<ResolvedCavernRoomV1> cavernRooms;
+        std::vector<ResolvedCavernEdgeV1> cavernEdges;
+        // Omitted from canonical identity when no records are present.
+        std::uint32_t oreVeinVocabularyVersion = 0;
+        std::vector<ResolvedLayoutOreVeinV1> oreVeins;
         std::string stableIdentity;
 
         bool finalize(std::string& error);
@@ -730,6 +1205,17 @@ namespace VoxelForgeCore
             std::string_view json, std::string& error);
     };
 
+    /**
+     * Resolve the deterministic band faces at one XY column. Gradient shares one smooth
+     * displaced face; Interleaved moves the faces inward by a total crossing no larger than
+     * the declared width. Both bands retain authored thickness and touch or overlap, so no
+     * air gap can form.
+     */
+    VFCORE_API ResolvedLayoutTransitionBandsV1 EvaluateResolvedLayoutTransitionBandsV1(
+        const ResolvedLayoutStratumV2& upper, const ResolvedLayoutStratumV2& lower,
+        std::int32_t worldSeed, std::int64_t layoutChunkSizeMicrometres,
+        std::int64_t xMicrometres, std::int64_t yMicrometres);
+
     struct ResolvedLayoutValidatorAuditV3
     {
         std::uint32_t controlsRun = 0;
@@ -743,6 +1229,68 @@ namespace VoxelForgeCore
         const std::vector<ResolvedLayoutPassageConfigV1>& configs,
         std::string& error);
 
+    struct ResolvedLayoutStampPlacementAuditV1
+    {
+        std::uint32_t negativeControlsRun = 0;
+        std::uint32_t negativeControlsRejected = 0;
+        bool passed = false;
+    };
+    VFCORE_API bool ResolveResolvedLayoutStampsV1(
+        ResolvedLayoutSnapshotV3& layout, std::int32_t seed,
+        std::span<const ResolvedLayoutStampRequestV1> requests,
+        std::string& error);
+    VFCORE_API bool ResolveResolvedLayoutStampsV2(
+        ResolvedLayoutSnapshotV3& layout, std::int32_t seed,
+        std::span<const ResolvedLayoutStampRequestV1> requests,
+        std::string& error);
+    // Vocabulary 3 adds explicit rounded capped-cylinder monoliths and rounded-box platforms.
+    VFCORE_API bool ResolveResolvedLayoutStampsV3(
+        ResolvedLayoutSnapshotV3& layout, std::int32_t seed,
+        std::span<const ResolvedLayoutStampRequestV1> requests,
+        std::string& error);
+    VFCORE_API ResolvedLayoutStampPlacementAuditV1 AuditResolvedLayoutStampPlacementV1(
+        const ResolvedLayoutSnapshotV3& layout);
+
+    VFCORE_API bool ResolveResolvedCavernGraphV1(
+        ResolvedLayoutSnapshotV3& layout, std::int32_t seed,
+        std::span<const ResolvedCavernRoomV1> rooms,
+        std::span<const ResolvedCavernEdgeV1> edges,
+        std::string& error);
+    VFCORE_API bool ResolveResolvedLayoutOreVeinsV1(
+        ResolvedLayoutSnapshotV3& layout, std::int32_t seed,
+        std::span<const ResolvedLayoutOreVeinRequestV1> requests,
+        std::string& error);
+
+    struct ResolvedLayoutOreVeinPlacementAuditV1
+    {
+        std::uint32_t negativeControlsRun = 0;
+        std::uint32_t negativeControlsRejected = 0;
+        bool passed = false;
+    };
+    VFCORE_API ResolvedLayoutOreVeinPlacementAuditV1 AuditResolvedLayoutOreVeinPlacementV1(
+        const ResolvedLayoutSnapshotV3& layout);
+
+    struct MaterialSampleV1
+    {
+        std::uint16_t hostMaterialId = 1;
+        std::array<std::uint16_t, 2> resourceMaterialIds{};
+        std::array<std::uint16_t, 2> resourceWeightsQ16{};
+    };
+
+    struct ResourceVolumeV1
+    {
+        std::uint16_t resourceMaterialId = 0;
+        std::uint64_t weightedSamplesQ16 = 0;
+        double volumeCubicMetres = 0.0;
+    };
+
+    struct OreMiningYieldV1
+    {
+        std::uint64_t solidSamplesRemoved = 0;
+        double sampleSpacingMetres = 0.0;
+        std::vector<ResourceVolumeV1> resources;
+    };
+
     struct FloatingIslandBoundsAuditResult
     {
         std::uint64_t boxesTested = 0;
@@ -929,6 +1477,7 @@ namespace VoxelForgeCore
         static void setThreadColumnInterpolationStrideSubvoxels(std::int64_t stride) noexcept;
         static std::int64_t threadColumnInterpolationStrideSubvoxels() noexcept;
         static void setThreadColumnCacheLegacyDirectMapped(bool enabled) noexcept;
+        static bool threadColumnCacheLegacyDirectMapped() noexcept;
         static const HeightfieldColumnCacheStats& threadColumnCacheStats() noexcept;
         FieldInterval interval(std::int64_t minimumXSubvoxels,
                                std::int64_t minimumYSubvoxels,
@@ -1021,6 +1570,7 @@ namespace VoxelForgeCore
         const WorldConfiguration& configuration() const;
         const WorldAssemblyManifest* worldAssembly() const noexcept;
         const ResolvedLayoutSnapshotV3* resolvedLayout() const noexcept;
+        ResolvedWorldSnapshot withResolvedLayout(const ResolvedLayoutSnapshotV3& layout) const;
         ResolvedWorldSnapshot withoutResolvedLayoutPassages() const;
 
     private:
@@ -1064,6 +1614,7 @@ namespace VoxelForgeCore
         bool roundTunnels = false;
         bool enhancedTunnelWalls = true;
         bool profileDetailBand = false;
+        bool parallelSignEdgeRepair = false;
         // World-wide walkability is a validation pass, not an input to the compiled field.
         // Keep it enabled for benchmarks/audits; the interactive viewer can defer it.
         bool validatePassageRoutes = true;
@@ -1248,6 +1799,9 @@ namespace VoxelForgeCore
         std::int32_t bandMinZVoxel = -2147483647 - 1;
         std::int32_t bandMaxZVoxel = 2147483647;
         bool hashDensity = false;
+        // Falsifier mode: retain mesh/topology hashes while permitting proven empty tiles
+        // to skip their density lattice. The density hash of such a skipped tile is empty.
+        bool allowUniformSkipsWhenHashing = false;
         bool captureDensitySamples = false;
         // Diagnostic only; materialize the full density lattice even when block proofs
         // establish that the tile has no surface.
@@ -1266,6 +1820,20 @@ namespace VoxelForgeCore
         // 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;
+        // Research-only: count passage-composer work per generated tile.
+        bool profilePassageComposer = false;
+        // Research-only field comparison. Zero keeps the unbounded passage carve;
+        // a positive value bounds its signed-distance reach in metres. A negative
+        // value leaves the process-level L93 setting in control.
+        double diagnosticPassageCarveReachMetres = -1.0;
+        // Research-only: collect tile-drain kernel counters and floating-island cache metrics.
+        // Inactive on ordinary generation so the hot path only pays the option check.
+        bool instrumentTileDrain = false;
+        // Linux headless measurement only. Compiled out of ordinary builds.
+        bool linux77Profile = false;
+        bool exactMidpointDensityMemo = true;
+        bool activeLaneBatching = false;
+        std::uint32_t proofBlockCells = 8;
         // 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;
@@ -1275,6 +1843,10 @@ namespace VoxelForgeCore
         // Diagnostic/performance control; memoizes exact MC lattice gradients at LOD0.
         // Controle de mesure/performance; memorise les gradients MC exacts au LOD0.
         bool memoizeMcGradients = true;
+        // Optional host-owned executor for predicted-heavy density-grid fills.
+        // Hosts leave this null for ordinary tiles and set a small limit for heavy tiles.
+        const JobScheduler* gridFillScheduler = nullptr;
+        std::uint32_t gridFillWorkerLimit = 1;
         // 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;
@@ -1282,7 +1854,7 @@ namespace VoxelForgeCore
         // LOD4-8 mesh hashes are salted; density and LOD0-3 keep their direct identities.
         // Incremente quand les plafonds partages ou l'horizon lointain changent.
         // Les hashes de maillage LOD4-8 incluent cette version; LOD0-3 gardent leur identite directe.
-        std::uint32_t farHorizonVersion = 4;
+        std::uint32_t farHorizonVersion = 5;
         // Linux research controls for reproducing L5 negative controls. Defaults preserve output.
         std::uint32_t diagnosticGlobalOctaveDrop = 0;
         std::uint32_t diagnosticCellStride = 1;
@@ -1330,22 +1902,24 @@ namespace VoxelForgeCore
                                bool analyticOnly = true,
                                bool diagnosticIncludeBaseCoveredTiles = false);
         void retainTileRegions(std::span<const TileKey> desiredTiles);
-        void buildFarWorld();
+        bool buildFarWorld();
         bool isCompiled() const noexcept;
         bool hasFarWorld() const noexcept;
         ShapeBuildStats buildStats() const;
 
         float densityAt(Vec3d voxelPosition) const;
-        // Audit-only view of density-field columns and short spans supporting passage voids.
-        std::vector<PassageVoidCrossingAuditV1> passageVoidCrossings() const;
-        bool isPassageColumnSample(std::size_t passageIndex, std::size_t segmentIndex,
-                                  Vec3d voxelPosition) const;
-        bool isPassageShortSpanSample(std::size_t passageIndex, std::size_t segmentIndex,
-                                     Vec3d voxelPosition) const;
+        // Companion material query for the bound strate evaluator; coordinates use Core voxels.
+        MaterialSampleV1 materialAt(Vec3d voxelPosition) const;
+        // Measure-only carve estimate. This does not apply an edit or grant inventory.
+        OreMiningYieldV1 measureOreMiningYieldForSphere(
+            Vec3d centerVoxel, double radiusMetres,
+            double sampleSpacingMetres = 0.25) const;
         // Audit-only selector provenance for the same point evaluator; never used by meshing.
         std::string densityDispatchPathAt(Vec3d voxelPosition) const;
         // Analytic source distance without the occupancy-preserving near-zero clamp or packed proxy.
         float unclampedDensityAt(Vec3d voxelPosition) const;
+        // Research-only source field entering passage composition, with passage carving omitted.
+        float passageSourceDensityAt(Vec3d voxelPosition) const;
         DetailFieldSample detailSampleAt(Vec3d voxelPosition) const;
         float densityAtLattice(Vec3i voxelPosition) const;
         bool isSolidAt(Vec3d voxelPosition) const;
@@ -1355,6 +1929,9 @@ namespace VoxelForgeCore
         std::vector<TileKey> desiredTiles(Vec3d cameraPositionVoxels) const;
         static std::vector<TileKey> prioritizeTiles(std::span<const TileKey> tiles,
                                                    Vec3i centerChunk);
+        // Count expanded resolved-passage route bounds intersecting the full tile bounds.
+        // Hosts use this stable estimate to prioritize and split expensive near tiles.
+        std::uint32_t passageOverlapScore(const TileKey& key) const noexcept;
         std::optional<TileMesh> generateTile(const TileKey& key,
                                              const TileGenerationOptions& options,
                                              std::string& error) const;

Standalone/Core/src/CoreNamespacePreamble.h

@@ -1,5 +1,9 @@
 #pragma once
 
+// Core implementation TUs opt into the standalone Unreal-shaped compatibility headers. UE's
+// Linux-generated module TUs leave this unset so those same header names forward to the engine.
+#define VFCORE_USE_COMPAT 1
+
 // Every standard or platform header used by the copied implementation must be included before
 // its wrapper opens vfcore::detail. This prevents system declarations from being nested in the
 // private namespace when the implementation includes its Unreal-shaped compatibility headers.
@@ -56,6 +60,7 @@
 #include "VoxelForgeCore/VoxelForgeCore.h"
 #include "VoxelForgeCore/ThreadLocalStorage.h"
 #include "VoxelForgeCore/SharedColumnCache.h"
+#include "VoxelForgeCore/FloatingIslandInstrumentation.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.

Standalone/Core/src/FarShellsInternal.h

@@ -6,7 +6,10 @@
 
 #include <algorithm>
 #include <array>
+#include <bit>
 #include <cmath>
+#include <cstdio>
+#include <cstdlib>
 #include <cstdint>
 #include <limits>
 #include <memory>
@@ -154,6 +157,8 @@ inline bool ContainsFarTilePoint(const FVoxelTileKey& Key,const FVector& P)
 inline bool FindFarConnectorSurfaceRadius(const FStandaloneShapeWorld& Shape,const FVector& Center,
     const FVector& Direction,double PreferredRadius,double& OutRadius)
 {
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellSurfaceQuery);
     const double SearchLength=PreferredRadius*2.0+32.0;
     const double AcceptBand=std::max(16.0,PreferredRadius*0.75);
     constexpr double Stride=8.0;
@@ -227,6 +232,8 @@ inline bool FindFarConnectorSurfaceRadius(const FStandaloneShapeWorld& Shape,con
 inline bool FindFarConnectorRadiusNearNominal(const FStandaloneShapeWorld& Shape,const FVector& Center,
     const FVector& Direction,double NominalRadius,double& OutRadius,double& OutUncertainty)
 {
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellSurfaceQuery);
     const double MatchTolerance=std::max(8.0,NominalRadius*0.35);
     const double HalfWidth=std::min(16.0,MatchTolerance*0.75);
     const double Lo=std::max(0.0,NominalRadius-HalfWidth),Hi=NominalRadius+HalfWidth;
@@ -245,6 +252,8 @@ inline void AppendFarConnectorShells(const FStandaloneShapeWorld& Shape,const FV
     int32 Step,int32 Cells,FVoxelMeshData& Mesh)
 {
     if(Key.Level<6||Step<=0)return;
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellProjectionNormal);
     // Four axial panels are the coarsest cross-section the survival audit samples.
     constexpr int32 SideCount=4;
     const FIntVector TileOrigin=Key.OriginVoxels();
@@ -817,11 +826,18 @@ inline void AppendFarConnectorShells(const FStandaloneShapeWorld& Shape,const FV
 struct FFarMeshColumnIndex
 {
     FFarMeshColumnIndex(const FVoxelMeshData& InMesh,const FIntVector& InOrigin,int32 InExtent,
-                        int32 InCells,double InStep,double InVoxelSizeCm)
+                        int32 InCells,double InStep,double InVoxelSizeCm,int32 InLevel)
         :Mesh(InMesh),Origin(InOrigin),Extent(InExtent),Cells(InCells),Step(InStep),
          VoxelSizeCm(InVoxelSizeCm),
-         ByColumn(static_cast<size_t>(InCells)*InCells)
+         Level(InLevel),ByColumn(static_cast<size_t>(InCells)*InCells),
+         bUseHitIndex(UseHitIndex()),bMeasureHitStats(MeasureHitStats())
     {
+        if(bUseHitIndex)
+        {
+            const size_t CellCount=static_cast<size_t>(Cells)*Cells*Cells;
+            ByDownwardCell.resize(CellCount);
+            ByUpwardCell.resize(CellCount);
+        }
         for(int32 Triangle=0;Triangle+2<Mesh.Triangles.Num();Triangle+=3)
         {
             const int32 A=Mesh.Triangles[Triangle],B=Mesh.Triangles[Triangle+1],C=Mesh.Triangles[Triangle+2];
@@ -830,14 +846,46 @@ struct FFarMeshColumnIndex
             const double MaxX=std::max({PositionAxis(A,0),PositionAxis(B,0),PositionAxis(C,0)});
             const double MinY=std::min({PositionAxis(A,1),PositionAxis(B,1),PositionAxis(C,1)});
             const double MaxY=std::max({PositionAxis(A,1),PositionAxis(B,1),PositionAxis(C,1)});
+            const double MinZ=std::min({PositionAxis(A,2),PositionAxis(B,2),PositionAxis(C,2)});
+            const double MaxZ=std::max({PositionAxis(A,2),PositionAxis(B,2),PositionAxis(C,2)});
             const int32 X0=std::clamp(static_cast<int32>(std::floor((MinX-Origin.X)/Step)),0,Cells-1);
             const int32 X1=std::clamp(static_cast<int32>(std::floor((MaxX-Origin.X)/Step)),0,Cells-1);
             const int32 Y0=std::clamp(static_cast<int32>(std::floor((MinY-Origin.Y)/Step)),0,Cells-1);
             const int32 Y1=std::clamp(static_cast<int32>(std::floor((MaxY-Origin.Y)/Step)),0,Cells-1);
             for(int32 Y=Y0;Y<=Y1;++Y)for(int32 X=X0;X<=X1;++X)
                 ByColumn[static_cast<size_t>(Y)*Cells+X].push_back(Triangle/3);
+            if(!bUseHitIndex||A>=Mesh.Normals.Num()||B>=Mesh.Normals.Num()
+                ||C>=Mesh.Normals.Num())continue;
+            const double NormalSum=Mesh.Normals[A].Z+Mesh.Normals[B].Z+Mesh.Normals[C].Z;
+            const bool bDown=!(NormalSum>=-1.5),bUp=!(NormalSum<=1.5);
+            if(!bDown&&!bUp)continue;
+            const double ZMargin=(MaxZ-MinZ)*2.0e-7+1.0e-8;
+            const int32 Z0=std::clamp(static_cast<int32>(std::floor((MinZ-ZMargin-Origin.Z)/Step)),0,Cells-1);
+            const int32 Z1=std::clamp(static_cast<int32>(std::floor((MaxZ+ZMargin-Origin.Z)/Step)),0,Cells-1);
+            for(int32 Z=Z0;Z<=Z1;++Z)for(int32 Y=Y0;Y<=Y1;++Y)for(int32 X=X0;X<=X1;++X)
+            {
+                const size_t Cell=(static_cast<size_t>(Z)*Cells+Y)*Cells+X;
+                if(bDown)ByDownwardCell[Cell].push_back(Triangle/3);
+                if(bUp)ByUpwardCell[Cell].push_back(Triangle/3);
             }
         }
+    }
+
+    ~FFarMeshColumnIndex()
+    {
+        if(!bMeasureHitStats||DownQueries+UpQueries==0)return;
+        std::fprintf(stderr,
+            "[FarHitQueryStats] lod=%d origin=(%d,%d,%d) "
+            "down_queries=%llu down_candidate_tests=%llu down_hit_queries=%llu "
+            "up_queries=%llu up_candidate_tests=%llu up_hit_queries=%llu\n",
+            Level,Origin.X,Origin.Y,Origin.Z,
+            static_cast<unsigned long long>(DownQueries),
+            static_cast<unsigned long long>(DownCandidateTests),
+            static_cast<unsigned long long>(DownHitQueries),
+            static_cast<unsigned long long>(UpQueries),
+            static_cast<unsigned long long>(UpCandidateTests),
+            static_cast<unsigned long long>(UpHitQueries));
+    }
 
     std::vector<double> VerticalHits(double X,double Y,double ZMin,double ZMax) const
     {
@@ -867,11 +915,13 @@ struct FFarMeshColumnIndex
 
     bool HasDownwardHit(double X,double Y,double Z,double Tolerance) const
     {
-        const int32 CX=std::clamp(static_cast<int32>(std::floor((X-Origin.X)/Step)),0,Cells-1);
-        const int32 CY=std::clamp(static_cast<int32>(std::floor((Y-Origin.Y)/Step)),0,Cells-1);
-        const auto& Candidates=ByColumn[static_cast<size_t>(CY)*Cells+CX];
+        if(bMeasureHitStats)++DownQueries;
+        std::vector<int32> CandidateScratch;
+        const auto& Candidates=FindHitCandidates(X,Y,Z,Tolerance,true,CandidateScratch);
+        bool bHit=false;
         for(const int32 Triangle:Candidates)
         {
+            if(bMeasureHitStats)++DownCandidateTests;
             const int32 IA=Mesh.Triangles[Triangle*3],IB=Mesh.Triangles[Triangle*3+1],
                 IC=Mesh.Triangles[Triangle*3+2];
             if(IA<0||IB<0||IC<0||IA>=Mesh.Normals.Num()||IB>=Mesh.Normals.Num()
@@ -887,9 +937,10 @@ struct FFarMeshColumnIndex
             const double W=1.0-U-V;
             if(U<-1.0e-7||V<-1.0e-7||W<-1.0e-7)continue;
             const double Hit=AZ+U*(BZ-AZ)+V*(CZ-AZ);
-            if(std::abs(Hit-Z)<=Tolerance)return true;
+            if(std::abs(Hit-Z)<=Tolerance){bHit=true;break;}
         }
-        return false;
+        if(bMeasureHitStats&&bHit)++DownHitQueries;
+        return bHit;
     }
 
     bool HasDownwardCellCoverage(double X0,double Y0,double X1,double Y1,
@@ -911,11 +962,13 @@ struct FFarMeshColumnIndex
 
     bool HasUpwardHit(double X,double Y,double Z,double Tolerance) const
     {
-        const int32 CX=std::clamp(static_cast<int32>(std::floor((X-Origin.X)/Step)),0,Cells-1);
-        const int32 CY=std::clamp(static_cast<int32>(std::floor((Y-Origin.Y)/Step)),0,Cells-1);
-        const auto& Candidates=ByColumn[static_cast<size_t>(CY)*Cells+CX];
+        if(bMeasureHitStats)++UpQueries;
+        std::vector<int32> CandidateScratch;
+        const auto& Candidates=FindHitCandidates(X,Y,Z,Tolerance,false,CandidateScratch);
+        bool bHit=false;
         for(const int32 Triangle:Candidates)
         {
+            if(bMeasureHitStats)++UpCandidateTests;
             const int32 IA=Mesh.Triangles[Triangle*3],IB=Mesh.Triangles[Triangle*3+1],
                 IC=Mesh.Triangles[Triangle*3+2];
             if(IA<0||IB<0||IC<0||IA>=Mesh.Normals.Num()||IB>=Mesh.Normals.Num()
@@ -931,9 +984,10 @@ struct FFarMeshColumnIndex
             const double W=1.0-U-V;
             if(U<-1.0e-7||V<-1.0e-7||W<-1.0e-7)continue;
             const double Hit=AZ+U*(BZ-AZ)+V*(CZ-AZ);
-            if(std::abs(Hit-Z)<=Tolerance)return true;
+            if(std::abs(Hit-Z)<=Tolerance){bHit=true;break;}
         }
-        return false;
+        if(bMeasureHitStats&&bHit)++UpHitQueries;
+        return bHit;
     }
 
     bool HasUpwardCellCoverage(double X0,double Y0,double X1,double Y1,
@@ -946,6 +1000,53 @@ struct FFarMeshColumnIndex
     }
 
 private:
+    const std::vector<int32>& FindHitCandidates(double X,double Y,double Z,double Tolerance,
+        bool bDown,std::vector<int32>& Scratch) const
+    {
+        const int32 CX=std::clamp(static_cast<int32>(std::floor((X-Origin.X)/Step)),0,Cells-1);
+        const int32 CY=std::clamp(static_cast<int32>(std::floor((Y-Origin.Y)/Step)),0,Cells-1);
+        const size_t Column=static_cast<size_t>(CY)*Cells+CX;
+        if(!bUseHitIndex||!std::isfinite(Tolerance)||Tolerance<0.0||Step<=0.0)
+            return ByColumn[Column];
+        const int32 Z0=std::clamp(static_cast<int32>(std::floor((Z-Tolerance-Origin.Z)/Step)),
+            0,Cells-1);
+        const int32 Z1=std::clamp(static_cast<int32>(std::floor((Z+Tolerance-Origin.Z)/Step)),
+            0,Cells-1);
+        const auto& Buckets=bDown?ByDownwardCell:ByUpwardCell;
+        const size_t First=(static_cast<size_t>(Z0)*Cells+CY)*Cells+CX;
+        if(Z0==Z1)return Buckets[First];
+        Scratch.clear();
+        for(int32 BucketZ=Z0;BucketZ<=Z1;++BucketZ)
+        {
+            const size_t Cell=(static_cast<size_t>(BucketZ)*Cells+CY)*Cells+CX;
+            const auto& Candidates=Buckets[Cell];
+            Scratch.insert(Scratch.end(),Candidates.begin(),Candidates.end());
+        }
+        std::sort(Scratch.begin(),Scratch.end());
+        Scratch.erase(std::unique(Scratch.begin(),Scratch.end()),Scratch.end());
+        return Scratch;
+    }
+
+    static bool UseHitIndex()
+    {
+        static const bool Enabled=[]()
+        {
+            const char* Value=std::getenv("VOXELFORGE_L104_FAR_HIT_CACHE");
+            return Value==nullptr||Value[0]!='0'||Value[1]!='\0';
+        }();
+        return Enabled;
+    }
+
+    static bool MeasureHitStats()
+    {
+        static const bool Enabled=[]()
+        {
+            const char* Value=std::getenv("VOXELFORGE_L104_FAR_HIT_STATS");
+            return Value&&Value[0]=='1'&&Value[1]=='\0';
+        }();
+        return Enabled;
+    }
+
     double PositionAxis(int32 Index,int32 Axis) const
     {
         const FVector& P=Mesh.Vertices[Index];
@@ -957,12 +1058,19 @@ private:
     int32 Extent=0,Cells=0;
     double Step=1.0;
     double VoxelSizeCm=25.0;
+    int32 Level=0;
     std::vector<std::vector<int32>> ByColumn;
+    std::vector<std::vector<int32>> ByDownwardCell,ByUpwardCell;
+    bool bUseHitIndex=false,bMeasureHitStats=false;
+    mutable std::uint64_t DownQueries=0,DownCandidateTests=0,DownHitQueries=0;
+    mutable std::uint64_t UpQueries=0,UpCandidateTests=0,UpHitQueries=0;
 };
 
 inline std::vector<double> FindFarStratumCrossings(const FStandaloneShapeWorld& Shape,
     double X,double Y,double ZMin,double ZMax)
 {
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellSurfaceQuery);
     std::vector<double> Crossings;
     if(ZMax<=ZMin)return Crossings;
     double PreviousZ=ZMin;
@@ -990,6 +1098,8 @@ inline std::vector<double> FindFarStratumCrossings(const FStandaloneShapeWorld&
 inline bool FindNearestFarStratumCrossing(const FStandaloneShapeWorld& Shape,
     double X,double Y,double ZMin,double ZMax,double Prediction,double& OutCrossing)
 {
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellSurfaceQuery);
     if(ZMax<=ZMin||!std::isfinite(Prediction))return false;
     const int32 Center=std::clamp(static_cast<int32>(std::floor(Prediction)),
         static_cast<int32>(std::ceil(ZMin)),static_cast<int32>(std::floor(ZMax)));
@@ -1052,6 +1162,8 @@ inline void AppendFarStratumShells(const FStandaloneOwnerWorld& World,const FSta
     const FVoxelTileKey& Key,int32 Step,FVoxelMeshData& Mesh)
 {
     if(Key.Level<7||Step<4||!World.Manager)return;
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellStratumRefinement);
     struct FBoundary { double Z=0.0,HalfWidth=8.0; };
     const auto& Layout=World.Manager->GetLayout();
     std::vector<FBoundary> Boundaries;
@@ -1080,7 +1192,7 @@ inline void AppendFarStratumShells(const FStandaloneOwnerWorld& World,const FSta
     const FColor Color=bHasColors&&OldVertexCount>0?Mesh.Colors[0]:FColor(160,160,160,255);
     const int32 Cells=std::max(1,World.CoarseTileCells);
     FFarMeshColumnIndex MeshIndex(Mesh,Origin,Extent,Cells,Step,
-        static_cast<double>(World.CoreVoxelSizeMicrons)/10000.0);
+        static_cast<double>(World.CoreVoxelSizeMicrons)/10000.0,Key.Level);
     std::vector<FVector> NewVertices,NewNormals;
     std::vector<FVector2f> NewUVs;std::vector<FColor> NewColors;
     std::vector<int32> NewTriangles;
@@ -1217,9 +1329,87 @@ inline void AppendFarStratumShells(const FStandaloneOwnerWorld& World,const FSta
     Mesh.NumSurfaceVertices=OldSurfaceVertices+AddedVertices;
 }
 
+// Fill only underside cells that marching cubes missed. Active transitions use the
+// same displaced face and passage-mouth fade as the signed-distance field.
+struct FTransitionFaceReplacement
+{
+    double BaseZVoxels=0.0;
+    double MaximumDisplacementVoxels=0.0;
+    std::vector<uint8> Cells;
+};
+
+inline int32 RemoveCoarseTransitionFaceTriangles(FVoxelMeshData& Mesh,
+    const FIntVector& Origin,int32 Step,int32 GridSide,double VoxelSizeCm,
+    const std::vector<FTransitionFaceReplacement>& Replacements,bool bUpward)
+{
+    if(Step<=0||GridSide<2||VoxelSizeCm<=0.0||Replacements.empty())return 0;
+    const int32 TriangleCount=Mesh.Triangles.Num()/3;
+    const int32 OldCeilingStart=std::max(0,TriangleCount-Mesh.NumCeilingTriangles);
+    TArray<uint8> OldMasks=Mesh.TriangleSkirtFaceMasks;
+    OldMasks.SetNum(TriangleCount);
+    TArray<int32> KeptTriangles;
+    TArray<uint8> KeptMasks;
+    KeptTriangles.Reserve(Mesh.Triangles.Num());
+    KeptMasks.Reserve(TriangleCount);
+    int32 Removed=0,RemovedCeiling=0;
+    const int32 CellSide=GridSide-1;
+    for(int32 Triangle=0;Triangle<TriangleCount;++Triangle)
+    {
+        const int32 IA=Mesh.Triangles[Triangle*3];
+        const int32 IB=Mesh.Triangles[Triangle*3+1];
+        const int32 IC=Mesh.Triangles[Triangle*3+2];
+        bool bRemove=false;
+        if(OldMasks[Triangle]==0&&IA>=0&&IB>=0&&IC>=0
+            &&IA<Mesh.Vertices.Num()&&IB<Mesh.Vertices.Num()&&IC<Mesh.Vertices.Num())
+        {
+            const FVector& A=Mesh.Vertices[IA];
+            const FVector& B=Mesh.Vertices[IB];
+            const FVector& C=Mesh.Vertices[IC];
+            const FVector GeometricNormal=FVector::CrossProduct(B-A,C-A);
+            const double NormalLength=GeometricNormal.Size();
+            const double Facing=NormalLength>1.0e-12?GeometricNormal.Z/NormalLength:0.0;
+            if((bUpward&&Facing>0.35)||(!bUpward&&Facing< -0.35))
+            {
+                const double X=(A.X+B.X+C.X)/(3.0*VoxelSizeCm);
+                const double Y=(A.Y+B.Y+C.Y)/(3.0*VoxelSizeCm);
+                const double Z=(A.Z+B.Z+C.Z)/(3.0*VoxelSizeCm);
+                const int32 CellX=static_cast<int32>(std::floor((X-Origin.X)/Step));
+                const int32 CellY=static_cast<int32>(std::floor((Y-Origin.Y)/Step));
+                if(CellX>=0&&CellX<CellSide&&CellY>=0&&CellY<CellSide)
+                {
+                    const std::size_t Cell=static_cast<std::size_t>(CellY)*CellSide+CellX;
+                    for(const auto& Replacement:Replacements)
+                    {
+                        if(Cell>=Replacement.Cells.size()||!Replacement.Cells[Cell])continue;
+                        const double Margin=Replacement.MaximumDisplacementVoxels+4.0;
+                        if(Z>=Replacement.BaseZVoxels-Margin
+                            &&Z<=Replacement.BaseZVoxels+Margin)
+                        {bRemove=true;break;}
+                    }
+                }
+            }
+        }
+        if(bRemove)
+        {
+            ++Removed;
+            if(Triangle>=OldCeilingStart)++RemovedCeiling;
+            continue;
+        }
+        KeptTriangles.Add(IA);KeptTriangles.Add(IB);KeptTriangles.Add(IC);
+        KeptMasks.Add(OldMasks[Triangle]);
+    }
+    if(Removed==0)return 0;
+    Mesh.Triangles=std::move(KeptTriangles);
+    Mesh.TriangleSkirtFaceMasks=std::move(KeptMasks);
+    Mesh.NumCeilingTriangles=std::max(0,Mesh.NumCeilingTriangles-RemovedCeiling);
+    return Removed;
+}
+
 inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     const FStandaloneShapeWorld& Shape,const FVoxelTileKey& Key,int32 Step,FVoxelMeshData& Mesh)
 {
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellStratumRefinement);
     if(Key.Level<0||Step<=0||!World.Manager)return;
     const FIntVector Origin=Key.OriginVoxels();
     const int32 Extent=Key.ExtentVoxels();
@@ -1230,9 +1420,14 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     {
         double FaceZ=0.0;
         double Thickness=0.0;
+        double MaximumDisplacementVoxels=0.0;
+        std::vector<double> FaceHeights;
         std::vector<uint8> SolidAbove;
+        const VoxelForgeCore::ResolvedLayoutStratumV2* Stratum=nullptr;
+        bool bTransition=false;
     };
     std::vector<FCandidate> Candidates;
+    std::vector<FTransitionFaceReplacement> Replacements;
     const double CoreMicrons=std::max<std::uint32_t>(1,World.CoreVoxelSizeMicrons);
     for(const FStrateSlot& Slot:World.Manager->GetLayout())
     {
@@ -1243,19 +1438,34 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
         Candidate.FaceZ=static_cast<double>(Stratum->ceiling.bottomMicrometres)/CoreMicrons;
         Candidate.Thickness=static_cast<double>(Stratum->ceiling.topMicrometres
             -Stratum->ceiling.bottomMicrometres)/CoreMicrons;
-        if(Candidate.FaceZ<Origin.Z-1.0e-6||Candidate.FaceZ>Origin.Z+Extent+1.0e-6)continue;
+        Candidate.Stratum=Stratum;
+        const auto* transitionUpper=Shape.FindResolvedLayoutStratumByOrder(Stratum->order-1);
+        const bool bTransition=transitionUpper
+            &&Shape.IsResolvedLayoutTransitionActive(*transitionUpper);
+        const double displacement=bTransition?static_cast<double>(
+            Shape.ResolvedTransitionMaximumFaceDisplacementMicrometres(*transitionUpper,*Stratum))
+            /CoreMicrons:0.0;
+        if(Candidate.FaceZ<Origin.Z-displacement-1.0e-6
+            ||Candidate.FaceZ>Origin.Z+Extent+displacement+1.0e-6)continue;
+        Candidate.bTransition=bTransition;
+        Candidate.MaximumDisplacementVoxels=displacement;
         const double Epsilon=std::min(0.5,Candidate.Thickness*0.25);
         if(Epsilon<=0.0)continue;
-        Candidate.SolidAbove.resize(static_cast<std::size_t>(GridSide)*GridSide,0);
+        const std::size_t GridCount=static_cast<std::size_t>(GridSide)*GridSide;
+        Candidate.FaceHeights.resize(GridCount,Candidate.FaceZ);
+        Candidate.SolidAbove.resize(GridCount,0);
         bool AnySolidAbove=false;
         for(int32 Y=0;Y<GridSide;++Y)for(int32 X=0;X<GridSide;++X)
         {
             const double WorldX=Origin.X+X*GridStep;
             const double WorldY=Origin.Y+Y*GridStep;
+            const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
+            Candidate.bTransition=Shape.ResolvedCeilingBottomAt(*Candidate.Stratum,
+                WorldX,WorldY,Candidate.FaceHeights[GridIndex])||Candidate.bTransition;
             const float Above=Shape.DensityAt(static_cast<float>(WorldX),static_cast<float>(WorldY),
-                static_cast<float>(Candidate.FaceZ+Epsilon));
+                static_cast<float>(Candidate.FaceHeights[GridIndex]+Epsilon));
             const bool bSolidAbove=std::isfinite(Above)&&Above<0.0f;
-            Candidate.SolidAbove[static_cast<std::size_t>(Y*GridSide+X)]=bSolidAbove?1:0;
+            Candidate.SolidAbove[GridIndex]=bSolidAbove?1:0;
             AnySolidAbove=AnySolidAbove||bSolidAbove;
         }
         if(AnySolidAbove)Candidates.push_back(std::move(Candidate));
@@ -1264,7 +1474,7 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
 
     const int32 Cells=std::max(1,World.CoarseTileCells);
     FFarMeshColumnIndex MeshIndex(Mesh,Origin,Extent,Cells,Step,
-        static_cast<double>(World.CoreVoxelSizeMicrons)/10000.0);
+        static_cast<double>(World.CoreVoxelSizeMicrons)/10000.0,Key.Level);
     const int32 OldVertexCount=Mesh.Vertices.Num();
     const int32 OldSurfaceVertices=std::clamp(Mesh.NumSurfaceVertices,0,OldVertexCount);
     const bool bHasUVs=Mesh.UVs.Num()==OldVertexCount;
@@ -1277,8 +1487,19 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     std::vector<int32> NewTriangles;
     for(const FCandidate& Candidate:Candidates)
     {
-        std::vector<int32> VertexMap(static_cast<std::size_t>(GridSide)*GridSide,INDEX_NONE);
-        const double CeilingZ=Candidate.FaceZ;
+        const std::size_t GridCount=static_cast<std::size_t>(GridSide)*GridSide;
+        std::vector<int32> VertexMap(GridCount,INDEX_NONE);
+        FTransitionFaceReplacement Replacement;
+        Replacement.BaseZVoxels=Candidate.FaceZ;
+        Replacement.MaximumDisplacementVoxels=Candidate.MaximumDisplacementVoxels;
+        Replacement.Cells.resize(static_cast<std::size_t>(GridSide-1)*(GridSide-1),0);
+        const auto heightAt=[&](double X,double Y)
+        {
+            if(!Candidate.bTransition)return Candidate.FaceZ;
+            double height=Candidate.FaceZ;
+            Shape.ResolvedCeilingBottomAt(*Candidate.Stratum,X,Y,height);
+            return height;
+        };
         const auto AddVertex=[&](int32 X,int32 Y)
         {
             const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
@@ -1286,8 +1507,20 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
             if(Mapped!=INDEX_NONE)return Mapped;
             Mapped=static_cast<int32>(NewVertices.size());
             const double WorldX=Origin.X+X*GridStep,WorldY=Origin.Y+Y*GridStep;
-            NewVertices.emplace_back(WorldX*VoxelSizeCm,WorldY*VoxelSizeCm,CeilingZ*VoxelSizeCm);
-            NewNormals.emplace_back(0.0,0.0,-1.0);
+            const double FaceZ=Candidate.FaceHeights[GridIndex];
+            FVector Normal(0.0,0.0,-1.0);
+            if(Candidate.bTransition)
+            {
+                const double Delta=std::max(1.0,std::min<double>(GridStep,4.0));
+                const double DX=(heightAt(WorldX+Delta,WorldY)-heightAt(WorldX-Delta,WorldY))
+                    /(2.0*Delta);
+                const double DY=(heightAt(WorldX,WorldY+Delta)-heightAt(WorldX,WorldY-Delta))
+                    /(2.0*Delta);
+                Normal=FVector(DX,DY,-1.0);
+                Normal.Normalize();
+            }
+            NewVertices.emplace_back(WorldX*VoxelSizeCm,WorldY*VoxelSizeCm,FaceZ*VoxelSizeCm);
+            NewNormals.push_back(Normal);
             if(bHasUVs)NewUVs.emplace_back(static_cast<float>(WorldX),static_cast<float>(WorldY));
             if(bHasColors)NewColors.push_back(Color);
             return Mapped;
@@ -1300,15 +1533,40 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
                 ||!Candidate.SolidAbove[I01]||!Candidate.SolidAbove[I11])continue;
             const double CellX0=Origin.X+X*GridStep,CellY0=Origin.Y+Y*GridStep;
             const double CellX1=CellX0+GridStep,CellY1=CellY0+GridStep;
-            // Suppress a coincident plane only when it covers the full cell. A hit at just the
-            // center of a curved shell triangle is not enough to leave the rest of this cap cell open.
-            if(MeshIndex.HasDownwardCellCoverage(CellX0,CellY0,CellX1,CellY1,CeilingZ,0.001))continue;
+            bool fullyCovered=false;
+            if(!Candidate.bTransition)
+                fullyCovered=MeshIndex.HasDownwardCellCoverage(
+                    CellX0,CellY0,CellX1,CellY1,Candidate.FaceZ,0.001);
+            else
+            {
+                fullyCovered=true;
+                constexpr double CoverageSamples[5][2]={
+                    {0.0,0.0},{1.0,0.0},{0.0,1.0},{1.0,1.0},{0.5,0.5}};
+                for(const auto& Sample:CoverageSamples)
+                {
+                    const double U=Sample[0],V=Sample[1];
+                    const double SampleX=CellX0+(CellX1-CellX0)*U;
+                    const double SampleY=CellY0+(CellY1-CellY0)*V;
+                    const double SampleZ=heightAt(SampleX,SampleY);
+                    if(!MeshIndex.HasDownwardHit(SampleX,SampleY,SampleZ,0.25))
+                        fullyCovered=false;
+                }
+            }
+            if(fullyCovered)continue;
+            if(Key.Level>=4&&Candidate.bTransition)
+                Replacement.Cells[static_cast<std::size_t>(Y)*(GridSide-1)+X]=1;
             const int32 A=AddVertex(X,Y),B=AddVertex(X+1,Y);
             const int32 C=AddVertex(X+1,Y+1),D=AddVertex(X,Y+1);
             NewTriangles.insert(NewTriangles.end(),{A,C,B,A,D,C});
         }
+        if(Key.Level>=4&&Candidate.bTransition
+            &&std::any_of(Replacement.Cells.begin(),Replacement.Cells.end(),
+                [](uint8 Value){return Value!=0;}))
+            Replacements.push_back(std::move(Replacement));
     }
     if(NewTriangles.empty())return;
+    const int32 removedCoarse=RemoveCoarseTransitionFaceTriangles(Mesh,Origin,GridStep,
+        GridSide,VoxelSizeCm,Replacements,false);
 
     const int32 AddedVertices=static_cast<int32>(NewVertices.size());
     auto InsertVertices=[&](auto& Existing,const auto& Added)
@@ -1347,19 +1605,28 @@ inline void AppendStratumBoundaryCeilings(const FStandaloneOwnerWorld& World,
     Mesh.NumCeilingTriangles+=static_cast<int32>(NewTriangles.size()/3);
 }
 
-// Add the interior-facing top of each bedrock band. The density composition already
-// makes this band solid and editable; this planar closure keeps its visible floor
-// continuous when a coarse marching-cubes step would otherwise skip a sub-voxel band.
+// Fill only top cells that marching cubes missed. Active transitions use the same
+// displaced face and passage-mouth fade as the signed-distance field.
 inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
     const FStandaloneShapeWorld& Shape,const FVoxelTileKey& Key,int32 Step,FVoxelMeshData& Mesh)
 {
+    FStandaloneShapeWorld::FScopedPassageDensityQueryCaller queryCaller(
+        EPassageDensityQueryCaller::FarShellStratumRefinement);
     if(Key.Level<0||Step<=0||!World.Manager||!Shape.ResolvedLayout)return;
     const FIntVector Origin=Key.OriginVoxels();
     const int32 Extent=Key.ExtentVoxels();
     if(Extent<=0||Extent%Step!=0)return;
     const int32 GridSide=Extent/Step+1;
-    struct FCandidate { double FloorZ=0.0; double Thickness=0.0; };
+    struct FCandidate
+    {
+        double FloorZ=0.0;
+        double Thickness=0.0;
+        double MaximumDisplacementVoxels=0.0;
+        const VoxelForgeCore::ResolvedLayoutStratumV2* Stratum=nullptr;
+        bool bTransition=false;
+    };
     std::vector<FCandidate> Candidates;
+    std::vector<FTransitionFaceReplacement> Replacements;
     const double CoreMicrons=std::max<std::uint32_t>(1,World.CoreVoxelSizeMicrons);
     for(const FStrateSlot& Slot:World.Manager->GetLayout())
     {
@@ -1367,15 +1634,23 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
         if(!Stratum||!Stratum->bedrock.presentInCurrentField
             ||Stratum->bedrock.topMicrometres<=Stratum->bedrock.bottomMicrometres)continue;
         const double FloorZ=static_cast<double>(Stratum->bedrock.topMicrometres)/CoreMicrons;
-        if(FloorZ<Origin.Z-1.0e-6||FloorZ>Origin.Z+Extent+1.0e-6)continue;
+        const auto* transitionLower=Shape.FindResolvedLayoutStratumByOrder(Stratum->order+1);
+        const bool bTransition=transitionLower
+            &&Shape.IsResolvedLayoutTransitionActive(*Stratum);
+        const double displacement=bTransition
+            ?static_cast<double>(Shape.ResolvedTransitionMaximumFaceDisplacementMicrometres(
+                *Stratum,*transitionLower))/CoreMicrons
+            :0.0;
+        if(FloorZ<Origin.Z-displacement-1.0e-6
+            ||FloorZ>Origin.Z+Extent+displacement+1.0e-6)continue;
         Candidates.push_back({FloorZ,static_cast<double>(Stratum->bedrock.topMicrometres
-            -Stratum->bedrock.bottomMicrometres)/CoreMicrons});
+            -Stratum->bedrock.bottomMicrometres)/CoreMicrons,displacement,Stratum,bTransition});
     }
     if(Candidates.empty())return;
 
     const int32 Cells=std::max(1,World.CoarseTileCells);
     FFarMeshColumnIndex MeshIndex(Mesh,Origin,Extent,Cells,Step,
-        static_cast<double>(World.CoreVoxelSizeMicrons)/10000.0);
+        static_cast<double>(World.CoreVoxelSizeMicrons)/10000.0,Key.Level);
     const int32 OldVertexCount=Mesh.Vertices.Num();
     const int32 OldSurfaceVertices=std::clamp(Mesh.NumSurfaceVertices,0,OldVertexCount);
     const bool bHasUVs=Mesh.UVs.Num()==OldVertexCount;
@@ -1390,16 +1665,34 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
     {
         const double Epsilon=std::min(0.5,Candidate.Thickness*0.25);
         if(Epsilon<=0.0)continue;
-        std::vector<uint8> SolidBelow(static_cast<std::size_t>(GridSide)*GridSide,0);
+        const std::size_t GridCount=static_cast<std::size_t>(GridSide)*GridSide;
+        std::vector<double> faceHeights(GridCount,Candidate.FloorZ);
+        std::vector<uint8> solidBelow(GridCount,0);
+        FTransitionFaceReplacement Replacement;
+        Replacement.BaseZVoxels=Candidate.FloorZ;
+        Replacement.MaximumDisplacementVoxels=Candidate.MaximumDisplacementVoxels;
+        Replacement.Cells.resize(static_cast<std::size_t>(GridSide-1)*(GridSide-1),0);
         for(int32 Y=0;Y<GridSide;++Y)for(int32 X=0;X<GridSide;++X)
         {
             const double WorldX=Origin.X+X*Step,WorldY=Origin.Y+Y*Step;
+            const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
+            if(Candidate.bTransition)
+                Shape.ResolvedBedrockTopAt(*Candidate.Stratum,WorldX,WorldY,
+                    faceHeights[GridIndex]);
             const float Density=Shape.DensityAt(static_cast<float>(WorldX),static_cast<float>(WorldY),
-                static_cast<float>(Candidate.FloorZ-Epsilon));
-            SolidBelow[static_cast<std::size_t>(Y*GridSide+X)]=
+                static_cast<float>(faceHeights[GridIndex]-Epsilon));
+            solidBelow[GridIndex]=
                 std::isfinite(Density)&&Density<0.0f?1:0;
         }
-        std::vector<int32> VertexMap(static_cast<std::size_t>(GridSide)*GridSide,INDEX_NONE);
+        const auto heightAt=[&](double X,double Y)
+        {
+            if(!Candidate.bTransition)return Candidate.FloorZ;
+            double height=Candidate.FloorZ;
+            if(Candidate.bTransition)
+                Shape.ResolvedBedrockTopAt(*Candidate.Stratum,X,Y,height);
+            return height;
+        };
+        std::vector<int32> VertexMap(GridCount,INDEX_NONE);
         const auto AddVertex=[&](int32 X,int32 Y)
         {
             const std::size_t GridIndex=static_cast<std::size_t>(Y*GridSide+X);
@@ -1407,9 +1700,20 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
             if(Mapped!=INDEX_NONE)return Mapped;
             Mapped=static_cast<int32>(NewVertices.size());
             const double WorldX=Origin.X+X*Step,WorldY=Origin.Y+Y*Step;
+            FVector Normal(0.0,0.0,1.0);
+            if(Candidate.bTransition)
+            {
+                const double Delta=std::max(1.0,std::min<double>(Step,4.0));
+                const double DX=(heightAt(WorldX+Delta,WorldY)-heightAt(WorldX-Delta,WorldY))
+                    /(2.0*Delta);
+                const double DY=(heightAt(WorldX,WorldY+Delta)-heightAt(WorldX,WorldY-Delta))
+                    /(2.0*Delta);
+                Normal=FVector(-DX,-DY,1.0);
+                Normal.Normalize();
+            }
             NewVertices.emplace_back(WorldX*VoxelSizeCm,WorldY*VoxelSizeCm,
-                Candidate.FloorZ*VoxelSizeCm);
-            NewNormals.emplace_back(0.0,0.0,1.0);
+                faceHeights[GridIndex]*VoxelSizeCm);
+            NewNormals.push_back(Normal);
             if(bHasUVs)NewUVs.emplace_back(static_cast<float>(WorldX),static_cast<float>(WorldY));
             if(bHasColors)NewColors.push_back(Color);
             return Mapped;
@@ -1418,16 +1722,43 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
         {
             const std::size_t I00=static_cast<std::size_t>(Y*GridSide+X);
             const std::size_t I10=I00+1,I01=I00+GridSide,I11=I01+1;
-            if(!SolidBelow[I00]||!SolidBelow[I10]||!SolidBelow[I01]||!SolidBelow[I11])continue;
+            if(!solidBelow[I00]||!solidBelow[I10]||!solidBelow[I01]||!solidBelow[I11])continue;
             const double X0=Origin.X+X*Step,Y0=Origin.Y+Y*Step;
             const double X1=X0+Step,Y1=Y0+Step;
-            if(MeshIndex.HasUpwardCellCoverage(X0,Y0,X1,Y1,Candidate.FloorZ,0.001))continue;
+            bool fullyCovered=false;
+            if(!Candidate.bTransition)
+                fullyCovered=MeshIndex.HasUpwardCellCoverage(
+                    X0,Y0,X1,Y1,Candidate.FloorZ,0.001);
+            else
+            {
+                fullyCovered=true;
+                constexpr double CoverageSamples[5][2]={
+                    {0.0,0.0},{1.0,0.0},{0.0,1.0},{1.0,1.0},{0.5,0.5}};
+                for(const auto& Sample:CoverageSamples)
+                {
+                    const double U=Sample[0],V=Sample[1];
+                    const double SampleX=X0+(X1-X0)*U;
+                    const double SampleY=Y0+(Y1-Y0)*V;
+                    const double SampleZ=heightAt(SampleX,SampleY);
+                    if(!MeshIndex.HasUpwardHit(SampleX,SampleY,SampleZ,0.25))
+                        fullyCovered=false;
+                }
+            }
+            if(fullyCovered)continue;
+            if(Key.Level>=4&&Candidate.bTransition)
+                Replacement.Cells[static_cast<std::size_t>(Y)*(GridSide-1)+X]=1;
             const int32 A=AddVertex(X,Y),B=AddVertex(X+1,Y);
             const int32 C=AddVertex(X+1,Y+1),D=AddVertex(X,Y+1);
             NewTriangles.insert(NewTriangles.end(),{A,B,C,A,C,D});
         }
+        if(Key.Level>=4&&Candidate.bTransition
+            &&std::any_of(Replacement.Cells.begin(),Replacement.Cells.end(),
+                [](uint8 Value){return Value!=0;}))
+            Replacements.push_back(std::move(Replacement));
     }
     if(NewTriangles.empty())return;
+    const int32 removedCoarse=RemoveCoarseTransitionFaceTriangles(Mesh,Origin,Step,
+        GridSide,VoxelSizeCm,Replacements,true);
 
     const int32 AddedVertices=static_cast<int32>(NewVertices.size());
     auto InsertVertices=[&](auto& Existing,const auto& Added)

Standalone/Core/src/FloatingIslandsInternal.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include "VoxelForgeCore/ThreadLocalStorage.h"
+#include "VoxelForgeCore/CpuCycleCounter.h"
+#include "VoxelForgeCore/FloatingIslandInstrumentation.h"
+#include "VoxelForgeCore/SharedColumnCache.h"
 #include "Json.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 
@@ -203,6 +206,7 @@ namespace floating_island_detail
         HashWord(hash, static_cast<std::uint64_t>(recipe.boundarySealSubvoxels), 8);
         HashWord(hash, static_cast<std::uint64_t>(recipe.bridgeHalfWidthSubvoxels), 8);
         HashWord(hash, static_cast<std::uint64_t>(recipe.bridgeThicknessSubvoxels), 8);
+        if(recipe.terrainFollowingRoute)HashWord(hash,1,1);
         HashWord(hash, HashRouteConstraints(recipe.routeConstraints), 8);
         return hash;
     }
@@ -470,13 +474,69 @@ namespace floating_island_detail
         double DeltaX=0.0,DeltaY=0.0,Radial=0.0,Angle=0.0,LobePhase=0.0,TopSurface=0.0;
     };
 
+    struct FIslandColumnCacheInstrumentation
+    {
+        std::uint64_t localHits=0,localMisses=0,localConflictReplacements=0;
+        std::uint64_t localProbeCycles=0,localProbeSamples=0;
+        std::uint64_t tileStartCycles=0,tileCycles=0;
+        VoxelForgeCoreShared::FColumnCacheMetrics shared;
+        FIslandFieldAttributionInstrumentation attribution;
+    };
+
+    inline FIslandColumnCacheInstrumentation*& ActiveIslandColumnCacheInstrumentation() noexcept
+    {
+        static thread_local FIslandColumnCacheInstrumentation* active=nullptr;
+        return active;
+    }
+
+    inline FIslandColumnCacheInstrumentation* SetIslandColumnCacheInstrumentation(
+        FIslandColumnCacheInstrumentation* value) noexcept
+    {
+        FIslandColumnCacheInstrumentation* previous=ActiveIslandColumnCacheInstrumentation();
+        ActiveIslandColumnCacheInstrumentation()=value;
+        SetActiveIslandFieldAttribution(value?&value->attribution:nullptr);
+        return previous;
+    }
+
     using FSharedIslandColumnCache =
         VoxelForgeCoreShared::TSharedColumnValueCache<FIslandColumnCacheEntry,16384,4>;
 
+    struct FIslandColumnTraceKey
+    {
+        bool valid=false;
+        std::uint64_t recipeHash=0,planHash=0,island=0;
+        std::int64_t x=0,y=0;
+    };
+
+    struct FIslandColumnReuseTrace
+    {
+        std::array<FIslandColumnTraceKey,128> recentMisses{};
+        std::array<FIslandColumnTraceKey,128> recentEvictions{};
+        std::uint64_t missSequence=0,printedEvents=0;
+    };
+
+    inline bool SameTraceKey(const FIslandColumnTraceKey& left,
+                             const FIslandColumnTraceKey& right) noexcept
+    {
+        return left.valid&&right.valid&&left.recipeHash==right.recipeHash
+            &&left.planHash==right.planHash&&left.island==right.island
+            &&left.x==right.x&&left.y==right.y;
+    }
+
+    inline std::size_t TraceKeyIndex(const FIslandColumnTraceKey& key) noexcept
+    {
+        std::uint64_t hash=key.island^static_cast<std::uint64_t>(key.x)*0x9e3779b97f4a7c15ull
+            ^static_cast<std::uint64_t>(key.y)*0xc2b2ae3d27d4eb4full
+            ^key.recipeHash^std::rotl(key.planHash,17);
+        hash^=hash>>33;hash*=0xff51afd7ed558ccdull;hash^=hash>>33;
+        return static_cast<std::size_t>(hash&127u);
+    }
+
     inline const FIslandColumnCacheEntry& IslandColumnCache(
         const FloatingIslandRecipeV1& recipe,const FloatingIslandPlanV1& plan,
         const FloatingIslandAnchorV1& island,double x,double y)
     {
+        FScopedIslandAttributionTimer columnTimer(EIslandAttributionBucket::Column);
         // 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.
         // Les echantillons suivent les colonnes Core entieres; reutiliser les memes metriques XY.
@@ -486,6 +546,7 @@ namespace floating_island_detail
         static thread_local VoxelForgeCoreThreadLocal::FLazy<
             std::array<FIslandColumnCacheEntry,SetCount*Ways>> Cache;
         auto& cache=Cache.Get();
+        FScopedIslandAttributionTimer localProbeTimer(EIslandAttributionBucket::LocalProbe);
         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
@@ -500,6 +561,7 @@ namespace floating_island_detail
         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))];
+        bool bFoundInvalid=false;
         for(std::size_t Way=0;Way<Ways;++Way)
         {
             FIslandColumnCacheEntry& Entry=cache[Base+Way];
@@ -515,8 +577,64 @@ namespace floating_island_detail
                 &&Entry.TopHalf==island.topHalfSubvoxels
                 &&Entry.TopFlattenQ16==recipe.topFlattenQ16
                 &&Entry.ContourWarp==recipe.contourWarpSubvoxels;
-            if(bKeyMatches)return Entry;
-            if(!Entry.bValid)Replacement=&Entry;
+            if(bKeyMatches)
+            {
+                if(auto* stats=ActiveIslandColumnCacheInstrumentation())++stats->localHits;
+                return Entry;
+            }
+            if(!Entry.bValid&&!bFoundInvalid)
+            {Replacement=&Entry;bFoundInvalid=true;}
+        }
+        localProbeTimer.Stop();
+        if(auto* stats=ActiveIslandColumnCacheInstrumentation())
+        {
+            ++stats->localMisses;
+            if(!bFoundInvalid)++stats->localConflictReplacements;
+            static thread_local FIslandColumnReuseTrace trace;
+            if((++trace.missSequence&1023u)==0)
+            {
+                auto& a=stats->attribution;
+                ++a.traceSampledMisses;
+                const FIslandColumnTraceKey requested{true,recipe.contentHash,
+                    plan.contentHash,island.stableId,SampleX,SampleY};
+                const std::size_t requestSlot=TraceKeyIndex(requested);
+                const bool seenBefore=SameTraceKey(trace.recentMisses[requestSlot],requested);
+                const bool reusedEviction=SameTraceKey(
+                    trace.recentEvictions[requestSlot],requested);
+                if(seenBefore)++a.traceSeenBefore;
+                if(reusedEviction)
+                {
+                    ++a.traceReusedEvictions;
+                    trace.recentEvictions[requestSlot].valid=false;
+                }
+                FIslandColumnTraceKey evicted{};
+                std::size_t replacementWay=0;
+                if(!bFoundInvalid&&Replacement)
+                {
+                    evicted={Replacement->bValid,Replacement->RecipeContentHash,
+                        Replacement->PlanContentHash,Replacement->StableId,
+                        Replacement->SampleX,Replacement->SampleY};
+                    replacementWay=static_cast<std::size_t>(Replacement-&cache[Base]);
+                    ++a.traceEvictions;
+                    if(evicted.valid)
+                        trace.recentEvictions[TraceKeyIndex(evicted)]=evicted;
+                }
+                trace.recentMisses[requestSlot]=requested;
+                if(trace.printedEvents<16&&a.traceCount<a.traceSet.size())
+                {
+                    const std::size_t event=a.traceCount++;
+                    ++trace.printedEvents;
+                    a.traceSet[event]=Base/Ways;
+                    a.traceX[event]=SampleX;a.traceY[event]=SampleY;
+                    a.traceIsland[event]=island.stableId;
+                    a.traceEvictedX[event]=evicted.valid?evicted.x:0;
+                    a.traceEvictedY[event]=evicted.valid?evicted.y:0;
+                    a.traceEvictedIsland[event]=evicted.valid?evicted.island:0;
+                    a.traceFlags[event]=static_cast<std::uint8_t>(
+                        (!bFoundInvalid?1u:0u)|(seenBefore?2u:0u)|(reusedEviction?4u:0u)
+                        |(replacementWay<<3));
+                }
+            }
         }
 
         const auto build=[&]()
@@ -543,9 +661,14 @@ namespace floating_island_detail
             Entry.Radial=std::hypot(Entry.DeltaX,Entry.DeltaY);
             Entry.Angle=std::atan2(Entry.DeltaY,Entry.DeltaX);
             Entry.LobePhase=LobePhase(recipe,island);
+            double contourOffset=0.0;
+            {
+                FScopedIslandAttributionTimer helixTimer(EIslandAttributionBucket::Helix);
+                contourOffset=LobeOffsetWithPhase(recipe,Entry.Angle,
+                    static_cast<double>(island.topZSubvoxels),Entry.LobePhase);
+            }
             const double EffectiveRadius=std::max(1.0,static_cast<double>(island.radiusSubvoxels)
-                +LobeOffsetWithPhase(recipe,Entry.Angle,static_cast<double>(island.topZSubvoxels),
-                    Entry.LobePhase));
+                +contourOffset);
             const double Edge=std::clamp(Entry.Radial/EffectiveRadius,0.0,1.0);
             const double Drop=(1.0-Q16ToDouble(recipe.topFlattenQ16))
                 *static_cast<double>(island.topHalfSubvoxels)*2.0*Edge*Edge;
@@ -561,7 +684,12 @@ namespace floating_island_detail
                 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);
+            auto* stats=ActiveIslandColumnCacheInstrumentation();
+            {
+                FScopedIslandAttributionTimer sharedCacheTimer(EIslandAttributionBucket::SharedCache);
+                Entry=shared->getOrCompute(key,build,computed,
+                    stats?&stats->shared:nullptr);
+            }
         }
         else Entry=build();
         *Replacement=Entry;
@@ -624,6 +752,7 @@ namespace floating_island_detail
                                   const FloatingIslandAnchorV1& island,
                                   std::int32_t rootIndex, double x, double y, double z)
     {
+        FScopedIslandAttributionTimer attributionTimer(EIslandAttributionBucket::Root);
         // Cache derived root constants per worker. The complete immutable input key keeps this
         // value-only cache safe across worlds, epochs and worker schedules.
         // Mettre en cache les constantes par worker; la cle complete evite tout partage d'etat.
@@ -694,6 +823,38 @@ namespace floating_island_detail
         return (std::sqrt(std::max(q, 0.0)) - 1.0) * Parameters.MinimumRadius;
     }
 
+    inline FRootLobeParameters RootLobeParametersForBounds(
+        const FloatingIslandRecipeV1& recipe,const FloatingIslandAnchorV1& island,
+        std::int32_t rootIndex)
+    {
+        constexpr std::array<std::array<double,2>,4> pattern{{
+            {{-0.92,-0.12}},{{0.28,0.98}},{{0.83,-0.42}},{{-0.16,-0.94}}}};
+        const std::uint64_t salt=0x524f4f540000ull+static_cast<std::uint64_t>(rootIndex);
+        const std::uint64_t roll=Roll(recipe.seed,island.stableId,salt);
+        const double radius=static_cast<double>(island.radiusSubvoxels);
+        const double rootDepth=radius*Q16ToDouble(recipe.rootDepthRatioQ16);
+        const double crustBottom=static_cast<double>(IslandCrustBottom(recipe,island));
+        const bool centralButtress=rootIndex==4;
+        const double orbit=centralButtress?0.0:radius*(0.17+0.07*UnitHash(roll));
+        const double rootX=static_cast<double>(island.centerSubvoxels[0])
+            +(centralButtress?0.0:pattern[static_cast<std::size_t>(rootIndex)][0]*orbit);
+        const double rootY=static_cast<double>(island.centerSubvoxels[1])
+            +(centralButtress?0.0:pattern[static_cast<std::size_t>(rootIndex)][1]*orbit);
+        const double shortRootVariation=UnitHash(Roll(recipe.seed,island.stableId,salt^0x4c454eull));
+        const double lengthRatio=centralButtress?1.0:(rootIndex==0?1.0
+            :Q16ToDouble(island.taperEndQ16)*(0.82+0.18*shortRootVariation));
+        const double lowerDepth=rootDepth*lengthRatio;
+        const double embedDepth=rootDepth*(centralButtress?0.22:(rootIndex==0?0.30:0.22));
+        const double verticalRadius=0.5*(lowerDepth+embedDepth);
+        const double centerZ=crustBottom+0.5*(embedDepth-lowerDepth);
+        const double rx=radius*(centralButtress?0.25
+            :0.15+0.055*UnitHash(Roll(recipe.seed,island.stableId,salt^0x5258ull)));
+        const double ry=radius*(centralButtress?0.25
+            :0.15+0.065*UnitHash(Roll(recipe.seed,island.stableId,salt^0x5259ull)));
+        return {rootX,rootY,centerZ,rx*rx,ry*ry,verticalRadius*verticalRadius,
+            std::min({rx,ry,verticalRadius})};
+    }
+
     inline double ApplySurfaceDetail(const FloatingIslandRecipeV1& recipe,
                                      std::uint64_t featureId, double structural,
                                      double x, double y, double z, double detailScale = 1.0)
@@ -712,6 +873,7 @@ namespace floating_island_detail
                                 const FloatingIslandAnchorV1& island,
                                 double x, double y, double z)
     {
+        FScopedIslandAttributionTimer islandTimer(EIslandAttributionBucket::Island);
         if (recipe.geometryVersion < 2)
         {
             const double dx = x - static_cast<double>(island.centerSubvoxels[0]);
@@ -739,8 +901,13 @@ namespace floating_island_detail
         const double radial=Column.Radial;
         const double topZ = static_cast<double>(island.topZSubvoxels);
         const double radius = static_cast<double>(island.radiusSubvoxels);
+        double contourOffset=0.0;
+        {
+            FScopedIslandAttributionTimer helixTimer(EIslandAttributionBucket::Helix);
+            contourOffset=LobeOffsetWithPhase(recipe,Column.Angle,z,Column.LobePhase);
+        }
         const double effectiveRadius = std::max(0.0,
-            radius + LobeOffsetWithPhase(recipe,Column.Angle,z,Column.LobePhase));
+            radius + contourOffset);
         const double edge = std::clamp(radial / std::max(effectiveRadius, 1.0), 0.0, 1.0);
         const double lowerSurface = static_cast<double>(IslandCrustBottom(recipe, island))
             + radius * 0.16 * edge * edge;
@@ -787,6 +954,7 @@ namespace floating_island_detail
                                    bool* topSurface = nullptr,
                                    double* alongFraction = nullptr)
     {
+        FScopedIslandAttributionTimer connectorTimer(EIslandAttributionBucket::Connector);
         const double ax = static_cast<double>(edge.startSubvoxels[0]);
         const double ay = static_cast<double>(edge.startSubvoxels[1]);
         const double az = static_cast<double>(edge.startSubvoxels[2]);
@@ -805,7 +973,37 @@ namespace floating_island_detail
         const double t = std::clamp(along / length, 0.0, 1.0);
         if (alongFraction) *alongFraction = t;
         const double deck = az + (static_cast<double>(edge.endSubvoxels[2]) - az) * t;
+        const std::uint64_t westernEdgeId = StableId(recipe.seed, 0x200000000ull,
+            0x425249444745ull);
+        const bool westernSupportConnector=edge.stableId==westernEdgeId;
+        if(recipe.geometryVersion>=2&&WorldAssemblyEvaluatorVersion>=183
+            &&westernSupportConnector)
+        {
+            const double phase=static_cast<double>(Roll(recipe.seed,edge.stableId,0x5749445448ull)
+                &0xffffffffull)*(2.0*Pi/4294967296.0);
+            const double localHalfWidth=std::max(
+                static_cast<double>(recipe.routeConstraints.capsuleRadiusSubvoxels+Q),
+                static_cast<double>(edge.halfWidthSubvoxels)
+                    +0.48*static_cast<double>(Q)*std::sin(6.0*Pi*t+phase));
+            const double localThickness=static_cast<double>(edge.thicknessSubvoxels);
+            const double rounding=std::min({1.5*static_cast<double>(Q),
+                localHalfWidth*0.6,localThickness*0.45});
+            const double roundedX=side-(localHalfWidth-rounding);
+            const double roundedY=std::abs(along-0.5*length)-(0.5*length-rounding);
+            const double roundedZ=std::abs(z-(deck-0.5*localThickness))
+                -(0.5*localThickness-rounding);
+            const double roundedOutside=std::sqrt(
+                std::pow(std::max(roundedX,0.0),2)
+                +std::pow(std::max(roundedY,0.0),2)
+                +std::pow(std::max(roundedZ,0.0),2));
+            const double roundedInside=std::min(std::max(roundedX,
+                std::max(roundedY,roundedZ)),0.0);
+            if(topSurface)*topSurface=z-deck>=std::max(horizontal,
+                deck-localThickness-z);
+            return roundedOutside+roundedInside-rounding;
+        }
         const double arch = recipe.geometryVersion >= 2
+                && WorldAssemblyEvaluatorVersion < 172
                 ? 2.0 * static_cast<double>(edge.thicknessSubvoxels) * (4.0 * t * (1.0 - t))
                 : 0.0;
         const double upper = z - deck;
@@ -814,6 +1012,227 @@ namespace floating_island_detail
         return std::max({horizontal, upper, lower});
     }
 
+    struct FScalarRange
+    {
+        double minimum=0.0,maximum=0.0;
+    };
+
+    struct FDensityRange
+    {
+        double minimum=0.0,maximum=0.0;
+    };
+
+    inline double DistanceToRange(double minimum,double maximum,double value)
+    {
+        if(value<minimum)return minimum-value;
+        if(value>maximum)return value-maximum;
+        return 0.0;
+    }
+
+    inline double MaximumDistanceToRange(double minimum,double maximum,double value)
+    {
+        return std::max(std::abs(minimum-value),std::abs(maximum-value));
+    }
+
+    inline FScalarRange AffineRange(double xMinimum,double xMaximum,double xOffset,
+        double xScale,double yMinimum,double yMaximum,double yOffset,double yScale)
+    {
+        const double xa=(xMinimum-xOffset)*xScale,xb=(xMaximum-xOffset)*xScale;
+        const double ya=(yMinimum-yOffset)*yScale,yb=(yMaximum-yOffset)*yScale;
+        return {std::min(xa,xb)+std::min(ya,yb),
+            std::max(xa,xb)+std::max(ya,yb)};
+    }
+
+    inline FScalarRange AbsoluteRange(double minimum,double maximum)
+    {
+        const double minimumAbsolute=minimum<=0.0&&maximum>=0.0
+            ?0.0:std::min(std::abs(minimum),std::abs(maximum));
+        return {minimumAbsolute,std::max(std::abs(minimum),std::abs(maximum))};
+    }
+
+    inline double RectangleSdf(double x,double y)
+    {
+        return std::hypot(std::max(x,0.0),std::max(y,0.0))
+            +std::min(std::max(x,y),0.0);
+    }
+
+    inline double RoundedBoxSdf(double x,double y,double z)
+    {
+        return std::sqrt(std::max(x,0.0)*std::max(x,0.0)
+            +std::max(y,0.0)*std::max(y,0.0)
+            +std::max(z,0.0)*std::max(z,0.0))
+            +std::min(std::max(x,std::max(y,z)),0.0);
+    }
+
+    inline FDensityRange RootLobeRange(const FloatingIslandRecipeV1& recipe,
+        const FloatingIslandAnchorV1& island,std::int32_t rootIndex,
+        const std::array<double,3>& minimum,const std::array<double,3>& maximum)
+    {
+        const FRootLobeParameters root=RootLobeParametersForBounds(recipe,island,rootIndex);
+        const double dxMinimum=DistanceToRange(minimum[0],maximum[0],root.RootX);
+        const double dyMinimum=DistanceToRange(minimum[1],maximum[1],root.RootY);
+        const double dzMinimum=DistanceToRange(minimum[2],maximum[2],root.CenterZ);
+        const double dxMaximum=MaximumDistanceToRange(minimum[0],maximum[0],root.RootX);
+        const double dyMaximum=MaximumDistanceToRange(minimum[1],maximum[1],root.RootY);
+        const double dzMaximum=MaximumDistanceToRange(minimum[2],maximum[2],root.CenterZ);
+        const double qMinimum=dxMinimum*dxMinimum/root.RadiusXSquared
+            +dyMinimum*dyMinimum/root.RadiusYSquared
+            +dzMinimum*dzMinimum/root.VerticalRadiusSquared;
+        const double qMaximum=dxMaximum*dxMaximum/root.RadiusXSquared
+            +dyMaximum*dyMaximum/root.RadiusYSquared
+            +dzMaximum*dzMaximum/root.VerticalRadiusSquared;
+        return {(std::sqrt(std::max(qMinimum,0.0))-1.0)*root.MinimumRadius,
+            (std::sqrt(std::max(qMaximum,0.0))-1.0)*root.MinimumRadius};
+    }
+
+    inline FDensityRange IslandDensityRange(const FloatingIslandRecipeV1& recipe,
+        const FloatingIslandAnchorV1& island,const std::array<double,3>& minimum,
+        const std::array<double,3>& maximum)
+    {
+        const double radius=static_cast<double>(island.radiusSubvoxels);
+        const double contour=static_cast<double>(recipe.contourWarpSubvoxels);
+        const double radialMinimum=std::hypot(
+            DistanceToRange(minimum[0],maximum[0],
+                static_cast<double>(island.centerSubvoxels[0])),
+            DistanceToRange(minimum[1],maximum[1],
+                static_cast<double>(island.centerSubvoxels[1])));
+        const double radialMaximum=std::max({
+            std::hypot(minimum[0]-island.centerSubvoxels[0],minimum[1]-island.centerSubvoxels[1]),
+            std::hypot(minimum[0]-island.centerSubvoxels[0],maximum[1]-island.centerSubvoxels[1]),
+            std::hypot(maximum[0]-island.centerSubvoxels[0],minimum[1]-island.centerSubvoxels[1]),
+            std::hypot(maximum[0]-island.centerSubvoxels[0],maximum[1]-island.centerSubvoxels[1])});
+
+        const double top=static_cast<double>(island.topZSubvoxels);
+        const double topDrop=std::max(0.0,(1.0-Q16ToDouble(recipe.topFlattenQ16))
+            *static_cast<double>(island.topHalfSubvoxels)*2.0);
+        const double topDistanceMinimum=minimum[2]-top;
+        const double topDistanceMaximum=maximum[2]-(top-topDrop);
+        const double sideDistanceMinimum=radialMinimum-std::max(0.0,radius+contour);
+        const double sideDistanceMaximum=recipe.geometryVersion<2
+            ?radialMaximum:radialMaximum-std::max(0.0,radius-contour);
+        double lowerMinimum=0.0,lowerMaximum=0.0;
+        if(recipe.geometryVersion<2)
+        {
+            const double bottom=static_cast<double>(island.bottomZSubvoxels);
+            lowerMinimum=bottom-maximum[2];
+            lowerMaximum=bottom-minimum[2];
+        }
+        else
+        {
+            const double crust=static_cast<double>(IslandCrustBottom(recipe,island));
+            lowerMinimum=crust-maximum[2];
+            lowerMaximum=crust+radius*0.16-minimum[2];
+        }
+        double structuralMinimum=std::max({topDistanceMinimum,
+            sideDistanceMinimum,lowerMinimum});
+        double structuralMaximum=std::max({topDistanceMaximum,
+            sideDistanceMaximum,lowerMaximum});
+
+        if(recipe.geometryVersion>=2)
+        {
+            const double rootBlend=std::clamp(radius*0.12,2.0*Q,5.0*Q);
+            for(std::int32_t root=0;root<RootCount(recipe,island);++root)
+            {
+                const FDensityRange rootRange=RootLobeRange(recipe,island,root,minimum,maximum);
+                structuralMinimum=std::min(structuralMinimum,rootRange.minimum)-rootBlend*0.25;
+                structuralMaximum=std::min(structuralMaximum,rootRange.maximum);
+            }
+            if(recipe.geometryVersion>=5&&recipe.geometryVersion<8
+                &&island.ordinal==recipe.anchorIslandOrdinal
+                &&recipe.anchorRootBottomZSubvoxels<island.bottomZSubvoxels)
+            {
+                const double rootTop=static_cast<double>(IslandCrustBottom(recipe,island));
+                const double rootBottom=static_cast<double>(recipe.anchorRootBottomZSubvoxels);
+                const double rootRadius=static_cast<double>(recipe.anchorRootRadiusSubvoxels);
+                const double anchorMinimum=std::max({radialMinimum-rootRadius,
+                    rootBottom-maximum[2],minimum[2]-rootTop});
+                const double anchorMaximum=std::max({radialMaximum-0.92*rootRadius,
+                    rootBottom-minimum[2],maximum[2]-rootTop});
+                const double anchorDetail=0.75*static_cast<double>(recipe.roughnessSubvoxels);
+                const double anchorBlend=std::clamp(rootRadius*0.12,3.0*Q,6.0*Q);
+                structuralMinimum=std::min(structuralMinimum,anchorMinimum-anchorDetail)
+                    -anchorBlend*0.25;
+                structuralMaximum=std::min(structuralMaximum,anchorMaximum+anchorDetail);
+            }
+        }
+        const double finalDetail=static_cast<double>(recipe.roughnessSubvoxels);
+        return {structuralMinimum-finalDetail,structuralMaximum+finalDetail};
+    }
+
+    inline FDensityRange ConnectorDensityRange(const FloatingIslandRecipeV1& recipe,
+        const FloatingIslandConnectorV1& edge,const std::array<double,3>& minimum,
+        const std::array<double,3>& maximum)
+    {
+        const double ax=static_cast<double>(edge.startSubvoxels[0]);
+        const double ay=static_cast<double>(edge.startSubvoxels[1]);
+        const double az=static_cast<double>(edge.startSubvoxels[2]);
+        const double dx=static_cast<double>(edge.endSubvoxels[0])-ax;
+        const double dy=static_cast<double>(edge.endSubvoxels[1])-ay;
+        const double dz=static_cast<double>(edge.endSubvoxels[2])-az;
+        const double length=std::hypot(dx,dy);
+        if(!(length>0.0))return {static_cast<double>(MaxDensity),static_cast<double>(MaxDensity)};
+        const double ux=dx/length,uy=dy/length;
+        const FScalarRange along=AffineRange(minimum[0],maximum[0],ax,ux,
+            minimum[1],maximum[1],ay,uy);
+        const FScalarRange signedSide=AffineRange(minimum[0],maximum[0],ax,-uy,
+            minimum[1],maximum[1],ay,ux);
+        const FScalarRange side=AbsoluteRange(signedSide.minimum,signedSide.maximum);
+        const double qxMinimum=side.minimum-static_cast<double>(edge.halfWidthSubvoxels);
+        const double qxMaximum=side.maximum-static_cast<double>(edge.halfWidthSubvoxels);
+        const FScalarRange alongCenter=AbsoluteRange(along.minimum-0.5*length,
+            along.maximum-0.5*length);
+        const double qyMinimum=alongCenter.minimum-0.5*length;
+        const double qyMaximum=alongCenter.maximum-0.5*length;
+        const double horizontalMinimum=RectangleSdf(qxMinimum,qyMinimum);
+        const double horizontalMaximum=RectangleSdf(qxMaximum,qyMaximum);
+
+        const double tMinimum=std::clamp(along.minimum/length,0.0,1.0);
+        const double tMaximum=std::clamp(along.maximum/length,0.0,1.0);
+        const double deckAtMinimum=az+dz*tMinimum;
+        const double deckAtMaximum=az+dz*tMaximum;
+        const double deckMinimum=std::min(deckAtMinimum,deckAtMaximum);
+        const double deckMaximum=std::max(deckAtMinimum,deckAtMaximum);
+        const std::uint64_t westernEdgeId=StableId(recipe.seed,0x200000000ull,
+            0x425249444745ull);
+        const bool westernSupportConnector=edge.stableId==westernEdgeId;
+        if(recipe.geometryVersion>=2&&WorldAssemblyEvaluatorVersion>=183
+            &&westernSupportConnector)
+        {
+            const double minimumHalfWidth=static_cast<double>(recipe.routeConstraints.capsuleRadiusSubvoxels+Q);
+            const double baseHalfWidth=static_cast<double>(edge.halfWidthSubvoxels);
+            const double halfWidthMinimum=std::max(minimumHalfWidth,baseHalfWidth-0.48*Q);
+            const double halfWidthMaximum=std::max(minimumHalfWidth,baseHalfWidth+0.48*Q);
+            const double roundingMinimum=std::min({1.5*Q,halfWidthMinimum*0.6,
+                static_cast<double>(edge.thicknessSubvoxels)*0.45});
+            const double roundingMaximum=std::min({1.5*Q,halfWidthMaximum*0.6,
+                static_cast<double>(edge.thicknessSubvoxels)*0.45});
+            const double roundedXMinimum=side.minimum-halfWidthMaximum+roundingMinimum;
+            const double roundedXMaximum=side.maximum-halfWidthMinimum+roundingMaximum;
+            const double roundedYMinimum=alongCenter.minimum-0.5*length+roundingMinimum;
+            const double roundedYMaximum=alongCenter.maximum-0.5*length+roundingMaximum;
+            const double halfThickness=0.5*static_cast<double>(edge.thicknessSubvoxels);
+            const double centerMinimum=deckMinimum-halfThickness;
+            const double centerMaximum=deckMaximum-halfThickness;
+            const double differenceMinimum=minimum[2]-centerMaximum;
+            const double differenceMaximum=maximum[2]-centerMinimum;
+            const FScalarRange absoluteDifference=AbsoluteRange(differenceMinimum,differenceMaximum);
+            const double roundedZMinimum=absoluteDifference.minimum-halfThickness+roundingMinimum;
+            const double roundedZMaximum=absoluteDifference.maximum-halfThickness+roundingMaximum;
+            return {RoundedBoxSdf(roundedXMinimum,roundedYMinimum,roundedZMinimum),
+                RoundedBoxSdf(roundedXMaximum,roundedYMaximum,roundedZMaximum)};
+        }
+
+        const double thickness=static_cast<double>(edge.thicknessSubvoxels);
+        const double maximumArch=recipe.geometryVersion>=2&&WorldAssemblyEvaluatorVersion<172
+            ?2.0*thickness:0.0;
+        const double upperMinimum=minimum[2]-deckMaximum;
+        const double upperMaximum=maximum[2]-deckMinimum;
+        const double lowerMinimum=deckMinimum-thickness-maximumArch-maximum[2];
+        const double lowerMaximum=deckMaximum-thickness-minimum[2];
+        return {std::max({horizontalMinimum,upperMinimum,lowerMinimum}),
+            std::max({horizontalMaximum,upperMaximum,lowerMaximum})};
+    }
+
     inline std::int64_t FieldDensity(const FloatingIslandRecipeV1& recipe,
                                      const FloatingIslandPlanV1& plan,
                                      std::int64_t x, std::int64_t y, std::int64_t z)
@@ -1174,8 +1593,8 @@ namespace floating_island_detail
         // Land each connector well inside the broad top so the full capsule footprint remains
         // supported across the bridge-to-island transition, including bounded surface roughness.
         // Les connecteurs recouvrent le plateau pour soutenir toute la capsule au raccord.
-        // Keep the narrow span exposed to open sky; a smaller fraction buries most of it in the island tops.
-        // Garder la passerelle etroite visible dans le vide ; une fraction plus faible l'enfouit dans les plateaux.
+        // Keep the capsule footprint supported while seating L37 connectors just below the native island tops.
+        // Garder l'appui de la capsule tout en enfouissant les connecteurs L37 juste sous les plateaux.
         const double landingFraction = recipe.geometryVersion >= 2 ? 0.52 : 0.62;
         const double fromReach = static_cast<double>(from.radiusSubvoxels) * landingFraction;
         const double toReach = static_cast<double>(to.radiusSubvoxels) * landingFraction;
@@ -1183,7 +1602,19 @@ namespace floating_island_detail
         const double sy = from.centerSubvoxels[1] + uy * fromReach;
         const double ex = to.centerSubvoxels[0] - ux * toReach;
         const double ey = to.centerSubvoxels[1] - uy * toReach;
-        const double routeDeckLift = recipe.geometryVersion >= 2 ? 1.0 * Q : 0.0;
+        const bool craterMouthConnector=WorldAssemblyEvaluatorVersion>=174
+            &&(from.ordinal==recipe.anchorIslandOrdinal
+                ||to.ordinal==recipe.anchorIslandOrdinal);
+        const bool westernSupportConnector=WorldAssemblyEvaluatorVersion>=178
+            &&((from.ordinal==0&&to.ordinal==1)||(from.ordinal==1&&to.ordinal==0));
+        const double routeDeckLift=recipe.geometryVersion>=2
+            ?(WorldAssemblyEvaluatorVersion>=178
+                ?(westernSupportConnector
+                    ?(WorldAssemblyEvaluatorVersion>=181?-1.0
+                        :(WorldAssemblyEvaluatorVersion>=180?-1.25
+                            :(WorldAssemblyEvaluatorVersion>=179?-1.5:-1.0))):-2.0)
+                :(craterMouthConnector?-2.0
+                    :(WorldAssemblyEvaluatorVersion>=172?-1.0:1.0)))*Q:0.0;
         const double sz = IslandTopSurface(recipe, from, sx, sy) + routeDeckLift;
         const double ez = IslandTopSurface(recipe, to, ex, ey) + routeDeckLift;
         edge.startSubvoxels = {RoundQ(sx), RoundQ(sy), RoundQ(sz)};
@@ -1336,6 +1767,7 @@ std::optional<FloatingIslandManifestV1> FloatingIslandManifestV1::FromJson(
                 manifest.recipe.anchorMouthOffsetSubvoxels))
         {error="floating-island geometry version 7 is missing a passage-rooted anchor field";return std::nullopt;}
     }
+    manifest.recipe.terrainFollowingRoute=recipeValue.Get("terrain_following_route").Boolean(false);
     if (!floating_island_detail::ReadU32(root.Get("schema_version"), schema)
         || !floating_island_detail::ReadHash(root.Get("content_hash"), manifestHash)
         || !floating_island_detail::ReadU32(recipeValue.Get("schema_version"), manifest.recipe.schemaVersion)
@@ -1495,6 +1927,7 @@ std::string FloatingIslandManifestV1::ToJson() const
             << ",\"anchor_island_minimum_radius_q\":" << recipe.anchorIslandMinimumRadiusSubvoxels
             << ",\"anchor_root_bottom_z_q\":" << recipe.anchorRootBottomZSubvoxels
             << ",\"anchor_mouth_offset_q\":" << recipe.anchorMouthOffsetSubvoxels;
+    if(recipe.terrainFollowingRoute)out << ",\"terrain_following_route\":true";
     out << ",\"blend_radius_q\":" << recipe.blendRadiusSubvoxels
         << ",\"contour_warp_q\":" << recipe.contourWarpSubvoxels
         << ",\"roughness_q\":" << recipe.roughnessSubvoxels
@@ -1746,6 +2179,26 @@ std::optional<FloatingIslandManifestV1> PlanFloatingIslandCluster(
             const std::int64_t y = floating_island_detail::RoundQ(
                 static_cast<double>(a.centerSubvoxels[1]) + dy * t);
             std::int64_t routeX=x,routeY=y;
+            if(WorldAssemblyEvaluatorVersion>=192&&recipe.terrainFollowingRoute
+                &&recipe.geometryVersion>=5
+                &&segment+2==count&&pieces>1)
+            {
+                const auto& anchor=islands[recipe.anchorIslandOrdinal];
+                const std::uint32_t side=static_cast<std::uint32_t>(
+                    floating_island_detail::UnitQ16(recipe.seed,anchor.stableId,
+                        0x414e43484f524d50ull)&1u);
+                const double length=std::hypot(dx,dy);
+                const double bend=10.0*floating_island_detail::Q
+                    *std::pow(std::sin(floating_island_detail::Pi*t),2.0);
+                const double sign=side?-1.0:1.0;
+                if(length>0.0)
+                {
+                    routeX=floating_island_detail::RoundQ(
+                        static_cast<double>(routeX)+sign*(-dy/length)*bend);
+                    routeY=floating_island_detail::RoundQ(
+                        static_cast<double>(routeY)+sign*(dx/length)*bend);
+                }
+            }
             if(recipe.geometryVersion>=5&&segment+2==count&&piece==pieces)
             {
                 const auto& anchor=islands[recipe.anchorIslandOrdinal];
@@ -1762,7 +2215,10 @@ std::optional<FloatingIslandManifestV1> PlanFloatingIslandCluster(
                 routeX=floating_island_detail::RoundQ(mouthX);
                 routeY=floating_island_detail::RoundQ(mouthY);
             }
-            const auto surface = floating_island_detail::FindCapsuleFootingTopZ(
+            const auto surface = WorldAssemblyEvaluatorVersion>=199
+                &&recipe.terrainFollowingRoute
+                ?floating_island_detail::FindSurfaceZ(recipe,manifest.plan,routeX,routeY)
+                :floating_island_detail::FindCapsuleFootingTopZ(
                     recipe,manifest.plan,routeX,routeY);
             if (!surface)
             { error = "island planner could not find a full capsule-width support surface along its connector chain"; return std::nullopt; }
@@ -1830,14 +2286,19 @@ bool FloatingIslandFieldV1::isValid() const noexcept
 std::int64_t FloatingIslandFieldV1::densitySubvoxels(std::int64_t x,
     std::int64_t y, std::int64_t z) const noexcept
 {
+    floating_island_detail::FScopedIslandAttributionTimer fieldTimer(
+        floating_island_detail::EIslandAttributionBucket::Field);
     // The selected evaluator validates once; do not scan the plan twice per scoped sample.
     // L'evaluateur choisi valide une seule fois; ne pas reparcourir le plan a chaque echantillon.
+    std::int64_t density=floating_island_detail::MaxDensity;
     if (const auto* list = ScopedWorldAssemblyFeatureQueriesV1::find(recipe_, plan_, x, y, z))
-        return densitySubvoxelsForTile(x, y, z, *list);
-    if (!isValid() || !floating_island_detail::ValidScalar(x)
+        density=densitySubvoxelsForTile(x, y, z, *list);
+    else if (!isValid() || !floating_island_detail::ValidScalar(x)
         || !floating_island_detail::ValidScalar(y) || !floating_island_detail::ValidScalar(z))
-        return floating_island_detail::MaxDensity;
-    return floating_island_detail::FieldDensity(*recipe_, *plan_, x, y, z);
+        density=floating_island_detail::MaxDensity;
+    else density=floating_island_detail::FieldDensity(*recipe_, *plan_, x, y, z);
+    fieldTimer.Stop();
+    return density;
 }
 
 std::vector<WorldAssemblyFeatureBoundsV1> FloatingIslandFieldV1::solidSupportBounds() const
@@ -2036,19 +2497,46 @@ FieldInterval FloatingIslandFieldV1::interval(std::int64_t minX, std::int64_t mi
         || !floating_island_detail::ValidScalar(minX) || !floating_island_detail::ValidScalar(minY)
         || !floating_island_detail::ValidScalar(minZ) || !floating_island_detail::ValidScalar(maxX)
         || !floating_island_detail::ValidScalar(maxY) || !floating_island_detail::ValidScalar(maxZ)) return result;
-    const std::array<std::int64_t, 3> minimum{minX, minY, minZ};
-    const std::array<std::int64_t, 3> maximum{maxX, maxY, maxZ};
+    using namespace floating_island_detail;
+    if (plan_->islands.empty())
+        return {true,MaxDensity,MaxDensity};
+
+    const std::array<double,3> minimum{static_cast<double>(minX),
+        static_cast<double>(minY),static_cast<double>(minZ)};
+    const std::array<double,3> maximum{static_cast<double>(maxX),
+        static_cast<double>(maxY),static_cast<double>(maxZ)};
+    double fieldMinimum=static_cast<double>(MaxDensity);
+    double fieldMaximum=static_cast<double>(MaxDensity);
     for(const auto& island:plan_->islands)
-        if (floating_island_detail::Intersects(minimum, maximum,
-                island.influenceMinimumSubvoxels, island.influenceMaximumSubvoxels)) return result;
+    {
+        FDensityRange group=IslandDensityRange(*recipe_,island,minimum,maximum);
         for(const auto& edge:plan_->clusterEdges)
-        if (floating_island_detail::Intersects(minimum, maximum,
-                edge.influenceMinimumSubvoxels, edge.influenceMaximumSubvoxels)) return result;
-    // Root is void. A box outside every lobe/taper/blend/connector influence bound proves air.
-    // La racine est le vide : une boite hors des influences bornees prouve l'air.
+        {
+            if(edge.fromIslandId!=island.stableId)continue;
+            const FDensityRange connector=ConnectorDensityRange(*recipe_,edge,minimum,maximum);
+            const double detail=recipe_->geometryVersion>=2
+                ?static_cast<double>(recipe_->roughnessSubvoxels):0.0;
+            group.minimum=std::min(group.minimum,connector.minimum-detail)
+                -static_cast<double>(recipe_->blendRadiusSubvoxels)*0.25;
+            group.maximum=std::min(group.maximum,connector.maximum+detail);
+        }
+        fieldMinimum=std::min(fieldMinimum,group.minimum);
+        fieldMaximum=std::min(fieldMaximum,group.maximum);
+    }
+    if(!std::isfinite(fieldMinimum)||!std::isfinite(fieldMaximum))return result;
+
+    // These interval operations are shared by native and future generator classifiers: SDF
+    // intersections take max, unions take min, and smooth unions subtract at most k/4.
+    // Keep two subvoxels of slack for floating bounds followed by the field's integer rounding.
+    // Ces bornes servent les generateurs actuels et futurs : intersections=max, unions=min.
+    const double minimumRounded=std::clamp(std::floor(fieldMinimum)-2.0,
+        -static_cast<double>(MaxDensity),static_cast<double>(MaxDensity));
+    const double maximumRounded=std::clamp(std::ceil(fieldMaximum)+2.0,
+        -static_cast<double>(MaxDensity),static_cast<double>(MaxDensity));
+    if(minimumRounded>maximumRounded)return result;
     result.known=true;
-    result.minimumDensitySubvoxels = 0;
-    result.maximumDensitySubvoxels = floating_island_detail::MaxDensity;
+    result.minimumDensitySubvoxels=static_cast<std::int64_t>(minimumRounded);
+    result.maximumDensitySubvoxels=static_cast<std::int64_t>(maximumRounded);
     return result;
 }
 

Standalone/Core/src/StandaloneSnapshotAdapter.h

@@ -11,5 +11,6 @@ namespace VoxelForgeCore
     // the same command-line overrides as the viewer's reference loader.
     ResolvedWorldSnapshot MakeStandaloneSnapshotFromParsedJson(const VFJson::Value& jsonRoot,
         std::int32_t seed,std::int32_t clipRadius,std::int32_t maxLodOverride,
-        bool roundTunnels,bool enhancedTunnelWalls,std::string& error);
+        bool roundTunnels,bool enhancedTunnelWalls,std::string& error,
+        bool hasUnrealResolvedCorePlan=false);
 }

Standalone/Core/src/VoxelForgeFieldShared.h

@@ -20,6 +20,7 @@
     #define VF_FIELD_CLAMP(v,a,b) clamp(v,a,b)
     #define VF_FIELD_LERP(a,b,t) lerp(a,b,t)
 #else
+    #include <array>
 #include <algorithm>
     #include <cmath>
     #include <cstdint>
@@ -244,11 +245,70 @@ VF_FIELD_INLINE float VF_FieldValueNoise(float x, float y, float z,
     return VF_FieldLerp(VF_FieldLerp(z00, z10, ty), VF_FieldLerp(z01, z11, ty), tz);
 }
 
+#if !defined(VF_FIELD_HLSL)
+struct VF_FieldValueNoiseCacheEntry
+{
+    VF_FieldI32 x=0,y=0,z=0,wavelength=0;
+    VF_FieldU32 seed=0;
+    bool valid=false;
+    std::array<float,8> corners{};
+};
+
+// Reuse the eight lattice values while adjacent voxel samples remain in the same
+// value-noise cell. Only the integer hash lookups are shared; interpolation keeps
+// the same inputs and operation order as VF_FieldValueNoise.
+VF_FIELD_INLINE float VF_FieldCachedValueNoise(float x,float y,float z,
+    VF_FieldI32 wavelength,VF_FieldU32 seed)
+{
+    static thread_local std::array<VF_FieldValueNoiseCacheEntry,64> cache{};
+    const float inv=1.0f/VF_FIELD_CAST_F32(wavelength);
+    const float fx=x*inv,fy=y*inv,fz=z*inv;
+    const VF_FieldI32 x0=VF_FIELD_CAST_I32(VF_FIELD_FLOOR(fx));
+    const VF_FieldI32 y0=VF_FIELD_CAST_I32(VF_FIELD_FLOOR(fy));
+    const VF_FieldI32 z0=VF_FIELD_CAST_I32(VF_FIELD_FLOOR(fz));
+    const VF_FieldU32 cellHash=VF_FieldMix(seed
+        ^VF_FIELD_CAST_U32(x0)*0x68E31DA4u
+        ^VF_FIELD_CAST_U32(y0)*0x1B56C4E9u
+        ^VF_FIELD_CAST_U32(z0)*0x9E3779B9u
+        ^VF_FIELD_CAST_U32(wavelength)*0x85EBCA77u);
+    auto& entry=cache[cellHash&(cache.size()-1)];
+    if(!entry.valid||entry.x!=x0||entry.y!=y0||entry.z!=z0
+        ||entry.wavelength!=wavelength||entry.seed!=seed)
+    {
+        entry.x=x0;entry.y=y0;entry.z=z0;entry.wavelength=wavelength;
+        entry.seed=seed;entry.valid=true;
+        entry.corners={
+            VF_FieldNoiseValue(x0,y0,z0,seed),
+            VF_FieldNoiseValue(x0+1,y0,z0,seed),
+            VF_FieldNoiseValue(x0,y0+1,z0,seed),
+            VF_FieldNoiseValue(x0+1,y0+1,z0,seed),
+            VF_FieldNoiseValue(x0,y0,z0+1,seed),
+            VF_FieldNoiseValue(x0+1,y0,z0+1,seed),
+            VF_FieldNoiseValue(x0,y0+1,z0+1,seed),
+            VF_FieldNoiseValue(x0+1,y0+1,z0+1,seed)};
+    }
+    const float tx=VF_FieldFade(fx-VF_FIELD_CAST_F32(x0));
+    const float ty=VF_FieldFade(fy-VF_FIELD_CAST_F32(y0));
+    const float tz=VF_FieldFade(fz-VF_FIELD_CAST_F32(z0));
+    const float z00=VF_FieldLerp(entry.corners[0],entry.corners[1],tx);
+    const float z10=VF_FieldLerp(entry.corners[2],entry.corners[3],tx);
+    const float z01=VF_FieldLerp(entry.corners[4],entry.corners[5],tx);
+    const float z11=VF_FieldLerp(entry.corners[6],entry.corners[7],tx);
+    return VF_FieldLerp(VF_FieldLerp(z00,z10,ty),VF_FieldLerp(z01,z11,ty),tz);
+}
+#endif
+
 VF_FIELD_INLINE float VF_FieldSurfaceRelief(float x, float y, float z, VF_FieldU32 seed)
 {
+#if defined(VF_FIELD_HLSL)
     const float macro = VF_FieldValueNoise(x, y, z, 32, seed ^ 0xB5297A4Du);
     const float mid = VF_FieldValueNoise(x, y, z, 16, seed ^ 0x63D83595u);
     const float fine = VF_FieldValueNoise(x, y, z, 4, seed ^ 0xA511E9B3u);
+#else
+    const float macro=VF_FieldCachedValueNoise(x,y,z,32,seed^0xB5297A4Du);
+    const float mid=VF_FieldCachedValueNoise(x,y,z,16,seed^0x63D83595u);
+    const float fine=VF_FieldCachedValueNoise(x,y,z,4,seed^0xA511E9B3u);
+#endif
     return 1.20f * macro + (0.80f + 0.25f * macro) * (0.40f * mid + 0.60f * fine);
 }
 
@@ -331,6 +391,37 @@ VF_FIELD_INLINE float VF_FieldPerlin3D(float x,float y,float z)
     return VF_FieldPerlinLerp(y0,y1,sw);
 }
 
+VF_FIELD_INLINE float VF_FieldPassageWallRelief(float x,float y,float z,VF_FieldU32 seed)
+{
+    // Use long, non-commensurate rotated scales. The shared passage wall keeps broad,
+    // uneven rock relief without a short wavelength that can read as repeated rings.
+#if defined(VF_FIELD_HLSL)
+    const float broad=VF_FieldValueNoise(x+17.0f,y-23.0f,z+11.0f,43,
+        seed^0xB5297A4Du);
+    const float mid=VF_FieldValueNoise(y-7.0f,z+19.0f,x-31.0f,29,
+        seed^0x63D83595u);
+    const float fine=VF_FieldValueNoise(z+5.0f,x+29.0f,y-13.0f,19,
+        seed^0xA511E9B3u);
+#else
+    const float broad=VF_FieldCachedValueNoise(x+17.0f,y-23.0f,z+11.0f,43,
+        seed^0xB5297A4Du);
+    const float mid=VF_FieldCachedValueNoise(y-7.0f,z+19.0f,x-31.0f,29,
+        seed^0x63D83595u);
+    const float fine=VF_FieldCachedValueNoise(z+5.0f,x+29.0f,y-13.0f,19,
+        seed^0xA511E9B3u);
+#endif
+    return 0.50f*broad+0.35f*mid+0.15f*fine;
+}
+
+VF_FIELD_INLINE float VF_FieldPassageGroundGrain(float x,float y,VF_FieldU32 seed)
+{
+    const float broad=VF_FieldValueNoise(x+3.25f,y-7.5f,0.0f,8,
+        seed^0xC2B2AE35u);
+    const float fine=VF_FieldValueNoise(y+11.75f,x-5.0f,0.0f,5,
+        seed^0x27D4EB2Fu);
+    return 0.65f*broad+0.35f*fine;
+}
+
 VF_FIELD_INLINE float VF_FieldOwnerFractal(float x,float y,float z,VF_FieldI32 octaves,
     VF_FieldI32 mode)
 {
@@ -372,9 +463,9 @@ VF_FIELD_INLINE float VF_FieldOwnerCellular(float x,float y,float z)
     {
         const VF_FieldI32 nx=cellX+dx,ny=cellY+dy,nz=cellZ+dz;
         const VF_FieldU32 h=VF_FieldVoxelHashMix(
-            VF_FIELD_CAST_U32(nx+0x7FFFFFFF)
-            ^VF_FieldVoxelHashMix(VF_FIELD_CAST_U32(ny+0x7FFFFFFF)*2654435761u)
-            ^VF_FieldVoxelHashMix(VF_FIELD_CAST_U32(nz+0x7FFFFFFF)*374761393u));
+            (VF_FIELD_CAST_U32(nx)+0x7FFFFFFFu)
+            ^VF_FieldVoxelHashMix((VF_FIELD_CAST_U32(ny)+0x7FFFFFFFu)*2654435761u)
+            ^VF_FieldVoxelHashMix((VF_FIELD_CAST_U32(nz)+0x7FFFFFFFu)*374761393u));
         const float fpx=VF_FIELD_CAST_F32(dx)
             +VF_FIELD_CAST_F32(h&0xFFFFFFu)*(1.0f/16777216.0f)-fracX;
         const VF_FieldU32 hy=VF_FieldVoxelHashMix(h^0x12345678u);

Standalone/Core/src/WorldAssemblerInternal.h

@@ -145,6 +145,12 @@ namespace world_assembly_detail
     };
 
     constexpr std::int64_t Q16 = 1ll << 16;
+    constexpr std::int64_t Q32 = 1ll << 32;
+    constexpr std::int64_t SurfaceProfileSubvoxelsPerMetre =
+        WorldAssemblySubvoxelsPerVoxel * 4;
+    constexpr std::int64_t SurfaceProfileMinimumClearanceSubvoxels = 2253;
+    constexpr std::int64_t SurfaceProfileFightClearanceSubvoxels =
+        8 * SurfaceProfileSubvoxelsPerMetre;
     constexpr std::int64_t MinimumCliffShelfThicknessSubvoxels = 2 * WorldAssemblySubvoxelsPerVoxel;
     constexpr std::int64_t MaxSerializedMagnitude = 1000000000000ll;
     constexpr std::size_t MaxBiomeCount = 8;
@@ -228,6 +234,114 @@ namespace world_assembly_detail
     inline bool OutsideRange(std::int64_t value)
     { return value < -MaxSerializedMagnitude || value > MaxSerializedMagnitude; }
 
+    inline bool IsNaturalSurfaceProfile(const WorldAssemblySurfaceProfileV1& profile)
+    { return profile.version == 0 && profile == WorldAssemblySurfaceProfileV1{}; }
+
+    inline bool ValidateSurfaceProfile(const WorldAssemblySurfaceProfileV1& profile,
+        std::uint32_t seed, std::string& error)
+    {
+        if (profile.version == 0)
+        {
+            if (!IsNaturalSurfaceProfile(profile))
+            { error = "natural SurfaceWorld profile must use the all-zero default payload"; return false; }
+            return true;
+        }
+        if (profile.version != 1
+            || !ValidScalar(profile.h0Subvoxels)
+            || !ValidScalar(profile.amplitudeXSubvoxels)
+            || !ValidScalar(profile.amplitudeYSubvoxels)
+            || !ValidScalar(profile.wavelengthXSubvoxels)
+            || !ValidScalar(profile.wavelengthYSubvoxels)
+            || !ValidScalar(profile.mirrorLambdaQ16)
+            || !ValidScalar(profile.minimumArenaClearanceSubvoxels)
+            || profile.minimumArenaClearanceSubvoxels < 0
+            || profile.minimumArenaClearanceSubvoxels > 32 * SurfaceProfileSubvoxelsPerMetre)
+        { error = "SurfaceWorld profile version or fixed-scale value is outside its supported range"; return false; }
+
+        constexpr std::int64_t MinimumPeriodAmplitude = SurfaceProfileSubvoxelsPerMetre / 2;
+        constexpr std::int64_t MaximumPeriodicAmplitude = 3 * SurfaceProfileSubvoxelsPerMetre;
+        constexpr std::int64_t MaximumMirrorAmplitude = 2 * SurfaceProfileSubvoxelsPerMetre;
+        constexpr std::int64_t MinimumWavelength = 80 * SurfaceProfileSubvoxelsPerMetre;
+        constexpr std::int64_t MaximumWavelength = 160 * SurfaceProfileSubvoxelsPerMetre;
+        const bool hasArenaClearance = profile.minimumArenaClearanceSubvoxels == 0
+            || profile.minimumArenaClearanceSubvoxels >= SurfaceProfileFightClearanceSubvoxels;
+        if (!hasArenaClearance)
+        { error = "SurfaceWorld arena clearance must be omitted or at least eight metres"; return false; }
+
+        if (profile.kind == WorldAssemblySurfaceProfileKindV1::periodicHills
+            || profile.kind == WorldAssemblySurfaceProfileKindV1::mirroredRelief)
+        {
+            const std::int64_t maximumAmplitude =
+                profile.kind == WorldAssemblySurfaceProfileKindV1::periodicHills
+                    ? MaximumPeriodicAmplitude : MaximumMirrorAmplitude;
+            if (profile.amplitudeXSubvoxels < MinimumPeriodAmplitude
+                || profile.amplitudeYSubvoxels < MinimumPeriodAmplitude
+                || profile.amplitudeXSubvoxels > maximumAmplitude
+                || profile.amplitudeYSubvoxels > maximumAmplitude
+                || profile.wavelengthXSubvoxels < MinimumWavelength
+                || profile.wavelengthYSubvoxels < MinimumWavelength
+                || profile.wavelengthXSubvoxels > MaximumWavelength
+                || profile.wavelengthYSubvoxels > MaximumWavelength)
+            { error = "periodic SurfaceWorld amplitudes or wavelengths are outside the R20 metre ranges"; return false; }
+
+            // Round every gradient component upward before applying the 15-degree bound.
+            // This makes the integer plan-time check conservative around division boundaries.
+            constexpr std::int64_t TwoPiQ16Ceiling = 411775;
+            constexpr std::int64_t Tan15Q16Floor = 17560;
+            const auto component = [](std::int64_t amplitude, std::int64_t wavelength)
+            {
+                const std::int64_t numerator = TwoPiQ16Ceiling * amplitude;
+                return (numerator + wavelength - 1) / wavelength;
+            };
+            const std::int64_t gx = component(profile.amplitudeXSubvoxels,
+                profile.wavelengthXSubvoxels);
+            const std::int64_t gy = component(profile.amplitudeYSubvoxels,
+                profile.wavelengthYSubvoxels);
+            if (gx * gx + gy * gy > Tan15Q16Floor * Tan15Q16Floor)
+            { error = "periodic SurfaceWorld maximum walk grade exceeds tan(15 degrees)"; return false; }
+
+            if (profile.kind == WorldAssemblySurfaceProfileKindV1::periodicHills)
+            {
+                if (profile.mirrorLambdaQ16 != 0
+                    || profile.phaseXTurnsQ32 != WorldAssemblySurfaceProfileSeededPhaseQ32(seed, 0)
+                    || profile.phaseYTurnsQ32 != WorldAssemblySurfaceProfileSeededPhaseQ32(seed, 1))
+                { error = "periodic-hill phases must be the stable seed-derived Q0.32 phases"; return false; }
+            }
+            else if (profile.mirrorLambdaQ16 < 49152 || profile.mirrorLambdaQ16 > Q16
+                || profile.phaseXTurnsQ32 != WorldAssemblySurfaceProfileSeededPhaseQ32(seed, 0)
+                || profile.phaseYTurnsQ32 != WorldAssemblySurfaceProfileSeededPhaseQ32(seed, 1))
+            { error = "mirrored-relief lambda or seeded phases are outside their supported range"; return false; }
+        }
+        else if (profile.kind == WorldAssemblySurfaceProfileKindV1::flatField)
+        {
+            if (profile.amplitudeXSubvoxels != 0 || profile.amplitudeYSubvoxels != 0
+                || profile.wavelengthXSubvoxels != 0 || profile.wavelengthYSubvoxels != 0
+                || profile.phaseXTurnsQ32 != 0 || profile.phaseYTurnsQ32 != 0
+                || profile.mirrorLambdaQ16 != 0)
+            { error = "flatField must not carry periodic or mirrored relief parameters"; return false; }
+        }
+        else
+        { error = "SurfaceWorld profile kind is unsupported"; return false; }
+        return true;
+    }
+
+    inline void HashSurfaceProfile(std::uint64_t& hash,
+        const WorldAssemblySurfaceProfileV1& profile)
+    {
+        HashWord(hash, 0x5355524650524f31ull, 8);
+        HashWord(hash, profile.version, 4);
+        HashWord(hash, static_cast<std::uint32_t>(profile.kind), 4);
+        HashWord(hash, static_cast<std::uint64_t>(profile.h0Subvoxels), 8);
+        HashWord(hash, static_cast<std::uint64_t>(profile.amplitudeXSubvoxels), 8);
+        HashWord(hash, static_cast<std::uint64_t>(profile.amplitudeYSubvoxels), 8);
+        HashWord(hash, static_cast<std::uint64_t>(profile.wavelengthXSubvoxels), 8);
+        HashWord(hash, static_cast<std::uint64_t>(profile.wavelengthYSubvoxels), 8);
+        HashWord(hash, profile.phaseXTurnsQ32, 4);
+        HashWord(hash, profile.phaseYTurnsQ32, 4);
+        HashWord(hash, static_cast<std::uint64_t>(profile.mirrorLambdaQ16), 8);
+        HashWord(hash, static_cast<std::uint64_t>(profile.minimumArenaClearanceSubvoxels), 8);
+    }
+
     inline bool ValidateRecipe(const WorldAssemblyRecipeV1& recipe, std::string& error)
     {
         if (recipe.schemaVersion != WorldAssemblySchemaVersion
@@ -296,16 +410,57 @@ namespace world_assembly_detail
                 || recipe.biomeClimateMoistureWavelengthSubvoxels <= 0
                 || recipe.biomeClimateReliefContrastQ16 < 0))
         { error = "world assembly climate parameters are outside the supported fixed-scale range"; return false; }
+        if (!ValidateSurfaceProfile(recipe.surfaceProfile, recipe.seed, error)) return false;
+        return true;
+    }
+
+    inline bool ValidateSurfaceProfileGeometry(const WorldAssemblySurfaceProfileV1& profile,
+        const WorldAssemblyStratumPlanV1& stratum, std::int64_t layoutChunkWidthSubvoxels,
+        std::string& error)
+    {
+        if (profile.version == 0) return true;
+        const std::int64_t relief = profile.amplitudeXSubvoxels + profile.amplitudeYSubvoxels;
+        const std::int64_t groundMinimum = profile.h0Subvoxels - relief - 2;
+        const std::int64_t groundMaximum = profile.h0Subvoxels + relief + 2;
+        std::int64_t capSwing = 0;
+        if (profile.kind == WorldAssemblySurfaceProfileKindV1::mirroredRelief)
+        {
+            const std::int64_t product = relief * profile.mirrorLambdaQ16;
+            capSwing = (product + Q16 - 1) / Q16 + 2;
+        }
+        const std::int64_t capMinimum = stratum.capHeightSubvoxels - capSwing;
+        const std::int64_t capMaximum = stratum.capHeightSubvoxels + capSwing;
+        const std::int64_t clearance = capMinimum - groundMaximum;
+        const std::int64_t requiredClearance = std::max(
+            SurfaceProfileMinimumClearanceSubvoxels,
+            profile.minimumArenaClearanceSubvoxels);
+        if (clearance < requiredClearance)
+        { error = "SurfaceWorld profile does not preserve its required floor-to-cap clearance"; return false; }
+
+        const std::int64_t stratumMinimum = static_cast<std::int64_t>(stratum.bottomChunkZ)
+            * layoutChunkWidthSubvoxels;
+        const std::int64_t stratumMaximum = (static_cast<std::int64_t>(stratum.topChunkZ) + 1)
+            * layoutChunkWidthSubvoxels;
+        if (groundMinimum <= stratumMinimum || capMaximum >= stratumMaximum)
+        { error = "SurfaceWorld profile escapes its finite stratum Z bounds"; return false; }
         return true;
     }
 
     inline bool ValidateStratum(const WorldAssemblyStratumPlanV1& stratum,
-        std::int64_t layoutChunkWidthSubvoxels, std::string& error)
+        const WorldAssemblyRecipeV1& recipe, std::string& error)
     {
+        const std::int64_t layoutChunkWidthSubvoxels = recipe.layoutChunkWidthSubvoxels;
         if (stratum.strateIndex < 0 || stratum.topChunkZ < stratum.bottomChunkZ
             || stratum.capWavelengthSubvoxels <= 0 || stratum.capUndulationSubvoxels < 0
             || stratum.features.size() > MaxFeatureCount || stratum.route.size() > MaxRoutePointCount)
         { error = "world assembly stratum plan has an invalid extent or exceeds its bounded payload"; return false; }
+        const WorldAssemblyRecipeV1& effectiveRecipe = stratum.hasRecipeOverride
+            ? stratum.recipeOverride : recipe;
+        if (!ValidateSurfaceProfile(stratum.surfaceProfile, effectiveRecipe.seed, error)) return false;
+        if (stratum.surfaceProfile != effectiveRecipe.surfaceProfile)
+        { error = "SurfaceWorld recipe and stratum plan profile payloads do not match"; return false; }
+        if (!ValidateSurfaceProfileGeometry(stratum.surfaceProfile, stratum,
+                layoutChunkWidthSubvoxels, error)) return false;
         if (!ValidScalar(stratum.capHeightSubvoxels) || !ValidScalar(stratum.capUndulationSubvoxels)
             || !ValidScalar(stratum.capWavelengthSubvoxels)
             || !ValidScalar(stratum.capDetailAmplitudeSubvoxels)
@@ -466,6 +621,8 @@ namespace world_assembly_detail
                     HashWord(hash, static_cast<std::uint64_t>(value), 8);
             }
         }
+        if (recipe.surfaceProfile.version != 0)
+            HashSurfaceProfile(hash, recipe.surfaceProfile);
         return hash;
     }
 
@@ -525,6 +682,8 @@ namespace world_assembly_detail
             for (const auto value : point.positionSubvoxels) HashWord(hash, static_cast<std::uint64_t>(value), 8);
             HashWord(hash, static_cast<std::uint64_t>(point.radiusSubvoxels), 8);
         }
+        if (stratum.surfaceProfile.version != 0)
+            HashSurfaceProfile(hash, stratum.surfaceProfile);
         return hash;
     }
 
@@ -627,6 +786,59 @@ namespace world_assembly_detail
         return out.str();
     }
 
+    inline const char* SurfaceProfileKindName(WorldAssemblySurfaceProfileKindV1 kind)
+    {
+        switch (kind)
+        {
+        case WorldAssemblySurfaceProfileKindV1::natural: return "natural";
+        case WorldAssemblySurfaceProfileKindV1::periodicHills: return "periodicHills";
+        case WorldAssemblySurfaceProfileKindV1::mirroredRelief: return "mirroredRelief";
+        case WorldAssemblySurfaceProfileKindV1::flatField: return "flatField";
+        }
+        return "unsupported";
+    }
+
+    inline bool ParseSurfaceProfile(const VFJson::Value& value,
+        WorldAssemblySurfaceProfileV1& profile)
+    {
+        if (!value.IsObject() || !ReadU32(value.Get("version"), profile.version)) return false;
+        const auto* kind = std::get_if<std::string>(&value.Get("kind").Data);
+        if (kind == nullptr) return false;
+        if (*kind == "periodicHills") profile.kind = WorldAssemblySurfaceProfileKindV1::periodicHills;
+        else if (*kind == "mirroredRelief") profile.kind = WorldAssemblySurfaceProfileKindV1::mirroredRelief;
+        else if (*kind == "flatField") profile.kind = WorldAssemblySurfaceProfileKindV1::flatField;
+        else if (*kind == "natural") profile.kind = WorldAssemblySurfaceProfileKindV1::natural;
+        else return false;
+        return ReadInteger(value.Get("h0_q"), profile.h0Subvoxels)
+            && ReadInteger(value.Get("amplitude_x_q"), profile.amplitudeXSubvoxels)
+            && ReadInteger(value.Get("amplitude_y_q"), profile.amplitudeYSubvoxels)
+            && ReadInteger(value.Get("wavelength_x_q"), profile.wavelengthXSubvoxels)
+            && ReadInteger(value.Get("wavelength_y_q"), profile.wavelengthYSubvoxels)
+            && ReadU32(value.Get("phase_x_turns_q32"), profile.phaseXTurnsQ32)
+            && ReadU32(value.Get("phase_y_turns_q32"), profile.phaseYTurnsQ32)
+            && ReadInteger(value.Get("mirror_lambda_q16"), profile.mirrorLambdaQ16)
+            && ReadInteger(value.Get("minimum_arena_clearance_q"),
+                profile.minimumArenaClearanceSubvoxels);
+    }
+
+    inline std::string SurfaceProfileJson(const WorldAssemblySurfaceProfileV1& profile)
+    {
+        std::ostringstream out;
+        out << "{\"version\":" << profile.version
+            << ",\"kind\":\"" << SurfaceProfileKindName(profile.kind) << "\""
+            << ",\"h0_q\":" << profile.h0Subvoxels
+            << ",\"amplitude_x_q\":" << profile.amplitudeXSubvoxels
+            << ",\"amplitude_y_q\":" << profile.amplitudeYSubvoxels
+            << ",\"wavelength_x_q\":" << profile.wavelengthXSubvoxels
+            << ",\"wavelength_y_q\":" << profile.wavelengthYSubvoxels
+            << ",\"phase_x_turns_q32\":" << profile.phaseXTurnsQ32
+            << ",\"phase_y_turns_q32\":" << profile.phaseYTurnsQ32
+            << ",\"mirror_lambda_q16\":" << profile.mirrorLambdaQ16
+            << ",\"minimum_arena_clearance_q\":"
+            << profile.minimumArenaClearanceSubvoxels << '}';
+        return out.str();
+    }
+
     inline bool ParseRecipe(const VFJson::Value& value, WorldAssemblyRecipeV1& recipe,
                             std::string& error)
     {
@@ -647,6 +859,10 @@ namespace world_assembly_detail
                 || !ReadInteger(value.Get("climate_moisture_wavelength_q"), recipe.biomeClimateMoistureWavelengthSubvoxels)
                 || !ReadInteger(value.Get("climate_relief_contrast_q16"), recipe.biomeClimateReliefContrastQ16)))
         { error = "world assembly recipe is missing evaluator-2 climate parameters"; return false; }
+        const VFJson::Value& surfaceProfileValue = value.Get("surface_profile");
+        if (!std::holds_alternative<std::nullptr_t>(surfaceProfileValue.Data)
+            && !ParseSurfaceProfile(surfaceProfileValue, recipe.surfaceProfile))
+        { error = "world assembly recipe has a malformed versioned SurfaceWorld profile"; return false; }
         for (const auto& item : value.Get("biomes").AsArray())
         {
             WorldAssemblyBiomeProfileV1 biome;
@@ -709,6 +925,8 @@ namespace world_assembly_detail
             out << ",\"climate_relief_wavelength_q\":" << recipe.biomeClimateReliefWavelengthSubvoxels
                 << ",\"climate_moisture_wavelength_q\":" << recipe.biomeClimateMoistureWavelengthSubvoxels
                 << ",\"climate_relief_contrast_q16\":" << recipe.biomeClimateReliefContrastQ16;
+        if (recipe.surfaceProfile.version != 0)
+            out << ",\"surface_profile\":" << SurfaceProfileJson(recipe.surfaceProfile);
         out << ",\"content_hash\":\"" << HashText(recipe.contentHash) << "\",\"biomes\":[";
         for (std::size_t i = 0; i < recipe.biomes.size(); ++i)
         {
@@ -797,6 +1015,10 @@ namespace world_assembly_detail
             { error = "world assembly stratum has malformed optional evaluator-2 fields"; return false; }
             if(hasWaterBoolean)stratum.waterEnabled=waterEnabled.Boolean(false);
             if(hasWaterNumber)stratum.waterEnabled=waterEnabled.Number()!=0.0;
+            const VFJson::Value& surfaceProfileValue = item.Get("surface_profile");
+            if (!std::holds_alternative<std::nullptr_t>(surfaceProfileValue.Data)
+                && !ParseSurfaceProfile(surfaceProfileValue, stratum.surfaceProfile))
+            { error = "world assembly stratum has a malformed versioned SurfaceWorld profile"; return false; }
             const VFJson::Value& routeConstraintsValue = item.Get("route_constraints");
             if (!std::holds_alternative<std::nullptr_t>(routeConstraintsValue.Data))
             {
@@ -1367,6 +1589,196 @@ namespace world_assembly_detail
         return SmoothQ16(static_cast<std::uint32_t>(std::clamp<std::int64_t>(edge*Q16/feather,0,Q16)));
     }
 
+    constexpr std::int64_t Q30 = 1ll << 30;
+    constexpr std::array<std::int64_t, 30> CordicAtanTurnsQ32{{
+        536870912,316933406,167458907,85004756,42667331,21354465,10679838,5340245,
+        2670163,1335087,667544,333772,166886,83443,41722,20861,10430,5215,2608,
+        1304,652,326,163,81,41,20,10,5,3,1}};
+
+    inline std::array<std::int64_t, 2> CordicSinCosQuarterQ30(std::uint32_t angleQ32)
+    {
+        if (angleQ32 == 0) return {Q30, 0};
+        std::int64_t x = 652032874, y = 0;
+        std::int64_t z = angleQ32;
+        for (std::size_t i = 0; i < CordicAtanTurnsQ32.size(); ++i)
+        {
+            const std::int64_t oldX = x;
+            if (z >= 0)
+            {
+                x -= y >> i;
+                y += oldX >> i;
+                z -= CordicAtanTurnsQ32[i];
+            }
+            else
+            {
+                x += y >> i;
+                y -= oldX >> i;
+                z += CordicAtanTurnsQ32[i];
+            }
+        }
+        return {std::clamp<std::int64_t>(x, -Q30, Q30),
+            std::clamp<std::int64_t>(y, -Q30, Q30)};
+    }
+
+    inline std::int64_t CosineQ30(std::uint32_t phaseTurnsQ32)
+    {
+        constexpr std::uint32_t Quarter = 1u << 30;
+        if (phaseTurnsQ32 == 0) return Q30;
+        if (phaseTurnsQ32 == Quarter) return 0;
+        if (phaseTurnsQ32 == 2u * Quarter) return -Q30;
+        if (phaseTurnsQ32 == 3u * Quarter) return 0;
+        constexpr std::uint32_t TableBits = 16;
+        constexpr std::uint32_t TableSize = 1u << TableBits;
+        constexpr std::uint32_t FractionMask = (1u << (32 - TableBits)) - 1u;
+        static const std::array<std::int32_t, TableSize> table = []
+        {
+            std::array<std::int32_t, TableSize> values{};
+            constexpr std::uint32_t QuarterTableSize = TableSize / 4;
+            constexpr std::uint32_t QuarterStepQ32 = 1u << (30 - (TableBits - 2));
+            std::array<std::int32_t, QuarterTableSize + 1> quarter{};
+            for (std::uint32_t offset = 0; offset <= QuarterTableSize; ++offset)
+            {
+                const std::int64_t cosine = CordicSinCosQuarterQ30(
+                    offset * QuarterStepQ32)[0];
+                const std::int64_t monotone = offset == 0 ? cosine
+                    : std::min<std::int64_t>(quarter[offset - 1], cosine);
+                quarter[offset] = static_cast<std::int32_t>(monotone);
+            }
+            for (std::uint32_t index = 0; index < TableSize; ++index)
+            {
+                const std::uint32_t quadrant = index / QuarterTableSize;
+                const std::uint32_t offset = index % QuarterTableSize;
+                const std::uint32_t mirroredOffset = QuarterTableSize - offset;
+                const std::int32_t value = quadrant == 0 ? quarter[offset]
+                    : quadrant == 1 ? -quarter[mirroredOffset]
+                    : quadrant == 2 ? -quarter[offset] : quarter[mirroredOffset];
+                values[index] = value;
+            }
+            return values;
+        }();
+        const std::uint32_t index = phaseTurnsQ32 >> (32 - TableBits);
+        const std::uint32_t fraction = phaseTurnsQ32 & FractionMask;
+        const std::int64_t first = table[index];
+        const std::int64_t second = table[(index + 1u) & (TableSize - 1u)];
+        const std::int64_t numerator = (second - first) * fraction;
+        const std::int64_t rounded = numerator >= 0
+            ? numerator + (1ll << (31 - TableBits))
+            : numerator - (1ll << (31 - TableBits));
+        // The fixed-point table interpolation is monotone within each quadrant;
+        // cosine interval bounds therefore still attain extrema at their endpoints
+        // or at the exact quarter-turn extrema checked below.
+        return first + rounded / (1ll << (32 - TableBits));
+    }
+
+    inline std::uint32_t SurfaceProfileTurnAtCoordinate(std::int64_t coordinate,
+        std::int64_t wavelength, std::uint32_t phaseTurnsQ32)
+    {
+        const std::uint64_t coordinateTurns = static_cast<std::uint64_t>(
+            FloorMod(coordinate, wavelength)) * static_cast<std::uint64_t>(Q32)
+            / static_cast<std::uint64_t>(wavelength);
+        return phaseTurnsQ32 + static_cast<std::uint32_t>(coordinateTurns);
+    }
+
+    struct CosineRangeQ30
+    {
+        std::int64_t minimum = -Q30;
+        std::int64_t maximum = Q30;
+    };
+
+    inline CosineRangeQ30 SurfaceProfileCosineRangeQ30(std::int64_t minimumCoordinate,
+        std::int64_t maximumCoordinate, std::int64_t wavelength,
+        std::uint32_t phaseTurnsQ32)
+    {
+        if (wavelength <= 0 || minimumCoordinate > maximumCoordinate
+            || maximumCoordinate - minimumCoordinate >= wavelength)
+            return {};
+
+        CosineRangeQ30 range;
+        const std::int64_t cosineAtMinimum = CosineQ30(
+            SurfaceProfileTurnAtCoordinate(minimumCoordinate, wavelength, phaseTurnsQ32));
+        const std::int64_t cosineAtMaximum = CosineQ30(
+            SurfaceProfileTurnAtCoordinate(maximumCoordinate, wavelength, phaseTurnsQ32));
+        range.minimum = std::min(cosineAtMinimum, cosineAtMaximum);
+        range.maximum = std::max(cosineAtMinimum, cosineAtMaximum);
+
+        // Coordinate turns are Q0.32. Test the exact analytic extrema in a common
+        // rational numerator domain; one Q0.32 unit of endpoint slack accounts for
+        // the fixed phase conversion used by point().
+        const std::uint64_t periodNumerator = static_cast<std::uint64_t>(wavelength)
+            * static_cast<std::uint64_t>(Q32);
+        const std::uint64_t startNumerator = (
+            static_cast<std::uint64_t>(FloorMod(minimumCoordinate, wavelength))
+                * static_cast<std::uint64_t>(Q32)
+            + static_cast<std::uint64_t>(phaseTurnsQ32)
+                * static_cast<std::uint64_t>(wavelength)) % periodNumerator;
+        const std::uint64_t spanNumerator = static_cast<std::uint64_t>(
+            maximumCoordinate - minimumCoordinate) * static_cast<std::uint64_t>(Q32);
+        const auto includesExtremum = [&](std::uint64_t target)
+        {
+            const std::uint64_t forward = target >= startNumerator
+                ? target - startNumerator : periodNumerator - startNumerator + target;
+            const std::uint64_t backward = periodNumerator - forward;
+            return forward <= spanNumerator + wavelength
+                || backward <= wavelength;
+        };
+        if (includesExtremum(0)) range.maximum = Q30;
+        if (includesExtremum(periodNumerator / 2)) range.minimum = -Q30;
+        return range;
+    }
+
+    inline std::int64_t MulQ30(std::int64_t value, std::int64_t cosineQ30)
+    { return (value * cosineQ30) / Q30; }
+
+    struct SurfaceProfileColumnBounds
+    {
+        std::int64_t groundMinimum = 0;
+        std::int64_t groundMaximum = 0;
+        std::int64_t capMinimum = 0;
+        std::int64_t capMaximum = 0;
+    };
+
+    inline SurfaceProfileColumnBounds ProfileColumnBounds(
+        const WorldAssemblySurfaceProfileV1& profile,
+        const WorldAssemblyStratumPlanV1& plan,
+        std::int64_t minimumX, std::int64_t minimumY,
+        std::int64_t maximumX, std::int64_t maximumY)
+    {
+        SurfaceProfileColumnBounds bounds;
+        if (profile.kind == WorldAssemblySurfaceProfileKindV1::flatField)
+        {
+            bounds.groundMinimum = profile.h0Subvoxels;
+            bounds.groundMaximum = profile.h0Subvoxels;
+            bounds.capMinimum = plan.capHeightSubvoxels;
+            bounds.capMaximum = plan.capHeightSubvoxels;
+            return bounds;
+        }
+        const CosineRangeQ30 x = SurfaceProfileCosineRangeQ30(minimumX, maximumX,
+            profile.wavelengthXSubvoxels, profile.phaseXTurnsQ32);
+        const CosineRangeQ30 y = SurfaceProfileCosineRangeQ30(minimumY, maximumY,
+            profile.wavelengthYSubvoxels, profile.phaseYTurnsQ32);
+        const std::int64_t groundXMinimum = MulQ30(profile.amplitudeXSubvoxels, x.minimum);
+        const std::int64_t groundXMaximum = MulQ30(profile.amplitudeXSubvoxels, x.maximum);
+        const std::int64_t groundYMinimum = MulQ30(profile.amplitudeYSubvoxels, y.minimum);
+        const std::int64_t groundYMaximum = MulQ30(profile.amplitudeYSubvoxels, y.maximum);
+        bounds.groundMinimum = profile.h0Subvoxels + groundXMinimum + groundYMinimum - 2;
+        bounds.groundMaximum = profile.h0Subvoxels + groundXMaximum + groundYMaximum + 2;
+        if (profile.kind == WorldAssemblySurfaceProfileKindV1::mirroredRelief)
+        {
+            const std::int64_t reliefMinimum = groundXMinimum + groundYMinimum;
+            const std::int64_t reliefMaximum = groundXMaximum + groundYMaximum;
+            bounds.capMinimum = plan.capHeightSubvoxels
+                - MulQ16(reliefMaximum, profile.mirrorLambdaQ16) - 2;
+            bounds.capMaximum = plan.capHeightSubvoxels
+                - MulQ16(reliefMinimum, profile.mirrorLambdaQ16) + 2;
+        }
+        else
+        {
+            bounds.capMinimum = plan.capHeightSubvoxels;
+            bounds.capMaximum = plan.capHeightSubvoxels;
+        }
+        return bounds;
+    }
+
     struct HeightfieldColumnCacheEntry
     {
         const WorldAssemblyRecipeV1* recipe = nullptr;
@@ -1415,6 +1827,61 @@ namespace world_assembly_detail
         HeightfieldPointSample out;
         if(recipe.evaluatorVersion>=2)
         {
+            if (recipe.surfaceProfile.version == 1)
+            {
+                const auto& profile = recipe.surfaceProfile;
+                std::int64_t relief = 0;
+                if (profile.kind != WorldAssemblySurfaceProfileKindV1::flatField)
+                {
+                    const std::int64_t cosineX = CosineQ30(SurfaceProfileTurnAtCoordinate(
+                        x, profile.wavelengthXSubvoxels, profile.phaseXTurnsQ32));
+                    const std::int64_t cosineY = CosineQ30(SurfaceProfileTurnAtCoordinate(
+                        y, profile.wavelengthYSubvoxels, profile.phaseYTurnsQ32));
+                    relief = MulQ30(profile.amplitudeXSubvoxels, cosineX)
+                        + MulQ30(profile.amplitudeYSubvoxels, cosineY);
+                }
+                out.groundHeightSubvoxels = profile.h0Subvoxels + relief;
+                out.capHeightSubvoxels = profile.kind
+                    == WorldAssemblySurfaceProfileKindV1::mirroredRelief
+                    ? plan.capHeightSubvoxels - MulQ16(relief, profile.mirrorLambdaQ16)
+                    : plan.capHeightSubvoxels;
+                out.biomeId = recipe.biomes.front().stableId;
+                out.neighborBiomeId = out.biomeId;
+                out.biomeWeightQ16 = static_cast<std::uint32_t>(Q16);
+                const auto* list = ScopedWorldAssemblyFeatureQueriesV1::find(
+                    &recipe, &plan, x, y, 0, true);
+                for (const auto& feature : FeatureRange{plan.features, list})
+                {
+                    if (feature.type == 1)
+                    {
+                        const std::uint32_t fade = FeatureFadeQ16(feature, x, y,
+                            feature.parametersSubvoxels[1]);
+                        if (fade) out.groundHeightSubvoxels += MulQ16(
+                            feature.parametersSubvoxels[0], fade);
+                    }
+                    else if (feature.type == 3)
+                    {
+                        const std::uint32_t fade = FeatureFadeQ16(feature, x, y,
+                            feature.parametersSubvoxels[2]);
+                        const std::int64_t wave = std::max<std::int64_t>(
+                            1, feature.parametersSubvoxels[1]);
+                        if (fade)
+                        {
+                            const std::uint32_t featureSeed = static_cast<std::uint32_t>(feature.stableId);
+                            const std::int64_t nx = NoiseCoordinateQ16(x, wave)
+                                + SeedOffsetQ16(featureSeed, 1700);
+                            const std::int64_t ny = NoiseCoordinateQ16(y, wave)
+                                + SeedOffsetQ16(featureSeed, 2900);
+                            const std::int32_t noise = FractalNoiseQ16(nx, ny,
+                                SeedOffsetQ16(featureSeed, 4100), 3);
+                            out.capHeightSubvoxels += MulQ16(MulQ16(noise,
+                                feature.parametersSubvoxels[0]), fade);
+                        }
+                    }
+                }
+                out.waterSurfaceSubvoxels = plan.waterSurfaceSubvoxels;
+                return out;
+            }
             const BiomeSelectionV2 selection=SelectBiomeV2(recipe,x,y);
             const auto& primary=recipe.biomes[selection.primary];
             const auto& neighbor=recipe.biomes[selection.neighbor];
@@ -1742,6 +2209,16 @@ std::optional<WorldAssemblyManifest> WorldAssemblyManifest::FromJson(
 
 bool WorldAssemblyManifest::finalize(std::string& error)
 {
+    ResolveWorldAssemblySurfaceProfilePhasesV1(recipe.surfaceProfile, recipe.seed);
+    for (auto& stratum : plan.strates)
+    {
+        WorldAssemblyRecipeV1& effectiveRecipe = stratum.hasRecipeOverride
+            ? stratum.recipeOverride : recipe;
+        ResolveWorldAssemblySurfaceProfilePhasesV1(effectiveRecipe.surfaceProfile,
+            effectiveRecipe.seed);
+        ResolveWorldAssemblySurfaceProfilePhasesV1(stratum.surfaceProfile,
+            effectiveRecipe.seed);
+    }
     if (schemaVersion != WorldAssemblySchemaVersion || plan.schemaVersion != WorldAssemblySchemaVersion
         || !world_assembly_detail::ValidateRecipe(recipe, error))
     { if (error.empty()) error = "world assembly manifest or plan version is unsupported"; return false; }
@@ -1759,7 +2236,7 @@ bool WorldAssemblyManifest::finalize(std::string& error)
             { error = "SurfaceWorld stratum recipe seed does not match the world assembly season seed"; return false; }
             stratum.recipeOverride.contentHash = world_assembly_detail::HashRecipe(stratum.recipeOverride);
         }
-        if (!world_assembly_detail::ValidateStratum(stratum, recipe.layoutChunkWidthSubvoxels, error)) return false;
+        if (!world_assembly_detail::ValidateStratum(stratum, recipe, error)) return false;
         if (recipe.evaluatorVersion >= 4)
         {
             if (stratum.routeConstraints.version != 1 || stratum.route.size() < 2)
@@ -1882,6 +2359,9 @@ std::string WorldAssemblyManifest::ToJson() const
         if (stratum.hasRecipeOverride)
             out << ",\"recipe_override\":"
                 << world_assembly_detail::RecipeJson(stratum.recipeOverride);
+        if (stratum.surfaceProfile.version != 0)
+            out << ",\"surface_profile\":"
+                << world_assembly_detail::SurfaceProfileJson(stratum.surfaceProfile);
         out
             << ",\"content_hash\":\"" << world_assembly_detail::HashText(stratum.contentHash)
             << "\",\"features\":[";
@@ -1957,6 +2437,8 @@ bool Heightfield2D::isValid() const noexcept
         || recipe_->biomes.empty() || recipe_->biomes.size() > world_assembly_detail::MaxBiomeCount
         || recipe_->biomeCellSizeSubvoxels <= 0 || recipe_->biomeWarpWavelengthSubvoxels <= 0
         || recipe_->biomeWarpSubvoxels < 0 || recipe_->biomeBorderBlendSubvoxels < 0
+        || recipe_->surfaceProfile != plan_->surfaceProfile
+        || recipe_->surfaceProfile.version > 1
         || plan_->strateIndex < 0 || plan_->topChunkZ < plan_->bottomChunkZ
         || plan_->capWavelengthSubvoxels <= 0 || plan_->capUndulationSubvoxels < 0)
         return false;
@@ -1973,6 +2455,32 @@ bool Heightfield2D::isValid() const noexcept
 std::array<std::int64_t,2> Heightfield2D::capHeightBounds() const noexcept
 {
     if(!isValid())return {0,0};
+    if (recipe_->surfaceProfile.version == 1)
+    {
+        const auto& profile = recipe_->surfaceProfile;
+        std::int64_t swing = 0;
+        if (profile.kind == WorldAssemblySurfaceProfileKindV1::mirroredRelief)
+        {
+            const std::int64_t relief = profile.amplitudeXSubvoxels
+                + profile.amplitudeYSubvoxels;
+            swing = (relief * profile.mirrorLambdaQ16 + world_assembly_detail::Q16 - 1)
+                / world_assembly_detail::Q16 + 2;
+        }
+        std::int64_t featureAmplitude = 0;
+        for (const auto& feature : plan_->features)
+            if (feature.type == 3)
+                featureAmplitude += std::abs(feature.parametersSubvoxels[0]);
+        std::int64_t minimum = plan_->capHeightSubvoxels - swing - featureAmplitude;
+        std::int64_t maximum = plan_->capHeightSubvoxels + swing + featureAmplitude;
+        if (recipe_->evaluatorVersion >= 5)
+        {
+            const std::int64_t upperBoundary = (static_cast<std::int64_t>(plan_->topChunkZ) + 1)
+                * recipe_->layoutChunkWidthSubvoxels;
+            minimum = std::min(minimum, upperBoundary);
+            maximum = std::min(maximum, upperBoundary);
+        }
+        return {minimum, maximum};
+    }
     long double Minimum=std::numeric_limits<long double>::infinity();
     long double Maximum=-std::numeric_limits<long double>::infinity();
     const auto IncludeBiome=[&](const WorldAssemblyBiomeProfileV1& Biome)
@@ -2145,6 +2653,9 @@ void Heightfield2D::setThreadColumnCaptureBounds(std::int64_t minimumXSubvoxels,
 void Heightfield2D::setThreadColumnCacheLegacyDirectMapped(bool enabled) noexcept
 { world_assembly_detail::HeightfieldColumnCacheLegacyDirectMapped=enabled; }
 
+bool Heightfield2D::threadColumnCacheLegacyDirectMapped() noexcept
+{ return world_assembly_detail::HeightfieldColumnCacheLegacyDirectMapped; }
+
 void Heightfield2D::setThreadColumnOctaveDrop(std::uint32_t octaveDrop) noexcept
 { world_assembly_detail::HeightfieldColumnOctaveDrop=octaveDrop; }
 
@@ -2178,6 +2689,15 @@ HeightfieldBoxClass Heightfield2D::classifyLatticeBox(std::int64_t minimumX,
             &&feature.minimumSubvoxels[2]<=maximumZ&&feature.maximumSubvoxels[2]>=minimumZ)
             return HeightfieldBoxClass::mixed;
     }
+    if (recipe_->surfaceProfile.version == 1)
+    {
+        const FieldInterval proof = interval(minimumX, minimumY, minimumZ,
+            maximumX, maximumY, maximumZ);
+        if (!proof.known) return HeightfieldBoxClass::unknown;
+        if (proof.minimumDensitySubvoxels > 0) return HeightfieldBoxClass::allAir;
+        if (proof.maximumDensitySubvoxels < 0) return HeightfieldBoxClass::allSolid;
+        return HeightfieldBoxClass::mixed;
+    }
     const std::int64_t stride=static_cast<std::int64_t>(stepVoxels)
         *WorldAssemblySubvoxelsPerVoxel;
     if((maximumX-minimumX)%stride!=0||(maximumY-minimumY)%stride!=0
@@ -2220,7 +2740,29 @@ FieldInterval Heightfield2D::interval(std::int64_t minX, std::int64_t minY,
     std::int64_t groundMax = std::numeric_limits<std::int64_t>::min();
     std::int64_t capMin=plan_->capHeightSubvoxels-plan_->capUndulationSubvoxels;
     std::int64_t capMax=plan_->capHeightSubvoxels+plan_->capUndulationSubvoxels;
-    if(recipe_->evaluatorVersion>=2)
+    if (recipe_->surfaceProfile.version == 1)
+    {
+        const auto profileBounds = world_assembly_detail::ProfileColumnBounds(
+            recipe_->surfaceProfile, *plan_, minX, minY, maxX, maxY);
+        groundMin = profileBounds.groundMinimum;
+        groundMax = profileBounds.groundMaximum;
+        capMin = profileBounds.capMinimum;
+        capMax = profileBounds.capMaximum;
+        std::int64_t groundFeatureMagnitude = 0;
+        std::int64_t capFeatureMagnitude = 0;
+        for (const auto& feature : plan_->features)
+        {
+            if (feature.type == 1)
+                groundFeatureMagnitude += std::abs(feature.parametersSubvoxels[0]);
+            if (feature.type == 3)
+                capFeatureMagnitude += std::abs(feature.parametersSubvoxels[0]);
+        }
+        groundMin -= groundFeatureMagnitude;
+        groundMax += groundFeatureMagnitude;
+        capMin -= capFeatureMagnitude;
+        capMax += capFeatureMagnitude;
+    }
+    else if(recipe_->evaluatorVersion>=2)
     {
         for(const auto& biome:recipe_->biomes)
         {
@@ -2313,6 +2855,24 @@ FieldDetailEnvelope Heightfield2D::detailEnvelope() const noexcept
 {
     FieldDetailEnvelope out;
     if (!isValid()) return out;
+    if (recipe_->surfaceProfile.version == 1)
+    {
+        const auto& profile = recipe_->surfaceProfile;
+        out.maximumAbsoluteDisplacementSubvoxels = profile.amplitudeXSubvoxels
+            + profile.amplitudeYSubvoxels;
+        if (profile.kind == WorldAssemblySurfaceProfileKindV1::mirroredRelief)
+            out.maximumAbsoluteDisplacementSubvoxels +=
+                (out.maximumAbsoluteDisplacementSubvoxels * profile.mirrorLambdaQ16
+                    + world_assembly_detail::Q16 - 1) / world_assembly_detail::Q16;
+        for (const auto& feature : plan_->features)
+            if (feature.type == 1 || feature.type == 3)
+                out.maximumAbsoluteDisplacementSubvoxels +=
+                    std::abs(feature.parametersSubvoxels[0]);
+        if (profile.kind != WorldAssemblySurfaceProfileKindV1::flatField)
+            out.minimumFeatureSizeSubvoxels = std::max<std::int64_t>(1,
+                std::min(profile.wavelengthXSubvoxels, profile.wavelengthYSubvoxels) / 2);
+        return out;
+    }
     std::int64_t maximum = plan_->capUndulationSubvoxels*5/2
         +plan_->capDetailAmplitudeSubvoxels*5/2+plan_->capRidgeAmplitudeSubvoxels;
     std::int64_t minimumFeature = std::numeric_limits<std::int64_t>::max();
@@ -2448,6 +3008,7 @@ WorldAssemblyBoundsAuditResult AuditHeightfieldBounds(const Heightfield2D& block
             &result.capBoxes,false,"cap");
     }
     bool hasCliffProfile=false;
+    if(recipe->surfaceProfile.version==0)
         for(const auto& biome:recipe->biomes)hasCliffProfile|=biome.cliffStrengthQ16>0;
     if(hasCliffProfile)
     {
@@ -2488,7 +3049,8 @@ WorldAssemblyBoundsAuditResult AuditHeightfieldBounds(const Heightfield2D& block
     // Controle negatif : cette plage unilaterale exclut un echantillon connu; l'audit doit rejeter cette borne mensongere.
     const FieldInterval deliberatelyWrong{true, controlPoint + 1, controlPoint + 2};
     result.negativeControlDetected = !world_assembly_detail::InInterval(deliberatelyWrong, controlPoint);
-    const bool borderCoverage=recipe->biomes.size()<2||recipe->biomeBorderBlendSubvoxels==0
+    const bool borderCoverage=recipe->surfaceProfile.version!=0
+        ||recipe->biomes.size()<2||recipe->biomeBorderBlendSubvoxels==0
         ||result.biomeBorderBoxes>0;
     const bool cliffCoverage=!hasCliffProfile||result.cliffBoxes>0;
     const bool exceptionCoverage=std::none_of(plan->features.begin(),plan->features.end(),