proto: liminal pass 2 - hills to the horizon, swept road over a cloud floor, pillar grid (L142)

Captures stream LOD0-8 (hills repeat at 80 m to the horizon). Road: cubic swept solid deck, 376.8 m, 8 m wide, max
12.06 deg, 17 supports, cloud floor ~45 m below; walk audit 0 blocked/unsupported, 300 m negative control fails as
expected. 15x15 identical pillar grid at 76 m. Owner canonical hashes unchanged; fast tier, Clang/GCC green.

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

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -1882,8 +1882,11 @@ int main(int argc,char** argv)
             ownerJsonRoot.Get("motif_family_override").Data);
         const bool hasLiminalRoad=!std::holds_alternative<std::nullptr_t>(
             ownerJsonRoot.Get("liminal_road_override").Data);
-        if(hasMotifFamily&&hasLiminalRoad)
-        {std::fprintf(stderr,"motif_family_override and liminal_road_override cannot be combined\n");return 2;}
+        const bool hasLiminalPillarGrid=!std::holds_alternative<std::nullptr_t>(
+            ownerJsonRoot.Get("liminal_pillar_grid_override").Data);
+        if((hasMotifFamily&&hasLiminalRoad)||(hasMotifFamily&&hasLiminalPillarGrid)
+            ||(hasLiminalRoad&&hasLiminalPillarGrid))
+        {std::fprintf(stderr,"liminal content overrides must be used in separate fixtures\n");return 2;}
         if(hasMotifFamily)
         {
             std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1> requests;
@@ -1914,22 +1917,62 @@ int main(int argc,char** argv)
         }
         if(hasLiminalRoad)
         {
-            std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1> requests(1);
-            if(!StandaloneWorldAssemblyPrototype::BuildLiminalRoadRequest(ownerJsonRoot,
-                    *ownerWorld,worldAssembly,resolvedLayout,requests.front(),error)
+            std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1> requests;
+            if(!StandaloneWorldAssemblyPrototype::BuildLiminalRoadRequests(ownerJsonRoot,
+                    *ownerWorld,worldAssembly,resolvedLayout,requests,error)
                 ||!VoxelForgeCore::ResolveResolvedLayoutStampsV1(
                     resolvedLayout,seed,requests,error))
             {std::fprintf(stderr,"Liminal road resolution failed: %s\n",error.c_str());return 2;}
-            const auto& road=resolvedLayout.stamps.front();
-            std::printf("[LiminalRoadResolved] vocabulary=%u id=%s strate=%d shape=rounded_dais "
-                "center_m=(%.3f,%.3f,%.3f) top_m=%.3f span_m=%.3f width_m=%.3f "
-                "grade_deg=0.000 placement=free route_keepout=PASS band_clearance=PASS status=PASS\n",
-                resolvedLayout.stampVocabularyVersion,road.stableId.c_str(),road.strateIndex,
-                road.positionMicrometres[0]/1.0e6,road.positionMicrometres[1]/1.0e6,
-                road.positionMicrometres[2]/1.0e6,
-                (road.positionMicrometres[2]+road.halfExtentsMicrometres[2])/1.0e6,
-                2.0*road.halfExtentsMicrometres[0]/1.0e6,
-                2.0*road.halfExtentsMicrometres[1]/1.0e6);
+            std::vector<const VoxelForgeCore::ResolvedLayoutStampV1*> deck;
+            std::size_t supportCount=0;
+            const std::string deckPrefix="liminal/road-clouds-v2/deck/";
+            const std::string supportPrefix="liminal/road-clouds-v2/support/";
+            for(const auto& stamp:resolvedLayout.stamps)
+            {
+                if(stamp.stableId.starts_with(deckPrefix))deck.push_back(&stamp);
+                else if(stamp.stableId.starts_with(supportPrefix))++supportCount;
+            }
+            std::sort(deck.begin(),deck.end(),[](const auto* a,const auto* b)
+                {return a->stableId<b->stableId;});
+            double pathLength=0.0,maxGradeDegrees=0.0;
+            for(std::size_t i=0;i<deck.size();++i)
+            {
+                const auto* segment=deck[i];
+                const double dx=(segment->sweepEndpointsMicrometres[1][0]
+                    -segment->sweepEndpointsMicrometres[0][0])/1.0e6;
+                const double dy=(segment->sweepEndpointsMicrometres[1][1]
+                    -segment->sweepEndpointsMicrometres[0][1])/1.0e6;
+                const double dz=std::abs(segment->sweepEndpointsMicrometres[1][2]
+                    -segment->sweepEndpointsMicrometres[0][2])/1.0e6;
+                const double horizontal=std::hypot(dx,dy);
+                pathLength+=horizontal;
+                maxGradeDegrees=std::max(maxGradeDegrees,
+                    std::atan2(dz,horizontal)*57.29577951308232);
+            }
+            const double width=deck.empty()?0.0:
+                2.0*deck.front()->halfExtentsMicrometres[1]/1.0e6;
+            std::printf("[LiminalRoadResolved] vocabulary=%u id=liminal/road-clouds-v2 "
+                "strate=%d shape=swept_deck_segments deck_segments=%zu supports=%zu "
+                "path_length_m=%.3f width_m=%.3f grade_max_deg=%.3f "
+                "placement=free route_keepout=PASS band_clearance=PASS status=%s\n",
+                resolvedLayout.stampVocabularyVersion,
+                deck.empty()?-1:deck.front()->strateIndex,deck.size(),supportCount,pathLength,
+                width,maxGradeDegrees,deck.size()>1&&pathLength>=300.0&&width>=3.0
+                    &&maxGradeDegrees<=15.0?"PASS":"FAIL");
+            if(deck.size()<2||pathLength<80.0||width<3.0||maxGradeDegrees>15.0)
+            {std::fprintf(stderr,"Liminal road resolved outside the walkable road bounds\n");return 2;}
+        }
+        if(hasLiminalPillarGrid)
+        {
+            std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1> requests;
+            if(!StandaloneWorldAssemblyPrototype::BuildLiminalPillarGridRequests(ownerJsonRoot,
+                    *ownerWorld,worldAssembly,resolvedLayout,requests,error)
+                ||!VoxelForgeCore::ResolveResolvedLayoutStampsV1(
+                    resolvedLayout,seed,requests,error))
+            {std::fprintf(stderr,"Liminal pillar-grid resolution failed: %s\n",error.c_str());return 2;}
+            std::printf("[LiminalPillarGridResolved] vocabulary=%u pillars=%zu shape=identical_vertical_cylinders "
+                "placement=regular_grid route_keepout=PASS band_clearance=PASS status=PASS\n",
+                resolvedLayout.stampVocabularyVersion,resolvedLayout.stamps.size());
         }
         if(options.LandmarkChamberDemo)
         {