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/Core/src/ResolvedLayoutInternal.h

@@ -4,7 +4,9 @@
 #include "VoxelForgeCore/VoxelForgeCore.h"
 
 #include <algorithm>
+#include <cmath>
 #include <iomanip>
+#include <limits>
 #include <sstream>
 
 namespace VoxelForgeCore
@@ -66,7 +68,7 @@ namespace
         b.behaviour=value.Get("behaviour").String();
         b.densitySide=value.Get("density_side").String();b.capPath=value.Get("cap_path").String();return b;
     }
-    std::string LayoutBodyJson(const ResolvedLayoutSnapshotV2& s)
+    std::string LayoutBodyJson(const ResolvedLayoutSnapshotV3& s)
     {
         std::ostringstream out;out<<"{\"schema_version\":"<<s.schemaVersion
             <<",\"world_identity\":"<<LayoutEscape(s.worldIdentity)
@@ -113,6 +115,29 @@ namespace
             }
             out<<"]}";
         }
+        out<<"],\"passages\":[";
+        for(std::size_t i=0;i<s.passages.size();++i)
+        {
+            if(i)out<<',';const auto& p=s.passages[i];
+            out<<"{\"stable_id\":"<<LayoutEscape(p.stableId)
+                <<",\"upper_strate_index\":"<<p.upperStrateIndex
+                <<",\"lower_strate_index\":"<<p.lowerStrateIndex
+                <<",\"placement_radius_q\":"<<p.placementRadiusSubvoxels
+                <<",\"upper_mouth_q\":["<<p.upperMouthSubvoxels[0]<<','
+                <<p.upperMouthSubvoxels[1]<<','<<p.upperMouthSubvoxels[2]
+                <<"],\"lower_mouth_q\":["<<p.lowerMouthSubvoxels[0]<<','
+                <<p.lowerMouthSubvoxels[1]<<','<<p.lowerMouthSubvoxels[2]
+                <<"],\"mouth_radius_q\":"<<p.mouthRadiusSubvoxels
+                <<",\"mid_radius_q\":"<<p.midRadiusSubvoxels<<",\"control_points\":[";
+            for(std::size_t j=0;j<p.controlPoints.size();++j)
+            {
+                if(j)out<<',';const auto& point=p.controlPoints[j];
+                out<<"{\"position_q\":["<<point.positionSubvoxels[0]<<','
+                    <<point.positionSubvoxels[1]<<','<<point.positionSubvoxels[2]
+                    <<"],\"radius_q\":"<<point.radiusSubvoxels<<'}';
+            }
+            out<<"]}";
+        }
         out<<"]}";return out.str();
     }
     std::int64_t LayoutInt(const VFJson::Value& obj,std::string_view key)
@@ -121,19 +146,76 @@ namespace
     {return obj.Get(key).String();}
     bool LayoutBool(const VFJson::Value& obj,std::string_view key,bool fallback=false)
     {return obj.Get(key).Boolean(fallback);}
+    std::uint64_t PassageHash(std::uint64_t value)
+    {
+        value+=0x9e3779b97f4a7c15ull;
+        value=(value^(value>>30))*0xbf58476d1ce4e5b9ull;
+        value=(value^(value>>27))*0x94d049bb133111ebull;
+        return value^(value>>31);
+    }
+    std::uint64_t PassageSeed(std::int32_t seed,std::int32_t upper,
+                              std::int32_t lower,std::uint32_t connection,
+                              std::uint32_t salt)
+    {
+        std::uint64_t h=PassageHash(static_cast<std::uint32_t>(seed));
+        h=PassageHash(h^static_cast<std::uint32_t>(upper));
+        h=PassageHash(h^static_cast<std::uint32_t>(lower));
+        h=PassageHash(h^connection);return PassageHash(h^salt);
+    }
+    std::uint64_t PassageIsqrt(std::uint64_t n)
+    {
+        std::uint64_t x=0,bit=std::uint64_t{1}<<62;
+        while(bit>n)bit>>=2;
+        while(bit)
+        {
+            if(n>=x+bit){n-=x+bit;x=(x>>1)+bit;}
+            else x>>=1;
+            bit>>=2;
+        }
+        return x;
+    }
+    std::int64_t PassageRoundRatio(std::int64_t value,std::int64_t numerator,
+                                  std::int64_t denominator)
+    {
+        if(denominator<=0)return 0;
+        const bool negative=value<0;
+        const std::uint64_t magnitude=static_cast<std::uint64_t>(negative?-value:value);
+        const std::uint64_t product=magnitude*static_cast<std::uint64_t>(numerator);
+        const std::uint64_t rounded=(product+static_cast<std::uint64_t>(denominator)/2)
+            /static_cast<std::uint64_t>(denominator);
+        return negative?-static_cast<std::int64_t>(rounded):static_cast<std::int64_t>(rounded);
+    }
+    std::array<std::int64_t,2> PassageRandomXY(std::uint64_t seed,
+        std::int64_t inner,std::int64_t outer)
+    {
+        if(outer<=0)return {};
+        inner=std::clamp(inner,std::int64_t{0},outer);
+        const std::uint64_t span=static_cast<std::uint64_t>(outer)*2+1;
+        for(std::uint32_t attempt=0;attempt<64;++attempt)
+        {
+            const std::uint64_t hx=PassageHash(seed+2ull*attempt);
+            const std::uint64_t hy=PassageHash(seed+2ull*attempt+1);
+            const std::int64_t x=static_cast<std::int64_t>(hx%span)-outer;
+            const std::int64_t y=static_cast<std::int64_t>(hy%span)-outer;
+            const std::uint64_t radiusSquared=static_cast<std::uint64_t>(x*x+y*y);
+            if(radiusSquared<=static_cast<std::uint64_t>(outer*outer)
+                &&radiusSquared>=static_cast<std::uint64_t>(inner*inner))return {x,y};
+        }
+        return {outer,0};
+    }
 }
 
-std::string ResolvedLayoutSnapshotV2::ToJson() const
+std::string ResolvedLayoutSnapshotV3::ToJson() const
 {
     const std::string body=LayoutBodyJson(*this);
     return body.substr(0,body.size()-1)+",\"stable_identity\":"
-        +LayoutEscape(stableIdentity.empty()?"resolved-layout-v2-fnv64:"+LayoutHex(LayoutHash(body)):stableIdentity)+"}";
+        +LayoutEscape(stableIdentity.empty()?"resolved-layout-v3-fnv64:"+LayoutHex(LayoutHash(body)):stableIdentity)+"}";
 }
 
-bool ResolvedLayoutSnapshotV2::finalize(std::string& error)
+bool ResolvedLayoutSnapshotV3::finalize(std::string& error)
 {
     error.clear();
-    if(schemaVersion!=ResolvedLayoutSchemaVersionV2||worldIdentity.empty()||strates.empty()
+    if(schemaVersion!=ResolvedLayoutSchemaVersionV3||worldIdentity.empty()||strates.empty()
         ||strateLayoutChunkSizeMicrometres==0||strateLayoutChunkWidthSubvoxels<=0)
     {error="resolved layout has an unsupported version, empty world identity, or no strates";return false;}
     std::stable_sort(strates.begin(),strates.end(),[](const auto& a,const auto& b)
@@ -149,22 +231,37 @@ bool ResolvedLayoutSnapshotV2::finalize(std::string& error)
         if(x.interiorTopMicrometres<=x.interiorBottomMicrometres||x.voxelSizeMicrometres==0)
         {error="resolved layout contains an invalid interior interval or voxel size";return false;}
     }
+    const std::int64_t playerCenterAboveFloorQ=static_cast<std::int64_t>(std::llround(
+        1.13*WorldAssemblySubvoxelsPerVoxel*1000000.0/coreVoxelSizeMicrometres));
+    for(auto& passage:passages)
+    {
+        passage.lowerMouthControlIndex=passage.controlPoints.empty()?0:passage.controlPoints.size()-1;
+        for(std::size_t i=1;i<passage.controlPoints.size();++i)
+        {
+            const auto& point=passage.controlPoints[i];
+            if(point.positionSubvoxels[0]==passage.lowerMouthSubvoxels[0]
+                &&point.positionSubvoxels[1]==passage.lowerMouthSubvoxels[1]
+                &&point.positionSubvoxels[2]-point.radiusSubvoxels+playerCenterAboveFloorQ
+                    ==passage.lowerMouthSubvoxels[2])
+                passage.lowerMouthControlIndex=i;
+        }
+    }
     stableIdentity.clear();const std::string body=LayoutBodyJson(*this);
-    stableIdentity="resolved-layout-v2-fnv64:"+LayoutHex(LayoutHash(body));
+    stableIdentity="resolved-layout-v3-fnv64:"+LayoutHex(LayoutHash(body));
     std::vector<ResolvedLayoutIssueV2> issues;
-    return validate(ResolvedLayoutValidationModeV2::compatibility,issues,error);
+    return validate(ResolvedLayoutValidationModeV3::compatibility,issues,error);
 }
 
-bool ResolvedLayoutSnapshotV2::validate(ResolvedLayoutValidationModeV2 mode,
+bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
     std::vector<ResolvedLayoutIssueV2>& issues,std::string& error) const
 {
     issues.clear();error.clear();
-    if(schemaVersion!=ResolvedLayoutSchemaVersionV2||worldIdentity.empty()||strates.empty()
+    if(schemaVersion!=ResolvedLayoutSchemaVersionV3||worldIdentity.empty()||strates.empty()
         ||strateLayoutChunkSizeMicrometres==0||strateLayoutChunkWidthSubvoxels<=0)
     {error="resolved layout schema/world/strata header is invalid";return false;}
     const auto add=[&](std::string code,std::string detail)
     {issues.push_back({std::move(code),std::move(detail)});};
-    const bool strict=mode==ResolvedLayoutValidationModeV2::strict;
+    const bool strict=mode==ResolvedLayoutValidationModeV3::strict;
     for(std::size_t i=0;i<strates.size();++i)
     {
         const auto& s=strates[i];
@@ -262,16 +359,110 @@ bool ResolvedLayoutSnapshotV2::validate(ResolvedLayoutValidationModeV2 mode,
             }
         }
     }
+    const auto findStratum=[this](std::int32_t index)->const ResolvedLayoutStratumV2*
+    {
+        const auto it=std::find_if(strates.begin(),strates.end(),[index](const auto& s)
+            {return s.strateIndex==index;});
+        return it==strates.end()?nullptr:&*it;
+    };
+    std::vector<std::string> passageIds;
+    for(std::size_t i=0;strict&&i+1<strates.size();++i)
+    {
+        const auto& upper=strates[i];const auto& lower=strates[i+1];
+        if(std::none_of(passages.begin(),passages.end(),[&](const auto& p)
+            {return p.upperStrateIndex==upper.strateIndex&&p.lowerStrateIndex==lower.strateIndex;}))
+            add("missing_passage_interface",upper.stableId+" has no passage to "+lower.stableId);
+    }
+    for(const auto& passage:passages)
+    {
+        const auto* upper=findStratum(passage.upperStrateIndex);
+        const auto* lower=findStratum(passage.lowerStrateIndex);
+        if(passage.stableId.empty()||std::find(passageIds.begin(),passageIds.end(),passage.stableId)!=passageIds.end())
+            add("passage_identity", "passage has an empty or duplicate stable identity");
+        else passageIds.push_back(passage.stableId);
+        if(!upper||!lower||lower->order!=upper->order+1)
+            add("passage_interface",passage.stableId+" does not join adjacent resolved strates");
+        if(!upper||!lower||passage.placementRadiusSubvoxels<=0
+            ||passage.mouthRadiusSubvoxels<=0||passage.midRadiusSubvoxels<=0
+            ||passage.controlPoints.size()<2)
+        {
+            add("passage_geometry",passage.stableId+" has invalid radii, placement bound, or control points");
+            continue;
+        }
+        const auto insidePlacement=[&](const std::array<std::int64_t,3>& p)
+        {
+            const auto x=p[0],y=p[1],r=passage.placementRadiusSubvoxels;
+            return std::abs(x)<=r&&std::abs(y)<=r&&x*x+y*y<=r*r;
+        };
+        const auto insideContent=[&](const ResolvedLayoutStratumV2& s,
+                                     const std::array<std::int64_t,3>& p)
+        {
+            const std::int64_t zMicrometres=p[2]*static_cast<std::int64_t>(coreVoxelSizeMicrometres)
+                /WorldAssemblySubvoxelsPerVoxel;
+            return s.content.presentInCurrentField&&zMicrometres>=s.content.bottomMicrometres
+                &&zMicrometres<s.content.topMicrometres;
+        };
+        if(!insidePlacement(passage.upperMouthSubvoxels)||!insidePlacement(passage.lowerMouthSubvoxels))
+            add("passage_placement",passage.stableId+" mouth lies outside its (0,0) placement radius");
+        if(!insideContent(*upper,passage.upperMouthSubvoxels)
+            ||!insideContent(*lower,passage.lowerMouthSubvoxels))
+            add("passage_mouth_content",passage.stableId+" mouth is outside its owned content band");
+        if(passage.controlPoints.size()<2)continue;
+        const std::int64_t PlayerCenterAboveFloorQ=coreVoxelSizeMicrometres>0
+            ?static_cast<std::int64_t>(std::llround(1.13*WorldAssemblySubvoxelsPerVoxel
+                *1000000.0/coreVoxelSizeMicrometres)):1157;
+        const auto floorProfile=[&](const ResolvedLayoutPassagePointV1& p)
+        {return p.positionSubvoxels[2]-p.radiusSubvoxels+PlayerCenterAboveFloorQ;};
+        std::size_t lowerMouthControlIndex=passage.controlPoints.size();
+        for(std::size_t i=1;i<passage.controlPoints.size();++i)
+        {
+            const auto& candidate=passage.controlPoints[i];
+            if(candidate.positionSubvoxels[0]==passage.lowerMouthSubvoxels[0]
+                &&candidate.positionSubvoxels[1]==passage.lowerMouthSubvoxels[1]
+                &&floorProfile(candidate)==passage.lowerMouthSubvoxels[2])
+                lowerMouthControlIndex=i;
+        }
+        if(lowerMouthControlIndex==passage.controlPoints.size())
+        {
+            add("passage_mouth_binding",passage.stableId+" has no control point bound to its lower mouth");
+            lowerMouthControlIndex=passage.controlPoints.size()-1;
+        }
+        for(std::size_t i=0;i<passage.controlPoints.size();++i)
+        {
+            const auto& point=passage.controlPoints[i];
+            if(point.radiusSubvoxels<=0||!insidePlacement(point.positionSubvoxels))
+                add("passage_control_point",passage.stableId+" has a non-positive radius or leaves its placement disk");
+            if(i==0||i==lowerMouthControlIndex)
+            {
+                const auto& mouth=i==0?passage.upperMouthSubvoxels:passage.lowerMouthSubvoxels;
+                if(point.positionSubvoxels[0]!=mouth[0]||point.positionSubvoxels[1]!=mouth[1]
+                    ||floorProfile(point)!=mouth[2])
+                    add("passage_mouth_binding",passage.stableId+" control point does not bind to its mouth anchor");
+            }
+            if(i==0)continue;
+            const auto& previous=passage.controlPoints[i-1];
+            const std::int64_t dx=point.positionSubvoxels[0]-previous.positionSubvoxels[0];
+            const std::int64_t dy=point.positionSubvoxels[1]-previous.positionSubvoxels[1];
+            const auto horizontal=PassageIsqrt(static_cast<std::uint64_t>(dx*dx+dy*dy));
+            const std::int64_t signedDz=floorProfile(point)-floorProfile(previous);
+            const std::int64_t dz=std::abs(signedDz);
+            const bool landingExtension=i>lowerMouthControlIndex;
+            if((landingExtension?dz*65536>static_cast<std::int64_t>(horizontal)*17560
+                :signedDz>=0||dz*65536>static_cast<std::int64_t>(horizontal)*17560)
+                ||horizontal==0)
+                add("passage_grade",passage.stableId+" is not strictly descending or exceeds the 15 degree grade limit");
+        }
+    }
     if(strict&&!issues.empty()){error="strict resolved-layout validation rejected "+issues.front().code;return false;}
     return true;
 }
 
-std::optional<ResolvedLayoutSnapshotV2> ResolvedLayoutSnapshotV2::FromJson(
+std::optional<ResolvedLayoutSnapshotV3> ResolvedLayoutSnapshotV3::FromJson(
     std::string_view json,std::string& error)
 {
     VFJson::Value root;if(!VFJson::Parser(std::string(json)).Parse(root,error))return std::nullopt;
     if(!root.IsObject()){error="resolved layout JSON root must be an object";return std::nullopt;}
-    ResolvedLayoutSnapshotV2 s;s.schemaVersion=static_cast<std::uint32_t>(LayoutInt(root,"schema_version"));
+    ResolvedLayoutSnapshotV3 s;s.schemaVersion=static_cast<std::uint32_t>(LayoutInt(root,"schema_version"));
     s.worldIdentity=LayoutString(root,"world_identity");
     s.ownerVoxelSizeMicrometres=static_cast<std::uint32_t>(LayoutInt(root,"owner_voxel_size_um"));
     s.coreVoxelSizeMicrometres=static_cast<std::uint32_t>(LayoutInt(root,"core_voxel_size_um"));
@@ -302,15 +493,314 @@ std::optional<ResolvedLayoutSnapshotV2> ResolvedLayoutSnapshotV2::FromJson(
             for(const auto& value:a.Get("values").AsArray())p.values.push_back(value.Integer());x.anchors.push_back(std::move(p));}
         s.strates.push_back(std::move(x));
     }
+    for(const auto& v:root.Get("passages").AsArray())
+    {
+        ResolvedLayoutPassageV1 p;p.stableId=LayoutString(v,"stable_id");
+        p.upperStrateIndex=static_cast<std::int32_t>(LayoutInt(v,"upper_strate_index"));
+        p.lowerStrateIndex=static_cast<std::int32_t>(LayoutInt(v,"lower_strate_index"));
+        p.placementRadiusSubvoxels=LayoutInt(v,"placement_radius_q");
+        p.mouthRadiusSubvoxels=LayoutInt(v,"mouth_radius_q");p.midRadiusSubvoxels=LayoutInt(v,"mid_radius_q");
+        const auto& upper=v.Get("upper_mouth_q").AsArray();
+        const auto& lower=v.Get("lower_mouth_q").AsArray();
+        for(std::size_t axis=0;axis<3&&axis<upper.size();++axis)p.upperMouthSubvoxels[axis]=upper[axis].Integer();
+        for(std::size_t axis=0;axis<3&&axis<lower.size();++axis)p.lowerMouthSubvoxels[axis]=lower[axis].Integer();
+        for(const auto& q:v.Get("control_points").AsArray())
+        {
+            ResolvedLayoutPassagePointV1 point;const auto& position=q.Get("position_q").AsArray();
+            for(std::size_t axis=0;axis<3&&axis<position.size();++axis)
+                point.positionSubvoxels[axis]=position[axis].Integer();
+            point.radiusSubvoxels=LayoutInt(q,"radius_q");p.controlPoints.push_back(point);
+        }
+        s.passages.push_back(std::move(p));
+    }
     const std::string serializedIdentity=LayoutString(root,"stable_identity");
     if(!s.finalize(error))return std::nullopt;
     if(s.stableIdentity!=serializedIdentity){error="resolved layout stable identity does not match its canonical payload";return std::nullopt;}
     return s;
 }
 
-ResolvedLayoutValidatorAuditV2 AuditResolvedLayoutValidatorV2()
+bool PlanResolvedLayoutPassagesV1(ResolvedLayoutSnapshotV3& layout,std::int32_t seed,
+    const std::vector<ResolvedLayoutPassageConfigV1>& configs,std::string& error)
 {
-    ResolvedLayoutValidatorAuditV2 result;
+    error.clear();layout.passages.clear();
+    if(layout.strates.size()<2)return true;
+    std::stable_sort(layout.strates.begin(),layout.strates.end(),[](const auto& a,const auto& b)
+    {return a.interiorTopMicrometres!=b.interiorTopMicrometres
+        ?a.interiorTopMicrometres>b.interiorTopMicrometres:a.order<b.order;});
+    for(std::size_t i=0;i<layout.strates.size();++i)
+        layout.strates[i].order=static_cast<std::int32_t>(i);
+    if(layout.coreVoxelSizeMicrometres==0)
+    {error="passage planner requires the resolved Core voxel size";return false;}
+    const std::int64_t qPerMetre=static_cast<std::int64_t>(std::llround(
+        static_cast<double>(WorldAssemblySubvoxelsPerVoxel)*1000000.0
+            /layout.coreVoxelSizeMicrometres));
+    if(qPerMetre<=0){error="passage planner could not resolve fixed-point metres";return false;}
+    const std::int64_t playerCenterAboveFloorQ=static_cast<std::int64_t>(std::llround(1.13*qPerMetre));
+    const std::array<std::array<std::int32_t,2>,16> directions{{
+        {{65536,0}},{{60547,25080}},{{46341,46341}},{{25080,60547}},
+        {{0,65536}},{{-25080,60547}},{{-46341,46341}},{{-60547,25080}},
+        {{-65536,0}},{{-60547,-25080}},{{-46341,-46341}},{{-25080,-60547}},
+        {{0,-65536}},{{25080,-60547}},{{46341,-46341}},{{60547,-25080}}}};
+    const auto configFor=[&](std::int32_t strate)->const ResolvedLayoutPassageConfigV1*
+    {
+        const auto it=std::find_if(configs.begin(),configs.end(),[strate](const auto& c)
+            {return c.upperStrateIndex==strate;});
+        return it==configs.end()?nullptr:&*it;
+    };
+    const auto routeAnchor=[](const ResolvedLayoutStratumV2& s,bool departure,
+        std::array<std::int64_t,3>& out)
+    {
+        const ResolvedLayoutAnchorV2* selected=nullptr;
+        for(const auto& a:s.anchors)
+            if(a.kind=="route_point"&&a.values.size()>=3)
+            {selected=&a;if(!departure)break;}
+        if(!selected)return false;
+        out={selected->values[0],selected->values[1],selected->values[2]};return true;
+    };
+    const auto routeTangent=[](const ResolvedLayoutStratumV2& s,bool departure,
+        std::array<std::int64_t,2>& out)
+    {
+        const ResolvedLayoutAnchorV2* first=nullptr,*second=nullptr,*last=nullptr,*previous=nullptr;
+        for(const auto& a:s.anchors)
+            if(a.kind=="route_point"&&a.values.size()>=3)
+            {if(!first)first=&a;else if(!second)second=&a;previous=last;last=&a;}
+        if(!first||!second||!last||!previous)return false;
+        const auto* from=departure?previous:first;
+        const auto* to=departure?last:second;
+        out={to->values[0]-from->values[0],to->values[1]-from->values[1]};
+        return out[0]!=0||out[1]!=0;
+    };
+    const auto radialWithin=[](const std::array<std::int64_t,3>& p,std::int64_t radius)
+    {return radius>0&&p[0]*p[0]+p[1]*p[1]<=radius*radius;};
+    const auto reachValue=[](std::uint64_t hash,std::int64_t lo,std::int64_t hi)
+    {
+        if(hi<lo)std::swap(hi,lo);
+        return lo+(hi>lo?static_cast<std::int64_t>(hash%static_cast<std::uint64_t>(hi-lo+1)):0);
+    };
+    const auto contentZQ=[&](std::int64_t micrometres)
+    {return static_cast<std::int64_t>(std::llround(static_cast<double>(micrometres)
+        *WorldAssemblySubvoxelsPerVoxel/layout.coreVoxelSizeMicrometres));};
+    const auto distanceQ=[](std::int64_t dx,std::int64_t dy)
+    {
+        const auto square=static_cast<std::uint64_t>(dx*dx+dy*dy);
+        const auto floor=PassageIsqrt(square);return floor*floor==square?floor:floor+1;
+    };
+    for(std::size_t interface=0;interface+1<layout.strates.size();++interface)
+    {
+        const auto& upper=layout.strates[interface];const auto& lower=layout.strates[interface+1];
+        const auto* cfg=configFor(upper.strateIndex);
+        const std::int64_t outer=cfg?std::max(cfg->distanceMinimumSubvoxels,
+            cfg->distanceMaximumSubvoxels):24*qPerMetre;
+        const std::int64_t inner=cfg?std::min(cfg->distanceMinimumSubvoxels,
+            cfg->distanceMaximumSubvoxels):8*qPerMetre;
+        const std::int64_t placementRadius=std::max<std::int64_t>(1,outer);
+        const std::int64_t mouthRadius=std::max<std::int64_t>(static_cast<std::int64_t>(std::llround(1.25*qPerMetre)),
+            cfg?cfg->mouthRadiusSubvoxels:0);
+        const std::int64_t midRadius=std::max<std::int64_t>(mouthRadius,
+            cfg?cfg->midRadiusSubvoxels:0);
+        const std::int64_t reachMinimum=cfg?std::max<std::int64_t>(0,cfg->reachMinimumSubvoxels):8*qPerMetre;
+        const std::int64_t reachMaximum=cfg?std::max<std::int64_t>(reachMinimum,cfg->reachMaximumSubvoxels):24*qPerMetre;
+        const std::uint32_t connectionCount=cfg?static_cast<std::uint32_t>(std::clamp(cfg->connections,1,12)):1;
+        for(std::uint32_t connection=0;connection<connectionCount;++connection)
+        {
+            ResolvedLayoutPassageV1 passage;
+            passage.stableId="passage/"+std::to_string(upper.strateIndex)+"-"
+                +std::to_string(lower.strateIndex)+"/"+std::to_string(connection);
+            passage.upperStrateIndex=upper.strateIndex;passage.lowerStrateIndex=lower.strateIndex;
+            passage.placementRadiusSubvoxels=placementRadius;
+            passage.mouthRadiusSubvoxels=mouthRadius;passage.midRadiusSubvoxels=midRadius;
+            std::array<std::int64_t,3> upperMouth{},lowerMouth{};
+            const bool hasUpperRoute=connection==0&&routeAnchor(upper,true,upperMouth);
+            const bool hasLowerRoute=connection==0&&routeAnchor(lower,false,lowerMouth);
+            if(!hasUpperRoute||!hasLowerRoute)
+            {
+                const auto xy=PassageRandomXY(PassageSeed(seed,upper.strateIndex,lower.strateIndex,
+                    connection,0x504c4143u),inner,placementRadius);
+                if(!hasUpperRoute)
+                {
+                    upperMouth[0]=xy[0];upperMouth[1]=xy[1];
+                    const auto reach=reachValue(PassageSeed(seed,upper.strateIndex,lower.strateIndex,
+                        connection,0x55505248u),reachMinimum,reachMaximum);
+                    upperMouth[2]=contentZQ(upper.content.bottomMicrometres)+reach;
+                }
+                if(!hasLowerRoute)
+                {
+                    lowerMouth[0]=xy[0];lowerMouth[1]=xy[1];
+                    const auto reach=reachValue(PassageSeed(seed,upper.strateIndex,lower.strateIndex,
+                        connection,0x4c4f5752u),reachMinimum,reachMaximum);
+                    lowerMouth[2]=contentZQ(lower.content.topMicrometres)-reach;
+                }
+            }
+            if(!radialWithin(upperMouth,placementRadius)||!radialWithin(lowerMouth,placementRadius))
+            {error=passage.stableId+" route mouth is outside the resolved PassageConfig.DistanceMax radius";return false;}
+            passage.upperMouthSubvoxels=upperMouth;passage.lowerMouthSubvoxels=lowerMouth;
+
+            constexpr std::int64_t LandingExtensionQ=8;
+            std::array<std::int64_t,2> upperTangent{},lowerTangent{};
+            const bool hasUpperTangent=hasUpperRoute
+                &&routeTangent(upper,true,upperTangent);
+            const bool hasLowerTangent=hasLowerRoute
+                &&routeTangent(lower,false,lowerTangent);
+
+            const std::int64_t ringRadius=std::max<std::int64_t>(1,
+                placementRadius-mouthRadius-qPerMetre/2);
+            std::uint32_t phase=static_cast<std::uint32_t>(PassageSeed(seed,
+                upper.strateIndex,lower.strateIndex,connection,0x50484153u)%16);
+            if(hasUpperRoute)
+            {
+                std::int64_t bestAlignment=std::numeric_limits<std::int64_t>::min();
+                const std::uint32_t hashedPhase=phase;
+                for(std::uint32_t offset=0;offset<16;++offset)
+                {
+                    const std::uint32_t candidate=static_cast<std::uint32_t>(
+                        (hashedPhase+offset)%16);
+                    const std::int64_t alignment=(hasUpperTangent?upperTangent[0]:upperMouth[0])
+                            *directions[candidate][0]
+                        +(hasUpperTangent?upperTangent[1]:upperMouth[1])
+                            *directions[candidate][1];
+                    if(alignment>bestAlignment)
+                    {bestAlignment=alignment;phase=candidate;}
+                }
+            }
+            const bool clockwise=(PassageSeed(seed,upper.strateIndex,lower.strateIndex,
+                connection,0x44495245u)&1u)!=0;
+            const int direction=clockwise?1:-1;
+            const auto ringPoint=[&](std::uint32_t directionIndex)
+            {
+                return std::array<std::int64_t,2>{
+                    static_cast<std::int64_t>(ringRadius)*directions[directionIndex][0]/65536,
+                    static_cast<std::int64_t>(ringRadius)*directions[directionIndex][1]/65536};
+            };
+            std::vector<std::array<std::int64_t,2>> xy;
+            const auto pushXY=[&](std::array<std::int64_t,2> p)
+            {if(xy.empty()||xy.back()!=p)xy.push_back(p);};
+            const auto firstRing=ringPoint(phase);
+            pushXY({upperMouth[0],upperMouth[1]});
+            pushXY(firstRing);
+            std::uint64_t totalHorizontal=0;std::uint32_t loops=0;
+            const std::int64_t verticalDistance=std::abs(lowerMouth[2]-upperMouth[2]);
+            constexpr std::int64_t TargetGradeQ16=12500; // leave margin below the 15-degree contract.
+            auto measurePath=[&]()
+            {
+                std::uint64_t total=0;
+                for(std::size_t i=1;i<xy.size();++i)
+                    total+=distanceQ(xy[i][0]-xy[i-1][0],xy[i][1]-xy[i-1][1]);
+                return total;
+            };
+            while(loops<256)
+            {
+                totalHorizontal=measurePath();
+                if(totalHorizontal*static_cast<std::uint64_t>(TargetGradeQ16)
+                    >=static_cast<std::uint64_t>(verticalDistance)*65536ull)break;
+                for(int step=1;step<=16;++step)
+                {
+                    int directionIndex=static_cast<int>(phase)+direction*step;
+                    directionIndex=(directionIndex%16+16)%16;
+                    pushXY(ringPoint(static_cast<std::uint32_t>(directionIndex)));
+                }
+                ++loops;
+            }
+            if(hasLowerTangent)
+            {
+                std::uint32_t lowerPhase=static_cast<std::uint32_t>(PassageSeed(seed,
+                    upper.strateIndex,lower.strateIndex,connection,0x4c505248u)%16);
+                std::int64_t bestAlignment=std::numeric_limits<std::int64_t>::min();
+                const std::uint32_t hashedLowerPhase=lowerPhase;
+                for(std::uint32_t offset=0;offset<16;++offset)
+                {
+                    const std::uint32_t candidate=static_cast<std::uint32_t>(
+                        (hashedLowerPhase+offset)%16);
+                    const auto terminal=ringPoint(candidate);
+                    const std::int64_t dx=lowerMouth[0]-terminal[0];
+                    const std::int64_t dy=lowerMouth[1]-terminal[1];
+                    const std::int64_t alignment=dx*lowerTangent[0]+dy*lowerTangent[1];
+                    const std::int64_t cross=std::abs(dx*lowerTangent[1]-dy*lowerTangent[0]);
+                    if(alignment<=0||cross==0)continue;
+                    const auto length=distanceQ(dx,dy);
+                    const std::int64_t score=alignment*65536/static_cast<std::int64_t>(length);
+                    if(score>bestAlignment)
+                    {bestAlignment=score;lowerPhase=candidate;}
+                }
+                if(bestAlignment==std::numeric_limits<std::int64_t>::min())
+                {error=passage.stableId+" could not find a non-overlapping lower landing approach";return false;}
+                if(phase!=lowerPhase)
+                    for(int step=1;step<=16;++step)
+                    {
+                        int directionIndex=static_cast<int>(phase)+direction*step;
+                        directionIndex=(directionIndex%16+16)%16;
+                        pushXY(ringPoint(static_cast<std::uint32_t>(directionIndex)));
+                        if(static_cast<std::uint32_t>(directionIndex)==lowerPhase)break;
+                    }
+                pushXY(ringPoint(lowerPhase));
+            }
+            pushXY({lowerMouth[0],lowerMouth[1]});totalHorizontal=measurePath();
+            const std::size_t lowerMouthIndex=xy.size()-1;
+            std::vector<std::array<std::int64_t,3>> lowerLandingPoints;
+            if(hasLowerTangent)
+            {
+                std::array<std::int64_t,3> previousRoutePoint=lowerMouth;
+                std::int64_t remainingQ=LandingExtensionQ*qPerMetre;
+                bool skippedMouth=false;
+                for(const auto& anchor:lower.anchors)
+                    if(anchor.kind=="route_point"&&anchor.values.size()>=3)
+                    {
+                        const std::array<std::int64_t,3> routePoint{{anchor.values[0],
+                            anchor.values[1],anchor.values[2]}};
+                        if(!skippedMouth){skippedMouth=true;continue;}
+                        if(remainingQ<=0)break;
+                        const std::int64_t dx=routePoint[0]-previousRoutePoint[0];
+                        const std::int64_t dy=routePoint[1]-previousRoutePoint[1];
+                        const std::uint64_t segmentLength=distanceQ(dx,dy);
+                        if(segmentLength==0)continue;
+                        const std::int64_t advance=std::min<std::int64_t>(remainingQ,
+                            static_cast<std::int64_t>(segmentLength));
+                        std::array<std::int64_t,3> landingPoint{};
+                        for(std::size_t axis=0;axis<3;++axis)
+                            landingPoint[axis]=previousRoutePoint[axis]+PassageRoundRatio(
+                                routePoint[axis]-previousRoutePoint[axis],advance,
+                                    static_cast<std::int64_t>(segmentLength));
+                        if(!radialWithin(landingPoint,placementRadius))break;
+                        lowerLandingPoints.push_back(landingPoint);
+                        pushXY({landingPoint[0],landingPoint[1]});
+                        previousRoutePoint=landingPoint;remainingQ-=advance;
+                        if(advance<static_cast<std::int64_t>(segmentLength))break;
+                    }
+                if(lowerLandingPoints.empty())
+                {error=passage.stableId+" lower route has no landing length inside PassageConfig.DistanceMax";return false;}
+            }
+            totalHorizontal=measurePath();
+            if(loops>=256||totalHorizontal==0)
+            {error=passage.stableId+" could not fit a supported grade inside the resolved placement radius";return false;}
+            std::vector<std::uint64_t> cumulative(xy.size(),0);
+            for(std::size_t i=1;i<xy.size();++i)
+                cumulative[i]=cumulative[i-1]+distanceQ(xy[i][0]-xy[i-1][0],xy[i][1]-xy[i-1][1]);
+            const std::uint64_t mouthHorizontal=cumulative[lowerMouthIndex];
+            if(mouthHorizontal==0)
+            {error=passage.stableId+" has no horizontal reach before its lower mouth";return false;}
+            passage.controlPoints.reserve(xy.size());
+            for(std::size_t i=0;i<xy.size();++i)
+            {
+                const std::int64_t radius=(i<=1||i+1>=xy.size()-1)?mouthRadius:midRadius;
+                const std::int64_t playerZ=i<=lowerMouthIndex
+                    ?upperMouth[2]+PassageRoundRatio(lowerMouth[2]-upperMouth[2],
+                        static_cast<std::int64_t>(cumulative[i]),static_cast<std::int64_t>(mouthHorizontal))
+                    :lowerLandingPoints[i-lowerMouthIndex-1][2];
+                ResolvedLayoutPassagePointV1 point;
+                point.positionSubvoxels={xy[i][0],xy[i][1],playerZ+radius-playerCenterAboveFloorQ};
+                point.radiusSubvoxels=radius;passage.controlPoints.push_back(point);
+            }
+            passage.controlPoints.front().positionSubvoxels[2]=upperMouth[2]+mouthRadius-playerCenterAboveFloorQ;
+            passage.controlPoints[lowerMouthIndex].positionSubvoxels[2]=
+                lowerMouth[2]+mouthRadius-playerCenterAboveFloorQ;
+            layout.passages.push_back(std::move(passage));
+        }
+    }
+    return true;
+}
+
+ResolvedLayoutValidatorAuditV3 AuditResolvedLayoutValidatorV3()
+{
+    ResolvedLayoutValidatorAuditV3 result;
     auto make=[](std::string id,std::int32_t order,std::int64_t top,std::int64_t bottom)
     {
         ResolvedLayoutStratumV2 s;s.stableId=std::move(id);s.order=order;s.strateIndex=order;s.generatorKind="synthetic";
@@ -322,16 +812,34 @@ ResolvedLayoutValidatorAuditV2 AuditResolvedLayoutValidatorV2()
         s.bedrock={"bedrock",bottom-1000000,bottom,true,true,false,"breakable bedrock","lower face","none"};
         return s;
     };
-    const auto expectReject=[&](std::string name,ResolvedLayoutSnapshotV2 candidate)
+    const auto expectReject=[&](std::string name,ResolvedLayoutSnapshotV3 candidate)
     {
         ++result.controlsRun;std::vector<ResolvedLayoutIssueV2> issues;std::string error;
-        if(!candidate.validate(ResolvedLayoutValidationModeV2::strict,issues,error))++result.controlsRejectedAsExpected;
+        if(!candidate.validate(ResolvedLayoutValidationModeV3::strict,issues,error))++result.controlsRejectedAsExpected;
         else result.failures.push_back({"negative_control_accepted",std::move(name)+" was accepted by strict validator"});
     };
-    auto base=ResolvedLayoutSnapshotV2{};base.worldIdentity="synthetic";base.strates={make("a",0,10000000,0),make("b",1,-2000000,-12000000)};
+    auto base=ResolvedLayoutSnapshotV3{};base.worldIdentity="synthetic";base.ownerVoxelSizeMicrometres=125000;
+    base.coreVoxelSizeMicrometres=250000;base.strates={make("a",0,10000000,0),make("b",1,-2000000,-12000000)};
+    ResolvedLayoutPassageConfigV1 passageConfig;passageConfig.upperStrateIndex=0;passageConfig.connections=1;
+    passageConfig.mouthRadiusSubvoxels=1280;passageConfig.midRadiusSubvoxels=1280;
+    passageConfig.reachMinimumSubvoxels=2048;passageConfig.reachMaximumSubvoxels=2048;
+    passageConfig.distanceMinimumSubvoxels=1024;passageConfig.distanceMaximumSubvoxels=10240;
+    std::string planError;
+    if(!PlanResolvedLayoutPassagesV1(base,19,{passageConfig},planError))
+        result.failures.push_back({"synthetic_passage_plan_failed",planError});
     {std::vector<ResolvedLayoutIssueV2> issues;std::string error;
-     if(!base.validate(ResolvedLayoutValidationModeV2::strict,issues,error))
+     if(!base.validate(ResolvedLayoutValidationModeV3::strict,issues,error))
          result.failures.push_back({"positive_control_rejected","valid ceiling/content/bedrock layout was rejected"});}
+    auto missingPassage=base;missingPassage.passages.clear();expectReject("missing interface passage",missingPassage);
+    auto outsidePassage=base;
+    if(!outsidePassage.passages.empty())
+    {
+        outsidePassage.passages.front().upperMouthSubvoxels[0]
+            =outsidePassage.passages.front().placementRadiusSubvoxels+1;
+        outsidePassage.passages.front().controlPoints.front().positionSubvoxels[0]
+            =outsidePassage.passages.front().upperMouthSubvoxels[0];
+    }
+    expectReject("passage mouth outside placement radius",outsidePassage);
     auto boundaryGap=base;boundaryGap.strates[1].ceiling.topMicrometres-=1;
     expectReject("bedrock/next-ceiling gap",boundaryGap);
     auto missingBedrock=base;missingBedrock.strates[0].bedrock.presentInCurrentField=false;expectReject("missing bedrock",missingBedrock);