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

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;
+}