skip: passage proof bounds include wall/floor relief (L75 soundness fix); FI -7.6%

L74's passage bound omitted the 0.21 m wall relief and 0.20 m floor relief, so its whole-tile
proof was unsound in principle (no tested view hit it). Passage support is now bounded per route
segment by four parameter-subinterval boxes using Catmull-Rom derivative extrema, local max
radius and relief padding. Stratum slicing only at LOD0-2 in FI/VS. Legacy sub-tile block
certificates are audit-only (runtime version was slower). TN regression (-80,-20,-3218) kept.

Exact full-grid vs skip hashes on every tile, 4 views, Clang/GCC, W1/W8/W12; control caught;
80-camera sweep 0 violations. Whole view vs c67b200: SW -1.3%, FI -7.6%, TN -2.3%, VS +0.2%.
Compiles in the Linux UE host (VFHostEditor, 27/27 actions).

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

ARCHITECTURE.md

@@ -1883,8 +1883,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 +1944,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 +2053,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

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. |
@@ -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

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/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

@@ -297,7 +297,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 +316,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)));
 }
 

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
+{
+    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))
         {
-            return i;
+            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/Private/VoxelWorld.cpp

@@ -82,6 +82,17 @@
 #include <atomic>
 #include <unordered_set>
 
+static FORCEINLINE int32 VF_ClipLevelScale(int32 Level)
+{
+    const uint32 SafeLevel = static_cast<uint32>(FMath::Clamp(Level, 0, 8));
+    return static_cast<int32>(uint32{1} << SafeLevel);
+}
+static FORCEINLINE int32 VF_ClipLevelExtentVoxels(int32 Level)
+{
+    return static_cast<int32>(static_cast<uint32>(CHUNK_SIZE)
+        * static_cast<uint32>(VF_ClipLevelScale(Level)));
+}
+
 static bool VF_TileOverlapsVoxelBounds(const FVoxelTileKey& Tile,
                                        const FVector& BoundsMin, const FVector& BoundsMax);
 static bool VF_TileFootprintsOverlap(const FVoxelTileKey& A, const FVoxelTileKey& B);
@@ -227,11 +238,11 @@ namespace
         GVoxelForgeStreamingResultBacklogCap,
         TEXT("Maximum queued results plus admitted tile tasks; 0 disables the safety cap. This is separate from the worker-slot cap."));
 
-    int32 GVoxelForgeStreamingReadyQueueDepth = 8;
+    int32 GVoxelForgeStreamingReadyQueueDepth = 16;
     FAutoConsoleVariableRef CVarVoxelForgeStreamingReadyQueueDepth(
         TEXT("voxel.StreamingReadyQueueDepth"),
         GVoxelForgeStreamingReadyQueueDepth,
-        TEXT("Extra admitted tile tasks kept ready beyond the worker slots, up to one worker-set; 0 disables the refill queue."));
+        TEXT("Extra admitted tile tasks kept ready beyond worker slots, up to four worker-sets/64 tasks; 0 disables the refill queue."));
 
     int32 GVoxelForgeStreamingBackgroundWorkerCap = 1;
     FAutoConsoleVariableRef CVarVoxelForgeStreamingBackgroundWorkerCap(
@@ -301,8 +312,8 @@ namespace
     FAutoConsoleVariableRef CVarVoxelForgeStreamingStartupApplyBoost(
         TEXT("voxel.StreamingStartupApplyBoost"),
         GVoxelForgeStreamingStartupApplyBoost,
-        TEXT("Bounded cold-view upload budget (default on): 1 allows a 14 ms / 12-mesh budget until the initial desired set and walkable ring are ready; 0 uses the authored per-frame budget."));
-    constexpr int32 StreamingStartupMaxMeshApplies = 12;
+        TEXT("Bounded cold-view upload budget (default on): 1 allows a 14 ms / 24-mesh cap until the initial desired set and walkable ring are ready; 0 uses the authored per-frame budget."));
+    constexpr int32 StreamingStartupMaxMeshApplies = 24;
     constexpr float StreamingStartupApplyBudgetMilliseconds = 14.0f;
     constexpr double StreamingStartupApplyMaxSeconds = 30.0;
 
@@ -2196,7 +2207,7 @@ void AVoxelWorld::BeginPlay()
                       CommandLineStreamingReadyQueueDepth))
     {
         GVoxelForgeStreamingReadyQueueDepth = FMath::Clamp(
-            CommandLineStreamingReadyQueueDepth, 0, 32);
+            CommandLineStreamingReadyQueueDepth, 0, 64);
     }
     if (FParse::Value(FCommandLine::Get(), TEXT("voxel.StreamingBackgroundWorkerCap="),
                       CommandLineStreamingBackgroundWorkerCap))
@@ -2623,7 +2634,8 @@ void AVoxelWorld::BeginPlay()
         FTaskGraphInterface& TaskGraph = FTaskGraphInterface::Get();
         LowLevelTasks::FScheduler& TaskScheduler = LowLevelTasks::FScheduler::Get();
         const int32 QueueDepth = FMath::Clamp(
-            GVoxelForgeStreamingReadyQueueDepth, 0, GetMaxConcurrentStreamingTasks());
+            GVoxelForgeStreamingReadyQueueDepth, 0,
+            FMath::Min(64, FMath::Max(1, GetMaxConcurrentStreamingTasks()) * 4));
         VoxelForgeStartupTrace::RecordEvent(TEXT("worker_backend_config"), FString::Printf(
             TEXT("\"logical_cores\":%d,\"effective_tile_slots\":%d,"
                  "\"task_api\":\"UE::Tasks::Launch\",\"task_scheduler_workers\":%u,"
@@ -6240,17 +6252,19 @@ static void VF_AppendTouchingAncestors(
     const FVoxelTileKey& Tile, int32 AncestorLevel, CandidateArray& OutCandidates)
 {
     if (AncestorLevel <= Tile.Level) { return; }
-    const int32 Divisor = 1 << (AncestorLevel - Tile.Level);
-    const auto FloorDiv = [Divisor](int32 Value)
+    const int32 Divisor = VF_ClipLevelScale(AncestorLevel - Tile.Level);
+    const auto FloorDiv = [Divisor](int64 Value)
     {
-        return Value >= 0 ? Value / Divisor : -(((-Value) + Divisor - 1) / Divisor);
+        const int64 Quotient = Value / Divisor;
+        const int64 Remainder = Value % Divisor;
+        return static_cast<int32>(Remainder < 0 ? Quotient - 1 : Quotient);
     };
     const auto AxisCandidates = [&FloorDiv, Divisor](int32 Value)
     {
         TArray<int32, TInlineAllocator<2>> Candidates;
         int32 First = FloorDiv(Value);
         if ((Value % Divisor) == 0) { --First; }
-        const int32 Last = FloorDiv(Value + 1);
+        const int32 Last = FloorDiv(static_cast<int64>(Value) + 1);
         for (int32 Coord = First; Coord <= Last; ++Coord) { Candidates.Add(Coord); }
         return Candidates;
     };
@@ -6338,7 +6352,7 @@ void AVoxelWorld::UpdateVisualStalenessAudit()
             const FVector& WorldPosition, int32 Level, auto& OutCandidates)
         {
             const FVector LocalVoxel = WorldToLocalVoxel(WorldPosition);
-            const float TileExtentVoxels = static_cast<float>(CHUNK_SIZE * (1 << Level));
+            const float TileExtentVoxels = static_cast<float>(VF_ClipLevelExtentVoxels(Level));
             TArray<int32, TInlineAllocator<2>> XCandidates;
             TArray<int32, TInlineAllocator<2>> YCandidates;
             TArray<int32, TInlineAllocator<2>> ZCandidates;
@@ -7182,7 +7196,7 @@ void AVoxelWorld::Tick(float DeltaTime)
         {
             const FIntVector Min = SteadyLevelMins.FindChecked(Level);
             const FIntVector Max = SteadyLevelMaxs.FindChecked(Level);
-            const int32 ExtentVoxels = CHUNK_SIZE << Level;
+            const int32 ExtentVoxels = VF_ClipLevelExtentVoxels(Level);
             const double TileExtentMetres = static_cast<double>(ExtentVoxels) * VOXEL_SIZE / 100.0;
             const double SpanX = static_cast<double>(Max.X - Min.X + 1) * TileExtentMetres;
             const double SpanY = static_cast<double>(Max.Y - Min.Y + 1) * TileExtentMetres;
@@ -7554,6 +7568,14 @@ bool AVoxelWorld::GetVoxelForgeCoreWorldAssembly(
     return bUseVoxelForgeCore && !OutCanonicalJson.IsEmpty() && !OutContentHash.IsEmpty();
 }
 
+bool AVoxelWorld::GetVoxelForgeCoreResolvedLayout(
+    FString& OutCanonicalJson, FString& OutStableIdentity) const
+{
+    OutCanonicalJson = VoxelForgeCoreResolvedLayoutJson;
+    OutStableIdentity = VoxelForgeCoreResolvedLayoutIdentity;
+    return bUseVoxelForgeCore && !OutCanonicalJson.IsEmpty() && !OutStableIdentity.IsEmpty();
+}
+
 bool AVoxelWorld::QueryVoxelForgeCoreDensityAt(FVector WorldLocation, float& OutDensity) const
 {
     OutDensity = 0.0f;
@@ -7572,6 +7594,8 @@ bool AVoxelWorld::InitializeVoxelForgeCoreWorld(FString& OutFailureReason)
     OutFailureReason.Reset();
     VoxelForgeCoreWorldAssemblyJson.Reset();
     VoxelForgeCoreWorldAssemblyHash.Reset();
+    VoxelForgeCoreResolvedLayoutJson.Reset();
+    VoxelForgeCoreResolvedLayoutIdentity.Reset();
     if (!bUseVoxelForgeCore) return true;
     if (!Settings || !StrateManager)
     {
@@ -7604,6 +7628,17 @@ bool AVoxelWorld::InitializeVoxelForgeCoreWorld(FString& OutFailureReason)
         UE_LOG(LogTemp, Error, TEXT("[VoxelForgeCoreRuntime] %s"), *OutFailureReason);
         return false;
     }
+    if (const VoxelForgeCore::ResolvedLayoutSnapshotV3* ResolvedLayout = Snapshot->resolvedLayout())
+    {
+        const std::string CanonicalLayout = ResolvedLayout->ToJson();
+        if (CanonicalLayout.empty())
+        {
+            OutFailureReason = TEXT("the resolved Core layout could not be serialized canonically.");
+            return false;
+        }
+        VoxelForgeCoreResolvedLayoutJson = UTF8_TO_TCHAR(CanonicalLayout.c_str());
+        VoxelForgeCoreResolvedLayoutIdentity = UTF8_TO_TCHAR(ResolvedLayout->stableIdentity.c_str());
+    }
     if (const VoxelForgeCore::WorldAssemblyManifest* Assembly = Snapshot->worldAssembly())
     {
         const std::string CanonicalAssembly = Assembly->ToJson();
@@ -7663,10 +7698,20 @@ bool AVoxelWorld::InitializeVoxelForgeCoreWorld(FString& OutFailureReason)
     };
     for (const VoxelForgeCore::TileKey& Key : InitialDesired)
     {
-        const int32 Extent = 32 << Key.lod;
-        const int32 OriginX = Key.coordinate.x * Extent;
-        const int32 OriginY = Key.coordinate.y * Extent;
-        const int32 OriginZ = Key.coordinate.z * Extent;
+        const int32 Extent = VF_ClipLevelExtentVoxels(Key.lod);
+        const int64 OriginXWide = static_cast<int64>(Key.coordinate.x) * Extent;
+        const int64 OriginYWide = static_cast<int64>(Key.coordinate.y) * Extent;
+        const int64 OriginZWide = static_cast<int64>(Key.coordinate.z) * Extent;
+        if (OriginXWide < MIN_int32 || OriginYWide < MIN_int32 || OriginZWide < MIN_int32
+            || OriginXWide + Extent > MAX_int32 || OriginYWide + Extent > MAX_int32
+            || OriginZWide + Extent > MAX_int32)
+        {
+            OutFailureReason = TEXT("Core initial clipmap exceeds the supported voxel-coordinate range.");
+            return false;
+        }
+        const int32 OriginX = static_cast<int32>(OriginXWide);
+        const int32 OriginY = static_cast<int32>(OriginYWide);
+        const int32 OriginZ = static_cast<int32>(OriginZWide);
         IncludeExtent(ClipMin.x, ClipMax.x, OriginX, Extent);
         IncludeExtent(ClipMin.y, ClipMax.y, OriginY, Extent);
         IncludeExtent(ClipMin.z, ClipMax.z, OriginZ, Extent);
@@ -7770,7 +7815,15 @@ void AVoxelWorld::FallBackToLegacyAfterCoreInitializationFailure(const FString&
     }
     VoxelForgeCoreWorldAssemblyJson.Reset();
     VoxelForgeCoreWorldAssemblyHash.Reset();
+    VoxelForgeCoreResolvedLayoutJson.Reset();
+    VoxelForgeCoreResolvedLayoutIdentity.Reset();
     bUseVoxelForgeCore = false;
+    // The Core adapter sets this before validation; legacy generation must not inherit it.
+    // L'adaptateur Core l'active avant validation ; le générateur historique ne doit pas en hériter.
+    if (StrateManager != nullptr)
+    {
+        StrateManager->SetHardTransitionFallbackForAssembly(false);
+    }
     CoreFallbackCenterLocalCm = FVector::ZeroVector;
     if (Mesher != nullptr)
     {
@@ -9908,6 +9961,9 @@ bool AVoxelWorld::ApplyTileResult(FChunkResult& Result)
                 Sample.QueueWaitSeconds = WorkerQueueSeconds + ResultQueueSeconds;
                 Sample.WorkerTaskSeconds = WorkerTaskSeconds;
                 Sample.GenerationSeconds = GenerationSeconds;
+                Sample.CoreGenerateSeconds = Result.CoreGenerateSeconds;
+                Sample.MeshCopySeconds = Result.MeshCopySeconds;
+                Sample.StreamBuildSeconds = Result.StreamBuildSeconds;
                 Sample.ClassifySeconds = Result.ClassifySeconds;
                 Sample.MeshSeconds = Result.MeshSeconds;
                 Sample.StreamSeconds = Result.StreamSeconds;
@@ -10068,8 +10124,11 @@ void AVoxelWorld::SyncRemeshTile(const FVoxelTileKey& Tile)
     {
         BandChunkLo = MeshBandChunkLo;
         BandChunkHi = MeshBandChunkHi;
-        BandVoxLo   = MeshBandChunkLo * CHUNK_SIZE;
-        BandVoxHi   = (MeshBandChunkHi + 1) * CHUNK_SIZE - 1;
+        BandVoxLo = static_cast<int32>(FMath::Clamp<int64>(
+            static_cast<int64>(MeshBandChunkLo) * CHUNK_SIZE, MIN_int32, MAX_int32));
+        BandVoxHi = static_cast<int32>(FMath::Clamp<int64>(
+            (static_cast<int64>(MeshBandChunkHi) + 1) * CHUNK_SIZE - 1,
+            MIN_int32, MAX_int32));
     }
 
     FChunkResult Result;
@@ -10232,7 +10291,7 @@ void AVoxelWorld::ReconcileReadyTransitionVisibility()
     ReadyToHide.Reserve(TileComponents.Num());
     auto GetAncestorAtLevel = [](const FVoxelTileKey& Tile, int32 AncestorLevel)
     {
-        const int32 Divisor = 1 << (AncestorLevel - Tile.Level);
+        const int32 Divisor = VF_ClipLevelScale(AncestorLevel - Tile.Level);
         return FVoxelTileKey(VoxelClipmapDesiredTiles::FloorDiv(Tile.Coord, Divisor), AncestorLevel);
     };
     for (const TPair<FVoxelTileKey, URealtimeMeshComponent*>& Pair : TileComponents)
@@ -10355,7 +10414,10 @@ void AVoxelWorld::ReconcileReadyTransitionVisibility()
 // Integer floor-division (correct for negatives), scalar + vector.
 static FORCEINLINE int32 VF_FloorDiv(int32 V, int32 D)
 {
-    return V >= 0 ? (V / D) : -(((-V) + D - 1) / D);
+    if (D <= 0) { return 0; }
+    const int32 Quotient = V / D;
+    const int32 Remainder = V % D;
+    return Remainder < 0 ? Quotient - 1 : Quotient;
 }
 static FORCEINLINE FIntVector VF_FloorDiv(const FIntVector& V, int32 D)
 {
@@ -11435,13 +11497,13 @@ bool AVoxelWorld::IsTileInClipRange(const FVoxelTileKey& Tile, const FIntVector&
     {
         VF_OuterShell(Settings, R, MaxLevelBase, MaxLevel, ROuter);
     }
-    const int32 PowMax   = 1 << MaxLevel;
+    const int32 PowMax   = VF_ClipLevelScale(MaxLevel);
     const FIntVector CMax = VF_FloorDiv(Center, PowMax);
 
     FVector CV;
     if (bUseVoxelForgeCore)
     {
-        const double TileExtentVoxels = static_cast<double>(CHUNK_SIZE << Tile.Level);
+        const double TileExtentVoxels = static_cast<double>(VF_ClipLevelExtentVoxels(Tile.Level));
         CV = FVector(
             (static_cast<double>(Tile.Coord.X) + 0.5) * TileExtentVoxels,
             (static_cast<double>(Tile.Coord.Y) + 0.5) * TileExtentVoxels,
@@ -11457,9 +11519,9 @@ bool AVoxelWorld::IsTileInClipRange(const FVoxelTileKey& Tile, const FIntVector&
         VF_FloorDiv(FMath::FloorToInt(CV.Y), SizeMax),
         VF_FloorDiv(FMath::FloorToInt(CV.Z), SizeMax));
 
-    return FMath::Abs(TMax.X - CMax.X) <= ROuter
-        && FMath::Abs(TMax.Y - CMax.Y) <= ROuter
-        && FMath::Abs(TMax.Z - CMax.Z) <= ROuter;
+    return FMath::Abs(static_cast<int64>(TMax.X) - CMax.X) <= ROuter
+        && FMath::Abs(static_cast<int64>(TMax.Y) - CMax.Y) <= ROuter
+        && FMath::Abs(static_cast<int64>(TMax.Z) - CMax.Z) <= ROuter;
 }
 
 int32 AVoxelWorld::GetMaxConcurrentTasks() const
@@ -11812,11 +11874,10 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
         }
     }
     const int32 MaxTasks = GetMaxConcurrentStreamingTasks();
-    // Keep at most one worker-set of ready work so an admission pass can feed idle slots
-    // without letting far work consume the near reserve. / Garder une file d'un ensemble
-    // de workers pour nourrir les slots sans consommer la reserve proche.
+    // Keep several bounded worker-sets ready so frame-paced admission can feed the
+    // background lane continuously without moving mesh application onto the game thread.
     const int32 ReadyQueueDepth = FMath::Clamp(
-        GVoxelForgeStreamingReadyQueueDepth, 0, MaxTasks);
+        GVoxelForgeStreamingReadyQueueDepth, 0, FMath::Min(64, FMath::Max(1, MaxTasks) * 4));
     const int32 TotalAdmissionCap = MaxTasks + ReadyQueueDepth;
     const int32 AuthoredNearTaskReserve = GetNearTaskReserve(MaxTasks);
     const FIntVector CenterChunk = GetTileCoordAtLocalCm(WorldToLocalCm(CenterPosition));
@@ -12052,7 +12113,7 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
                 LevelSummaries.Num(), Leavers.Num(), CollisionOnlyTiles.Num()));
             for (const FDesiredLevelSummary& Summary : LevelSummaries)
             {
-                const int32 ExtentVoxels = CHUNK_SIZE << Summary.Level;
+                const int32 ExtentVoxels = VF_ClipLevelExtentVoxels(Summary.Level);
                 const double TileExtentMetres = static_cast<double>(ExtentVoxels) * VOXEL_SIZE / 100.0;
                 const double SpanX = static_cast<double>(Summary.Max.X - Summary.Min.X + 1) * TileExtentMetres;
                 const double SpanY = static_cast<double>(Summary.Max.Y - Summary.Min.Y + 1) * TileExtentMetres;
@@ -12103,8 +12164,9 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
                 for (const FVoxelTileKey& T : LoadedTiles)
                 {
                     if (T.Level < CutMin) continue;
-                    const int32 CLo = T.Coord.Z << T.Level;
-                    const int32 CHi = ((T.Coord.Z + 1) << T.Level) - 1;
+                    const int64 LevelScale = VF_ClipLevelScale(T.Level);
+                    const int64 CLo = static_cast<int64>(T.Coord.Z) * LevelScale;
+                    const int64 CHi = (static_cast<int64>(T.Coord.Z) + 1) * LevelScale - 1;
                     const bool bInOld  = CLo >= MeshBandChunkLo && CHi <= MeshBandChunkHi;
                     const bool bInNew  = CLo >= NewLo && CHi <= NewHi;
                     const bool bOutOld = CHi < MeshBandChunkLo || CLo > MeshBandChunkHi;
@@ -12324,7 +12386,7 @@ void AVoxelWorld::UpdateChunksAroundPosition(const FVector& CenterPosition, APaw
                 }
                 Heading = Heading.GetSafeNormal();
                 const FVector PlayerLocalCm = WorldToLocalCm(CenterPosition);
-                const double TileSizeCm = static_cast<double>(CHUNK_SIZE << Level)
+                const double TileSizeCm = static_cast<double>(VF_ClipLevelExtentVoxels(Level))
                     * GetActiveVoxelSizeCm();
                 LevelTiles.Sort([&](const FVoxelTileKey& A, const FVoxelTileKey& B)
                 {
@@ -12725,7 +12787,7 @@ void AVoxelWorld::LoadTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority Wor
 
     const int32 MaxTasks = GetMaxConcurrentStreamingTasks();   // Core and worker lane clamped. / Core et voie worker plafonnes.
     const int32 ReadyQueueDepth = FMath::Clamp(
-        GVoxelForgeStreamingReadyQueueDepth, 0, MaxTasks);
+        GVoxelForgeStreamingReadyQueueDepth, 0, FMath::Min(64, FMath::Max(1, MaxTasks) * 4));
     const int32 TotalAdmissionCap = MaxTasks + ReadyQueueDepth;
     const bool bNearPriority = WorkPriority != EVoxelTileWorkPriority::Horizon;
     const int32 NearReserve = EffectiveNearTaskReserve >= 0
@@ -12782,7 +12844,7 @@ void AVoxelWorld::LoadTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority Wor
     const int32 FullRes = GVoxelForgeTestFullResClipLevels >= 0
         ? FMath::Clamp(GVoxelForgeTestFullResClipLevels, 1, 9)
         : (Settings ? FMath::Max(1, Settings->FullResClipLevels) : 2);
-    const int32 Extent  = CHUNK_SIZE << Tile.Level;
+    const int32 Extent  = VF_ClipLevelExtentVoxels(Tile.Level);
 
     const int32 Cells = (Tile.Level < FullRes)
         ? CHUNK_SIZE
@@ -12847,7 +12909,9 @@ void AVoxelWorld::LoadTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority Wor
         // et mélanges de matériaux qu'avant la coupe) — la tuile ne peut rendre que des artefacts
         // ⇒ on n'émet RIEN. Résultat vide via ProcessQueue (bookkeeping normal : PendingTiles,
         // LoadedTiles, epoch) ; jamais figé — le changement de bande re-queue via BandRemeshQueue.
-        if (Step > (BandChunkHi - BandChunkLo + 1) * CHUNK_SIZE)
+        const int64 BandHeightVoxels =
+            (static_cast<int64>(BandChunkHi) - BandChunkLo + 1) * CHUNK_SIZE;
+        if (static_cast<int64>(Step) > BandHeightVoxels)
         {
             FChunkResult Empty;
             Empty.Tile        = Tile;
@@ -13066,7 +13130,7 @@ void AVoxelWorld::LoadCoreTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority
 
     const int32 MaxTasks = GetMaxConcurrentStreamingTasks();
     const int32 ReadyQueueDepth = FMath::Clamp(
-        GVoxelForgeStreamingReadyQueueDepth, 0, MaxTasks);
+        GVoxelForgeStreamingReadyQueueDepth, 0, FMath::Min(64, FMath::Max(1, MaxTasks) * 4));
     const int32 TotalAdmissionCap = MaxTasks + ReadyQueueDepth;
     const bool bNearPriority = WorkPriority != EVoxelTileWorkPriority::Horizon;
     const int32 NearReserve = EffectiveNearTaskReserve >= 0
@@ -13174,6 +13238,11 @@ void AVoxelWorld::LoadCoreTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority
         Result.WorkPriority = WorkPriority;
         Result.GenerationStartCycles = FPlatformTime::Cycles64();
         Result.GenerationOrdinal = NextStreamingGenerationOrdinal.fetch_add(1, std::memory_order_relaxed) + 1;
+#if PLATFORM_LINUX
+        const bool bMeasureWorkerPhases = VoxelForgeStartupTrace::IsActive();
+#else
+        constexpr bool bMeasureWorkerPhases = false;
+#endif
 
         auto EnqueueObsolete = [&]()
         {
@@ -13229,7 +13298,14 @@ void AVoxelWorld::LoadCoreTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority
             FReadScopeLock Lock(State->WorldLock);
             if (State->World)
             {
+                const uint64 CoreGenerateStartCycles = bMeasureWorkerPhases
+                    ? FPlatformTime::Cycles64() : 0;
                 CoreMesh = State->World->generateTile(CoreKey, Options, CoreError);
+                if (CoreGenerateStartCycles != 0)
+                {
+                    Result.CoreGenerateSeconds = FPlatformTime::ToSeconds64(
+                        FPlatformTime::Cycles64() - CoreGenerateStartCycles);
+                }
             }
         }
         Result.GenerationEndCycles = FPlatformTime::Cycles64();
@@ -13271,6 +13347,8 @@ void AVoxelWorld::LoadCoreTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority
 
         if (!Result.bEmpty)
         {
+            const uint64 MeshCopyStartCycles = bMeasureWorkerPhases
+                ? FPlatformTime::Cycles64() : 0;
             FVoxelMeshData MeshData;
             MeshData.Vertices.Reserve(Result.NumVertices);
             MeshData.Normals.Reserve(Result.NumVertices);
@@ -13291,8 +13369,20 @@ void AVoxelWorld::LoadCoreTile(const FVoxelTileKey& Tile, EVoxelTileWorkPriority
             MeshData.NumSurfaceVertices = static_cast<int32>(CoreMesh->groups.surfaceVertexCount);
             MeshData.NumCeilingTriangles = Result.NumCeilingTriangles;
             MeshData.NumSkirtTriangles = Result.NumSkirtTriangles;
+            if (MeshCopyStartCycles != 0)
+            {
+                Result.MeshCopySeconds = FPlatformTime::ToSeconds64(
+                    FPlatformTime::Cycles64() - MeshCopyStartCycles);
+            }
+            const uint64 StreamBuildStartCycles = bMeasureWorkerPhases
+                ? FPlatformTime::Cycles64() : 0;
             Result.Streams = MakeShared<RealtimeMesh::FRealtimeMeshStreamSet>();
             BuildTileStreamSet(*Result.Streams, MeshData);
+            if (StreamBuildStartCycles != 0)
+            {
+                Result.StreamBuildSeconds = FPlatformTime::ToSeconds64(
+                    FPlatformTime::Cycles64() - StreamBuildStartCycles);
+            }
         }
         Result.GenerationEndCycles = FPlatformTime::Cycles64();
         if (Cancellation->bObsolete.load(std::memory_order_acquire)
@@ -13982,7 +14072,8 @@ bool AVoxelWorld::ApplyMeshToTile(FChunkResult& Result)
         // Convertir les bornes physiques de tuile vers les strates owner, y compris les rapports fractionnaires.
         const double OwnerChunksPerCoreTile = static_cast<double>(GetActiveVoxelSizeCm())
             / VOXEL_SIZE;
-        const double TileExtentCoreVoxels = static_cast<double>(CHUNK_SIZE << Tile.Level);
+        const double TileExtentCoreVoxels =
+            static_cast<double>(VF_ClipLevelExtentVoxels(Tile.Level));
         const int32 MinOwnerChunkX = FMath::FloorToInt(
             Tile.Coord.X * TileExtentCoreVoxels * OwnerChunksPerCoreTile / CHUNK_SIZE);
         const int32 MinOwnerChunkY = FMath::FloorToInt(
@@ -15078,6 +15169,7 @@ FString AVoxelWorld::GetCurrentSeasonContentHash() const
     }
 
     FString AssemblyHash = VoxelForgeCoreWorldAssemblyHash;
+    FString ResolvedLayoutIdentity = VoxelForgeCoreResolvedLayoutIdentity;
     if (AssemblyHash.IsEmpty())
     {
         FString AssemblyJson;
@@ -15114,12 +15206,17 @@ FString AVoxelWorld::GetCurrentSeasonContentHash() const
                 AssemblyHash = FString::Printf(TEXT("%016llx"),
                     static_cast<unsigned long long>(Assembly->contentHash));
             }
+            if (const VoxelForgeCore::ResolvedLayoutSnapshotV3* ResolvedLayout = Snapshot->resolvedLayout())
+            {
+                ResolvedLayoutIdentity = UTF8_TO_TCHAR(ResolvedLayout->stableIdentity.c_str());
+            }
         }
     }
     const bool bHybridMesher = CoreMesherRecipe != EVoxelForgeCoreMesherRecipe::MarchingCubesV1;
     const uint32 CoreVoxelSizeMicrons = static_cast<uint32>(
         FMath::RoundToInt(GetActiveVoxelSizeCm() * 10000.0f));
-    if (AssemblyHash.IsEmpty() && !bHybridMesher && CoreVoxelSizeMicrons == 250000)
+    if (AssemblyHash.IsEmpty() && ResolvedLayoutIdentity.IsEmpty()
+        && !bHybridMesher && CoreVoxelSizeMicrons == 250000)
     {
         return SeasonHash;
     }
@@ -15144,6 +15241,11 @@ FString AVoxelWorld::GetCurrentSeasonContentHash() const
         Payload += TEXT("|world_assembly=");
         Payload += AssemblyHash;
     }
+    if (!ResolvedLayoutIdentity.IsEmpty())
+    {
+        Payload += TEXT("|resolved_layout=");
+        Payload += ResolvedLayoutIdentity;
+    }
     if (CoreVoxelSizeMicrons != 250000)
     {
         Payload += FString::Printf(TEXT("|core_voxel_size_microns=%u"), CoreVoxelSizeMicrons);
@@ -15174,7 +15276,7 @@ void AVoxelWorld::RemeshDirtyChunks(const TArray<FIntVector>& DirtyCoords, const
     // BackgroundHigh; the old component remains visible until its post-edit replacement is applied.
     auto TileCoversDirtyCoord = [&DirtyCoords](const FVoxelTileKey& Tile) -> bool
     {
-        const int32 Span = 1 << Tile.Level;
+        const int32 Span = VF_ClipLevelScale(Tile.Level);
         const FIntVector MinChunk = Tile.Coord * Span;
         const FIntVector MaxChunk = MinChunk + FIntVector(Span, Span, Span);
         for (const FIntVector& Coord : DirtyCoords)

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/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;

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

@@ -145,6 +145,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.
@@ -614,6 +618,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,6 +783,8 @@ private:
     TSharedPtr<FVoxelForgeCoreRuntimeState, ESPMode::ThreadSafe> VoxelForgeCoreState;
     FString VoxelForgeCoreWorldAssemblyJson;
     FString VoxelForgeCoreWorldAssemblyHash;
+    FString VoxelForgeCoreResolvedLayoutJson;
+    FString VoxelForgeCoreResolvedLayoutIdentity;
     FVector CoreFallbackCenterLocalCm = FVector::ZeroVector;
     bool bCoreRegionCompilePending = false;
     TArray<FVoxelTileKey> PendingCoreRegionTiles;

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,64 +1942,73 @@ struct FExploreWorld
         // loaded package remains untouched.
         Settings->TotalStrates = NumStrates;
 
-        if (bUseAuthoredStrate)
+        if (Arguments.bOwnerFourStratePlan)
         {
-            // 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.
-            Settings->StratePool.Reset();
-            Settings->FixedStrates.Reset();
-        }
-        Definitions.Reserve(NumStrates);
-        for (int32 Index = 0; Index < NumStrates; ++Index)
-        {
-            UVoxelStrateDefinition* Definition = bUseAuthoredStrate
-                ? DuplicateObject<UVoxelStrateDefinition>(
-                    AuthoredDefinition, GetTransientPackage())
-                : NewObject<UVoxelStrateDefinition>(
-                    GetTransientPackage(), NAME_None, RF_Transient);
-            if (Definition == nullptr)
+            if (!ApplyOwnerFourStratePlan(Settings.Get(), Definitions, true, OutError))
             {
-                OutError = FString::Printf(
-                    TEXT("Could not create transient strate definition for slot %d."), Index);
                 return false;
             }
-            if (!bUseAuthoredStrate)
+        }
+        else
+        {
+            if (bUseAuthoredStrate)
             {
-                Definition->StrateName = FText::FromString(FString::Printf(
-                    TEXT("VoxelForgeExplore_%s_slot%d"),
-                    ArchetypeName(Index == Arguments.Slot
+                // Keep the historical single-asset interior probe isolated from loaded packages.
+                Settings->StratePool.Reset();
+                Settings->FixedStrates.Reset();
+            }
+            Definitions.Reserve(NumStrates);
+            for (int32 Index = 0; Index < NumStrates; ++Index)
+            {
+                UVoxelStrateDefinition* Definition = bUseAuthoredStrate
+                    ? DuplicateObject<UVoxelStrateDefinition>(
+                        AuthoredDefinition, GetTransientPackage())
+                    : NewObject<UVoxelStrateDefinition>(
+                        GetTransientPackage(), NAME_None, RF_Transient);
+                if (Definition == nullptr)
+                {
+                    OutError = FString::Printf(
+                        TEXT("Could not create transient strate definition for slot %d."), Index);
+                    return false;
+                }
+                if (!bUseAuthoredStrate)
+                {
+                    Definition->StrateName = FText::FromString(FString::Printf(
+                        TEXT("VoxelForgeExplore_%s_slot%d"),
+                        ArchetypeName(Index == Arguments.Slot
+                            ? Arguments.Archetype
+                            : ECaveGeneratorType::TunnelNetwork),
+                        Index));
+                    Definition->StrateDescription = FText::FromString(
+                        TEXT("Transient, deterministic commandlet definition."));
+                    // The commandlet's acceptance sweep uses the owner-facing base spacing:
+                    // 8 chunks * 32 voxels * 0.125 m = 32 m per strate. Production assets may be taller;
+                    // this keeps the measured tunnel arithmetic tied to the stated ~32 m descent.
+                    Definition->StrateHeightInChunks = 8;
+                    Definition->TransitionType = EVoxelStrateTransition::Hard;
+                    Definition->GeneratorType = Index == Arguments.Slot
                         ? Arguments.Archetype
-                        : ECaveGeneratorType::TunnelNetwork),
-                    Index));
-                Definition->StrateDescription = FText::FromString(
-                    TEXT("Transient, deterministic commandlet definition."));
-                // The commandlet's acceptance sweep uses the owner-facing base spacing:
-                // 8 chunks * 32 voxels * 0.125 m = 32 m per strate. Production assets may be taller;
-                // this keeps the measured tunnel arithmetic tied to the stated ~32 m descent.
-                Definition->StrateHeightInChunks = 8;
-                Definition->TransitionType = EVoxelStrateTransition::Hard;
-                Definition->GeneratorType = Index == Arguments.Slot
-                    ? Arguments.Archetype
-                    : ECaveGeneratorType::TunnelNetwork;
-                if (Arguments.bWormsEnabledOverride)
-                {
-                    Definition->bEnableWorms = Arguments.bWormsEnabled;
+                        : ECaveGeneratorType::TunnelNetwork;
+                    if (Arguments.bWormsEnabledOverride)
+                    {
+                        Definition->bEnableWorms = Arguments.bWormsEnabled;
+                    }
+                    if (Arguments.bWormStrengthOverride
+                        && (Definition->GeneratorType == ECaveGeneratorType::TunnelNetwork
+                            || Definition->GeneratorType == ECaveGeneratorType::Underwater))
+                    {
+                        Definition->GenerationParams.WormStrength = Arguments.WormStrength;
+                    }
                 }
-                if (Arguments.bWormStrengthOverride
-                    && (Definition->GeneratorType == ECaveGeneratorType::TunnelNetwork
-                        || Definition->GeneratorType == ECaveGeneratorType::Underwater))
-                {
-                    Definition->GenerationParams.WormStrength = Arguments.WormStrength;
-                }
-            }
 
-            const TSoftObjectPtr<UVoxelStrateDefinition> SoftDefinition(Definition);
-            Settings->FixedStrates.Add(Index, SoftDefinition);
-            if (!bUseAuthoredStrate)
-            {
-                Settings->StratePool.Add(SoftDefinition);
+                const TSoftObjectPtr<UVoxelStrateDefinition> SoftDefinition(Definition);
+                Settings->FixedStrates.Add(Index, SoftDefinition);
+                if (!bUseAuthoredStrate)
+                {
+                    Settings->StratePool.Add(SoftDefinition);
+                }
+                Definitions.Add(TStrongObjectPtr<UVoxelStrateDefinition>(Definition));
             }
-            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;
@@ -17654,8 +17855,16 @@ bool RunCoreWorldActorIntegrationTest(const FExploreArguments& Arguments, FStrin
 
     float StagedWalkSpeedCmPerSecond = 0.0f;
     float StagedSprintSpeedCmPerSecond = 0.0f;
-    if (!ReadStagedPlayerSpeeds(
-            StagedWalkSpeedCmPerSecond, StagedSprintSpeedCmPerSecond, OutError))
+    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 +17872,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 +18049,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 +18076,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 +18105,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,6 +18118,11 @@ 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)
         {
@@ -18023,6 +18277,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 +18463,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 +18520,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 +18610,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;
@@ -19367,7 +19686,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 +21680,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);

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,10 +64,22 @@ 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
@@ -119,11 +146,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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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
+#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/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

@@ -81,6 +81,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 +131,54 @@ 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 passageTileMouthSegmentCandidates = 0;
+        std::uint64_t passageComposerQueries = 0;
+        std::uint64_t passageIterations = 0;
+        std::uint64_t passageUpperMouthFilterChecks = 0;
+        std::uint64_t passageColumnCandidates = 0;
+        std::uint64_t passageColumnDistanceCalls = 0;
+        std::uint64_t passageNegativeBoundChecks = 0;
+        std::uint64_t passageNegativeBoundRejects = 0;
+        std::uint64_t passagePositiveBoundChecks = 0;
+        std::uint64_t passagePositiveBoundRejects = 0;
+        std::uint64_t passageCarveSegmentVisits = 0;
+        std::uint64_t passageSmoothCarveJoins = 0;
+        std::uint64_t passageSupportSegmentVisits = 0;
+        std::uint64_t passageSmoothSupportJoins = 0;
+        std::uint64_t passageSupportCapsuleChecks = 0;
+        std::uint64_t passageLaterBoreChecks = 0;
+        std::uint64_t passageOtherCapsuleChecks = 0;
+        std::uint64_t passageMouthSupportCalls = 0;
+        std::uint64_t passageMouthRouteSegmentChecks = 0;
+        std::uint64_t passageReliefFieldCalls = 0;
+        std::uint64_t passageSmoothstepEvaluations = 0;
         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::uint64_t densityX8PointCalls = 0;
+        std::uint64_t densityFieldEvalNanoseconds = 0;
+        std::uint64_t densityFieldEvalSamplePoints = 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;
@@ -157,12 +200,30 @@ 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;
         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 +252,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 +280,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 +315,130 @@ 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.
+    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 213;
 
     enum class FieldChannel : std::uint32_t
     {
@@ -297,6 +485,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 +555,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 +615,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 +687,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 +829,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 +984,24 @@ 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 usePassageAnchorForColumns = false;
+        bool hasNativeCaveField = false;
+        bool hasNativeLatticeField = false;
+    };
+
+    struct ResolvedLayoutInterfaceCapabilitiesV1
+    {
+        bool preserveUpperBedrockAirGap = false;
+        bool surfaceToTunnelLandingSupport = false;
+    };
+
     struct ResolvedLayoutStratumV2
     {
         std::string stableId;
@@ -637,6 +1031,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 +1083,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{};
@@ -719,6 +1148,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 +1169,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 +1193,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;
@@ -1021,6 +1533,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 +1577,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 +1762,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 +1783,14 @@ 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: 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;
+        bool exactMidpointDensityMemo = false;
+        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;
@@ -1282,7 +1807,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;
@@ -1336,6 +1861,12 @@ namespace VoxelForgeCore
         ShapeBuildStats buildStats() const;
 
         float densityAt(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 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,

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

@@ -1217,6 +1217,82 @@ 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)
 {
@@ -1230,9 +1306,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 +1324,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));
@@ -1277,8 +1373,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 +1393,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 +1419,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,9 +1491,8 @@ 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)
 {
@@ -1358,8 +1501,16 @@ inline void AppendStratumBoundaryFloors(const FStandaloneOwnerWorld& World,
     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,9 +1518,17 @@ 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;
 
@@ -1390,16 +1549,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 +1584,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 +1606,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,15 +973,266 @@ 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
-            ? 2.0 * static_cast<double>(edge.thicknessSubvoxels) * (4.0 * t * (1.0 - t))
-            : 0.0;
+                && WorldAssemblyEvaluatorVersion < 172
+                ? 2.0 * static_cast<double>(edge.thicknessSubvoxels) * (4.0 * t * (1.0 - t))
+                : 0.0;
         const double upper = z - deck;
         const double lower = deck - static_cast<double>(edge.thicknessSubvoxels) - arch - z;
         if (topSurface) *topSurface = upper >= std::max(horizontal, lower);
         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,8 +2215,11 @@ std::optional<FloatingIslandManifestV1> PlanFloatingIslandCluster(
                 routeX=floating_island_detail::RoundQ(mouthX);
                 routeY=floating_island_detail::RoundQ(mouthY);
             }
-            const auto surface = floating_island_detail::FindCapsuleFootingTopZ(
-                recipe, manifest.plan, routeX, routeY);
+            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; }
             WorldAssemblyRoutePointV1 point;
@@ -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};
-    for (const auto& island : plan_->islands)
-        if (floating_island_detail::Intersects(minimum, maximum,
-                island.influenceMinimumSubvoxels, island.influenceMaximumSubvoxels)) return result;
-    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.
-    result.known = true;
-    result.minimumDensitySubvoxels = 0;
-    result.maximumDensitySubvoxels = floating_island_detail::MaxDensity;
+    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)
+    {
+        FDensityRange group=IslandDensityRange(*recipe_,island,minimum,maximum);
+        for(const auto& edge:plan_->clusterEdges)
+        {
+            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=static_cast<std::int64_t>(minimumRounded);
+    result.maximumDensitySubvoxels=static_cast<std::int64_t>(maximumRounded);
     return result;
 }
 

Standalone/Core/src/VoxelForgeCore.cpp

@@ -12,10 +12,12 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <set>
+#include <map>
 #include <functional>
 #include <thread>
 #include <new>
 #include <stdexcept>
+#include <sstream>
 
 namespace vfcore::detail
 {
@@ -40,6 +42,34 @@ namespace VoxelForgeCore
 
     namespace
     {
+#if defined(VF_L30_ENABLE_COST_COUNTERS)
+        void PrintL30CostCounters(const FStandaloneShapeWorld::FClassificationThreadStats& stats)
+        {
+            if(stats.BoundaryBandCalls==0&&stats.ColumnZOverlapCalls==0)return;
+            std::printf("[L30CostTile] boundary_band_calls=%llu transition_window_checks=%llu "
+                "transition_window_hits=%llu transition_evaluations=%llu passage_fade_calls=%llu "
+                "passage_fade_mouth_tests=%llu column_z_overlap_calls=%llu column_guard_calls=%llu "
+                "column_guard_nonpositive_skips=%llu column_guard_radial_rejects=%llu "
+                "boundary_tile_cull_rejects=%llu boundary_point_cull_rejects=%llu "
+                "transition_passage_tile_skips=%llu "
+                "column_sdf_calls=%llu\n",
+                static_cast<unsigned long long>(stats.BoundaryBandCalls),
+                static_cast<unsigned long long>(stats.TransitionWindowChecks),
+                static_cast<unsigned long long>(stats.TransitionWindowHits),
+                static_cast<unsigned long long>(stats.TransitionEvaluatorCalls),
+                static_cast<unsigned long long>(stats.TransitionPassageFadeCalls),
+                static_cast<unsigned long long>(stats.TransitionPassageMouthTests),
+                static_cast<unsigned long long>(stats.ColumnZOverlapCalls),
+                static_cast<unsigned long long>(stats.ColumnGuardCalls),
+                static_cast<unsigned long long>(stats.ColumnGuardNonpositiveSkips),
+                static_cast<unsigned long long>(stats.ColumnGuardRadialRejects),
+                static_cast<unsigned long long>(stats.BoundaryTileCullRejects),
+                static_cast<unsigned long long>(stats.BoundaryPointCullRejects),
+                static_cast<unsigned long long>(stats.TransitionPassageTileSkips),
+                static_cast<unsigned long long>(stats.ColumnSignedDistanceCalls));
+        }
+#endif
+
         FIntVector ToNative(Vec3i value) { return {value.x,value.y,value.z}; }
         FVector ToNative(Vec3d value) { return {value.x,value.y,value.z}; }
         Vec3d FromNative(const FVector& value) { return {value.X,value.Y,value.Z}; }
@@ -188,6 +218,19 @@ namespace VoxelForgeCore
             return hash;
         }
 
+        std::uint64_t HashMaterialSamples(std::span<const MeshVertex> vertices)
+        {
+            std::uint64_t hash=14695981039346656037ull;
+            AddWord(hash,vertices.size(),8);
+            for(const MeshVertex& vertex:vertices)
+            {
+                AddWord(hash,vertex.hostMaterialId,2);
+                for(const std::uint16_t id:vertex.resourceMaterialIds)AddWord(hash,id,2);
+                for(const std::uint16_t weight:vertex.resourceWeightsQ16)AddWord(hash,weight,2);
+            }
+            return hash;
+        }
+
         std::uint64_t HashBrushTransaction(const EditTransaction& transaction)
         {
             std::uint64_t hash=14695981039346656037ull;
@@ -961,6 +1004,15 @@ namespace VoxelForgeCore
     const ResolvedLayoutSnapshotV3* ResolvedWorldSnapshot::resolvedLayout() const noexcept
     { return data_?data_->resolvedLayout.get():nullptr; }
 
+    ResolvedWorldSnapshot ResolvedWorldSnapshot::withResolvedLayout(
+        const ResolvedLayoutSnapshotV3& layout) const
+    {
+        if(!data_)return {};
+        auto copy=std::make_shared<Data>(*data_);
+        copy->resolvedLayout=std::make_shared<ResolvedLayoutSnapshotV3>(layout);
+        return ResolvedWorldSnapshot(std::move(copy));
+    }
+
     ResolvedWorldSnapshot ResolvedWorldSnapshot::withoutResolvedLayoutPassages() const
     {
         if(!data_||!data_->resolvedLayout)return {};
@@ -1018,6 +1070,18 @@ namespace VoxelForgeCore
         }
     };
 
+    struct FScopedIslandColumnCacheInstrumentation
+    {
+        floating_island_detail::FIslandColumnCacheInstrumentation* Previous=nullptr;
+        explicit FScopedIslandColumnCacheInstrumentation(
+            floating_island_detail::FIslandColumnCacheInstrumentation* Current,bool Enabled)
+            :Previous(Enabled?floating_island_detail::SetIslandColumnCacheInstrumentation(Current):nullptr),
+             bEnabled(Enabled){}
+        ~FScopedIslandColumnCacheInstrumentation()
+        {if(bEnabled)floating_island_detail::SetIslandColumnCacheInstrumentation(Previous);}
+        bool bEnabled=false;
+    };
+
     World::World(ResolvedWorldSnapshot snapshot):impl_(std::make_unique<Impl>())
     {
         if(snapshot.data_)
@@ -1179,27 +1243,150 @@ namespace VoxelForgeCore
             const double tileMaximum[3]={static_cast<double>(maximum.X),
                 static_cast<double>(maximum.Y),static_cast<double>(maximum.Z)};
             for(const auto& passage:layout.passages)
-            for(std::size_t segment=1;segment<passage.controlPoints.size();++segment)
             {
-                const auto& a=passage.controlPoints[segment-1];
-                const auto& b=passage.controlPoints[segment];
-                const double radius=static_cast<double>(std::max(
-                    a.radiusSubvoxels,b.radiusSubvoxels))/Q;
-                const double horizontalExtent=std::max(radius,bridgeHalfWidthVoxels);
-                const double low[3]={
-                    std::min(a.positionSubvoxels[0],b.positionSubvoxels[0])/Q-horizontalExtent,
-                    std::min(a.positionSubvoxels[1],b.positionSubvoxels[1])/Q-horizontalExtent,
-                    std::min(a.positionSubvoxels[2],b.positionSubvoxels[2])/Q-radius
-                        -bridgeFootDepthVoxels};
-                const double high[3]={
-                    std::max(a.positionSubvoxels[0],b.positionSubvoxels[0])/Q+horizontalExtent,
-                    std::max(a.positionSubvoxels[1],b.positionSubvoxels[1])/Q+horizontalExtent,
-                    std::max(a.positionSubvoxels[2],b.positionSubvoxels[2])/Q+radius};
+                for(std::size_t segment=1;segment<passage.controlPoints.size();++segment)
+                {
+                    const auto& a=passage.controlPoints[segment-1];
+                    const auto& b=passage.controlPoints[segment];
+                    const double radius=static_cast<double>(std::max(
+                        a.radiusSubvoxels,b.radiusSubvoxels))/Q;
+                    const double horizontalExtent=std::max(radius,bridgeHalfWidthVoxels);
+                    const double low[3]={
+                        std::min(a.positionSubvoxels[0],b.positionSubvoxels[0])/Q-horizontalExtent,
+                        std::min(a.positionSubvoxels[1],b.positionSubvoxels[1])/Q-horizontalExtent,
+                        std::min(a.positionSubvoxels[2],b.positionSubvoxels[2])/Q-radius
+                            -bridgeFootDepthVoxels};
+                    const double high[3]={
+                        std::max(a.positionSubvoxels[0],b.positionSubvoxels[0])/Q+horizontalExtent,
+                        std::max(a.positionSubvoxels[1],b.positionSubvoxels[1])/Q+horizontalExtent,
+                        std::max(a.positionSubvoxels[2],b.positionSubvoxels[2])/Q+radius};
+                    bool overlap=true;
+                    for(int axis=0;axis<3;++axis)
+                        overlap&=high[axis]>=tileMinimum[axis]&&low[axis]<=tileMaximum[axis];
+                    if(overlap)return true;
+                }
+
+            // L27 can add a long support column around an unsupported passage span. Its
+            // radius can exceed the route and bridge bounds above by the column wall and
+            // flare allowance. The precompile shape-free proof runs before that crossing
+            // plan exists, so conservatively bound every possible column from the resolved
+            // route itself. The center is either the passage anchor or an average of route
+            // samples; in the latter case it lies inside the route's XY bounds.
+            if(passage.controlPoints.size()>=2)
+            {
+                double routeMinimum[3]={std::numeric_limits<double>::infinity(),
+                    std::numeric_limits<double>::infinity(),
+                    std::numeric_limits<double>::infinity()};
+                double routeMaximum[3]={-std::numeric_limits<double>::infinity(),
+                    -std::numeric_limits<double>::infinity(),
+                    -std::numeric_limits<double>::infinity()};
+                double maximumBoreRadius=0.0;
+                for(const auto& point:passage.controlPoints)
+                {
+                    for(int axis=0;axis<3;++axis)
+                    {
+                        const double value=static_cast<double>(point.positionSubvoxels[axis])/Q;
+                        routeMinimum[axis]=std::min(routeMinimum[axis],value);
+                        routeMaximum[axis]=std::max(routeMaximum[axis],value);
+                    }
+                    maximumBoreRadius=std::max(maximumBoreRadius,
+                        static_cast<double>(point.radiusSubvoxels)/Q);
+                }
+
+                double centerMinimumX=routeMinimum[0],centerMaximumX=routeMaximum[0];
+                double centerMinimumY=routeMinimum[1],centerMaximumY=routeMaximum[1];
+                double maximumRouteOffset=std::hypot(
+                    routeMaximum[0]-routeMinimum[0],routeMaximum[1]-routeMinimum[1]);
+                const auto upper=std::find_if(layout.strates.begin(),layout.strates.end(),
+                    [&passage](const auto& stratum)
+                    {return stratum.strateIndex==passage.upperStrateIndex;});
+                if(upper!=layout.strates.end()
+                    &&upper->passageCapabilities.usePassageAnchorForColumns)
+                {
+                    const auto anchor=std::find_if(upper->anchors.begin(),upper->anchors.end(),
+                        [](const auto& value)
+                        {return value.kind=="passage_anchor"&&value.values.size()>=2;});
+                    if(anchor!=upper->anchors.end())
+                    {
+                        const double centerX=static_cast<double>(anchor->values[0])/Q;
+                        const double centerY=static_cast<double>(anchor->values[1])/Q;
+                        centerMinimumX=centerMaximumX=centerX;
+                        centerMinimumY=centerMaximumY=centerY;
+                        maximumRouteOffset=0.0;
+                        for(const auto& point:passage.controlPoints)
+                            maximumRouteOffset=std::max(maximumRouteOffset,std::hypot(
+                                static_cast<double>(point.positionSubvoxels[0])/Q-centerX,
+                                static_cast<double>(point.positionSubvoxels[1])/Q-centerY));
+                    }
+                }
+                // The generated maximum column radius is the route offset, bore radius,
+                // and 13.25 m of wall/irregularity/flare allowance.
+                const double columnRadius=maximumRouteOffset+maximumBoreRadius
+                    +13.25*voxelsPerMetre;
+                const double columnMinimum[3]={centerMinimumX-columnRadius,
+                    centerMinimumY-columnRadius,routeMinimum[2]-6.0*voxelsPerMetre};
+                const double columnMaximum[3]={centerMaximumX+columnRadius,
+                    centerMaximumY+columnRadius,routeMaximum[2]+5.0*voxelsPerMetre};
                 bool overlap=true;
                 for(int axis=0;axis<3;++axis)
-                    overlap&=high[axis]>=tileMinimum[axis]&&low[axis]<=tileMaximum[axis];
+                    overlap=overlap&&columnMaximum[axis]>=tileMinimum[axis]
+                        &&columnMinimum[axis]<=tileMaximum[axis];
                 if(overlap)return true;
             }
+            }
+            return false;
+        }
+
+        bool ResolvedStampTouchesBox(const ResolvedLayoutSnapshotV3& layout,
+            const FIntVector& minimum,const FIntVector& maximum,
+            std::uint32_t coreVoxelSizeMicrons)
+        {
+            if(layout.stamps.empty()||coreVoxelSizeMicrons==0)return false;
+            const double tileMinimum[3]={static_cast<double>(minimum.X),
+                static_cast<double>(minimum.Y),static_cast<double>(minimum.Z)};
+            const double tileMaximum[3]={static_cast<double>(maximum.X),
+                static_cast<double>(maximum.Y),static_cast<double>(maximum.Z)};
+            for(const auto& stamp:layout.stamps)
+            {
+                bool overlap=true;
+                for(std::size_t axis=0;axis<3;++axis)
+                {
+                    const double low=static_cast<double>(stamp.boundsMinimumMicrometres[axis])
+                        /coreVoxelSizeMicrons;
+                    const double high=static_cast<double>(stamp.boundsMaximumMicrometres[axis])
+                        /coreVoxelSizeMicrons;
+                    overlap=overlap&&high>=tileMinimum[axis]&&low<=tileMaximum[axis];
+                }
+                if(overlap)return true;
+            }
+            return false;
+        }
+
+        bool ResolvedCavernGraphTouchesBox(const ResolvedLayoutSnapshotV3& layout,
+            const FIntVector& minimum,const FIntVector& maximum,
+            std::uint32_t coreVoxelSizeMicrons)
+        {
+            if((layout.cavernRooms.empty()&&layout.cavernEdges.empty())
+                ||coreVoxelSizeMicrons==0)return false;
+            const double tileMinimum[3]={static_cast<double>(minimum.X),
+                static_cast<double>(minimum.Y),static_cast<double>(minimum.Z)};
+            const double tileMaximum[3]={static_cast<double>(maximum.X),
+                static_cast<double>(maximum.Y),static_cast<double>(maximum.Z)};
+            const auto overlaps=[&](const auto& feature)
+            {
+                bool overlap=true;
+                for(std::size_t axis=0;axis<3;++axis)
+                {
+                    const double low=static_cast<double>(feature.boundsMinimumMicrometres[axis])
+                        /coreVoxelSizeMicrons;
+                    const double high=static_cast<double>(feature.boundsMaximumMicrometres[axis])
+                        /coreVoxelSizeMicrons;
+                    overlap=overlap&&high>=tileMinimum[axis]&&low<=tileMaximum[axis];
+                }
+                return overlap;
+            };
+            for(const auto& room:layout.cavernRooms)if(overlaps(room))return true;
+            for(const auto& edge:layout.cavernEdges)if(overlaps(edge))return true;
             return false;
         }
     }
@@ -1220,7 +1407,8 @@ namespace VoxelForgeCore
             static_cast<int32>(std::clamp<std::uint32_t>(request.workerLimit,1,16)),ToNative(request.detail),
             request.includeFarWorld,error,&scheduler,request.roundTunnels,request.profileDetailBand,
             request.validatePassageRoutes,request.gpuVisualDetailTiles,
-            request.cpuVisualDetailTiles,impl_->worldAssembly.get(),impl_->resolvedLayout.get());
+            request.cpuVisualDetailTiles,impl_->worldAssembly.get(),impl_->resolvedLayout.get(),
+            request.parallelSignEdgeRepair);
         if(ok)
         {
             impl_->shape=std::move(shape);
@@ -1247,13 +1435,31 @@ namespace VoxelForgeCore
         const int32 firstSurfaceChunk=FloorDiv(boundsMin.Z,LayoutChunkWidth);
         const int32 lastSurfaceChunk=FloorDiv(boundsMax.Z,LayoutChunkWidth);
         const WorldAssemblyStratumPlanV1* selectedPlan=nullptr;
+        const ResolvedLayoutStratumV2* selectedGraphStratum=nullptr;
         for(int32 chunkZ=firstSurfaceChunk;chunkZ<=lastSurfaceChunk;++chunkZ)
         {
-            if(impl_->owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,chunkZ))
-                !=ECaveGeneratorType::SurfaceWorld)return false;
             const int32 strateIndex=impl_->owner->Manager->GetStrateIndex(
                 static_cast<float>((static_cast<double>(chunkZ)+0.5)
                     *impl_->resolvedLayout->strateLayoutChunkSizeMicrometres/10000.0));
+            const auto resolved=std::find_if(impl_->resolvedLayout->strates.begin(),
+                impl_->resolvedLayout->strates.end(),[strateIndex](const auto& stratum)
+                    {return stratum.strateIndex==strateIndex;});
+            const bool nativeGraph=resolved!=impl_->resolvedLayout->strates.end()
+                &&HasNativeGraphField(*resolved)
+                &&(IsNativeCaveFieldStratum(*resolved)
+                    ?resolved->passageCapabilities.hasNativeCaveField
+                    :resolved->passageCapabilities.hasNativeLatticeField);
+            const auto managerType=impl_->owner->Manager->GetGeneratorTypeForChunk(
+                FIntVector(0,0,chunkZ));
+            if(!nativeGraph&&managerType!=ECaveGeneratorType::SurfaceWorld)return false;
+            if(nativeGraph)
+            {
+                if(selectedGraphStratum&&selectedGraphStratum!=&*resolved)return false;
+                selectedGraphStratum=&*resolved;
+                if(selectedPlan)return false;
+                continue;
+            }
+            if(selectedGraphStratum)return false;
             const auto found=std::find_if(impl_->worldAssembly->plan.strates.begin(),
                 impl_->worldAssembly->plan.strates.end(),[strateIndex,chunkZ](const auto& plan)
                 {return plan.strateIndex==strateIndex&&chunkZ<=plan.topChunkZ
@@ -1262,7 +1468,9 @@ namespace VoxelForgeCore
                 ||(selectedPlan&&selectedPlan!=&*found))return false;
             selectedPlan=&*found;
         }
-        if(!selectedPlan||!Heightfield2D(impl_->worldAssembly->recipe,*selectedPlan).isValid())
+        if((!selectedGraphStratum&&(!selectedPlan
+                ||!Heightfield2D(impl_->worldAssembly->recipe,*selectedPlan).isValid()))
+            ||(selectedGraphStratum&&selectedPlan))
             return false;
 
         const double coreVoxelsPerOwnerChunk=static_cast<double>(
@@ -1280,10 +1488,17 @@ namespace VoxelForgeCore
             tileMinimum[2]*scale};
         const std::int64_t subMaximum[3]={tileMaximum[0]*scale,tileMaximum[1]*scale,
             tileMaximum[2]*scale};
-        for(const WorldAssemblyFeatureV1& feature:selectedPlan->features)
-            if(IntersectsBox(feature.minimumSubvoxels,feature.maximumSubvoxels,
-                subMinimum,subMaximum))return false;
-        if(RouteTouchesBox(*selectedPlan,subMinimum,subMaximum))return false;
+        if(selectedPlan)
+        {
+            for(const WorldAssemblyFeatureV1& feature:selectedPlan->features)
+                if(IntersectsBox(feature.minimumSubvoxels,feature.maximumSubvoxels,
+                    subMinimum,subMaximum))return false;
+            if(RouteTouchesBox(*selectedPlan,subMinimum,subMaximum))return false;
+        }
+        if(ResolvedStampTouchesBox(*impl_->resolvedLayout,boundsMin,boundsMax,
+            impl_->owner->CoreVoxelSizeMicrons))return false;
+        if(ResolvedCavernGraphTouchesBox(*impl_->resolvedLayout,boundsMin,boundsMax,
+            impl_->owner->CoreVoxelSizeMicrons))return false;
         if(ResolvedPassageTouchesBox(*impl_->resolvedLayout,boundsMin,boundsMax,
             impl_->owner->CoreVoxelSizeMicrons))return false;
         if(OwnerPassageTouchesBox(*impl_->owner,boundsMin,boundsMax))return false;
@@ -1542,6 +1757,62 @@ namespace VoxelForgeCore
 
     float World::densityAt(Vec3d position) const
     { return impl_&&impl_->shapeReady.load(std::memory_order_acquire)&&impl_->shape?impl_->shape->DensityAt(static_cast<float>(position.x),static_cast<float>(position.y),static_cast<float>(position.z)):0.0f; }
+    MaterialSampleV1 World::materialAt(Vec3d position) const
+    {
+        if(!impl_||!impl_->shapeReady.load(std::memory_order_acquire)||!impl_->shape)
+            return {};
+        return impl_->shape->MaterialAt(static_cast<float>(position.x),
+            static_cast<float>(position.y),static_cast<float>(position.z));
+    }
+    OreMiningYieldV1 World::measureOreMiningYieldForSphere(Vec3d centerVoxel,
+        double radiusMetres,double sampleSpacingMetres) const
+    {
+        OreMiningYieldV1 result;result.sampleSpacingMetres=sampleSpacingMetres;
+        if(!impl_||!impl_->shapeReady.load(std::memory_order_acquire)||!impl_->shape
+            ||!std::isfinite(radiusMetres)||!std::isfinite(sampleSpacingMetres)
+            ||radiusMetres<=0.0||sampleSpacingMetres<0.05||sampleSpacingMetres>2.0)
+            return result;
+        const std::uint32_t voxelMicrometres=impl_->configuration.voxelSizeMicrons;
+        if(voxelMicrometres==0)return result;
+        const double voxelMetres=static_cast<double>(voxelMicrometres)/1000000.0;
+        const double radiusVoxels=radiusMetres/voxelMetres;
+        const double spacingVoxels=sampleSpacingMetres/voxelMetres;
+        const int steps=static_cast<int>(std::ceil(radiusMetres/sampleSpacingMetres));
+        const double radiusSquared=radiusMetres*radiusMetres;
+        std::map<std::uint16_t,std::uint64_t> weightedSamples;
+        for(int z=-steps;z<=steps;++z)
+            for(int y=-steps;y<=steps;++y)
+                for(int x=-steps;x<=steps;++x)
+                {
+                    const double dx=x*sampleSpacingMetres;
+                    const double dy=y*sampleSpacingMetres;
+                    const double dz=z*sampleSpacingMetres;
+                    const double distanceSquared=dx*dx+dy*dy+dz*dz;
+                    if(distanceSquared>radiusSquared)continue;
+                    const Vec3d point={centerVoxel.x+x*spacingVoxels,
+                        centerVoxel.y+y*spacingVoxels,centerVoxel.z+z*spacingVoxels};
+                    const float before=impl_->shape->DensityAt(static_cast<float>(point.x),
+                        static_cast<float>(point.y),static_cast<float>(point.z));
+                    const double carveDensity=radiusVoxels
+                        -std::sqrt(distanceSquared)/voxelMetres;
+                    const double after=std::max(static_cast<double>(before),carveDensity);
+                    if(!(before<0.0f&&after>=0.0))continue;
+                    ++result.solidSamplesRemoved;
+                    const MaterialSampleV1 material=materialAt(point);
+                    for(std::size_t slot=0;slot<2;++slot)
+                        if(material.resourceMaterialIds[slot]
+                            &&material.resourceWeightsQ16[slot])
+                            weightedSamples[material.resourceMaterialIds[slot]]
+                                +=material.resourceWeightsQ16[slot];
+                }
+        const double sampleVolume=sampleSpacingMetres*sampleSpacingMetres
+            *sampleSpacingMetres;
+        result.resources.reserve(weightedSamples.size());
+        for(const auto& [id,weighted]:weightedSamples)
+            result.resources.push_back({id,weighted,
+                static_cast<double>(weighted)/65535.0*sampleVolume});
+        return result;
+    }
     std::vector<PassageVoidCrossingAuditV1> World::passageVoidCrossings() const
     {
         std::vector<PassageVoidCrossingAuditV1> result;
@@ -1742,6 +2013,10 @@ namespace VoxelForgeCore
         FScopedSharedColumnCaches sharedColumnCaches(options.useSharedColumnCache
                 ?impl_->sharedHeightfieldColumns.get():nullptr,
             options.useSharedColumnCache?impl_->sharedIslandColumns.get():nullptr);
+        floating_island_detail::FIslandColumnCacheInstrumentation islandCacheInstrumentation;
+        islandCacheInstrumentation.tileStartCycles=VoxelForgeCoreShared::ReadCpuCycles();
+        FScopedIslandColumnCacheInstrumentation islandCacheScope(
+            &islandCacheInstrumentation,options.instrumentTileDrain);
         const auto& world=*impl_->owner;
         FStandaloneShapeWorld nativeOnlyShape;
         FIntVector nativeOnlyMinimum,nativeOnlyMaximum;
@@ -1771,6 +2046,10 @@ namespace VoxelForgeCore
         mesher.bStandaloneSkipUV=options.skipUv;mesher.bStandaloneSkipColors=options.skipColors;
         mesher.bStandaloneSkipMaterialGroups=options.skipMaterialGroups;
         mesher.bStandaloneEnableGradientMemoization=options.memoizeMcGradients;
+        mesher.bStandaloneEnableExactMidpointDensityMemo=options.exactMidpointDensityMemo;
+        mesher.bStandaloneEnableActiveLaneBatching=options.activeLaneBatching;
+        mesher.bStandaloneProofBlockCells=static_cast<int32>(std::clamp<std::uint32_t>(
+            options.proofBlockCells,1u,static_cast<std::uint32_t>(std::max(1,CHUNK_SIZE))));
         mesher.bGenerateSkirts=world.bGenerateSkirts;
         mesher.SkirtCells=static_cast<float>(world.SkirtCells)
             *static_cast<float>(world.OwnerVoxelSizeMicrons)
@@ -1881,6 +2160,110 @@ namespace VoxelForgeCore
         int64 sampleCount=0;std::vector<float> densityValues;
         FVoxelMarchingCubesStageTimings McStageTimings;
         TileMesh out;out.key=key;
+        const auto CopyIslandCacheMetrics=[&]()
+        {
+            if(options.instrumentTileDrain)
+            {
+                const auto& QueryCounts=FStandaloneShapeWorld::GetThreadClassificationStats();
+                out.diagnostics.densityPointCalls=QueryCounts.DensityPointCalls;
+                out.diagnostics.densityFloatPointCalls=QueryCounts.DensityFloatPointCalls;
+                out.diagnostics.densityLatticePointCalls=QueryCounts.DensityLatticePointCalls;
+                out.diagnostics.densityUnclampedPointCalls=QueryCounts.DensityUnclampedPointCalls;
+                out.diagnostics.densityX8PointCalls=QueryCounts.DensityX8PointCalls;
+                out.diagnostics.densityFieldEvalNanoseconds=QueryCounts.DensityFieldEvalNanoseconds;
+                out.diagnostics.densityFieldEvalSamplePoints=QueryCounts.DensityFieldEvalSamplePoints;
+            }
+            if(!options.instrumentTileDrain)return;
+            islandCacheInstrumentation.tileCycles=VoxelForgeCoreShared::ReadCpuCycles()
+                -islandCacheInstrumentation.tileStartCycles;
+            out.diagnostics.islandLocalCacheHits=islandCacheInstrumentation.localHits;
+            out.diagnostics.islandLocalCacheMisses=islandCacheInstrumentation.localMisses;
+            out.diagnostics.islandLocalCacheConflictReplacements=
+                islandCacheInstrumentation.localConflictReplacements;
+            out.diagnostics.islandSharedCacheHits=islandCacheInstrumentation.shared.hits;
+            out.diagnostics.islandSharedCacheMisses=islandCacheInstrumentation.shared.misses;
+            out.diagnostics.islandSharedCacheComputes=islandCacheInstrumentation.shared.computes;
+            out.diagnostics.islandSharedCacheConflictReplacements=
+                islandCacheInstrumentation.shared.conflictReplacements;
+            out.diagnostics.islandSharedCacheLockWaitNanoseconds=
+                islandCacheInstrumentation.shared.lockWaitNanoseconds;
+            const auto& a=islandCacheInstrumentation.attribution;
+            const auto Estimate=[](std::uint64_t cycles,std::uint64_t calls,
+                std::uint64_t samples)->std::uint64_t
+            {
+                return samples?static_cast<std::uint64_t>(
+                    static_cast<long double>(cycles)*calls/samples):0;
+            };
+            constexpr std::array<const char*,5> CallerNames={
+                "grid","skirt","boundary","filter","other"};
+            constexpr std::array<const char*,10> BucketNames={
+                "field","island","roots","connectors","helix","column",
+                "local_probe","shared_cache","mouth_filter","boundary"};
+            std::uint64_t sampledNativeCalls=0;
+            for(const auto samples:a.sampledNativeCalls)sampledNativeCalls+=samples;
+            std::ostringstream line;
+            line<<"[FiFieldAttribution] key=("<<key.coordinate.x<<","<<key.coordinate.y<<","<<key.coordinate.z
+                <<",lod"<<key.lod<<") tile_cycles="<<islandCacheInstrumentation.tileCycles
+                <<" sample_period=256 native_calls_est="<<sampledNativeCalls*256
+                <<" native_samples="<<sampledNativeCalls;
+            for(std::size_t i=0;i<a.sampledNativeCalls.size();++i)
+            {
+                line<<" native_"<<CallerNames[i]<<"="<<a.sampledNativeCalls[i]*256<<"/"
+                    <<a.sampledNativeCalls[i]<<"/"
+                    <<Estimate(a.nativeCycles[i],a.sampledNativeCalls[i]*256,
+                        a.sampledNativeCalls[i])
+                    <<" native_"<<CallerNames[i]<<"_ns_est="
+                    <<Estimate(a.nativeNanoseconds[i],a.sampledNativeCalls[i]*256,
+                        a.sampledNativeCalls[i]);
+                line<<" field_"<<CallerNames[i]<<"="<<a.sampledFieldCalls[i]*256<<"/"
+                    <<a.sampledFieldCalls[i]<<"/"
+                    <<Estimate(a.fieldCycles[i],a.sampledFieldCalls[i]*256,
+                        a.sampledFieldCalls[i])
+                    <<" field_"<<CallerNames[i]<<"_ns_est="
+                    <<Estimate(a.fieldNanoseconds[i],a.sampledFieldCalls[i]*256,
+                        a.sampledFieldCalls[i]);
+            }
+            for(std::size_t i=0;i<BucketNames.size();++i)
+                line<<" comp_"<<BucketNames[i]<<"="
+                    <<Estimate(a.exclusiveCycles[i],a.scopeSamples[i]*256,
+                        a.scopeSamples[i])
+                    <<" comp_"<<BucketNames[i]<<"_ns_est="
+                    <<Estimate(a.exclusiveNanoseconds[i],a.scopeSamples[i]*256,
+                        a.scopeSamples[i])
+                    <<"/"<<a.scopeSamples[i]<<"/"<<a.scopeSamples[i]*256;
+            const auto& shared=islandCacheInstrumentation.shared;
+            line<<" local_probe_calls="<<(islandCacheInstrumentation.localHits
+                    +islandCacheInstrumentation.localMisses)
+                <<" shared_calls_est="<<shared.sampledInitialReads*128
+                <<" shared_initial_read="<<shared.sampledInitialReads<<"/"
+                <<Estimate(shared.sampledInitialReadCycles,shared.sampledInitialReads*128,
+                    shared.sampledInitialReads)
+                <<" shared_locked_read="<<shared.sampledLockedReads<<"/"
+                <<Estimate(shared.sampledLockedReadCycles,shared.sampledLockedReads*128,
+                    shared.sampledLockedReads)
+                <<" shared_lock="<<shared.sampledLocks<<"/"
+                <<Estimate(shared.sampledLockCycles,shared.sampledLocks*128,
+                    shared.sampledLocks)
+                <<" shared_build="<<shared.sampledBuilds<<"/"
+                <<Estimate(shared.sampledBuildCycles,shared.sampledBuilds*128,
+                    shared.sampledBuilds)
+                <<" trace_sampled="<<a.traceSampledMisses
+                <<" trace_seen_before="<<a.traceSeenBefore
+                <<" trace_evictions="<<a.traceEvictions
+                <<" trace_reused_evictions="<<a.traceReusedEvictions
+                <<" trace_events="<<a.traceCount;
+            std::printf("%s\n",line.str().c_str());
+            for(std::size_t i=0;i<a.traceCount;++i)
+                std::printf("[FiReuseTrace] tile=(%d,%d,%d,lod%d) set=%llu island=%llu xy=(%lld,%lld) evicted_island=%llu evicted_xy=(%lld,%lld) flags=%u\n",
+                    key.coordinate.x,key.coordinate.y,key.coordinate.z,key.lod,
+                    static_cast<unsigned long long>(a.traceSet[i]),
+                    static_cast<unsigned long long>(a.traceIsland[i]),
+                    static_cast<long long>(a.traceX[i]),static_cast<long long>(a.traceY[i]),
+                    static_cast<unsigned long long>(a.traceEvictedIsland[i]),
+                    static_cast<long long>(a.traceEvictedX[i]),
+                    static_cast<long long>(a.traceEvictedY[i]),
+                    static_cast<unsigned>(a.traceFlags[i]));
+        };
         out.diagnostics.featureRefinedResolution=bFeatureRefinedResolution;
         if(options.profileMesherStages)
         {
@@ -1917,20 +2300,50 @@ namespace VoxelForgeCore
                 bHasNativeSurfaceHorizonPlan=bHasNativeSurfaceHorizonPlan
                     ||(TileMinimumZ<=PlanMaximumZ&&TileMaximumZ>=PlanMinimumZ);
             }
+            constexpr int64 IslandQueryPad=2*WorldAssemblySubvoxelsPerVoxel;
+            const std::array<int64,3> TileMinimum={
+                (static_cast<int64>(origin.X)*WorldAssemblySubvoxelsPerVoxel)-IslandQueryPad,
+                (static_cast<int64>(origin.Y)*WorldAssemblySubvoxelsPerVoxel)-IslandQueryPad,
+                (static_cast<int64>(origin.Z)*WorldAssemblySubvoxelsPerVoxel)-IslandQueryPad};
+            const std::array<int64,3> TileMaximum={
+                ((static_cast<int64>(origin.X)+extent)*WorldAssemblySubvoxelsPerVoxel)+IslandQueryPad,
+                ((static_cast<int64>(origin.Y)+extent)*WorldAssemblySubvoxelsPerVoxel)+IslandQueryPad,
+                ((static_cast<int64>(origin.Z)+extent)*WorldAssemblySubvoxelsPerVoxel)+IslandQueryPad};
             for(const auto& Entry:impl_->worldAssembly->floatingIslands)
             {
                 const int64 PlanMinimumZ=static_cast<int64>(std::min(Entry.bottomChunkZ,Entry.topChunkZ))
                     *impl_->resolvedLayout->strateLayoutChunkWidthSubvoxels/WorldAssemblySubvoxelsPerVoxel;
                 const int64 PlanMaximumZ=(static_cast<int64>(std::max(Entry.bottomChunkZ,Entry.topChunkZ)+1))
                     *impl_->resolvedLayout->strateLayoutChunkWidthSubvoxels/WorldAssemblySubvoxelsPerVoxel;
+                if(TileMinimumZ>PlanMaximumZ||TileMaximumZ<PlanMinimumZ)continue;
+
+                const auto IntersectsTile=[&](const auto& Feature)
+                {
+                    for(std::size_t Axis=0;Axis<3;++Axis)
+                        if(Feature.influenceMinimumSubvoxels[Axis]>TileMaximum[Axis]
+                            ||Feature.influenceMaximumSubvoxels[Axis]<TileMinimum[Axis])return false;
+                    return true;
+                };
+                bool bIslandFeatureOverlap=std::any_of(Entry.manifest.plan.islands.begin(),
+                    Entry.manifest.plan.islands.end(),IntersectsTile)
+                    ||std::any_of(Entry.manifest.plan.clusterEdges.begin(),
+                        Entry.manifest.plan.clusterEdges.end(),IntersectsTile);
+                const auto& Recipe=Entry.manifest.recipe;
+                const int64 Bottom=Recipe.layoutMinimumZSubvoxels;
+                const int64 Top=Recipe.layoutMaximumZSubvoxels;
+                const int64 Seal=Recipe.boundarySealSubvoxels;
+                const bool bBoundarySealOverlap=(TileMinimum[2]<=Top&&TileMaximum[2]>=Top-Seal)
+                    ||(Recipe.geometryVersion<3&&TileMinimum[2]<Bottom+Seal
+                        &&TileMaximum[2]>=Bottom);
                 bHasIslandPlanInTile=bHasIslandPlanInTile
-                    ||(TileMinimumZ<=PlanMaximumZ&&TileMaximumZ>=PlanMinimumZ);
+                    ||bIslandFeatureOverlap||bBoundarySealOverlap;
             }
         }
         const bool bUseNativeSurfaceHorizon=key.lod>=5&&!bOverlapsPlayerEdit
             &&bHasNativeSurfaceHorizonPlan&&!bHasIslandPlanInTile;
         const bool bSkipFarShellRepair=key.lod>=7&&bUseNativeSurfaceHorizon;
         FStandaloneShapeWorld::ResetThreadClassificationStats();
+        FStandaloneShapeWorld::SetThreadDensityQueryProfileEnabled(options.instrumentTileDrain);
         VoxelForgeCore::Heightfield2D::resetThreadColumnCacheStats(
             options.captureColumnCoordinates);
         if(options.captureColumnCoordinates)
@@ -1943,6 +2356,7 @@ namespace VoxelForgeCore
                 static_cast<std::int64_t>(origin.Y+extent)*SubvoxelsPerVoxel);
         }
         bool bNativeSurfaceTile=false;
+        bool bTileProofSkipSafe=false;
         bool bNativeSurfaceBandSafe=false;
         double classificationColumnComputeMilliseconds=0.0;
         if(bHasWorldAssembly)
@@ -1950,10 +2364,15 @@ namespace VoxelForgeCore
             const double columnMillisecondsBeforeClassification=
                 VoxelForgeCore::Heightfield2D::threadColumnCacheStats().columnComputeMilliseconds;
             const auto Classification=tileShape.ClassifyBoxDetailed(origin,step,cells);
+            out.diagnostics.tileProofVetoReason=Classification.LegacyProofVeto;
+            out.diagnostics.tileProofSafe=Classification.bSkipSafe;
+            out.diagnostics.tileLegacyBlockProofRelevant=
+                Classification.bLegacyBlockProofRelevant;
             classificationColumnComputeMilliseconds=std::max(0.0,
                 VoxelForgeCore::Heightfield2D::threadColumnCacheStats().columnComputeMilliseconds
                     -columnMillisecondsBeforeClassification);
             bNativeSurfaceTile=Classification.bNativeSurface;
+            bTileProofSkipSafe=Classification.bSkipSafe;
             if(options.profileMesherStages)
                 out.diagnostics.nativeSurfaceTile=bNativeSurfaceTile;
             // NativeSurfaceDensityAt consumes only the bounded manifest heightfield and its
@@ -1961,7 +2380,7 @@ namespace VoxelForgeCore
             // unknown; edits and cross-strate tiles are still excluded below.
             // NativeSurfaceDensityAt ne consomme que le champ et les volumes bornes du manifeste.
             bNativeSurfaceBandSafe=bNativeSurfaceTile;
-            if(bNativeSurfaceTile)
+            if(bNativeSurfaceTile||bTileProofSkipSafe)
             {
                 out.diagnostics.tileWasClassified=true;
                 switch(Classification.bUnknown?EVoxelTileClass::Mixed:Classification.Verdict)
@@ -1970,12 +2389,30 @@ namespace VoxelForgeCore
                     case EVoxelTileClass::AllAir:out.diagnostics.tileClass=TileClass::allAir;break;
                     case EVoxelTileClass::Mixed:out.diagnostics.tileClass=TileClass::mixed;break;
                 }
-                if((out.diagnostics.tileClass==TileClass::allSolid
+                if(bTileProofSkipSafe&&(out.diagnostics.tileClass==TileClass::allSolid
                     ||out.diagnostics.tileClass==TileClass::allAir)
-                    &&!options.hashDensity&&!options.captureDensitySamples&&!bNeedsFarShell
+                    &&(!options.hashDensity||options.allowUniformSkipsWhenHashing)
+                    &&!options.captureDensitySamples&&!bNeedsFarShell
                     &&!options.auditUniformBlockProofs)
                 {
                     out.diagnostics.meshingSkipped=true;
+                    if(options.hashDensity)
+                    {
+                        const FVoxelMeshData EmptyMesh;
+                        out.densityHash=14695981039346656037ull;
+                        out.meshHash=HashViewerMesh(EmptyMesh);
+                        out.payloadHash=HashPayload(EmptyMesh);
+                        out.topologyHash=HashTopology(EmptyMesh);
+                        out.materialHash=HashMaterialSamples(out.vertices);
+                        if(key.lod>=4)
+                        {
+                            out.meshHash=SaltFarHorizonHash(out.meshHash,options.farHorizonVersion);
+                            out.payloadHash=SaltFarHorizonHash(out.payloadHash,options.farHorizonVersion);
+                            out.topologyHash=SaltFarHorizonHash(out.topologyHash,options.farHorizonVersion);
+                        }
+                        out.hasDensityHash=out.hasMeshHash=out.hasPayloadHash=out.hasTopologyHash=true;
+                        out.hasMaterialHash=true;
+                    }
                     const auto Counts=FStandaloneShapeWorld::GetThreadClassificationStats();
                     const auto& Columns=VoxelForgeCore::Heightfield2D::threadColumnCacheStats();
                     out.diagnostics.solidBoxes=Counts.SolidBoxes;
@@ -1995,6 +2432,9 @@ namespace VoxelForgeCore
                     out.diagnostics.classificationExclusiveMilliseconds=std::max(0.0,
                         Counts.Milliseconds-classificationColumnComputeMilliseconds);
                     out.diagnostics.columnComputeMilliseconds=Columns.columnComputeMilliseconds;
+#if defined(VF_L30_ENABLE_COST_COUNTERS)
+                    PrintL30CostCounters(Counts);
+#endif
                     if(options.captureColumnCoordinates)
                     {
                         out.diagnostics.columnEvaluationWorkerHash=static_cast<std::uint64_t>(
@@ -2002,13 +2442,16 @@ namespace VoxelForgeCore
                         out.diagnostics.columnCoordinateCaptureComplete=Columns.coordinateCaptureComplete;
                         out.diagnostics.evaluatedColumnCoordinates=Columns.evaluatedCoordinates;
                     }
+                    CopyIslandCacheMetrics();
                     out.densitySampleCount=0;
                     return out;
                 }
-                // Native SurfaceWorld classifies each 8-cell block against its exact sample
-                // lattice. This lets the mesher avoid filling density grids for proven air/rock.
-                mesher.bUseBlockEarlyOut=true;
             }
+            // Preserve the committed native-field block path. Legacy block certificates
+            // remain audit-only until their cost is repaid against the full-grid path.
+            if(bHasWorldAssembly&&step<=2
+                &&(bNativeSurfaceTile||options.auditUniformBlockProofs))
+                mesher.bUseBlockEarlyOut=true;
         }
         const auto MeshingStart=std::chrono::steady_clock::now();
         int32 MeshBandMinZVoxel=options.bandMinZVoxel;
@@ -2094,6 +2537,88 @@ namespace VoxelForgeCore
                         RelevantMinimum=std::min(RelevantMinimum,FeatureMinimum);
                         RelevantMaximum=std::max(RelevantMaximum,FeatureMaximum);
                     }
+                    // A resolved passage void column can add solid support above or
+                    // below the native heightfield's local Z range. Its finite radial
+                    // and vertical bounds must participate before the mesh band is clipped.
+                    for(const auto& Crossing:tileShape.GetPassageVoidCrossings())
+                    {
+                        if(!Crossing.needsColumn||Crossing.maximumRadiusSubvoxels<=0
+                            ||Crossing.topZSubvoxels<=Crossing.bottomZSubvoxels)continue;
+                        const double Radius=static_cast<double>(Crossing.maximumRadiusSubvoxels)
+                            /static_cast<double>(SubvoxelScale);
+                        const double CenterX=static_cast<double>(Crossing.centerXSubvoxels)
+                            /static_cast<double>(SubvoxelScale);
+                        const double CenterY=static_cast<double>(Crossing.centerYSubvoxels)
+                            /static_cast<double>(SubvoxelScale);
+                        if(CenterX+Radius<TileMinimum[0]/static_cast<double>(SubvoxelScale)
+                            ||CenterX-Radius>TileMaximum[0]/static_cast<double>(SubvoxelScale)
+                            ||CenterY+Radius<TileMinimum[1]/static_cast<double>(SubvoxelScale)
+                            ||CenterY-Radius>TileMaximum[1]/static_cast<double>(SubvoxelScale))continue;
+                        RelevantMinimum=std::min(RelevantMinimum,
+                            static_cast<double>(Crossing.bottomZSubvoxels)
+                                /static_cast<double>(SubvoxelScale));
+                        RelevantMaximum=std::max(RelevantMaximum,
+                            static_cast<double>(Crossing.topZSubvoxels)
+                                /static_cast<double>(SubvoxelScale));
+                    }
+                    // The native heightfield band only covers the owner terrain and its
+                    // manifest features. Resolved SDF stamps can carve below that band or
+                    // add a floor there, so include every overlapping stamp's bounded Z
+                    // support before clipping marching-cubes samples.
+                    if(impl_->resolvedLayout&&impl_->owner->CoreVoxelSizeMicrons>0)
+                    {
+                        const double MicronsToVoxels=1.0
+                            /static_cast<double>(impl_->owner->CoreVoxelSizeMicrons);
+                        const double TileMinimumX=static_cast<double>(origin.X-step);
+                        const double TileMinimumY=static_cast<double>(origin.Y-step);
+                        const double TileMaximumX=static_cast<double>(origin.X+extent+step);
+                        const double TileMaximumY=static_cast<double>(origin.Y+extent+step);
+                        for(const auto& Stamp:impl_->resolvedLayout->stamps)
+                        {
+                            if(Stamp.strateIndex!=PlanIt->strateIndex)continue;
+                            const double MinimumX=Stamp.boundsMinimumMicrometres[0]
+                                *MicronsToVoxels;
+                            const double MaximumX=Stamp.boundsMaximumMicrometres[0]
+                                *MicronsToVoxels;
+                            const double MinimumY=Stamp.boundsMinimumMicrometres[1]
+                                *MicronsToVoxels;
+                            const double MaximumY=Stamp.boundsMaximumMicrometres[1]
+                                *MicronsToVoxels;
+                            if(MaximumX<TileMinimumX||MinimumX>TileMaximumX
+                                ||MaximumY<TileMinimumY||MinimumY>TileMaximumY)continue;
+                            const double MinimumZ=Stamp.boundsMinimumMicrometres[2]
+                                *MicronsToVoxels;
+                            const double MaximumZ=Stamp.boundsMaximumMicrometres[2]
+                                *MicronsToVoxels;
+                            if(MaximumZ<TileMinimumZ||MinimumZ>TileMaximumZ)continue;
+                            RelevantMinimum=std::min(RelevantMinimum,MinimumZ);
+                            RelevantMaximum=std::max(RelevantMaximum,MaximumZ);
+                        }
+                        const auto includeCavernBounds=[&](const auto& Feature)
+                        {
+                            const double MinimumX=Feature.boundsMinimumMicrometres[0]
+                                *MicronsToVoxels;
+                            const double MaximumX=Feature.boundsMaximumMicrometres[0]
+                                *MicronsToVoxels;
+                            const double MinimumY=Feature.boundsMinimumMicrometres[1]
+                                *MicronsToVoxels;
+                            const double MaximumY=Feature.boundsMaximumMicrometres[1]
+                                *MicronsToVoxels;
+                            if(MaximumX<TileMinimumX||MinimumX>TileMaximumX
+                                ||MaximumY<TileMinimumY||MinimumY>TileMaximumY)return;
+                            const double MinimumZ=Feature.boundsMinimumMicrometres[2]
+                                *MicronsToVoxels;
+                            const double MaximumZ=Feature.boundsMaximumMicrometres[2]
+                                *MicronsToVoxels;
+                            if(MaximumZ<TileMinimumZ||MinimumZ>TileMaximumZ)return;
+                            RelevantMinimum=std::min(RelevantMinimum,MinimumZ);
+                            RelevantMaximum=std::max(RelevantMaximum,MaximumZ);
+                        };
+                        for(const auto& Room:impl_->resolvedLayout->cavernRooms)
+                            includeCavernBounds(Room);
+                        for(const auto& Edge:impl_->resolvedLayout->cavernEdges)
+                            includeCavernBounds(Edge);
+                    }
                     if(std::isfinite(RelevantMinimum)&&std::isfinite(RelevantMaximum))
                     {
                         const int32 NativeBandMinimum=FMath::FloorToInt(RelevantMinimum)-step;
@@ -2142,7 +2667,22 @@ namespace VoxelForgeCore
         // GenerateMesh n'échantillonne que origin..origin+extent et la marge de normale d'un pas ;
         // queryMinimum/queryMaximum ci-dessus couvrent exactement ce domaine inclusif.
         const FStandaloneShapeWorld::FScopedPassageTileQueries passageFeatureScope(
-            tileShape,queryMinimum,queryMaximum);
+            tileShape,queryMinimum,queryMaximum,
+            options.profilePassageComposer?&out.diagnostics:nullptr);
+        if(options.profilePassageComposer)
+        {
+            out.diagnostics.passageComposerProfiled=true;
+            out.diagnostics.passageTileFeatureCount=passageFeatureScope.featureCount();
+            if(impl_->resolvedLayout)
+            {
+                out.diagnostics.passageTileRouteSegmentCandidates=
+                    passageFeatureScope.routeSegmentCandidateCount();
+                for(std::size_t passageIndex=0;
+                    passageIndex<impl_->resolvedLayout->passages.size();++passageIndex)
+                    out.diagnostics.passageTileMouthSegmentCandidates+=
+                        passageFeatureScope.mouthSupportSegments(passageIndex).size();
+            }
+        }
         const bool bDiagnosticColumnSampling=options.diagnosticGlobalOctaveDrop!=0
             ||options.diagnosticColumnInterpolationStride>1;
         const std::uint32_t PreviousOctaveDrop=bDiagnosticColumnSampling
@@ -2211,9 +2751,29 @@ namespace VoxelForgeCore
             out.diagnostics.marchingCubesOtherMilliseconds=McStageTimings.OtherMilliseconds;
             out.diagnostics.marchingCubesGradientFallbackDensityCalls=
                 McStageTimings.GradientFallbackDensityCalls;
+            out.diagnostics.marchingCubesGradientCalls=McStageTimings.GradientCalls;
             out.diagnostics.marchingCubesEdgeMidpointDensityCalls=
                 McStageTimings.EdgeMidpointDensityCalls;
+            out.diagnostics.marchingCubesEdgeMidpointDensityMemoHits=
+                McStageTimings.EdgeMidpointDensityMemoHits;
             out.diagnostics.marchingCubesGradientMemoHits=McStageTimings.GradientMemoHits;
+            out.diagnostics.marchingCubesX8DensityCalls=McStageTimings.X8DensityCalls;
+            out.diagnostics.marchingCubesX8ActiveLanes=McStageTimings.X8ActiveLanes;
+            out.diagnostics.marchingCubesCandidateCells=McStageTimings.CandidateCells;
+            out.diagnostics.marchingCubesZBandRejectedCells=McStageTimings.ZBandRejectedCells;
+            out.diagnostics.marchingCubesCellClassificationCalls=
+                McStageTimings.CellClassificationCalls;
+            out.diagnostics.marchingCubesSurfaceCellCalls=McStageTimings.SurfaceCellCalls;
+            out.diagnostics.marchingCubesProofSkippedSolidCells=
+                McStageTimings.ProofSkippedSolidCells;
+            out.diagnostics.marchingCubesProofSkippedAirCells=
+                McStageTimings.ProofSkippedAirCells;
+            out.diagnostics.marchingCubesProofSkippedDensitySamples=
+                McStageTimings.ProofSkippedDensitySamples;
+            out.diagnostics.marchingCubesSkirtEdgeCandidates=McStageTimings.SkirtEdgeCandidates;
+            out.diagnostics.marchingCubesSkirtBoundaryCandidates=
+                McStageTimings.SkirtBoundaryCandidates;
+            out.diagnostics.marchingCubesSkirtDensityProbes=McStageTimings.SkirtDensityProbes;
         }
         const double MeshingMilliseconds=std::chrono::duration<double,std::milli>(
             std::chrono::steady_clock::now()-MeshingStart).count();
@@ -2356,6 +2916,9 @@ namespace VoxelForgeCore
         if(bHasWorldAssembly)
         {
             const auto Counts=FStandaloneShapeWorld::GetThreadClassificationStats();
+#if defined(VF_L30_ENABLE_COST_COUNTERS)
+            PrintL30CostCounters(Counts);
+#endif
             const auto& Columns=VoxelForgeCore::Heightfield2D::threadColumnCacheStats();
             out.diagnostics.fieldCalls=Columns.pointCalls;
             out.diagnostics.floatFieldCalls=Counts.NativeFloatFieldCalls;
@@ -2408,6 +2971,21 @@ namespace VoxelForgeCore
         out.skirtFaceMasks.assign(mesh.TriangleSkirtFaceMasks.begin(),
             mesh.TriangleSkirtFaceMasks.end());
         out.skirtFaceMasks.resize(mesh.Triangles.Num()/3,0);
+        constexpr std::int64_t MaterialSubvoxelsPerVoxel=WorldAssemblySubvoxelsPerVoxel;
+        const std::array<std::int64_t,3> materialTileMinimum={
+            (static_cast<std::int64_t>(origin.X)-step)*MaterialSubvoxelsPerVoxel,
+            (static_cast<std::int64_t>(origin.Y)-step)*MaterialSubvoxelsPerVoxel,
+            (static_cast<std::int64_t>(origin.Z)-step)*MaterialSubvoxelsPerVoxel};
+        const std::array<std::int64_t,3> materialTileMaximum={
+            (static_cast<std::int64_t>(origin.X)+extent+step)*MaterialSubvoxelsPerVoxel,
+            (static_cast<std::int64_t>(origin.Y)+extent+step)*MaterialSubvoxelsPerVoxel,
+            (static_cast<std::int64_t>(origin.Z)+extent+step)*MaterialSubvoxelsPerVoxel};
+        const auto materialCandidates=tileShape.OreVeinTileCandidates(
+            materialTileMinimum,materialTileMaximum);
+        out.diagnostics.materialTileOutsideEveryVein=materialCandidates.empty();
+        const double geometryVoxelSizeCm=static_cast<double>(world.CoreVoxelSizeMicrons)/10000.0;
+        std::uint64_t materialQueries=0,materialCandidateChecks=0;
+        const auto materialQueryStart=std::chrono::steady_clock::now();
         out.vertices.reserve(static_cast<std::size_t>(mesh.Vertices.Num()));
         for(int32 i=0;i<mesh.Vertices.Num();++i)
         {
@@ -2415,9 +2993,25 @@ namespace VoxelForgeCore
             const FVector normal=i<mesh.Normals.Num()?mesh.Normals[i]:FVector::ZeroVector;
             const FVector2f uv=i<mesh.UVs.Num()?mesh.UVs[i]:FVector2f(0.0f,0.0f);
             const FColor color=i<mesh.Colors.Num()?mesh.Colors[i]:FColor(0,0,0,0);
+            MaterialSampleV1 material;
+            if(!materialCandidates.empty())
+            {
+                ++materialQueries;
+                material=tileShape.EvaluateMaterialAt(
+                    static_cast<float>(p.X/geometryVoxelSizeCm),
+                    static_cast<float>(p.Y/geometryVoxelSizeCm),
+                    static_cast<float>(p.Z/geometryVoxelSizeCm),materialCandidates,
+                    &materialCandidateChecks);
+            }
             out.vertices.push_back({{p.X,p.Y,p.Z},{normal.X,normal.Y,normal.Z},{uv.X,uv.Y},
-                {color.R,color.G,color.B,color.A}});
+                {color.R,color.G,color.B,color.A},material.hostMaterialId,
+                material.resourceMaterialIds,material.resourceWeightsQ16});
         }
+        out.diagnostics.materialQueries=materialQueries;
+        out.diagnostics.materialCandidateChecks=materialCandidateChecks;
+        out.diagnostics.materialQueryMilliseconds=materialQueries
+            ?std::chrono::duration<double,std::milli>(
+                std::chrono::steady_clock::now()-materialQueryStart).count():0.0;
         out.indices.reserve(static_cast<std::size_t>(mesh.Triangles.Num()));
         for(const int32 index:mesh.Triangles)out.indices.push_back(static_cast<std::uint32_t>(index));
         if(options.captureDensitySamples)out.debugDensitySamples=std::move(densityValues);
@@ -2427,8 +3021,77 @@ namespace VoxelForgeCore
             const auto& values=options.captureDensitySamples?out.debugDensitySamples:densityValues;
             for(const float value:values)
             { densityHash^=std::bit_cast<std::uint32_t>(value);densityHash*=1099511628211ull; }
+
+            // A stream-hash run is the full-grid reference path. Record the exact sign
+            // uniformity ceiling from the same captured lattice that feeds Marching Cubes.
+            // Blocks are disjoint sample cubes; partial cubes at tile edges are included.
+            const std::size_t gridWidth=static_cast<std::size_t>(
+                std::clamp(MeshCells,2,CHUNK_SIZE)+3);
+            const std::size_t xySamples=gridWidth*gridWidth;
+            const std::size_t zSamples=xySamples>0&&values.size()%xySamples==0
+                ?values.size()/xySamples:0;
+            bool tileHasSign=false,tileUniform=true;
+            bool tileAir=false;
+            for(const float value:values)
+            {
+                if(!std::isfinite(value)||value==0.0f)
+                {tileUniform=false;continue;}
+                const bool air=value>0.0f;
+                if(!tileHasSign){tileHasSign=true;tileAir=air;}
+                else if(tileAir!=air)tileUniform=false;
+            }
+            const auto CountUniformBlocks=[&](std::size_t blockWidth)
+            {
+                std::uint64_t uniformBlocks=0,uniformSamples=0;
+                if(zSamples==0)return std::pair{uniformBlocks,uniformSamples};
+                for(std::size_t z0=0;z0<zSamples;z0+=blockWidth)
+                for(std::size_t y0=0;y0<gridWidth;y0+=blockWidth)
+                for(std::size_t x0=0;x0<gridWidth;x0+=blockWidth)
+                {
+                    const std::size_t z1=std::min(zSamples,z0+blockWidth);
+                    const std::size_t y1=std::min(gridWidth,y0+blockWidth);
+                    const std::size_t x1=std::min(gridWidth,x0+blockWidth);
+                    bool hasSign=false,uniform=true,air=false;
+                    for(std::size_t z=z0;z<z1&&uniform;++z)
+                    for(std::size_t y=y0;y<y1&&uniform;++y)
+                    for(std::size_t x=x0;x<x1;++x)
+                    {
+                        const float value=values[(z*gridWidth+y)*gridWidth+x];
+                        if(!std::isfinite(value)||value==0.0f)
+                        {uniform=false;break;}
+                        const bool sampleAir=value>0.0f;
+                        if(!hasSign){hasSign=true;air=sampleAir;}
+                        else if(air!=sampleAir){uniform=false;break;}
+                    }
+                    if(uniform&&hasSign)
+                    {
+                        ++uniformBlocks;
+                        uniformSamples+=static_cast<std::uint64_t>(z1-z0)
+                            *static_cast<std::uint64_t>(y1-y0)
+                            *static_cast<std::uint64_t>(x1-x0);
+                    }
+                }
+                return std::pair{uniformBlocks,uniformSamples};
+            };
+            const auto [uniformBlocks8,uniformSamples8]=CountUniformBlocks(8);
+            const auto [uniformBlocks4,uniformSamples4]=CountUniformBlocks(4);
+            const double centerZ=(static_cast<double>(origin.Z)
+                +static_cast<double>(extent)*0.5)*static_cast<double>(world.CoreVoxelSizeMicrons)
+                /10000.0;
+            const int32 stratum=world.Manager
+                ?world.Manager->GetStrateIndex(static_cast<float>(centerZ)):-1;
+            std::printf("[UniformGridCeiling] strate=%d lod=%d key=(%d,%d,%d) samples=%zu uniform=%d air=%d blocks8=%llu samples8=%llu blocks4=%llu samples4=%llu proof_safe=%d proof_veto=%u\n",
+                stratum,key.lod,key.coordinate.x,key.coordinate.y,key.coordinate.z,values.size(),
+                tileUniform&&tileHasSign?1:0,tileUniform&&tileHasSign&&tileAir?1:0,
+                static_cast<unsigned long long>(uniformBlocks8),
+                static_cast<unsigned long long>(uniformSamples8),
+                static_cast<unsigned long long>(uniformBlocks4),
+                static_cast<unsigned long long>(uniformSamples4),
+                out.diagnostics.tileProofSafe?1:0,
+                static_cast<unsigned>(out.diagnostics.tileProofVetoReason));
             out.densityHash=densityHash;out.meshHash=HashViewerMesh(mesh);
             out.payloadHash=HashPayload(mesh);out.topologyHash=HashTopology(mesh);
+            out.materialHash=HashMaterialSamples(out.vertices);
             if(key.lod>=4)
             {
                 out.meshHash=SaltFarHorizonHash(out.meshHash,options.farHorizonVersion);
@@ -2436,9 +3099,11 @@ namespace VoxelForgeCore
                 out.topologyHash=SaltFarHorizonHash(out.topologyHash,options.farHorizonVersion);
             }
             out.hasDensityHash=out.hasMeshHash=out.hasPayloadHash=out.hasTopologyHash=true;
+            out.hasMaterialHash=true;
         }
         out.diagnostics.meshAssemblyMilliseconds=std::chrono::duration<double,std::milli>(
             std::chrono::steady_clock::now()-MeshAssemblyStart).count();
+        CopyIslandCacheMetrics();
         return out;
     }
 

Standalone/Core/src/VoxelForgeFieldShared.h

@@ -331,6 +331,28 @@ 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.
+    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);
+    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 +394,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)
@@ -2178,6 +2686,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 +2737,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 +2852,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,7 +3005,8 @@ WorldAssemblyBoundsAuditResult AuditHeightfieldBounds(const Heightfield2D& block
             &result.capBoxes,false,"cap");
     }
     bool hasCliffProfile=false;
-    for(const auto& biome:recipe->biomes)hasCliffProfile|=biome.cliffStrengthQ16>0;
+    if(recipe->surfaceProfile.version==0)
+        for(const auto& biome:recipe->biomes)hasCliffProfile|=biome.cliffStrengthQ16>0;
     if(hasCliffProfile)
     {
         const std::int64_t d=16*WorldAssemblySubvoxelsPerVoxel;
@@ -2488,7 +3046,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(),

Standalone/DESIGN_WORLD_ASSEMBLER.md

@@ -83,6 +83,12 @@ Costs below are design estimates, not timings. Low means bounded analytic featur
 
 A passage planner must produce a traversable route or pair a non-walkable visual passage with another guaranteed route. A narrow crack or drop cannot be assumed walkable because its centerline is air.
 
+For a SurfaceWorld strate, the supported arrival-to-departure route follows the sampled terrain
+ground and stays within the mouth placement bounds. The inter-strate departure passage owns the
+descent from that ground mouth through rock and bedrock. Treating the bottom of a tall SurfaceWorld
+strate as the route's departure height would ask the walk planner to cross open terrain air; it is
+the wrong endpoint for the intra-strate route.
+
 | Passage type | Planner output | Bound and likely cost |
 |---|---|---|
 | SlopedTunnel | Straight-style path with switchbacks as needed, capsule clearance, supported floor, maximum grade and landing geometry. | Swept capsule bounds plus floor envelope; low–medium. |

Standalone/Research/WorldAssemblerM3/Linux29/REPORT.md

@@ -0,0 +1,110 @@
+# World Assembler L29 — bedrock/ceiling transitions
+
+**Core now honors the upper strate's `EVoxelStrateTransition` at the shared interface.** The owner
+world's upper two-chunk Gradient resolves to 16 m at the 8 m layout chunk size. SurfaceWorld's
+one-chunk setting remains in the resolved strate record. Core does not blend unrelated generator
+parameters. `WorldAssemblyEvaluatorVersion` is 15; recipe versions and resolved-layout schema V3
+are unchanged.
+
+## Appearance and safety
+
+| Mode | Result |
+|---|---|
+| Hard | The original flat, touching boundary. No displacement or overlap. |
+| Gradient | Both faces follow one smooth 2D hash surface. On the 16 m interface, the measured peak-to-peak undulation is 3.988 m. |
+| Interleaved | A deterministic 3D domain-warped hash field moves both faces inward, producing fingered overlap. Measured peak crossing was 6.487 m in FloatingIslands and 6.952 m in SurfaceWorld, within the declared 16 m. |
+
+Each boundary band keeps at least **two Core voxels** of solid thickness: 0.5 m at the default
+25 cm voxel size. The owner bands measured 0.5–1.0 m on the upper side and 6.25 m on the lower
+side. Interleaved is capped by both the declared width and the bands' combined thickness, so the
+solid intervals still touch or overlap.
+
+The strict interface audit covers a 512 m square: 4,221 columns per interface, with four passage
+columns excluded from the hole sweep. Hard, Gradient and Interleaved each report zero hole columns
+and zero air samples. Both negative controls reject as expected: crossing one micrometre wider than
+declared, and either band one micrometre thinner than the minimum. All six recipe/mode runs pass.
+
+Transition faces return to the nominal seam near passage mouths: the protected radius is the mouth
+radius plus 1 m, followed by a 2 m smooth fade. This kept the style-2 FI landing supported; its
+final capsule/support audit passes.
+
+## Passage and parity audits
+
+The final matrix has 4 styles × 2 recipes × 2 compilers (16 runs). Capsule and walkability,
+open-air, naturalness, no-long-bridge, route bindings, strict-validator controls, L13 route parity,
+and L9 proof audits pass. Open-air reports zero violations; validator controls reject 10/10;
+route-parity and proof audits report zero mismatches/violations. The L23/L24/L26 negative controls
+are detected.
+
+The L28 `FloorProfileBlend` diagnostic still exceeds its 2-voxel threshold in styles 1 and 3:
+2.544 and 3.645 voxels. L28 records the same values on both compilers, so this is inherited and
+unchanged.
+
+## Hashes
+
+The L25 W1/W8/W12 hash matrix is identical across Clang and GCC for both recipes: full-detail,
+whole-view, all LOD rows and exact-query hashes match. Hash order below is density / mesh / payload /
+topology.
+
+| Recipe | Full detail (960 tiles) | Whole view (2,370 tiles) | Exact-query density / detail / collision |
+|---|---|---|---|
+| SurfaceWorld | `ace56c8f205238ad / a9c603a1248de6b8 / ea55f1f4fcc6a894 / 5ea7bc78a1b678ae` | `0e8c5af01df96b14 / 70099e89b77811ed / dbce0fdcf6764126 / ddaf81a1228f9b4b` | `c949c4df2ce6f9d9 / 114c501e2d830d94 / e6011d3a248d4849` |
+| FloatingIslands | `ed550e0c8b182695 / 0e410a8e80a3e7f7 / 0751926f0c67d8a4 / f01208bc2f7841ec` | `a492eefa4f534975 / 141f00f3e411a0df / 93f50c569526c5cb / d83b53c8e53df81c` | `7b7c50ac24ccadcc / efcba20c0c70c415 / e604823a249029bf` |
+
+The 24 m moving crossing processed 314 entering tiles per recipe; Clang/GCC crossing hashes match.
+SurfaceWorld's away-from-interface probe at z = −400 m also matches L28: all 960 full-detail
+tiles and the exact-query density/detail/collision hashes are identical. The broader whole-view
+hash differs because its far-LOD coverage also includes the changed interface.
+
+## Cost
+
+Five clean, alternating W12 pairs against
+`Saved/Linux/bin/VoxelForgeCoreHeadless-linux28-clang-r28`, hashing off:
+
+| Recipe | L28 whole-view ready | L29 whole-view ready | Change |
+|---|---:|---:|---:|
+| SurfaceWorld | 1.581 s | 1.644 s | +3.97% |
+| FloatingIslands | 16.605 s | 16.814 s | +1.26% |
+
+FloatingIslands is within the ~3% target. SurfaceWorld is about one percentage point above it.
+
+## Captures
+
+All are 1280×720 JPEGs, each under 21 KB (well below 300 KB):
+
+- `captures/fi-floor-gradient-above.jpg` — FI floor from above, inside FI.
+- `captures/sw-ceiling-gradient-below.jpg` — SW ceiling from below, inside SW.
+- `captures/interface-hard-side-cutaway.jpg`
+- `captures/interface-gradient-side-cutaway.jpg`
+- `captures/interface-interleaved-side-cutaway.jpg`
+
+## Changes and run history
+
+Core transition evaluation/validation and the shared composition path changed, along with the
+headless transition audit, architecture/codemap, and the two Unreal files
+`Source/VoxelForge/Public/VoxelStrateTypes.h` and
+`Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp`. Unreal was unavailable here, so those edits
+were not compiled. No commit, push or stash was made.
+
+Failed or retried runs:
+
+- An early Clang build used a nonexistent dispatch helper; corrected to the current query method and rebuilt with Clang and GCC.
+- The first Interleaved overlap used the full sum of band thicknesses and opened gaps (1,085 columns / 20,313 air samples). Capping overlap to `min(declared width, combined thickness)` removed the gaps.
+- An initial hole sweep sampled a half-open band edge and reported 752 boundary-rounding holes. Sampling half a voxel inside each band removed those edge artifacts; final sweeps report zero holes.
+- The first FI style-2 passage audit had 11 unsupported probes after Gradient moved the mouth face. The local mouth taper fixed it; all 16 final passage runs pass.
+- A resolved-layout-only command initially omitted required pipeline flags and exited 2; rerun with the required flags passed. Early cutaway camera/clip settings produced blank framing; the final orientation and clip plane produced the captures above.
+- One cost folder contained a duplicated timing sequence and was discarded. The five-pair clean run above was sequential. A cache experiment did not improve cost and was removed. A cost-extraction `sed` typo was rerun with Python; benchmark logs were unaffected.
+
+No build or audit exceeded 30 minutes, and no step remained stuck for 15 minutes. All builds and runs
+used CPUs 0–11, at most 12 workers, normal priority, and the 6 GiB address-space cap.
+
+## Orchestrator review (Claude)
+
+- Merged: transitions honoured safely (0 holes over 4,221 columns per interface, negative controls reject, all
+  passage audits pass, deterministic).
+- **The look is not verified by the captures:** `interface-interleaved-side-cutaway.jpg` shows flat faces
+  (black = uncapped solid between faces), with no visible fingers; `sw-ceiling-gradient-below.jpg` is a flat
+  plane; `fi-floor-gradient-above.jpg` shows **concentric dashed rings** on the FI floor, which looks like an
+  artifact (possibly the passage-mouth protected-radius fade, or quantised undulation), not a smooth Gradient.
+- Cumulative SW cost vs L24 is now ~+8% (L28 +3.7% plus L29 +4%). L30 covers the ring artifact, readable
+  transition captures, and cost recovery.

Standalone/Research/WorldAssemblerM3/Linux30/MeasureRing.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""Rasterize upward mesh triangles into a top-down field height map."""
+import argparse
+import array
+import json
+import math
+import struct
+import sys
+
+Q16 = 1 << 16
+MASK64 = (1 << 64) - 1
+
+
+def trunc_div(numerator, denominator):
+    return numerator // denominator if numerator >= 0 else -((-numerator) // denominator)
+
+
+def transition_hash(seed, interface, x, y, z, salt):
+    value = 14695981039346656037
+    for word in (seed & 0xffffffff, interface & 0xffffffff,
+                 x & MASK64, y & MASK64, z & MASK64, salt):
+        for byte in range(8):
+            value ^= (word >> (byte * 8)) & 0xff
+            value = (value * 1099511628211) & MASK64
+    value ^= value >> 30
+    value = (value * 0xbf58476d1ce4e5b9) & MASK64
+    value ^= value >> 27
+    value = (value * 0x94d049bb133111eb) & MASK64
+    value ^= value >> 31
+    return ((value >> 32) >> 15) - Q16
+
+
+def transition_fade(value):
+    value = max(0, min(Q16, value))
+    square = value * value // Q16
+    return square * (3 * Q16 - 2 * value) // Q16
+
+
+def gradient_height_um(layout, x_um, y_um):
+    upper = next(item for item in layout["strates"] if item["order"] == 0)
+    lower = next(item for item in layout["strates"] if item["order"] == 1)
+    width = upper["transition_width_um"]
+    cell = max(1_000_000, layout["strate_layout_chunk_size_um"] * 4)
+    ix = x_um // cell
+    iy = y_um // cell
+    tx = transition_fade(((x_um - ix * cell) * Q16) // cell)
+    ty = transition_fade(((y_um - iy * cell) * Q16) // cell)
+
+    def at(dx, dy):
+        noise = transition_hash(0, upper["strate_index"], ix + dx, iy + dy, 0,
+                                0x47524144)
+        return noise
+
+    def lerp(a, b, t):
+        return a + trunc_div((b - a) * t, Q16)
+
+    low = lerp(lerp(at(0, 0), at(1, 0), tx),
+               lerp(at(0, 1), at(1, 1), tx), ty)
+    displacement = trunc_div(low * (width // 8), Q16)
+    seam = upper["bedrock"]["bottom_um"]
+    thickness = upper["bedrock"]["top_um"] - seam
+    return seam + displacement + thickness
+
+
+def read_scene(path):
+    triangles = []
+    with open(path, "rb") as stream:
+        if stream.read(8) != b"VFMSH001":
+            raise SystemExit(f"{path}: invalid scene header")
+        version, voxel_um, count = struct.unpack("<3I", stream.read(12))
+        stream.read(40)
+        if version != 1 or count > 100000:
+            raise SystemExit("unsupported scene")
+        for _ in range(count):
+            key = struct.unpack("<4i", stream.read(16))
+            surface_vertices, skirt_count, vertex_count, index_count, mask_count = struct.unpack(
+                "<5I", stream.read(20))
+            positions = array.array("f")
+            positions.frombytes(stream.read(vertex_count * 12))
+            normals = array.array("f")
+            normals.frombytes(stream.read(vertex_count * 12))
+            indices = array.array("I")
+            indices.frombytes(stream.read(index_count * 4))
+            masks = stream.read(mask_count)
+            if sys.byteorder != "little":
+                positions.byteswap()
+                normals.byteswap()
+                indices.byteswap()
+            for index in range(0, index_count, 3):
+                if masks and masks[index // 3]:
+                    continue
+                a, b, c = indices[index:index + 3]
+                if max(a, b, c) >= surface_vertices:
+                    continue
+                nz = (normals[a * 3 + 2] + normals[b * 3 + 2]
+                      + normals[c * 3 + 2]) / 3.0
+                if nz < 0.35:
+                    continue
+                vertices = tuple((positions[v * 3], positions[v * 3 + 1],
+                                  positions[v * 3 + 2]) for v in (a, b, c))
+                triangles.append(vertices)
+    return voxel_um, triangles
+
+
+def rasterize(triangles, bounds, width, height):
+    x0, x1, y0, y1 = bounds
+    values = [None] * (width * height)
+    sx, sy = width / (x1 - x0), height / (y1 - y0)
+    for tri in triangles:
+        (ax, ay, az), (bx, by, bz), (cx, cy, cz) = tri
+        den = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy)
+        if abs(den) < 1.0e-12:
+            continue
+        left = max(0, int(math.floor((min(ax, bx, cx) - x0) * sx)))
+        right = min(width - 1, int(math.ceil((max(ax, bx, cx) - x0) * sx)))
+        top = max(0, int(math.floor((y1 - max(ay, by, cy)) * sy)))
+        bottom = min(height - 1, int(math.ceil((y1 - min(ay, by, cy)) * sy)))
+        for py in range(top, bottom + 1):
+            y = y1 - (py + 0.5) / sy
+            row = py * width
+            for px in range(left, right + 1):
+                x = x0 + (px + 0.5) / sx
+                u = ((by - cy) * (x - cx) + (cx - bx) * (y - cy)) / den
+                v = ((cy - ay) * (x - cx) + (ax - cx) * (y - cy)) / den
+                w = 1.0 - u - v
+                if min(u, v, w) < -1.0e-6:
+                    continue
+                z = u * az + v * bz + w * cz
+                idx = row + px
+                if values[idx] is None or z > values[idx]:
+                    values[idx] = z
+    return values
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("scene")
+    parser.add_argument("output_ppm")
+    parser.add_argument("--bounds", nargs=4, type=float, required=True,
+                        metavar=("XMIN", "XMAX", "YMIN", "YMAX"))
+    parser.add_argument("--size", nargs=2, type=int, default=(640, 640))
+    parser.add_argument("--range", nargs=2, type=float, default=(-122.0, -118.0),
+                        metavar=("ZMIN", "ZMAX"))
+    parser.add_argument("--ring-center", nargs=2, type=float,
+                        metavar=("X", "Y"))
+    parser.add_argument("--layout")
+    args = parser.parse_args()
+    voxel_um, triangles = read_scene(args.scene)
+    width, height = args.size
+    sx, sy = width / (args.bounds[1] - args.bounds[0]), height / (args.bounds[3] - args.bounds[2])
+    values = rasterize(triangles, args.bounds, width, height)
+    finite = sorted(value for value in values if value is not None)
+    if not finite:
+        raise SystemExit("no upward-facing field samples in bounds")
+    low, high = args.range
+    if high <= low:
+        raise SystemExit("height range must increase")
+    stops = ((0.00, (31, 52, 92)), (0.24, (41, 119, 153)),
+             (0.50, (85, 177, 143)), (0.73, (226, 207, 105)),
+             (1.00, (181, 71, 49)))
+    with open(args.output_ppm, "wb") as output:
+        output.write(f"P6\n{width} {height}\n255\n".encode())
+        for value in values:
+            if value is None:
+                output.write(bytes((18, 22, 30)))
+                continue
+            t = max(0.0, min(1.0, (value - low) / (high - low)))
+            for index in range(len(stops) - 1):
+                if t <= stops[index + 1][0]:
+                    ta, ca = stops[index]
+                    tb, cb = stops[index + 1]
+                    blend = (t - ta) / (tb - ta)
+                    rgb = tuple(round(ca[c] + blend * (cb[c] - ca[c]))
+                                for c in range(3))
+                    break
+            else:
+                rgb = stops[-1][1]
+            output.write(bytes(rgb))
+    def quantile(p):
+        return finite[round((len(finite) - 1) * p)]
+    print(f"[RingFieldRaster] voxel_um={voxel_um} triangles={len(triangles)} "
+          f"pixels={len(finite)}/{len(values)} height_min_m={finite[0]:.6f} "
+          f"height_p05_m={quantile(.05):.6f} height_median_m={quantile(.5):.6f} "
+          f"height_p95_m={quantile(.95):.6f} height_max_m={finite[-1]:.6f} "
+          f"height_range_m={finite[-1]-finite[0]:.6f} "
+          f"map={args.output_ppm}")
+    if args.ring_center:
+        cx, cy = args.ring_center
+        def at_world(x, y):
+            fx = (x - args.bounds[0]) * sx - 0.5
+            fy = (args.bounds[3] - y) * sy - 0.5
+            ix, iy = math.floor(fx), math.floor(fy)
+            tx, ty = fx - ix, fy - iy
+            samples = []
+            for px, py in ((ix, iy), (ix + 1, iy), (ix, iy + 1), (ix + 1, iy + 1)):
+                if not (0 <= px < width and 0 <= py < height):
+                    return None
+                value = values[py * width + px]
+                if value is None:
+                    return None
+                samples.append(value)
+            return ((samples[0] * (1 - tx) + samples[1] * tx) * (1 - ty)
+                    + (samples[2] * (1 - tx) + samples[3] * tx) * ty)
+        print(f"[RingRadialProbe] center_m=({cx:.3f},{cy:.3f}) "
+              "radius_m mean_m angular_sd_m min_m max_m samples")
+        for radius in range(1, 17):
+            row = [at_world(cx + radius * math.cos(a * math.tau / 32),
+                            cy + radius * math.sin(a * math.tau / 32))
+                   for a in range(32)]
+            row = [value for value in row if value is not None]
+            if row:
+                mean = sum(row) / len(row)
+                sd = math.sqrt(sum((value - mean) ** 2 for value in row) / len(row))
+                print(f"  {radius:>2} {mean:.6f} {sd:.6f} {min(row):.6f} "
+                      f"{max(row):.6f} {len(row)}")
+    if args.layout:
+        layout = json.load(open(args.layout, encoding="utf-8"))
+        if next(item for item in layout["strates"] if item["order"] == 0)["transition_mode"] != "Gradient":
+            raise SystemExit("--layout must describe a Gradient owner interface")
+        errors = []
+        for index, actual in enumerate(values):
+            if actual is None:
+                continue
+            px, py = index % width, index // width
+            x = args.bounds[0] + (px + 0.5) / sx
+            y = args.bounds[3] - (py + 0.5) / sy
+            expected = gradient_height_um(layout, round(x * 1_000_000),
+                                          round(y * 1_000_000)) / 1_000_000.0
+            errors.append(actual - expected)
+        absolute = sorted(abs(error) for error in errors)
+        rms = math.sqrt(sum(error * error for error in errors) / len(errors))
+        print(f"[RingGradientMatch] samples={len(errors)} rms_m={rms:.6f} "
+              f"p95_abs_m={absolute[round((len(absolute)-1)*.95)]:.6f} "
+              f"max_abs_m={absolute[-1]:.6f} "
+              "expected=owner-resolved-2d-hash-value-noise")
+
+
+if __name__ == "__main__":
+    main()

Standalone/Research/WorldAssemblerM3/Linux30/ProbeTransitionNoise.cpp

@@ -0,0 +1,28 @@
+#include "CoreNamespacePreamble.h"
+#include "ResolvedLayoutInternal.h"
+
+int main()
+{
+    VoxelForgeCore::ResolvedLayoutStratumV2 upper, lower;
+    upper.strateIndex=0;upper.order=0;upper.transitionMode="Gradient";
+    upper.transitionWidthMicrometres=16000000;
+    upper.bedrock.bottomMicrometres=-120000000;
+    upper.bedrock.topMicrometres=-119500000;
+    upper.bedrock.presentInCurrentField=true;
+    lower.strateIndex=1;lower.order=1;
+    lower.ceiling.bottomMicrometres=-126250000;
+    lower.ceiling.topMicrometres=-120000000;
+    lower.ceiling.presentInCurrentField=true;
+    for(const auto& point:std::array<std::array<std::int64_t,2>,5>{
+        std::array<std::int64_t,2>{64000000,-32000000},
+        {65000000,-32000000},{64000000,-31000000},{70000000,-32000000},
+        {80000000,-35000000}})
+    {
+        const auto bands=VoxelForgeCore::EvaluateResolvedLayoutTransitionBandsV1(
+            upper,lower,0,8000000,point[0],point[1]);
+        std::printf("x_m=%.3f y_m=%.3f top_m=%.6f bottom_m=%.6f\n",
+            point[0]/1000000.0,point[1]/1000000.0,
+            bands.upperBedrockTopMicrometres/1000000.0,
+            bands.upperBedrockBottomMicrometres/1000000.0);
+    }
+}

Standalone/Research/WorldAssemblerM3/Linux30/REPORT.md

@@ -0,0 +1,121 @@
+# VoxelForge L30
+
+Work is on `assembler/world`. The speed and look patches are saved separately under
+`Saved/Linux/l30/`; evaluator version is now 16 for the field change. No Unreal files were edited.
+Nothing was committed, pushed, or stashed.
+
+## Ring measurement and fix
+
+I rasterized upward-facing triangles from the L29 mesh (skirt triangles excluded) over the same
+409,600 pixels as the after field. At `(64, -32)`, the L29 field stayed almost flat at `-120.063 m` from
+radii 1–11 m, then broke at 12 m. The expected Gradient at radius 1 m is `-121.360 m`. This is a
+field defect, not shading: the probe is about 67 m from the passage mouth, and the raster has no
+skirts or readable-shading tint. The passage column flare is at that distant mouth as well.
+
+The upper FloatingIslands generator could leave native solid density in the air-side gap above a
+negatively displaced Gradient face. The constant band densities also snapped the face to Core
+voxel levels. The owner Gradient path now clears that gap with positive signed distance and writes
+negative signed distance below the face, allowing the mesh to interpolate its height. The after
+profile follows the resolved hash surface at every sampled radius. Match error fell from RMS
+`0.361765 m`, p95 `1.016178 m`, max `1.304169 m` to RMS `0.110357 m`, p95 `0.218531 m`, max
+`0.248818 m` (one Core voxel is `0.25 m`).
+
+Before/after captures use the same color ramp and bounds:
+
+- [L29 height map](captures/fi-floor-gradient-before-heightmap.jpg), [fixed height map](captures/fi-floor-gradient-after-heightmap.jpg)
+- [L29 readable render](captures/fi-floor-gradient-before.jpg), [fixed readable render](captures/fi-floor-gradient-after.jpg)
+
+## Transition captures
+
+The maps cover the full 640×640 surface and are all below 300 KB. Gradient is the owner world
+without a mode override. Hard and Interleaved use fixture overrides; the resolved layouts record
+those modes.
+
+- [Hard](captures/transition-hard-heightmap.jpg) — flat interface.
+- [Gradient](captures/transition-gradient-heightmap.jpg) — owner field.
+- [Interleaved](captures/transition-interleaved-heightmap.jpg) — fixture override.
+
+## Cost
+
+Five alternating W12 pairs, hashing off and `cache_hits=0`. First table is the separable speed-only
+build, whose hashes remain L29-identical. Second table is the final version-16 build.
+
+| Recipe | L24 | L29 | L30 speed-only | vs L24 | L30 final | vs L24 |
+|---|---:|---:|---:|---:|---:|---:|
+| SurfaceWorld | 1.566 s | 1.653 s | 1.606 s | +2.55% | 1.530 s | +2.68% |
+| FloatingIslands | 16.625 s | 16.779 s | 16.470 s | −0.93% | 16.543 s | +0.21% |
+
+Counter-enabled runs on the same plain W12 workload locate the saved work:
+
+| Recipe | Boundary calls | Window checks → evaluations | Fade calls | Boundary tile / point culls | Column Z tests → guards → radial rejects | SDF calls |
+|---|---:|---:|---:|---:|---:|---:|
+| SurfaceWorld | 19.95 M | 3.54 M → 739 k | 8.2 k | 8.99 M / 8.96 M | 1.87 M → 1.85 M → 1.58 M | 18.4 k |
+| FloatingIslands | 66.33 M | 8.00 M → 2.68 M | 8.6 k | 38.25 M / 23.63 M | 8.17 M → 8.14 M → 6.82 M | 83.4 k |
+
+The fade-tile cull skips 731 k SurfaceWorld and 2.67 M FloatingIslands fade evaluations; the
+column guard exits on nonpositive field values 272 k and 1.27 M times. Timing comes from
+uninstrumented binaries; the counts above use counter logging.
+
+## Hashes and audits
+
+The speed-only v15 build matches all 12 L29 hash records for each recipe/compiler/worker matrix
+(W1/W8/W12), and all 12 records for each 24 m crossing matrix. That is 24 exact comparisons;
+all pass. The final v16 build is deterministic across both compilers and all worker counts, in the
+normal and 24 m crossing runs. Representative W12 hashes (`density / mesh / payload / topology`):
+
+| Recipe | Full detail | Whole view |
+|---|---|---|
+| SurfaceWorld | `ace56c8f205238ad / a9c603a1248de6b8 / ea55f1f4fcc6a894 / 5ea7bc78a1b678ae` | `0e8c5af01df96b14 / 70099e89b77811ed / dbce0fdcf6764126 / ddaf81a1228f9b4b` |
+| FloatingIslands | `ed550e0c8b182695 / 0e410a8e80a3e7f7 / 0751926f0c67d8a4 / f01208bc2f7841ec` | `4ee19ea6b6406ca6 / be648f94c899b47e / 310b525f31604f98 / 10366eb6dfce2384` |
+
+Exact-query hashes also match across v16 runs: SurfaceWorld
+`c949c4df2ce6f9d9 / 114c501e2d830d94 / e6011d3a248d4849`; FloatingIslands
+`7b7c50ac24ccadcc / efcba20c0c70c415 / e604823a249029bf`.
+
+- Interface audit: all 12 compiler/recipe/mode combinations pass; 4,221 columns each, zero holes
+  and air samples, both negative controls reject.
+- The 16 L29 fixture-matrix replays pass passage safety/open-air, validator controls (10/10), L13
+  route parity, L9 proof checks (zero violations), and walkability. `FloorProfileBlend` still
+  reports 2.544 vox in style 1 and 3.645 vox in style 3, unchanged from L29.
+- Audit scope caveat: the L29 files named `floating-islands` were run with
+  `--recipe=surface-world`. With the actual `--recipe=floating-islands` option, the rock-column
+  audit fails on all four styles on both L29 and L30: connected ends are 1/2, 3/4, 1/2, 3/4.
+  The open-air audit passes. This is inherited, but means the L29 report's “two recipes” matrix did
+  not exercise the FloatingIslands CLI recipe.
+
+## Failed and retried runs
+
+- Broad air-gap experiments first lost a SurfaceWorld style-2 support sample. Route/radius masks
+  and support restoration then caused open-air violations. Widening the fade restored that case,
+  but measurement placed the ring far outside the fade, so those variants were discarded. The
+  final owner-only gate and signed-distance face pass the targeted support audit.
+- Early speed variants missed the target: tile-only `+4.04%`, Z-point `+3.11%`, scalar path
+  `+4.33%` vs L24. The final band and fade-tile culls meet the target.
+- The first counter-instrumentation compile failed; the counter hook was corrected and rebuilt
+  with Clang and GCC. One duplicated timing sequence was discarded; only the clean five-pair runs
+  are reported.
+- The first 24 m crossing comparison supplied an extra camera override and mismatched. Rerunning
+  with the L29 camera setup and only `--camera-step=24,0,0` matches all hashes.
+- An early Hard export hit `std::bad_alloc`; retry passed. The first EGL render used an unwritable
+  cache; retry with `XDG_CACHE_HOME` under `Saved/Linux/l30` passed. The first map conversion also
+  stopped before the Hard/Interleaved maps; both were rerun individually and have full raster
+  coverage.
+- The first passage-matrix summary script assumed a different marker order and reported failure;
+  checking each audit marker by name confirms the core matrix passes. A `check=True` true-recipe
+  control runner stopped on the expected L29 exit code 10; rerunning while recording return codes
+  confirmed the same four inherited rock-column failures on L29 and L30.
+
+No build or run exceeded 30 minutes or remained stuck for 15 minutes. Builds and runs used CPUs
+0–11, at most 12 workers, normal priority, and the 6 GiB address-space cap. No Unreal build was
+attempted.
+
+## Orchestrator review (Claude)
+
+- Merged: the ring was a real field defect (air-side gap left solid, face snapped to voxel levels), now fixed
+  (RMS 0.36 → 0.11 m). Cost back to SW +2.7% / FI +0.2% vs L24. The speed part is bit-identical; final v16 is
+  deterministic.
+- Still visible: `fi-floor-gradient-after.jpg` shows faint concentric lines. Unknown whether that is residual
+  geometry (≤0.25 m steps) or the readable shader's height-tint banding; L31 measures it.
+- **Important finding (thanks to Luna's caveat):** L29's "both recipes" passage matrix ran SurfaceWorld twice. On
+  the real `--recipe=floating-islands`, the rock-column connected-ends audit fails in all 4 styles (1/2 or 3/4).
+  Since L27, FI column results were never really tested. L31 priority.

Standalone/Research/WorldAssemblerM3/Linux30/RunCost.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Interleave five W12 hash-off whole-view cost triplets for L24/L29/L30."""
+import re
+import subprocess
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l30"
+OUT.mkdir(parents=True, exist_ok=True)
+BINARIES = {
+    "l24": ROOT / "Saved/Linux/l24-source/bin/linux/VoxelForgeCoreHeadless-linux24-clang19",
+    "l29": ROOT / "Saved/Linux/bin/VoxelForgeCoreHeadless-linux29-clang",
+    "l30": ROOT / "Saved/Linux/l30/bin/VoxelForgeCoreHeadless-linux30-speed-fade",
+}
+ORDERS = (
+    ("l24", "l29", "l30"),
+    ("l29", "l30", "l24"),
+    ("l30", "l24", "l29"),
+    ("l24", "l30", "l29"),
+    ("l29", "l24", "l30"),
+)
+WHOLE_READY = re.compile(r"\bwhole_view_ready=([0-9.]+)s")
+rows = []
+for recipe in ("surface-world", "floating-islands"):
+    for pair, order in enumerate(ORDERS, 1):
+        for build in order:
+            name = f"cost-speedfade-{recipe}-pair{pair}-{build}"
+            logfile = OUT / f"{name}.log"
+            command = [
+                "prlimit", "--as=6442450944", "--", str(BINARIES[build]),
+                str(ROOT / "Standalone/data/owner_world.json"),
+                "--workers=12", "--world-assembler-prototype", "--stream-benchmark",
+                "--stream-pipeline", "--force-generate", "--clip-radius=3",
+                "--max-clip-level=8", "--max-level=-1", f"--recipe={recipe}",
+            ]
+            started = time.monotonic()
+            with logfile.open("w", encoding="utf-8") as stream:
+                subprocess.run(command, stdout=stream, stderr=subprocess.STDOUT,
+                               check=True, timeout=1800)
+            elapsed = time.monotonic() - started
+            text = logfile.read_text(encoding="utf-8", errors="replace")
+            matches = WHOLE_READY.findall(text)
+            if len(matches) != 1 or "hash=off" not in text or "cache_hits=0" not in text:
+                raise SystemExit(f"invalid cost run: {name}; see {logfile}")
+            ready = float(matches[0])
+            rows.append((recipe, pair, build, ready, elapsed))
+            print(f"{recipe} pair={pair} build={build} whole_view_ready={ready:.3f}s "
+                  f"process_elapsed={elapsed:.3f}s", flush=True)
+
+summary = OUT / "cost-runs-speedfade.csv"
+summary.write_text("recipe,pair,build,whole_view_ready_seconds,process_elapsed_seconds\n" +
+    "".join(f"{recipe},{pair},{build},{ready:.6f},{elapsed:.6f}\n"
+            for recipe, pair, build, ready, elapsed in rows), encoding="utf-8")
+print(f"wrote {summary}", flush=True)

Standalone/Research/WorldAssemblerM3/Linux30/RunCrossing30.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Verify speed-only L30 hashes on the 24 m crossing against L29."""
+import re
+import subprocess
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l30"
+OUT.mkdir(parents=True, exist_ok=True)
+BINARIES = {
+    "clang": ROOT / "Saved/Linux/l30/bin/VoxelForgeCoreHeadless-linux30-speed-fade",
+    "gcc": ROOT / "Saved/Linux/l30/bin/VoxelForgeCoreHeadless-linux30-speed-fade-gcc",
+}
+PATTERN = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
+passed = True
+for compiler, binary in BINARIES.items():
+    for recipe in ("surface-world", "floating-islands"):
+        reference_path = ROOT / f"Saved/Linux/linux29-final-crossing24-{compiler}-{recipe}.log"
+        reference = PATTERN.findall(reference_path.read_text(encoding="utf-8"))
+        for workers in (1, 8, 12):
+            name = f"crossing-speedonly-default-{compiler}-{recipe}-w{workers}"
+            logfile = OUT / f"{name}.log"
+            command = [
+                "prlimit", "--as=6442450944", "--", str(binary),
+                str(ROOT / "Standalone/data/owner_world.json"),
+                "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+                "--stream-hash", "--force-generate", "--clip-radius=3",
+                "--max-clip-level=8", f"--workers={workers}",
+                "--camera-step=24,0,0",
+                "--region-crossing", f"--recipe={recipe}",
+            ]
+            started = time.monotonic()
+            with logfile.open("w", encoding="utf-8") as stream:
+                subprocess.run(command, stdout=stream, stderr=subprocess.STDOUT,
+                               check=True, timeout=1800)
+            elapsed = time.monotonic() - started
+            rows = PATTERN.findall(logfile.read_text(encoding="utf-8", errors="replace"))
+            ok = len(reference) == 12 and rows == reference
+            passed &= ok
+            print(f"{compiler} {recipe} W{workers} elapsed={elapsed:.3f}s "
+                  f"hash_rows={len(rows)} {'MATCH' if ok else 'MISMATCH'}", flush=True)
+print(f"[CrossingSpeedOnly] runs=12 status={'PASS' if passed else 'FAIL'}", flush=True)
+raise SystemExit(0 if passed else 1)

Standalone/Research/WorldAssemblerM3/Linux31/AggregateCostL31.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Combine the initial and repeat L31 interleaved cost batches."""
+import csv
+import statistics
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l31"
+sources = (
+    ("first", 0, OUT / "cost-first/cost-runs.csv"),
+    ("repeat", 5, OUT / "cost-runs.csv"),
+)
+rows = []
+for batch, offset, path in sources:
+    with path.open(newline="", encoding="utf-8") as stream:
+        for row in csv.DictReader(stream):
+            row["pair"] = str(int(row["pair"]) + offset)
+            row["source_batch"] = batch
+            rows.append(row)
+
+with (OUT / "cost-combined.csv").open("w", newline="", encoding="utf-8") as stream:
+    writer = csv.DictWriter(stream, fieldnames=(
+        "recipe", "pair", "build", "whole_view_ready_seconds", "process_elapsed_seconds",
+        "exit_code", "status", "source_batch"))
+    writer.writeheader()
+    writer.writerows(rows)
+
+print("recipe pairs median_l30_s median_l31_s median_change_pct paired_median_pct range_pct")
+failed = False
+for recipe in ("surface-world", "floating-islands"):
+    by_build = {
+        build: [float(row["whole_view_ready_seconds"]) for row in rows
+                if row["recipe"] == recipe and row["build"] == build]
+        for build in ("l30", "l31")
+    }
+    paired = []
+    for pair in range(1, 11):
+        times = {
+            row["build"]: float(row["whole_view_ready_seconds"])
+            for row in rows if row["recipe"] == recipe and int(row["pair"]) == pair
+        }
+        paired.append((times["l31"] / times["l30"] - 1.0) * 100.0)
+    median_l30 = statistics.median(by_build["l30"])
+    median_l31 = statistics.median(by_build["l31"])
+    median_change = (median_l31 / median_l30 - 1.0) * 100.0
+    print(f"{recipe} 10 {median_l30:.3f} {median_l31:.3f} {median_change:+.2f} "
+          f"{statistics.median(paired):+.2f} {min(paired):+.2f}..{max(paired):+.2f}")
+    failed |= len(by_build["l30"]) != 10 or len(by_build["l31"]) != 10
+print(f"[L31CostCombined] pairs_per_recipe=10 runs={len(rows)} "
+      f"status={'FAIL' if failed else 'PASS'} summary={OUT / 'cost-combined.csv'}")
+raise SystemExit(1 if failed or len(rows) != 40 else 0)