wip(assembler): round L21 -- resolved strate layout snapshot + validator (no world change)

Core ResolvedLayoutSnapshotV1 (canonical JSON, stable identity): per strate stable ID, generator, recipe, interior bounds in metres, ceiling/bedrock bands as Core really applies them, transition mode/width, dispatch provenance. Validator: compat mode reports today's deviations; strict mode enforces ceiling -> content -> bedrock -> next ceiling (owner rule), two separate bands, nominal contiguity, interpenetration only within the declared EVoxelStrateTransition width; 7 negative controls rejected. Findings: SW built at -120..-632 m although the params say -60 m; a 60 m unowned gap filled by analytic FI fallback; no active bedrock bands; transitions ignored by Core. All L19 hashes unchanged (28 + 14 crossing runs). The Unreal adapter exports resolved_layout (uncompiled here). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01CSFYgsdW8ejZSyiMf4qRSX
2026-10-20 10:22:00 +02:00
1 parent 5d5447dc32
commit 8753f6dbe4
@@ -1869,6 +1869,36 @@ query, stratum position, scale, or asynchronous route changes. The strict LOD0
 audit and the matched before/after captures are in
 [`Standalone/Research/WorldAssemblerM3/Linux19/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux19/REPORT.md).
 ### 8.39 Resolved layout snapshots and nominal strate bands — World Assembler L21
 `ResolvedLayoutSnapshotV1` is a separate Core-owned record built from the resolved manager slots and
 the native SurfaceWorld/FloatingIslands plans. It has a canonical JSON representation, schema version,
 and stable FNV-1a identity. Its physical intervals use half-open micrometre coordinates; recipe anchors
 retain their serialized fixed-point units. The Unreal adapter exports it beside `world_assembly`, so the
 layout digest never salts a recipe, manifest, density, or mesh hash. The standalone exporter follows
 the same builder after plan resolution. It runs once per plan request and is not read from density or
 tile-worker loops.
 Each record separates the nominal ceiling, content, and bedrock bands. A strict layout requires that
 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
 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,
 with protection represented explicitly.
 Compatibility facts from L21: native SurfaceWorld plan/query bounds use 32 Core voxels (8 m) per
 dispatch chunk, while FloatingIslands converts the 32-voxel owner chunk through its 12.5/25 cm scale
 (16 Core voxels, 4 m). In the prototype where the top slot is FloatingIslands, this leaves a nominal
 60 m interval between the FI bottom (−60 m) and SurfaceWorld top (−120 m); the Core selectors fall
 through to the compiled analytic FloatingIslands fallback there. Core does not apply the manager's
 parameter blend at either recipe boundary. The FI v3 upper seal remains a ceiling inside its current
 content range, and its missing lower bedrock is recorded without changing evaluation. See
 [`Standalone/Research/WorldAssemblerM3/Linux21/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux21/REPORT.md).
 ## 9. Multiplayer model (listen-server first, dedicated-friendly)
 > **Status: transport is DESIGN ONLY — nothing is networked in-tree yet** (no `Replicated`/`HasAuthority`/RPCs; a
@@ -163,13 +163,14 @@ 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` | `ResolvedLayoutSnapshotV1`: versioned micrometre intervals, owned ceiling/content/bedrock bands, transition and dispatch provenance, recipe anchors, canonical JSON/FNV identity, compatibility/strict validators, and negative-control audit. Built from resolved plans; no evaluator call sites consume it. §8.39. |
 | `../../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.
 | 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 places canonical `world_assembly` JSON and its hash in the Core snapshot. Invalid plans fail Core initialization. |
+| `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/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. |
@@ -944,6 +944,199 @@ bool AttachValidatedWorldAssembly(const UVoxelSettings* Settings,
        MatchedStrateIndices.Add(Plan.strateIndex);
    }
    // Keep the inspectable physical-layout export separate from the manifest identity: it is
    // assembled from the same resolved slots/plans, but adding it must not salt evaluation hashes.
    VoxelForgeCore::ResolvedLayoutSnapshotV1 Layout;
    Layout.worldIdentity = std::string("owner-world/seed/")
        + std::to_string(StrateManager->GetWorldSeed());
    Layout.ownerVoxelSizeMicrometres = static_cast<std::uint32_t>(std::llround(OwnerVoxelSizeCm * 10000.0));
    Layout.coreVoxelSizeMicrometres = ExpectedCoreVoxelMicrons;
    const auto generatorName = [](ECaveGeneratorType Type) -> const char*
    {
        switch (Type)
        {
        case ECaveGeneratorType::TunnelNetwork: return "TunnelNetwork";
        case ECaveGeneratorType::FlatPlain: return "FlatPlain";
        case ECaveGeneratorType::CrystalChamber: return "CrystalChamber";
        case ECaveGeneratorType::Maze: return "Maze";
        case ECaveGeneratorType::SurfaceWorld: return "SurfaceWorld";
        case ECaveGeneratorType::VerticalShafts: return "VerticalShafts";
        case ECaveGeneratorType::FloatingIslands: return "FloatingIslands";
        case ECaveGeneratorType::Underwater: return "Underwater";
        }
        return "Unknown";
    };
    const auto transitionName = [](EVoxelStrateTransition Type) -> const char*
    {
        switch (Type)
        {
        case EVoxelStrateTransition::Gradient: return "Gradient";
        case EVoxelStrateTransition::Hard: return "Hard";
        case EVoxelStrateTransition::Interleaved: return "Interleaved";
        }
        return "Unknown";
    };
    const std::int64_t OwnerVoxelMicrons = Layout.ownerVoxelSizeMicrometres;
    const auto FixedToMicrons = [ExpectedCoreVoxelMicrons](std::int64_t Fixed)
    {
        return static_cast<std::int64_t>(std::llround(static_cast<double>(Fixed)
            * ExpectedCoreVoxelMicrons / VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel));
    };
    for (const FStrateSlot& Slot : StrateManager->GetLayout())
    {
        if (Slot.Definition == nullptr) continue;
        const ECaveGeneratorType Type = StrateManager->GetGeneratorTypeForChunk(
            FIntVector(0, 0, Slot.TopChunkZ));
        VoxelForgeCore::ResolvedLayoutStratumV1 Item;
        Item.strateIndex = Slot.StrateIndex;
        Item.generatorKind = generatorName(Type);
        Item.stableId = Layout.worldIdentity + "/strate/" + std::to_string(Slot.StrateIndex)
            + "/generator/" + generatorName(Type);
        Item.recipeId = Type == ECaveGeneratorType::SurfaceWorld ? "SurfaceWorld.Heightfield2D"
            : Type == ECaveGeneratorType::FloatingIslands ? "FloatingIslands.ClusterField"
            : std::string("legacy.") + generatorName(Type);
        Item.recipeVersion = Type == ECaveGeneratorType::SurfaceWorld ? Manifest->recipe.schemaVersion : 0;
        Item.voxelSizeMicrometres = ExpectedCoreVoxelMicrons;
        Item.interiorBottomMicrometres = static_cast<std::int64_t>(Slot.BottomChunkZ)
            * CHUNK_SIZE * ExpectedCoreVoxelMicrons;
        Item.interiorTopMicrometres = static_cast<std::int64_t>(Slot.TopChunkZ + 1)
            * CHUNK_SIZE * ExpectedCoreVoxelMicrons;
        Item.managerChunkWidthMicrometres = CHUNK_SIZE * OwnerVoxelMicrons;
        Item.dispatchChunkWidthMicrometres = Type == ECaveGeneratorType::FloatingIslands
            ? CHUNK_SIZE * OwnerVoxelMicrons : CHUNK_SIZE * ExpectedCoreVoxelMicrons;
        Item.transitionMode = transitionName(Slot.Definition->TransitionType);
        Item.transitionBlendChunks = Slot.Definition->TransitionBlendChunks;
        Item.transitionWidthMicrometres = static_cast<std::int64_t>(Item.transitionBlendChunks)
            * Item.managerChunkWidthMicrometres;
        Item.transitionWarpAmplitudeMicrometres = Item.transitionMode == "Interleaved"
            ? 2 * Item.managerChunkWidthMicrometres : 0;
        Item.transitionInterpenetrationMicrometres = 0;
        Item.transitionHonouredInCore = false;
        Item.transitionDispatchPath = "upper strate owns lower interface; manager GetGenerationParams can blend legacy vectors, but Core's compiled field selects per-strate/native recipe fields without transition blending";
        Item.managerLookup = "UVoxelStrateManager::GetGeneratorTypeForChunk; transition is controlled by upper strate";
        if (Type == ECaveGeneratorType::SurfaceWorld)
        {
            Item.boundDispatchPath = "BuildSurfaceStratumPlan uses slot chunkZ * 32 Core voxels";
            Item.queryDispatchPath = "NativeSurfaceDensityAt uses floor(CoreZ / 32), then GetGeneratorTypeForChunk/GetStrateIndex";
            const auto Plan = std::find_if(Manifest->plan.strates.begin(), Manifest->plan.strates.end(),
                [&Slot](const auto& Entry) { return Entry.strateIndex == Slot.StrateIndex; });
            if (Plan != Manifest->plan.strates.end())
            {
                for (const auto& Profile : Manifest->recipe.biomes)
                    if (Profile.hasCapProfile)
                    {
                        VoxelForgeCore::ResolvedLayoutAnchorV1 Anchor;
                        Anchor.kind = "cap_profile";
                        Anchor.stableId = "biome/" + std::to_string(Profile.stableId);
                        Anchor.units = "1/256 Core voxel";
                        Anchor.values = { Profile.capHeightSubvoxels, Profile.capUndulationSubvoxels,
                            Profile.capWavelengthSubvoxels, Profile.capDetailAmplitudeSubvoxels,
                            Profile.capRidgeAmplitudeSubvoxels };
                        Item.anchors.push_back(std::move(Anchor));
                    }
                for (std::size_t RouteIndex = 0; RouteIndex < Plan->route.size(); ++RouteIndex)
                {
                    const auto& Point = Plan->route[RouteIndex];
                    VoxelForgeCore::ResolvedLayoutAnchorV1 Anchor;
                    Anchor.kind = "route_point"; Anchor.stableId = "route/" + std::to_string(RouteIndex);
                    Anchor.units = "1/256 Core voxel";
                    Anchor.values = { Point.positionSubvoxels[0], Point.positionSubvoxels[1],
                        Point.positionSubvoxels[2], Point.radiusSubvoxels };
                    Item.anchors.push_back(std::move(Anchor));
                }
            }
            Item.ceiling = { "ceiling", Item.interiorTopMicrometres, Item.interiorTopMicrometres,
                false, true, false, "no separate volumetric boundary band; cap profile remains content",
                "none", "Heightfield2D cap + AppendStratumBoundaryCeilings fallback mesh" };
            Item.bedrock = { "bedrock", Item.interiorBottomMicrometres,
                Item.interiorBottomMicrometres, false, true, false,
                "no lower bedrock band", "none", "none" };
        }
        else if (Type == ECaveGeneratorType::FloatingIslands)
        {
            Item.boundDispatchPath = "BuildFloatingIslandStratumPlan uses slot chunkZ * 32 * owner/Core voxel ratio";
            Item.queryDispatchPath = "NativeFloatingIslandDensityAt uses floor(CoreZ / (32 * owner/Core ratio)), then manager lookup";
            const auto Plan = std::find_if(Manifest->floatingIslands.begin(), Manifest->floatingIslands.end(),
                [&Slot](const auto& Entry) { return Entry.strateIndex == Slot.StrateIndex; });
            std::int64_t SealMicrometres = 0;
            if (Plan != Manifest->floatingIslands.end())
            {
                Item.interiorBottomMicrometres = FixedToMicrons(Plan->manifest.recipe.layoutMinimumZSubvoxels);
                Item.interiorTopMicrometres = FixedToMicrons(Plan->manifest.recipe.layoutMaximumZSubvoxels);
                SealMicrometres = FixedToMicrons(Plan->manifest.recipe.boundarySealSubvoxels);
                Item.recipeVersion = Plan->manifest.recipe.geometryVersion;
                for (std::size_t IslandIndex = 0; IslandIndex < Plan->manifest.plan.islands.size(); ++IslandIndex)
                {
                    const auto& Island = Plan->manifest.plan.islands[IslandIndex];
                    VoxelForgeCore::ResolvedLayoutAnchorV1 Anchor;
                    Anchor.kind = "island_anchor"; Anchor.stableId = "island/" + std::to_string(IslandIndex);
                    Anchor.units = "1/256 Core voxel";
                    Anchor.values = { Island.centerSubvoxels[0], Island.centerSubvoxels[1],
                        Island.centerSubvoxels[2], Island.radiusSubvoxels, Island.topHalfSubvoxels };
                    Item.anchors.push_back(std::move(Anchor));
                }
            }
            Item.ceiling = { "ceiling", Item.interiorTopMicrometres - SealMicrometres,
                Item.interiorTopMicrometres, SealMicrometres > 0, true, false,
                "v3 shared upper boundary seal; one-sided and inset from upper edge",
                "upper/interior side", "VF_ApplyUpperBoundarySeal" };
            Item.bedrock = { "bedrock", Item.interiorBottomMicrometres,
                Item.interiorBottomMicrometres, false, true, false,
                "no lower seal in FloatingIsland geometryVersion 3", "none", "none" };
        }
        else
        {
            Item.boundDispatchPath = "resolved manager slot scaled by Core chunk width";
            Item.queryDispatchPath = "legacy Core route; manager chunk selected by floor(CoreZ / 32)";
            const std::int64_t SealMicrometres = static_cast<std::int64_t>(std::llround(
                std::max(0.0f, Slot.Definition->GenerationParams.BoundarySealThickness)
                    * OwnerVoxelMicrons));
            Item.ceiling = { "ceiling", Item.interiorTopMicrometres,
                Item.interiorTopMicrometres + SealMicrometres, false, true, false,
                "manager configures a two-sided legacy seal, but Core's compiled analytic field does not apply this density band",
                "configured upper side", "legacy VF_ApplyBoundarySeal; absent from current Core density path" };
            Item.bedrock = { "bedrock", Item.interiorBottomMicrometres - SealMicrometres,
                Item.interiorBottomMicrometres, false, true, false,
                "manager configures a two-sided legacy seal, but Core's compiled analytic field does not apply this density band; breakable by default",
                "configured lower side", "legacy VF_ApplyBoundarySeal; absent from current Core density path" };
        }
        Item.content = { "content", Item.interiorBottomMicrometres,
            Item.interiorTopMicrometres, true, true, false, "resolved generator interior",
            "none", "none" };
        for (std::size_t PassageIndex = 0; PassageIndex < StrateManager->GetPassages().Num(); ++PassageIndex)
        {
            const FVoxelPassage& Passage = StrateManager->GetPassages()[static_cast<int32>(PassageIndex)];
            if (Passage.UpperStrateIndex != Slot.StrateIndex && Passage.LowerStrateIndex != Slot.StrateIndex) continue;
            VoxelForgeCore::ResolvedLayoutAnchorV1 Anchor;
            Anchor.kind = "passage"; Anchor.stableId = "passage/" + std::to_string(PassageIndex);
            Anchor.units = "milli owner voxels";
            Anchor.values = { static_cast<std::int64_t>(std::llround(Passage.UpperPoint.X * 1000.0)),
                static_cast<std::int64_t>(std::llround(Passage.UpperPoint.Y * 1000.0)),
                static_cast<std::int64_t>(std::llround(Passage.UpperPoint.Z * 1000.0)),
                static_cast<std::int64_t>(std::llround(Passage.LowerPoint.X * 1000.0)),
                static_cast<std::int64_t>(std::llround(Passage.LowerPoint.Y * 1000.0)),
                static_cast<std::int64_t>(std::llround(Passage.LowerPoint.Z * 1000.0)) };
            Item.anchors.push_back(std::move(Anchor));
        }
        Layout.strates.push_back(std::move(Item));
    }
    std::string LayoutError;
    if (!Layout.finalize(LayoutError))
    {
        OutError = FString::Printf(TEXT("Core resolved-layout export failed: %s"), UTF8_TO_TCHAR(LayoutError.c_str()));
        return false;
    }
    const std::string LayoutJson = Layout.ToJson();
    const FString LayoutText = UTF8_TO_TCHAR(LayoutJson.c_str());
    TSharedPtr<FJsonObject> LayoutObject;
    const TSharedRef<TJsonReader<>> LayoutReader = TJsonReaderFactory<>::Create(LayoutText);
    if (!FJsonSerializer::Deserialize(LayoutReader, LayoutObject) || !LayoutObject.IsValid())
    {
        OutError = TEXT("Core resolved-layout canonical JSON could not be embedded in the resolved snapshot.");
        return false;
    }
    Root->SetObjectField(TEXT("resolved_layout"), LayoutObject.ToSharedRef());
    const std::string CanonicalJson = Manifest->ToJson();
    if (CanonicalJson.empty())
    {
@@ -563,6 +563,96 @@ namespace VoxelForgeCore
        std::string ToJson() const;
    };
    // Read-only, versioned account of the physical layout resolved by the director and the
    // 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 ResolvedLayoutSchemaVersionV1 = 1;
    enum class ResolvedLayoutValidationModeV1 : std::uint8_t { compatibility, strict };
    struct ResolvedLayoutAnchorV1
    {
        std::string kind;
        std::string stableId;
        std::string units;
        std::vector<std::int64_t> values;
    };
    struct ResolvedLayoutBandV1
    {
        std::string kind; // ceiling, content, bedrock
        std::int64_t bottomMicrometres = 0;
        std::int64_t topMicrometres = 0;
        bool presentInCurrentField = false;
        bool diggable = true;
        bool protectedBand = false;
        std::string behaviour;
        std::string densitySide;
        std::string capPath;
    };
    struct ResolvedLayoutStratumV1
    {
        std::string stableId;
        std::int32_t order = 0;
        std::int32_t strateIndex = -1;
        std::string generatorKind;
        std::string recipeId;
        std::uint32_t recipeVersion = 0;
        std::int64_t interiorBottomMicrometres = 0;
        std::int64_t interiorTopMicrometres = 0;
        std::uint32_t voxelSizeMicrometres = 0;
        std::array<std::int64_t, 3> latticeOriginMicrometres{};
        ResolvedLayoutBandV1 ceiling;
        ResolvedLayoutBandV1 content;
        ResolvedLayoutBandV1 bedrock;
        std::string transitionMode; // mode at this strate's lower interface
        std::int32_t transitionBlendChunks = 0;
        std::int64_t transitionWidthMicrometres = 0;
        std::int64_t transitionWarpAmplitudeMicrometres = 0;
        std::int64_t transitionInterpenetrationMicrometres = 0;
        bool transitionHonouredInCore = false;
        std::string transitionDispatchPath;
        std::string boundDispatchPath;
        std::string queryDispatchPath;
        std::string managerLookup;
        std::int64_t managerChunkWidthMicrometres = 0;
        std::int64_t dispatchChunkWidthMicrometres = 0;
        std::vector<ResolvedLayoutAnchorV1> anchors;
    };
    struct ResolvedLayoutIssueV1
    {
        std::string code;
        std::string detail;
    };
    struct VFCORE_API ResolvedLayoutSnapshotV1
    {
        std::uint32_t schemaVersion = ResolvedLayoutSchemaVersionV1;
        std::string worldIdentity;
        std::uint32_t ownerVoxelSizeMicrometres = 0;
        std::uint32_t coreVoxelSizeMicrometres = 0;
        std::vector<ResolvedLayoutStratumV1> strates;
        std::string stableIdentity;
        bool finalize(std::string& error);
        bool validate(ResolvedLayoutValidationModeV1 mode,
                      std::vector<ResolvedLayoutIssueV1>& issues,
                      std::string& error) const;
        std::string ToJson() const;
        static std::optional<ResolvedLayoutSnapshotV1> FromJson(
            std::string_view json, std::string& error);
    };
    struct ResolvedLayoutValidatorAuditV1
    {
        std::uint32_t controlsRun = 0;
        std::uint32_t controlsRejectedAsExpected = 0;
        bool passed = false;
        std::vector<ResolvedLayoutIssueV1> failures;
    };
    VFCORE_API ResolvedLayoutValidatorAuditV1 AuditResolvedLayoutValidatorV1();
    struct FloatingIslandBoundsAuditResult
    {
        std::uint64_t boxesTested = 0;
@@ -1154,6 +1244,8 @@ namespace VoxelForgeCore
        ShapeBuildStats buildStats() const;
        float densityAt(Vec3d voxelPosition) const;
        // Audit-only selector provenance for the same point evaluator; never used by meshing.
        std::string densityDispatchPathAt(Vec3d voxelPosition) const;
        // Analytic source distance without the occupancy-preserving near-zero clamp or packed proxy.
        float unclampedDensityAt(Vec3d voxelPosition) const;
        DetailFieldSample detailSampleAt(Vec3d voxelPosition) const;
@@ -0,0 +1,330 @@
 #pragma once
 #include "Json.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 #include <algorithm>
 #include <iomanip>
 #include <sstream>
 namespace VoxelForgeCore
 {
 namespace
 {
    std::string LayoutEscape(std::string_view value)
    {
        std::string out="\"";
        for(unsigned char c:value)
        {
            switch(c)
            {
            case '"':out+="\\\"";break;
            case '\\':out+="\\\\";break;
            case '\b':out+="\\b";break;
            case '\f':out+="\\f";break;
            case '\n':out+="\\n";break;
            case '\r':out+="\\r";break;
            case '\t':out+="\\t";break;
            default:if(c<0x20){char b[7];std::snprintf(b,sizeof(b),"\\u%04x",c);out+=b;}
                    else out+=static_cast<char>(c);
            }
        }
        out+='"';return out;
    }
    std::uint64_t LayoutHash(std::string_view value)
    {
        std::uint64_t hash=14695981039346656037ull;
        for(unsigned char c:value){hash^=c;hash*=1099511628211ull;}
        return hash;
    }
    std::string LayoutHex(std::uint64_t value)
    {std::ostringstream out;out<<std::hex<<std::setfill('0')<<std::setw(16)<<value;return out.str();}
    std::int64_t LayoutTransitionLimit(const ResolvedLayoutStratumV1& stratum)
    {
        if(stratum.transitionMode=="Hard")return 0;
        return stratum.transitionWidthMicrometres
            +(stratum.transitionMode=="Interleaved"?stratum.transitionWarpAmplitudeMicrometres:0);
    }
    std::string LayoutBandJson(const ResolvedLayoutBandV1& band)
    {
        std::ostringstream out;out<<"{\"kind\":"<<LayoutEscape(band.kind)
            <<",\"bottom_um\":"<<band.bottomMicrometres<<",\"top_um\":"<<band.topMicrometres
            <<",\"present\":"<<(band.presentInCurrentField?"true":"false")
            <<",\"diggable\":"<<(band.diggable?"true":"false")
            <<",\"protected\":"<<(band.protectedBand?"true":"false")
            <<",\"behaviour\":"<<LayoutEscape(band.behaviour)
            <<",\"density_side\":"<<LayoutEscape(band.densitySide)
            <<",\"cap_path\":"<<LayoutEscape(band.capPath)<<'}';return out.str();
    }
    ResolvedLayoutBandV1 ParseLayoutBand(const VFJson::Value& value)
    {
        ResolvedLayoutBandV1 b;b.kind=value.Get("kind").String();
        b.bottomMicrometres=value.Get("bottom_um").Integer();b.topMicrometres=value.Get("top_um").Integer();
        b.presentInCurrentField=value.Get("present").Boolean();b.diggable=value.Get("diggable").Boolean(true);
        b.protectedBand=value.Get("protected").Boolean();b.behaviour=value.Get("behaviour").String();
        b.densitySide=value.Get("density_side").String();b.capPath=value.Get("cap_path").String();return b;
    }
    std::string LayoutBodyJson(const ResolvedLayoutSnapshotV1& s)
    {
        std::ostringstream out;out<<"{\"schema_version\":"<<s.schemaVersion
            <<",\"world_identity\":"<<LayoutEscape(s.worldIdentity)
            <<",\"owner_voxel_size_um\":"<<s.ownerVoxelSizeMicrometres
            <<",\"core_voxel_size_um\":"<<s.coreVoxelSizeMicrometres<<",\"strates\":[";
        for(std::size_t i=0;i<s.strates.size();++i)
        {
            if(i)out<<',';const auto& x=s.strates[i];
            out<<"{\"stable_id\":"<<LayoutEscape(x.stableId)<<",\"order\":"<<x.order
                <<",\"strate_index\":"<<x.strateIndex<<",\"generator_kind\":"<<LayoutEscape(x.generatorKind)
                <<",\"recipe_id\":"<<LayoutEscape(x.recipeId)<<",\"recipe_version\":"<<x.recipeVersion
                <<",\"interior_bottom_um\":"<<x.interiorBottomMicrometres
                <<",\"interior_top_um\":"<<x.interiorTopMicrometres
                <<",\"voxel_size_um\":"<<x.voxelSizeMicrometres
                <<",\"lattice_origin_um\":["<<x.latticeOriginMicrometres[0]<<','
                <<x.latticeOriginMicrometres[1]<<','<<x.latticeOriginMicrometres[2]<<']'
                <<",\"ceiling\":"<<LayoutBandJson(x.ceiling)
                <<",\"content\":"<<LayoutBandJson(x.content)
                <<",\"bedrock\":"<<LayoutBandJson(x.bedrock)
                <<",\"transition_mode\":"<<LayoutEscape(x.transitionMode)
                <<",\"transition_blend_chunks\":"<<x.transitionBlendChunks
                <<",\"transition_width_um\":"<<x.transitionWidthMicrometres
                <<",\"transition_warp_amplitude_um\":"<<x.transitionWarpAmplitudeMicrometres
                <<",\"transition_interpenetration_um\":"<<x.transitionInterpenetrationMicrometres
                <<",\"transition_honoured_in_core\":"<<(x.transitionHonouredInCore?"true":"false")
                <<",\"transition_dispatch_path\":"<<LayoutEscape(x.transitionDispatchPath)
                <<",\"bound_dispatch_path\":"<<LayoutEscape(x.boundDispatchPath)
                <<",\"query_dispatch_path\":"<<LayoutEscape(x.queryDispatchPath)
                <<",\"manager_lookup\":"<<LayoutEscape(x.managerLookup)
                <<",\"manager_chunk_width_um\":"<<x.managerChunkWidthMicrometres
                <<",\"dispatch_chunk_width_um\":"<<x.dispatchChunkWidthMicrometres
                <<",\"anchors\":[";
            for(std::size_t a=0;a<x.anchors.size();++a)
            {
                if(a)out<<',';const auto& anchor=x.anchors[a];
                out<<"{\"kind\":"<<LayoutEscape(anchor.kind)<<",\"stable_id\":"
                    <<LayoutEscape(anchor.stableId)<<",\"units\":"<<LayoutEscape(anchor.units)<<",\"values\":[";
                for(std::size_t v=0;v<anchor.values.size();++v){if(v)out<<',';out<<anchor.values[v];}
                out<<"]}";
            }
            out<<"]}";
        }
        out<<"]}";return out.str();
    }
    std::int64_t LayoutInt(const VFJson::Value& obj,std::string_view key)
    {return obj.Get(key).Integer();}
    std::string LayoutString(const VFJson::Value& obj,std::string_view key)
    {return obj.Get(key).String();}
    bool LayoutBool(const VFJson::Value& obj,std::string_view key,bool fallback=false)
    {return obj.Get(key).Boolean(fallback);}
 }
 std::string ResolvedLayoutSnapshotV1::ToJson() const
 {
    const std::string body=LayoutBodyJson(*this);
    return body.substr(0,body.size()-1)+",\"stable_identity\":"
        +LayoutEscape(stableIdentity.empty()?"resolved-layout-v1-fnv64:"+LayoutHex(LayoutHash(body)):stableIdentity)+"}";
 }
 bool ResolvedLayoutSnapshotV1::finalize(std::string& error)
 {
    error.clear();
    if(schemaVersion!=ResolvedLayoutSchemaVersionV1||worldIdentity.empty()||strates.empty())
    {error="resolved layout has an unsupported version, empty world identity, or no strates";return false;}
    std::stable_sort(strates.begin(),strates.end(),[](const auto& a,const auto& b)
    {return a.interiorTopMicrometres!=b.interiorTopMicrometres
        ?a.interiorTopMicrometres>b.interiorTopMicrometres:a.order<b.order;});
    for(std::size_t i=0;i<strates.size();++i)
    {
        auto& x=strates[i];x.order=static_cast<std::int32_t>(i);
        if(x.stableId.empty())x.stableId=worldIdentity+"/strate/"+std::to_string(x.strateIndex);
        if(x.content.kind.empty())x.content.kind="content";
        if(x.ceiling.kind.empty())x.ceiling.kind="ceiling";
        if(x.bedrock.kind.empty())x.bedrock.kind="bedrock";
        if(x.interiorTopMicrometres<=x.interiorBottomMicrometres||x.voxelSizeMicrometres==0)
        {error="resolved layout contains an invalid interior interval or voxel size";return false;}
    }
    stableIdentity.clear();const std::string body=LayoutBodyJson(*this);
    stableIdentity="resolved-layout-v1-fnv64:"+LayoutHex(LayoutHash(body));
    std::vector<ResolvedLayoutIssueV1> issues;
    return validate(ResolvedLayoutValidationModeV1::compatibility,issues,error);
 }
 bool ResolvedLayoutSnapshotV1::validate(ResolvedLayoutValidationModeV1 mode,
    std::vector<ResolvedLayoutIssueV1>& issues,std::string& error) const
 {
    issues.clear();error.clear();
    if(schemaVersion!=ResolvedLayoutSchemaVersionV1||worldIdentity.empty()||strates.empty())
    {error="resolved layout schema/world/strata header is invalid";return false;}
    const auto add=[&](std::string code,std::string detail)
    {issues.push_back({std::move(code),std::move(detail)});};
    const bool strict=mode==ResolvedLayoutValidationModeV1::strict;
    for(std::size_t i=0;i<strates.size();++i)
    {
        const auto& s=strates[i];
        const std::int64_t effectiveTransitionWidth=LayoutTransitionLimit(s);
        if(s.interiorTopMicrometres<=s.interiorBottomMicrometres)
            add("invalid_interior",s.stableId+" has non-positive content height");
        if(s.transitionInterpenetrationMicrometres>effectiveTransitionWidth
            ||s.transitionInterpenetrationMicrometres<0)
            add("transition_overlap_exceeds_width",s.stableId+" transition interpenetration exceeds its declared width");
        if(s.managerChunkWidthMicrometres>0&&s.dispatchChunkWidthMicrometres>0
            &&s.managerChunkWidthMicrometres!=s.dispatchChunkWidthMicrometres)
            add("ambiguous_dispatch_units",s.stableId+" manager chunk width differs from Core dispatch chunk width");
        if(i+1<strates.size()&&s.transitionMode!="Hard"&&!s.transitionHonouredInCore)
            add("transition_not_honoured",s.stableId+" declares a blend/interleave that Core does not apply on this interface");
        if(!s.ceiling.presentInCurrentField)add("missing_ceiling",s.stableId+" has no explicit ceiling band in today's field");
        if(!s.bedrock.presentInCurrentField)add("missing_bedrock",s.stableId+" has no explicit bedrock floor in today's field");
        if(strict)
        {
            if(s.order!=static_cast<std::int32_t>(i))add("wrong_order",s.stableId+" order is not top-to-bottom");
            if(!s.ceiling.presentInCurrentField||!s.bedrock.presentInCurrentField)
                add(!s.ceiling.presentInCurrentField?"missing_ceiling":"missing_bedrock",s.stableId+" lacks a required boundary band");
            if(!s.content.presentInCurrentField)
                add("missing_content",s.stableId+" has no content generator band");
            const auto bandShape=[&](const ResolvedLayoutBandV1& b,std::string_view expected)
            {
                if(b.kind!=expected||b.topMicrometres<=b.bottomMicrometres)
                    add("wrong_order",s.stableId+" has an invalid "+std::string(expected)+" band");
                if(b.protectedBand&&b.diggable)
                    add("invalid_protection",s.stableId+" band is both protected and diggable");
            };
            bandShape(s.ceiling,"ceiling");bandShape(s.content,"content");bandShape(s.bedrock,"bedrock");
            if(s.ceiling.bottomMicrometres!=s.content.topMicrometres
                ||s.content.bottomMicrometres!=s.bedrock.topMicrometres)
                add("wrong_order",s.stableId+" bands do not follow ceiling -> content -> bedrock");
            if(i+1<strates.size()
                &&s.bedrock.bottomMicrometres!=strates[i+1].ceiling.topMicrometres)
                add(s.bedrock.bottomMicrometres>strates[i+1].ceiling.topMicrometres?"gap":"overlap",
                    s.stableId+" bedrock and next strate ceiling are not nominally contiguous");
            if(s.transitionInterpenetrationMicrometres>effectiveTransitionWidth)
                add("transition_overlap_exceeds_width",s.stableId+" interpenetration is wider than the declared transition zone");
        }
    }
    if(!strict)
    {
        for(const auto& s:strates)
        {
            if(s.content.presentInCurrentField&&s.ceiling.presentInCurrentField)
            {
                if(s.ceiling.bottomMicrometres<s.content.topMicrometres)
                    add("band_overlap",s.stableId+" ceiling overlaps content by "+std::to_string(
                        s.content.topMicrometres-s.ceiling.bottomMicrometres)+" um");
                else if(s.ceiling.bottomMicrometres>s.content.topMicrometres)
                    add("uncovered_interval",s.stableId+" has a "+std::to_string(
                        s.ceiling.bottomMicrometres-s.content.topMicrometres)+" um gap below its ceiling");
            }
            if(s.content.presentInCurrentField&&s.bedrock.presentInCurrentField)
            {
                if(s.bedrock.topMicrometres>s.content.bottomMicrometres)
                    add("band_overlap",s.stableId+" bedrock overlaps content by "+std::to_string(
                        s.bedrock.topMicrometres-s.content.bottomMicrometres)+" um");
                else if(s.bedrock.topMicrometres<s.content.bottomMicrometres)
                    add("uncovered_interval",s.stableId+" has a "+std::to_string(
                        s.content.bottomMicrometres-s.bedrock.topMicrometres)+" um gap above its bedrock");
            }
        }
        for(std::size_t i=0;i+1<strates.size();++i)
        {
            const auto& a=strates[i];const auto& b=strates[i+1];
            const std::int64_t effectiveTransitionWidth=LayoutTransitionLimit(a);
            if(a.interiorBottomMicrometres>b.interiorTopMicrometres)
                add("uncovered_interval",a.stableId+" to "+b.stableId+" leaves "+std::to_string(
                    a.interiorBottomMicrometres-b.interiorTopMicrometres)+" um uncovered");
            else if(a.interiorBottomMicrometres<b.interiorTopMicrometres)
            {
                const std::int64_t overlap=b.interiorTopMicrometres-a.interiorBottomMicrometres;
                if(overlap>effectiveTransitionWidth)
                    add("overlap",a.stableId+" and "+b.stableId+" interiors overlap by "+std::to_string(overlap)+" um");
                else add("transition_interpenetration",a.stableId+" and "+b.stableId+" overlap inside the declared transition zone");
            }
            if(a.bedrock.presentInCurrentField&&b.ceiling.presentInCurrentField)
            {
                if(a.bedrock.bottomMicrometres>b.ceiling.topMicrometres)
                    add("uncovered_interval",a.stableId+" bedrock and "+b.stableId+" ceiling leave "+std::to_string(
                        a.bedrock.bottomMicrometres-b.ceiling.topMicrometres)+" um uncovered");
                else if(a.bedrock.bottomMicrometres<b.ceiling.topMicrometres)
                {
                    const std::int64_t overlap=b.ceiling.topMicrometres-a.bedrock.bottomMicrometres;
                    if(overlap>effectiveTransitionWidth)
                        add("overlap",a.stableId+" bedrock and "+b.stableId+" ceiling overlap by "+std::to_string(overlap)+" um");
                    else add("transition_interpenetration",a.stableId+" bedrock and "+b.stableId+" ceiling interpenetrate by "+std::to_string(overlap)+" um inside the declared transition zone");
                }
            }
        }
    }
    if(strict&&!issues.empty()){error="strict resolved-layout validation rejected "+issues.front().code;return false;}
    return true;
 }
 std::optional<ResolvedLayoutSnapshotV1> ResolvedLayoutSnapshotV1::FromJson(
    std::string_view json,std::string& error)
 {
    VFJson::Value root;if(!VFJson::Parser(std::string(json)).Parse(root,error))return std::nullopt;
    if(!root.IsObject()){error="resolved layout JSON root must be an object";return std::nullopt;}
    ResolvedLayoutSnapshotV1 s;s.schemaVersion=static_cast<std::uint32_t>(LayoutInt(root,"schema_version"));
    s.worldIdentity=LayoutString(root,"world_identity");
    s.ownerVoxelSizeMicrometres=static_cast<std::uint32_t>(LayoutInt(root,"owner_voxel_size_um"));
    s.coreVoxelSizeMicrometres=static_cast<std::uint32_t>(LayoutInt(root,"core_voxel_size_um"));
    for(const auto& v:root.Get("strates").AsArray())
    {
        ResolvedLayoutStratumV1 x;x.stableId=LayoutString(v,"stable_id");
        x.order=static_cast<std::int32_t>(LayoutInt(v,"order"));x.strateIndex=static_cast<std::int32_t>(LayoutInt(v,"strate_index"));
        x.generatorKind=LayoutString(v,"generator_kind");x.recipeId=LayoutString(v,"recipe_id");
        x.recipeVersion=static_cast<std::uint32_t>(LayoutInt(v,"recipe_version"));
        x.interiorBottomMicrometres=LayoutInt(v,"interior_bottom_um");x.interiorTopMicrometres=LayoutInt(v,"interior_top_um");
        x.voxelSizeMicrometres=static_cast<std::uint32_t>(LayoutInt(v,"voxel_size_um"));
        const auto& origin=v.Get("lattice_origin_um").AsArray();for(std::size_t i=0;i<3&&i<origin.size();++i)x.latticeOriginMicrometres[i]=origin[i].Integer();
        x.ceiling=ParseLayoutBand(v.Get("ceiling"));x.content=ParseLayoutBand(v.Get("content"));x.bedrock=ParseLayoutBand(v.Get("bedrock"));
        x.transitionMode=LayoutString(v,"transition_mode");x.transitionBlendChunks=static_cast<std::int32_t>(LayoutInt(v,"transition_blend_chunks"));
        x.transitionWidthMicrometres=LayoutInt(v,"transition_width_um");
        x.transitionWarpAmplitudeMicrometres=LayoutInt(v,"transition_warp_amplitude_um");
        x.transitionInterpenetrationMicrometres=LayoutInt(v,"transition_interpenetration_um");
        x.transitionHonouredInCore=LayoutBool(v,"transition_honoured_in_core");x.transitionDispatchPath=LayoutString(v,"transition_dispatch_path");
        x.boundDispatchPath=LayoutString(v,"bound_dispatch_path");x.queryDispatchPath=LayoutString(v,"query_dispatch_path");
        x.managerLookup=LayoutString(v,"manager_lookup");x.managerChunkWidthMicrometres=LayoutInt(v,"manager_chunk_width_um");
        x.dispatchChunkWidthMicrometres=LayoutInt(v,"dispatch_chunk_width_um");
        for(const auto& a:v.Get("anchors").AsArray())
        {ResolvedLayoutAnchorV1 p;p.kind=LayoutString(a,"kind");p.stableId=LayoutString(a,"stable_id");p.units=LayoutString(a,"units");
            for(const auto& value:a.Get("values").AsArray())p.values.push_back(value.Integer());x.anchors.push_back(std::move(p));}
        s.strates.push_back(std::move(x));
    }
    const std::string serializedIdentity=LayoutString(root,"stable_identity");
    if(!s.finalize(error))return std::nullopt;
    if(s.stableIdentity!=serializedIdentity){error="resolved layout stable identity does not match its canonical payload";return std::nullopt;}
    return s;
 }
 ResolvedLayoutValidatorAuditV1 AuditResolvedLayoutValidatorV1()
 {
    ResolvedLayoutValidatorAuditV1 result;
    auto make=[](std::string id,std::int32_t order,std::int64_t top,std::int64_t bottom)
    {
        ResolvedLayoutStratumV1 s;s.stableId=std::move(id);s.order=order;s.strateIndex=order;s.generatorKind="synthetic";
        s.interiorTopMicrometres=top;s.interiorBottomMicrometres=bottom;s.voxelSizeMicrometres=250000;
        s.transitionMode="Gradient";s.transitionWidthMicrometres=4000000;
        s.transitionHonouredInCore=true;
        s.ceiling={"ceiling",top,top+1000000,true,true,false,"closed ceiling band","upper face","synthetic"};
        s.content={"content",bottom,top,true,true,false,"generator content","none","none"};
        s.bedrock={"bedrock",bottom-1000000,bottom,true,true,false,"breakable bedrock","lower face","none"};
        return s;
    };
    const auto expectReject=[&](std::string name,ResolvedLayoutSnapshotV1 candidate)
    {
        ++result.controlsRun;std::vector<ResolvedLayoutIssueV1> issues;std::string error;
        if(!candidate.validate(ResolvedLayoutValidationModeV1::strict,issues,error))++result.controlsRejectedAsExpected;
        else result.failures.push_back({"negative_control_accepted",std::move(name)+" was accepted by strict validator"});
    };
    auto base=ResolvedLayoutSnapshotV1{};base.worldIdentity="synthetic";base.strates={make("a",0,10000000,0),make("b",1,-2000000,-12000000)};
    {std::vector<ResolvedLayoutIssueV1> issues;std::string error;
     if(!base.validate(ResolvedLayoutValidationModeV1::strict,issues,error))
         result.failures.push_back({"positive_control_rejected","valid ceiling/content/bedrock layout was rejected"});}
    auto boundaryGap=base;boundaryGap.strates[1].ceiling.topMicrometres-=1;
    expectReject("bedrock/next-ceiling gap",boundaryGap);
    auto missingBedrock=base;missingBedrock.strates[0].bedrock.presentInCurrentField=false;expectReject("missing bedrock",missingBedrock);
    auto missingCeiling=base;missingCeiling.strates[0].ceiling.presentInCurrentField=false;expectReject("missing ceiling",missingCeiling);
    auto wrongOrder=base;wrongOrder.strates[0].content.kind="bedrock";expectReject("wrong band order",wrongOrder);
    auto largeOverlap=base;largeOverlap.strates[0].transitionInterpenetrationMicrometres=4000001;expectReject("interpenetration exceeds transition width",largeOverlap);
    auto genericOverlap=base;genericOverlap.strates[0].bedrock.bottomMicrometres-=1;expectReject("nominal band overlap",genericOverlap);
    auto genericGap=base;genericGap.strates[0].bedrock.bottomMicrometres+=1;expectReject("nominal band gap",genericGap);
    result.passed=result.controlsRun==result.controlsRejectedAsExpected&&result.failures.empty();return result;
 }
 }
@@ -1095,6 +1095,32 @@ public:
        return AnalyticDensityAt(X,Y,Z);
    }
    std::string DensityDispatchPathAt(float X,float Y,float Z) const
    {
        if(SharedDensitySource)return SharedDensitySource->DensityDispatchPathAt(X,Y,Z);
        float Density=0.0f;
        if(NativeFloatingIslandDensityAt(X,Y,Z,Density))return "FloatingIslands-native";
        if(NativeSurfaceDensityAt(X,Y,Z,Density))return "SurfaceWorld-native";
        if(UsesLegacySurfaceField(X,Y,Z))return "SurfaceWorld-legacy";
        if(Owner&&Owner->Manager)
        {
            const int32 ChunkZ=FMath::FloorToInt(Z/static_cast<float>(CHUNK_SIZE));
            const ECaveGeneratorType Type=Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ));
            switch(Type)
            {
            case ECaveGeneratorType::TunnelNetwork:return "compiled-analytic/TunnelNetwork";
            case ECaveGeneratorType::FlatPlain:return "compiled-analytic/FlatPlain";
            case ECaveGeneratorType::CrystalChamber:return "compiled-analytic/CrystalChamber";
            case ECaveGeneratorType::Maze:return "compiled-analytic/Maze";
            case ECaveGeneratorType::SurfaceWorld:return "compiled-analytic/SurfaceWorld";
            case ECaveGeneratorType::VerticalShafts:return "compiled-analytic/VerticalShafts";
            case ECaveGeneratorType::FloatingIslands:return "compiled-analytic/FloatingIslands";
            case ECaveGeneratorType::Underwater:return "compiled-analytic/Underwater";
            }
        }
        return "compiled-analytic/fallback";
    }
    float DensityAtLattice(int32 X,int32 Y,int32 Z) const
    {
        if(SharedDensitySource)return SharedDensitySource->DensityAtLattice(X,Y,Z);
@@ -2,6 +2,7 @@
 #include "StandaloneSnapshotAdapter.h"
 #include "VoxelForgeCore/VoxelForgeCore.h"
 #include "WorldAssemblerInternal.h"
 #include "ResolvedLayoutInternal.h"
 #include "FloatingIslandsInternal.h"
 #include <shared_mutex>
@@ -1457,6 +1458,10 @@ 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; }
    std::string World::densityDispatchPathAt(Vec3d position) const
    { return impl_&&impl_->shapeReady.load(std::memory_order_acquire)&&impl_->shape
        ?impl_->shape->DensityDispatchPathAt(static_cast<float>(position.x),static_cast<float>(position.y),static_cast<float>(position.z))
        :"uncompiled"; }
    float World::unclampedDensityAt(Vec3d position) const
    { return impl_&&impl_->shapeReady.load(std::memory_order_acquire)&&impl_->shape?impl_->shape->DensityAtUnclamped(static_cast<float>(position.x),static_cast<float>(position.y),static_cast<float>(position.z)):0.0f; }
    DetailFieldSample World::detailSampleAt(Vec3d position) const
@@ -0,0 +1,203 @@
 # World Assembler L21 — resolved strate layout
 This round adds a read-only layout snapshot and validator. It does not change density or mesh
 evaluation.
 ## Snapshot and current stack
 World identity is `owner-world/seed/0`; Core voxel size is 0.25 m, owner voxel size is 0.125 m, and
 all lattice origins are `(0,0,0)`. Intervals below are half-open `[bottom, top)` metres. Stable strate
 IDs are `owner-world/seed/0/strate/<index>/generator/<kind>`. The shared Core record uses canonical
 JSON schema v1 and an FNV-1a payload identity.
 The required structure, top to bottom, is:
 ```text
 strate N       ceiling band
               content
               bedrock band
 strate N+1     ceiling band
               content
               bedrock band
 ```
 Ceiling and bedrock remain distinct bands owned by their own strate. Their nominal edges touch; a
 separate `EVoxelStrateTransition` declaration describes possible interpenetration.
 | Prototype | Order / stable suffix | Generator; recipe version | Interior/content (m) | Current ceiling | Current bedrock | Transition at lower interface |
 |---|---|---|---|---|---|---|
 | SurfaceWorld | 0 / `TunnelNetwork` | TunnelNetwork; `legacy.TunnelNetwork` v0 | `[-120, 8)` | No Core density band. Manager configures a 1 m upper `VF_ApplyBoundarySeal` at `[8,9)`, but the compiled analytic Core path does not apply it. | No Core density band. Manager configures a 1 m lower `VF_ApplyBoundarySeal` at `[-121,-120)`, but the compiled analytic Core path does not apply it. | Gradient, 2 chunks = 8 m by the 4 m manager chunk. Core does not apply it; manager/dispatch chunk widths are 4/8 m. |
 | SurfaceWorld | 1 / `SurfaceWorld` | SurfaceWorld; `SurfaceWorld.Heightfield2D` v1 | `[-632,-120)` | No separate volumetric band; cap profile is in content, with `AppendStratumBoundaryCeilings` mesh fallback. | None. | Gradient, 1 chunk = 4 m by manager units; no lower strate in this plan. Manager/dispatch widths are 4/8 m. |
 | FloatingIslands | 0 / `FloatingIslands` | FloatingIslands; `FloatingIslands.ClusterField` geometry v3 | `[-60,4)` | Active one-sided upper seal `[3.5,4)` = 0.5 m. It overlaps the content range by 0.5 m. | None in geometry v3. | Gradient, 2 chunks = 8 m. Core does not apply it; manager/dispatch widths are both 4 m. |
 | FloatingIslands | 1 / `SurfaceWorld` | SurfaceWorld; `SurfaceWorld.Heightfield2D` v1 | `[-632,-120)` | No separate volumetric band; cap profile is in content, with mesh fallback. | None. | Gradient, 1 chunk = 4 m; no lower strate in this plan. Manager/dispatch widths are 4/8 m. |
 Dispatch provenance is recorded per stratum in the JSON snapshot:
 - SurfaceWorld bounds come from `BuildSurfaceStratumPlan`, which converts each chunk with 32 Core
  voxels = 8 m. `NativeSurfaceDensityAt` selects with `floor(CoreZ/32)`, then calls
  `GetGeneratorTypeForChunk` / `GetStrateIndex`. The manager's owner chunk is 4 m.
 - FI bounds come from `BuildFloatingIslandStratumPlan`, which converts each 32-voxel owner chunk
  through the 12.5/25 cm owner/Core ratio = 16 Core voxels = 4 m. `NativeFloatingIslandDensityAt`
  uses the same conversion before the manager lookup.
 - Legacy TunnelNetwork selection uses the Core 32-voxel chunk lookup. The manager helper assigns
  the upper strate's transition to its lower interface.
 SurfaceWorld strata carry four cap profiles, 33 route points and their attached passages. The FI
 strate carries four island anchors and its attached passages. The snapshot preserves these recipe
 anchors in their source fixed-point units.
 The owner configuration’s non-Hard transitions are currently not honored by Core at these interfaces.
 `UVoxelStrateManager::GetGenerationParams` contains legacy vector blending, but Core’s compiled
 dispatcher selects the resolved/native per-strate fields without applying that blend. FI v3 calls
 `VF_ApplyUpperBoundarySeal` for its ceiling; player edit brushes are applied after the native field,
 so that seal remains diggable. Bands default to `diggable=true`, `protected=false`; protection is an
 explicit option.
 ```text
 Current SurfaceWorld plan, top → bottom
  TunnelNetwork ceiling [8,9) (configured; inactive in Core density)
  TunnelNetwork content                                      [-120,8)
  TunnelNetwork bedrock [-121,-120) (configured; inactive in Core)
  SurfaceWorld ceiling: none
  SurfaceWorld content                                       [-632,-120)
  SurfaceWorld bedrock: none
 Current FI prototype, top → bottom
  FI ceiling [3.5,4) active, inset into FI content by 0.5 m
  FI content                                                  [-60,4)
  FI bedrock: missing
  Unassigned interval                                        [-120,-60) = 60 m
  SurfaceWorld ceiling: none
  SurfaceWorld content                                       [-632,-120)
  SurfaceWorld bedrock: none
 ```
 The SurfaceWorld and FI content interiors therefore do not overlap: the FI prototype has a 60 m gap.
 The owner manager slots meet at −60 m when both use 4 m owner chunks, but SurfaceWorld plan/query
 dispatch converts chunks at 8 m while FI converts at 4 m. In the gap, Core answers through the
 compiled analytic FloatingIslands fallback, not either planned recipe; probes at −68 m returned
 solid density −4.125. SurfaceWorld and TunnelNetwork content interiors touch at −120 m in the
 SurfaceWorld prototype, but Core does not apply the declared Gradient there.
 ## Compatibility validation and boundary probes
 Compatibility mode accepted both layouts with seven reported issues apiece. SurfaceWorld reports
 unhonored transition, 4/8 m dispatch-unit ambiguity on both strates, and missing current-field
 ceiling and bedrock bands on both. FI reports its unhonored transition, missing FI bedrock, the
 0.5 m ceiling/content overlap, the 60 m uncovered interval, and missing SurfaceWorld ceiling and
 bedrock. These are recorded as compatibility deviations, not world changes.
 Strict mode accepted a valid synthetic two-strate fixture. Its seven negative controls rejected:
 | Control | Strict check that rejects it |
 |---|---|
 | Nominal band overlap | Bedrock(N) bottom must equal ceiling(N+1) top. |
 | Nominal band gap | The same exact nominal contiguity check. |
 | Missing bedrock | `bedrock.present` is required. |
 | Missing ceiling | `ceiling.present` is required. |
 | Wrong band order | Each band kind and the ceiling → content → bedrock edges must match. |
 | Gap between bedrock(N) and ceiling(N+1) | Their nominal endpoints must be equal. |
 | Interpenetration wider than transition | Explicit overlap must be at most the mode’s limit; this control uses 4,000,001 µm against a 4,000,000 µm Gradient zone. |
 Hard has a 0 m limit. Gradient uses `TransitionBlendChunks × 4 m`; Interleaved adds its recorded
 two-manager-chunk warp amplitude to the blend width. The nominal bands still touch exactly; the
 separate interpenetration field records any permitted physical crossing. Current Core
 interpenetration is 0 m because it does not apply the declared blends.
 Each plan audited 21 points: one Core voxel (0.25 m) below, at, and above every distinct content,
 active-band, configured-band, and transition-zone endpoint. The remaining points agreed with the
 snapshot. Every disagreement was an uncovered snapshot point answered by a named compiled analytic
 fallback:
 | Prototype | Probe Z (m) | Actual Core dispatch | Density / occupancy |
 |---|---|---|---|
 | SurfaceWorld | −632.250 | `compiled-analytic/TunnelNetwork` | `+1`, air |
 | SurfaceWorld | 8.000, 8.250, 8.750, 9.000, 9.250 | `compiled-analytic/TunnelNetwork` | `+9.648438`, `+10.64844`, `+12.64844`, `+13.64844`, `+14.64844`; all air |
 | FI | −632.250 | `compiled-analytic/TunnelNetwork` | `+1`, air |
 | FI | −120.000, −119.750 | `compiled-analytic/FloatingIslands` | `−108.4793`, `−107.4969`; solid |
 | FI | −68.250, −68.000, −67.750, −60.250 | `compiled-analytic/FloatingIslands` | `−4.125`; solid at each point |
 | FI | 4.000, 4.250 | `compiled-analytic/FloatingIslands` | `+0.671875`, `+2.253906`; air |
 Probe summaries: SurfaceWorld 6/21 disagreements; FI 9/21. Full per-point records are in
 `Saved/Linux/linux21/boundary-probes-{surface-world,floating-islands}.log`.
 ## Identity, output parity and cost
 Snapshots round-tripped through canonical JSON. At W1/W8/W12 their bytes were identical per recipe:
 | Recipe | Stable identity | Canonical JSON SHA-256 |
 |---|---|---|
 | SurfaceWorld | `resolved-layout-v1-fnv64:63cf4d2661149fcd` | `267586b3da9bc5c08c654c097559b205222f53c594c4c4332cb4929fd3d75c05` |
 | FloatingIslands | `resolved-layout-v1-fnv64:1d90167f37ef9323` | `7bb9e9d745de3a2edf4276f507a5e4c082ff86aa73d9c1ad7e77c1b4d8b8bea8` |
 The 28 hash runs (both recipes, Clang `fp-contract=off` and GCC default, W1/W8/W12 and W12×5)
 matched all 12 L19 rows per run. The 14 dedicated 24 m crossing runs also matched all 12 L19
 crossing rows. The table gives the final Clang W12×5 rows, in density/mesh/payload/topology order;
 each equals its L19 reference.
 | Scope | SurfaceWorld | FloatingIslands |
 |---|---|---|
 | Full detail | `0ee0579bd15cbbe4 / 32e5d4964d610fee / 1932b96ee4b1d910 / 69743c6bad3447dc` | `43034299d33f2536 / a41e8353ec4bbe9c / cd0e3e15eef827b0 / 0b3c3f13cc1d6f8a` |
 | Whole view | `c10697a8f48380c7 / 4197fc1072f0ff58 / 7b3e616ec9459851 / c879e35592bf33e5` | `00bc3607a7839854 / 4baa66127c2b0892 / e11ef05e851a1517 / 1278bc4b1fffb869` |
 | LOD 0 | `769f2a706d585a72 / 33eeeb39fa443816 / 645621a1d968983f / c2457ed905036c9d` | `ccf97d8e95163a35 / 3333fa0ddebdece2 / d1906bffc2b9d6f2 / a261f3d965e15c12` |
 | LOD 1 | `69cc5a5c0a2c60af / b48335f5410c57d5 / d15c5480162ab8ba / feca1bd025823604` | `25fa2f0fa7fbb6e6 / c549c519707ac1d7 / 66f797cde4ebdecf / 2383982a12a27ee5` |
 | LOD 2 | `85deed5683a77202 / 53469895987aeea2 / e55f8ae7e1532033 / d5feb12a0e85c09b` | `c0577decd8a02cab / 3ccf08b7be6edc5b / 0abcbbda5a06c110 / 11c77b71b606fe75` |
 | LOD 3 | `6518caefb3be7e7f / ec513c90b853a614 / f62fa1137ff17f82 / ccf1dcf681965816` | `386e0c0ef2d7c920 / 1ee2c82d34ad9918 / 000a6514ba018406 / 1b4523b19e90f305` |
 | LOD 4 | `62d4be96021992f4 / 42706847cb9c744a / eab76f9634e4b9bd / 207ffbb6ef184397` | `e8117a3a803be9f8 / 8a6c36cae1fe0e30 / c839f1b1629eff8c / 0ce9d7ea77b4f62b` |
 | LOD 5 | `5e4a8c38b8cea6fc / 76adc9ae86988e27 / 938975bf7cc6d94d / 42e135856abdbcac` | `ca6d1df453c6b600 / 02c90d834d9a3fb6 / 4364c37d526f4104 / 1b1cf40d25e50ddf` |
 | LOD 6 | `e036e95b9006945b / a880cc101a4ed957 / bd82f1aefad6dd89 / 5e9f3408345d95b3` | `6764e347b08603a0 / 46c6ed9a1f029b94 / 5b8dc9d5b7cb0d3d / a10a4a69a93eac4d` |
 | LOD 7 | `8ee358af56a30d8d / 5cbd8e5965a2cc3f / d4a7fe5d9e4bde30 / 4dd52cd090a9af78` | `c7cd1b483c598595 / a545eb567dc4a0df / b0a1fb225437e05a / 301d1b884c509550` |
 | LOD 8 | `c3458e1cbdb9c471 / fba3698d21dd1be0 / 77dfb814eac3a24c / c9514f1580c42449` | `7b6e9279b4993109 / cc63440d9867a18d / 12f5cec78b38fa1b / eed919db6db6b2a7` |
 Exact-query rows (density/unclamped, detail, collision): SurfaceWorld `e4d4a8eb95b35933 / e4d4a8eb95b35933`,
 `efcba20c0c70c415`, `e604823a249029bf`; FloatingIslands `87e5c0dbf9ee9ee2 / 87e5c0dbf9ee9ee2`,
 `efcba20c0c70c415`, `e604823a249029bf`. The representative 24 m crossing W12×5 whole-view row is the
 SurfaceWorld row above; all crossing full-detail, LOD and exact-query rows matched the L19 crossing
 reference.
 Five interleaved hashing-off W12 pairs against L19 measured SurfaceWorld medians 1.510 s old / 1.512 s
 new (+0.14%) and FI 13.487 s old / 13.381 s new (−0.79%). The opt-in snapshot is constructed once
 at plan time, outside tile workers; ordinary standalone evaluation does not request it. No hash rows
 were produced during these pairs.
 Clang and GCC builds passed at 12 jobs. Final build peak process-tree/single-process RSS was
 2,697,676/450,248 KiB (Clang) and 4,570,704/897,024 KiB (GCC). The final evidence runner's maximum
 single-process RSS was 583,736 KiB. All runs used CPUs 0–11 and stayed below the per-run limit; no
 governor or system changes were made.
 ## Failed and retried runs
 - An initial snapshot invocation omitted `--stream-benchmark --stream-pipeline` and exited 2; adding
  the required flags passed.
 - Early Clang builds caught a `strates` member typo, then an audit initializer/type error. Both were
  fixed; the final Clang builds passed.
 - The first complete evidence pass exited 1 at boundary probing because the audit read the host
  manager after the harness had released it. Dispatch provenance was moved to Core's live selector;
  the final audits passed.
 - One GCC build wrapper was interrupted (exit 130) while diagnosing an empty progress log, then
  rerun successfully. No runtime/hash run timed out or exceeded 15 minutes, and no L19 hash mismatch
  remained.
 ## Owner note
 This records the present strata and confirms the selected ceiling → content → bedrock model. FI still
 has no floor in v3; SurfaceWorld has no volumetric floor or separate ceiling; the 8 m / 4 m dispatch
 conversions leave a 60 m FI-prototype gap answered by analytic fallback. Core currently ignores the
 configured transition blend at these interfaces. Bedrock and ceiling protection remain explicit
 options with diggable defaults. This round changes no world output.
 The Unreal adapter adds only a separate `resolved_layout` JSON field beside `world_assembly`; that
 small edit could not be compiled on this Linux machine. No async path, density evaluator, hash input,
 or recipe version changed. No commit, push, or stash was made.
 ## Orchestrator review (Claude)
 - Merged: read-only snapshot + validator, no world change (28 hash runs and 14 crossing runs equal L19;
  cost within noise). The Unreal adapter gains a 193-line `resolved_layout` export beside
  `world_assembly`. It is export-only, but UNCOMPILED here; it must be built on the owner PC.
 - Key facts for the owner: the authored params put the SW top at −60 m (4 m owner chunks), Core
  builds SW at −120…−632 m (8 m conversion); the 60 m between FI and SW is unowned and answered by
  the analytic FloatingIslands fallback as solid. No strate has an active bedrock band; SW has no
  ceiling band (mesh fallback only); configured Gradient transitions are ignored by Core.
 - To check next: whether the "ledges" ground seen under the islands is this fallback solid in the
  unowned gap rather than SW terrain (L19 attributed them to SW at about −60…−73 m).
@@ -0,0 +1,165 @@
 #!/usr/bin/env python3
 """Constrained L21 snapshot, output-parity, crossing, and off-cost evidence."""
 import os
 import re
 import signal
 import statistics
 import subprocess
 import time
 from pathlib import Path
 ROOT = Path(__file__).resolve().parents[4]
 OUT = ROOT / "Saved/Linux/linux21"
 OUT.mkdir(parents=True, exist_ok=True)
 if not os.sched_getaffinity(0).issubset(set(range(12))):
    raise SystemExit("run under taskset -c 0-11")
 BIN = {
    "clang-off": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux21-clang",
    "gcc-default": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux21-gcc",
 }
 OLD_CLANG = ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux19-clang"
 OLD_GCC = ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux19-gcc"
 DATA = ROOT / "Standalone/data/owner_world.json"
 HASH_ROW = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
 LODS = [(1, 1), (8, 1), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5)]
 RECIPES = {
    "surface-world": "0,-35,-487.94,0,-22",
    "floating-islands": "-22,-19,-22.8,0,-4",
 }
 results = []
 def launch(name, argv, timeout=900):
    logfile = OUT / f"{name}.log"
    command = ["taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--", *map(str, argv)]
    started = time.monotonic()
    peak_tree = 0
    peak_process = 0
    timed_out = False
    with logfile.open("w", encoding="utf-8") as stream:
        process = subprocess.Popen(command, stdout=stream, stderr=subprocess.STDOUT,
                                   start_new_session=True)
        while process.poll() is None:
            pending, seen, total = [process.pid], set(), 0
            while pending:
                pid = pending.pop()
                if pid in seen:
                    continue
                seen.add(pid)
                try:
                    pending.extend(int(x) for x in Path(f"/proc/{pid}/task/{pid}/children").read_text().split())
                    values = {}
                    for line in Path(f"/proc/{pid}/status").read_text().splitlines():
                        if line.startswith(("VmRSS:", "VmHWM:")):
                            key, amount, *_ = line.split()
                            values[key] = int(amount)
                    total += values.get("VmRSS:", 0)
                    peak_process = max(peak_process, values.get("VmRSS:", 0), values.get("VmHWM:", 0))
                except (FileNotFoundError, PermissionError, ProcessLookupError, ValueError):
                    pass
            peak_tree = max(peak_tree, total)
            if time.monotonic() - started > timeout:
                os.killpg(process.pid, signal.SIGTERM)
                try:
                    process.wait(timeout=5)
                except subprocess.TimeoutExpired:
                    os.killpg(process.pid, signal.SIGKILL)
                    process.wait()
                timed_out = True
                break
            time.sleep(0.1)
        code = process.wait()
    elapsed = time.monotonic() - started
    rows = HASH_ROW.findall(logfile.read_text(encoding="utf-8", errors="replace"))
    results.append((name, code, elapsed, peak_process, peak_tree, timed_out, len(rows)))
    print(f"[L21Run] {name} exit={code} seconds={elapsed:.3f} peak_process_rss_kib={peak_process} "
          f"peak_tree_rss_kib={peak_tree} hash_rows={len(rows)} timed_out={str(timed_out).lower()}", flush=True)
    return logfile
 def base_args(binary, recipe, workers, hash_output=False, crossing=False):
    args = [binary, DATA, "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
            "--force-generate", "--clip-radius=3", "--max-clip-level=8", f"--workers={workers}",
            f"--camera={RECIPES[recipe]}", f"--recipe={recipe}"]
    if hash_output:
        args.append("--stream-hash")
    if crossing:
        args += ["--camera-step=24,0,0", "--region-crossing"]
    return args
 # Plan-time identities and canonical serialization at W1/W8/W12, both field recipes.
 snapshots = {}
 for recipe in RECIPES:
    for workers, repeat in [(1, 1), (8, 1), (12, 1)]:
        path = OUT / f"snapshot-{recipe}-w{workers}-r{repeat}.json"
        args = [BIN["clang-off"], DATA, "--world-assembler-prototype", "--stream-benchmark",
                "--stream-pipeline", f"--recipe={recipe}", f"--workers={workers}",
                f"--resolved-layout-output={path}", "--resolved-layout-only"]
        log = launch(f"snapshot-{recipe}-w{workers}-r{repeat}", args)
        if results[-1][1] != 0:
            raise SystemExit(f"snapshot plan failed: {log}")
        snapshots[(recipe, workers)] = path.read_bytes()
    if len({snapshots[(recipe, workers)] for workers in (1, 8, 12)}) != 1:
        raise SystemExit(f"snapshot serialization changed with worker count: {recipe}")
    print(f"[L21SnapshotIdentity] recipe={recipe} worker_counts=1,8,12 canonical_bytes=identical status=PASS", flush=True)
 # Full matrix. Every row is compared against the L19 W12x5 reference.
 for recipe in RECIPES:
    for compiler, binary in BIN.items():
        for workers, repeat in LODS:
            name = f"matrix-{recipe}-{compiler}-w{workers}-r{repeat}"
            log = launch(name, base_args(binary, recipe, workers, hash_output=True))
            rows = HASH_ROW.findall(log.read_text(encoding="utf-8", errors="replace"))
            reference_name = f"{recipe}-{compiler}-w12-r5.log"
            reference = ROOT / "Saved/Linux/l19-matrix" / reference_name
            expected = HASH_ROW.findall(reference.read_text(encoding="utf-8", errors="replace"))
            if results[-1][1] != 0 or len(rows) != 12 or rows != expected:
                print(f"[L21HashMismatch] {name} expected_rows={len(expected)} actual_rows={len(rows)}", flush=True)
                raise SystemExit(1)
 # The crossing matrix retains the 24 m two-view query proof on both compilers.
 for compiler, binary in BIN.items():
    for workers, repeat in LODS:
        name = f"crossing-{compiler}-w{workers}-r{repeat}"
        log = launch(name, base_args(binary, "surface-world", workers, hash_output=True, crossing=True))
        rows = HASH_ROW.findall(log.read_text(encoding="utf-8", errors="replace"))
        reference = ROOT / "Saved/Linux/l19-crossing" / f"{compiler}-w12-r5.log"
        expected = HASH_ROW.findall(reference.read_text(encoding="utf-8", errors="replace"))
        if results[-1][1] != 0 or len(rows) != 12 or rows != expected:
            print(f"[L21CrossingHashMismatch] {name} expected_rows={len(expected)} actual_rows={len(rows)}", flush=True)
            raise SystemExit(1)
 # Five interleaved W12 pairs per recipe, hashing disabled. Alternate order by pair to reduce drift.
 off_pairs = {recipe: {"old": [], "new": []} for recipe in RECIPES}
 for recipe in RECIPES:
    for pair in range(1, 6):
        order = [("old", OLD_CLANG), ("new", BIN["clang-off"])] if pair % 2 else [("new", BIN["clang-off"]), ("old", OLD_CLANG)]
        for label, binary in order:
            name = f"offcost-{recipe}-pair{pair}-{label}"
            log = launch(name, base_args(binary, recipe, 12, hash_output=False), timeout=900)
            if results[-1][1] != 0:
                raise SystemExit(f"hashing-off cost run failed: {log}")
            off_pairs[recipe][label].append(results[-1][2])
        print(f"[L21OffCostPair] recipe={recipe} pair={pair} old_seconds={off_pairs[recipe]['old'][-1]:.3f} "
              f"new_seconds={off_pairs[recipe]['new'][-1]:.3f}", flush=True)
 for recipe, pair in off_pairs.items():
    old = statistics.median(pair["old"])
    new = statistics.median(pair["new"])
    print(f"[L21OffCostSummary] recipe={recipe} pairs=5 median_old_seconds={old:.3f} "
          f"median_new_seconds={new:.3f} delta_percent={(new-old)/old*100.0:.2f}", flush=True)
 # Query the real compiled Core field at every distinct recorded stratum/band endpoint.
 for recipe in RECIPES:
    name = f"boundary-probes-{recipe}"
    args = base_args(BIN["clang-off"], recipe, 12, hash_output=False)
    args += ["--audit-resolved-layout-boundaries"]
    log = launch(name, args)
    if results[-1][1] != 0:
        raise SystemExit(f"Core boundary probes failed: {log}")
 print(f"[L21EvidenceSummary] snapshots=6 matrix=28 crossing=14 off_cost_pairs=10 boundary_audits=2 status=PASS", flush=True)
 for name, code, elapsed, rss, tree, timed_out, rows in results:
    print(f"[L21RunDetail] {name} exit={code} seconds={elapsed:.3f} peak_process_rss_kib={rss} "
          f"peak_tree_rss_kib={tree} hash_rows={rows} timed_out={str(timed_out).lower()}", flush=True)
@@ -63,6 +63,9 @@ namespace
        float CameraYawDegrees=0.0f;
        float CameraPitchDegrees=0.0f;
        std::filesystem::path MeshExportPath;
        std::filesystem::path ResolvedLayoutOutputPath;
        bool ResolvedLayoutOnly=false;
        bool AuditResolvedLayoutBoundaries=false;
    };
    bool ParseInteger(std::string_view text,int& output)
@@ -117,6 +120,9 @@ namespace
                    "  --mesh-export=FILE (write the exact generated tile meshes for offline rendering)\n"
                    "  --profile-column-overlap --far-horizon-lod8-step=N --force-generate\n"
                    "  --seed=N --recipe=surface-world|floating-islands\n"
                    "  --resolved-layout-output=FILE (canonical plan-time layout snapshot)\n"
                    "  --resolved-layout-only (exit after plan and snapshot validation)\n"
                    "  --audit-resolved-layout-boundaries (query Core at each recorded endpoint)\n"
                    "  --auto-surface-camera (place the 27-tile cube on this seed's surface)\n"
                    "  --mesh-coverage (report non-empty tiles and indexed triangles)\n"
                    "  --screen-space-gate (measure display error and historical negative controls)\n"
@@ -134,6 +140,8 @@ namespace
                return false;
            }
            if(arg=="--world-assembler-prototype")options.WorldAssemblerPrototype=true;
            else if(arg=="--resolved-layout-only")options.ResolvedLayoutOnly=true;
            else if(arg=="--audit-resolved-layout-boundaries")options.AuditResolvedLayoutBoundaries=true;
            else if(arg=="--stream-benchmark")options.StreamBenchmark=true;
            else if(arg=="--stream-pipeline")options.StreamPipeline=true;
            else if(arg=="--stream-hash")options.StreamHash=true;
@@ -155,6 +163,8 @@ namespace
                else if(recipe=="floating-islands")options.FloatingIslandsRecipe=true;
                else {std::fprintf(stderr,"Invalid --recipe value: %.*s\n",static_cast<int>(recipe.size()),recipe.data());return false;}
            }
            else if(arg.starts_with("--resolved-layout-output="))
                options.ResolvedLayoutOutputPath=std::string(arg.substr(std::string_view("--resolved-layout-output=").size()));
            else if(arg.starts_with("--seed="))
            {if(!readInt("--seed=",options.SeedOverride))return false;options.HasSeedOverride=true;}
            else if(arg.starts_with("--render-distance-chunks="))
@@ -314,6 +324,52 @@ int main(int argc,char** argv)
        &&!StandaloneWorldAssemblyPrototype::AttachFloatingIslandWorldAssembly(
            *ownerWorld,ownerJsonRoot,worldAssembly,error))
    {std::fprintf(stderr,"Floating-island assembly setup failed: %s\n",error.c_str());return 2;}
    VoxelForgeCore::ResolvedLayoutSnapshotV1 resolvedLayout;
    const bool buildResolvedLayout=!options.ResolvedLayoutOutputPath.empty()
        ||options.AuditResolvedLayoutBoundaries||options.ResolvedLayoutOnly;
    if(buildResolvedLayout)
    {
        const std::string_view variant=options.FloatingIslandsRecipe?"floating-islands":"surface-world";
        if(!StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
            *ownerWorld,worldAssembly,variant,resolvedLayout,error))
        {std::fprintf(stderr,"Resolved-layout snapshot failed: %s\n",error.c_str());return 2;}
        const std::string layoutJson=resolvedLayout.ToJson();
        if(!options.ResolvedLayoutOutputPath.empty())
        {
            const auto roundTrip=VoxelForgeCore::ResolvedLayoutSnapshotV1::FromJson(layoutJson,error);
            if(!roundTrip||roundTrip->ToJson()!=layoutJson||roundTrip->stableIdentity!=resolvedLayout.stableIdentity)
            {if(error.empty())error="resolved-layout canonical serialization did not round-trip";
             std::fprintf(stderr,"Resolved-layout round trip failed: %s\n",error.c_str());return 2;}
            if(!options.ResolvedLayoutOutputPath.parent_path().empty())
                std::filesystem::create_directories(options.ResolvedLayoutOutputPath.parent_path());
            std::ofstream output(options.ResolvedLayoutOutputPath,std::ios::binary);
            if(!output){std::fprintf(stderr,"Could not write resolved-layout snapshot: %s\n",options.ResolvedLayoutOutputPath.c_str());return 2;}
            output.write(layoutJson.data(),static_cast<std::streamsize>(layoutJson.size()));
            if(!output){std::fprintf(stderr,"Resolved-layout snapshot write failed: %s\n",options.ResolvedLayoutOutputPath.c_str());return 2;}
        }
        const auto controls=VoxelForgeCore::AuditResolvedLayoutValidatorV1();
        std::vector<VoxelForgeCore::ResolvedLayoutIssueV1> compatibilityIssues;
        std::string compatibilityError;
        const bool compatibilityAccepted=resolvedLayout.validate(
            VoxelForgeCore::ResolvedLayoutValidationModeV1::compatibility,
            compatibilityIssues,compatibilityError);
        std::printf("[ResolvedLayoutSnapshot] schema=%u stable_identity=%s strata=%zu bytes=%zu round_trip=PASS\n",
            resolvedLayout.schemaVersion,resolvedLayout.stableIdentity.c_str(),resolvedLayout.strates.size(),layoutJson.size());
        std::printf("[ResolvedLayoutCompatibility] accepted=%s issues=%zu error=%s\n",
            compatibilityAccepted?"true":"false",compatibilityIssues.size(),compatibilityError.c_str());
        for(const auto& issue:compatibilityIssues)
            std::printf("[ResolvedLayoutCompatibilityIssue] code=%s detail=%s\n",
                issue.code.c_str(),issue.detail.c_str());
        if(!compatibilityAccepted)
        {std::fprintf(stderr,"Resolved-layout compatibility validation failed: %s\n",compatibilityError.c_str());return 2;}
        std::printf("[ResolvedLayoutValidatorControls] rejected=%u/%u status=%s\n",
            controls.controlsRejectedAsExpected,controls.controlsRun,controls.passed?"PASS":"FAIL");
        if(!controls.passed)
        {for(const auto& failure:controls.failures)std::printf("[ResolvedLayoutValidatorControlFailure] %s %s\n",failure.code.c_str(),failure.detail.c_str());return 2;}
        if(!options.ResolvedLayoutOutputPath.empty())
            std::printf("[ResolvedLayoutSnapshotOutput] path=%s\n",options.ResolvedLayoutOutputPath.c_str());
        if(options.ResolvedLayoutOnly)return 0;
    }
    if(options.AutoSurfaceCamera)
    {
        constexpr std::int64_t UnitsPerVoxel=VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
@@ -377,5 +433,6 @@ int main(int argc,char** argv)
        cameraStepVoxels,options.AuditUniformBlockProofs,options.ProfileLodWork,
        options.RegionCrossing,options.AuditTileShapeReadiness,
        options.DiagnosticSlowShapeCompileMs,options.AuditBasePageEquivalence,
-        options.AuditRouteParity);
+        options.AuditRouteParity,options.AuditResolvedLayoutBoundaries,
        buildResolvedLayout?&resolvedLayout:nullptr);
 }
@@ -253,7 +253,9 @@ namespace StandaloneStreamBenchmark
        bool bAuditUniformBlockProofs=false,bool bReportLodWorkProfile=false,
        bool bRegionCrossing=false,
        bool bAuditTileShapeReadiness=false,int DiagnosticSlowShapeCompileMs=0,
-        bool bAuditBasePageEquivalence=false,bool bAuditRouteParity=false)
+        bool bAuditBasePageEquivalence=false,bool bAuditRouteParity=false,
        bool bAuditResolvedLayoutBoundaries=false,
        const VoxelForgeCore::ResolvedLayoutSnapshotV1* ResolvedLayout=nullptr)
    {
        using Clock=std::chrono::steady_clock;
        FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -438,6 +440,89 @@ namespace StandaloneStreamBenchmark
            Streamer.Stop();
            std::fprintf(stderr,"[StreamPipeline] full shape build failed: %s\n",BuildError.c_str());return 2;
        }
        if(bAuditResolvedLayoutBoundaries)
        {
            if(ResolvedLayout==nullptr)
            {Streamer.Stop();std::fprintf(stderr,"[ResolvedLayoutProbe] missing plan-time snapshot\n");return 2;}
            std::vector<std::int64_t> endpoints;
            for(const auto& Stratum:ResolvedLayout->strates)
            {
                endpoints.push_back(Stratum.interiorBottomMicrometres);
                endpoints.push_back(Stratum.interiorTopMicrometres);
                endpoints.push_back(Stratum.ceiling.bottomMicrometres);
                endpoints.push_back(Stratum.ceiling.topMicrometres);
                endpoints.push_back(Stratum.bedrock.bottomMicrometres);
                endpoints.push_back(Stratum.bedrock.topMicrometres);
            }
            for(std::size_t StratumIndex=0;StratumIndex+1<ResolvedLayout->strates.size();++StratumIndex)
            {
                const auto& Upper=ResolvedLayout->strates[StratumIndex];
                if(Upper.transitionMode=="Hard"||Upper.transitionWidthMicrometres<=0)continue;
                endpoints.push_back(Upper.interiorBottomMicrometres-Upper.transitionWidthMicrometres);
                endpoints.push_back(Upper.interiorBottomMicrometres+Upper.transitionWidthMicrometres);
            }
            std::sort(endpoints.begin(),endpoints.end());
            endpoints.erase(std::unique(endpoints.begin(),endpoints.end()),endpoints.end());
            std::uint64_t probes=0,disagreements=0;
            const double CoreVoxelMicrometres=std::max<std::uint32_t>(1,World.CoreVoxelSizeMicrons);
            const auto expectedAt=[&](std::int64_t zMicrometres)
            {
                std::vector<std::string> candidates;
                for(const auto& Stratum:ResolvedLayout->strates)
                {
                    const auto contains=[zMicrometres](const VoxelForgeCore::ResolvedLayoutBandV1& Band)
                    {return Band.presentInCurrentField&&zMicrometres>=Band.bottomMicrometres
                        &&zMicrometres<Band.topMicrometres;};
                    if(contains(Stratum.ceiling))candidates.push_back(Stratum.generatorKind+"/ceiling");
                    if(contains(Stratum.content))candidates.push_back(Stratum.generatorKind+"/content");
                    if(contains(Stratum.bedrock))candidates.push_back(Stratum.generatorKind+"/bedrock");
                }
                return candidates;
            };
            const std::array<std::int64_t,3> offsets{{
                -static_cast<std::int64_t>(World.CoreVoxelSizeMicrons),0,
                static_cast<std::int64_t>(World.CoreVoxelSizeMicrons)}};
            for(const std::int64_t Endpoint:endpoints)
            for(const std::int64_t Offset:offsets)
            {
                const std::int64_t zMicrometres=Endpoint+Offset;
                const double zVoxel=static_cast<double>(zMicrometres)/CoreVoxelMicrometres;
                const VoxelForgeCore::Vec3d position{0.0,0.0,zVoxel};
                const std::string actual=Shape.densityDispatchPathAt(position);
                const auto expected=expectedAt(zMicrometres);
                std::string expectedLabel;
                std::vector<std::string> expectedGenerators;
                for(const auto& Candidate:expected)
                {
                    if(!expectedLabel.empty())expectedLabel+=',';
                    expectedLabel+=Candidate;
                    const auto Separator=Candidate.find('/');
                    const std::string Kind=Candidate.substr(0,Separator);
                    if(std::find(expectedGenerators.begin(),expectedGenerators.end(),Kind)==expectedGenerators.end())
                        expectedGenerators.push_back(Kind);
                }
                if(expected.empty())expectedLabel="uncovered";
                std::string actualGenerator;
                if(actual=="SurfaceWorld-native"||actual=="SurfaceWorld-legacy")actualGenerator="SurfaceWorld";
                else if(actual=="FloatingIslands-native")actualGenerator="FloatingIslands";
                else if(actual.rfind("compiled-analytic/",0)==0)actualGenerator=actual.substr(18);
                const bool mismatch=expected.empty()
                    ?actual!="compiled-analytic/fallback"
                    :std::find(expectedGenerators.begin(),expectedGenerators.end(),actualGenerator)==expectedGenerators.end();
                const float density=Shape.densityAt(position);
                const bool solid=density<0.0f;
                ++probes;disagreements+=mismatch?1u:0u;
                std::printf("[ResolvedLayoutProbe] endpoint_um=%lld offset_um=%lld z_m=%.3f expected=%s actual=%s density=%.7g occupancy=%s disagreement=%s\n",
                    static_cast<long long>(Endpoint),static_cast<long long>(Offset),
                    static_cast<double>(zMicrometres)/1000000.0,expectedLabel.c_str(),actual.c_str(),density,
                    solid?"solid":"air",mismatch?"YES":"no");
            }
            std::printf("[ResolvedLayoutProbeSummary] probes=%llu disagreements=%llu status=%s\n",
                static_cast<unsigned long long>(probes),static_cast<unsigned long long>(disagreements),
                disagreements==0?"PASS":"DEVIATIONS_RECORDED");
            Streamer.Stop();
            return 0;
        }
        const auto ShapeReady=Clock::now();
        const double ShapeSeconds=std::chrono::duration<double>(ShapeReady-ShapeBuildStart).count();
        if(bAuditTileShapeReadiness)
@@ -525,4 +525,161 @@ namespace StandaloneWorldAssemblyPrototype
        return true;
    }
    inline const char* GeneratorKind(ECaveGeneratorType type)
    {
        switch(type)
        {
        case ECaveGeneratorType::TunnelNetwork:return "TunnelNetwork";
        case ECaveGeneratorType::FlatPlain:return "FlatPlain";
        case ECaveGeneratorType::CrystalChamber:return "CrystalChamber";
        case ECaveGeneratorType::Maze:return "Maze";
        case ECaveGeneratorType::SurfaceWorld:return "SurfaceWorld";
        case ECaveGeneratorType::VerticalShafts:return "VerticalShafts";
        case ECaveGeneratorType::FloatingIslands:return "FloatingIslands";
        case ECaveGeneratorType::Underwater:return "Underwater";
        }
        return "Unknown";
    }
    inline const char* TransitionKind(EVoxelStrateTransition type)
    {
        switch(type)
        {
        case EVoxelStrateTransition::Gradient:return "Gradient";
        case EVoxelStrateTransition::Hard:return "Hard";
        case EVoxelStrateTransition::Interleaved:return "Interleaved";
        }
        return "Unknown";
    }
    inline bool BuildResolvedLayoutSnapshot(const FStandaloneOwnerWorld& owner,
        const VoxelForgeCore::WorldAssemblyManifest& assembly,std::string_view recipeVariant,
        VoxelForgeCore::ResolvedLayoutSnapshotV1& out,std::string& error)
    {
        using namespace VoxelForgeCore;
        if(!owner.Manager){error="resolved layout builder requires the initialized director";return false;}
        (void)recipeVariant;
        out={};out.worldIdentity="owner-world/seed/"+std::to_string(owner.Seed);
        out.ownerVoxelSizeMicrometres=owner.OwnerVoxelSizeMicrons;
        out.coreVoxelSizeMicrometres=owner.CoreVoxelSizeMicrons;
        const std::int64_t coreMicrons=std::max<std::uint32_t>(1,owner.CoreVoxelSizeMicrons);
        const std::int64_t managerChunkMicrons=CHUNK_SIZE*static_cast<std::int64_t>(owner.OwnerVoxelSizeMicrons);
        const auto fixedToMicrons=[&](std::int64_t fixed)
        {return static_cast<std::int64_t>(std::llround(static_cast<double>(fixed)
            *static_cast<double>(coreMicrons)/(WorldAssemblySubvoxelsPerVoxel)));};
        for(const FStrateSlot& slot:owner.Manager->GetLayout())
        {
            if(!slot.Definition)continue;
            const auto type=owner.Manager->GetGeneratorTypeForChunk(FIntVector(0,0,slot.TopChunkZ));
            ResolvedLayoutStratumV1 s;s.strateIndex=slot.StrateIndex;s.generatorKind=GeneratorKind(type);
            s.stableId=out.worldIdentity+"/strate/"+std::to_string(slot.StrateIndex)
                +"/generator/"+GeneratorKind(type);
            s.recipeId=type==ECaveGeneratorType::SurfaceWorld?"SurfaceWorld.Heightfield2D"
                :type==ECaveGeneratorType::FloatingIslands?"FloatingIslands.ClusterField":"legacy."+std::string(GeneratorKind(type));
            s.recipeVersion=type==ECaveGeneratorType::SurfaceWorld?assembly.recipe.schemaVersion
                :type==ECaveGeneratorType::FloatingIslands&&!assembly.floatingIslands.empty()
                    ?assembly.floatingIslands.front().manifest.recipe.geometryVersion:0;
            s.voxelSizeMicrometres=owner.CoreVoxelSizeMicrons;
            s.latticeOriginMicrometres={0,0,0};
            std::int64_t bottom=static_cast<std::int64_t>(slot.BottomChunkZ)*CHUNK_SIZE*coreMicrons;
            std::int64_t top=static_cast<std::int64_t>(slot.TopChunkZ+1)*CHUNK_SIZE*coreMicrons;
            if(type==ECaveGeneratorType::FloatingIslands)
            {
                const auto it=std::find_if(assembly.floatingIslands.begin(),assembly.floatingIslands.end(),
                    [&](const auto& p){return p.strateIndex==slot.StrateIndex;});
                if(it!=assembly.floatingIslands.end())
                {bottom=fixedToMicrons(it->manifest.recipe.layoutMinimumZSubvoxels);
                 top=fixedToMicrons(it->manifest.recipe.layoutMaximumZSubvoxels);}
            }
            s.interiorBottomMicrometres=bottom;s.interiorTopMicrometres=top;
            s.content={"content",bottom,top,true,true,false,"current generator interior","none","none"};
            s.transitionMode=TransitionKind(slot.Definition->TransitionType);
            s.transitionBlendChunks=slot.Definition->TransitionBlendChunks;
            s.transitionWidthMicrometres=static_cast<std::int64_t>(s.transitionBlendChunks)*managerChunkMicrons;
            s.transitionWarpAmplitudeMicrometres=s.transitionMode=="Interleaved"
                ?2*managerChunkMicrons:0;
            s.transitionInterpenetrationMicrometres=0;
            s.transitionHonouredInCore=false;
            s.transitionDispatchPath="upper strate owns lower interface; UVoxelStrateManager::GetGenerationParams can blend legacy vectors, but Core's compiled field selects per-strate/native recipe fields without transition blending";
            s.managerLookup="UVoxelStrateManager::GetGeneratorTypeForChunk; upper strate TransitionType owns lower interface";
            s.managerChunkWidthMicrometres=managerChunkMicrons;
            s.dispatchChunkWidthMicrometres=type==ECaveGeneratorType::FloatingIslands
                ?static_cast<std::int64_t>(CHUNK_SIZE)*owner.OwnerVoxelSizeMicrons
                :static_cast<std::int64_t>(CHUNK_SIZE)*coreMicrons;
            if(type==ECaveGeneratorType::SurfaceWorld)
            {s.boundDispatchPath="BuildSurfaceStratumPlan: (chunkZ*CHUNK_SIZE) Core voxels; 32 Core voxels per chunk";
             s.queryDispatchPath="FStandaloneShapeWorld::NativeSurfaceDensityAt: floor(Z/CHUNK_SIZE), manager lookup; 32 Core voxels per chunk";}
            else if(type==ECaveGeneratorType::FloatingIslands)
            {s.boundDispatchPath="BuildFloatingIslandStratumPlan: owner chunk * 32 * owner/Core voxel ratio";
             s.queryDispatchPath="FStandaloneShapeWorld::NativeFloatingIslandDensityAt: floor(Z/(32*owner/Core ratio)), manager lookup";}
            else
            {s.boundDispatchPath="legacy strata slot bounds scaled by Core chunk width";
             s.queryDispatchPath="legacy Core field; manager lookup uses floor(Z/CHUNK_SIZE)";}
            const std::int64_t legacySealMicrons=static_cast<std::int64_t>(std::llround(
                std::max(0.0f,slot.Definition->GenerationParams.BoundarySealThickness)
                    *owner.OwnerVoxelSizeMicrons));
            if(type==ECaveGeneratorType::FloatingIslands)
            {
                const auto it=std::find_if(assembly.floatingIslands.begin(),assembly.floatingIslands.end(),
                    [&](const auto& p){return p.strateIndex==slot.StrateIndex;});
                const std::int64_t seal=it==assembly.floatingIslands.end()?0:fixedToMicrons(
                    it->manifest.recipe.boundarySealSubvoxels);
                s.ceiling={"ceiling",top-seal,top,seal>0,true,false,
                    "v3 shared upper boundary density seal; one sided; inset from upper edge","upper/interior side","VF_ApplyUpperBoundarySeal"};
                s.bedrock={"bedrock",bottom,bottom,false,true,false,
                    "no lower boundary seal in geometryVersion 3","none","none"};
                if(it!=assembly.floatingIslands.end())
                {
                    for(std::size_t n=0;n<it->manifest.plan.islands.size();++n)
                    {const auto& a=it->manifest.plan.islands[n];ResolvedLayoutAnchorV1 anchor;
                     anchor.kind="island_anchor";anchor.stableId="island/"+std::to_string(n);anchor.units="1/256 Core voxel";
                     anchor.values={a.centerSubvoxels[0],a.centerSubvoxels[1],a.centerSubvoxels[2],a.radiusSubvoxels,a.topHalfSubvoxels};
                     s.anchors.push_back(std::move(anchor));}
                }
            }
            else if(type==ECaveGeneratorType::SurfaceWorld)
            {
                s.ceiling={"ceiling",top,top,false,true,false,
                    "no separate volumetric ceiling band; cap profile is internal to content","none",
                    "Heightfield2D cap profile + AppendStratumBoundaryCeilings fallback mesh"};
                s.bedrock={"bedrock",bottom,bottom,false,true,false,"no lower bedrock band","none","none"};
                for(const auto& p:assembly.recipe.biomes)
                    if(p.hasCapProfile)
                    {ResolvedLayoutAnchorV1 a;a.kind="cap_profile";a.stableId="biome/"+std::to_string(p.stableId);
                     a.units="1/256 Core voxel";a.values={p.capHeightSubvoxels,p.capUndulationSubvoxels,
                        p.capWavelengthSubvoxels,p.capDetailAmplitudeSubvoxels,p.capRidgeAmplitudeSubvoxels};s.anchors.push_back(std::move(a));}
                const auto plan=std::find_if(assembly.plan.strates.begin(),assembly.plan.strates.end(),
                    [&](const auto& p){return p.strateIndex==slot.StrateIndex;});
                if(plan!=assembly.plan.strates.end())
                {
                    for(std::size_t n=0;n<plan->route.size();++n)
                    {const auto& p=plan->route[n];ResolvedLayoutAnchorV1 a;a.kind="route_point";a.stableId="route/"+std::to_string(n);
                     a.units="1/256 Core voxel";a.values={p.positionSubvoxels[0],p.positionSubvoxels[1],p.positionSubvoxels[2],p.radiusSubvoxels};
                     s.anchors.push_back(std::move(a));}
                }
            }
            else
            {
                s.ceiling={"ceiling",top,top+legacySealMicrons,false,true,false,
                    "manager configures a two-sided legacy seal, but Core's compiled analytic field does not apply this density band",
                    "configured upper side","legacy VF_ApplyBoundarySeal; absent from current Core density path"};
                s.bedrock={"bedrock",bottom-legacySealMicrons,bottom,false,true,false,
                    "manager configures a two-sided legacy seal, but Core's compiled analytic field does not apply this density band; breakable by default",
                    "configured lower side","legacy VF_ApplyBoundarySeal; absent from current Core density path"};
            }
            for(std::size_t n=0;n<owner.Manager->GetPassages().Num();++n)
            {
                const auto& passage=owner.Manager->GetPassages()[static_cast<int32>(n)];
                if(passage.UpperStrateIndex!=slot.StrateIndex&&passage.LowerStrateIndex!=slot.StrateIndex)continue;
                ResolvedLayoutAnchorV1 a;a.kind="passage";a.stableId="passage/"+std::to_string(n);
                a.units="milli owner voxels";a.values={std::llround(passage.UpperPoint.X*1000.0),
                    std::llround(passage.UpperPoint.Y*1000.0),std::llround(passage.UpperPoint.Z*1000.0),
                    std::llround(passage.LowerPoint.X*1000.0),std::llround(passage.LowerPoint.Y*1000.0),
                    std::llround(passage.LowerPoint.Z*1000.0)};s.anchors.push_back(std::move(a));
            }
            out.strates.push_back(std::move(s));
        }
        return out.finalize(error);
    }
 } // namespace StandaloneWorldAssemblyPrototype