passages: prepared per-segment data + per-column XY projection cache (L98, exact)

Per-world prepared chord/length/radius/Catmull-Rom/floor-profile data (310 segments, ~66 KB,
<0.04 ms); same expression grouping, divisions and square roots, so output is bit-identical
(zero density/tile mismatches, Clang vs GCC equal). No measurable readiness gain - the cost is
the number of samples running passage work, not per-sample arithmetic. Note: the report's
world labels are shifted by one row (the 2,850-tile row is SurfaceWorld). Fast tier PASS;
Linux UE host builds.

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

Standalone/Core/src/ShapeWorldInternal.h

@@ -70,6 +70,20 @@ static bool VF_IsL90PassageCandidateCensusEnabled()
     return bEnabled;
 }
 
+static bool VF_IsL98PassageReuseCountEnabled()
+{
+    static const bool bEnabled=VF_IsL88DiagnosticSwitchEnabled(
+        "VOXELFORGE_L98_PASSAGE_REUSE_COUNTS");
+    return bEnabled;
+}
+
+static bool VF_IsL98PassagePrepareTraceEnabled()
+{
+    static const bool bEnabled=VF_IsL88DiagnosticSwitchEnabled(
+        "VOXELFORGE_L98_PASSAGE_PREP_TRACE");
+    return bEnabled;
+}
+
 static double VF_L91PassageSourceFloorVoxels()
 {
     static const double Value=[]
@@ -251,6 +265,21 @@ public:
             std::ptrdiff_t first=-1,end=-1;
             std::vector<std::uint8_t> activeNodes;
         };
+        enum class EPreparedSegmentUse : std::uint8_t
+        { Carve,Support,Capsule,Mouth };
+        struct FReuseCounters
+        {
+            std::atomic<std::uint64_t> projectionColumns{0};
+            std::atomic<std::uint64_t> projectionComputes{0};
+            std::atomic<std::uint64_t> projectionHits{0};
+            std::atomic<std::uint64_t> floorProfileReads{0};
+            std::array<std::atomic<std::uint64_t>,4> preparedSegmentUses{};
+        };
+        struct FProjectionCacheEntry
+        {
+            std::uint64_t generation=0;
+            double numerator=0.0;
+        };
         FScopedPassageTileQueries(const FStandaloneShapeWorld& shape,
             const std::array<std::int64_t,3>& minimumSubvoxels,
             const std::array<std::int64_t,3>& maximumSubvoxels,
@@ -358,6 +387,14 @@ public:
                 std::sort(values.begin(),values.end(),[](const auto& a,const auto& b)
                     {return a.segmentIndex<b.segmentIndex;});
             }
+            projectionCacheSize_=(shape.PassageSegmentOffsets.empty()?0
+                :shape.PassageSegmentOffsets.back())
+                +(shape.PassageMouthSupportSegmentOffsets.empty()?0
+                    :shape.PassageMouthSupportSegmentOffsets.back())
+                +(shape.PassageStratumCapsuleSegmentOffsets.empty()?0
+                    :shape.PassageStratumCapsuleSegmentOffsets.back());
+            if(VF_IsL98PassageReuseCountEnabled())
+                reuseCounters_=std::make_shared<FReuseCounters>();
             ActivePassageTileQueries=this;
         }
         // Duplicate the immutable per-tile masks onto a density-grid helper worker. Mutable
@@ -379,11 +416,32 @@ public:
              candidateProfiled_(source.candidateProfiled_),
              passageSourceFloorVoxels_(source.passageSourceFloorVoxels_),
              passageCarveReachMetres_(source.passageCarveReachMetres_),
-             clampCounters_(source.clampCounters_),ownsClampCounters_(false)
+             clampCounters_(source.clampCounters_),ownsClampCounters_(false),
+             projectionCacheSize_(source.projectionCacheSize_),
+             reuseCounters_(source.reuseCounters_),ownsReuseCounters_(false)
         { ActivePassageTileQueries=this; }
         ~FScopedPassageTileQueries()
         {
             ActivePassageTileQueries=previous_;
+            if(ownsReuseCounters_&&reuseCounters_)
+                std::printf("[L98PassageReuseTile] lod=%d projection_columns=%llu projection_computes=%llu projection_hits=%llu floor_profile_reads=%llu carve_prepared=%llu support_prepared=%llu capsule_prepared=%llu mouth_prepared=%llu\n",
+                    profileLod_,
+                    static_cast<unsigned long long>(reuseCounters_->projectionColumns.load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->projectionComputes.load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->projectionHits.load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->floorProfileReads.load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->preparedSegmentUses[0].load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->preparedSegmentUses[1].load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->preparedSegmentUses[2].load(
+                        std::memory_order_relaxed)),
+                    static_cast<unsigned long long>(reuseCounters_->preparedSegmentUses[3].load(
+                        std::memory_order_relaxed)));
             if(ownsClampCounters_&&clampCounters_&&passageSourceFloorVoxels_>0.0)
                 std::printf("[L91PassageSourceClampTile] lod=%d floor_vox=%.3f source_clamped=%llu source_delta_sum=%.9g deepest_source_vox=%.9g\n",
                     profileLod_,passageSourceFloorVoxels_,
@@ -442,6 +500,54 @@ public:
         FScopedPassageTileQueries& operator=(const FScopedPassageTileQueries&)=delete;
 
         bool matches(const FStandaloneShapeWorld& shape) const{return shape_==&shape;}
+        bool beginProjectionColumn() const
+        {
+            const bool previous=projectionColumnActive_;
+            projectionColumnActive_=true;
+            ++projectionGeneration_;
+            if(projectionGeneration_==0)
+            {
+                for(auto& entry:projectionCache_)entry.generation=0;
+                projectionGeneration_=1;
+            }
+            if(reuseCounters_)
+                reuseCounters_->projectionColumns.fetch_add(1,std::memory_order_relaxed);
+            return previous;
+        }
+        void endProjectionColumn(bool previous) const
+        {projectionColumnActive_=previous;}
+        double projectionNumerator(std::size_t flatIndex,double qx,double qy,
+            double ax,double ay,double dx,double dy) const
+        {
+            const auto compute=[&](){return (qx-ax)*dx+(qy-ay)*dy;};
+            if(!projectionColumnActive_||!shape_)return compute();
+            if(projectionCache_.size()!=projectionCacheSize_)
+                projectionCache_.resize(projectionCacheSize_);
+            if(flatIndex>=projectionCache_.size())return compute();
+            FProjectionCacheEntry& entry=projectionCache_[flatIndex];
+            if(entry.generation==projectionGeneration_)
+            {
+                if(reuseCounters_)
+                    reuseCounters_->projectionHits.fetch_add(1,std::memory_order_relaxed);
+                return entry.numerator;
+            }
+            entry.numerator=compute();
+            entry.generation=projectionGeneration_;
+            if(reuseCounters_)
+                reuseCounters_->projectionComputes.fetch_add(1,std::memory_order_relaxed);
+            return entry.numerator;
+        }
+        void recordPreparedSegmentUse(EPreparedSegmentUse use) const
+        {
+            if(reuseCounters_)
+                reuseCounters_->preparedSegmentUses[static_cast<std::size_t>(use)]
+                    .fetch_add(1,std::memory_order_relaxed);
+        }
+        void recordPreparedFloorProfileRead() const
+        {
+            if(reuseCounters_)
+                reuseCounters_->floorProfileReads.fetch_add(1,std::memory_order_relaxed);
+        }
         static const FScopedPassageTileQueries* CurrentFor(const FStandaloneShapeWorld& shape)
         {
             const FScopedPassageTileQueries* current=ActivePassageTileQueries;
@@ -579,6 +685,12 @@ public:
         double passageCarveReachMetres_=0.0;
         mutable std::shared_ptr<FPassageSourceClampCounters> clampCounters_;
         bool ownsClampCounters_=true;
+        std::size_t projectionCacheSize_=0;
+        mutable std::vector<FProjectionCacheEntry> projectionCache_;
+        mutable std::uint64_t projectionGeneration_=0;
+        mutable bool projectionColumnActive_=false;
+        std::shared_ptr<FReuseCounters> reuseCounters_;
+        bool ownsReuseCounters_=true;
         mutable std::uint64_t l90Queries_=0,l90NoBrickQueries_=0;
         mutable std::uint64_t l90FallbackIterations_=0,l90FallbackNanoseconds_=0,
             l90QueryNanoseconds_=0,l90FallbackCarveVisits_=0,l90FallbackTreadVisits_=0,
@@ -589,6 +701,23 @@ public:
         mutable std::array<std::array<std::uint64_t,17>,4> l90CandidateHistogram_{};
     };
 
+    class FScopedPassageColumnXYReuse
+    {
+    public:
+        explicit FScopedPassageColumnXYReuse(const FStandaloneShapeWorld& shape)
+            :queries_(FScopedPassageTileQueries::CurrentFor(shape))
+        {
+            if(queries_)previousActive_=queries_->beginProjectionColumn();
+        }
+        ~FScopedPassageColumnXYReuse()
+        {if(queries_)queries_->endProjectionColumn(previousActive_);}
+        FScopedPassageColumnXYReuse(const FScopedPassageColumnXYReuse&)=delete;
+        FScopedPassageColumnXYReuse& operator=(const FScopedPassageColumnXYReuse&)=delete;
+    private:
+        const FScopedPassageTileQueries* queries_=nullptr;
+        bool previousActive_=false;
+    };
+
     bool IsResolvedPassageColumnSample(std::size_t PassageIndex,std::size_t SegmentIndex,
         const VoxelForgeCore::Vec3d& Position) const
     {
@@ -1410,21 +1539,25 @@ public:
                     ||qz<Constants.lastFloorQ-2.0*Passage.mouthRadiusSubvoxels)
                     continue;
                 const std::ptrdiff_t LowerMouthIndex=Constants.lowerMouthIndex;
-                const auto FloorProfile=[&](const auto& Point)
-                {return Point.positionSubvoxels[2]-Point.radiusSubvoxels
-                    +1.13*qPerMetre;};
-                const auto CarveHigh=std::lower_bound(Passage.controlPoints.begin(),
-                    Passage.controlPoints.begin()+LowerMouthIndex+1,
+                const auto& FloorProfileQ=Constants.controlFloorProfileQ;
+                const auto CompareFloorProfile=[&](double FloorProfile,double Value)
+                {
+                    if(passageTileScopeMatches)
+                        passageTileQueries->recordPreparedFloorProfileRead();
+                    return FloorProfile>Value;
+                };
+                const auto CarveHigh=std::lower_bound(FloorProfileQ.begin(),
+                    FloorProfileQ.begin()+LowerMouthIndex+1,
                     qz+Constants.carveSearchMargin,
-                    [&](const auto& Point,double Value){return FloorProfile(Point)>Value;});
-                const auto CarveLow=std::lower_bound(Passage.controlPoints.begin(),
-                    Passage.controlPoints.begin()+LowerMouthIndex+1,
+                    CompareFloorProfile);
+                const auto CarveLow=std::lower_bound(FloorProfileQ.begin(),
+                    FloorProfileQ.begin()+LowerMouthIndex+1,
                     qz-Constants.carveSearchMargin,
-                    [&](const auto& Point,double Value){return FloorProfile(Point)>Value;});
+                    CompareFloorProfile);
                 const std::ptrdiff_t CarveBegin=std::max<std::ptrdiff_t>(0,
-                    (CarveHigh-Passage.controlPoints.begin())-1);
+                    (CarveHigh-FloorProfileQ.begin())-1);
                 const std::ptrdiff_t CarveEnd=std::min<std::ptrdiff_t>(LowerMouthIndex-1,
-                    (CarveLow-Passage.controlPoints.begin())+1);
+                    (CarveLow-FloorProfileQ.begin())+1);
                 const double rawSignedDistanceLimit=-static_cast<double>(density)*Q
                     +0.24*qPerMetre;
                 const double SignedDistanceLimit=passageCarveReachEnabled
@@ -1514,16 +1647,20 @@ public:
                 if(index>=route.size())return;
                 if(passageProfile)++passageProfile->passageMouthRouteSegmentChecks;
                 const auto& segment=route[index];
-                const double dx=static_cast<double>(segment.b[0]-segment.a[0]);
-                const double dy=static_cast<double>(segment.b[1]-segment.a[1]);
-                const double lengthSq=dx*dx+dy*dy;
-                const double t=lengthSq>0.0?std::clamp(((qx-segment.a[0])*dx
-                    +(qy-segment.a[1])*dy)/lengthSq,0.0,1.0):0.0;
-                const double centerX=segment.a[0]+t*dx,centerY=segment.a[1]+t*dy;
-                const double centerZ=segment.a[2]
-                    +t*(static_cast<double>(segment.b[2])-segment.a[2]);
+                const auto* l98TileQueries=ActivePassageTileQueries;
+                if(l98TileQueries&&l98TileQueries->matches(*this))
+                    l98TileQueries->recordPreparedSegmentUse(
+                        FScopedPassageTileQueries::EPreparedSegmentUse::Mouth);
+                const double dx=segment.preparedDelta[0],dy=segment.preparedDelta[1];
+                const double lengthSq=segment.horizontalLengthSq;
+                const double t=lengthSq>0.0?std::clamp(
+                    PassageMouthSupportXYProjectionNumerator(passageIndex,index,qx,qy)
+                        /lengthSq,0.0,1.0):0.0;
+                const double centerX=segment.preparedA[0]+t*dx,
+                    centerY=segment.preparedA[1]+t*dy;
+                const double centerZ=segment.preparedA[2]+t*segment.preparedDelta[2];
                 const double routeRadius=segment.hasRadius
-                    ?segment.a[3]+t*(static_cast<double>(segment.b[3])-segment.a[3]):0.0;
+                    ?segment.preparedA[3]+t*segment.preparedDelta[3]:0.0;
                 const double halfWidth=std::clamp(routeRadius,
                     0.42*qPerMetre,0.56*qPerMetre);
                 const double horizontalX=qx-centerX,horizontalY=qy-centerY;
@@ -1703,25 +1840,31 @@ public:
             {
                 continue;
             }
-            const auto floorProfile=[&](const auto& point)
-            {return point.positionSubvoxels[2]-point.radiusSubvoxels+playerCenterAboveFloorQ;};
             const std::ptrdiff_t lastIndex=passageConstants.lastIndex;
             const std::ptrdiff_t lowerMouthIndex=passageConstants.lowerMouthIndex;
-            const auto mainEnd=passage.controlPoints.begin()+lowerMouthIndex+1;
+            const auto& floorProfileQ=passageConstants.controlFloorProfileQ;
             // The tube radius is measured from its centerline, while floorProfile is
             // one player-center offset away. Search the full vertical radius of the SDF;
             // a narrow point window misses earlier turns of a low-pitch helix.
             const double carveSearchMargin=passageConstants.carveSearchMargin;
-            const auto carveHigh=std::lower_bound(passage.controlPoints.begin(),mainEnd,
+            const auto compareFloorProfile=[&](double floorProfile,double value)
+            {
+                if(passageTileScopeMatches)
+                    passageTileQueries->recordPreparedFloorProfileRead();
+                return floorProfile>value;
+            };
+            const auto carveHigh=std::lower_bound(floorProfileQ.begin(),
+                floorProfileQ.begin()+lowerMouthIndex+1,
                 qz+carveSearchMargin,
-                [&](const auto& point,double value){return floorProfile(point)>value;});
-            const auto carveLow=std::lower_bound(passage.controlPoints.begin(),mainEnd,
+                compareFloorProfile);
+            const auto carveLow=std::lower_bound(floorProfileQ.begin(),
+                floorProfileQ.begin()+lowerMouthIndex+1,
                 qz-carveSearchMargin,
-                [&](const auto& point,double value){return floorProfile(point)>value;});
+                compareFloorProfile);
             const std::ptrdiff_t carveBegin=std::max<std::ptrdiff_t>(0,
-                (carveHigh-passage.controlPoints.begin())-1);
+                (carveHigh-floorProfileQ.begin())-1);
             const std::ptrdiff_t carveEnd=std::min<std::ptrdiff_t>(lowerMouthIndex-1,
-                (carveLow-passage.controlPoints.begin())+1);
+                (carveLow-floorProfileQ.begin())+1);
             const std::ptrdiff_t mouthSearchBegin=passageConstants.mouthSearchBegin;
             const std::ptrdiff_t mouthSearchEnd=passageConstants.mouthSearchEnd;
             if(l90CandidateProfiled)
@@ -1801,27 +1944,27 @@ public:
             {
                 l90IterationTimer.recordCarve();
                 if(passageProfile)++passageProfile->passageCarveSegmentVisits;
+                const FPassageSegmentData& segment=GetPassageSegmentData(
+                    passageIndex,segmentIndex);
+                if(passageTileScopeMatches)
+                    passageTileQueries->recordPreparedSegmentUse(
+                        FScopedPassageTileQueries::EPreparedSegmentUse::Carve);
                 const std::ptrdiff_t index=static_cast<std::ptrdiff_t>(segmentIndex);
-                const auto& a=passage.controlPoints[static_cast<std::size_t>(index)];
-                const auto& b=passage.controlPoints[static_cast<std::size_t>(index+1)];
-                const double ax=static_cast<double>(a.positionSubvoxels[0]);
-                const double ay=static_cast<double>(a.positionSubvoxels[1]);
-                const double az=static_cast<double>(a.positionSubvoxels[2]);
-                const double dx=static_cast<double>(b.positionSubvoxels[0])-ax;
-                const double dy=static_cast<double>(b.positionSubvoxels[1])-ay;
-                const double dz=static_cast<double>(b.positionSubvoxels[2])-az;
-                const double lengthSq=dx*dx+dy*dy+dz*dz;
+                const double ax=segment.a[0],ay=segment.a[1],az=segment.a[2];
+                const double dx=segment.delta[0],dy=segment.delta[1],dz=segment.delta[2];
+                const double lengthSq=segment.lengthSq;
                 if(lengthSq<=0.0)return;
-                const double t=std::clamp(((qx-ax)*dx+(qy-ay)*dy+(qz-az)*dz)/lengthSq,0.0,1.0);
+                const double projectionXY=PassageXYProjectionNumerator(
+                    passageIndex,segmentIndex,qx,qy);
+                const double t=std::clamp((projectionXY+(qz-az)*dz)/lengthSq,0.0,1.0);
                 if(!passageTileScopeMatches)
                 {
-                    const double horizontalLengthSq=dx*dx+dy*dy;
+                    const double horizontalLengthSq=segment.horizontalLengthSq;
                     const double playerT=horizontalLengthSq>0.0
-                        ?std::clamp(((qx-ax)*dx+(qy-ay)*dy)/horizontalLengthSq,0.0,1.0):t;
+                        ?std::clamp(projectionXY/horizontalLengthSq,0.0,1.0):t;
                     const double playerDx=qx-(ax+playerT*dx);
                     const double playerDy=qy-(ay+playerT*dy);
-                    const double playerRadius=static_cast<double>(a.radiusSubvoxels)
-                        +playerT*(b.radiusSubvoxels-a.radiusSubvoxels);
+                    const double playerRadius=segment.radiusA+playerT*segment.radiusDelta;
                     const double playerCenterZ=az+playerT*dz-playerRadius+playerCenterAboveFloorQ;
                     const double playerVertical=std::max(0.0,
                         std::abs(qz-playerCenterZ)-0.54*qPerMetre);
@@ -1832,23 +1975,21 @@ public:
                 double cx=ax+t*dx,cy=ay+t*dy,cz=az+t*dz;
                 const bool smoothCarveJoin=index>2
                     &&index+(internalChainPassage?2:12)<lowerMouthIndex
-                    &&DeterministicSqrt(lengthSq)<=8.0*qPerMetre
+                    &&segment.lengthSubvoxels<=8.0*qPerMetre
                     &&!IsPassageShortSpanSegment(passageIndex,segmentIndex-1)
                     &&!IsPassageShortSpanSegment(passageIndex,segmentIndex)
                     &&!IsPassageShortSpanSegment(passageIndex,segmentIndex+1);
                 if(smoothCarveJoin)
                 {
                     if(passageProfile)++passageProfile->passageSmoothCarveJoins;
-                    const auto& p0=passage.controlPoints[static_cast<std::size_t>(index-1)];
-                    const auto& p3=passage.controlPoints[static_cast<std::size_t>(index+2)];
                     constexpr double SmoothJoinWeight=1.0;
                     const double t2=t*t,t3=t2*t;
                     for(std::size_t axis=0;axis<3;++axis)
                     {
-                        const double v0=static_cast<double>(p0.positionSubvoxels[axis]);
-                        const double v1=static_cast<double>(a.positionSubvoxels[axis]);
-                        const double v2=static_cast<double>(b.positionSubvoxels[axis]);
-                        const double v3=static_cast<double>(p3.positionSubvoxels[axis]);
+                        const double v0=segment.catmullBefore[axis];
+                        const double v1=segment.a[axis];
+                        const double v2=segment.b[axis];
+                        const double v3=segment.catmullAfter[axis];
                         const double curve=0.5*((2.0*v1)+(-v0+v2)*t
                             +(2.0*v0-5.0*v1+4.0*v2-v3)*t2
                             +(-v0+3.0*v1-3.0*v2+v3)*t3);
@@ -1860,8 +2001,7 @@ public:
                     }
                 }
                 const double ex=qx-cx,ey=qy-cy,ez=qz-cz;
-                const double radius=static_cast<double>(a.radiusSubvoxels)
-                    +t*(b.radiusSubvoxels-a.radiusSubvoxels);
+                const double radius=segment.radiusA+t*segment.radiusDelta;
                 const double signedDistance=DeterministicSqrt(ex*ex+ey*ey+ez*ez)-radius;
                 if(signedDistance<bestSignedDistance
                     ||(signedDistance==bestSignedDistance
@@ -1908,14 +2048,13 @@ public:
                     L90PassageCandidateProgramValid
                     &&PassageCandidateBrickContains(l90CandidateBrick,0,passageIndex,
                         static_cast<std::int32_t>(bestIndex)));
-            const auto& nearestA=passage.controlPoints[static_cast<std::size_t>(bestIndex)];
-            const auto& nearestB=passage.controlPoints[static_cast<std::size_t>(bestIndex+1)];
-            const double nearestRadius=nearestA.radiusSubvoxels+bestT*(
-                static_cast<double>(nearestB.radiusSubvoxels)-nearestA.radiusSubvoxels);
+            const FPassageSegmentData& nearestSegment=PassageSegmentData[passageIndex][
+                static_cast<std::size_t>(bestIndex)];
+            const double nearestRadius=nearestSegment.radiusA
+                +bestT*nearestSegment.radiusDelta;
             const double distanceToCenter=std::max(1.0e-9,bestSignedDistance+nearestRadius);
             const double verticalWallAlignment=distanceToCenter>1.0e-9
-                ?std::clamp(-(qz-(nearestA.positionSubvoxels[2]+bestT*(
-                    static_cast<double>(nearestB.positionSubvoxels[2])-nearestA.positionSubvoxels[2])))
+                ?std::clamp(-(qz-(nearestSegment.a[2]+bestT*nearestSegment.delta[2]))
                     /distanceToCenter,0.0,1.0):0.0;
             const std::uint32_t passageReliefSeed=static_cast<std::uint32_t>(Owner?Owner->Seed:0);
             float cachedWallRelief=0.0f,cachedMouthSurfaceRelief=0.0f,
@@ -1959,15 +2098,11 @@ public:
             };
             const auto routeSegmentLengthMetres=[&](std::ptrdiff_t routeIndex)
             {
-                const auto& before=passage.controlPoints[static_cast<std::size_t>(routeIndex)];
-                const auto& after=passage.controlPoints[static_cast<std::size_t>(routeIndex+1)];
-                const double dx=static_cast<double>(after.positionSubvoxels[0])
-                    -before.positionSubvoxels[0];
-                const double dy=static_cast<double>(after.positionSubvoxels[1])
-                    -before.positionSubvoxels[1];
-                const double dz=static_cast<double>(after.positionSubvoxels[2])
-                    -before.positionSubvoxels[2];
-                return DeterministicSqrt(dx*dx+dy*dy+dz*dz)/qPerMetre;
+                if(passageTileScopeMatches)
+                    passageTileQueries->recordPreparedSegmentUse(
+                        FScopedPassageTileQueries::EPreparedSegmentUse::Mouth);
+                return PassageSegmentData[passageIndex][
+                    static_cast<std::size_t>(routeIndex)].lengthMetres;
             };
             double distanceFromOpenMouth=std::numeric_limits<double>::infinity();
             if(bestIndex<=2)
@@ -2007,19 +2142,22 @@ public:
                     routeIndex<std::min<std::ptrdiff_t>(3,lowerMouthIndex);++routeIndex)
                 {
                     if(passageProfile)++passageProfile->passageMouthRouteSegmentChecks;
-                    const auto& before=passage.controlPoints[static_cast<std::size_t>(routeIndex)];
-                    const auto& after=passage.controlPoints[static_cast<std::size_t>(routeIndex+1)];
-                    const double ax=static_cast<double>(before.positionSubvoxels[0]);
-                    const double ay=static_cast<double>(before.positionSubvoxels[1]);
-                    const double az=static_cast<double>(before.positionSubvoxels[2]);
-                    const double dx=static_cast<double>(after.positionSubvoxels[0])-ax;
-                    const double dy=static_cast<double>(after.positionSubvoxels[1])-ay;
-                    const double dz=static_cast<double>(after.positionSubvoxels[2])-az;
-                    const double horizontalLengthSq=dx*dx+dy*dy;
+                    const FPassageSegmentData& routeSegment=PassageSegmentData[
+                        passageIndex][static_cast<std::size_t>(routeIndex)];
+                    if(passageTileScopeMatches)
+                        passageTileQueries->recordPreparedSegmentUse(
+                            FScopedPassageTileQueries::EPreparedSegmentUse::Mouth);
+                    const double ax=routeSegment.a[0],ay=routeSegment.a[1],
+                        az=routeSegment.a[2];
+                    const double dx=routeSegment.delta[0],dy=routeSegment.delta[1],
+                        dz=routeSegment.delta[2];
+                    const double horizontalLengthSq=routeSegment.horizontalLengthSq;
                     const double t=horizontalLengthSq>0.0?std::clamp(
-                        ((qx-ax)*dx+(qy-ay)*dy)/horizontalLengthSq,0.0,1.0):0.0;
+                        PassageXYProjectionNumerator(passageIndex,
+                            static_cast<std::size_t>(routeIndex),qx,qy)
+                            /horizontalLengthSq,0.0,1.0):0.0;
                     double projectedX=ax+t*dx,projectedY=ay+t*dy;
-                    const double horizontalLength=DeterministicSqrt(horizontalLengthSq);
+                    const double horizontalLength=routeSegment.horizontalLength;
                     if(horizontalLength>1.0e-6)
                     {
                         const double pathRelief=std::clamp(static_cast<double>(
@@ -2039,8 +2177,7 @@ public:
                     {
                         nearestEntryPlanDistance=planDistance;
                         const double centerZ=az+t*dz;
-                        const double radius=before.radiusSubvoxels+t*(
-                            static_cast<double>(after.radiusSubvoxels)-before.radiusSubvoxels);
+                        const double radius=routeSegment.radiusA+t*routeSegment.radiusDelta;
                         mouthEntryFloorQ=centerZ-radius+0.20*qPerMetre;
                         const double centerDistance=DeterministicSqrt(planDx*planDx
                             +planDy*planDy+(qz-centerZ)*(qz-centerZ));
@@ -2182,13 +2319,15 @@ public:
             {
                 l90IterationTimer.recordTread();
                 if(passageProfile)++passageProfile->passageSupportSegmentVisits;
+                const FPassageSegmentData& segment=GetPassageSegmentData(
+                    passageIndex,static_cast<std::size_t>(index));
+                if(passageTileScopeMatches)
+                    passageTileQueries->recordPreparedSegmentUse(
+                        FScopedPassageTileQueries::EPreparedSegmentUse::Support);
                 const auto& segmentA=passage.controlPoints[static_cast<std::size_t>(index)];
-                const auto& segmentB=passage.controlPoints[static_cast<std::size_t>(index+1)];
-                const double dx=static_cast<double>(segmentB.positionSubvoxels[0])-segmentA.positionSubvoxels[0];
-                const double dy=static_cast<double>(segmentB.positionSubvoxels[1])-segmentA.positionSubvoxels[1];
-                const double dz=static_cast<double>(segmentB.positionSubvoxels[2])-segmentA.positionSubvoxels[2];
-                const double radiusA=segmentA.radiusSubvoxels;
-                const double radiusB=segmentB.radiusSubvoxels;
+                const double dx=segment.delta[0],dy=segment.delta[1],dz=segment.delta[2];
+                const double radiusA=segment.radiusA;
+                const double radiusB=segment.radiusB;
                 const bool entryMouthShoulder=index<=2;
                 // Keep the tread within the probe band and below the capsule's
                 // lowest sampled point.
@@ -2200,7 +2339,7 @@ public:
                 double floorOffset=bridgeDeck
                     ?PassageBridgeDeckOffsetMetres(passageIndex,static_cast<std::size_t>(index))
                     :std::lerp(internalChainPassage?0.20:0.15,0.20,lowerMouthBlend);
-                const double horizontalLengthSq=dx*dx+dy*dy;
+                const double horizontalLengthSq=segment.horizontalLengthSq;
                 const bool overlapSupportJoin=index+12<lastIndex
                     &&!IsPassageShortSpanSegment(passageIndex,static_cast<std::size_t>(index))
                     &&(index==0||(!IsPassageShortSpanSegment(passageIndex,
@@ -2208,25 +2347,21 @@ public:
                 const bool smoothSupportJoin=index>0&&overlapSupportJoin
                     &&!IsPassageShortSpanSegment(passageIndex,static_cast<std::size_t>(index+1));
                 const double projection=horizontalLengthSq>0.0
-                    ?((qx-segmentA.positionSubvoxels[0])*dx
-                        +(qy-segmentA.positionSubvoxels[1])*dy)/horizontalLengthSq:bestT;
+                    ?PassageXYProjectionNumerator(passageIndex,
+                        static_cast<std::size_t>(index),qx,qy)/horizontalLengthSq:bestT;
                 // Extend tread segments by a fixed distance through route knots. A
                 // fractional extension made the support width change with segment length.
                 const double overlapFraction=overlapSupportJoin&&horizontalLengthSq>0.0
-                ?std::min(0.5,2.0*qPerMetre/DeterministicSqrt(horizontalLengthSq)):0.0;
+                ?std::min(0.5,2.0*qPerMetre/segment.horizontalLength):0.0;
                 const double supportT=horizontalLengthSq>0.0
                     ?std::clamp(projection,-overlapFraction,1.0+overlapFraction):bestT;
-                double centerX=segmentA.positionSubvoxels[0]+supportT*dx;
-                double centerY=segmentA.positionSubvoxels[1]+supportT*dy;
-                double centerZ=segmentA.positionSubvoxels[2]+supportT*(
-                    static_cast<double>(segmentB.positionSubvoxels[2])-segmentA.positionSubvoxels[2]);
-                double radius=segmentA.radiusSubvoxels+supportT*(
-                    static_cast<double>(segmentB.radiusSubvoxels)-segmentA.radiusSubvoxels);
+                double centerX=segment.a[0]+supportT*dx;
+                double centerY=segment.a[1]+supportT*dy;
+                double centerZ=segment.a[2]+supportT*dz;
+                double radius=radiusA+supportT*segment.radiusDelta;
                 if(smoothSupportJoin)
                 {
                     if(passageProfile)++passageProfile->passageSmoothSupportJoins;
-                    const auto& p0=passage.controlPoints[static_cast<std::size_t>(index-1)];
-                    const auto& p3=passage.controlPoints[static_cast<std::size_t>(index+2)];
                     const double t2=supportT*supportT,t3=t2*supportT;
                     const auto interpolate=[&](double v0,double v1,double v2,double v3)
                     {
@@ -2235,18 +2370,18 @@ public:
                             +(-v0+3.0*v1-3.0*v2+v3)*t3);
                     };
                     const double SmoothSupportHeightWeight=internalChainPassage?0.0:0.25;
-                    centerZ+=(interpolate(p0.positionSubvoxels[2],segmentA.positionSubvoxels[2],
-                        segmentB.positionSubvoxels[2],p3.positionSubvoxels[2])-centerZ)
+                    centerZ+=(interpolate(segment.catmullBefore[2],segment.a[2],
+                        segment.b[2],segment.catmullAfter[2])-centerZ)
                         *SmoothSupportHeightWeight;
-                    radius+=(interpolate(p0.radiusSubvoxels,segmentA.radiusSubvoxels,
-                        segmentB.radiusSubvoxels,p3.radiusSubvoxels)-radius)
+                    radius+=(interpolate(segment.catmullRadiusBefore,radiusA,
+                        radiusB,segment.catmullRadiusAfter)-radius)
                         *SmoothSupportHeightWeight;
                 }
                 double treadRelief=0.0;
                 if(entryMouthShoulder
                     ||(index>=lowerMouthIndex-2&&index<=lowerMouthIndex+2))
                 {
-                    const double horizontalLength=DeterministicSqrt(horizontalLengthSq);
+                    const double horizontalLength=segment.horizontalLength;
                     if(horizontalLength>1.0e-6)
                     {
                         const double pathRelief=std::clamp(static_cast<double>(
@@ -2272,8 +2407,7 @@ public:
                 // not turn that tread into a ceiling or mid-air shelf.
                 // Sparse authored routes use the full signed distance around the top;
                 // dense routes retain the legacy one-sided tread density.
-                const double supportSegmentLength=DeterministicSqrt(
-                    horizontalLengthSq+dz*dz)/qPerMetre;
+                const double supportSegmentLength=segment.lengthMetres;
                 const double sparseRouteThreshold=VoxelForgeCore::WorldAssemblyEvaluatorVersion>=188
                     &&floatingIslandPassage&&passage.style==0?1.0:1.5;
                 const bool sparseRouteSupport=supportSegmentLength>sparseRouteThreshold;
@@ -2311,17 +2445,11 @@ public:
                     double prefixMetres=0.0;
                     for(std::ptrdiff_t routeIndex=0;routeIndex<index;++routeIndex)
                     {
-                        const auto& before=passage.controlPoints[
-                            static_cast<std::size_t>(routeIndex)];
-                        const auto& after=passage.controlPoints[
-                            static_cast<std::size_t>(routeIndex+1)];
-                        const double dx=static_cast<double>(after.positionSubvoxels[0])
-                            -before.positionSubvoxels[0];
-                        const double dy=static_cast<double>(after.positionSubvoxels[1])
-                            -before.positionSubvoxels[1];
-                        const double dz=static_cast<double>(after.positionSubvoxels[2])
-                            -before.positionSubvoxels[2];
-                        prefixMetres+=DeterministicSqrt(dx*dx+dy*dy+dz*dz)/qPerMetre;
+                        if(passageTileScopeMatches)
+                            passageTileQueries->recordPreparedSegmentUse(
+                                FScopedPassageTileQueries::EPreparedSegmentUse::Support);
+                        prefixMetres+=PassageSegmentData[passageIndex][
+                            static_cast<std::size_t>(routeIndex)].lengthMetres;
                     }
                     distanceFromMouthMetres=std::max(0.0,
                         prefixMetres+supportT*supportSegmentLength);
@@ -2332,17 +2460,11 @@ public:
                     for(std::ptrdiff_t routeIndex=index+1;
                         routeIndex<lowerMouthIndex;++routeIndex)
                     {
-                        const auto& before=passage.controlPoints[
-                            static_cast<std::size_t>(routeIndex)];
-                        const auto& after=passage.controlPoints[
-                            static_cast<std::size_t>(routeIndex+1)];
-                        const double dx=static_cast<double>(after.positionSubvoxels[0])
-                            -before.positionSubvoxels[0];
-                        const double dy=static_cast<double>(after.positionSubvoxels[1])
-                            -before.positionSubvoxels[1];
-                        const double dz=static_cast<double>(after.positionSubvoxels[2])
-                            -before.positionSubvoxels[2];
-                        suffixMetres+=DeterministicSqrt(dx*dx+dy*dy+dz*dz)/qPerMetre;
+                        if(passageTileScopeMatches)
+                            passageTileQueries->recordPreparedSegmentUse(
+                                FScopedPassageTileQueries::EPreparedSegmentUse::Support);
+                        suffixMetres+=PassageSegmentData[passageIndex][
+                            static_cast<std::size_t>(routeIndex)].lengthMetres;
                     }
                     distanceFromMouthMetres=std::max(0.0,
                         suffixMetres+(1.0-supportT)*supportSegmentLength);
@@ -2465,11 +2587,11 @@ public:
                 // whose floor is just below this density query, not the closest wall.
                 const double supportProfileOffset=surfaceToTunnelSupport?1.13:0.93;
                 const double supportProfileTarget=qz+supportProfileOffset*qPerMetre;
-                const auto supportProfile=std::lower_bound(passage.controlPoints.begin(),mainEnd,
-                    supportProfileTarget,[&](const auto& point,double value)
-                        {return floorProfile(point)>value;});
+                const auto supportProfile=std::lower_bound(floorProfileQ.begin(),
+                    floorProfileQ.begin()+lowerMouthIndex+1,supportProfileTarget,
+                    compareFloorProfile);
                 const std::ptrdiff_t profileIndex=std::clamp<std::ptrdiff_t>(
-                    supportProfile-passage.controlPoints.begin(),0,lowerMouthIndex);
+                    supportProfile-floorProfileQ.begin(),0,lowerMouthIndex);
                 // At floor height the nearest 3D centerline can belong to the next
                 // coil below. The descending floor profile identifies the coil that
                 // owns this tread, even when it is more than eight control points away.
@@ -4470,12 +4592,77 @@ private:
         double firstFloorQ=0.0,lastFloorQ=0.0,carveSearchMargin=0.0;
         std::ptrdiff_t lowerMouthIndex=1,lastIndex=1;
         std::ptrdiff_t mouthSearchBegin=0,mouthSearchEnd=0;
+        std::vector<double> controlFloorProfileQ;
     };
+    struct FPassageSegmentData
+    {
+        std::array<double,3> a{},b{},delta{},catmullBefore{},catmullAfter{};
+        double radiusA=0.0,radiusB=0.0,radiusDelta=0.0;
+        double catmullRadiusBefore=0.0,catmullRadiusAfter=0.0;
+        double lengthSq=0.0,horizontalLengthSq=0.0;
+        double lengthSubvoxels=0.0,horizontalLength=0.0,lengthMetres=0.0;
+    };
+    struct FPreparedPassageCapsuleSegment
+    {
+        std::array<double,3> a{},delta{};
+        double horizontalLengthSq=0.0;
+    };
+    const FPassageSegmentData& GetPassageSegmentData(std::size_t passageIndex,
+        std::size_t segmentIndex) const
+    {return PassageSegmentData[passageIndex][segmentIndex];}
+
+    double PassageXYProjectionNumerator(std::size_t passageIndex,
+        std::size_t segmentIndex,double qx,double qy) const
+    {
+        const FPassageSegmentData& segment=GetPassageSegmentData(
+            passageIndex,segmentIndex);
+        const std::size_t flatIndex=PassageSegmentOffsets[passageIndex]+segmentIndex;
+        const auto* tileQueries=ActivePassageTileQueries;
+        if(tileQueries&&tileQueries->matches(*this))
+            return tileQueries->projectionNumerator(flatIndex,qx,qy,
+                segment.a[0],segment.a[1],segment.delta[0],segment.delta[1]);
+        return (qx-segment.a[0])*segment.delta[0]
+            +(qy-segment.a[1])*segment.delta[1];
+    }
+
+    double PassageCapsuleRouteXYProjectionNumerator(std::size_t stratumIndex,
+        std::size_t segmentIndex,double qx,double qy) const
+    {
+        const FPreparedPassageCapsuleSegment& segment=
+            PassageStratumCapsuleSegments[stratumIndex][segmentIndex];
+        const std::size_t flatIndex=PassageSegmentOffsets.back()
+            +PassageMouthSupportSegmentOffsets.back()
+            +PassageStratumCapsuleSegmentOffsets[stratumIndex]+segmentIndex;
+        const auto* tileQueries=ActivePassageTileQueries;
+        if(tileQueries&&tileQueries->matches(*this))
+            return tileQueries->projectionNumerator(flatIndex,qx,qy,
+                segment.a[0],segment.a[1],segment.delta[0],segment.delta[1]);
+        return (qx-segment.a[0])*segment.delta[0]
+            +(qy-segment.a[1])*segment.delta[1];
+    }
+
     struct FPassageMouthSupportSegment
     {
         std::array<std::int64_t,4> a{},b{};
+        std::array<double,4> preparedA{},preparedDelta{};
+        double horizontalLengthSq=0.0;
         bool hasRadius=false;
     };
+    double PassageMouthSupportXYProjectionNumerator(std::size_t passageIndex,
+        std::size_t routeIndex,double qx,double qy) const
+    {
+        const FPassageMouthSupportSegment& segment=
+            PassageMouthSupportRoutes[passageIndex][routeIndex];
+        const std::size_t flatIndex=PassageSegmentOffsets.back()
+            +PassageMouthSupportSegmentOffsets[passageIndex]+routeIndex;
+        const auto* tileQueries=ActivePassageTileQueries;
+        if(tileQueries&&tileQueries->matches(*this))
+            return tileQueries->projectionNumerator(flatIndex,qx,qy,
+                segment.preparedA[0],segment.preparedA[1],
+                segment.preparedDelta[0],segment.preparedDelta[1]);
+        return (qx-segment.preparedA[0])*segment.preparedDelta[0]
+            +(qy-segment.preparedA[1])*segment.preparedDelta[1];
+    }
     struct FPassageNearestNode
     {
         std::array<double,3> minimum{},maximum{};
@@ -5520,18 +5707,75 @@ private:
 
     void BuildPassageComposerConstants()
     {
+        const bool tracePreparation=VF_IsL98PassagePrepareTraceEnabled();
+        const auto preparationStart=tracePreparation
+            ?std::chrono::steady_clock::now():std::chrono::steady_clock::time_point{};
         PassageComposerConstants.clear();
-        if(!ResolvedLayout)return;
+        PassageSegmentData.clear();
+        PassageSegmentOffsets.clear();
+        PassageStratumCapsuleSegments.clear();
+        PassageStratumCapsuleSegmentOffsets.clear();
+        if(!ResolvedLayout)
+        {
+            if(tracePreparation)
+                std::printf("[L98PassagePrepare] passages=0 segments=0 bytes=0 prepare_ms=%.3f\n",
+                    std::chrono::duration<double,std::milli>(
+                        std::chrono::steady_clock::now()-preparationStart).count());
+            return;
+        }
         PassageComposerConstants.resize(ResolvedLayout->passages.size());
+        PassageSegmentData.resize(ResolvedLayout->passages.size());
+        PassageSegmentOffsets.resize(ResolvedLayout->passages.size()+1,0);
+        PassageStratumCapsuleSegments.resize(ResolvedLayout->strates.size());
+        PassageStratumCapsuleSegmentOffsets.resize(ResolvedLayout->strates.size()+1,0);
         constexpr double Q=static_cast<double>(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
         const double qPerMetre=Q*1000000.0/
             std::max<std::uint32_t>(1,ResolvedLayout->coreVoxelSizeMicrometres);
         const double playerCenterAboveFloorQ=1.13*qPerMetre;
+        std::size_t preparedSegments=0;
+        std::size_t preparedFloorSamples=0;
         for(std::size_t passageIndex=0;passageIndex<ResolvedLayout->passages.size();
             ++passageIndex)
         {
+            PassageSegmentOffsets[passageIndex]=preparedSegments;
             const auto& passage=ResolvedLayout->passages[passageIndex];
-            if(passage.controlPoints.size()<2)continue;
+            if(passage.controlPoints.size()<2)
+            {
+                PassageSegmentOffsets[passageIndex+1]=preparedSegments;
+                continue;
+            }
+            auto& segmentData=PassageSegmentData[passageIndex];
+            segmentData.resize(passage.controlPoints.size()-1);
+            for(std::size_t segmentIndex=0;segmentIndex<segmentData.size();++segmentIndex)
+            {
+                const auto& a=passage.controlPoints[segmentIndex];
+                const auto& b=passage.controlPoints[segmentIndex+1];
+                const auto& p0=passage.controlPoints[segmentIndex==0?0:segmentIndex-1];
+                const auto& p3=passage.controlPoints[std::min(segmentIndex+2,
+                    passage.controlPoints.size()-1)];
+                FPassageSegmentData& data=segmentData[segmentIndex];
+                for(std::size_t axis=0;axis<3;++axis)
+                {
+                    data.a[axis]=static_cast<double>(a.positionSubvoxels[axis]);
+                    data.b[axis]=static_cast<double>(b.positionSubvoxels[axis]);
+                    data.delta[axis]=data.b[axis]-data.a[axis];
+                    data.catmullBefore[axis]=static_cast<double>(p0.positionSubvoxels[axis]);
+                    data.catmullAfter[axis]=static_cast<double>(p3.positionSubvoxels[axis]);
+                }
+                data.radiusA=static_cast<double>(a.radiusSubvoxels);
+                data.radiusB=static_cast<double>(b.radiusSubvoxels);
+                data.radiusDelta=static_cast<double>(b.radiusSubvoxels)-a.radiusSubvoxels;
+                data.catmullRadiusBefore=static_cast<double>(p0.radiusSubvoxels);
+                data.catmullRadiusAfter=static_cast<double>(p3.radiusSubvoxels);
+                const double dx=data.delta[0],dy=data.delta[1],dz=data.delta[2];
+                data.lengthSq=dx*dx+dy*dy+dz*dz;
+                data.horizontalLengthSq=dx*dx+dy*dy;
+                data.lengthSubvoxels=DeterministicSqrt(data.lengthSq);
+                data.horizontalLength=DeterministicSqrt(data.horizontalLengthSq);
+                data.lengthMetres=data.lengthSubvoxels/qPerMetre;
+                ++preparedSegments;
+            }
+            PassageSegmentOffsets[passageIndex+1]=preparedSegments;
             const auto supportStratum=[&](std::int32_t strateIndex)
                 ->const VoxelForgeCore::ResolvedLayoutStratumV2*
             {
@@ -5563,10 +5807,16 @@ private:
                 &&supportUpper->passageCapabilities.hasFloatingIslandLanding;
             constants.surfaceToTunnelSupport=supportUpper&&supportLower
                 &&supportUpper->lowerInterfaceCapabilities.surfaceToTunnelLandingSupport;
-            constants.firstFloorQ=passage.controlPoints.front().positionSubvoxels[2]
-                -passage.controlPoints.front().radiusSubvoxels+playerCenterAboveFloorQ;
-            constants.lastFloorQ=passage.controlPoints.back().positionSubvoxels[2]
-                -passage.controlPoints.back().radiusSubvoxels+playerCenterAboveFloorQ;
+            constants.controlFloorProfileQ.resize(passage.controlPoints.size());
+            for(std::size_t pointIndex=0;pointIndex<passage.controlPoints.size();++pointIndex)
+            {
+                const auto& point=passage.controlPoints[pointIndex];
+                constants.controlFloorProfileQ[pointIndex]=point.positionSubvoxels[2]
+                    -point.radiusSubvoxels+playerCenterAboveFloorQ;
+                ++preparedFloorSamples;
+            }
+            constants.firstFloorQ=constants.controlFloorProfileQ.front();
+            constants.lastFloorQ=constants.controlFloorProfileQ.back();
             constants.lastIndex=static_cast<std::ptrdiff_t>(passage.controlPoints.size())-1;
             constants.lowerMouthIndex=std::clamp<std::ptrdiff_t>(
                 static_cast<std::ptrdiff_t>(passage.lowerMouthControlIndex),1,
@@ -5578,6 +5828,43 @@ private:
             constants.carveSearchMargin=std::max(passage.mouthRadiusSubvoxels,
                 passage.midRadiusSubvoxels)+0.25*qPerMetre;
         }
+        std::size_t preparedCapsuleSegments=0;
+        for(std::size_t stratumIndex=0;stratumIndex<ResolvedLayout->strates.size();
+            ++stratumIndex)
+        {
+            PassageStratumCapsuleSegmentOffsets[stratumIndex]=preparedCapsuleSegments;
+            const auto& stratum=ResolvedLayout->strates[stratumIndex];
+            std::vector<const VoxelForgeCore::ResolvedLayoutAnchorV2*> routePoints;
+            for(const auto& anchor:stratum.anchors)
+                if(anchor.kind=="route_point"&&anchor.values.size()>=3)
+                    routePoints.push_back(&anchor);
+            auto& prepared=PassageStratumCapsuleSegments[stratumIndex];
+            if(routePoints.size()>1)prepared.resize(routePoints.size()-1);
+            for(std::size_t segmentIndex=0;segmentIndex<prepared.size();++segmentIndex)
+            {
+                FPreparedPassageCapsuleSegment& segment=prepared[segmentIndex];
+                for(std::size_t axis=0;axis<3;++axis)
+                {
+                    segment.a[axis]=routePoints[segmentIndex]->values[axis];
+                    segment.delta[axis]=routePoints[segmentIndex+1]->values[axis]
+                        -segment.a[axis];
+                }
+                const double dx=segment.delta[0],dy=segment.delta[1];
+                segment.horizontalLengthSq=dx*dx+dy*dy;
+                ++preparedCapsuleSegments;
+            }
+            PassageStratumCapsuleSegmentOffsets[stratumIndex+1]=preparedCapsuleSegments;
+        }
+        if(tracePreparation)
+            std::printf("[L98PassagePrepare] passages=%zu segments=%zu floor_samples=%zu capsule_route_segments=%zu bytes=%zu prepare_ms=%.3f\n",
+                PassageSegmentData.size(),preparedSegments,
+                preparedFloorSamples,
+                preparedCapsuleSegments,
+                preparedSegments*sizeof(FPassageSegmentData)
+                    +preparedFloorSamples*sizeof(double)
+                    +preparedCapsuleSegments*sizeof(FPreparedPassageCapsuleSegment),
+                std::chrono::duration<double,std::milli>(
+                    std::chrono::steady_clock::now()-preparationStart).count());
     }
 
     void BuildPassageSpatialIndices()
@@ -5595,6 +5882,7 @@ private:
         PassageNearestNodes.resize(ResolvedLayout?ResolvedLayout->passages.size():0);
         PassageMouthSupportRoutes.clear();
         PassageMouthSupportRoutes.resize(ResolvedLayout?ResolvedLayout->passages.size():0);
+        PassageMouthSupportSegmentOffsets.assign(PassageMouthSupportRoutes.size()+1,0);
         PassageLaterBoreSources.clear();
         PassageColumnSegmentFlags.clear();PassageShortSpanSegmentFlags.clear();
         PassageHasShortSpanFlags.clear();
@@ -5832,6 +6120,36 @@ private:
                 }
             }
         }
+        const bool traceMouthPreparation=VF_IsL98PassagePrepareTraceEnabled();
+        const auto mouthPreparationStart=traceMouthPreparation
+            ?std::chrono::steady_clock::now():std::chrono::steady_clock::time_point{};
+        std::size_t mouthSupportSegmentCount=0;
+        for(std::size_t passageIndex=0;passageIndex<PassageMouthSupportRoutes.size();
+            ++passageIndex)
+        {
+            PassageMouthSupportSegmentOffsets[passageIndex]=mouthSupportSegmentCount;
+            for(auto& segment:PassageMouthSupportRoutes[passageIndex])
+            {
+                for(std::size_t axis=0;axis<4;++axis)
+                {
+                    segment.preparedA[axis]=static_cast<double>(segment.a[axis]);
+                    segment.preparedDelta[axis]=axis<2
+                        ?static_cast<double>(segment.b[axis]-segment.a[axis])
+                        :static_cast<double>(segment.b[axis])-segment.a[axis];
+                }
+                const double dx=segment.preparedDelta[0];
+                const double dy=segment.preparedDelta[1];
+                segment.horizontalLengthSq=dx*dx+dy*dy;
+                ++mouthSupportSegmentCount;
+            }
+            PassageMouthSupportSegmentOffsets[passageIndex+1]=mouthSupportSegmentCount;
+        }
+        if(traceMouthPreparation)
+            std::printf("[L98PassageMouthPrepare] segments=%zu bytes=%zu prepare_ms=%.3f\n",
+                mouthSupportSegmentCount,
+                mouthSupportSegmentCount*sizeof(FPassageMouthSupportSegment),
+                std::chrono::duration<double,std::milli>(
+                    std::chrono::steady_clock::now()-mouthPreparationStart).count());
         // Precompute the later-bore leaves that can intersect each tread segment.
         // Passage support samples normally stay within this source envelope, so the
         // hot query can test a short list of physical bounds instead of walking a
@@ -6627,19 +6945,23 @@ private:
             for(auto it=candidate;it!=node.segments.end()&&*it<end;++it)
             {
                 const std::size_t index=*it;
-                const auto& a=passage.controlPoints[index];const auto& b=passage.controlPoints[index+1];
-                const double ax=a.positionSubvoxels[0],ay=a.positionSubvoxels[1],az=a.positionSubvoxels[2];
-                const double dx=static_cast<double>(b.positionSubvoxels[0])-ax;
-                const double dy=static_cast<double>(b.positionSubvoxels[1])-ay;
-                const double dz=static_cast<double>(b.positionSubvoxels[2])-az;
-                const double lengthSq=dx*dx+dy*dy+dz*dz;
+                const FPassageSegmentData& segment=GetPassageSegmentData(
+                    passageIndex,index);
+                const auto* l98TileQueries=ActivePassageTileQueries;
+                if(l98TileQueries&&l98TileQueries->matches(*this))
+                    l98TileQueries->recordPreparedSegmentUse(
+                        FScopedPassageTileQueries::EPreparedSegmentUse::Capsule);
+                const double ax=segment.a[0],ay=segment.a[1],az=segment.a[2];
+                const double dx=segment.delta[0],dy=segment.delta[1],dz=segment.delta[2];
+                const double lengthSq=segment.lengthSq;
                 if(lengthSq<=0.0)continue;
-                const double horizontalLengthSq=dx*dx+dy*dy;
+                const double horizontalLengthSq=segment.horizontalLengthSq;
                 const double t=horizontalLengthSq>0.0
-                    ?std::clamp(((qx-ax)*dx+(qy-ay)*dy)/horizontalLengthSq,0.0,1.0):0.0;
+                    ?std::clamp(PassageXYProjectionNumerator(passageIndex,index,qx,qy)
+                        /horizontalLengthSq,0.0,1.0):0.0;
                 const double centerX=ax+t*dx,centerY=ay+t*dy;
-                const double centerZ=az+t*dz-(static_cast<double>(a.radiusSubvoxels)
-                    +t*(static_cast<double>(b.radiusSubvoxels)-a.radiusSubvoxels))+1.13*qPerMetre;
+                const double centerZ=az+t*dz-(segment.radiusA
+                    +t*segment.radiusDelta)+1.13*qPerMetre;
                 const double horizontalX=qx-centerX,horizontalY=qy-centerY;
                 const double vertical=std::max(0.0,std::abs(qz-centerZ)-0.54*qPerMetre);
                 const double distance=DeterministicSqrt(horizontalX*horizontalX+horizontalY*horizontalY
@@ -6741,27 +7063,27 @@ private:
         constexpr double Q=static_cast<double>(VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
         const double qPerMetre=Q*1000000.0/std::max<std::uint32_t>(1,
             ResolvedLayout->coreVoxelSizeMicrometres);
-        const auto& a=passage.controlPoints[SegmentIndex];
-        const auto& b=passage.controlPoints[SegmentIndex+1];
         const auto upperStratum=std::find_if(ResolvedLayout->strates.begin(),
             ResolvedLayout->strates.end(),[&passage](const auto& value)
                 {return value.strateIndex==passage.upperStrateIndex;});
         const bool surfaceWorldUpper=upperStratum!=ResolvedLayout->strates.end()
             &&upperStratum->passageCapabilities.hasSurfaceLanding;
-        const double ax=static_cast<double>(a.positionSubvoxels[0]);
-        const double ay=static_cast<double>(a.positionSubvoxels[1]);
-        const double dx=static_cast<double>(b.positionSubvoxels[0])-ax;
-        const double dy=static_cast<double>(b.positionSubvoxels[1])-ay;
-        const double horizontalLengthSq=dx*dx+dy*dy;
+        const FPassageSegmentData& segment=GetPassageSegmentData(PassageIndex,SegmentIndex);
+        const auto* l98TileQueries=ActivePassageTileQueries;
+        if(l98TileQueries&&l98TileQueries->matches(*this))
+            l98TileQueries->recordPreparedSegmentUse(
+                FScopedPassageTileQueries::EPreparedSegmentUse::Support);
+        const double ax=segment.a[0],ay=segment.a[1];
+        const double dx=segment.delta[0],dy=segment.delta[1];
+        const double horizontalLengthSq=segment.horizontalLengthSq;
         const double qx=static_cast<double>(X)*Q,qy=static_cast<double>(Y)*Q;
         const double qz=static_cast<double>(Z)*Q;
         const double t=horizontalLengthSq>0.0
-            ?std::clamp(((qx-ax)*dx+(qy-ay)*dy)/horizontalLengthSq,0.0,1.0):0.0;
+            ?std::clamp(PassageXYProjectionNumerator(PassageIndex,SegmentIndex,qx,qy)
+                /horizontalLengthSq,0.0,1.0):0.0;
         const double centerX=ax+t*dx,centerY=ay+t*dy;
-        const double centerZ=a.positionSubvoxels[2]+t*(
-            static_cast<double>(b.positionSubvoxels[2])-a.positionSubvoxels[2]);
-        const double radius=a.radiusSubvoxels+t*(
-            static_cast<double>(b.radiusSubvoxels)-a.radiusSubvoxels);
+        const double centerZ=segment.a[2]+t*segment.delta[2];
+        const double radius=segment.radiusA+t*segment.radiusDelta;
         // Embed the deck 13 cm above the bore bottom: within the 25 cm support
         // probe, while leaving 16 cm between it and the capsule's lowest sample.
         const double floorQ=centerZ-radius
@@ -6819,27 +7141,31 @@ private:
                 const double capsuleRadius=0.37*qPerMetre;
                 const double capsuleHalfHeight=0.86*qPerMetre;
                 const double capsuleRadiusSquared=capsuleRadius*capsuleRadius;
-                const VoxelForgeCore::ResolvedLayoutAnchorV2* previous=nullptr;
-                for(const auto& anchor:lower->anchors)
+                const std::size_t lowerStratumIndex=static_cast<std::size_t>(
+                    lower-ResolvedLayout->strates.begin());
+                const auto& routeSegments=PassageStratumCapsuleSegments[
+                    lowerStratumIndex];
+                for(std::size_t segmentIndex=0;segmentIndex<routeSegments.size();
+                    ++segmentIndex)
                 {
-                    if(anchor.kind!="route_point"||anchor.values.size()<3)continue;
-                    if(previous)
-                    {
-                        const double ax=previous->values[0],ay=previous->values[1];
-                        const double dx=static_cast<double>(anchor.values[0])-ax;
-                        const double dy=static_cast<double>(anchor.values[1])-ay;
-                        const double lengthSquared=dx*dx+dy*dy;
-                        const double t=lengthSquared>0.0?std::clamp(
-                            ((qx-ax)*dx+(qy-ay)*dy)/lengthSquared,0.0,1.0):0.0;
-                        const double routeX=ax+t*dx,routeY=ay+t*dy;
-                        const double routeZ=previous->values[2]+t*(
-                            static_cast<double>(anchor.values[2])-previous->values[2]);
-                        const double routeDx=qx-routeX,routeDy=qy-routeY;
-                        if(routeDx*routeDx+routeDy*routeDy<=capsuleRadiusSquared
-                            &&std::abs(qz-routeZ)<=capsuleHalfHeight)
-                            return maximumRadius+qPerMetre;
-                    }
-                    previous=&anchor;
+                    const FPreparedPassageCapsuleSegment& segment=
+                        routeSegments[segmentIndex];
+                    const auto* l98TileQueries=ActivePassageTileQueries;
+                    if(l98TileQueries&&l98TileQueries->matches(*this))
+                        l98TileQueries->recordPreparedSegmentUse(
+                            FScopedPassageTileQueries::EPreparedSegmentUse::Capsule);
+                    const double ax=segment.a[0],ay=segment.a[1];
+                    const double dx=segment.delta[0],dy=segment.delta[1];
+                    const double lengthSquared=segment.horizontalLengthSq;
+                    const double t=lengthSquared>0.0?std::clamp(
+                        PassageCapsuleRouteXYProjectionNumerator(lowerStratumIndex,
+                            segmentIndex,qx,qy)/lengthSquared,0.0,1.0):0.0;
+                    const double routeX=ax+t*dx,routeY=ay+t*dy;
+                    const double routeZ=segment.a[2]+t*segment.delta[2];
+                    const double routeDx=qx-routeX,routeDy=qy-routeY;
+                    if(routeDx*routeDx+routeDy*routeDy<=capsuleRadiusSquared
+                        &&std::abs(qz-routeZ)<=capsuleHalfHeight)
+                        return maximumRadius+qPerMetre;
                 }
             }
         }
@@ -12778,6 +13104,7 @@ public:
             return;
         }
         if(Count<=0||OutDensity==nullptr)return;
+        FScopedPassageColumnXYReuse passageColumnXYReuse(*this);
         FScopedRoute l77DispatchRoute(ERoute::Dispatch);
         FScopedPhase l77DispatchPhase(EPhase::Dispatch);
         FScopedDensityQueryProfile queryProfile(EDensityQueryKind::Lattice,
@@ -13543,7 +13870,13 @@ private:
     bool PassageFeatureBoundsFailOpen=false;
     std::vector<std::vector<FPassageNearestNode>> PassageNearestNodes;
     std::vector<std::vector<FPassageMouthSupportSegment>> PassageMouthSupportRoutes;
+    std::vector<std::size_t> PassageMouthSupportSegmentOffsets;
     std::vector<FPassageComposerConstants> PassageComposerConstants;
+    std::vector<std::vector<FPassageSegmentData>> PassageSegmentData;
+    std::vector<std::size_t> PassageSegmentOffsets;
+    std::vector<std::vector<FPreparedPassageCapsuleSegment>>
+        PassageStratumCapsuleSegments;
+    std::vector<std::size_t> PassageStratumCapsuleSegmentOffsets;
     std::vector<std::vector<FPassageLaterBoreSource>> PassageLaterBoreSources;
     std::vector<FPassageProofBound> PassageProofBounds;
     std::vector<FPassageProofNode> PassageProofNodes;

Standalone/Core/src/VoxelForgeCore.cpp

@@ -18,6 +18,7 @@
 #include <new>
 #include <stdexcept>
 #include <sstream>
+#include <cstdlib>
 
 namespace vfcore::detail
 {
@@ -2799,6 +2800,94 @@ namespace VoxelForgeCore
             options.profilePassageComposer?&out.diagnostics:nullptr,key.lod,
             options.diagnosticPassageSourceFloorVoxels,
             options.diagnosticPassageCarveReachMetres);
+        static std::atomic<bool> l98ProjectionProbeStarted{false};
+        const char* l98ProjectionProbeSwitch=std::getenv(
+            "VOXELFORGE_L98_PASSAGE_REUSE_PROBE");
+        bool expectedProbeStart=false;
+        if(l98ProjectionProbeSwitch&&l98ProjectionProbeSwitch[0]=='1'
+            &&l98ProjectionProbeSwitch[1]=='\0'&&!tileShape.IsNativeOnly()
+            &&impl_->resolvedLayout
+            &&!impl_->resolvedLayout->passages.empty()
+            &&l98ProjectionProbeStarted.compare_exchange_strong(expectedProbeStart,true,
+                std::memory_order_relaxed))
+        {
+            constexpr std::int64_t ProbePadding=8
+                *WorldAssemblySubvoxelsPerVoxel;
+            std::array<std::int64_t,3> probeMinimum={
+                std::numeric_limits<std::int64_t>::max(),
+                std::numeric_limits<std::int64_t>::max(),
+                std::numeric_limits<std::int64_t>::max()};
+            std::array<std::int64_t,3> probeMaximum={
+                std::numeric_limits<std::int64_t>::min(),
+                std::numeric_limits<std::int64_t>::min(),
+                std::numeric_limits<std::int64_t>::min()};
+            const auto includeProbePoint=[&](std::size_t axis,double coordinate,
+                double radius)
+            {
+                if(!std::isfinite(coordinate)||!std::isfinite(radius))return;
+                probeMinimum[axis]=std::min(probeMinimum[axis],
+                    static_cast<std::int64_t>(std::floor(coordinate-radius))-ProbePadding);
+                probeMaximum[axis]=std::max(probeMaximum[axis],
+                    static_cast<std::int64_t>(std::ceil(coordinate+radius))+ProbePadding);
+            };
+            for(const auto& passage:impl_->resolvedLayout->passages)
+                for(const auto& point:passage.controlPoints)
+                    for(std::size_t axis=0;axis<3;++axis)
+                        includeProbePoint(axis,static_cast<double>(
+                            point.positionSubvoxels[axis]),
+                            static_cast<double>(point.radiusSubvoxels));
+            for(const auto& stratum:impl_->resolvedLayout->strates)
+                for(const auto& anchor:stratum.anchors)
+                    if(anchor.kind=="route_point"&&anchor.values.size()>=3)
+                        for(std::size_t axis=0;axis<3;++axis)
+                            includeProbePoint(axis,anchor.values[axis],0.0);
+            std::uint64_t probeRuns=0,probeSamples=0,probeMismatches=0;
+            if(probeMinimum[0]<=probeMaximum[0]
+                &&probeMinimum[1]<=probeMaximum[1]
+                &&probeMinimum[2]<=probeMaximum[2])
+            {
+                const FStandaloneShapeWorld::FScopedPassageTileQueries probeScope(
+                    tileShape,probeMinimum,probeMaximum,nullptr,key.lod);
+                constexpr int32 ProbeCount=8;
+                float runDensity[ProbeCount]{};
+                for(const auto& passage:impl_->resolvedLayout->passages)
+                    for(std::size_t segmentIndex=0;
+                        segmentIndex+1<passage.controlPoints.size();++segmentIndex)
+                    {
+                        const auto& a=passage.controlPoints[segmentIndex];
+                        const auto& b=passage.controlPoints[segmentIndex+1];
+                        const auto toVoxel=[](double subvoxels)
+                        {return static_cast<std::int32_t>(std::llround(
+                            subvoxels/WorldAssemblySubvoxelsPerVoxel));};
+                        const std::int32_t x=toVoxel(0.5*(
+                            static_cast<double>(a.positionSubvoxels[0])
+                                +static_cast<double>(b.positionSubvoxels[0])));
+                        const std::int32_t y=toVoxel(0.5*(
+                            static_cast<double>(a.positionSubvoxels[1])
+                                +static_cast<double>(b.positionSubvoxels[1])));
+                        const std::int32_t zMid=toVoxel(0.5*(
+                            static_cast<double>(a.positionSubvoxels[2])
+                                +static_cast<double>(b.positionSubvoxels[2])));
+                        const std::int32_t zStart=zMid-ProbeCount/2;
+                        tileShape.DensityAtLatticeZRun(x,y,zStart,1,ProbeCount,runDensity);
+                        ++probeRuns;
+                        probeSamples+=ProbeCount;
+                        for(std::int32_t lane=0;lane<ProbeCount;++lane)
+                        {
+                            const float scalarDensity=tileShape.DensityAtLattice(
+                                x,y,zStart+lane);
+                            if(std::bit_cast<std::uint32_t>(scalarDensity)
+                                !=std::bit_cast<std::uint32_t>(runDensity[lane]))
+                                ++probeMismatches;
+                        }
+                    }
+            }
+            std::printf("[L98PassageReuseProbe] z_runs=%llu samples=%llu scalar_mismatches=%llu status=%s\n",
+                static_cast<unsigned long long>(probeRuns),
+                static_cast<unsigned long long>(probeSamples),
+                static_cast<unsigned long long>(probeMismatches),
+                probeRuns>0&&probeMismatches==0?"PASS":"FAIL");
+        }
         if(options.profilePassageComposer)
         {
             out.diagnostics.passageComposerProfiled=true;