wip(assembler): round L23 -- inter-strate passages planned from the resolved layout and carved

After L22 the FI -> SW passage no longer connected the strates (legacy owner-voxel coordinates,
lower end 23 m above SW), and Core never carved passages through the bands. Now the director
plans passages from the resolved layout (PlanResolvedLayoutPassagesV1; deterministic hash of
seed/strates/connection; placement disk from PassageConfig, 8-24 m around (0,0)); shared
composition applies generator field -> bands -> bounded passage carve and support shelf, opening
the bands only along the tunnel. Mouths bind to the strate routes. Capsule audit: 0 blocked /
0 unsupported (325,962 samples FI, 284,319 TunnelNetwork), negative controls detected; all 8
generator kinds exercised. SW away from the passage is bit-identical. Layout V3, evaluator 9.
Open: look not yet natural (stepped tube in FI void, terraced SW arrival); SW-as-upper route
planning fails; Unreal adapter uncompiled.

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -255,7 +255,8 @@ namespace StandaloneStreamBenchmark
         bool bAuditTileShapeReadiness=false,int DiagnosticSlowShapeCompileMs=0,
         bool bAuditBasePageEquivalence=false,bool bAuditRouteParity=false,
         bool bAuditResolvedLayoutBoundaries=false,
-        const VoxelForgeCore::ResolvedLayoutSnapshotV2* ResolvedLayout=nullptr)
+        bool bAuditResolvedLayoutPassages=false,
+        const VoxelForgeCore::ResolvedLayoutSnapshotV3* ResolvedLayout=nullptr)
     {
         using Clock=std::chrono::steady_clock;
         FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -440,6 +441,349 @@ namespace StandaloneStreamBenchmark
             Streamer.Stop();
             std::fprintf(stderr,"[StreamPipeline] full shape build failed: %s\n",BuildError.c_str());return 2;
         }
+        if(bAuditResolvedLayoutPassages)
+        {
+            if(ResolvedLayout==nullptr||!CoreSnapshot.resolvedLayout())
+            {Streamer.Stop();std::fprintf(stderr,"[ResolvedPassageAudit] missing resolved-layout snapshot\n");return 2;}
+            struct FWalkAudit
+            {
+                std::uint64_t segments=0,centers=0,capsuleSamples=0,blocked=0;
+                std::uint64_t supportSamples=0,unsupported=0,gradeFailures=0;
+                std::array<std::array<double,4>,8> firstBlocked{};
+                std::array<std::array<double,4>,8> firstUnsupported{};
+                std::size_t firstBlockedCount=0,firstUnsupportedCount=0;
+                bool passed=false;
+            };
+            const double coreMetres=static_cast<double>(World.CoreVoxelSizeMicrons)/1000000.0;
+            const auto auditPlayerPath=[&](const VoxelForgeCore::World& Field,
+                const std::vector<std::array<double,3>>& path,
+                double supportStartMetres,double supportStepMetres,
+                double supportMaximumMetres,std::uint32_t minimumSupportProbes,
+                double supportProbeRadiusMetres)
+            {
+                FWalkAudit audit;
+                if(path.size()<2)return audit;
+                constexpr std::array<double,7> heights{{-0.84,-0.60,-0.30,0.0,0.30,0.60,0.84}};
+                constexpr std::array<std::array<double,2>,8> directions{{
+                    {{1.0,0.0}},{{0.7071067811865475,0.7071067811865475}},{{0.0,1.0}},
+                    {{-0.7071067811865475,0.7071067811865475}},{{-1.0,0.0}},
+                    {{-0.7071067811865475,-0.7071067811865475}},{{0.0,-1.0}},
+                    {{0.7071067811865475,-0.7071067811865475}}}};
+                const auto solidAt=[&](double xMetres,double yMetres,double zMetres)
+                {
+                    ++audit.capsuleSamples;
+                    const VoxelForgeCore::Vec3d position{xMetres/coreMetres,yMetres/coreMetres,zMetres/coreMetres};
+                    const float density=Field.densityAt(position);
+                    if(density<0.0f)
+                    {
+                        if(audit.firstBlockedCount<audit.firstBlocked.size())
+                        {
+                            audit.firstBlocked[audit.firstBlockedCount++]={xMetres,yMetres,zMetres,density};
+                            std::printf("[ResolvedWalkDispatch] kind=blocked xyz_m=(%.3f,%.3f,%.3f) path=%s\n",
+                                xMetres,yMetres,zMetres,Field.densityDispatchPathAt(position).c_str());
+                        }
+                        ++audit.blocked;return true;
+                    }
+                    return false;
+                };
+                for(std::size_t segment=1;segment<path.size();++segment)
+                {
+                    ++audit.segments;
+                    const auto& a=path[segment-1];const auto& b=path[segment];
+                    const double dx=b[0]-a[0],dy=b[1]-a[1],dz=b[2]-a[2];
+                    const double horizontal=std::hypot(dx,dy)*coreMetres;
+                    const double vertical=std::abs(dz)*coreMetres;
+                    if(horizontal<=1.0e-6||vertical>horizontal*0.2679491924311227)
+                        ++audit.gradeFailures;
+                    const double length=std::sqrt(dx*dx+dy*dy+dz*dz)*coreMetres;
+                    const std::uint64_t intervals=std::max<std::uint64_t>(1,
+                        static_cast<std::uint64_t>(std::ceil(length/0.5)));
+                    for(std::uint64_t step=0;step<=intervals;++step)
+                    {
+                        if(segment>1&&step==0)continue;
+                        const double t=static_cast<double>(step)/intervals;
+                        const double x=(a[0]+dx*t)*coreMetres;
+                        const double y=(a[1]+dy*t)*coreMetres;
+                        const double z=(a[2]+dz*t)*coreMetres;
+                        ++audit.centers;
+                        for(const double h:heights)
+                        {
+                            const double capOffset=std::max(0.0,std::abs(h)-0.54);
+                            const double radial=std::abs(h)<=0.54?0.34
+                                :std::sqrt(std::max(0.0,0.34*0.34-capOffset*capOffset));
+                            solidAt(x,y,z+h);
+                            for(const auto& direction:directions)
+                                solidAt(x+direction[0]*radial,y+direction[1]*radial,z+h);
+                        }
+                        const double footZ=z-0.88;
+                        const std::array<std::array<double,2>,5> supportOffsets{{
+                            {{0.0,0.0}},{{supportProbeRadiusMetres,0.0}},
+                            {{-supportProbeRadiusMetres,0.0}},
+                            {{0.0,supportProbeRadiusMetres}},
+                            {{0.0,-supportProbeRadiusMetres}}}};
+                        std::uint32_t supportedProbes=0;
+                        double firstUnsupportedX=x,firstUnsupportedY=y,lastUnsupportedDensity=0.0;
+                        for(const auto& offset:supportOffsets)
+                        {
+                            const double supportX=x+offset[0],supportY=y+offset[1];
+                            bool supported=false;
+                            for(double depth=supportStartMetres;
+                                depth<=supportMaximumMetres+1.0e-6;depth+=supportStepMetres)
+                            {
+                                ++audit.supportSamples;
+                                lastUnsupportedDensity=Field.densityAt({supportX/coreMetres,
+                                    supportY/coreMetres,(footZ-depth)/coreMetres});
+                                if(lastUnsupportedDensity<0.0)
+                                {
+                                    supported=true;break;
+                                }
+                            }
+                            if(supported)++supportedProbes;
+                            else{firstUnsupportedX=supportX;firstUnsupportedY=supportY;}
+                        }
+                        if(supportedProbes<minimumSupportProbes)
+                        {
+                            ++audit.unsupported;
+                            if(audit.firstUnsupportedCount<audit.firstUnsupported.size())
+                            {
+                                audit.firstUnsupported[audit.firstUnsupportedCount++]={
+                                    firstUnsupportedX,firstUnsupportedY,footZ,lastUnsupportedDensity};
+                                std::printf("[ResolvedWalkDispatch] kind=unsupported xyz_m=(%.3f,%.3f,%.3f) support_probes=%u/5 path=%s\n",
+                                    firstUnsupportedX,firstUnsupportedY,footZ,supportedProbes,
+                                    Field.densityDispatchPathAt({firstUnsupportedX/coreMetres,
+                                        firstUnsupportedY/coreMetres,footZ/coreMetres}).c_str());
+                            }
+                        }
+                    }
+                }
+                audit.passed=audit.centers>0&&audit.blocked==0&&audit.unsupported==0
+                    &&audit.gradeFailures==0;
+                return audit;
+            };
+            const auto qToMetres=[&](std::int64_t q)
+            {return static_cast<double>(q)*World.CoreVoxelSizeMicrons
+                /(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel*1000000.0);};
+            const auto findStratum=[&](std::int32_t index)->const VoxelForgeCore::ResolvedLayoutStratumV2*
+            {
+                const auto it=std::find_if(ResolvedLayout->strates.begin(),ResolvedLayout->strates.end(),
+                    [index](const auto& s){return s.strateIndex==index;});
+                return it==ResolvedLayout->strates.end()?nullptr:&*it;
+            };
+            const auto mouthInContent=[&](std::int32_t index,const std::array<std::int64_t,3>& mouth)
+            {
+                const auto* stratum=findStratum(index);if(!stratum)return false;
+                const std::int64_t zUm=static_cast<std::int64_t>(std::llround(
+                    static_cast<double>(mouth[2])*World.CoreVoxelSizeMicrons
+                        /VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel));
+                return zUm>=stratum->content.bottomMicrometres&&zUm<stratum->content.topMicrometres;
+            };
+            std::uint64_t passageCount=0,passagePasses=0,blockedControls=0;
+            for(const auto& passage:ResolvedLayout->passages)
+            {
+                std::vector<std::array<double,3>> path;path.reserve(passage.controlPoints.size());
+                for(const auto& point:passage.controlPoints)
+                {
+                    const double playerZ=static_cast<double>(point.positionSubvoxels[2]
+                        -point.radiusSubvoxels)+1.13*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel
+                            *1000000.0/World.CoreVoxelSizeMicrons;
+                    path.push_back({qToMetres(point.positionSubvoxels[0])/coreMetres,
+                        qToMetres(point.positionSubvoxels[1])/coreMetres,playerZ/256.0});
+                }
+                const FWalkAudit passageAudit=auditPlayerPath(Shape,path,0.125,0.125,0.25,3,0.45);
+                const auto radialSquared=[](const std::array<std::int64_t,3>& p)
+                {return p[0]*p[0]+p[1]*p[1];};
+                const bool mouthsInRadius=radialSquared(passage.upperMouthSubvoxels)
+                        <=passage.placementRadiusSubvoxels*passage.placementRadiusSubvoxels
+                    &&radialSquared(passage.lowerMouthSubvoxels)
+                        <=passage.placementRadiusSubvoxels*passage.placementRadiusSubvoxels;
+                const bool mouthsInContent=mouthInContent(passage.upperStrateIndex,passage.upperMouthSubvoxels)
+                    &&mouthInContent(passage.lowerStrateIndex,passage.lowerMouthSubvoxels);
+                ++passageCount;passagePasses+=passageAudit.passed&&mouthsInRadius&&mouthsInContent;
+                std::printf("[ResolvedPassageAudit] id=%s interface=%d-%d control_points=%zu center_samples=%llu capsule_samples=%llu blocked=%llu support_samples=%llu unsupported=%llu grade_failures=%llu mouth_content=%d/2 mouth_radius=%d/2 walkability=%s\n",
+                    passage.stableId.c_str(),passage.upperStrateIndex,passage.lowerStrateIndex,
+                    passage.controlPoints.size(),static_cast<unsigned long long>(passageAudit.centers),
+                    static_cast<unsigned long long>(passageAudit.capsuleSamples),
+                    static_cast<unsigned long long>(passageAudit.blocked),
+                    static_cast<unsigned long long>(passageAudit.supportSamples),
+                    static_cast<unsigned long long>(passageAudit.unsupported),
+                    static_cast<unsigned long long>(passageAudit.gradeFailures),mouthsInContent?2:0,
+                    mouthsInRadius?2:0,passageAudit.passed?"PASS":"FAIL");
+                for(std::size_t i=0;i<passageAudit.firstBlockedCount;++i)
+                    std::printf("[ResolvedPassageAuditSample] id=%s kind=blocked xyz_m=(%.3f,%.3f,%.3f) density=%.6f\n",
+                        passage.stableId.c_str(),passageAudit.firstBlocked[i][0],passageAudit.firstBlocked[i][1],
+                        passageAudit.firstBlocked[i][2],passageAudit.firstBlocked[i][3]);
+                for(std::size_t i=0;i<passageAudit.firstUnsupportedCount;++i)
+                    std::printf("[ResolvedPassageAuditSample] id=%s kind=unsupported xyz_m=(%.3f,%.3f,%.3f) density=%.6f\n",
+                        passage.stableId.c_str(),passageAudit.firstUnsupported[i][0],
+                        passageAudit.firstUnsupported[i][1],passageAudit.firstUnsupported[i][2],
+                        passageAudit.firstUnsupported[i][3]);
+            }
+            std::uint64_t routePoints=0,routePasses=0,routeWalkPasses=0,routeBindings=0,routeBindingFailures=0;
+            struct FRouteAuditInput
+            {
+                std::int32_t strateIndex=0;
+                std::vector<std::array<double,3>> path;
+                double supportStart=0.125,supportStep=0.125,supportMaximum=0.25,
+                    supportProbeRadius=0.45;
+                std::uint32_t minimumSupportProbes=3;
+            };
+            std::vector<FRouteAuditInput> routeAuditInputs;
+            for(const auto& stratum:ResolvedLayout->strates)
+            {
+                std::vector<const VoxelForgeCore::ResolvedLayoutAnchorV2*> anchors;
+                for(const auto& anchor:stratum.anchors)
+                    if(anchor.kind=="route_point"&&anchor.values.size()>=3)anchors.push_back(&anchor);
+                if(anchors.size()<2)continue;
+                std::vector<std::array<double,3>> route;route.reserve(anchors.size());
+                for(const auto* anchor:anchors)
+                {
+                    route.push_back({qToMetres(anchor->values[0])/coreMetres,
+                        qToMetres(anchor->values[1])/coreMetres,
+                        qToMetres(anchor->values[2])/coreMetres});
+                    ++routePoints;
+                }
+                double supportStartMetres=0.125,supportStepMetres=0.125,
+                    supportMaximumMetres=0.25,supportProbeRadiusMetres=0.45;
+                std::uint32_t minimumSupportProbes=3;
+                const VoxelForgeCore::WorldAssemblyRouteConstraintsV1* routeConstraints=nullptr;
+                if(Assembly)
+                {
+                    const auto worldRoute=std::find_if(Assembly->plan.strates.begin(),
+                        Assembly->plan.strates.end(),[&](const auto& candidate)
+                            {return candidate.strateIndex==stratum.strateIndex;});
+                    if(worldRoute!=Assembly->plan.strates.end()
+                        &&worldRoute->routeConstraints.version==1)
+                        routeConstraints=&worldRoute->routeConstraints;
+                    const auto islandRoute=std::find_if(Assembly->floatingIslands.begin(),
+                        Assembly->floatingIslands.end(),[&](const auto& candidate)
+                            {return candidate.strateIndex==stratum.strateIndex;});
+                    if(islandRoute!=Assembly->floatingIslands.end()
+                        &&islandRoute->manifest.recipe.routeConstraints.version==1)
+                        routeConstraints=&islandRoute->manifest.recipe.routeConstraints;
+                }
+                if(routeConstraints)
+                {
+                    const double qMetres=coreMetres
+                        /VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
+                    minimumSupportProbes=std::clamp<std::uint32_t>(
+                        routeConstraints->minimumSupportProbes,1,5);
+                    supportProbeRadiusMetres=routeConstraints->supportProbeRadiusSubvoxels*qMetres;
+                    if(stratum.generatorKind=="FloatingIslands")
+                    {
+                        supportStartMetres=(routeConstraints->minimumClearanceSubvoxels
+                            +VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel/2)*qMetres;
+                        supportStepMetres=VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel
+                            *0.5*qMetres;
+                        supportMaximumMetres=(routeConstraints->minimumClearanceSubvoxels
+                            +routeConstraints->supportSearchDepthSubvoxels)*qMetres;
+                    }
+                    else
+                    {
+                        const std::int64_t spacing=std::min<std::int64_t>(
+                            routeConstraints->sweepSpacingSubvoxels,
+                            VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel/4);
+                        supportStepMetres=std::max<std::int64_t>(1,spacing)*qMetres;
+                        supportStartMetres=supportStepMetres;
+                        supportMaximumMetres=routeConstraints->supportSearchDepthSubvoxels*qMetres;
+                    }
+                }
+                const FWalkAudit routeAudit=auditPlayerPath(Shape,route,supportStartMetres,
+                    supportStepMetres,supportMaximumMetres,minimumSupportProbes,
+                    supportProbeRadiusMetres);
+                routeAuditInputs.push_back({stratum.strateIndex,route,supportStartMetres,
+                    supportStepMetres,supportMaximumMetres,supportProbeRadiusMetres,
+                    minimumSupportProbes});
+                bool binding=true;
+                for(const auto& passage:ResolvedLayout->passages)
+                {
+                    const auto equalPosition=[](const auto& a,const auto& b)
+                    {return a[0]==b[0]&&a[1]==b[1]&&a[2]==b[2];};
+                    if(passage.upperStrateIndex==stratum.strateIndex)
+                    {
+                        const std::array<std::int64_t,3> departure{{anchors.back()->values[0],
+                            anchors.back()->values[1],anchors.back()->values[2]}};
+                        binding&=equalPosition(passage.upperMouthSubvoxels,
+                            departure);
+                    }
+                    if(passage.lowerStrateIndex==stratum.strateIndex)
+                    {
+                        const std::array<std::int64_t,3> arrival{{anchors.front()->values[0],
+                            anchors.front()->values[1],anchors.front()->values[2]}};
+                        binding&=equalPosition(passage.lowerMouthSubvoxels,
+                            arrival);
+                    }
+                }
+                ++routePasses;routeWalkPasses+=routeAudit.passed;
+                routeBindings+=binding;routeBindingFailures+=!binding;
+                std::printf("[ResolvedStrateRouteAudit] strate=%d route_points=%zu center_samples=%llu capsule_samples=%llu blocked=%llu support_samples=%llu unsupported=%llu grade_failures=%llu mouth_binding=%s status=%s\n",
+                    stratum.strateIndex,anchors.size(),static_cast<unsigned long long>(routeAudit.centers),
+                    static_cast<unsigned long long>(routeAudit.capsuleSamples),
+                    static_cast<unsigned long long>(routeAudit.blocked),
+                    static_cast<unsigned long long>(routeAudit.supportSamples),
+                    static_cast<unsigned long long>(routeAudit.unsupported),
+                    static_cast<unsigned long long>(routeAudit.gradeFailures),binding?"PASS":"FAIL",
+                    routeAudit.passed&&binding?"PASS":"FAIL");
+                for(std::size_t i=0;i<routeAudit.firstBlockedCount;++i)
+                    std::printf("[ResolvedStrateRouteAuditSample] strate=%d kind=blocked xyz_m=(%.3f,%.3f,%.3f) density=%.6f\n",
+                        stratum.strateIndex,routeAudit.firstBlocked[i][0],routeAudit.firstBlocked[i][1],
+                        routeAudit.firstBlocked[i][2],routeAudit.firstBlocked[i][3]);
+                for(std::size_t i=0;i<routeAudit.firstUnsupportedCount;++i)
+                    std::printf("[ResolvedStrateRouteAuditSample] strate=%d kind=unsupported xyz_m=(%.3f,%.3f,%.3f) density=%.6f\n",
+                        stratum.strateIndex,routeAudit.firstUnsupported[i][0],
+                        routeAudit.firstUnsupported[i][1],routeAudit.firstUnsupported[i][2],
+                        routeAudit.firstUnsupported[i][3]);
+            }
+            const auto controlSnapshot=CoreSnapshot.withoutResolvedLayoutPassages();
+            VoxelForgeCore::World blockedWorld(controlSnapshot);
+            std::string blockedCompileError;
+            const bool blockedCompiled=controlSnapshot
+                &&blockedWorld.compile(ShapeRequest,Scheduler,blockedCompileError);
+            if(blockedCompiled)
+                for(const auto& passage:ResolvedLayout->passages)
+                {
+                    std::vector<std::array<double,3>> path;path.reserve(passage.controlPoints.size());
+                    for(const auto& point:passage.controlPoints)
+                    {
+                        const double playerZ=static_cast<double>(point.positionSubvoxels[2]
+                            -point.radiusSubvoxels)+1.13*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel
+                                *1000000.0/World.CoreVoxelSizeMicrons;
+                        path.push_back({qToMetres(point.positionSubvoxels[0])/coreMetres,
+                            qToMetres(point.positionSubvoxels[1])/coreMetres,playerZ/256.0});
+                    }
+                    const FWalkAudit blockedAudit=auditPlayerPath(blockedWorld,path,
+                        0.125,0.125,0.25,3,0.45);
+                    blockedControls+=blockedAudit.blocked>0&&!blockedAudit.passed;
+                    std::printf("[ResolvedPassageBlockedControl] id=%s blocked_capsule_samples=%llu detected=%s\n",
+                        passage.stableId.c_str(),static_cast<unsigned long long>(blockedAudit.blocked),
+                        blockedAudit.blocked>0&&!blockedAudit.passed?"true":"false");
+                }
+            else
+                std::fprintf(stderr,"[ResolvedPassageBlockedControl] compile_failed=%s\n",blockedCompileError.c_str());
+            if(blockedCompiled)
+                for(const auto& input:routeAuditInputs)
+                {
+                    const FWalkAudit controlRoute=auditPlayerPath(blockedWorld,input.path,
+                        input.supportStart,input.supportStep,input.supportMaximum,
+                        input.minimumSupportProbes,input.supportProbeRadius);
+                    std::printf("[ResolvedStrateRouteBlockedControl] strate=%d blocked=%llu unsupported=%llu status=%s\n",
+                        input.strateIndex,static_cast<unsigned long long>(controlRoute.blocked),
+                        static_cast<unsigned long long>(controlRoute.unsupported),
+                        controlRoute.passed?"PASS":"FAIL");
+                }
+            const bool auditPassed=passageCount>0&&passagePasses==passageCount
+                &&routePasses>0&&routePasses==routeWalkPasses&&routePasses==routeBindings
+                &&routeBindingFailures==0
+                &&blockedCompiled&&blockedControls==passageCount;
+            std::printf("[ResolvedPassageAuditSummary] interfaces=%llu passed=%llu strate_routes=%llu route_walkable=%llu route_points=%llu route_bindings=%llu route_binding_failures=%llu blocked_controls=%llu/%llu status=%s\n",
+                static_cast<unsigned long long>(passageCount),static_cast<unsigned long long>(passagePasses),
+                static_cast<unsigned long long>(routePasses),static_cast<unsigned long long>(routeWalkPasses),
+                static_cast<unsigned long long>(routePoints),
+                static_cast<unsigned long long>(routeBindings),static_cast<unsigned long long>(routeBindingFailures),
+                static_cast<unsigned long long>(blockedControls),static_cast<unsigned long long>(passageCount),
+                auditPassed?"PASS":"FAIL");
+            if(!auditPassed)
+            {Streamer.Stop();return 10;}
+        }
         if(bAuditResolvedLayoutBoundaries)
         {
             if(ResolvedLayout==nullptr)