perf(core): FloatingIslands whole view 16.7 s -> 7.4 s (L51); research R20

Measured first: 45% of FI tiles are all-air, yet FloatingIslandFieldV1 returned unknown for any box near
an island AABB (25,536 unknown boxes, 0 tile skips). Conservative ranges for island bodies, root lobes,
buttresses, connectors, surface detail and smooth-min budgets now let the shared box classifier prove FI
air/solid (216 tile skips; 28.6 M audited samples, 0 violations). The X8 path reuses its FI preflight
samples. LOD7-8 far-shell and column work is skipped outside per-tile island/connector influence bounds
(farHorizonVersion 4 -> 5). FI 16.74 -> 7.36 s (-56%), FI moving entering-tile p50 halved; SW unchanged.
Peer determinism (Clang/GCC W1/W8/W12, random cameras) PASS; fast/medium/full PASS.
Research R20: world-type catalogue and dreamcore/liminal concepts (revised after a deepening pass).

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

Standalone/Core/src/FloatingIslandsInternal.h

@@ -695,6 +695,38 @@ namespace floating_island_detail
         return (std::sqrt(std::max(q, 0.0)) - 1.0) * Parameters.MinimumRadius;
     }
 
+    inline FRootLobeParameters RootLobeParametersForBounds(
+        const FloatingIslandRecipeV1& recipe,const FloatingIslandAnchorV1& island,
+        std::int32_t rootIndex)
+    {
+        constexpr std::array<std::array<double,2>,4> pattern{{
+            {{-0.92,-0.12}},{{0.28,0.98}},{{0.83,-0.42}},{{-0.16,-0.94}}}};
+        const std::uint64_t salt=0x524f4f540000ull+static_cast<std::uint64_t>(rootIndex);
+        const std::uint64_t roll=Roll(recipe.seed,island.stableId,salt);
+        const double radius=static_cast<double>(island.radiusSubvoxels);
+        const double rootDepth=radius*Q16ToDouble(recipe.rootDepthRatioQ16);
+        const double crustBottom=static_cast<double>(IslandCrustBottom(recipe,island));
+        const bool centralButtress=rootIndex==4;
+        const double orbit=centralButtress?0.0:radius*(0.17+0.07*UnitHash(roll));
+        const double rootX=static_cast<double>(island.centerSubvoxels[0])
+            +(centralButtress?0.0:pattern[static_cast<std::size_t>(rootIndex)][0]*orbit);
+        const double rootY=static_cast<double>(island.centerSubvoxels[1])
+            +(centralButtress?0.0:pattern[static_cast<std::size_t>(rootIndex)][1]*orbit);
+        const double shortRootVariation=UnitHash(Roll(recipe.seed,island.stableId,salt^0x4c454eull));
+        const double lengthRatio=centralButtress?1.0:(rootIndex==0?1.0
+            :Q16ToDouble(island.taperEndQ16)*(0.82+0.18*shortRootVariation));
+        const double lowerDepth=rootDepth*lengthRatio;
+        const double embedDepth=rootDepth*(centralButtress?0.22:(rootIndex==0?0.30:0.22));
+        const double verticalRadius=0.5*(lowerDepth+embedDepth);
+        const double centerZ=crustBottom+0.5*(embedDepth-lowerDepth);
+        const double rx=radius*(centralButtress?0.25
+            :0.15+0.055*UnitHash(Roll(recipe.seed,island.stableId,salt^0x5258ull)));
+        const double ry=radius*(centralButtress?0.25
+            :0.15+0.065*UnitHash(Roll(recipe.seed,island.stableId,salt^0x5259ull)));
+        return {rootX,rootY,centerZ,rx*rx,ry*ry,verticalRadius*verticalRadius,
+            std::min({rx,ry,verticalRadius})};
+    }
+
     inline double ApplySurfaceDetail(const FloatingIslandRecipeV1& recipe,
                                      std::uint64_t featureId, double structural,
                                      double x, double y, double z, double detailScale = 1.0)
@@ -845,6 +877,227 @@ namespace floating_island_detail
         return std::max({horizontal, upper, lower});
     }
 
+    struct FScalarRange
+    {
+        double minimum=0.0,maximum=0.0;
+    };
+
+    struct FDensityRange
+    {
+        double minimum=0.0,maximum=0.0;
+    };
+
+    inline double DistanceToRange(double minimum,double maximum,double value)
+    {
+        if(value<minimum)return minimum-value;
+        if(value>maximum)return value-maximum;
+        return 0.0;
+    }
+
+    inline double MaximumDistanceToRange(double minimum,double maximum,double value)
+    {
+        return std::max(std::abs(minimum-value),std::abs(maximum-value));
+    }
+
+    inline FScalarRange AffineRange(double xMinimum,double xMaximum,double xOffset,
+        double xScale,double yMinimum,double yMaximum,double yOffset,double yScale)
+    {
+        const double xa=(xMinimum-xOffset)*xScale,xb=(xMaximum-xOffset)*xScale;
+        const double ya=(yMinimum-yOffset)*yScale,yb=(yMaximum-yOffset)*yScale;
+        return {std::min(xa,xb)+std::min(ya,yb),
+            std::max(xa,xb)+std::max(ya,yb)};
+    }
+
+    inline FScalarRange AbsoluteRange(double minimum,double maximum)
+    {
+        const double minimumAbsolute=minimum<=0.0&&maximum>=0.0
+            ?0.0:std::min(std::abs(minimum),std::abs(maximum));
+        return {minimumAbsolute,std::max(std::abs(minimum),std::abs(maximum))};
+    }
+
+    inline double RectangleSdf(double x,double y)
+    {
+        return std::hypot(std::max(x,0.0),std::max(y,0.0))
+            +std::min(std::max(x,y),0.0);
+    }
+
+    inline double RoundedBoxSdf(double x,double y,double z)
+    {
+        return std::sqrt(std::max(x,0.0)*std::max(x,0.0)
+            +std::max(y,0.0)*std::max(y,0.0)
+            +std::max(z,0.0)*std::max(z,0.0))
+            +std::min(std::max(x,std::max(y,z)),0.0);
+    }
+
+    inline FDensityRange RootLobeRange(const FloatingIslandRecipeV1& recipe,
+        const FloatingIslandAnchorV1& island,std::int32_t rootIndex,
+        const std::array<double,3>& minimum,const std::array<double,3>& maximum)
+    {
+        const FRootLobeParameters root=RootLobeParametersForBounds(recipe,island,rootIndex);
+        const double dxMinimum=DistanceToRange(minimum[0],maximum[0],root.RootX);
+        const double dyMinimum=DistanceToRange(minimum[1],maximum[1],root.RootY);
+        const double dzMinimum=DistanceToRange(minimum[2],maximum[2],root.CenterZ);
+        const double dxMaximum=MaximumDistanceToRange(minimum[0],maximum[0],root.RootX);
+        const double dyMaximum=MaximumDistanceToRange(minimum[1],maximum[1],root.RootY);
+        const double dzMaximum=MaximumDistanceToRange(minimum[2],maximum[2],root.CenterZ);
+        const double qMinimum=dxMinimum*dxMinimum/root.RadiusXSquared
+            +dyMinimum*dyMinimum/root.RadiusYSquared
+            +dzMinimum*dzMinimum/root.VerticalRadiusSquared;
+        const double qMaximum=dxMaximum*dxMaximum/root.RadiusXSquared
+            +dyMaximum*dyMaximum/root.RadiusYSquared
+            +dzMaximum*dzMaximum/root.VerticalRadiusSquared;
+        return {(std::sqrt(std::max(qMinimum,0.0))-1.0)*root.MinimumRadius,
+            (std::sqrt(std::max(qMaximum,0.0))-1.0)*root.MinimumRadius};
+    }
+
+    inline FDensityRange IslandDensityRange(const FloatingIslandRecipeV1& recipe,
+        const FloatingIslandAnchorV1& island,const std::array<double,3>& minimum,
+        const std::array<double,3>& maximum)
+    {
+        const double radius=static_cast<double>(island.radiusSubvoxels);
+        const double contour=static_cast<double>(recipe.contourWarpSubvoxels);
+        const double radialMinimum=std::hypot(
+            DistanceToRange(minimum[0],maximum[0],
+                static_cast<double>(island.centerSubvoxels[0])),
+            DistanceToRange(minimum[1],maximum[1],
+                static_cast<double>(island.centerSubvoxels[1])));
+        const double radialMaximum=std::max({
+            std::hypot(minimum[0]-island.centerSubvoxels[0],minimum[1]-island.centerSubvoxels[1]),
+            std::hypot(minimum[0]-island.centerSubvoxels[0],maximum[1]-island.centerSubvoxels[1]),
+            std::hypot(maximum[0]-island.centerSubvoxels[0],minimum[1]-island.centerSubvoxels[1]),
+            std::hypot(maximum[0]-island.centerSubvoxels[0],maximum[1]-island.centerSubvoxels[1])});
+
+        const double top=static_cast<double>(island.topZSubvoxels);
+        const double topDrop=std::max(0.0,(1.0-Q16ToDouble(recipe.topFlattenQ16))
+            *static_cast<double>(island.topHalfSubvoxels)*2.0);
+        const double topDistanceMinimum=minimum[2]-top;
+        const double topDistanceMaximum=maximum[2]-(top-topDrop);
+        const double sideDistanceMinimum=radialMinimum-std::max(0.0,radius+contour);
+        const double sideDistanceMaximum=recipe.geometryVersion<2
+            ?radialMaximum:radialMaximum-std::max(0.0,radius-contour);
+        double lowerMinimum=0.0,lowerMaximum=0.0;
+        if(recipe.geometryVersion<2)
+        {
+            const double bottom=static_cast<double>(island.bottomZSubvoxels);
+            lowerMinimum=bottom-maximum[2];
+            lowerMaximum=bottom-minimum[2];
+        }
+        else
+        {
+            const double crust=static_cast<double>(IslandCrustBottom(recipe,island));
+            lowerMinimum=crust-maximum[2];
+            lowerMaximum=crust+radius*0.16-minimum[2];
+        }
+        double structuralMinimum=std::max({topDistanceMinimum,
+            sideDistanceMinimum,lowerMinimum});
+        double structuralMaximum=std::max({topDistanceMaximum,
+            sideDistanceMaximum,lowerMaximum});
+
+        if(recipe.geometryVersion>=2)
+        {
+            const double rootBlend=std::clamp(radius*0.12,2.0*Q,5.0*Q);
+            for(std::int32_t root=0;root<RootCount(recipe,island);++root)
+            {
+                const FDensityRange rootRange=RootLobeRange(recipe,island,root,minimum,maximum);
+                structuralMinimum=std::min(structuralMinimum,rootRange.minimum)-rootBlend*0.25;
+                structuralMaximum=std::min(structuralMaximum,rootRange.maximum);
+            }
+            if(recipe.geometryVersion>=5&&recipe.geometryVersion<8
+                &&island.ordinal==recipe.anchorIslandOrdinal
+                &&recipe.anchorRootBottomZSubvoxels<island.bottomZSubvoxels)
+            {
+                const double rootTop=static_cast<double>(IslandCrustBottom(recipe,island));
+                const double rootBottom=static_cast<double>(recipe.anchorRootBottomZSubvoxels);
+                const double rootRadius=static_cast<double>(recipe.anchorRootRadiusSubvoxels);
+                const double anchorMinimum=std::max({radialMinimum-rootRadius,
+                    rootBottom-maximum[2],minimum[2]-rootTop});
+                const double anchorMaximum=std::max({radialMaximum-0.92*rootRadius,
+                    rootBottom-minimum[2],maximum[2]-rootTop});
+                const double anchorDetail=0.75*static_cast<double>(recipe.roughnessSubvoxels);
+                const double anchorBlend=std::clamp(rootRadius*0.12,3.0*Q,6.0*Q);
+                structuralMinimum=std::min(structuralMinimum,anchorMinimum-anchorDetail)
+                    -anchorBlend*0.25;
+                structuralMaximum=std::min(structuralMaximum,anchorMaximum+anchorDetail);
+            }
+        }
+        const double finalDetail=static_cast<double>(recipe.roughnessSubvoxels);
+        return {structuralMinimum-finalDetail,structuralMaximum+finalDetail};
+    }
+
+    inline FDensityRange ConnectorDensityRange(const FloatingIslandRecipeV1& recipe,
+        const FloatingIslandConnectorV1& edge,const std::array<double,3>& minimum,
+        const std::array<double,3>& maximum)
+    {
+        const double ax=static_cast<double>(edge.startSubvoxels[0]);
+        const double ay=static_cast<double>(edge.startSubvoxels[1]);
+        const double az=static_cast<double>(edge.startSubvoxels[2]);
+        const double dx=static_cast<double>(edge.endSubvoxels[0])-ax;
+        const double dy=static_cast<double>(edge.endSubvoxels[1])-ay;
+        const double dz=static_cast<double>(edge.endSubvoxels[2])-az;
+        const double length=std::hypot(dx,dy);
+        if(!(length>0.0))return {static_cast<double>(MaxDensity),static_cast<double>(MaxDensity)};
+        const double ux=dx/length,uy=dy/length;
+        const FScalarRange along=AffineRange(minimum[0],maximum[0],ax,ux,
+            minimum[1],maximum[1],ay,uy);
+        const FScalarRange signedSide=AffineRange(minimum[0],maximum[0],ax,-uy,
+            minimum[1],maximum[1],ay,ux);
+        const FScalarRange side=AbsoluteRange(signedSide.minimum,signedSide.maximum);
+        const double qxMinimum=side.minimum-static_cast<double>(edge.halfWidthSubvoxels);
+        const double qxMaximum=side.maximum-static_cast<double>(edge.halfWidthSubvoxels);
+        const FScalarRange alongCenter=AbsoluteRange(along.minimum-0.5*length,
+            along.maximum-0.5*length);
+        const double qyMinimum=alongCenter.minimum-0.5*length;
+        const double qyMaximum=alongCenter.maximum-0.5*length;
+        const double horizontalMinimum=RectangleSdf(qxMinimum,qyMinimum);
+        const double horizontalMaximum=RectangleSdf(qxMaximum,qyMaximum);
+
+        const double tMinimum=std::clamp(along.minimum/length,0.0,1.0);
+        const double tMaximum=std::clamp(along.maximum/length,0.0,1.0);
+        const double deckAtMinimum=az+dz*tMinimum;
+        const double deckAtMaximum=az+dz*tMaximum;
+        const double deckMinimum=std::min(deckAtMinimum,deckAtMaximum);
+        const double deckMaximum=std::max(deckAtMinimum,deckAtMaximum);
+        const std::uint64_t westernEdgeId=StableId(recipe.seed,0x200000000ull,
+            0x425249444745ull);
+        const bool westernSupportConnector=edge.stableId==westernEdgeId;
+        if(recipe.geometryVersion>=2&&WorldAssemblyEvaluatorVersion>=183
+            &&westernSupportConnector)
+        {
+            const double minimumHalfWidth=static_cast<double>(recipe.routeConstraints.capsuleRadiusSubvoxels+Q);
+            const double baseHalfWidth=static_cast<double>(edge.halfWidthSubvoxels);
+            const double halfWidthMinimum=std::max(minimumHalfWidth,baseHalfWidth-0.48*Q);
+            const double halfWidthMaximum=std::max(minimumHalfWidth,baseHalfWidth+0.48*Q);
+            const double roundingMinimum=std::min({1.5*Q,halfWidthMinimum*0.6,
+                static_cast<double>(edge.thicknessSubvoxels)*0.45});
+            const double roundingMaximum=std::min({1.5*Q,halfWidthMaximum*0.6,
+                static_cast<double>(edge.thicknessSubvoxels)*0.45});
+            const double roundedXMinimum=side.minimum-halfWidthMaximum+roundingMinimum;
+            const double roundedXMaximum=side.maximum-halfWidthMinimum+roundingMaximum;
+            const double roundedYMinimum=alongCenter.minimum-0.5*length+roundingMinimum;
+            const double roundedYMaximum=alongCenter.maximum-0.5*length+roundingMaximum;
+            const double halfThickness=0.5*static_cast<double>(edge.thicknessSubvoxels);
+            const double centerMinimum=deckMinimum-halfThickness;
+            const double centerMaximum=deckMaximum-halfThickness;
+            const double differenceMinimum=minimum[2]-centerMaximum;
+            const double differenceMaximum=maximum[2]-centerMinimum;
+            const FScalarRange absoluteDifference=AbsoluteRange(differenceMinimum,differenceMaximum);
+            const double roundedZMinimum=absoluteDifference.minimum-halfThickness+roundingMinimum;
+            const double roundedZMaximum=absoluteDifference.maximum-halfThickness+roundingMaximum;
+            return {RoundedBoxSdf(roundedXMinimum,roundedYMinimum,roundedZMinimum),
+                RoundedBoxSdf(roundedXMaximum,roundedYMaximum,roundedZMaximum)};
+        }
+
+        const double thickness=static_cast<double>(edge.thicknessSubvoxels);
+        const double maximumArch=recipe.geometryVersion>=2&&WorldAssemblyEvaluatorVersion<172
+            ?2.0*thickness:0.0;
+        const double upperMinimum=minimum[2]-deckMaximum;
+        const double upperMaximum=maximum[2]-deckMinimum;
+        const double lowerMinimum=deckMinimum-thickness-maximumArch-maximum[2];
+        const double lowerMaximum=deckMaximum-thickness-minimum[2];
+        return {std::max({horizontalMinimum,upperMinimum,lowerMinimum}),
+            std::max({horizontalMaximum,upperMaximum,lowerMaximum})};
+    }
+
     inline std::int64_t FieldDensity(const FloatingIslandRecipeV1& recipe,
                                      const FloatingIslandPlanV1& plan,
                                      std::int64_t x, std::int64_t y, std::int64_t z)
@@ -2104,19 +2357,46 @@ FieldInterval FloatingIslandFieldV1::interval(std::int64_t minX, std::int64_t mi
         || !floating_island_detail::ValidScalar(minX) || !floating_island_detail::ValidScalar(minY)
         || !floating_island_detail::ValidScalar(minZ) || !floating_island_detail::ValidScalar(maxX)
         || !floating_island_detail::ValidScalar(maxY) || !floating_island_detail::ValidScalar(maxZ)) return result;
-    const std::array<std::int64_t, 3> minimum{minX, minY, minZ};
-    const std::array<std::int64_t, 3> maximum{maxX, maxY, maxZ};
-    for (const auto& island : plan_->islands)
-        if (floating_island_detail::Intersects(minimum, maximum,
-                island.influenceMinimumSubvoxels, island.influenceMaximumSubvoxels)) return result;
-    for (const auto& edge : plan_->clusterEdges)
-        if (floating_island_detail::Intersects(minimum, maximum,
-                edge.influenceMinimumSubvoxels, edge.influenceMaximumSubvoxels)) return result;
-    // Root is void. A box outside every lobe/taper/blend/connector influence bound proves air.
-    // La racine est le vide : une boite hors des influences bornees prouve l'air.
-    result.known = true;
-    result.minimumDensitySubvoxels = 0;
-    result.maximumDensitySubvoxels = floating_island_detail::MaxDensity;
+    using namespace floating_island_detail;
+    if (plan_->islands.empty())
+        return {true,MaxDensity,MaxDensity};
+
+    const std::array<double,3> minimum{static_cast<double>(minX),
+        static_cast<double>(minY),static_cast<double>(minZ)};
+    const std::array<double,3> maximum{static_cast<double>(maxX),
+        static_cast<double>(maxY),static_cast<double>(maxZ)};
+    double fieldMinimum=static_cast<double>(MaxDensity);
+    double fieldMaximum=static_cast<double>(MaxDensity);
+    for(const auto& island:plan_->islands)
+    {
+        FDensityRange group=IslandDensityRange(*recipe_,island,minimum,maximum);
+        for(const auto& edge:plan_->clusterEdges)
+        {
+            if(edge.fromIslandId!=island.stableId)continue;
+            const FDensityRange connector=ConnectorDensityRange(*recipe_,edge,minimum,maximum);
+            const double detail=recipe_->geometryVersion>=2
+                ?static_cast<double>(recipe_->roughnessSubvoxels):0.0;
+            group.minimum=std::min(group.minimum,connector.minimum-detail)
+                -static_cast<double>(recipe_->blendRadiusSubvoxels)*0.25;
+            group.maximum=std::min(group.maximum,connector.maximum+detail);
+        }
+        fieldMinimum=std::min(fieldMinimum,group.minimum);
+        fieldMaximum=std::min(fieldMaximum,group.maximum);
+    }
+    if(!std::isfinite(fieldMinimum)||!std::isfinite(fieldMaximum))return result;
+
+    // These interval operations are shared by native and future generator classifiers: SDF
+    // intersections take max, unions take min, and smooth unions subtract at most k/4.
+    // Keep two subvoxels of slack for floating bounds followed by the field's integer rounding.
+    // Ces bornes servent les generateurs actuels et futurs : intersections=max, unions=min.
+    const double minimumRounded=std::clamp(std::floor(fieldMinimum)-2.0,
+        -static_cast<double>(MaxDensity),static_cast<double>(MaxDensity));
+    const double maximumRounded=std::clamp(std::ceil(fieldMaximum)+2.0,
+        -static_cast<double>(MaxDensity),static_cast<double>(MaxDensity));
+    if(minimumRounded>maximumRounded)return result;
+    result.known=true;
+    result.minimumDensitySubvoxels=static_cast<std::int64_t>(minimumRounded);
+    result.maximumDensitySubvoxels=static_cast<std::int64_t>(maximumRounded);
     return result;
 }
 

Standalone/Core/src/ShapeWorldInternal.h

@@ -3121,20 +3121,36 @@ public:
         }
         bool bHasLegacySurfaceSample=false;
         bool bHasNativeIslandSample=false;
+        std::array<float,8> NativeIslandDensity{};
+        std::array<bool,8> HasNativeIslandSample{};
         for(int32 Lane=0;Lane<Count;++Lane)
         {
             const float SampleX=static_cast<float>(XStart+Lane*XStep);
             const float SampleY=static_cast<float>(Y);
             const float SampleZ=static_cast<float>(Z);
             bHasLegacySurfaceSample|=UsesLegacySurfaceField(SampleX,SampleY,SampleZ);
-            float IslandDensity=0.0f;
-            bHasNativeIslandSample|=NativeFloatingIslandDensityAt(
-                SampleX,SampleY,SampleZ,IslandDensity);
+            HasNativeIslandSample[static_cast<std::size_t>(Lane)]=NativeFloatingIslandDensityAt(
+                SampleX,SampleY,SampleZ,NativeIslandDensity[static_cast<std::size_t>(Lane)]);
+            bHasNativeIslandSample|=HasNativeIslandSample[static_cast<std::size_t>(Lane)];
         }
         if(bHasLegacySurfaceSample||bHasNativeIslandSample)
         {
             for(int32 Lane=0;Lane<Count;++Lane)
-                OutDensity[Lane]=DensityAtLattice(XStart+Lane*XStep,Y,Z);
+            {
+                const std::size_t Index=static_cast<std::size_t>(Lane);
+                if(HasNativeIslandSample[Index])
+                {
+                    ++ThreadClassificationStats().NativeFloatFieldCalls;
+                    const float SampleX=static_cast<float>(XStart+Lane*XStep);
+                    const float SampleY=static_cast<float>(Y);
+                    const float SampleZ=static_cast<float>(Z);
+                    OutDensity[Lane]=ApplyEditBrushes(ApplyResolvedStrateComposition(
+                        NativeIslandDensity[Index],SampleX,SampleY,SampleZ),
+                        SampleX,SampleY,SampleZ);
+                }
+                else
+                    OutDensity[Lane]=DensityAtLattice(XStart+Lane*XStep,Y,Z);
+            }
             return;
         }
         if(bAnalyticOnly)
@@ -5044,8 +5060,7 @@ public:
         // A box crossing recipes cannot use one field interval; unknown composition stays Mixed.
         // Une boite qui traverse plusieurs recettes reste Mixed, car l'intervalle d'un seul champ ne suffit pas.
         if(bBadPlan||(bSurfaceOverlap&&(bIslandOverlap||bOtherStrateOverlap))
-            ||(bIslandOverlap&&(bIslandOtherStrateOverlap
-                ||(!bSurfaceOverlap&&bOtherStrateOverlap))))
+            ||(bIslandOverlap&&bIslandOtherStrateOverlap))
             return Finish(EVoxelTileClass::Mixed,true);
         // The native interval path below is the exact field selected first by DensityAtLattice
         // for SurfaceWorld and FloatingIslands. Legacy analytic primitives/layer bounds cannot

Standalone/Core/src/VoxelForgeCore.cpp

@@ -2151,14 +2151,43 @@ namespace VoxelForgeCore
                 bHasNativeSurfaceHorizonPlan=bHasNativeSurfaceHorizonPlan
                     ||(TileMinimumZ<=PlanMaximumZ&&TileMaximumZ>=PlanMinimumZ);
             }
+            constexpr int64 IslandQueryPad=2*WorldAssemblySubvoxelsPerVoxel;
+            const std::array<int64,3> TileMinimum={
+                (static_cast<int64>(origin.X)*WorldAssemblySubvoxelsPerVoxel)-IslandQueryPad,
+                (static_cast<int64>(origin.Y)*WorldAssemblySubvoxelsPerVoxel)-IslandQueryPad,
+                (static_cast<int64>(origin.Z)*WorldAssemblySubvoxelsPerVoxel)-IslandQueryPad};
+            const std::array<int64,3> TileMaximum={
+                ((static_cast<int64>(origin.X)+extent)*WorldAssemblySubvoxelsPerVoxel)+IslandQueryPad,
+                ((static_cast<int64>(origin.Y)+extent)*WorldAssemblySubvoxelsPerVoxel)+IslandQueryPad,
+                ((static_cast<int64>(origin.Z)+extent)*WorldAssemblySubvoxelsPerVoxel)+IslandQueryPad};
             for(const auto& Entry:impl_->worldAssembly->floatingIslands)
             {
                 const int64 PlanMinimumZ=static_cast<int64>(std::min(Entry.bottomChunkZ,Entry.topChunkZ))
                     *impl_->resolvedLayout->strateLayoutChunkWidthSubvoxels/WorldAssemblySubvoxelsPerVoxel;
                 const int64 PlanMaximumZ=(static_cast<int64>(std::max(Entry.bottomChunkZ,Entry.topChunkZ)+1))
                     *impl_->resolvedLayout->strateLayoutChunkWidthSubvoxels/WorldAssemblySubvoxelsPerVoxel;
+                if(TileMinimumZ>PlanMaximumZ||TileMaximumZ<PlanMinimumZ)continue;
+
+                const auto IntersectsTile=[&](const auto& Feature)
+                {
+                    for(std::size_t Axis=0;Axis<3;++Axis)
+                        if(Feature.influenceMinimumSubvoxels[Axis]>TileMaximum[Axis]
+                            ||Feature.influenceMaximumSubvoxels[Axis]<TileMinimum[Axis])return false;
+                    return true;
+                };
+                bool bIslandFeatureOverlap=std::any_of(Entry.manifest.plan.islands.begin(),
+                    Entry.manifest.plan.islands.end(),IntersectsTile)
+                    ||std::any_of(Entry.manifest.plan.clusterEdges.begin(),
+                        Entry.manifest.plan.clusterEdges.end(),IntersectsTile);
+                const auto& Recipe=Entry.manifest.recipe;
+                const int64 Bottom=Recipe.layoutMinimumZSubvoxels;
+                const int64 Top=Recipe.layoutMaximumZSubvoxels;
+                const int64 Seal=Recipe.boundarySealSubvoxels;
+                const bool bBoundarySealOverlap=(TileMinimum[2]<=Top&&TileMaximum[2]>=Top-Seal)
+                    ||(Recipe.geometryVersion<3&&TileMinimum[2]<Bottom+Seal
+                        &&TileMaximum[2]>=Bottom);
                 bHasIslandPlanInTile=bHasIslandPlanInTile
-                    ||(TileMinimumZ<=PlanMaximumZ&&TileMaximumZ>=PlanMinimumZ);
+                    ||bIslandFeatureOverlap||bBoundarySealOverlap;
             }
         }
         const bool bUseNativeSurfaceHorizon=key.lod>=5&&!bOverlapsPlayerEdit