wip(L27, side branch): passages cross open voids inside shared natural rock columns

Unsupported passage runs > 12.5 m become a solid relief-bearing column (ceiling/island to
ground, flared base) with the helix inside, for every recipe; FI anchor uses the same path.
All 4 styles x both recipes: 0/0/0, 0 open-air, naturalness pass; no-long-bridge audit (L26
fails it). Deterministic, Clang = GCC. Look approved; cost +35% SW / +19% FI blocks merge (L28).

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -726,7 +726,8 @@ namespace StandaloneStreamBenchmark
             }
             struct FPassageOpenAirAudit
             {
-                std::uint64_t supportSamples=0,violations=0,legacyViolations=0,bridgeSamples=0;
+                std::uint64_t supportSamples=0,violations=0,legacyViolations=0;
+                std::uint64_t columnSamples=0,shortSpanSamples=0;
                 std::uint64_t routeSupportSamples=0,routeSupportViolations=0;
                 std::array<std::array<double,4>,8> firstViolations{};
                 std::size_t firstViolationCount=0;
@@ -773,10 +774,14 @@ namespace StandaloneStreamBenchmark
                         ++audit.legacyViolations;
                     if(nativeDensity>=0.0f&&passageDensity<0.0f)
                     {
-                        const bool connectedBridge=!routeSupport
+                        const bool connectedColumn=!routeSupport
                             &&passageSegment!=std::numeric_limits<std::size_t>::max()
-                            &&Field.isPassageBridgeSample(passageIndex,passageSegment,sample);
-                        if(connectedBridge){++audit.bridgeSamples;return;}
+                            &&Field.isPassageColumnSample(passageIndex,passageSegment,sample);
+                        if(connectedColumn){++audit.columnSamples;return;}
+                        const bool groundedShortSpan=!routeSupport
+                            &&passageSegment!=std::numeric_limits<std::size_t>::max()
+                            &&Field.isPassageShortSpanSample(passageIndex,passageSegment,sample);
+                        if(groundedShortSpan){++audit.shortSpanSamples;return;}
                         audit.routeSupportViolations+=routeSupport;
                         if(audit.firstViolationCount<audit.firstViolations.size())
                             audit.firstViolations[audit.firstViolationCount++]={xMetres,yMetres,
@@ -894,20 +899,23 @@ namespace StandaloneStreamBenchmark
                 }
                 return audit;
             };
-            struct FPassageBridgeAudit
+            struct FPassageColumnAudit
             {
-                std::uint64_t spans=0,connectedEnds=0,crossSections=0,crossSectionFailures=0;
-                double minimumThicknessMetres=std::numeric_limits<double>::infinity();
-                double maximumThicknessMetres=0.0;
-                double thicknessReliefPeakToPeakMetres=0.0;
+                std::uint64_t columns=0,shortSpans=0,connectedEnds=0,routeSections=0;
+                std::uint64_t routeSectionFailures=0,wallSections=0,wallFailures=0;
+                double minimumWallMetres=std::numeric_limits<double>::infinity();
+                double minimumSurfaceRadiusMetres=std::numeric_limits<double>::infinity();
+                double maximumSurfaceRadiusMetres=0.0;
+                double surfaceRadiusReliefMetres=0.0;
+                double longestShortSpanMetres=0.0;
                 bool passed=true;
             };
-            const auto auditPassageBridges=[&](const VoxelForgeCore::World& Field,
+            const auto auditPassageColumns=[&](const VoxelForgeCore::World& Field,
                 const VoxelForgeCore::World& Native,
                 const VoxelForgeCore::ResolvedLayoutPassageV1& passage,
                 std::size_t passageIndex)
             {
-                FPassageBridgeAudit audit;
+                FPassageColumnAudit audit;
                 const double qMetres=coreMetres
                     /VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
                 constexpr std::array<std::array<double,2>,5> supportOffsets{{
@@ -928,37 +936,67 @@ namespace StandaloneStreamBenchmark
                     }
                     return supported>=3;
                 };
-                const auto bridgeSolidAt=[&](std::size_t segment,double x,double y,double z)
+                const auto columnSolidAt=[&](std::size_t segment,double x,double y,double z)
                 {
-                    return Field.isPassageBridgeSample(passageIndex,segment,
+                    return Field.isPassageColumnSample(passageIndex,segment,
                         {x/coreMetres,y/coreMetres,z/coreMetres});
                 };
-                const auto thicknessAt=[&](std::size_t segment,double x,double y,double floor)
+                const auto shortSpanSolidAt=[&](std::size_t segment,double x,double y,double z)
                 {
-                    double thickness=0.0;
-                    for(double depth=0.125;depth<=6.0+1.0e-6;depth+=0.125)
-                    {
-                        if(!bridgeSolidAt(segment,x,y,floor-depth))break;
-                        thickness=depth;
-                    }
-                    return thickness;
+                    return Field.isPassageShortSpanSample(passageIndex,segment,
+                        {x/coreMetres,y/coreMetres,z/coreMetres});
                 };
-                for(const auto& range:Field.passageBridgeRanges())
+                const auto crossings=Field.passageVoidCrossings();
+                for(const auto& crossing:crossings)
                 {
-                    if(range.passageIndex!=passageIndex
-                        ||range.lastSegment+1>=passage.controlPoints.size())continue;
-                    ++audit.spans;
-                    const bool connectedStart=endpointConnected(range.startPointSubvoxels);
-                    const bool connectedEnd=endpointConnected(range.endPointSubvoxels);
+                    if(crossing.passageIndex!=passageIndex)continue;
+                    const bool connectedStart=endpointConnected(crossing.startPointSubvoxels);
+                    const bool connectedEnd=endpointConnected(crossing.endPointSubvoxels);
+                    if(!crossing.needsColumn)
+                    {
+                        ++audit.shortSpans;
+                        audit.longestShortSpanMetres=std::max(audit.longestShortSpanMetres,
+                            crossing.unsupportedLengthMetres);
+                        const bool shortSpanPass=connectedStart&&connectedEnd
+                            &&crossing.unsupportedLengthMetres<=12.5
+                            &&crossing.lastSegment+1<passage.controlPoints.size();
+                        audit.passed&=shortSpanPass;
+                        std::printf("[PassageGroundedShortSpanAudit] id=%s segments=%zu..%zu length_m=%.3f threshold_m=12.500 connected=%d/2 status=%s\n",
+                            passage.stableId.c_str(),crossing.firstSegment,crossing.lastSegment,
+                            crossing.unsupportedLengthMetres,
+                            static_cast<int>(connectedStart)+static_cast<int>(connectedEnd),
+                            shortSpanPass?"PASS":"FAIL");
+                        const std::size_t segment=std::min(crossing.firstSegment,
+                            passage.controlPoints.size()-2);
+                        const auto& a=passage.controlPoints[segment];
+                        const auto& b=passage.controlPoints[segment+1];
+                        const double x=(qToMetres(a.positionSubvoxels[0])
+                            +qToMetres(b.positionSubvoxels[0]))*0.5;
+                        const double y=(qToMetres(a.positionSubvoxels[1])
+                            +qToMetres(b.positionSubvoxels[1]))*0.5;
+                        const double z=(qToMetres(a.positionSubvoxels[2])
+                            +qToMetres(b.positionSubvoxels[2]))*0.5
+                            -qToMetres(a.radiusSubvoxels+b.radiusSubvoxels)*0.5+0.13;
+                        audit.passed&=shortSpanSolidAt(segment,x,y,z-0.25);
+                        continue;
+                    }
+                    if(crossing.lastSegment+1>=passage.controlPoints.size())
+                    {audit.passed=false;continue;}
+                    ++audit.columns;
                     audit.connectedEnds+=connectedStart+connectedEnd;
-                    const std::size_t segmentCount=range.lastSegment-range.firstSegment+1;
-                    const std::size_t probeCount=std::min<std::size_t>(256,segmentCount);
-                    double spanMinimumThickness=std::numeric_limits<double>::infinity();
-                    double spanMaximumThickness=0.0;
-                    std::uint64_t spanCrossSections=0,spanCrossSectionFailures=0;
+                    const double axisX=qToMetres(crossing.columnAxisSubvoxels[0]);
+                    const double axisY=qToMetres(crossing.columnAxisSubvoxels[1]);
+                    const double minimumRadius=qToMetres(crossing.columnMinimumRadiusSubvoxels);
+                    const double maximumRadius=qToMetres(crossing.columnMaximumRadiusSubvoxels);
+                    const double minimumWall=minimumRadius-crossing.maximumRouteOffsetMetres
+                        -crossing.maximumBoreRadiusMetres-0.50;
+                    audit.minimumWallMetres=std::min(audit.minimumWallMetres,minimumWall);
+                    const std::size_t segmentCount=crossing.lastSegment-crossing.firstSegment+1;
+                    const std::size_t probeCount=std::min<std::size_t>(128,segmentCount);
+                    std::uint64_t crossingRouteFailures=0,crossingWallFailures=0;
                     for(std::size_t probe=0;probe<probeCount;++probe)
                     {
-                        const std::size_t segment=range.firstSegment
+                        const std::size_t segment=crossing.firstSegment
                             +std::min(segmentCount-1,(probe*segmentCount)/probeCount);
                         const auto& a=passage.controlPoints[segment];
                         const auto& b=passage.controlPoints[segment+1];
@@ -973,42 +1011,96 @@ namespace StandaloneStreamBenchmark
                         const double radius=(qToMetres(a.radiusSubvoxels)
                             +qToMetres(b.radiusSubvoxels))*0.5;
                         const double floor=z-radius+0.13;
-                        const double thickness=thicknessAt(segment,x,y,floor);
-                        spanMinimumThickness=std::min(spanMinimumThickness,thickness);
-                        spanMaximumThickness=std::max(spanMaximumThickness,thickness);
-                        audit.minimumThicknessMetres=std::min(audit.minimumThicknessMetres,thickness);
-                        audit.maximumThicknessMetres=std::max(audit.maximumThicknessMetres,thickness);
-                        const double dx=bx-ax,dy=by-ay,horizontal=std::hypot(dx,dy);
-                        if(horizontal<=1.0e-6)continue;
-                        const double nx=dy/horizontal,ny=-dx/horizontal;
-                        bool crossSectionSolid=true;
-                        for(const double offset:{-2.5,0.0,2.5})
-                            crossSectionSolid&=bridgeSolidAt(segment,x+nx*offset,
-                                y+ny*offset,floor-2.0);
-                        ++audit.crossSections;
-                        ++spanCrossSections;
-                        spanCrossSectionFailures+=!crossSectionSolid;
-                        audit.crossSectionFailures+=!crossSectionSolid;
+                        const VoxelForgeCore::Vec3d supportPoint{
+                            x/coreMetres,y/coreMetres,(floor-2.0)/coreMetres};
+                        const bool solidUnderRoute=columnSolidAt(segment,x,y,floor-2.0)
+                            ||Native.densityAt(supportPoint)<0.0f;
+                        ++audit.routeSections;
+                        audit.routeSectionFailures+=!solidUnderRoute;
+                        crossingRouteFailures+=!solidUnderRoute;
+                        const double radial=std::hypot(x-axisX,y-axisY);
+                        const double wallRadius=radial+radius+1.5;
+                        const double outwardX=radial>1.0e-6?(x-axisX)/radial:1.0;
+                        const double outwardY=radial>1.0e-6?(y-axisY)/radial:0.0;
+                        const bool wallSolid=columnSolidAt(segment,
+                            axisX+outwardX*wallRadius,axisY+outwardY*wallRadius,z);
+                        ++audit.wallSections;
+                        audit.wallFailures+=!wallSolid;
+                        crossingWallFailures+=!wallSolid;
                     }
-                    const double relief=std::isfinite(spanMinimumThickness)
-                        ?spanMaximumThickness-spanMinimumThickness:0.0;
-                    audit.thicknessReliefPeakToPeakMetres=std::max(
-                        audit.thicknessReliefPeakToPeakMetres,relief);
-                    const bool spanPass=connectedStart&&connectedEnd
-                        &&spanCrossSections>=3&&spanCrossSectionFailures==0
-                        &&spanMinimumThickness>=2.75
-                        &&spanMaximumThickness<=6.5
-                        &&audit.thicknessReliefPeakToPeakMetres>=0.20;
-                    audit.passed&=spanPass;
-                    std::printf("[PassageRockBridgeAudit] id=%s segments=%zu..%zu gap_m=%.3f connected_ends=%d/2 width_at_least_m=5.000 cross_sections=%llu/%llu thickness_m=%.3f..%.3f relief_p2p_m=%.3f status=%s\n",
-                        passage.stableId.c_str(),range.firstSegment,range.lastSegment,
-                        range.unsupportedLengthMetres,static_cast<int>(connectedStart)
-                            +static_cast<int>(connectedEnd),
-                        static_cast<unsigned long long>(spanCrossSections-spanCrossSectionFailures),
-                        static_cast<unsigned long long>(spanCrossSections),
-                        std::isfinite(spanMinimumThickness)?spanMinimumThickness:0.0,
-                        spanMaximumThickness,relief,
-                        spanPass?"PASS":"FAIL");
+                    double crossingMinimumSurfaceRadius=std::numeric_limits<double>::infinity();
+                    double crossingMaximumSurfaceRadius=0.0;
+                    std::array<double,6> meanRadiusByHeight{};
+                    std::size_t heightSamples=0;
+                    constexpr double RayStepMetres=0.25;
+                    constexpr std::array<double,6> HeightFractions{{0.25,0.35,0.45,0.55,0.65,0.75}};
+                    constexpr std::size_t DirectionCount=16;
+                    const double topMetres=qToMetres(crossing.columnTopZSubvoxels);
+                    const double bottomMetres=qToMetres(crossing.columnBottomZSubvoxels);
+                    const double rayStart=crossing.maximumRouteOffsetMetres
+                        +crossing.maximumBoreRadiusMetres+0.75;
+                    for(const double heightFraction:HeightFractions)
+                    {
+                        const double z=topMetres+(bottomMetres-topMetres)*heightFraction;
+                        double heightMeanRadius=0.0;
+                        std::uint64_t heightRayCount=0;
+                        for(std::size_t direction=0;direction<DirectionCount;++direction)
+                        {
+                            const double angle=2.0*3.14159265358979323846
+                                *direction/DirectionCount;
+                            double lastSolidRadius=0.0;
+                            bool enteredColumn=false;
+                            const std::size_t raySteps=static_cast<std::size_t>(std::ceil(
+                                (maximumRadius+2.0-rayStart)/RayStepMetres));
+                            for(std::size_t step=0;step<=raySteps;++step)
+                            {
+                                const double rayRadius=rayStart+step*RayStepMetres;
+                                const VoxelForgeCore::Vec3d point{
+                                    (axisX+rayRadius*std::cos(angle))/coreMetres,
+                                    (axisY+rayRadius*std::sin(angle))/coreMetres,
+                                    z/coreMetres};
+                                if(Field.densityAt(point)<0.0f)
+                                {enteredColumn=true;lastSolidRadius=rayRadius;}
+                                else if(enteredColumn)break;
+                            }
+                            if(!enteredColumn)continue;
+                            heightMeanRadius+=lastSolidRadius;
+                            ++heightRayCount;
+                            crossingMinimumSurfaceRadius=std::min(crossingMinimumSurfaceRadius,
+                                lastSolidRadius);
+                            crossingMaximumSurfaceRadius=std::max(crossingMaximumSurfaceRadius,
+                                lastSolidRadius);
+                        }
+                        if(heightRayCount==0)continue;
+                        meanRadiusByHeight[heightSamples++]=heightMeanRadius/heightRayCount;
+                    }
+                    const double crossingSurfaceRelief=heightSamples>=2
+                        ?*std::max_element(meanRadiusByHeight.begin(),
+                            meanRadiusByHeight.begin()+heightSamples)
+                            -*std::min_element(meanRadiusByHeight.begin(),
+                                meanRadiusByHeight.begin()+heightSamples):0.0;
+                    audit.minimumSurfaceRadiusMetres=std::min(audit.minimumSurfaceRadiusMetres,
+                        crossingMinimumSurfaceRadius);
+                    audit.maximumSurfaceRadiusMetres=std::max(audit.maximumSurfaceRadiusMetres,
+                        crossingMaximumSurfaceRadius);
+                    audit.surfaceRadiusReliefMetres=std::max(audit.surfaceRadiusReliefMetres,
+                        crossingSurfaceRelief);
+                    const double measuredWall=crossingMinimumSurfaceRadius
+                        -crossing.maximumRouteOffsetMetres-crossing.maximumBoreRadiusMetres;
+                    const bool columnPass=connectedStart&&connectedEnd
+                        &&minimumWall>=1.50&&crossingRouteFailures==0
+                        &&crossingWallFailures==0&&std::isfinite(measuredWall)
+                        &&measuredWall>=1.50&&crossingSurfaceRelief>=0.20;
+                    audit.passed&=columnPass;
+                    std::printf("[PassageRockColumnAudit] id=%s segments=%zu..%zu span_m=%.3f axis_m=(%.3f,%.3f) connected=%d/2 route_support=%llu/%llu wall_margin_m=%.3f threshold_m=1.500 radii_m=%.3f..%.3f relief_p2p_m=%.3f nominal_radius_m=%.3f status=%s\n",
+                        passage.stableId.c_str(),crossing.firstSegment,crossing.lastSegment,
+                        crossing.unsupportedLengthMetres,axisX,axisY,
+                        static_cast<int>(connectedStart)+static_cast<int>(connectedEnd),
+                        static_cast<unsigned long long>(probeCount-crossingRouteFailures),
+                        static_cast<unsigned long long>(probeCount),measuredWall,
+                        crossingMinimumSurfaceRadius,crossingMaximumSurfaceRadius,
+                        crossingSurfaceRelief,qToMetres(crossing.columnNominalRadiusSubvoxels),
+                        columnPass?"PASS":"FAIL");
                 }
                 return audit;
             };
@@ -1022,6 +1114,7 @@ namespace StandaloneStreamBenchmark
                         Assembly->floatingIslands.end(),[&](const auto& value)
                             {return value.strateIndex==stratum.strateIndex;});
                     if(anchor==stratum.anchors.end()||islandPlan==Assembly->floatingIslands.end())continue;
+                    if(islandPlan->manifest.recipe.geometryVersion>=8)continue;
                     const auto ordinal=islandPlan->manifest.recipe.anchorIslandOrdinal;
                     if(ordinal>=islandPlan->manifest.plan.islands.size())continue;
                     const auto& anchorIsland=islandPlan->manifest.plan.islands[ordinal];
@@ -1110,9 +1203,34 @@ namespace StandaloneStreamBenchmark
             };
             std::uint64_t passageCount=0,passagePasses=0,blockedControls=0,naturalPasses=0;
             std::uint64_t openAirViolations=0,openAirLegacyViolations=0,openAirSamples=0;
-            std::uint64_t openAirAudits=0,openAirBridgeSamples=0,bridgeSpans=0,
-                bridgeConnectedEnds=0;
-            bool bridgeAuditsPassed=true;
+            std::uint64_t openAirAudits=0,openAirColumnSamples=0,openAirShortSpanSamples=0;
+            std::uint64_t columnCrossings=0,shortGroundedSpans=0,columnConnectedEnds=0;
+            std::uint64_t columnRouteFailures=0,columnWallFailures=0;
+            double longestUncolumnedSpanMetres=0.0,longestShortSpanMetres=0.0;
+            double l26LegacyBridgeSpanMetres=0.0;
+            bool columnAuditsPassed=true,noLongBridgeAuditPassed=true;
+            bool l26NegativeControlApplicable=false;
+            const auto plannedVoidCrossings=Shape.passageVoidCrossings();
+            for(const auto& crossing:plannedVoidCrossings)
+            {
+                if(crossing.needsColumn)continue;
+                longestUncolumnedSpanMetres=std::max(longestUncolumnedSpanMetres,
+                    crossing.unsupportedLengthMetres);
+            }
+            for(std::size_t passageIndex=0;passageIndex<ResolvedLayout->passages.size();
+                ++passageIndex)
+            {
+                const auto& passage=ResolvedLayout->passages[passageIndex];
+                const auto* upper=findStratum(passage.upperStrateIndex);
+                const auto* lower=findStratum(passage.lowerStrateIndex);
+                if(!upper||!lower||lower->generatorKind!="SurfaceWorld"
+                    ||upper->generatorKind=="FloatingIslands")continue;
+                l26NegativeControlApplicable=true;
+                for(const auto& crossing:plannedVoidCrossings)
+                    if(crossing.passageIndex==passageIndex)
+                        l26LegacyBridgeSpanMetres=std::max(l26LegacyBridgeSpanMetres,
+                            crossing.unsupportedLengthMetres);
+            }
             for(std::size_t passageIndex=0;passageIndex<ResolvedLayout->passages.size();++passageIndex)
             {
                 const auto& passage=ResolvedLayout->passages[passageIndex];
@@ -1131,15 +1249,21 @@ namespace StandaloneStreamBenchmark
                 const FPassageNaturalnessAudit naturalAudit=auditPassageNaturalness(Shape,passage);
                 const FPassageOpenAirAudit openAirAudit=auditPassageOpenAir(Shape,blockedWorld,
                     passage,passageIndex);
-                const FPassageBridgeAudit bridgeAudit=auditPassageBridges(Shape,blockedWorld,
+                const FPassageColumnAudit columnAudit=auditPassageColumns(Shape,blockedWorld,
                     passage,passageIndex);
                 openAirSamples+=openAirAudit.supportSamples;
                 openAirViolations+=openAirAudit.violations;
                 openAirLegacyViolations+=openAirAudit.legacyViolations;
-                openAirBridgeSamples+=openAirAudit.bridgeSamples;
-                bridgeSpans+=bridgeAudit.spans;
-                bridgeConnectedEnds+=bridgeAudit.connectedEnds;
-                bridgeAuditsPassed&=bridgeAudit.passed;
+                openAirColumnSamples+=openAirAudit.columnSamples;
+                openAirShortSpanSamples+=openAirAudit.shortSpanSamples;
+                columnCrossings+=columnAudit.columns;
+                shortGroundedSpans+=columnAudit.shortSpans;
+                columnConnectedEnds+=columnAudit.connectedEnds;
+                columnRouteFailures+=columnAudit.routeSectionFailures;
+                columnWallFailures+=columnAudit.wallFailures;
+                longestShortSpanMetres=std::max(longestShortSpanMetres,
+                    columnAudit.longestShortSpanMetres);
+                columnAuditsPassed&=columnAudit.passed;
                 ++openAirAudits;
                 const auto radialSquared=[](const std::array<std::int64_t,3>& p)
                 {return p[0]*p[0]+p[1]*p[1];};
@@ -1167,10 +1291,11 @@ namespace StandaloneStreamBenchmark
                     static_cast<unsigned long long>(naturalAudit.wallSamples),
                     static_cast<unsigned long long>(naturalAudit.missingWallSamples),
                     naturalAudit.passed?"PASS":"FAIL");
-                std::printf("[PassageOpenAirAudit] id=%s support_samples=%llu violations=%llu bridge_samples=%llu l24_ungated_violations=%llu route_support_samples=%llu route_support_violations=%llu spacing_m=%.3f status=%s\n",
+                std::printf("[PassageOpenAirAudit] id=%s support_samples=%llu violations=%llu column_samples=%llu short_span_samples=%llu l24_ungated_violations=%llu route_support_samples=%llu route_support_violations=%llu spacing_m=%.3f status=%s\n",
                     passage.stableId.c_str(),static_cast<unsigned long long>(openAirAudit.supportSamples),
                     static_cast<unsigned long long>(openAirAudit.violations),
-                    static_cast<unsigned long long>(openAirAudit.bridgeSamples),
+                    static_cast<unsigned long long>(openAirAudit.columnSamples),
+                    static_cast<unsigned long long>(openAirAudit.shortSpanSamples),
                     static_cast<unsigned long long>(openAirAudit.legacyViolations),
                     static_cast<unsigned long long>(openAirAudit.routeSupportSamples),
                     static_cast<unsigned long long>(openAirAudit.routeSupportViolations),
@@ -1229,12 +1354,12 @@ namespace StandaloneStreamBenchmark
                     const VoxelForgeCore::Vec3d nativePosition{sample[0]/coreMetres,
                         sample[1]/coreMetres,sample[2]/coreMetres};
                     const float nativeDensity=blockedWorld.densityAt(nativePosition);
-                    const bool bridgeVolume=Shape.isPassageBridgeSample(passageIndex,
+                    const bool passageColumn=Shape.isPassageColumnSample(passageIndex,
                         nearestSegment,nativePosition);
-                    std::printf("[ResolvedPassageAuditSample] id=%s kind=blocked xyz_m=(%.3f,%.3f,%.3f) density=%.6f native_density=%.6f segment=%zu t=%.3f passage_segment=%zu passage_sdf_m=%.3f bridge_volume=%d native_path=%s\n",
+                    std::printf("[ResolvedPassageAuditSample] id=%s kind=blocked xyz_m=(%.3f,%.3f,%.3f) density=%.6f native_density=%.6f segment=%zu t=%.3f passage_segment=%zu passage_sdf_m=%.3f passage_column=%d native_path=%s\n",
                         passage.stableId.c_str(),sample[0],sample[1],sample[2],sample[3],
                         nativeDensity,nearestSegment,nearestT,nearestPassageSegment,
-                        nearestPassageSdf,bridgeVolume?1:0,
+                        nearestPassageSdf,passageColumn?1:0,
                         blockedWorld.densityDispatchPathAt(nativePosition).c_str());
                 }
                 for(std::size_t i=0;i<passageAudit.firstUnsupportedCount;++i)
@@ -1255,15 +1380,15 @@ namespace StandaloneStreamBenchmark
                     const double firstZ=(sample[2]-0.125)/coreMetres;
                     const VoxelForgeCore::Vec3d bridgeProbe{sample[0]/coreMetres,
                         sample[1]/coreMetres,(sample[2]-0.25)/coreMetres};
-                    const bool bridgeAtSupport=Shape.isPassageBridgeSample(passageIndex,
+                    const bool columnAtSupport=Shape.isPassageColumnSample(passageIndex,
                         segment,bridgeProbe);
-                    std::printf("[ResolvedPassageSupportSegment] id=%s segment=%zu route_z_m=%.3f..%.3f centers=%llu unsupported=%llu native_unsupported=%llu first_foot_m=(%.3f,%.3f,%.3f) bridge_at_d025=%d native_support_probes=%u/5 native_density_d0125_d1_d2_d4=(%.6f,%.6f,%.6f,%.6f) native_path=%s\n",
+                    std::printf("[ResolvedPassageSupportSegment] id=%s segment=%zu route_z_m=%.3f..%.3f centers=%llu unsupported=%llu native_unsupported=%llu first_foot_m=(%.3f,%.3f,%.3f) column_at_d025=%d native_support_probes=%u/5 native_density_d0125_d1_d2_d4=(%.6f,%.6f,%.6f,%.6f) native_path=%s\n",
                         passage.stableId.c_str(),segment,
                         std::min(a[2],b[2])*coreMetres,std::max(a[2],b[2])*coreMetres,
                         static_cast<unsigned long long>(item.centers),
                         static_cast<unsigned long long>(item.unsupported),
                         static_cast<unsigned long long>(item.nativeUnsupported),
-                        sample[0],sample[1],sample[2],bridgeAtSupport?1:0,
+                        sample[0],sample[1],sample[2],columnAtSupport?1:0,
                         item.firstNativeSupportedProbes,item.firstNativeDensities[0],item.firstNativeDensities[1],
                         item.firstNativeDensities[2],item.firstNativeDensities[3],
                         blockedWorld.densityDispatchPathAt({firstX,firstY,firstZ}).c_str());
@@ -1429,19 +1554,37 @@ namespace StandaloneStreamBenchmark
             std::printf("[PassageOpenAirNegativeControl] source=L24_ungated_support unsupported_samples=%llu detected=%s\n",
                 static_cast<unsigned long long>(openAirLegacyViolations),
                 l24OpenAirControlDetected?"true":"false");
-            std::printf("[PassageOpenAirAuditSummary] interfaces=%llu samples=%llu violations=%llu bridge_samples=%llu l24_negative_control=%s status=%s\n",
+            std::printf("[PassageOpenAirAuditSummary] interfaces=%llu samples=%llu violations=%llu column_samples=%llu short_span_samples=%llu l24_negative_control=%s status=%s\n",
                 static_cast<unsigned long long>(openAirAudits),
                 static_cast<unsigned long long>(openAirSamples),
                 static_cast<unsigned long long>(openAirViolations),
-                static_cast<unsigned long long>(openAirBridgeSamples),
+                static_cast<unsigned long long>(openAirColumnSamples),
+                static_cast<unsigned long long>(openAirShortSpanSamples),
                 l24OpenAirControlDetected?"DETECTED":"MISSED",
                 openAirAudits==passageCount&&openAirViolations==0&&l24OpenAirControlDetected
                     ?"PASS":"FAIL");
-            std::printf("[PassageRockBridgeAuditSummary] spans=%llu connected_ends=%llu/%llu status=%s\n",
-                static_cast<unsigned long long>(bridgeSpans),
-                static_cast<unsigned long long>(bridgeConnectedEnds),
-                static_cast<unsigned long long>(bridgeSpans*2),
-                bridgeAuditsPassed?"PASS":"FAIL");
+            const bool l26NoLongBridgeControlDetected=l26NegativeControlApplicable
+                &&l26LegacyBridgeSpanMetres>12.5;
+            const bool l26NoLongBridgeControlPass=!l26NegativeControlApplicable
+                ||l26NoLongBridgeControlDetected;
+            noLongBridgeAuditPassed=longestUncolumnedSpanMetres<=12.5
+                &&l26NoLongBridgeControlPass;
+            std::printf("[PassageNoLongBridgeNegativeControl] source=L26_SurfaceWorld_bridge applicable=%s longest_uncolumned_m=%.3f threshold_m=12.500 detected=%s\n",
+                l26NegativeControlApplicable?"true":"false",l26LegacyBridgeSpanMetres,
+                l26NoLongBridgeControlDetected?"true":"false");
+            std::printf("[PassageNoLongBridgeAudit] columns=%llu short_grounded_spans=%llu longest_uncolumned_m=%.3f threshold_m=12.500 longest_short_span_m=%.3f l26_negative_control=%s status=%s\n",
+                static_cast<unsigned long long>(columnCrossings),
+                static_cast<unsigned long long>(shortGroundedSpans),longestUncolumnedSpanMetres,
+                longestShortSpanMetres,l26NegativeControlApplicable
+                    ?(l26NoLongBridgeControlDetected?"DETECTED":"MISSED"):"NOT_APPLICABLE",
+                noLongBridgeAuditPassed?"PASS":"FAIL");
+            std::printf("[PassageRockColumnAuditSummary] columns=%llu connected_ends=%llu/%llu short_spans=%llu wall_or_support_failures=%llu status=%s\n",
+                static_cast<unsigned long long>(columnCrossings),
+                static_cast<unsigned long long>(columnConnectedEnds),
+                static_cast<unsigned long long>(columnCrossings*2),
+                static_cast<unsigned long long>(shortGroundedSpans),
+                static_cast<unsigned long long>(columnRouteFailures+columnWallFailures),
+                columnAuditsPassed?"PASS":"FAIL");
             const bool l23SmoothWallDetected=!looksNatural(0.0,0.0);
             std::printf("[PassageNaturalnessNegativeControl] source=L23_smooth_unrelieved_wall relief_p2p_m=0.000 threshold_m=%.3f detected=%s\n",
                 MinimumWallReliefMetres,l23SmoothWallDetected?"true":"false");
@@ -1452,7 +1595,7 @@ namespace StandaloneStreamBenchmark
             const bool auditPassed=passageCount>0&&passagePasses==passageCount
                 &&naturalPasses==passageCount&&l23SmoothWallDetected
                 &&openAirAudits==passageCount&&openAirViolations==0&&l24OpenAirControlDetected
-                &&bridgeAuditsPassed
+                &&columnAuditsPassed&&noLongBridgeAuditPassed
                 &&routePasses>0&&routePasses==routeWalkPasses&&routePasses==routeBindings
                 &&routeBindingFailures==0
                 &&blockedCompiled&&blockedControls==passageCount;