wip(L17, side branch): FloatingIslands seal-cap fix + owner/Core chunk-scale change (breaks SurfaceWorld)

Not for assembler/world: the 8 m -> 4 m strate chunk change moves every stratum, so the SurfaceWorld
spawn camera floats in a void and the L1 mesh export shrank 58.7 -> 31.7 MB. Kept for its
diagnostics, the boundarySeal finding and the readable capture shading. See Linux17/REPORT.md.

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

ARCHITECTURE.md

@@ -1840,6 +1840,28 @@ fill and check page tiles against the evaluator they actually sample. This is th
 the Unreal adapter and its asynchronous MPSC/Epoch flow are unchanged. See
 [`Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md).
 
+### 8.37 Owner/Core stratum coordinates and FloatingIslands boundaries — World Assembler M3 L17
+
+Manager chunk coordinates are in owner chunks, while Core density positions are Core voxels. Convert
+between them with `32 * OwnerVoxelSizeMicrons / CoreVoxelSizeMicrons`; do not divide Core positions
+by `CHUNK_SIZE` directly. The L17 owner snapshot uses 0.125 m owner voxels and 0.25 m Core voxels,
+so one owner chunk is 16 Core voxels (4 m), not 32 (8 m). The old hard-coded divisor doubled the
+manifest's vertical stratum bounds and misplaced native-only readiness queries.
+
+FloatingIslands is the sparse `FloatingIslandFieldV1` manifest route. Its 0.5 m `boundarySeal`
+limits feature influence; it is not a signed solid cap across the whole XY plane. Applying it as a
+solid cap produced a false top at +3.5 m, while the doubled legacy layer bound also produced a cap at
++8 m. SurfaceWorld remains the planar `Heightfield2D` field with its independent ground and cap
+surfaces. Adjacent native FI/SW strata now clip their signed distances to the same physical owner
+boundary, preserving exact surface signs and height through the mesh sample lattice.
+
+The output change increments `WorldAssemblyEvaluatorVersion` from 6 to 7; the plan schema and
+recipe geometry version stay unchanged because their inputs did not change. The L17 probes found
+zero cave/floor influence at the false square and at the sampled island ground. The shared Core
+coordinate conversion also changes SurfaceWorld native readiness and hashes where the previous
+mapping selected the wrong route. See
+[`Standalone/Research/WorldAssemblerM3/Linux17/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux17/REPORT.md).
+
 ## 9. Multiplayer model (listen-server first, dedicated-friendly)
 
 > **Status: transport is DESIGN ONLY — nothing is networked in-tree yet** (no `Replicated`/`HasAuthority`/RPCs; a

CODEMAP.md

@@ -1132,11 +1132,19 @@ Implementation and evidence: [`Standalone/Research/WorldAssemblerM3/Linux9/REPOR
 
 | Symbol | Canonical file | Role |
 |---|---|---|
-| `FStandaloneShapeWorld::SetSharedDensitySource`, `SharedDensitySource` | `Standalone/Core/src/ShapeWorldInternal.h`, bound before publication in `Standalone/Core/src/VoxelForgeCore.cpp` | Makes compiled analytic pages delegate field, lattice, detail, classification, and solid queries to the Core world's base shape; `WorldAssemblyEvaluatorVersion` is 6. |
+| `FStandaloneShapeWorld::SetSharedDensitySource`, `SharedDensitySource` | `Standalone/Core/src/ShapeWorldInternal.h`, bound before publication in `Standalone/Core/src/VoxelForgeCore.cpp` | Makes compiled analytic pages delegate field, lattice, detail, classification, and solid queries to the Core world's base shape; `WorldAssemblyEvaluatorVersion` is 7. |
 
 The base manifest field is authoritative for tile generation and exact queries. See ARCHITECTURE
 §8.36 and [`Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux13/REPORT.md).
 
+### 3.23 Owner/Core stratum coordinates — World Assembler M3 L17
+
+`FStandaloneShapeWorld::GetCoreVoxelsPerOwnerChunk` is the shared conversion for manager chunk
+lookups, manifest layer bounds, readiness proofs, and adjacent native strata. FloatingIslands uses
+`FloatingIslandFieldV1`; its boundary seal bounds feature influence and does not fill an XY-wide
+solid cap. SurfaceWorld remains the `Heightfield2D` path. See ARCHITECTURE §8.37 and
+[`Standalone/Research/WorldAssemblerM3/Linux17/REPORT.md`](Standalone/Research/WorldAssemblerM3/Linux17/REPORT.md).
+
 ## 4. The density pipeline (most-edited hot path)
 
 ### 4.1 `GetDensityWithParams` (TunnelNetwork) — VoxelGenerator.cpp:3749

Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h

@@ -249,8 +249,8 @@ namespace VoxelForgeCore
     // L'assembleur v1 encode coordonnees et scalaires en 1/256 de voxel, independamment des tuiles.
     inline constexpr std::int64_t WorldAssemblySubvoxelsPerVoxel = 256;
     inline constexpr std::uint32_t WorldAssemblySchemaVersion = 1;
-    // Version 6 binds every compiled tile page to the world's base density evaluator.
-    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 6;
+    // Version 7 fixes owner/Core chunk mapping and native adjacent-stratum boundaries.
+    inline constexpr std::uint32_t WorldAssemblyEvaluatorVersion = 7;
 
     enum class FieldChannel : std::uint32_t
     {

Standalone/Core/src/ShapeWorldInternal.h

@@ -47,6 +47,18 @@ public:
         return static_cast<double>(CHUNK_SIZE) * OwnerVoxelSizeCm / GetCoreVoxelSizeCm();
     }
 
+    int32 OwnerChunkLowerBoundaryCoreVoxel(int32 ChunkZ) const
+    {
+        return static_cast<int32>(std::floor(
+            static_cast<double>(ChunkZ) * GetCoreVoxelsPerOwnerChunk()));
+    }
+
+    int32 OwnerChunkUpperBoundaryCoreVoxel(int32 ChunkZ) const
+    {
+        return static_cast<int32>(std::ceil(
+            static_cast<double>(ChunkZ) * GetCoreVoxelsPerOwnerChunk()));
+    }
+
     enum class EDetailVariant : uint8 { Coherent, Smooth, PerVoxel };
     struct FBoxClassification
     {
@@ -712,14 +724,21 @@ public:
         if(Owner&&Owner->Manager)
         {
             const double TileZ0=Origin.Z,TileZ1=Origin.Z+static_cast<double>(Cells)*Step;
+            const double CoreVoxelsPerOwnerChunk=GetCoreVoxelsPerOwnerChunk();
             for(const FStrateSlot& Slot:Owner->Manager->GetLayout())
             {
+                const int32 MidChunkZ=(Slot.TopChunkZ+Slot.BottomChunkZ)/2;
+                if(bUseNativeManifestFields
+                    &&Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,MidChunkZ))
+                        ==ECaveGeneratorType::FloatingIslands)
+                    continue;
                 const FStrateGenerationParams Params=Owner->Manager->GetGenerationParams(
-                    FIntVector(0,0,(Slot.TopChunkZ+Slot.BottomChunkZ)/2));
+                    FIntVector(0,0,MidChunkZ));
                 const float HalfWidth=static_cast<float>(std::max(8.0,
                     static_cast<double>(Params.BoundarySealThickness)+8.0));
-                const float Boundaries[2]={static_cast<float>(Slot.BottomChunkZ)*CHUNK_SIZE,
-                    static_cast<float>(Slot.TopChunkZ+1)*CHUNK_SIZE};
+                const float Boundaries[2]={
+                    static_cast<float>(static_cast<double>(Slot.BottomChunkZ)*CoreVoxelsPerOwnerChunk),
+                    static_cast<float>(static_cast<double>(Slot.TopChunkZ+1)*CoreVoxelsPerOwnerChunk)};
                 for(const float Z:Boundaries)
                     if(Z+HalfWidth>=TileZ0&&Z-HalfWidth<=TileZ1)
                         Out.stratumBoundaries.push_back({Z,HalfWidth});
@@ -1028,19 +1047,21 @@ public:
             float NativeDensity=0.0f;
             if(!NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
             {RecordNativeOnlyViolation();return 0.0f;}
-            return NativeDensity;
+            return ApplyAdjacentStratumBoundary(X,Y,Z,NativeDensity,false);
         }
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(X,Y,Z,IslandDensity))
         {
             ++ThreadClassificationStats().NativeFloatFieldCalls;
-            return ApplyEditBrushes(IslandDensity,X,Y,Z);
+            return ApplyEditBrushes(ApplyAdjacentStratumBoundary(
+                X,Y,Z,IslandDensity,true),X,Y,Z);
         }
         float NativeDensity=0.0f;
         if(NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
         {
             ++ThreadClassificationStats().NativeFloatFieldCalls;
-            return ApplyEditBrushes(NativeDensity,X,Y,Z);
+            return ApplyEditBrushes(ApplyAdjacentStratumBoundary(
+                X,Y,Z,NativeDensity,false),X,Y,Z);
         }
         if(UsesLegacySurfaceField(X,Y,Z))
             return LegacySurfaceDensityAt(X,Y,Z);
@@ -1064,21 +1085,27 @@ public:
             if(!NativeSurfaceDensityAt(static_cast<float>(X),static_cast<float>(Y),
                 static_cast<float>(Z),NativeDensity))
             {RecordNativeOnlyViolation();return 0.0f;}
-            return NativeDensity;
+            return ApplyAdjacentStratumBoundary(
+                static_cast<float>(X),static_cast<float>(Y),static_cast<float>(Z),
+                NativeDensity,false);
         }
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(static_cast<float>(X),static_cast<float>(Y),
             static_cast<float>(Z),IslandDensity))
         {
             ++ThreadClassificationStats().NativeLatticeFieldCalls;
-            return ApplyEditBrushes(IslandDensity,X,Y,Z);
+            return ApplyEditBrushes(ApplyAdjacentStratumBoundary(
+                static_cast<float>(X),static_cast<float>(Y),static_cast<float>(Z),
+                IslandDensity,true),X,Y,Z);
         }
         float NativeDensity=0.0f;
         if(NativeSurfaceDensityAt(static_cast<float>(X),static_cast<float>(Y),
             static_cast<float>(Z),NativeDensity))
         {
             ++ThreadClassificationStats().NativeLatticeFieldCalls;
-            return ApplyEditBrushes(NativeDensity,X,Y,Z);
+            return ApplyEditBrushes(ApplyAdjacentStratumBoundary(
+                static_cast<float>(X),static_cast<float>(Y),static_cast<float>(Z),
+                NativeDensity,false),X,Y,Z);
         }
         if(UsesLegacySurfaceField(static_cast<float>(X),static_cast<float>(Y),
             static_cast<float>(Z)))
@@ -1102,19 +1129,21 @@ public:
             float NativeDensity=0.0f;
             if(!NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
             {RecordNativeOnlyViolation();return 0.0f;}
-            return NativeDensity;
+            return ApplyAdjacentStratumBoundary(X,Y,Z,NativeDensity,false);
         }
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(X,Y,Z,IslandDensity))
         {
             ++ThreadClassificationStats().NativeUnclampedFieldCalls;
-            return ApplyEditBrushes(IslandDensity,X,Y,Z);
+            return ApplyEditBrushes(ApplyAdjacentStratumBoundary(
+                X,Y,Z,IslandDensity,true),X,Y,Z);
         }
         float NativeDensity=0.0f;
         if(NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
         {
             ++ThreadClassificationStats().NativeUnclampedFieldCalls;
-            return ApplyEditBrushes(NativeDensity,X,Y,Z);
+            return ApplyEditBrushes(ApplyAdjacentStratumBoundary(
+                X,Y,Z,NativeDensity,false),X,Y,Z);
         }
         if(UsesLegacySurfaceField(X,Y,Z))
             return LegacySurfaceDensityAt(X,Y,Z);
@@ -1260,12 +1289,18 @@ private:
         if(OutFloorInfluence)*OutFloorInfluence=0.0f;
         float IslandDensity=0.0f;
         if(NativeFloatingIslandDensityAt(X,Y,Z,IslandDensity))
+        {
+            IslandDensity=ApplyAdjacentStratumBoundary(X,Y,Z,IslandDensity,true);
             return bApplyEdits?ApplyEditBrushes(IslandDensity,X,Y,Z):IslandDensity;
+        }
         if(UsesLegacySurfaceField(X,Y,Z))
         {
             float NativeDensity=0.0f;
             if(NativeSurfaceDensityAt(X,Y,Z,NativeDensity))
+            {
+                NativeDensity=ApplyAdjacentStratumBoundary(X,Y,Z,NativeDensity,false);
                 return bApplyEdits?ApplyEditBrushes(NativeDensity,X,Y,Z):NativeDensity;
+            }
             const float Density=Owner->Generator->GetDensityAt(X,Y,Z);
             return bApplyEdits?ApplyEditBrushes(Density,X,Y,Z):Density;
         }
@@ -1321,8 +1356,11 @@ public:
             return SharedDensitySource->GetNativeSurfaceHeightsAt(X,Y,ChunkZ,OutGroundZ,OutCeilingZ);
         if(!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
             ||!std::isfinite(X)||!std::isfinite(Y))return false;
-        const std::int64_t chunkMinimum=static_cast<std::int64_t>(ChunkZ)*CHUNK_SIZE;
-        const std::int64_t chunkMaximum=chunkMinimum+CHUNK_SIZE;
+        const double CoreVoxelsPerOwnerChunk=GetCoreVoxelsPerOwnerChunk();
+        const std::int64_t chunkMinimum=static_cast<std::int64_t>(std::floor(
+            static_cast<double>(ChunkZ)*CoreVoxelsPerOwnerChunk));
+        const std::int64_t chunkMaximum=static_cast<std::int64_t>(std::ceil(
+            static_cast<double>(ChunkZ+1)*CoreVoxelsPerOwnerChunk));
         if(bNativeOnly&&(!NativeOnlyContainsColumn(X,Y)
             ||chunkMaximum<NativeOnlyMinimum.Z||chunkMinimum>NativeOnlyMaximum.Z
             ||Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
@@ -1344,7 +1382,8 @@ public:
         const VoxelForgeCore::Heightfield2D Block(WorldAssembly->recipe,*Plan);
         if(!Block.isValid())return false;
         const auto Column=Block.point(ToFixed(X),ToFixed(Y),
-            static_cast<int64>(ChunkZ)*CHUNK_SIZE*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
+            static_cast<int64>(std::llround(static_cast<double>(ChunkZ)
+                *CoreVoxelsPerOwnerChunk*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel)));
         OutGroundZ=static_cast<float>(Column.groundHeightSubvoxels/Scale);
         OutCeilingZ=static_cast<float>(Column.capHeightSubvoxels/Scale);
         return std::isfinite(OutGroundZ)&&std::isfinite(OutCeilingZ);
@@ -1360,10 +1399,11 @@ public:
         const int32 Pad=std::max(Step,1);
         const int32 BMin=Origin.Z-Pad;
         const int32 BMax=Origin.Z+(Cells+1)*Step;
+        const double CoreVoxelsPerOwnerChunk=GetCoreVoxelsPerOwnerChunk();
         const int32 FirstChunk=FMath::FloorToInt(static_cast<float>(BMin)
-            /static_cast<float>(CHUNK_SIZE));
+            /static_cast<float>(CoreVoxelsPerOwnerChunk));
         const int32 LastChunk=FMath::FloorToInt(static_cast<float>(BMax)
-            /static_cast<float>(CHUNK_SIZE));
+            /static_cast<float>(CoreVoxelsPerOwnerChunk));
         const VoxelForgeCore::WorldAssemblyStratumPlanV1* Plan=nullptr;
         for(int32 ChunkZ=FirstChunk;ChunkZ<=LastChunk;++ChunkZ)
         {
@@ -1407,12 +1447,13 @@ public:
         bool bIslandOtherStrateOverlap=false,bBadPlan=false;
         if(Owner&&Owner->Manager)
         {
-            // Keep the delivered SurfaceWorld chunk mapping unchanged.
-            // Conserver le mapping de chunks SurfaceWorld deja livre.
+            // All manifest strata use the same resolved owner-chunk to Core-voxel scale.
+            // Toutes les strates du manifeste partagent l'echelle owner/Core resolue.
+            const double CoreVoxelsPerOwnerChunk=GetCoreVoxelsPerOwnerChunk();
             const int32 FirstChunk=FMath::FloorToInt(static_cast<float>(BMin[2])
-                /static_cast<float>(CHUNK_SIZE));
+                /static_cast<float>(CoreVoxelsPerOwnerChunk));
             const int32 LastChunk=FMath::FloorToInt(static_cast<float>(BMax[2])
-                /static_cast<float>(CHUNK_SIZE));
+                /static_cast<float>(CoreVoxelsPerOwnerChunk));
             for(int32 ChunkZ=FirstChunk;ChunkZ<=LastChunk;++ChunkZ)
             {
                 const ECaveGeneratorType Type=Owner->Manager->GetGeneratorTypeForChunk(
@@ -1544,19 +1585,6 @@ public:
         {
             if(!IslandPlan)return Finish(EVoxelTileClass::Mixed,true);
             constexpr std::int64_t Scale=VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
-            const std::int64_t Bottom=IslandPlan->manifest.recipe.layoutMinimumZSubvoxels;
-            const std::int64_t Top=IslandPlan->manifest.recipe.layoutMaximumZSubvoxels;
-            const std::int64_t Seal=IslandPlan->manifest.recipe.boundarySealSubvoxels;
-            const std::int64_t BoxBottom=static_cast<std::int64_t>(BMin[2])*Scale;
-            const std::int64_t BoxTop=static_cast<std::int64_t>(BMax[2])*Scale;
-            const bool bBottomSealOverlap=BoxBottom<Bottom+Seal&&BoxTop>=Bottom;
-            const bool bTopSealOverlap=BoxBottom<=Top&&BoxTop>Top-Seal;
-            if(bBottomSealOverlap)
-                return Finish(BoxBottom>=Bottom&&BoxTop<=Bottom+Seal
-                    ?EVoxelTileClass::AllSolid:EVoxelTileClass::Mixed);
-            if(bTopSealOverlap)
-                return Finish(BoxBottom>=Top-Seal&&BoxTop<=Top
-                    ?EVoxelTileClass::AllSolid:EVoxelTileClass::Mixed);
             const VoxelForgeCore::FloatingIslandFieldV1 Block(
                 IslandPlan->manifest.recipe,IslandPlan->manifest.plan);
             if(!Block.isValid())return Finish(EVoxelTileClass::Mixed,true);
@@ -2079,7 +2107,8 @@ private:
     {
         if(!bUseNativeManifestFields||!WorldAssembly||!Owner||!Owner->Manager||!Owner->Generator
             ||!std::isfinite(X)||!std::isfinite(Y)||!std::isfinite(Z))return false;
-        const int32 ChunkZ=FMath::FloorToInt(Z/static_cast<float>(CHUNK_SIZE));
+        const int32 ChunkZ=FMath::FloorToInt(Z
+            /static_cast<float>(GetCoreVoxelsPerOwnerChunk()));
         if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,ChunkZ))
             !=ECaveGeneratorType::SurfaceWorld)return false;
         const int32 StrateIndex=Owner->Manager->GetStrateIndex(
@@ -2125,23 +2154,79 @@ private:
         const VoxelForgeCore::FloatingIslandFieldV1 Field(
             Plan->manifest.recipe,Plan->manifest.plan);
         if(!Field.isValid())return false;
-        std::int64_t Density=Field.densitySubvoxels(ToFixed(X),ToFixed(Y),ToFixed(Z));
-        const std::int64_t Bottom=Plan->manifest.recipe.layoutMinimumZSubvoxels;
-        const std::int64_t Top=Plan->manifest.recipe.layoutMaximumZSubvoxels;
-        const std::int64_t Seal=Plan->manifest.recipe.boundarySealSubvoxels;
-        const std::int64_t Zq=ToFixed(Z);
-        if(Zq>=Bottom&&Zq<Bottom+Seal)Density=std::min(Density,-std::max<std::int64_t>(1,Zq-Bottom));
-        if(Zq<=Top&&Zq>Top-Seal)Density=std::min(Density,-std::max<std::int64_t>(1,Top-Zq));
+        // The recipe's boundary seal is a feature margin, not a horizontal solid cap.
+        // La marge de scellement du plan borne ses formes, sans remplir tout le plan XY.
+        const std::int64_t Density=Field.densitySubvoxels(ToFixed(X),ToFixed(Y),ToFixed(Z));
         OutDensity=static_cast<float>(static_cast<double>(Density)/Scale);
         return std::isfinite(OutDensity);
     }
 
+    float ApplyAdjacentStratumBoundary(float X,float Y,float Z,float Density,
+                                       bool bFloatingIsland) const
+    {
+        if(!bUseNativeManifestFields||!WorldAssembly||!Owner||!Owner->Manager
+            ||!std::isfinite(X)||!std::isfinite(Y)||!std::isfinite(Z))return Density;
+        const double CoreVoxelsPerOwnerChunk=GetCoreVoxelsPerOwnerChunk();
+        const int32 ChunkZ=FMath::FloorToInt(Z/static_cast<float>(CoreVoxelsPerOwnerChunk));
+        const ECaveGeneratorType CurrentType=Owner->Manager->GetGeneratorTypeForChunk(
+            FIntVector(0,0,ChunkZ));
+        if(bFloatingIsland&&CurrentType==ECaveGeneratorType::FloatingIslands)
+        {
+            const int32 StrateIndex=Owner->Manager->GetStrateIndex(
+                static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
+            const auto* Plan=FindWorldAssemblyFloatingIslandStratum(StrateIndex,ChunkZ);
+            if(!Plan)return Density;
+            const int32 LowerChunk=Plan->bottomChunkZ-1;
+            if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,LowerChunk))
+                !=ECaveGeneratorType::SurfaceWorld)return Density;
+            const double Boundary=static_cast<double>(Plan->bottomChunkZ)
+                *CoreVoxelsPerOwnerChunk;
+            float LowerDensity=0.0f,UpperDensity=0.0f;
+            if(!NativeSurfaceDensityAt(X,Y,static_cast<float>(Boundary-0.5),LowerDensity)
+                ||!NativeFloatingIslandDensityAt(X,Y,static_cast<float>(Boundary+0.5),UpperDensity)
+                ||(LowerDensity<0.0f)==(UpperDensity<0.0f))return Density;
+
+            // Clip the two signed-distance fields to their shared owner-stratum plane.
+            // This keeps a solid-below/air-above seam continuous at every mesh sample step.
+            // Les deux champs sont limites au plan commun, quel que soit le pas de maillage.
+            const float Plane=static_cast<float>(static_cast<double>(Z)-Boundary);
+            return LowerDensity<0.0f?std::min(Density,Plane)
+                                    :std::max(Density,-Plane);
+        }
+        if(!bFloatingIsland&&CurrentType==ECaveGeneratorType::SurfaceWorld)
+        {
+            const int32 StrateIndex=Owner->Manager->GetStrateIndex(
+                static_cast<float>((static_cast<double>(ChunkZ)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE));
+            const auto* Plan=FindWorldAssemblyStratum(StrateIndex,ChunkZ);
+            if(!Plan)return Density;
+            const int32 UpperChunk=Plan->topChunkZ+1;
+            if(Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,UpperChunk))
+                !=ECaveGeneratorType::FloatingIslands)return Density;
+            const auto* UpperPlan=FindWorldAssemblyFloatingIslandStratum(
+                Owner->Manager->GetStrateIndex(static_cast<float>((
+                    static_cast<double>(UpperChunk)*CHUNK_SIZE+CHUNK_SIZE/2)*VOXEL_SIZE)),UpperChunk);
+            if(!UpperPlan)return Density;
+            const double Boundary=static_cast<double>(UpperPlan->bottomChunkZ)
+                *CoreVoxelsPerOwnerChunk;
+            float LowerDensity=0.0f,UpperDensity=0.0f;
+            if(!NativeSurfaceDensityAt(X,Y,static_cast<float>(Boundary-0.5),LowerDensity)
+                ||!NativeFloatingIslandDensityAt(X,Y,static_cast<float>(Boundary+0.5),UpperDensity)
+                ||(LowerDensity<0.0f)==(UpperDensity<0.0f))return Density;
+
+            const float Plane=static_cast<float>(static_cast<double>(Z)-Boundary);
+            return LowerDensity<0.0f?std::max(Density,Plane)
+                                    :std::min(Density,-Plane);
+        }
+        return Density;
+    }
+
     bool UsesLegacySurfaceField(float X,float Y,float Z) const
     {
         if(!Owner||!Owner->Manager||!Owner->Generator)return false;
-        const FIntVector ChunkCoord(FMath::FloorToInt(X/static_cast<float>(CHUNK_SIZE)),
-            FMath::FloorToInt(Y/static_cast<float>(CHUNK_SIZE)),
-            FMath::FloorToInt(Z/static_cast<float>(CHUNK_SIZE)));
+        const float CoreVoxelsPerOwnerChunk=static_cast<float>(GetCoreVoxelsPerOwnerChunk());
+        const FIntVector ChunkCoord(FMath::FloorToInt(X/CoreVoxelsPerOwnerChunk),
+            FMath::FloorToInt(Y/CoreVoxelsPerOwnerChunk),
+            FMath::FloorToInt(Z/CoreVoxelsPerOwnerChunk));
         return Owner->Manager->GetGeneratorTypeForChunk(ChunkCoord)
             ==ECaveGeneratorType::SurfaceWorld;
     }
@@ -2351,19 +2436,26 @@ private:
         int32 Top=MIN_int32,Bottom=MAX_int32;
         for(const FStrateSlot& Slot:Layout)
         {
+            const int32 MidChunkZ=(Slot.TopChunkZ+Slot.BottomChunkZ)/2;
+            // A manifest-backed FloatingIslands stratum supplies its own sparse island
+            // field; it must not extend the legacy solid envelope across the open sky.
+            if(bUseNativeManifestFields
+                &&Owner->Manager->GetGeneratorTypeForChunk(FIntVector(0,0,MidChunkZ))
+                    ==ECaveGeneratorType::FloatingIslands)
+                continue;
             Top=std::max(Top,Slot.TopChunkZ);Bottom=std::min(Bottom,Slot.BottomChunkZ);
             if(!Slot.Definition)continue;
-            const int32 MidChunkZ=(Slot.TopChunkZ+Slot.BottomChunkZ)/2;
             FLayerField Field;
-            Field.Lo=Slot.BottomChunkZ*CHUNK_SIZE;
-            Field.Hi=(Slot.TopChunkZ+1)*CHUNK_SIZE;
+            Field.Lo=OwnerChunkLowerBoundaryCoreVoxel(Slot.BottomChunkZ);
+            Field.Hi=OwnerChunkUpperBoundaryCoreVoxel(Slot.TopChunkZ+1);
             Field.StrateIndex=Slot.StrateIndex;
             Field.Params=Owner->Manager->GetGenerationParams(FIntVector(0,0,MidChunkZ));
             LayerFields.push_back(std::move(Field));
         }
         if(Top>=Bottom)
         {
-            LayerRanges.push_back({Bottom*CHUNK_SIZE,(Top+1)*CHUNK_SIZE});
+            LayerRanges.push_back({OwnerChunkLowerBoundaryCoreVoxel(Bottom),
+                OwnerChunkUpperBoundaryCoreVoxel(Top+1)});
         }
     }
 
@@ -3474,8 +3566,9 @@ private:
         auto Unit=[&](uint32 H){return static_cast<double>(Hash(H)>>8)*(1.0/16777216.0);};
         for(const FStrateSlot& Slot:Layout)
         {
-            const double ZBottom=static_cast<double>(Slot.BottomChunkZ)*CHUNK_SIZE;
-            const double ZTop=static_cast<double>(Slot.TopChunkZ+1)*CHUNK_SIZE;
+            const double CoreVoxelsPerOwnerChunk=GetCoreVoxelsPerOwnerChunk();
+            const double ZBottom=static_cast<double>(Slot.BottomChunkZ)*CoreVoxelsPerOwnerChunk;
+            const double ZTop=static_cast<double>(Slot.TopChunkZ+1)*CoreVoxelsPerOwnerChunk;
             for(int32 GY=GY0;GY<=GY1;++GY)for(int32 GX=GX0;GX<=GX1;++GX)
             {
                 uint32 H=Hash(Seed^static_cast<uint32>(GX)*0x9E3779B9u

Standalone/Core/src/VoxelForgeCore.cpp

@@ -1162,8 +1162,13 @@ namespace VoxelForgeCore
 
         const std::int64_t tileMinimum[3]={boundsMin.X,boundsMin.Y,boundsMin.Z};
         const std::int64_t tileMaximum[3]={boundsMax.X,boundsMax.Y,boundsMax.Z};
-        const int32 firstSurfaceChunk=FloorDiv(boundsMin.Z,CHUNK_SIZE);
-        const int32 lastSurfaceChunk=FloorDiv(boundsMax.Z,CHUNK_SIZE);
+        const double coreVoxelsPerOwnerChunk=static_cast<double>(CHUNK_SIZE)
+            *static_cast<double>(impl_->owner->OwnerVoxelSizeMicrons)
+            /static_cast<double>(std::max(1u,impl_->owner->CoreVoxelSizeMicrons));
+        const int32 firstSurfaceChunk=FMath::FloorToInt(
+            static_cast<double>(boundsMin.Z)/coreVoxelsPerOwnerChunk);
+        const int32 lastSurfaceChunk=FMath::FloorToInt(
+            static_cast<double>(boundsMax.Z)/coreVoxelsPerOwnerChunk);
         const WorldAssemblyStratumPlanV1* selectedPlan=nullptr;
         for(int32 chunkZ=firstSurfaceChunk;chunkZ<=lastSurfaceChunk;++chunkZ)
         {
@@ -1183,9 +1188,6 @@ namespace VoxelForgeCore
         if(!selectedPlan||!Heightfield2D(impl_->worldAssembly->recipe,*selectedPlan).isValid())
             return false;
 
-        const double coreVoxelsPerOwnerChunk=static_cast<double>(CHUNK_SIZE)
-            *static_cast<double>(impl_->owner->OwnerVoxelSizeMicrons)
-            /static_cast<double>(std::max(1u,impl_->owner->CoreVoxelSizeMicrons));
         const int32 firstIslandChunk=FMath::FloorToInt(
             static_cast<double>(boundsMin.Z)/coreVoxelsPerOwnerChunk);
         const int32 lastIslandChunk=FMath::FloorToInt(

Standalone/Research/WorldAssemblerM3/Linux15/REPORT.md

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

Standalone/Research/WorldAssemblerM3/Linux16/REPORT.md

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

Standalone/Research/WorldAssemblerM3/Linux17/BoundaryProbe.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Measure upward mesh faces around the FI/SW stratum interface."""
+import array
+import collections
+import math
+import struct
+import sys
+
+
+def read_exact(stream, size):
+    data = stream.read(size)
+    if len(data) != size:
+        raise EOFError(f"wanted {size} bytes, got {len(data)}")
+    return data
+
+
+path = sys.argv[1]
+low_z = float(sys.argv[2]) if len(sys.argv) > 2 else -80.0
+high_z = float(sys.argv[3]) if len(sys.argv) > 3 else -45.0
+with open(path, "rb") as stream:
+    if read_exact(stream, 8) != b"VFMSH001":
+        raise SystemExit("bad VFMSH001 header")
+    version, voxel_um, tile_count = struct.unpack("<3I", read_exact(stream, 12))
+    camera = struct.unpack("<3d", read_exact(stream, 24))
+    yaw, pitch = struct.unpack("<2d", read_exact(stream, 16))
+    per_lod = collections.defaultdict(lambda: {"tiles": 0, "faces": [], "spans": []})
+    near_tiles = collections.defaultdict(list)
+    for _ in range(tile_count):
+        key = struct.unpack("<4i", read_exact(stream, 16))
+        surf_vertices, skirt_count, vertex_count, index_count, mask_count = struct.unpack(
+            "<5I", read_exact(stream, 20))
+        p = array.array("f")
+        p.frombytes(read_exact(stream, vertex_count * 12))
+        n = array.array("f")
+        n.frombytes(read_exact(stream, vertex_count * 12))
+        if sys.byteorder != "little":
+            p.byteswap(); n.byteswap()
+        indices = array.array("I")
+        indices.frombytes(read_exact(stream, index_count * 4))
+        masks = read_exact(stream, mask_count)
+        if sys.byteorder != "little":
+            indices.byteswap()
+        lod = key[3]
+        z_values = []
+        for tri in range(index_count // 3):
+            if masks and masks[tri] != 0:
+                continue
+            a, b, c = indices[tri * 3:tri * 3 + 3]
+            if max(a, b, c) >= surf_vertices:
+                continue
+            normal_z = (n[a * 3 + 2] + n[b * 3 + 2] + n[c * 3 + 2]) / 3.0
+            if normal_z < 0.65:
+                continue
+            z = (p[a * 3 + 2] + p[b * 3 + 2] + p[c * 3 + 2]) / 3.0
+            if low_z <= z <= high_z:
+                z_values.append(z)
+        if not z_values:
+            continue
+        z_values.sort()
+        row = per_lod[lod]
+        row["tiles"] += 1
+        row["faces"].extend(z_values)
+        span = z_values[math.floor(.95 * (len(z_values) - 1))] - z_values[math.floor(.05 * (len(z_values) - 1))]
+        row["spans"].append(span)
+        extent = 32 * (1 << lod) * voxel_um / 1_000_000.0
+        cx = (key[0] + 0.5) * extent
+        cy = (key[1] + 0.5) * extent
+        near_tiles[lod].append((math.hypot(cx - camera[0], cy - camera[1]), key,
+                                z_values[len(z_values) // 2], span, len(z_values)))
+
+
+def q(values, fraction):
+    return values[math.floor(fraction * (len(values) - 1))] if values else math.nan
+
+
+print(f"camera_m={camera} yaw={yaw} pitch={pitch} boundary_band_m={low_z}..{high_z}")
+print("lod tiles_with_boundary_faces faces z_m_p05/median/p95 tile_span_m_p50/p95/max")
+for lod in sorted(per_lod):
+    row = per_lod[lod]
+    spans = sorted(row["spans"])
+    print(f"{lod} {row['tiles']} {len(row['faces'])} "
+          f"{q(sorted(row['faces']), .05):.4f}/{q(sorted(row['faces']), .5):.4f}/"
+          f"{q(sorted(row['faces']), .95):.4f} "
+          f"{q(spans, .5):.4f}/{q(spans, .95):.4f}/{max(spans):.4f}")
+print("nearest_xy_boundary_tiles_by_lod:")
+for lod in sorted(near_tiles):
+    for distance, key, median, span, faces in sorted(near_tiles[lod])[:3]:
+        print(f"lod={lod} key={key} xy_distance_m={distance:.2f} "
+              f"boundary_median_z={median:.4f} within_tile_p05_p95_m={span:.4f} faces={faces}")

Standalone/Research/WorldAssemblerM3/Linux17/FloatingIslandDensityProbe.cpp

@@ -0,0 +1,143 @@
+#include "Json.h"
+#include "StandaloneCoreScheduler.h"
+#include "StandaloneSnapshotAdapter.h"
+#include "VoxelForgeCore/VoxelForgeCore.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <fstream>
+#include <iterator>
+#include <string>
+
+namespace
+{
+    constexpr double CoreVoxelsPerMeter = 4.0;
+    constexpr std::int64_t QPerCoreVoxel = VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
+
+    std::int64_t ToQ(double Meters)
+    {
+        return static_cast<std::int64_t>(std::llround(Meters*CoreVoxelsPerMeter*QPerCoreVoxel));
+    }
+
+    void PrintLegacyBoundarySealTerms(const VoxelForgeCore::FloatingIslandManifestV1& Manifest,
+        double X, double Y, double Z)
+    {
+        using namespace VoxelForgeCore;
+        const auto Xq=ToQ(X),Yq=ToQ(Y),Zq=ToQ(Z);
+        const FloatingIslandFieldV1 field(Manifest.recipe,Manifest.plan);
+        const std::int64_t fieldQ=field.densitySubvoxels(Xq,Yq,Zq);
+        const std::int64_t bottom=Manifest.recipe.layoutMinimumZSubvoxels;
+        const std::int64_t top=Manifest.recipe.layoutMaximumZSubvoxels;
+        const std::int64_t seal=Manifest.recipe.boundarySealSubvoxels;
+        std::int64_t bridged=fieldQ;
+        bool applied=false;
+        if(Zq>=bottom&&Zq<bottom+seal)
+        {bridged=std::min(bridged,-std::max<std::int64_t>(1,Zq-bottom));applied=true;}
+        if(Zq<=top&&Zq>top-seal)
+        {bridged=std::min(bridged,-std::max<std::int64_t>(1,top-Zq));applied=true;}
+        std::printf("[PreFixIslandTerms] xyz_m=%.3f,%.3f,%.3f native_field_q=%lld "
+            "legacy_solid_seal_delta_q=%lld legacy_seal_active=%d pre_fix_wrapper_q=%lld\n",
+            X,Y,Z,static_cast<long long>(fieldQ),
+            static_cast<long long>(bridged-fieldQ),applied?1:0,static_cast<long long>(bridged));
+        for(const auto& island:Manifest.plan.islands)
+        {
+            const bool inBounds=Xq>=island.influenceMinimumSubvoxels[0]
+                &&Xq<=island.influenceMaximumSubvoxels[0]
+                &&Yq>=island.influenceMinimumSubvoxels[1]
+                &&Yq<=island.influenceMaximumSubvoxels[1]
+                &&Zq>=island.influenceMinimumSubvoxels[2]
+                &&Zq<=island.influenceMaximumSubvoxels[2];
+            std::printf("[IslandGroup] ordinal=%u center_m=%.3f,%.3f,%.3f "
+                "bounds_contains_sample=%d\n",
+                island.ordinal,island.centerSubvoxels[0]/1024.0,island.centerSubvoxels[1]/1024.0,
+                island.centerSubvoxels[2]/1024.0,inBounds?1:0);
+        }
+        for(const auto& edge:Manifest.plan.clusterEdges)
+        {
+            bool inBounds=true;
+            const std::int64_t q[3]={Xq,Yq,Zq};
+            for(std::size_t axis=0;axis<3;++axis)
+                inBounds=inBounds&&q[axis]>=edge.influenceMinimumSubvoxels[axis]
+                    &&q[axis]<=edge.influenceMaximumSubvoxels[axis];
+            std::printf("[IslandConnector] id=%016llx bounds_contains_sample=%d\n",
+                static_cast<unsigned long long>(edge.stableId),inBounds?1:0);
+        }
+    }
+}
+
+void PrintDensityLine(VoxelForgeCore::World& World,const char* Label,
+    double X,double Y,double ZMinimum,double ZMaximum,double Step)
+{
+    using namespace VoxelForgeCore;
+    std::printf("[DensityLine] label=%s xy_m=(%.6f,%.6f) z_m=%.2f..%.2f step_m=%.2f\n",
+        Label,X,Y,ZMinimum,ZMaximum,Step);
+    for(double Z=ZMinimum;Z<=ZMaximum+1.0e-9;Z+=Step)
+    {
+        const Vec3d Point{X*CoreVoxelsPerMeter,Y*CoreVoxelsPerMeter,
+            Z*CoreVoxelsPerMeter};
+        const double Density=World.densityAt(Point);
+        const double Unclamped=World.unclampedDensityAt(Point);
+        const DetailFieldSample Detail=World.detailSampleAt(Point);
+        std::printf("[DensitySample] label=%s xyz_m=%.3f,%.3f,%.3f density_core_vox=%.9f "
+            "density_cm=%.3f unclamped_core_vox=%.9f cave_influence=%.6f "
+            "floor_influence=%.6f detail_displacement=%.6f sign=%s\n",Label,X,Y,Z,
+            Density,Density*25.0,Unclamped,Detail.caveInfluence,Detail.floorInfluence,
+            Detail.displacement,Density<0.0?"solid":"air");
+    }
+}
+
+int main(int argc,char** argv)
+{
+    if(argc!=2)
+    {
+        std::fprintf(stderr,"usage: %s owner-world-with-world-assembly.json\n",argv[0]);
+        return 2;
+    }
+    VFJson::Value root;
+    std::string error;
+    if(!VFJson::Load(argv[1],root,error))
+    {std::fprintf(stderr,"owner JSON parse failed: %s\n",error.c_str());return 2;}
+    auto snapshot=VoxelForgeCore::MakeStandaloneSnapshotFromParsedJson(root,0,3,8,false,false,error);
+    if(!snapshot)
+    {std::fprintf(stderr,"snapshot resolve failed: %s\n",error.c_str());return 2;}
+    const auto* assembly=snapshot.worldAssembly();
+    if(!assembly||assembly->floatingIslands.empty())
+    {std::fprintf(stderr,"FloatingIslands manifest missing\n");return 2;}
+
+    VoxelForgeCore::World world(std::move(snapshot));
+    VoxelForgeCore::ShapeBuildRequest request;
+    request.minVoxel={-96,-512,-288};
+    request.maxVoxel={96,96,64};
+    request.clipMinVoxel=request.minVoxel;
+    request.clipMaxVoxel=request.maxVoxel;
+    request.workerLimit=12;
+    request.includeFarWorld=false;
+    FStandaloneCoreScheduler scheduler;
+    if(!world.compile(request,scheduler,error))
+    {std::fprintf(stderr,"shape compile failed: %s\n",error.c_str());return 2;}
+
+    constexpr double FlatX=-11.612443923950195;
+    constexpr double FlatY=-118.22123718261719;
+    constexpr double IslandX=-6.3;
+    constexpr double IslandY=-19.057;
+    constexpr double RingX=-4.889;
+    constexpr double RingY=-16.008;
+    std::printf("[DensityRoute] flat_square_xy_m=(%.6f,%.6f) island_ground_xy_m=(%.6f,%.6f) "
+        "compiled=%d core_voxel_size_m=0.25 owner_to_core_chunk_voxels=16\n",
+        FlatX,FlatY,IslandX,IslandY,world.isCompiled()?1:0);
+    PrintDensityLine(world,"flat-square",FlatX,FlatY,2.5,9.0,0.25);
+    PrintDensityLine(world,"fi-sw-boundary",FlatX,FlatY,-62.0,-58.0,0.25);
+    PrintDensityLine(world,"island-center",IslandX,IslandY,-39.0,-20.0,0.5);
+    PrintDensityLine(world,"lod0-lod1-ring-edge",RingX,RingY,-62.0,-20.0,1.0);
+
+    const auto& island=assembly->floatingIslands.front().manifest;
+    for(double z:{2.75,2.99,3.00,3.01,3.25,3.49,3.50,3.51,3.75,3.99,4.00,4.01,7.75,8.00,8.25})
+        PrintLegacyBoundarySealTerms(island,FlatX,FlatY,z);
+    for(double z:{-35.0,-30.0,-25.0})
+        PrintLegacyBoundarySealTerms(island,IslandX,IslandY,z);
+    for(double z:{-60.0,-35.0,-28.0,-25.0})
+        PrintLegacyBoundarySealTerms(island,RingX,RingY,z);
+    return 0;
+}

Standalone/Research/WorldAssemblerM3/Linux17/MeasureBuild.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Measure peak per-process RSS for a build process tree under the L17 limits."""
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def descendants(root):
+    pending = [root]
+    seen = set()
+    while pending:
+        pid = pending.pop()
+        if pid in seen:
+            continue
+        seen.add(pid)
+        try:
+            children = Path(f"/proc/{pid}/task/{pid}/children").read_text().split()
+            pending.extend(int(child) for child in children)
+        except (FileNotFoundError, PermissionError, ProcessLookupError):
+            pass
+    return seen
+
+
+def status(pid):
+    try:
+        fields = {}
+        for line in Path(f"/proc/{pid}/status").read_text().splitlines():
+            if line.startswith(("Name:", "VmRSS:", "VmSize:")):
+                key, *value = line.split()
+                fields[key[:-1]] = value[0] if value else ""
+        return (int(fields.get("VmRSS", "0")), int(fields.get("VmSize", "0")),
+                fields.get("Name", ""))
+    except (FileNotFoundError, PermissionError, ProcessLookupError, ValueError):
+        return None
+
+
+if len(sys.argv) < 2:
+    raise SystemExit("usage: MeasureBuild.py command [arguments ...]")
+if not os.sched_getaffinity(0).issubset(set(range(12))):
+    raise SystemExit("run under taskset -c 0-11")
+
+started = time.monotonic()
+process = subprocess.Popen(sys.argv[1:], start_new_session=True)
+peak_rss = (0, 0, "")
+peak_vms = (0, 0, "")
+while process.poll() is None:
+    for pid in descendants(process.pid):
+        measured = status(pid)
+        if measured is None:
+            continue
+        rss, vms, name = measured
+        if rss > peak_rss[0]:
+            peak_rss = (rss, pid, name)
+        if vms > peak_vms[0]:
+            peak_vms = (vms, pid, name)
+    time.sleep(0.1)
+
+exit_code = process.wait()
+elapsed = time.monotonic() - started
+print(f"[BuildTreeResources] exit_code={exit_code} wall_s={elapsed:.3f} "
+      f"peak_process_rss_kib={peak_rss[0]} peak_rss_pid={peak_rss[1]} "
+      f"peak_rss_name={peak_rss[2]} peak_process_vms_kib={peak_vms[0]} "
+      f"peak_vms_pid={peak_vms[1]} peak_vms_name={peak_vms[2]} "
+      "monitor_interval_s=0.1", flush=True)
+raise SystemExit(exit_code)

Standalone/Research/WorldAssemblerM3/Linux17/MeshProbe.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""Summarize exported tile geometry and upward-facing ground for L17."""
+import array
+import collections
+import math
+import struct
+import sys
+
+
+def read_exact(stream, size):
+    data = stream.read(size)
+    if len(data) != size:
+        raise EOFError(f"wanted {size} bytes, got {len(data)}")
+    return data
+
+
+path = sys.argv[1]
+with open(path, "rb") as stream:
+    if read_exact(stream, 8) != b"VFMSH001":
+        raise SystemExit("bad VFMSH001 header")
+    version, voxel_um, tile_count = struct.unpack("<3I", read_exact(stream, 12))
+    camera = struct.unpack("<3d", read_exact(stream, 24))
+    yaw, pitch = struct.unpack("<2d", read_exact(stream, 16))
+    per_lod = collections.defaultdict(lambda: {"tiles": 0, "vertices": 0,
+        "triangles": 0, "surface_triangles": 0, "up_triangles": 0,
+        "up_centroids": [], "tile_spans": [], "empty": 0})
+    tile_rows = []
+    for _ in range(tile_count):
+        key = struct.unpack("<4i", read_exact(stream, 16))
+        surf_vertices, skirt_count, vertex_count, index_count, mask_count = struct.unpack(
+            "<5I", read_exact(stream, 20))
+        p = array.array("f")
+        p.frombytes(read_exact(stream, vertex_count * 12))
+        n = array.array("f")
+        n.frombytes(read_exact(stream, vertex_count * 12))
+        if sys.byteorder != "little":
+            p.byteswap(); n.byteswap()
+        indices = array.array("I")
+        indices.frombytes(read_exact(stream, index_count * 4))
+        masks = read_exact(stream, mask_count)
+        if sys.byteorder != "little":
+            indices.byteswap()
+        lod = key[3]
+        row = per_lod[lod]
+        row["tiles"] += 1
+        row["vertices"] += vertex_count
+        row["triangles"] += index_count // 3
+        row["surface_triangles"] += index_count // 3 - skirt_count
+        up = []
+        for tri in range(index_count // 3):
+            if masks and masks[tri] != 0:
+                continue
+            a, b, c = indices[tri * 3:tri * 3 + 3]
+            if max(a, b, c) >= surf_vertices:
+                continue
+            if (n[a * 3 + 2] + n[b * 3 + 2] + n[c * 3 + 2]) / 3.0 < 0.65:
+                continue
+            up.append((p[a * 3 + 2] + p[b * 3 + 2] + p[c * 3 + 2]) / 3.0)
+        row["up_triangles"] += len(up)
+        row["up_centroids"].extend(up)
+        if up:
+            up.sort()
+            span = up[math.floor(0.95 * (len(up) - 1))] - up[math.floor(0.05 * (len(up) - 1))]
+            row["tile_spans"].append(span)
+            tile_rows.append((key, vertex_count, index_count // 3, skirt_count,
+                              len(up), up[0], up[len(up) // 2], up[-1], span))
+        else:
+            row["empty"] += 1
+            tile_rows.append((key, vertex_count, index_count // 3, skirt_count,
+                              0, math.nan, math.nan, math.nan, math.nan))
+
+print(f"version={version} voxel_um={voxel_um} tiles={tile_count} camera_m={camera} yaw={yaw} pitch={pitch}")
+print("lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles "
+      "upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max")
+for lod in sorted(per_lod):
+    r = per_lod[lod]
+    z = sorted(r["up_centroids"])
+    s = sorted(r["tile_spans"])
+    def q(values, fraction):
+        return values[math.floor(fraction * (len(values) - 1))] if values else math.nan
+    print(f"{lod} {r['tiles']} {r['tiles']-r['empty']} {r['vertices']} {r['triangles']} "
+          f"{sum(row[3] for row in tile_rows if row[0][3] == lod)} {r['up_triangles']} "
+          f"{q(z,.05):.4f}/{q(z,.5):.4f}/{q(z,.95):.4f} "
+          f"{q(s,.5):.4f}/{q(s,.95):.4f}/{max(s) if s else math.nan:.4f}")
+
+print("near_camera_up_tiles (sorted by XY tile-centre distance):")
+near = []
+for row in tile_rows:
+    key = row[0]
+    lod = key[3]
+    extent = 32 * (1 << lod) * voxel_um / 1_000_000.0
+    cx = (key[0] + 0.5) * extent
+    cy = (key[1] + 0.5) * extent
+    near.append((math.hypot(cx-camera[0], cy-camera[1]), row))
+for distance, row in sorted(near)[:30]:
+    key, verts, tris, skirts, ups, lo, med, hi, span = row
+    if ups:
+        print(f"key={key} xy_distance_m={distance:.2f} vertices={verts} triangles={tris} "
+              f"skirt_triangles={skirts} upward_triangles={ups} z_m={lo:.3f}/{med:.3f}/{hi:.3f} "
+              f"tile_span_p05_p95_m={span:.3f}")

Standalone/Research/WorldAssemblerM3/Linux17/OWNER_NOTE.md

@@ -0,0 +1,26 @@
+# Owner note — L17 FloatingIslands steps
+
+The ledges were real generated mesh geometry caused by two boundary mistakes that made empty space
+look like flat ground: the FloatingIslands seal was applied as a solid cap across XY, and owner
+chunks were treated as 8 m of Core voxels instead of their actual 4 m. At the measured flat square,
+the native island field is air and cave/floor influence is zero. The point is about 100 m from the
+four islands.
+
+I removed the false cap and corrected the shared owner/Core coordinate conversion. Evaluator version
+is 7. The before/after captures show the false sheet disappear and the actual island shape remain.
+SurfaceWorld’s L1 hash changes because it now selects its intended `Heightfield2D` route; its route,
+readiness and proof audits pass.
+
+The export has nonempty meshes at LOD0–8, and the standalone viewer enables and draws all levels by
+default. I cannot identify the screenshot’s dark square as a whole missing LOD from the Linux data;
+it may be a specific tile or viewer draw/upload issue. I did not change the Windows viewer. Please
+capture the view below and, if the square remains, repeat with `--capture-only-lod=0` through `8`.
+
+The low-view camera is `(-22,-19,-22.8) m`, yaw 0°, pitch −4°, matching the Linux island pair.
+
+```bat
+VoxelForgeCoreStandalone.exe --world-assembler-prototype --recipe=floating-islands --clip-radius=3 --max-clip-level=8 --workers=12 --camera=-22,-19,-22.8,0,-4 --capture=Standalone\Research\WorldAssemblerM3\Linux17\captures\floating-islands-windows.png --frame-limit=60
+```
+
+Use a different `--capture=` filename for each isolated LOD. Send the all-level image plus the
+isolated image that corresponds to the square.

Standalone/Research/WorldAssemblerM3/Linux17/REPORT.md

@@ -0,0 +1,182 @@
+# VoxelForge L17 — FloatingIslands boundary report
+
+Branch `assembler/world`, starting HEAD `9a7c87e`. No cache code was changed. The shared evaluator
+version is now 7; the recipe schema stays at 1.
+
+## Cause and fix
+
+FloatingIslands uses the sparse `FloatingIslandFieldV1` manifest field. SurfaceWorld uses the
+separate planar `Heightfield2D` field. The owner voxel is 12.5 cm and the Core voxel is 25 cm, so
+one 32-voxel owner chunk is **16 Core voxels / 4 m**. Several shared paths divided Core positions
+by 32 directly, treating that chunk as 8 m. That doubled stratum bounds, selected the wrong
+generator route near the SurfaceWorld boundary, and made the legacy layer envelope extend over
+empty FloatingIslands space.
+
+The FloatingIslands `boundarySeal` also had been applied as a solid cap over all XY. At the owner’s
+flat-square probe `(-11.612444,-118.221237) m`, the raw island field is air: at Z=3.25 m it was
+`+81,809` subvoxels. The old seal added `−82,065`, yielding `−256` (`−1` Core voxel, or −25 cm);
+at Z=3.50 m it yielded `−1` subvoxel (−0.098 cm), then air again at Z=3.75 m. The wrong 8 m
+legacy layer bound produced a second false top near Z=8 m (old world density at 7.75 m was
+−0.743 Core voxels; at 8 m it was +0.073). The owner’s 4.5 m LOD0 jump is real mesh geometry
+created by those bad boundaries, often inside a tile; it is not a renderer artifact or island relief.
+Nested clipmap rectangles made its placement look like a tile-boundary-only issue.
+
+The fix uses the resolved owner/Core scale for manager lookups, layer bounds, readiness, and
+adjacent native strata; removes the XY-wide FloatingIslands seal cap and its all-solid proof; and
+clips adjacent native FI/SW signed-distance fields at their shared physical boundary. This is in
+Core and applies to every generator route. SurfaceWorld still uses `Heightfield2D`.
+
+The cave-floor lead does not match the samples. Cave and floor influence were exactly zero at the
+flat square, the island center, and the sampled ledge/ring point. The native FI field and its island
+or connector bounds account for the surface. The owner world compiled 70 rooms, 69 tunnels and 2
+passages in this run; those legacy primitives do not contribute to the measured FI ledge.
+
+## Before/after measurements
+
+`RingProbe.py` samples upward-facing mesh surfaces on adjacent XY tile edges only when the tiles’
+vertical bands overlap. Values are median / p95 / maximum absolute height difference, in cm. `n/a`
+means this sparse-island export had no same-band LOD0↔1 surface pair after removing the false cap;
+it is not a zero-error result. Higher rings include the deep SurfaceWorld boundary and other deep
+surfaces, so those rows are not all FloatingIslands ground.
+
+| LOD edge | Before (cm) | After (cm) |
+|---|---:|---:|
+| 0→1 | 3.451 / 8.920 / 449.158 (266 samples) | n/a (no same-band pair) |
+| 1→2 | 26.642 / 148.262 / 149.862 (514) | 0 / 0 / 0 (234) |
+| 2→3 | 0.134 / 198.730 / 773.318 (596) | 0 / 0 / 0 (207) |
+| 3→4 | 3.269 / 47.875 / 188.531 (277) | 0 / 0 / 0 (288) |
+| 4→5 | 29.975 / 130.496 / 445.444 (544) | 0 / 0 / 30.957 (258) |
+| 5→6 | 12.234 / 127.224 / 536.573 (266) | 12.234 / 127.224 / 536.573 (266) |
+| 6→7 | 29.013 / 301.752 / 42,624.479 (264) | 28.892 / 291.861 / 945.477 (264) |
+| 7→8 | 83.843 / 1,225.416 / 3,755.407 (275) | 83.843 / 1,225.416 / 3,755.407 (275) |
+
+The valid worst pre-fix LOD0↔1 sample is the false cap: 3.500 m vs 7.992 m, a 449.158 cm
+difference. Upward-face within-tile span p95 / maximum changed from 4.490 / 4.491 m to 1.186 /
+1.927 m on LOD0. The remaining LOD0 span is the actual island shape. LOD1–3 after-fix upward
+faces at the measured lower boundary are exactly at −60 m. The island tops around the matched
+camera are roughly −30 to −25 m.
+
+A separate exploratory column comparison initially reported a 34.7 m difference by pairing an
+island top near −25 m with a −60 m SurfaceWorld surface from a vertically disjoint tile. That
+comparison was rejected: it is not a same-band ring seam. The saved `RingProbe.py` output is the
+cross-LOD evidence used above.
+
+## History, viewer and SurfaceWorld
+
+Prebuilt L7, L9, L12, L13 and L14 binaries/logs all have the same legacy hashes: whole-view D/M/P/T
+`92ba6a57a8690c00 / 9c6b56dfab6241c9 / 82394dd7c368a061 / 445e40bdb69b0bdb`; full-detail
+`93ee3b6fb6b446f3 / 3ebc72d2027ab80b / cd5f55a96de12458 / 2f61c29af247b547`. The pattern
+predates L7; these measurements show no output change at L9 or L13. S9 `e7586a1`, S12 `212814a`
+and S14 `ec2afe9` do not contain the headless pipeline source, so they cannot be measured this way.
+No old commit was rebuilt: `git worktree add` failed because `.git/worktrees` is read-only, and the
+available old binaries were used as-is.
+
+The headless mesh export has nonempty tiles at **all** LODs 0–8 (matched view counts:
+15, 64, 40, 48, 48, 96, 48, 48, 153). The standalone viewer initializes all nine `bShowLevel`
+flags to true and its draw loop visits all streaming batches. There is no evidence that a whole LOD
+is absent from generated data or globally filtered by the viewer. The screenshot’s dark square
+cannot be mapped to a particular tile/LOD from this Linux export; a localized viewer draw/upload
+or camera issue remains unconfirmed. No viewer change was made because the Windows D3D11 build and
+capture are unavailable here. The Unreal comparison does not identify the cause of that square.
+
+SurfaceWorld L1 hashes changed for the shared coordinate fix. Old L14 LOD1 D/M/P/T was
+`5043975b1e5b5a3d / 1c2a5658f10fdeaa / 23b6779ef35c3a0a / 1a6d2e2d152b4f84`; L17 is
+`393ad79fd8c07132 / 47c9ba17e9f5ceaa / d5d6a948ac880e17 / 8b85ea08b2c440c4`. Before, readiness
+was 0/27; now it is 27/27 on the near ring. The old mapping selected the wrong route at the
+SurfaceWorld stratum; the corrected mapping selects its manifest `Heightfield2D` plan. Page/native
+route parity and exact queries pass, so this is the intended shared-route output change.
+
+## Gates, captures and limits
+
+All 28 determinism rows passed: FI and SW, Clang 19 `-ffp-contract=off` and GCC 14 default,
+W1/W8/W12 with five W12 repeats. Each recipe had one unique full, whole, nine-LOD and exact-query
+hash tuple across all configurations. FI whole-view D/M/P/T is
+`8339509b4d5ec231 / 70e5b2b9085b517c / 4e72e53745f20ed0 / 1a2643e5138e0407`; SW whole-view is
+`b286ee4f4c38b7fc / 6862deb8ab9c2af9 / f23480a4953457f9 / 62977edfd04b3afe`.
+
+FI route parity: 8 page pairs, 14 higher-LOD exact pairs, 782,026 exact samples, zero mismatches;
+uniform proof: 19,288 blocks / 25,672,328 samples / zero violations. SW: 5 page and 9 native-only
+pairs, 814,625 exact samples, zero mismatches; uniform proof: 13,297 blocks / 17,698,307 samples /
+zero violations. Readiness negative controls were caught. The Clang FP-contraction-off and GCC
+default builds passed; the Core startup FP self-test did not reject either. No async/MPSC/Epoch
+code changed; `FLazy`, shared column caches, L9/L12 proof paths and L13 route binding remain in the
+tested build.
+
+Readable Linux capture mode adds directional light with soft ambient, gentle height tint, and an
+optional faint tile-edge overlay. Five 1600×900 JPEGs, all below 300 KB, are in `captures/`:
+
+- `floating-islands-flat-square-before.jpg` / `floating-islands-flat-square-after.jpg`: same owner
+  probe camera `(-11.6124,-118.2212,-19.8452) m`, yaw 0, pitch 0, before/after.
+- `floating-islands-island-view-before.jpg` / `floating-islands-island-view-after.jpg`: same low
+  island camera `(-22,-19,-22.8) m`, yaw 0, pitch −4°, before/after.
+- `surface-world-l1-readable-tiles.jpg`: SurfaceWorld L1 sanity view, camera `(0,-35,30) m`, yaw 0,
+  pitch −60°.
+
+All are 1600×900 JPEGs; SHA256 is included for byte-level review.
+
+| Capture | Bytes | SHA256 |
+|---|---:|---|
+| `floating-islands-flat-square-before.jpg` | 70,166 | `c41ed7645735ebefea97fbc1aed167b66a3e06c019c25b1c7d8cae9449713999` |
+| `floating-islands-flat-square-after.jpg` | 47,612 | `f8fb5f937ac65be9db70a41473c7a10d7f35943ba6ef5c94ab03fde9ded5c544` |
+| `floating-islands-island-view-before.jpg` | 70,813 | `5c7a8eda446f51a51ab22e45ed7286bf4180e69d8e3b2180780349facadacd32` |
+| `floating-islands-island-view-after.jpg` | 51,429 | `3aeedef903fce62e81ea1f07bb460dd2beb42b893bbd9bf29220973951295b4c` |
+| `surface-world-l1-readable-tiles.jpg` | 53,351 | `23f1753ed100c87607e22d2adc4f8e8a2856b8af3f1d37aa4f4cec9420a92b93` |
+
+Clang/GCC compile peak RSS was 435,588 / 902,000 KiB. Determinism peak was 538,140 KiB; FI/SW
+route-audit peaks were 621,404 / 763,112 KiB. The governor remained `powersave`; runs were limited
+to CPUs 0–11, at most 12 workers, 6 GiB address space; llvmpipe used 12 threads.
+
+## Failed or retried attempts
+
+- The first headless invocation omitted the explicit owner-world input; it was rerun with
+  `Standalone/data/owner_world.json`.
+- An initial SurfaceWorld export failed the native-only readiness guard; corrected owner/Core
+  mapping and rerun passed.
+- A SurfaceWorld `--max-clip-level=1` attempt expanded to 35,435,983 tiles and failed the bounded
+  compiler (20.985 s, 3,988,160 KiB peak RSS). Retried with `--max-level=1` (960 tiles), which
+  passed.
+- `BoundaryProbe.py` was first called with unsupported named Z arguments; rerun with positional
+  bounds passed.
+- The first XY-only ring comparison mixed vertically disjoint surfaces; replaced by the
+  overlapping-band `RingProbe.py` used above. The exploratory column probe was also rejected for
+  pairing different vertical bands.
+- The first offscreen SurfaceWorld command reversed scene/output arguments and failed to open the
+  mesh; rerun with the documented order passed.
+- The first density-probe invocation used `Standalone/data/owner_world.json` without a resolved FI
+  manifest and failed. It was rerun with `Saved/Linux/l17-fi-owner-snapshot.json` and passed.
+- `/usr/bin/time` was unavailable and an early process monitor mishandled a zombie child; the
+  process-tree monitor in `MeasureBuild.py` replaced both attempts.
+- `git worktree add` could not write `.git/worktrees`; no worktree was created and no old commit was
+  built outside the repository.
+- Mesa could not create `/home/jahni/.cache` in the read-only environment, disabled shader caching,
+  and completed all captures. No file was written outside the repository.
+
+## Windows confirmation
+
+Run from the repository root on Windows to capture the low island view:
+
+```bat
+VoxelForgeCoreStandalone.exe --world-assembler-prototype --recipe=floating-islands --clip-radius=3 --max-clip-level=8 --workers=12 --camera=-22,-19,-22.8,0,-4 --capture=Standalone\Research\WorldAssemblerM3\Linux17\captures\floating-islands-windows.png --frame-limit=60
+```
+
+For isolation, repeat with `--capture-only-lod=0` through `--capture-only-lod=8`, changing the
+capture filename each time. Please send the all-level image and the isolated image matching the
+dark square; those will identify whether it is a per-tile draw gap or a particular LOD payload.
+
+## Orchestrator review (Claude) — NOT MERGED
+
+- **The fix breaks SurfaceWorld.** I exported the L1 view (camera `0,-35,-487.94`) from L14 and from
+  L17 and rendered both in the new readable mode (`Saved/Linux/claude/sw/{before,after}-{l1,hz}.jpg`).
+  After L17, the ground under the spawn camera is gone (black void below), the terrain sits far
+  away, and the mesh export shrank from 58.7 MB to 31.7 MB. Halving the strate chunk size (8 m → 4 m)
+  moves and squashes every stratum: a world change, not a fix.
+- **What the approved world uses:** the Core world the owner played and approved places strata
+  with 8 m chunks (32 Core voxels of 25 cm). The "owner chunk = 4 m" claim must be checked against
+  what the Unreal Core route actually does (`AVoxelWorld::CoreVoxelSizeCm`, the Core bridge,
+  `ResolvedWorldSnapshot`), not assumed.
+- **Probably real and separable:** the FloatingIslands `boundarySeal` applied as a solid cap over all
+  XY (the false floors at 3.5/8 m). That needs its own minimal fix with SurfaceWorld unchanged.
+- **Still open in FloatingIslands after the fix:** dark tile-aligned rectangles on the ground (the L17
+  "after" captures, lower left).
+- Kept on side branch `wip/l17-fi-scale`. Only the capture tool's readable shading
+  (`LinuxOffscreenCapture.cpp`) is taken into `assembler/world`.

Standalone/Research/WorldAssemblerM3/Linux17/RingProbe.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Compare upward mesh heights on shared XY edges between adjacent LOD rings."""
+import array
+import collections
+import math
+import struct
+import sys
+
+
+def read_scene(path):
+    tiles = []
+    with open(path, "rb") as f:
+        if f.read(8) != b"VFMSH001":
+            raise SystemExit(f"{path}: invalid mesh header")
+        version, voxel_um, count = struct.unpack("<3I", f.read(12))
+        camera = struct.unpack("<3d", f.read(24))
+        yaw, pitch = struct.unpack("<2d", f.read(16))
+        voxel_m = voxel_um / 1_000_000.0
+        for _ in range(count):
+            key = struct.unpack("<4i", f.read(16))
+            surface_vertices, skirt_count, vertex_count, index_count, mask_count = struct.unpack(
+                "<5I", f.read(20))
+            positions = array.array("f")
+            positions.frombytes(f.read(vertex_count * 12))
+            normals = array.array("f")
+            normals.frombytes(f.read(vertex_count * 12))
+            indices = array.array("I")
+            indices.frombytes(f.read(index_count * 4))
+            masks = f.read(mask_count)
+            if sys.byteorder != "little":
+                positions.byteswap(); normals.byteswap(); indices.byteswap()
+            triangles = []
+            for i in range(0, index_count, 3):
+                if masks and masks[i // 3] != 0:
+                    continue
+                a, b, c = indices[i:i + 3]
+                if max(a, b, c) >= surface_vertices:
+                    continue
+                nz = (normals[a * 3 + 2] + normals[b * 3 + 2] + normals[c * 3 + 2]) / 3.0
+                if nz < 0.65:
+                    continue
+                tri = tuple((positions[j * 3], positions[j * 3 + 1], positions[j * 3 + 2])
+                            for j in (a, b, c))
+                triangles.append(tri)
+            if triangles:
+                lod = key[3]
+                extent = 32 * (1 << lod) * voxel_m
+                tiles.append({"key": key, "lod": lod, "extent": extent,
+                              "x0": key[0] * extent, "y0": key[1] * extent,
+                              "x1": (key[0] + 1) * extent, "y1": (key[1] + 1) * extent,
+                              "z0": key[2] * extent, "z1": (key[2] + 1) * extent,
+                              "triangles": triangles})
+    return camera, yaw, pitch, tiles
+
+
+def height_at(tile, x, y):
+    best = None
+    for tri in tile["triangles"]:
+        (x0, y0, z0), (x1, y1, z1), (x2, y2, z2) = tri
+        den = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2)
+        if abs(den) < 1.0e-10:
+            continue
+        a = ((y1 - y2) * (x - x2) + (x2 - x1) * (y - y2)) / den
+        b = ((y2 - y0) * (x - x2) + (x0 - x2) * (y - y2)) / den
+        c = 1.0 - a - b
+        if min(a, b, c) >= -1.0e-5:
+            z = a * z0 + b * z1 + c * z2
+            if best is None or z > best:
+                best = z
+    return best
+
+
+path = sys.argv[1]
+camera, yaw, pitch, tiles = read_scene(path)
+by_lod = collections.defaultdict(list)
+for tile in tiles:
+    by_lod[tile["lod"]].append(tile)
+print(f"scene={path} camera_m={camera} yaw={yaw} pitch={pitch} nonempty_mesh_tiles={len(tiles)}")
+print("lod_pair shared_edges samples_both median_abs_cm p95_abs_cm max_abs_cm median_delta_cm gaps")
+for lod in range(8):
+    fine = by_lod[lod]
+    coarse = by_lod[lod + 1]
+    deltas = []
+    edge_rows = []
+    edge_count = 0
+    gap_count = 0
+    # Shared XY edges occur only where tile extents touch and overlap on the other axis.
+    for a in fine:
+        for b in coarse:
+            zlo, zhi = max(a["z0"], b["z0"]), min(a["z1"], b["z1"])
+            if zhi - zlo <= 1.0e-4:
+                continue
+            edge = None
+            if abs(a["x1"] - b["x0"]) < 1.0e-4 or abs(b["x1"] - a["x0"]) < 1.0e-4:
+                lo, hi = max(a["y0"], b["y0"]), min(a["y1"], b["y1"])
+                if hi - lo > 1.0e-4:
+                    edge = ("x", a["x1"] if abs(a["x1"] - b["x0"]) < 1.0e-4 else a["x0"], lo, hi)
+            if edge is None and (abs(a["y1"] - b["y0"]) < 1.0e-4 or abs(b["y1"] - a["y0"]) < 1.0e-4):
+                lo, hi = max(a["x0"], b["x0"]), min(a["x1"], b["x1"])
+                if hi - lo > 1.0e-4:
+                    edge = ("y", a["y1"] if abs(a["y1"] - b["y0"]) < 1.0e-4 else a["y0"], lo, hi)
+            if edge is None:
+                continue
+            edge_count += 1
+            axis, fixed, lo, hi = edge
+            epsilon = min(0.02, a["extent"] * 0.001, b["extent"] * 0.001)
+            samples = 9
+            matched = 0
+            edge_deltas = []
+            for i in range(samples):
+                t = (i + 0.5) / samples
+                varying = lo + (hi - lo) * t
+                if axis == "x":
+                    side_a = 1.0 if abs(a["x1"] - fixed) < 1.0e-4 else -1.0
+                    side_b = 1.0 if abs(b["x1"] - fixed) < 1.0e-4 else -1.0
+                    za = height_at(a, fixed - side_a * epsilon, varying)
+                    zb = height_at(b, fixed - side_b * epsilon, varying)
+                else:
+                    side_a = 1.0 if abs(a["y1"] - fixed) < 1.0e-4 else -1.0
+                    side_b = 1.0 if abs(b["y1"] - fixed) < 1.0e-4 else -1.0
+                    za = height_at(a, varying, fixed - side_a * epsilon)
+                    zb = height_at(b, varying, fixed - side_b * epsilon)
+                if za is not None and not zlo - 1.0e-3 <= za <= zhi + 1.0e-3:
+                    za = None
+                if zb is not None and not zlo - 1.0e-3 <= zb <= zhi + 1.0e-3:
+                    zb = None
+                if za is not None and zb is not None:
+                    delta = (za - zb) * 100.0
+                    deltas.append(delta)
+                    edge_deltas.append((delta, za, zb, varying))
+                    matched += 1
+            if matched == 0:
+                gap_count += 1
+            elif edge_deltas:
+                edge_rows.append((max(abs(row[0]) for row in edge_deltas),
+                                  a["key"], b["key"], edge, edge_deltas))
+    if deltas:
+        absolute = sorted(abs(x) for x in deltas)
+        signed = sorted(deltas)
+        p95 = absolute[math.floor(0.95 * (len(absolute) - 1))]
+        median_abs = absolute[len(absolute) // 2]
+        median_delta = signed[len(signed) // 2]
+        print(f"{lod}->{lod+1} {edge_count} {len(deltas)} {median_abs:.3f} {p95:.3f} {max(absolute):.3f} {median_delta:.3f} {gap_count}")
+        for worst, fine_key, coarse_key, edge, rows in sorted(edge_rows, reverse=True)[:2]:
+            row = max(rows, key=lambda item: abs(item[0]))
+            print(f"  worst_edge max_abs_cm={worst:.3f} fine={fine_key} coarse={coarse_key} "
+                  f"axis={edge[0]} fixed_m={edge[1]:.3f} span_m={edge[2]:.3f}..{edge[3]:.3f} "
+                  f"sample_v_m={row[3]:.3f} fine_z_m={row[1]:.3f} "
+                  f"coarse_z_m={row[2]:.3f} delta_cm={row[0]:.3f}")
+    else:
+        print(f"{lod}->{lod+1} {edge_count} 0 n/a n/a n/a n/a {gap_count}")

Standalone/Research/WorldAssemblerM3/Linux17/RunMatrix.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Run the L17 deterministic W1/W8/W12 x5 matrix on both supported Linux builds."""
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l17-matrix"
+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")
+
+BINARIES = {
+    "clang-off": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux17-final-clang",
+    "gcc-default": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux17-final-gcc",
+}
+RECIPES = {
+    "floating-islands": "-10,-31,-22,0,-8",
+    "surface-world": "0,-35,-75,0,0",
+}
+HASH_PATTERNS = {
+    "full": re.compile(r"^\[PipelineFullDetailHash\].*$", re.M),
+    "whole": re.compile(r"^\[PipelineWholeViewHash\].*$", re.M),
+    "lod": re.compile(r"^\[PipelineLODHash\].*$", re.M),
+    "exact": re.compile(r"^\[PipelineExactQueryHash\].*$", re.M),
+}
+rows = []
+all_pass = True
+
+for recipe, camera in RECIPES.items():
+    for compiler, binary in BINARIES.items():
+        if not binary.exists():
+            raise SystemExit(f"missing binary: {binary}")
+        for workers, repeat in [(1, 1), (8, 1), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5)]:
+            name = f"{recipe}-{compiler}-w{workers}-r{repeat}"
+            logfile = OUT / f"{name}.log"
+            command = ["prlimit", "--as=6442450944", "--", str(binary),
+                str(ROOT / "Standalone/data/owner_world.json"),
+                "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+                "--stream-hash", "--force-generate", "--clip-radius=3",
+                "--max-clip-level=8", f"--workers={workers}", f"--camera={camera}",
+                f"--recipe={recipe}"]
+            started = time.monotonic()
+            peak_rss_kib = 0
+            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 = [process.pid]
+                    seen = set()
+                    while pending:
+                        pid = pending.pop()
+                        if pid in seen:
+                            continue
+                        seen.add(pid)
+                        try:
+                            children = Path(f"/proc/{pid}/task/{pid}/children").read_text().split()
+                            pending.extend(int(value) for value in children)
+                            for line in Path(f"/proc/{pid}/status").read_text().splitlines():
+                                if line.startswith("VmRSS:"):
+                                    peak_rss_kib = max(peak_rss_kib, int(line.split()[1]))
+                                    break
+                        except (FileNotFoundError, PermissionError, ProcessLookupError, ValueError):
+                            pass
+                    if time.monotonic() - started > 900:
+                        os.killpg(process.pid, signal.SIGTERM)
+                        try:
+                            process.wait(timeout=5)
+                        except subprocess.TimeoutExpired:
+                            os.killpg(process.pid, signal.SIGKILL)
+                            process.wait()
+                        all_pass = False
+                        break
+                    time.sleep(0.1)
+                code = process.wait()
+            elapsed = time.monotonic() - started
+            output = logfile.read_text(encoding="utf-8", errors="replace")
+            matched = {key: pattern.findall(output) for key, pattern in HASH_PATTERNS.items()}
+            ok = code == 0 and all(matched.values()) and len(matched["lod"]) == 9
+            if not ok:
+                all_pass = False
+            row = {"recipe": recipe, "compiler": compiler, "workers": workers,
+                   "repeat": repeat, "exit": code, "seconds": elapsed,
+                   "peak_rss_kib": peak_rss_kib, "ok": ok,
+                   "full": matched["full"][-1] if matched["full"] else "",
+                   "whole": matched["whole"][-1] if matched["whole"] else "",
+                   "lod": " || ".join(matched["lod"]),
+                   "exact": matched["exact"][-1] if matched["exact"] else ""}
+            rows.append(row)
+            print(f"[MatrixRun] {name} exit={code} seconds={elapsed:.3f} "
+                  f"peak_rss_kib={peak_rss_kib} hash_rows={sum(map(len,matched.values()))} "
+                  f"status={'PASS' if ok else 'FAIL'}", flush=True)
+
+summary = OUT / "summary.tsv"
+columns = ["recipe", "compiler", "workers", "repeat", "exit", "seconds", "peak_rss_kib",
+           "ok", "full", "whole", "lod", "exact"]
+with summary.open("w", encoding="utf-8") as f:
+    f.write("\t".join(columns) + "\n")
+    for row in rows:
+        f.write("\t".join(str(row[key]) for key in columns) + "\n")
+
+for recipe in RECIPES:
+    reference = None
+    for row in rows:
+        if row["recipe"] != recipe:
+            continue
+        signature = (row["full"], row["whole"], row["lod"], row["exact"])
+        if reference is None:
+            reference = signature
+        elif signature != reference:
+            print(f"[MatrixMismatch] recipe={recipe} workers={row['workers']} "
+                  f"compiler={row['compiler']} repeat={row['repeat']}", flush=True)
+            all_pass = False
+print(f"[MatrixSummary] rows={len(rows)} expected=28 result={'PASS' if all_pass else 'FAIL'} "
+      f"path={summary}", flush=True)
+raise SystemExit(0 if all_pass and len(rows) == 28 else 1)

Standalone/Research/WorldAssemblerM3/Linux17/boundary-after.txt

@@ -0,0 +1,27 @@
+camera_m=(-22.0, -19.0, -22.799999237060547) yaw=0.0 pitch=-4.0 boundary_band_m=-80.0..-45.0
+lod tiles_with_boundary_faces faces z_m_p05/median/p95 tile_span_m_p50/p95/max
+1 64 131072 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+2 40 20480 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+3 48 24576 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+4 48 22945 -60.0000/-60.0000/-60.0000 0.0000/0.9167/1.8008
+5 48 19554 -60.0000/-60.0000/-60.0000 0.0000/1.0819/1.7900
+6 9 134 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+nearest_xy_boundary_tiles_by_lod:
+lod=1 key=(-2, -2, -4, 1) xy_distance_m=5.39 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=2048
+lod=1 key=(-2, -1, -4, 1) xy_distance_m=11.18 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=2048
+lod=1 key=(-1, -2, -4, 1) xy_distance_m=14.87 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=2048
+lod=2 key=(-1, 1, -2, 2) xy_distance_m=67.27 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=2 key=(1, -1, -2, 2) xy_distance_m=70.06 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=2 key=(-2, 1, -2, 2) xy_distance_m=71.87 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=3 key=(-3, -1, -1, 3) xy_distance_m=138.61 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=3 key=(-1, -3, -1, 3) xy_distance_m=141.35 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=3 key=(-3, 0, -1, 3) xy_distance_m=147.12 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=4 key=(-3, -1, -1, 4) xy_distance_m=301.38 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=4 key=(-1, -3, -1, 4) xy_distance_m=303.92 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=4 key=(-3, 0, -1, 4) xy_distance_m=309.34 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=5 key=(-3, -1, -1, 5) xy_distance_m=627.54 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=343
+lod=5 key=(-1, -3, -1, 5) xy_distance_m=629.98 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=512
+lod=5 key=(-3, 0, -1, 5) xy_distance_m=635.24 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.4903 faces=142
+lod=6 key=(-3, 0, -1, 6) xy_distance_m=1287.71 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=2
+lod=6 key=(0, -3, -1, 6) xy_distance_m=1291.28 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=16
+lod=6 key=(1, 2, -1, 6) xy_distance_m=1520.36 boundary_median_z=-60.0000 within_tile_p05_p95_m=0.0000 faces=3

Standalone/Research/WorldAssemblerM3/Linux17/boundary-before.txt

@@ -0,0 +1,35 @@
+camera_m=(-22.0, -19.0, -22.799999237060547) yaw=0.0 pitch=-4.0 boundary_band_m=-80.0..-45.0
+lod tiles_with_boundary_faces faces z_m_p05/median/p95 tile_span_m_p50/p95/max
+1 65 144957 -60.4936/-60.4872/-59.5000 0.0059/0.9906/2.2272
+2 75 29057 -76.1525/-61.3304/-60.7788 0.8725/2.9863/8.5642
+3 87 26484 -73.0968/-63.0185/-62.4964 1.3211/11.6236/14.1057
+4 48 25679 -72.6651/-62.8690/-62.2182 3.2371/15.9700/17.0106
+5 48 26381 -67.4390/-62.7489/-61.8320 4.2721/11.9903/14.5467
+6 14 390 -73.7183/-67.0059/-62.3980 4.0318/11.7718/12.7473
+7 18 483 -74.7834/-71.1169/-67.5754 4.0317/7.3030/8.1412
+8 22 176 -75.3669/-69.9656/-63.4334 3.5327/3.5370/13.7478
+nearest_xy_boundary_tiles_by_lod:
+lod=1 key=(-2, -2, -4, 1) xy_distance_m=5.39 boundary_median_z=-60.4712 within_tile_p05_p95_m=0.0177 faces=2048
+lod=1 key=(-2, -1, -4, 1) xy_distance_m=11.18 boundary_median_z=-60.4718 within_tile_p05_p95_m=0.0158 faces=2048
+lod=1 key=(-1, -2, -4, 1) xy_distance_m=14.87 boundary_median_z=-60.4550 within_tile_p05_p95_m=0.0212 faces=2048
+lod=2 key=(-1, 1, -2, 2) xy_distance_m=67.27 boundary_median_z=-60.7421 within_tile_p05_p95_m=0.2955 faces=496
+lod=2 key=(1, -1, -3, 2) xy_distance_m=70.06 boundary_median_z=-74.2743 within_tile_p05_p95_m=2.9398 faces=97
+lod=2 key=(1, -1, -2, 2) xy_distance_m=70.06 boundary_median_z=-60.7387 within_tile_p05_p95_m=1.2725 faces=496
+lod=3 key=(-3, -1, -1, 3) xy_distance_m=138.61 boundary_median_z=-62.5408 within_tile_p05_p95_m=0.3465 faces=512
+lod=3 key=(-1, -3, -1, 3) xy_distance_m=141.35 boundary_median_z=-62.5378 within_tile_p05_p95_m=1.6699 faces=512
+lod=3 key=(-3, 0, -1, 3) xy_distance_m=147.12 boundary_median_z=-62.5837 within_tile_p05_p95_m=0.3165 faces=512
+lod=4 key=(-3, -1, -1, 4) xy_distance_m=301.38 boundary_median_z=-62.3784 within_tile_p05_p95_m=4.5901 faces=546
+lod=4 key=(-1, -3, -1, 4) xy_distance_m=303.92 boundary_median_z=-62.3534 within_tile_p05_p95_m=10.4664 faces=596
+lod=4 key=(-3, 0, -1, 4) xy_distance_m=309.34 boundary_median_z=-62.3696 within_tile_p05_p95_m=6.1327 faces=544
+lod=5 key=(-3, -1, -1, 5) xy_distance_m=627.54 boundary_median_z=-62.0651 within_tile_p05_p95_m=9.5826 faces=523
+lod=5 key=(-1, -3, -1, 5) xy_distance_m=629.98 boundary_median_z=-61.9414 within_tile_p05_p95_m=2.3891 faces=526
+lod=5 key=(-3, 0, -1, 5) xy_distance_m=635.24 boundary_median_z=-62.0996 within_tile_p05_p95_m=9.3777 faces=567
+lod=6 key=(-3, 0, -1, 6) xy_distance_m=1287.71 boundary_median_z=-69.5358 within_tile_p05_p95_m=4.1243 faces=26
+lod=6 key=(0, -3, -1, 6) xy_distance_m=1291.28 boundary_median_z=-70.4254 within_tile_p05_p95_m=12.7473 faces=41
+lod=6 key=(0, 2, -1, 6) xy_distance_m=1328.41 boundary_median_z=-63.9805 within_tile_p05_p95_m=0.0000 faces=1
+lod=7 key=(0, -3, -1, 7) xy_distance_m=2596.50 boundary_median_z=-70.2015 within_tile_p05_p95_m=4.1663 faces=36
+lod=7 key=(2, -1, -1, 7) xy_distance_m=2628.64 boundary_median_z=-70.1072 within_tile_p05_p95_m=3.5366 faces=8
+lod=7 key=(-3, 1, -1, 7) xy_distance_m=2976.49 boundary_median_z=-70.9568 within_tile_p05_p95_m=4.8223 faces=24
+lod=8 key=(-1, 2, -1, 8) xy_distance_m=5235.77 boundary_median_z=-65.8628 within_tile_p05_p95_m=3.5343 faces=8
+lod=8 key=(-1, -4, -1, 8) xy_distance_m=7218.88 boundary_median_z=-71.4663 within_tile_p05_p95_m=3.5332 faces=8
+lod=8 key=(-4, 0, -1, 8) xy_distance_m=7221.71 boundary_median_z=-70.6999 within_tile_p05_p95_m=3.5335 faces=8

Standalone/Research/WorldAssemblerM3/Linux17/mesh-after-boundary-summary.txt

@@ -0,0 +1,13 @@
+version=1 voxel_um=250000 tiles=2370 camera_m=(-22.0, -19.0, -22.799999237060547) yaw=0.0 pitch=-4.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 15 30819 54860 9176 12102 -29.7482/-28.0275/-25.2555 0.5335/1.1856/1.9265
+1 448 64 94272 163840 32768 131072 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+2 320 40 28476 45376 15296 20480 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+3 208 48 58599 93736 30968 24576 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+4 240 48 105724 164240 27638 22945 -60.0000/-60.0000/-60.0000 0.0000/0.9167/1.8008
+5 144 96 96543 156615 22706 109798 -506.3981/-502.5195/-60.0000 1.7900/110.1491/138.3581
+6 96 48 114212 157583 28194 91871 -506.2913/-503.3460/-411.9775 78.1123/124.2575/136.4059
+7 96 48 142940 234358 31690 95029 -506.1172/-503.3633/-412.8203 90.7064/105.1855/106.9902
+8 306 153 290960 421667 73118 147296 -505.8558/-503.1657/-422.5029 82.1507/93.3314/110.2594
+near_camera_up_tiles (sorted by XY tile-centre distance):
+key=(-2, -2, -4, 1) xy_distance_m=5.39 vertices=1473 triangles=2560 skirt_triangles=512 upward_triangles=2048 z_m=-60.000/-60.000/-60.000 tile_span_p05_p95_m=0.000

Standalone/Research/WorldAssemblerM3/Linux17/mesh-after-summary.txt

@@ -0,0 +1,13 @@
+version=1 voxel_um=250000 tiles=2370 camera_m=(-22.0, -19.0, -22.799999237060547) yaw=0.0 pitch=-4.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 15 30819 54860 9176 12102 -29.7482/-28.0275/-25.2555 0.5335/1.1856/1.9265
+1 448 64 94272 163840 32768 131072 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+2 320 40 28476 45376 15296 20480 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+3 208 48 58599 93736 30968 24576 -60.0000/-60.0000/-60.0000 0.0000/0.0000/0.0000
+4 240 48 105724 164240 27638 22945 -60.0000/-60.0000/-60.0000 0.0000/0.9167/1.8008
+5 144 96 96543 156615 22706 109798 -506.3981/-502.5195/-60.0000 1.7900/110.1491/138.3581
+6 96 48 114212 157583 28194 91871 -506.2913/-503.3460/-411.9775 78.1123/124.2575/136.4059
+7 96 48 142940 234358 31690 95029 -506.1172/-503.3633/-412.8203 90.7064/105.1855/106.9902
+8 306 153 290960 421667 73118 147296 -505.8558/-503.1657/-422.5029 82.1507/93.3314/110.2594
+near_camera_up_tiles (sorted by XY tile-centre distance):
+key=(-2, -2, -4, 1) xy_distance_m=5.39 vertices=1473 triangles=2560 skirt_triangles=512 upward_triangles=2048 z_m=-60.000/-60.000/-60.000 tile_span_p05_p95_m=0.000

Standalone/Research/WorldAssemblerM3/Linux17/mesh-before-matched-summary.txt

@@ -0,0 +1,19 @@
+version=1 voxel_um=250000 tiles=2370 camera_m=(-22.0, -19.0, -22.799999237060547) yaw=0.0 pitch=-4.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 143 588792 892284 293148 300091 3.5000/7.6738/8.2568 0.4215/4.4898/4.4913
+1 448 119 509571 954666 323268 265175 -60.4932/-60.4491/8.1722 0.3356/0.9926/4.2986
+2 320 130 93432 150346 51220 55675 -76.2021/-60.8983/8.0124 0.3035/2.9398/8.5642
+3 208 135 91227 146168 33040 51843 -70.7997/-62.4979/8.0125 1.0249/11.2411/19.6108
+4 240 103 173336 278284 61076 58421 -505.3757/-411.1270/-62.3657 8.2807/88.3431/118.1829
+5 144 96 137096 173158 40930 117557 -506.3330/-502.1182/-62.4087 10.4471/110.1491/138.5524
+6 96 48 151997 168987 43320 92193 -506.3014/-503.3398/-410.9469 78.1123/124.2575/136.4059
+7 96 96 236120 321403 61348 120078 -505.8770/-502.4482/8.0020 0.0000/103.3187/110.4079
+8 306 306 553491 741221 166096 225866 -505.4486/-472.2318/8.0020 0.0000/92.1234/110.0400
+near_camera_up_tiles (sorted by XY tile-centre distance):
+key=(-3, -3, 0, 0) xy_distance_m=2.24 vertices=8058 triangles=11660 skirt_triangles=3796 upward_triangles=3768 z_m=3.500/3.500/7.999 tile_span_p05_p95_m=4.445
+key=(-3, -3, 1, 0) xy_distance_m=2.24 vertices=668 triangles=1052 skirt_triangles=376 upward_triangles=676 z_m=8.000/8.087/8.252 tile_span_p05_p95_m=0.203
+key=(-2, -2, -4, 1) xy_distance_m=5.39 vertices=2562 triangles=8192 skirt_triangles=2048 upward_triangles=2048 z_m=-60.480/-60.471/-60.457 tile_span_p05_p95_m=0.018
+key=(-4, -3, 0, 0) xy_distance_m=6.08 vertices=7502 triangles=10753 skirt_triangles=3764 upward_triangles=2893 z_m=3.500/3.500/8.000 tile_span_p05_p95_m=4.486
+key=(-4, -3, 1, 0) xy_distance_m=6.08 vertices=1617 triangles=2507 skirt_triangles=928 upward_triangles=1579 z_m=8.000/8.099/8.372 tile_span_p05_p95_m=0.248
+key=(-3, -2, 0, 0) xy_distance_m=7.28 vertices=7772 triangles=10994 skirt_triangles=4024 upward_triangles=2874 z_m=3.500/3.500/8.000 tile_span_p05_p95_m=4.491
+key=(-3, -2, 1, 0) xy_distance_m=7.28 vertices=1883 triangles=2904 skirt_triangles=1116 upward_triangles=1788 z_m=8.000/8.115/8.363 tile_span_p05_p95_m=0.280

Standalone/Research/WorldAssemblerM3/Linux17/mesh-before-summary.txt

@@ -0,0 +1,19 @@
+version=1 voxel_um=250000 tiles=2370 camera_m=(-11.612443923950195, -118.22123718261719, -19.84520721435547) yaw=0.0 pitch=0.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 128 579561 840946 290676 288126 3.5000/7.7495/8.2586 0.3781/4.4867/4.4932
+1 448 124 503677 964366 331082 258850 -63.8505/-60.4908/8.1722 0.2965/2.9282/5.7538
+2 320 127 83460 135059 46994 53146 -71.5347/-60.5904/8.0124 0.5224/2.7093/6.0349
+3 208 126 93575 151669 35042 52200 -75.6995/-61.9814/8.0125 0.5630/13.5938/55.4526
+4 240 103 172283 277754 60622 58086 -505.4072/-410.6667/-62.3188 6.7752/88.3431/118.1829
+5 144 96 137096 173158 40930 117557 -506.3330/-502.1182/-62.4087 10.4471/110.1491/138.5524
+6 96 48 151997 168987 43320 92193 -506.3014/-503.3398/-410.9469 78.1123/124.2575/136.4059
+7 96 96 236120 321403 61348 120078 -505.8770/-502.4482/8.0020 0.0000/103.3187/110.4079
+8 306 306 553491 741221 166096 225866 -505.4486/-472.2318/8.0020 0.0000/92.1234/110.0400
+near_camera_up_tiles (sorted by XY tile-centre distance):
+key=(-2, -15, 0, 0) xy_distance_m=2.25 vertices=7941 triangles=11569 skirt_triangles=3860 upward_triangles=3613 z_m=3.500/3.500/8.000 tile_span_p05_p95_m=4.472
+key=(-2, -15, 1, 0) xy_distance_m=2.25 vertices=1159 triangles=1557 skirt_triangles=684 upward_triangles=873 z_m=8.000/8.082/8.275 tile_span_p05_p95_m=0.250
+key=(-1, -8, -4, 1) xy_distance_m=4.03 vertices=2562 triangles=8192 skirt_triangles=2048 upward_triangles=2048 z_m=-60.494/-60.494/-60.493 tile_span_p05_p95_m=0.001
+key=(-2, -16, 0, 0) xy_distance_m=5.79 vertices=8315 triangles=12274 skirt_triangles=3928 upward_triangles=4250 z_m=3.500/7.740/8.000 tile_span_p05_p95_m=4.459
+key=(-2, -16, 1, 0) xy_distance_m=5.79 vertices=677 triangles=700 skirt_triangles=520 upward_triangles=180 z_m=8.000/8.008/8.057 tile_span_p05_p95_m=0.036
+key=(-1, -15, 0, 0) xy_distance_m=7.93 vertices=6918 triangles=9878 skirt_triangles=3384 upward_triangles=2398 z_m=3.500/3.500/8.000 tile_span_p05_p95_m=4.453
+key=(-1, -15, 1, 0) xy_distance_m=7.93 vertices=1611 triangles=2700 skirt_triangles=652 upward_triangles=2048 z_m=8.001/8.202/8.323 tile_span_p05_p95_m=0.242

Standalone/Research/WorldAssemblerM3/Linux17/mesh-sw-after-summary.txt

@@ -0,0 +1,12 @@
+version=1 voxel_um=250000 tiles=2553 camera_m=(0.0, -35.0, -487.94000244140625) yaw=0.0 pitch=-22.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 0 0 0 0 0 nan/nan/nan nan/nan/nan
+1 448 0 0 0 0 0 nan/nan/nan nan/nan/nan
+2 448 0 0 0 0 0 nan/nan/nan nan/nan/nan
+3 384 0 0 0 0 0 nan/nan/nan nan/nan/nan
+4 320 52 139437 209316 34996 8129 -56.2002/-42.7865/-32.7998 6.2138/32.5482/53.6770
+5 144 102 100254 158707 25586 96013 -506.9092/-503.1813/-378.0397 12.8110/109.5153/138.3581
+6 96 61 110399 149031 17088 92803 -506.4873/-503.3776/-412.3926 53.2054/124.2575/136.4059
+7 48 48 132222 219052 16356 95003 -506.1172/-503.3639/-412.8861 90.7064/105.1855/106.9902
+8 153 153 229080 384768 82518 147226 -505.8568/-503.1676/-422.8789 82.0687/93.3180/110.0400
+near_camera_up_tiles (sorted by XY tile-centre distance):

Standalone/Research/WorldAssemblerM3/Linux17/mesh-sw-l1-after-summary.txt

@@ -0,0 +1,5 @@
+version=1 voxel_um=250000 tiles=960 camera_m=(-11.612443923950195, -118.22123718261719, -506.7861328125) yaw=0.0 pitch=0.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 0 0 0 0 0 nan/nan/nan nan/nan/nan
+1 448 0 0 0 0 0 nan/nan/nan nan/nan/nan
+near_camera_up_tiles (sorted by XY tile-centre distance):

Standalone/Research/WorldAssemblerM3/Linux17/mesh-sw-l1-cap-after-summary.txt

@@ -0,0 +1,5 @@
+version=1 voxel_um=250000 tiles=960 camera_m=(0.0, -35.0, -75.0) yaw=0.0 pitch=0.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 0 0 0 0 0 nan/nan/nan nan/nan/nan
+1 448 76 153596 265964 51168 82938 -43.9418/-14.9892/-6.3079 0.8803/5.3022/10.8345
+near_camera_up_tiles (sorted by XY tile-centre distance):

Standalone/Research/WorldAssemblerM3/Linux17/mesh-sw-l1-ground-after-summary.txt

@@ -0,0 +1,5 @@
+version=1 voxel_um=250000 tiles=960 camera_m=(0.0, -35.0, -42.0) yaw=0.0 pitch=-8.0
+lod tiles mesh_tiles vertices triangles skirt_triangles upward_surface_triangles upward_centroid_z_m_p05/median/p95 tile_up_z_span_m_p50/p95/max
+0 512 25 80260 139176 28088 34692 -43.9640/-33.5509/-32.8013 0.7072/4.9851/7.0117
+1 448 131 295583 474122 103438 230953 -33.6783/3.9507/4.1428 0.3514/4.4247/10.8345
+near_camera_up_tiles (sorted by XY tile-centre distance):

Standalone/Source/LinuxOffscreenCapture.cpp

@@ -25,6 +25,8 @@ namespace
         float Position[3];
         float Normal[3];
         float Height;
+        float WorldPosition[3];
+        float TileData[4];
     };
 
     struct FScene
@@ -32,6 +34,8 @@ namespace
         std::uint32_t VoxelSizeMicrons=0;
         std::array<double,3> CameraMeters{};
         double YawDegrees=0.0,PitchDegrees=0.0;
+        float MinimumHeight=std::numeric_limits<float>::infinity();
+        float MaximumHeight=-std::numeric_limits<float>::infinity();
         std::vector<FVertex> Vertices;
         std::vector<std::uint32_t> Indices;
         std::uint64_t Triangles=0,SkirtTriangles=0;
@@ -70,7 +74,8 @@ namespace
             if(!Read(File,SurfaceVertices)||!Read(File,SkirtCount)||!Read(File,VertexCount)
                 ||!Read(File,IndexCount)||!Read(File,MaskCount)
                 ||VertexCount>10000000||IndexCount>60000000||MaskCount>20000000
-                ||IndexCount%3!=0||(MaskCount!=0&&MaskCount!=IndexCount/3))
+                ||IndexCount%3!=0||(MaskCount!=0&&MaskCount!=IndexCount/3)
+                ||Key[3]<0||Key[3]>8)
             {Error="tile mesh header is malformed";return false;}
             if(TotalVertices+VertexCount>std::numeric_limits<std::uint32_t>::max()
                 ||TotalIndices+IndexCount>std::numeric_limits<std::size_t>::max())
@@ -86,6 +91,25 @@ namespace
                 for(float& Value:Scene.Vertices[I].Normal)if(!Read(File,Value))
                 {Error="tile normals are truncated";return false;}
                 Scene.Vertices[I].Height=Scene.Vertices[I].Position[2];
+                Scene.MinimumHeight=std::min(Scene.MinimumHeight,Scene.Vertices[I].Height);
+                Scene.MaximumHeight=std::max(Scene.MaximumHeight,Scene.Vertices[I].Height);
+            }
+            const double TileVoxels=static_cast<double>(32u<<Key[3]);
+            const float TileExtentMeters=static_cast<float>(TileVoxels
+                *static_cast<double>(Scene.VoxelSizeMicrons)/1000000.0);
+            const float TileOriginX=static_cast<float>(static_cast<double>(Key[0])
+                *TileExtentMeters);
+            const float TileOriginY=static_cast<float>(static_cast<double>(Key[1])
+                *TileExtentMeters);
+            for(std::size_t I=Base;I<Base+VertexCount;++I)
+            {
+                FVertex& Vertex=Scene.Vertices[I];
+                std::copy(std::begin(Vertex.Position),std::end(Vertex.Position),
+                    std::begin(Vertex.WorldPosition));
+                Vertex.TileData[0]=TileOriginX;
+                Vertex.TileData[1]=TileOriginY;
+                Vertex.TileData[2]=TileExtentMeters;
+                Vertex.TileData[3]=static_cast<float>(Key[3]);
             }
             const std::size_t IndexOffset=Scene.Indices.size();
             Scene.Indices.resize(IndexOffset+IndexCount);
@@ -151,8 +175,12 @@ precision highp float;
 layout(location=0) in vec3 inCameraPosition;
 layout(location=1) in vec3 inNormal;
 layout(location=2) in float inHeight;
+layout(location=3) in vec3 inWorldPosition;
+layout(location=4) in vec4 inTileData;
 out vec3 vNormal;
 out float vHeight;
+out vec3 vWorldPosition;
+out vec4 vTileData;
 uniform float uTanHalfHorizontal;
 uniform float uTanHalfVertical;
 uniform float uNear;
@@ -165,19 +193,54 @@ void main()
         inCameraPosition.y/uTanHalfVertical,clipZ,z);
     vNormal=normalize(inNormal);
     vHeight=inHeight;
+    vWorldPosition=inWorldPosition;
+    vTileData=inTileData;
 })GLSL";
         static constexpr char FragmentSource[]=R"GLSL(#version 300 es
 precision highp float;
 in vec3 vNormal;
 in float vHeight;
+in vec3 vWorldPosition;
+in vec4 vTileData;
 out vec4 outColor;
+uniform int uReadableMode;
+uniform int uTileEdges;
+uniform float uHeightCenter;
+uniform float uHeightRange;
+uniform float uTileEdgeWidth;
+uniform vec3 uLightDirection;
 void main()
 {
     vec3 n=normalize(vNormal);
-    vec3 normalColor=abs(n)*0.78+vec3(0.12);
-    float band=mod(floor((vHeight+10000.0)/80.0),2.0);
-    vec3 bandColor=mix(vec3(0.24,0.31,0.37),vec3(0.39,0.42,0.35),band);
-    outColor=vec4(mix(bandColor,normalColor,0.68),1.0);
+    vec3 color;
+    if(uReadableMode==0)
+    {
+        vec3 normalColor=abs(n)*0.78+vec3(0.12);
+        float band=mod(floor((vHeight+10000.0)/80.0),2.0);
+        vec3 bandColor=mix(vec3(0.24,0.31,0.37),vec3(0.39,0.42,0.35),band);
+        color=mix(bandColor,normalColor,0.68);
+    }
+    else
+    {
+        float heightT=clamp(0.5+(vHeight-uHeightCenter)/max(uHeightRange,0.001),0.0,1.0);
+        vec3 heightTint=mix(vec3(0.80,0.91,1.0),vec3(1.0,0.91,0.77),heightT);
+        float diffuse=max(dot(n,normalize(uLightDirection)),0.0);
+        float illumination=0.62+0.38*diffuse;
+        color=vec3(0.64,0.62,0.56)*heightTint*illumination;
+    }
+    if(uTileEdges!=0&&vTileData.z>0.0)
+    {
+        vec2 local=mod(vWorldPosition.xy-vTileData.xy,vTileData.z);
+        vec2 edge=min(local,vec2(vTileData.z)-local);
+        float distanceToTileEdge=min(edge.x,edge.y);
+        float antialias=max(fwidth(distanceToTileEdge),0.005);
+        float line=1.0-smoothstep(uTileEdgeWidth-antialias,
+            uTileEdgeWidth+antialias,distanceToTileEdge);
+        vec3 edgeColor=mix(vec3(0.16,0.22,0.25),vec3(0.30,0.23,0.14),
+            clamp(vTileData.w/8.0,0.0,1.0));
+        color=mix(color,edgeColor,0.32*line);
+    }
+    outColor=vec4(color,1.0);
 })GLSL";
         const GLuint VS=CompileShader(GL_VERTEX_SHADER,VertexSource);
         const GLuint FS=CompileShader(GL_FRAGMENT_SHADER,FragmentSource);
@@ -224,7 +287,8 @@ void main()
     }
 
     bool Render(FScene& Scene,const std::filesystem::path& Output,int Width,int Height,
-                double HorizontalFovDegrees)
+                double HorizontalFovDegrees,bool ReadableMode,bool TileEdges,
+                double TileEdgeWidthMeters)
     {
         EGLDisplay Display=MakeDisplay();
         EGLint Major=0,Minor=0;
@@ -304,6 +368,10 @@ void main()
             reinterpret_cast<void*>(offsetof(FVertex,Normal)));
         glEnableVertexAttribArray(2);glVertexAttribPointer(2,1,GL_FLOAT,GL_FALSE,sizeof(FVertex),
             reinterpret_cast<void*>(offsetof(FVertex,Height)));
+        glEnableVertexAttribArray(3);glVertexAttribPointer(3,3,GL_FLOAT,GL_FALSE,sizeof(FVertex),
+            reinterpret_cast<void*>(offsetof(FVertex,WorldPosition)));
+        glEnableVertexAttribArray(4);glVertexAttribPointer(4,4,GL_FLOAT,GL_FALSE,sizeof(FVertex),
+            reinterpret_cast<void*>(offsetof(FVertex,TileData)));
         glViewport(0,0,Width,Height);glDisable(GL_CULL_FACE);glEnable(GL_DEPTH_TEST);
         glDepthFunc(GL_LEQUAL);glClearColor(0.035f,0.055f,0.075f,1.0f);
         glClearDepthf(1.0f);glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
@@ -312,6 +380,14 @@ void main()
         glUniform1f(glGetUniformLocation(Program,"uTanHalfVertical"),static_cast<float>(TanHalfVertical));
         glUniform1f(glGetUniformLocation(Program,"uNear"),static_cast<float>(Near));
         glUniform1f(glGetUniformLocation(Program,"uFar"),static_cast<float>(Far));
+        glUniform1i(glGetUniformLocation(Program,"uReadableMode"),ReadableMode?1:0);
+        glUniform1i(glGetUniformLocation(Program,"uTileEdges"),TileEdges?1:0);
+        glUniform1f(glGetUniformLocation(Program,"uHeightCenter"),
+            static_cast<float>(Scene.CameraMeters[2]));
+        glUniform1f(glGetUniformLocation(Program,"uHeightRange"),64.0f);
+        glUniform1f(glGetUniformLocation(Program,"uTileEdgeWidth"),
+            static_cast<float>(TileEdgeWidthMeters));
+        glUniform3f(glGetUniformLocation(Program,"uLightDirection"),-0.42f,-0.58f,0.70f);
         glDrawElements(GL_TRIANGLES,static_cast<GLsizei>(Scene.Indices.size()),GL_UNSIGNED_INT,nullptr);
         glFinish();
         std::vector<std::uint8_t> Pixels(static_cast<std::size_t>(Width)*Height*4);
@@ -323,9 +399,10 @@ void main()
         {
             std::error_code SizeError;
             const auto Bytes=std::filesystem::file_size(Output,SizeError);
-            std::printf("[OffscreenCapture] triangles=%llu tiles=%u skirts=%llu png_bytes=%llu status=PASS path=%s\n",
+        std::printf("[OffscreenCapture] triangles=%llu tiles=%u skirts=%llu shading=%s tile_edges=%s edge_width_m=%.3f png_bytes=%llu status=PASS path=%s\n",
                 static_cast<unsigned long long>(Scene.Triangles),Scene.TileCount,
                 static_cast<unsigned long long>(Scene.SkirtTriangles),
+                ReadableMode?"readable":"normal",TileEdges?"on":"off",TileEdgeWidthMeters,
                 static_cast<unsigned long long>(SizeError?0:Bytes),Output.string().c_str());
         }
         glDeleteProgram(Program);glDeleteBuffers(1,&Ebo);glDeleteBuffers(1,&Vbo);
@@ -341,12 +418,13 @@ int main(int argc,char** argv)
 {
     if(argc<3)
     {
-        std::fprintf(stderr,"Usage: %s scene.vfmesh output.png [--size=WIDTHxHEIGHT] [--fov-deg=90] [--camera-m=X,Y,Z] [--yaw-deg=N] [--pitch-deg=N]\n",argv[0]);
+        std::fprintf(stderr,"Usage: %s scene.vfmesh output.png [--size=WIDTHxHEIGHT] [--fov-deg=90] [--camera-m=X,Y,Z] [--yaw-deg=N] [--pitch-deg=N] [--shade=readable|normal] [--tile-edges=on|off] [--tile-edge-width-m=N]\n",argv[0]);
         return 2;
     }
     int Width=2560,Height=1440;double Fov=90.0;
     bool HasYaw=false,HasPitch=false;double Yaw=0.0,Pitch=0.0;
     bool HasCamera=false;std::array<double,3> Camera{};
+    bool ReadableMode=true,TileEdges=false;double TileEdgeWidthMeters=0.15;
     for(int I=3;I<argc;++I)
     {
         const std::string_view Arg(argv[I]);
@@ -380,6 +458,28 @@ int main(int argc,char** argv)
             {std::fprintf(stderr,"Invalid camera angle\n");return 2;}
             if(IsYaw){Yaw=Parsed;HasYaw=true;}else{Pitch=Parsed;HasPitch=true;}
         }
+        else if(Arg.starts_with("--shade="))
+        {
+            const std::string_view Mode=Arg.substr(8);
+            if(Mode=="readable")ReadableMode=true;
+            else if(Mode=="normal")ReadableMode=false;
+            else {std::fprintf(stderr,"Invalid shading mode\n");return 2;}
+        }
+        else if(Arg.starts_with("--tile-edges="))
+        {
+            const std::string_view Mode=Arg.substr(13);
+            if(Mode=="on")TileEdges=true;
+            else if(Mode=="off")TileEdges=false;
+            else {std::fprintf(stderr,"Invalid tile-edge mode\n");return 2;}
+        }
+        else if(Arg.starts_with("--tile-edge-width-m="))
+        {
+            char* End=nullptr;const std::string Value(Arg.substr(20));
+            TileEdgeWidthMeters=std::strtod(Value.c_str(),&End);
+            if(End==Value.c_str()||*End!='\0'||!std::isfinite(TileEdgeWidthMeters)
+                ||TileEdgeWidthMeters<=0.0||TileEdgeWidthMeters>5.0)
+            {std::fprintf(stderr,"Invalid tile-edge width\n");return 2;}
+        }
         else {std::fprintf(stderr,"Unknown option: %.*s\n",static_cast<int>(Arg.size()),Arg.data());return 2;}
     }
     FScene Scene;std::string Error;
@@ -388,10 +488,12 @@ int main(int argc,char** argv)
     if(HasCamera)Scene.CameraMeters=Camera;
     if(HasYaw)Scene.YawDegrees=Yaw;
     if(HasPitch)Scene.PitchDegrees=Pitch;
-    std::printf("[OffscreenScene] voxels_per_meter=%.6f camera_m=(%.3f,%.3f,%.3f) yaw=%.2f pitch=%.2f vertices=%zu triangles=%llu\n",
+    std::printf("[OffscreenScene] voxels_per_meter=%.6f camera_m=(%.3f,%.3f,%.3f) yaw=%.2f pitch=%.2f height_m=%.3f..%.3f shade=%s tile_edges=%s vertices=%zu triangles=%llu\n",
         1000000.0/Scene.VoxelSizeMicrons,Scene.CameraMeters[0],Scene.CameraMeters[1],Scene.CameraMeters[2],
-        Scene.YawDegrees,Scene.PitchDegrees,Scene.Vertices.size(),
+        Scene.YawDegrees,Scene.PitchDegrees,Scene.MinimumHeight,Scene.MaximumHeight,
+        ReadableMode?"readable":"normal",TileEdges?"on":"off",Scene.Vertices.size(),
         static_cast<unsigned long long>(Scene.Triangles));
-    return Render(Scene,argv[2],Width,Height,Fov)?0:3;
+    return Render(Scene,argv[2],Width,Height,Fov,ReadableMode,TileEdges,
+        TileEdgeWidthMeters)?0:3;
 }
 

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -63,6 +63,7 @@ namespace
         float CameraYawDegrees=0.0f;
         float CameraPitchDegrees=0.0f;
         std::filesystem::path MeshExportPath;
+        std::filesystem::path WorldAssemblyManifestOutputPath;
     };
 
     bool ParseInteger(std::string_view text,int& output)
@@ -115,6 +116,7 @@ namespace
                     "  --region-crossing (compile entering Core regions at the camera step)\n"
                     "  --column-cache=shared|thread-local (default: shared)\n"
                     "  --mesh-export=FILE (write the exact generated tile meshes for offline rendering)\n"
+                    "  --world-assembler-manifest-output=FILE (write the resolved plan for diagnostics)\n"
                     "  --profile-column-overlap --far-horizon-lod8-step=N --force-generate\n"
                     "  --seed=N --recipe=surface-world|floating-islands\n"
                     "  --auto-surface-camera (place the 27-tile cube on this seed's surface)\n"
@@ -204,6 +206,13 @@ namespace
                 if(options.MeshExportPath.empty())
                 {std::fprintf(stderr,"--mesh-export needs a file path\n");return false;}
             }
+            else if(arg.starts_with("--world-assembler-manifest-output="))
+            {
+                options.WorldAssemblyManifestOutputPath=std::filesystem::path(
+                    arg.substr(std::string_view("--world-assembler-manifest-output=").size()));
+                if(options.WorldAssemblyManifestOutputPath.empty())
+                {std::fprintf(stderr,"--world-assembler-manifest-output needs a file path\n");return false;}
+            }
             else if(arg.starts_with("--workers="))
             {if(!readInt("--workers=",options.WorkerCount))return false;}
             else if(arg.starts_with("--clip-radius="))
@@ -314,6 +323,22 @@ 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;}
+    if(!options.WorldAssemblyManifestOutputPath.empty())
+    {
+        std::error_code directoryError;
+        const auto parent=options.WorldAssemblyManifestOutputPath.parent_path();
+        if(!parent.empty())std::filesystem::create_directories(parent,directoryError);
+        if(directoryError)
+        {std::fprintf(stderr,"Manifest output directory failed: %s\n",directoryError.message().c_str());return 2;}
+        std::ofstream manifestFile(options.WorldAssemblyManifestOutputPath,std::ios::binary|std::ios::trunc);
+        if(!manifestFile)
+        {std::fprintf(stderr,"Cannot write manifest output: %s\n",options.WorldAssemblyManifestOutputPath.string().c_str());return 2;}
+        manifestFile<<worldAssembly.ToJson()<<'\n';
+        if(!manifestFile)
+        {std::fprintf(stderr,"Manifest output write failed: %s\n",options.WorldAssemblyManifestOutputPath.string().c_str());return 2;}
+        std::printf("[WorldAssemblyManifest] path=%s status=PASS\n",
+            options.WorldAssemblyManifestOutputPath.string().c_str());
+    }
     if(options.AutoSurfaceCamera)
     {
         constexpr std::int64_t UnitsPerVoxel=VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;