#include "SourceStamp.h"
#include "OwnerWorldLoader.h"
#include "StandaloneCoreScheduler.h"
#include "StreamBenchmarkPipeline.h"
#include "WorldAssemblyPrototype.h"
#include "StandaloneTlsProbe.h"
#include "../Core/src/StandaloneSnapshotAdapter.h"

#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <string_view>

namespace
{
    struct FOptions
    {
        std::filesystem::path DataPath;
        int WorkerCount=8;
        int ClipRadius=3;
        int MaxClipLevel=8;
        int MaxLevel=-1;
        int FarHorizonLOD8InteriorStepVoxels=0;
        bool WorldAssemblerPrototype=false;
        bool StreamBenchmark=false;
        bool StreamPipeline=false;
        bool StreamHash=false;
        bool StreamHashTiles=false;
        bool ProfileColumnOverlap=false;
        bool UseSharedColumnCache=true;
        bool ForceGenerate=false;
        bool MeshCoverage=false;
        bool ScreenSpaceGate=false;
        bool AuditUniformBlockProofs=false;
        bool ProfileLodWork=false;
        bool AuditBasePageEquivalence=false;
        bool AuditRouteParity=false;
        bool RegionCrossing=false;
        bool AuditTileShapeReadiness=false;
        int DiagnosticSlowShapeCompileMs=0;
        bool HasSeedOverride=false;
        int SeedOverride=0;
        bool HasRenderDistanceOverride=false;
        int RenderDistanceOverride=0;
        bool FloatingIslandsRecipe=false;
        bool LandmarkChamberDemo=false;
        bool AuditLandmarkReachability=false;
        bool TlsProbeRequested=false;
        int TlsProbeWorkers=0;
        std::string TlsProbeTouch="none";
        bool HasCamera=false;
        bool HasCameraStep=false;
        bool AutoSurfaceCamera=false;
        FVector CameraMeters=FVector::ZeroVector;
        FVector CameraStepMeters=FVector::ZeroVector;
        float CameraYawDegrees=0.0f;
        float CameraPitchDegrees=0.0f;
        std::filesystem::path MeshExportPath;
        std::filesystem::path ResolvedLayoutOutputPath;
        bool ResolvedLayoutOnly=false;
        bool AuditResolvedLayoutBoundaries=false;
        bool AuditResolvedLayoutPassages=false;
        bool AuditSurfaceClearance=false;
        bool AuditStrateTransitions=false;
        int TransitionModeOverride=-1;
        int TransitionWidthChunksOverride=-1;
    };

    bool ParseInteger(std::string_view text,int& output)
    {
        if(text.empty())return false;
        char* end=nullptr;
        const std::string value(text);
        const long parsed=std::strtol(value.c_str(),&end,10);
        if(end==value.c_str()||*end!='\0'||parsed<INT32_MIN||parsed>INT32_MAX)return false;
        output=static_cast<int>(parsed);
        return true;
    }

    bool ParseCamera(std::string_view text,FVector& meters,float& yawDegrees,float& pitchDegrees)
    {
        const std::string values(text);
        float x=0.0f,y=0.0f,z=0.0f,yaw=0.0f,pitch=0.0f;
        if(std::sscanf(values.c_str(),"%f,%f,%f,%f,%f",&x,&y,&z,&yaw,&pitch)!=5)
            return false;
        meters={x,y,z};
        yawDegrees=yaw;
        pitchDegrees=pitch;
        return true;
    }

    bool ParseCameraStep(std::string_view text,FVector& meters)
    {
        const std::string values(text);
        float x=0.0f,y=0.0f,z=0.0f;
        if(std::sscanf(values.c_str(),"%f,%f,%f",&x,&y,&z)!=3)return false;
        meters={x,y,z};
        return true;
    }

    bool MakeLandmarkChamberDemoRequests(
        const VoxelForgeCore::ResolvedLayoutSnapshotV3& layout,
        const VoxelForgeCore::WorldAssemblyManifest& worldAssembly,
        std::int32_t seed,
        std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1>& requests,
        std::string& error)
    {
        using namespace VoxelForgeCore;
        requests.clear();
        const auto surface=std::find_if(layout.strates.begin(),layout.strates.end(),
            [](const auto& value){return value.generatorKind=="SurfaceWorld";});
        if(surface==layout.strates.end())
        {error="landmark chamber demo needs a SurfaceWorld strate";return false;}
        const auto passage=std::find_if(layout.passages.begin(),layout.passages.end(),
            [&](const auto& value){return value.lowerStrateIndex==surface->strateIndex
                &&value.controlPoints.size()>=2;});
        if(passage==layout.passages.end())
        {error="landmark chamber demo needs a passage arrival mouth in SurfaceWorld";return false;}
        const std::size_t mouthIndex=std::min(passage->lowerMouthControlIndex,
            passage->controlPoints.size()-1);
        const auto& mouth=passage->controlPoints[mouthIndex].positionSubvoxels;
        const std::size_t priorIndex=mouthIndex>0?mouthIndex-1:mouthIndex;
        const auto& prior=passage->controlPoints[priorIndex].positionSubvoxels;
        const double dx=static_cast<double>(mouth[0])-prior[0];
        const double dy=static_cast<double>(mouth[1])-prior[1];
        const double length=std::hypot(dx,dy);
        if(!(length>0.0))
        {error="landmark chamber demo passage arrival has no horizontal tangent";return false;}
        const double sideX=-dy/length,sideY=dx/length;
        const double micrometresPerSubvoxel=static_cast<double>(layout.coreVoxelSizeMicrometres)
            /WorldAssemblySubvoxelsPerVoxel;
        std::array<std::int64_t,3> arrivalMicrometres{};
        for(std::size_t axis=0;axis<3;++axis)
            arrivalMicrometres[axis]=static_cast<std::int64_t>(std::llround(
                mouth[axis]*micrometresPerSubvoxel));
        ResolvedLayoutStampRequestV1 chamber;
        chamber.stableId="landmark/sw-arrival-chamber-v1";
        chamber.strateIndex=surface->strateIndex;
        chamber.kind=ResolvedSdfStampKindV1::carveEllipsoid;
        // Anchor the chamber horizontally beside the arrival passage. Its height is
        // set from the local SurfaceWorld ground sample below so the carve keeps a
        // real rock roof instead of breaking through a low patch of terrain.
        chamber.anchorPositionMicrometres={
            arrivalMicrometres[0]+static_cast<std::int64_t>(std::llround(sideX*28000000.0)),
            arrivalMicrometres[1]+static_cast<std::int64_t>(std::llround(sideY*28000000.0)),
            arrivalMicrometres[2]-13000000};
        chamber.placementRadiusMicrometres=0;
        chamber.halfExtentsMicrometres={8500000,7500000,3000000};
        chamber.smoothWidthMicrometres=600000;
        chamber.irregularityAmplitudeMicrometres=600000;
        chamber.irregularityWavelengthMicrometres=3800000;

        ResolvedLayoutStampRequestV1 dais;
        // Resolved stamps compose in stable-ID order. Keep the raised fills after
        // chamber-v1 so that the enclosing carve cannot cut them away.
        dais.stableId="landmark/sw-arrival-chamber-v1-dais";
        dais.strateIndex=surface->strateIndex;
        // The version-2 ellipsoid fill rounds the platform into the chamber floor
        // instead of leaving the long, straight wall of a flat-topped pillar.
        dais.kind=ResolvedSdfStampKindV1::fillDais;
        dais.anchorPositionMicrometres=chamber.anchorPositionMicrometres;
        // Keep the raised platform on the broad filled floor rather than merging
        // it into the chamber's outer slope. Leave a capsule-width landing around
        // the ramp's centerline at the chamber entrance.
        dais.anchorPositionMicrometres[0]+=static_cast<std::int64_t>(std::llround(sideX*2600000.0));
        dais.anchorPositionMicrometres[1]+=static_cast<std::int64_t>(std::llround(sideY*2600000.0));
        dais.anchorPositionMicrometres[2]-=400000;
        dais.placementRadiusMicrometres=0;
        dais.halfExtentsMicrometres={2100000,1800000,1300000};
        dais.smoothWidthMicrometres=450000;
        dais.irregularityAmplitudeMicrometres=180000;
        dais.irregularityWavelengthMicrometres=1800000;

        ResolvedLayoutStampRequestV1 chamberFloor;
        chamberFloor.stableId="landmark/sw-arrival-chamber-v1-floor";
        chamberFloor.strateIndex=surface->strateIndex;
        chamberFloor.kind=ResolvedSdfStampKindV1::fillDais;
        chamberFloor.anchorPositionMicrometres=chamber.anchorPositionMicrometres;
        chamberFloor.anchorPositionMicrometres[2]-=2500000;
        chamberFloor.placementRadiusMicrometres=0;
        chamberFloor.halfExtentsMicrometres={5800000,5200000,2000000};
        chamberFloor.smoothWidthMicrometres=250000;
        chamberFloor.irregularityAmplitudeMicrometres=80000;
        chamberFloor.irregularityWavelengthMicrometres=2200000;

        const auto surfacePlan=std::find_if(worldAssembly.plan.strates.begin(),
            worldAssembly.plan.strates.end(),[&](const auto& value)
                {return value.strateIndex==surface->strateIndex;});
        if(surfacePlan==worldAssembly.plan.strates.end())
        {error="landmark chamber demo needs its SurfaceWorld heightfield plan";return false;}
        const Heightfield2D field(worldAssembly.recipe,*surfacePlan);
        if(!field.isValid())
        {error="landmark chamber demo SurfaceWorld heightfield is invalid";return false;}

        const double coreMicrometres=std::max<std::uint32_t>(1,layout.coreVoxelSizeMicrometres);
        const double qToMicrometres=coreMicrometres/WorldAssemblySubvoxelsPerVoxel;
        const auto qToMetres=[&](std::int64_t value)
            {return static_cast<double>(value)*qToMicrometres/1000000.0;};
        const auto metresToQ=[&](double value)
            {return static_cast<std::int64_t>(std::llround(value*1000000.0/qToMicrometres));};
        const double startX=qToMetres(mouth[0])+sideX*20.0;
        const double startY=qToMetres(mouth[1])+sideY*20.0;
        const auto surfaceSample=field.point(metresToQ(startX),metresToQ(startY),0);
        const std::int64_t surfaceHeightQ=surfaceSample.groundHeightSubvoxels;
        const double surfaceHeight=qToMetres(surfaceHeightQ);

        // Search beside the arrival corridor for a chamber site whose actual terrain
        // height lets the player descend from this surface entrance at a walkable grade.
        // The earlier fixed XY site lay over a deep valley, leaving no room for a roof
        // and asking the ramp to drop 37 m in 71 m.
        double chamberSideOffset=0.0,chamberTangentOffset=0.0;
        double chamberGroundHeight=0.0,bestChamberSiteScore=std::numeric_limits<double>::infinity();
        for(double sideOffset=28.0;sideOffset<=52.0;sideOffset+=2.0)
            for(double tangentOffset=-32.0;tangentOffset<=32.0;tangentOffset+=2.0)
            {
                const double x=qToMetres(mouth[0])+sideX*sideOffset+dx/length*tangentOffset;
                const double y=qToMetres(mouth[1])+sideY*sideOffset+dy/length*tangentOffset;
                const double distanceFromEntrance=std::hypot(x-startX,y-startY);
                if(distanceFromEntrance<16.0)continue;
                const auto sample=field.point(metresToQ(x),metresToQ(y),0);
                const double ground=qToMetres(sample.groundHeightSubvoxels);
                if(ground<surfaceHeight-3.5||ground>surfaceHeight+4.0)continue;
                const double sideDelta=sideOffset-42.0;
                const double tangentDelta=tangentOffset-2.0;
                const double score=sideDelta*sideDelta+tangentDelta*tangentDelta
                    +4.0*(ground-surfaceHeight)*(ground-surfaceHeight);
                if(score>=bestChamberSiteScore)continue;
                bestChamberSiteScore=score;chamberSideOffset=sideOffset;
                chamberTangentOffset=tangentOffset;chamberGroundHeight=ground;
                chamber.anchorPositionMicrometres[0]=static_cast<std::int64_t>(
                    std::llround(x*1000000.0));
                chamber.anchorPositionMicrometres[1]=static_cast<std::int64_t>(
                    std::llround(y*1000000.0));
            }
        if(!std::isfinite(bestChamberSiteScore))
        {error="landmark chamber has no nearby surface site with a walkable descent grade";return false;}
        constexpr double ChamberRoofCoverMetres=0.5;
        const double chamberCarveTopReach=
            static_cast<double>(chamber.halfExtentsMicrometres[2]
                +chamber.smoothWidthMicrometres
                +chamber.irregularityAmplitudeMicrometres)/1000000.0;
        const double chamberCenterZ=chamberGroundHeight-chamberCarveTopReach
            -ChamberRoofCoverMetres;
        chamber.anchorPositionMicrometres[2]=static_cast<std::int64_t>(
            std::llround(chamberCenterZ*1000000.0));
        dais.anchorPositionMicrometres[0]=chamber.anchorPositionMicrometres[0]
            +static_cast<std::int64_t>(std::llround(sideX*2600000.0));
        dais.anchorPositionMicrometres[1]=chamber.anchorPositionMicrometres[1]
            +static_cast<std::int64_t>(std::llround(sideY*2600000.0));
        dais.anchorPositionMicrometres[2]=chamber.anchorPositionMicrometres[2]-400000;
        chamberFloor.anchorPositionMicrometres[0]=chamber.anchorPositionMicrometres[0];
        chamberFloor.anchorPositionMicrometres[1]=chamber.anchorPositionMicrometres[1];
        chamberFloor.anchorPositionMicrometres[2]=chamber.anchorPositionMicrometres[2]-2500000;

        struct FPathPoint { double x=0.0,y=0.0; };
        const FPathPoint start{startX,startY};
        const FPathPoint firstTurn{
            qToMetres(mouth[0])+sideX*34000000.0/1000000.0+dx/length*14000000.0/1000000.0,
            qToMetres(mouth[1])+sideY*34000000.0/1000000.0+dy/length*14000000.0/1000000.0};
        const FPathPoint end{
            chamber.anchorPositionMicrometres[0]/1000000.0,
            chamber.anchorPositionMicrometres[1]/1000000.0};
        const std::array<FPathPoint,3> waypoints={start,firstTurn,end};
        std::vector<FPathPoint> densePath;
        const auto appendLine=[&](FPathPoint from,FPathPoint to)
        {
            const double distance=std::hypot(to.x-from.x,to.y-from.y);
            const int steps=std::max(1,static_cast<int>(std::ceil(distance/0.25)));
            for(int i=0;i<=steps;++i)
            {
                const double t=static_cast<double>(i)/steps;
                const FPathPoint point{from.x+(to.x-from.x)*t,from.y+(to.y-from.y)*t};
                if(densePath.empty()||std::hypot(point.x-densePath.back().x,
                    point.y-densePath.back().y)>1.0e-6)densePath.push_back(point);
            }
        };
        constexpr double BendRadius=6.0;
        FPathPoint current=waypoints.front();
        for(std::size_t i=1;i+1<waypoints.size();++i)
        {
            const auto& previous=waypoints[i-1];const auto& corner=waypoints[i];
            const auto& next=waypoints[i+1];
            const double inLength=std::hypot(corner.x-previous.x,corner.y-previous.y);
            const double outLength=std::hypot(next.x-corner.x,next.y-corner.y);
            if(inLength<=2.0*BendRadius||outLength<=2.0*BendRadius)
            {error="landmark cave ramp has a segment too short to round";return false;}
            const FPathPoint inDirection{(corner.x-previous.x)/inLength,
                (corner.y-previous.y)/inLength};
            const FPathPoint outDirection{(next.x-corner.x)/outLength,
                (next.y-corner.y)/outLength};
            const FPathPoint before{corner.x-inDirection.x*BendRadius,
                corner.y-inDirection.y*BendRadius};
            const FPathPoint after{corner.x+outDirection.x*BendRadius,
                corner.y+outDirection.y*BendRadius};
            appendLine(current,before);
            constexpr int ArcSteps=24;
            for(int step=0;step<=ArcSteps;++step)
            {
                const double t=static_cast<double>(step)/ArcSteps,oneMinus=1.0-t;
                const FPathPoint point{
                    oneMinus*oneMinus*before.x+2.0*oneMinus*t*corner.x+t*t*after.x,
                    oneMinus*oneMinus*before.y+2.0*oneMinus*t*corner.y+t*t*after.y};
                if(densePath.empty()||std::hypot(point.x-densePath.back().x,
                    point.y-densePath.back().y)>1.0e-6)densePath.push_back(point);
            }
            current=after;
        }
        appendLine(current,waypoints.back());
        if(densePath.size()<2)
        {error="landmark cave ramp path is degenerate";return false;}
        std::vector<double> arcLength(densePath.size(),0.0);
        for(std::size_t i=1;i<densePath.size();++i)
            arcLength[i]=arcLength[i-1]+std::hypot(densePath[i].x-densePath[i-1].x,
                densePath[i].y-densePath[i-1].y);
        const double totalLength=arcLength.back();
        double firstTurnDistance=0.0;
        double firstTurnDistanceError=std::numeric_limits<double>::infinity();
        for(std::size_t i=0;i<densePath.size();++i)
        {
            const double distance=std::hypot(densePath[i].x-firstTurn.x,
                densePath[i].y-firstTurn.y);
            if(distance<firstTurnDistanceError)
            {firstTurnDistanceError=distance;firstTurnDistance=arcLength[i];}
        }
        // Put the first tunnel center one floor radius above grade so its lower boundary
        // meets the outdoor ground cleanly, while keeping a walkable cave-sized headroom.
        constexpr double RampRadiusMetres=1.6;
        const double startZ=surfaceHeight+RampRadiusMetres;
        // Join the chamber's filled floor at its top surface.
        const double endZ=chamberCenterZ+1.1;
        const double descent=endZ-startZ;
        constexpr double EntryLandingLength=5.0;
        constexpr double TurnLandingHalfLength=1.5;
        const double firstTurnLandingStart=std::max(EntryLandingLength,
            firstTurnDistance-TurnLandingHalfLength);
        const double firstTurnLandingEnd=std::min(totalLength,
            firstTurnDistance+TurnLandingHalfLength);
        const double firstTurnLandingLength=firstTurnLandingEnd-firstTurnLandingStart;
        const double slopedLength=std::max(0.0,totalLength-EntryLandingLength
            -firstTurnLandingLength);
        ResolvedLayoutStampRequestV1 mouthStamp;
        mouthStamp.stableId="landmark/sw-arrival-chamber-mouth-v1";
        mouthStamp.strateIndex=surface->strateIndex;
        mouthStamp.kind=ResolvedSdfStampKindV1::carveEllipsoid;
        mouthStamp.anchorPositionMicrometres={
            static_cast<std::int64_t>(std::llround(startX*1000000.0)),
            static_cast<std::int64_t>(std::llround(startY*1000000.0)),
            static_cast<std::int64_t>(std::llround((startZ+1.0)*1000000.0))};
        mouthStamp.placementRadiusMicrometres=0;
        mouthStamp.halfExtentsMicrometres={4200000,3700000,2800000};
        mouthStamp.smoothWidthMicrometres=450000;
        // A broad, rounded upper flare blends the side-facing portal into the slope.
        mouthStamp.irregularityAmplitudeMicrometres=250000;
        mouthStamp.irregularityWavelengthMicrometres=2400000;
        std::printf("[LandmarkChamberPlan] center_m=(%.3f,%.3f,%.3f) local_ground_m=%.3f carve_top_reach_m=%.3f roof_cover_m=%.3f\n",
            end.x,end.y,chamberCenterZ,chamberGroundHeight,chamberCarveTopReach,
            chamberGroundHeight-(chamberCenterZ+chamberCarveTopReach));
        std::printf("[LandmarkChamberSite] side_offset_m=%.3f tangent_offset_m=%.3f entrance_ground_m=%.3f chamber_ground_m=%.3f\n",
            chamberSideOffset,chamberTangentOffset,surfaceHeight,chamberGroundHeight);
        std::printf("[LandmarkRampPlan] entry_m=(%.3f,%.3f,%.3f) ground_m=%.3f cap_m=%.3f end_m=(%.3f,%.3f,%.3f) horizontal_m=%.3f entry_landing_m=%.3f turn_landing_m=%.3f turn_distance_m=%.3f sloped_m=%.3f descent_m=%.3f grade_deg=%.3f required_length_m=%.3f\n",
            startX,startY,startZ,surfaceHeight,
            qToMetres(surfaceSample.capHeightSubvoxels),end.x,end.y,endZ,totalLength,
            EntryLandingLength,firstTurnLandingLength,firstTurnDistance,
            slopedLength,descent,
            std::atan2(std::abs(descent),slopedLength)*180.0/3.14159265358979323846,
            std::abs(descent)/std::tan(15.0*3.14159265358979323846/180.0));
        if(!(slopedLength>0.0)||std::atan2(std::abs(descent),slopedLength)
            >15.0*3.14159265358979323846/180.0)
        {error="landmark cave ramp cannot meet the 15 degree walk grade";return false;}

        const double entryPathLength=std::hypot(firstTurn.x-start.x,
            firstTurn.y-start.y);
        const double entryPathX=(firstTurn.x-start.x)/entryPathLength;
        const double entryPathY=(firstTurn.y-start.y)/entryPathLength;
        const double mouthNormalX=-entryPathY,mouthNormalY=entryPathX;
        constexpr double MouthPortalDepth=3.8;
        constexpr double MouthPortalHalfWidth=2.8;
        constexpr double MouthPortalCenterOffset=2.6;
        const double mouthPortalX=startX+mouthNormalX*MouthPortalCenterOffset;
        const double mouthPortalY=startY+mouthNormalY*MouthPortalCenterOffset;
        ResolvedLayoutStampRequestV1 mouthPortal;
        mouthPortal.stableId="landmark/sw-arrival-chamber-mouth-approach-v1";
        mouthPortal.strateIndex=surface->strateIndex;
        mouthPortal.kind=ResolvedSdfStampKindV1::carveEllipsoid;
        mouthPortal.anchorPositionMicrometres={
            static_cast<std::int64_t>(std::llround(mouthPortalX*1000000.0)),
            static_cast<std::int64_t>(std::llround(mouthPortalY*1000000.0)),
            static_cast<std::int64_t>(std::llround(startZ*1000000.0))};
        mouthPortal.placementRadiusMicrometres=0;
        mouthPortal.halfExtentsMicrometres={3800000,2800000,2000000};
        mouthPortal.smoothWidthMicrometres=450000;
        mouthPortal.irregularityAmplitudeMicrometres=180000;
        mouthPortal.irregularityWavelengthMicrometres=2000000;

        ResolvedLayoutStampRequestV1 mouthLanding;
        mouthLanding.stableId="landmark/sw-arrival-z-mouth-landing-v1";
        mouthLanding.strateIndex=surface->strateIndex;
        mouthLanding.kind=ResolvedSdfStampKindV1::fillPillar;
        mouthLanding.anchorPositionMicrometres={
            static_cast<std::int64_t>(std::llround(mouthPortalX*1000000.0)),
            static_cast<std::int64_t>(std::llround(mouthPortalY*1000000.0)),
            static_cast<std::int64_t>(std::llround((startZ-RampRadiusMetres-1.5)
                *1000000.0))};
        mouthLanding.placementRadiusMicrometres=0;
        mouthLanding.halfExtentsMicrometres={3800000,2800000,1500000};
        mouthLanding.smoothWidthMicrometres=180000;
        mouthLanding.irregularityAmplitudeMicrometres=0;
        mouthLanding.irregularityWavelengthMicrometres=2000000;
        std::printf("[LandmarkMouthPortal] center_m=(%.3f,%.3f,%.3f) normal=(%.3f,%.3f) depth_m=%.2f half_width_m=%.2f landing_top_m=%.3f\n",
            mouthPortalX,mouthPortalY,startZ,mouthNormalX,mouthNormalY,
            MouthPortalDepth,MouthPortalHalfWidth,surfaceHeight);

        const auto atDistance=[&](double distance)
        {
            distance=std::clamp(distance,0.0,totalLength);
            const auto upper=std::lower_bound(arcLength.begin(),arcLength.end(),distance);
            const std::size_t hi=std::min<std::size_t>(densePath.size()-1,
                static_cast<std::size_t>(upper-arcLength.begin()));
            const std::size_t lo=hi?hi-1:0;
            const double span=arcLength[hi]-arcLength[lo];
            const double t=span>0.0?(distance-arcLength[lo])/span:0.0;
            return FPathPoint{densePath[lo].x+(densePath[hi].x-densePath[lo].x)*t,
                densePath[lo].y+(densePath[hi].y-densePath[lo].y)*t};
        };
        const auto centerlineHeight=[&](double distance)
        {
            const double beforeFirstTurn=std::clamp(distance-EntryLandingLength,0.0,
                firstTurnLandingStart-EntryLandingLength);
            const double afterFirstTurn=distance>firstTurnLandingEnd
                ?std::clamp(distance-firstTurnLandingEnd,0.0,
                    totalLength-firstTurnLandingEnd):0.0;
            return startZ+descent*std::clamp((beforeFirstTurn+afterFirstTurn)
                /slopedLength,0.0,1.0);
        };
        const double pointSpacing=0.6;
        const std::size_t rampCount=static_cast<std::size_t>(std::ceil(totalLength/pointSpacing));
        std::vector<ResolvedLayoutStampRequestV1> rampCarves;
        std::vector<ResolvedLayoutStampRequestV1> rampSupports;
        rampCarves.reserve(rampCount+1);
        // Footfall supports are denser and narrower than the tunnel stamps. This
        // keeps their overlapping flat caps from forming broad downhill shelves.
        const double supportSpacing=0.3;
        const std::size_t supportCount=static_cast<std::size_t>(std::ceil(
            totalLength/supportSpacing));
        rampSupports.reserve(supportCount+1);
        for(std::size_t i=0;i<=rampCount;++i)
        {
            const double distance=std::min(totalLength,static_cast<double>(i)*pointSpacing);
            const FPathPoint point=atDistance(distance);
            ResolvedLayoutStampRequestV1 ramp;
            const std::size_t number=i;
            ramp.stableId=std::string("landmark/sw-arrival-chamber-ramp-")+
                (number<10?"00":number<100?"0":"")+std::to_string(number);
            ramp.strateIndex=surface->strateIndex;
            ramp.kind=ResolvedSdfStampKindV1::carveEllipsoid;
            const double centerZ=centerlineHeight(distance);
            ramp.anchorPositionMicrometres={
                static_cast<std::int64_t>(std::llround(point.x*1000000.0)),
                static_cast<std::int64_t>(std::llround(point.y*1000000.0)),
                static_cast<std::int64_t>(std::llround(centerZ*1000000.0))};
            ramp.placementRadiusMicrometres=0;
            ramp.halfExtentsMicrometres={2600000,2600000,2000000};
            ramp.smoothWidthMicrometres=650000;
            // Keep the footfall surface smooth enough for the capsule grade limit;
            // the chamber and entrance carry the larger natural wall variation.
            ramp.irregularityAmplitudeMicrometres=250000;
            ramp.irregularityWavelengthMicrometres=2400000;
            rampCarves.push_back(std::move(ramp));
        }
        for(std::size_t i=0;i<=supportCount;++i)
        {
            const double distance=std::min(totalLength,static_cast<double>(i)*supportSpacing);
            const FPathPoint point=atDistance(distance);
            const double floorZ=centerlineHeight(distance)-RampRadiusMetres;
            ResolvedLayoutStampRequestV1 support;
            support.stableId=std::string("landmark/sw-arrival-ramp-support-")+
                (i<10?"00":i<100?"0":"")+std::to_string(i);
            support.strateIndex=surface->strateIndex;
            support.kind=ResolvedSdfStampKindV1::fillPillar;
            support.anchorPositionMicrometres={
                static_cast<std::int64_t>(std::llround(point.x*1000000.0)),
                static_cast<std::int64_t>(std::llround(point.y*1000000.0)),
                static_cast<std::int64_t>(std::llround((floorZ-1.5)*1000000.0))};
            support.placementRadiusMicrometres=0;
            // The first support widens into a buried entry landing under the open
            // mouth, so the approach surface stays supported at its carved rim.
            support.halfExtentsMicrometres=i==0
                ?std::array<std::int64_t,3>{3500000,3000000,1500000}
                :std::array<std::int64_t,3>{550000,550000,1500000};
            support.smoothWidthMicrometres=180000;
            support.irregularityAmplitudeMicrometres=0;
            support.irregularityWavelengthMicrometres=2200000;
            rampSupports.push_back(std::move(support));
        }
        requests.push_back(std::move(mouthStamp));
        requests.push_back(std::move(mouthPortal));
        requests.insert(requests.end(),std::make_move_iterator(rampCarves.begin()),
            std::make_move_iterator(rampCarves.end()));
        requests.push_back(std::move(chamber));
        requests.insert(requests.end(),std::make_move_iterator(rampSupports.begin()),
            std::make_move_iterator(rampSupports.end()));
        requests.push_back(std::move(mouthLanding));
        requests.push_back(std::move(chamberFloor));
        requests.push_back(std::move(dais));
        (void)seed;
        return true;
    }

    bool OverrideTransitions(VFJson::Value& root,int mode,int widthChunks,std::string& error)
    {
        auto* object=std::get_if<VFJson::Value::Object>(&root.Data);
        if(!object){error="transition fixture override requires an owner JSON object";return false;}
        const auto stratesIt=object->find("strates");
        if(stratesIt==object->end())
        {error="transition fixture override cannot find the resolved strate array";return false;}
        auto* strates=std::get_if<VFJson::Value::Array>(&stratesIt->second.Data);
        if(!strates||strates->empty())
        {error="transition fixture override found an empty or invalid strate array";return false;}
        for(auto& strate:*strates)
        {
            auto* strateObject=std::get_if<VFJson::Value::Object>(&strate.Data);
            if(!strateObject){error="transition fixture contains a malformed strate";return false;}
            const auto assetIt=strateObject->find("asset");
            if(assetIt==strateObject->end())continue;
            auto* asset=std::get_if<VFJson::Value::Object>(&assetIt->second.Data);
            if(!asset)continue;
            if(mode>=0)
            {
                VFJson::Value value;value.Data=static_cast<double>(mode);
                (*asset)["TransitionType"]=std::move(value);
            }
            if(widthChunks>=0)
            {
                VFJson::Value value;value.Data=static_cast<double>(widthChunks);
                (*asset)["TransitionBlendChunks"]=std::move(value);
            }
        }
        return true;
    }

    bool ParseOptions(int argc,char** argv,FOptions& options)
    {
        const std::filesystem::path executable=std::filesystem::absolute(argv[0]);
        options.DataPath=executable.parent_path().parent_path()/"data/owner_world.json";
        for(int index=1;index<argc;++index)
        {
            const std::string_view arg(argv[index]);
            const auto readInt=[&](std::string_view prefix,int& value)
            {return arg.starts_with(prefix)&&ParseInteger(arg.substr(prefix.size()),value);};
            if(arg=="--help"||arg=="-h")
            {
                std::printf("Usage: %s [owner_world.json] --world-assembler-prototype --stream-benchmark --stream-pipeline [options]\n"
                    "  --workers=N --clip-radius=N --max-clip-level=N --max-level=N\n"
                    "  --camera=X,Y,Z,YAW,PITCH (position in metres) --stream-hash\n"
                    "  --stream-hash-tiles (print per-tile hashes; implies --stream-hash)\n"
                    "  --camera-step=X,Y,Z (optional second view step in metres)\n"
                    "  --region-crossing (compile entering Core regions at the camera step)\n"
                    "  --column-cache=shared|thread-local (default: shared)\n"
                    "  --mesh-export=FILE (write the exact generated tile meshes for offline rendering)\n"
                    "  --profile-column-overlap --far-horizon-lod8-step=N --force-generate\n"
                    "  --seed=N --recipe=surface-world|floating-islands\n"
                    "  --landmark-chamber-demo (opt-in natural SW landmark chamber and ramp)\n"
                    "  --resolved-layout-output=FILE (canonical plan-time layout snapshot)\n"
                    "  --resolved-layout-only (exit after plan and snapshot validation)\n"
                    "  --audit-resolved-layout-boundaries (query Core at each recorded endpoint)\n"
                    "  --audit-strate-transitions (measure interface crossing, band thickness and holes)\n"
                    "  --transition-mode=hard|gradient|interleaved --transition-width-chunks=N (fixture override)\n"
                    "  --audit-resolved-layout-passages (capsule, support, route-binding and blocked-control audit)\n"
                    "  --audit-landmark-reachability (capsule, support, grade and buried-L43 control)\n"
                    "  --audit-surface-clearance (sample biome terrain/caps against the resolved ceiling)\n"
                    "  --auto-surface-camera (place the 27-tile cube on this seed's surface)\n"
                    "  --mesh-coverage (report non-empty tiles and indexed triangles)\n"
                    "  --screen-space-gate (measure display error and historical negative controls)\n"
                    "  --audit-uniform-block-proofs (fill and check every interval-certified block)\n"
                    "  --profile-lod-work (report per-LOD density sample counts)\n"
                    "  --audit-base-page-equivalence (hash one tile through both shape routes)\n"
                    "  --audit-route-parity (compare page, native-only, exact-query and mesh routes)\n"
                    "  --audit-tile-shape-readiness (run a deliberately mis-marked tile against the native-only guard)\n"
                    "  --diagnostic-slow-shape-compile-ms=N (diagnostic overlap control; default 0)\n"
                    "  --render-distance-chunks=N (0 disables the extra far ring)\n"
                    "  --tls-probe=N (Linux worker TLS/stack measurement; N=0..12)\n"
                    "  --tls-probe-touch=none|surface-world|floating-islands (first-use probe)\n"
                    "  --process-affinity=MASK --process-priority=Normal --frame-limit=FPS (viewer compatibility only)\n",
                    argv[0]);
                return false;
            }
            if(arg=="--world-assembler-prototype")options.WorldAssemblerPrototype=true;
            else if(arg=="--resolved-layout-only")options.ResolvedLayoutOnly=true;
            else if(arg=="--audit-resolved-layout-boundaries")options.AuditResolvedLayoutBoundaries=true;
            else if(arg=="--audit-resolved-layout-passages")options.AuditResolvedLayoutPassages=true;
            else if(arg=="--audit-landmark-reachability")options.AuditLandmarkReachability=true;
            else if(arg=="--audit-surface-clearance")options.AuditSurfaceClearance=true;
            else if(arg=="--audit-strate-transitions")options.AuditStrateTransitions=true;
            else if(arg.starts_with("--transition-mode="))
            {
                const std::string_view mode=arg.substr(std::string_view("--transition-mode=").size());
                if(mode=="gradient")options.TransitionModeOverride=0;
                else if(mode=="hard")options.TransitionModeOverride=1;
                else if(mode=="interleaved")options.TransitionModeOverride=2;
                else {std::fprintf(stderr,"Invalid transition mode: %.*s\n",static_cast<int>(mode.size()),mode.data());return false;}
            }
            else if(arg.starts_with("--transition-width-chunks="))
            {
                if(!readInt("--transition-width-chunks=",options.TransitionWidthChunksOverride)
                    ||options.TransitionWidthChunksOverride<0||options.TransitionWidthChunksOverride>64)
                {std::fprintf(stderr,"transition width chunks must be in 0..64\n");return false;}
            }
            else if(arg=="--stream-benchmark")options.StreamBenchmark=true;
            else if(arg=="--stream-pipeline")options.StreamPipeline=true;
            else if(arg=="--stream-hash")options.StreamHash=true;
            else if(arg=="--stream-hash-tiles")options.StreamHash=true,options.StreamHashTiles=true;
            else if(arg=="--profile-column-overlap")options.ProfileColumnOverlap=true;
            else if(arg=="--force-generate")options.ForceGenerate=true;
            else if(arg=="--mesh-coverage")options.MeshCoverage=true;
            else if(arg=="--screen-space-gate")options.ScreenSpaceGate=true;
            else if(arg=="--audit-uniform-block-proofs")options.AuditUniformBlockProofs=true;
            else if(arg=="--profile-lod-work")options.ProfileLodWork=true;
            else if(arg=="--audit-base-page-equivalence")options.AuditBasePageEquivalence=true;
            else if(arg=="--audit-route-parity")options.AuditRouteParity=true;
            else if(arg=="--region-crossing")options.RegionCrossing=true;
            else if(arg=="--audit-tile-shape-readiness")options.AuditTileShapeReadiness=true;
            else if(arg=="--auto-surface-camera")options.AutoSurfaceCamera=true;
            else if(arg.starts_with("--recipe="))
            {
                const std::string_view recipe=arg.substr(std::string_view("--recipe=").size());
                if(recipe=="surface-world")options.FloatingIslandsRecipe=false;
                else if(recipe=="floating-islands")options.FloatingIslandsRecipe=true;
                else {std::fprintf(stderr,"Invalid --recipe value: %.*s\n",static_cast<int>(recipe.size()),recipe.data());return false;}
            }
            else if(arg=="--landmark-chamber-demo")options.LandmarkChamberDemo=true;
            else if(arg.starts_with("--resolved-layout-output="))
                options.ResolvedLayoutOutputPath=std::string(arg.substr(std::string_view("--resolved-layout-output=").size()));
            else if(arg.starts_with("--seed="))
            {if(!readInt("--seed=",options.SeedOverride))return false;options.HasSeedOverride=true;}
            else if(arg.starts_with("--render-distance-chunks="))
            {
                if(!readInt("--render-distance-chunks=",options.RenderDistanceOverride))return false;
                options.RenderDistanceOverride=std::max(0,options.RenderDistanceOverride);
                options.HasRenderDistanceOverride=true;
            }
            else if(arg.starts_with("--tls-probe="))
            {
                if(!readInt("--tls-probe=",options.TlsProbeWorkers))return false;
                if(options.TlsProbeWorkers<0||options.TlsProbeWorkers>12)
                {std::fprintf(stderr,"--tls-probe must be in 0..12\n");return false;}
                options.TlsProbeRequested=true;
            }
            else if(arg.starts_with("--tls-probe-touch="))
            {
                const std::string_view touch=arg.substr(std::string_view("--tls-probe-touch=").size());
                if(touch!="none"&&touch!="surface-world"&&touch!="floating-islands")
                {std::fprintf(stderr,"Invalid --tls-probe-touch value: %.*s\n",static_cast<int>(touch.size()),touch.data());return false;}
                options.TlsProbeTouch=touch;
            }
            else if(arg.starts_with("--camera="))
            {
                if(!ParseCamera(arg.substr(9),options.CameraMeters,
                    options.CameraYawDegrees,options.CameraPitchDegrees))
                {std::fprintf(stderr,"Invalid --camera value: %.*s\n",static_cast<int>(arg.size()),arg.data());return false;}
                options.HasCamera=true;
            }
            else if(arg.starts_with("--camera-step="))
            {
                if(!ParseCameraStep(arg.substr(std::string_view("--camera-step=").size()),
                    options.CameraStepMeters))
                {std::fprintf(stderr,"Invalid --camera-step value: %.*s\n",static_cast<int>(arg.size()),arg.data());return false;}
                options.HasCameraStep=true;
            }
            else if(arg.starts_with("--column-cache="))
            {
                const std::string_view mode=arg.substr(std::string_view("--column-cache=").size());
                if(mode=="shared")options.UseSharedColumnCache=true;
                else if(mode=="thread-local")options.UseSharedColumnCache=false;
                else {std::fprintf(stderr,"Invalid --column-cache value: %.*s\n",static_cast<int>(arg.size()),arg.data());return false;}
            }
            else if(arg.starts_with("--mesh-export="))
            {
                options.MeshExportPath=std::filesystem::path(arg.substr(14));
                if(options.MeshExportPath.empty())
                {std::fprintf(stderr,"--mesh-export needs a file path\n");return false;}
            }
            else if(arg.starts_with("--workers="))
            {if(!readInt("--workers=",options.WorkerCount))return false;}
            else if(arg.starts_with("--clip-radius="))
            {if(!readInt("--clip-radius=",options.ClipRadius))return false;}
            else if(arg.starts_with("--max-clip-level="))
            {if(!readInt("--max-clip-level=",options.MaxClipLevel))return false;}
            else if(arg.starts_with("--max-level="))
            {if(!readInt("--max-level=",options.MaxLevel))return false;}
            else if(arg.starts_with("--far-horizon-lod8-step="))
            {if(!readInt("--far-horizon-lod8-step=",options.FarHorizonLOD8InteriorStepVoxels))return false;}
            else if(arg.starts_with("--diagnostic-slow-shape-compile-ms="))
            {if(!readInt("--diagnostic-slow-shape-compile-ms=",options.DiagnosticSlowShapeCompileMs))return false;}
            else if(arg.starts_with("--process-affinity=")||arg.starts_with("--process-priority=")
                ||arg.starts_with("--frame-limit="))
            {
                // These viewer switches are accepted for command-line parity. The caller pins
                // this headless process with taskset, and a headless run has no frame limiter.
            }
            else if(!arg.empty()&&arg.front()!='-')options.DataPath=std::filesystem::path(arg);
            else
            {std::fprintf(stderr,"Unknown option: %.*s\n",static_cast<int>(arg.size()),arg.data());return false;}
        }
        options.WorkerCount=std::clamp(options.WorkerCount,1,16);
        options.ClipRadius=std::clamp(options.ClipRadius,1,64);
        options.MaxClipLevel=std::clamp(options.MaxClipLevel,0,8);
        options.FarHorizonLOD8InteriorStepVoxels=std::max(0,options.FarHorizonLOD8InteriorStepVoxels);
        options.DiagnosticSlowShapeCompileMs=std::clamp(options.DiagnosticSlowShapeCompileMs,0,30000);
        if(!options.TlsProbeRequested&&options.TlsProbeTouch!="none")
        {std::fprintf(stderr,"--tls-probe-touch requires --tls-probe=N\n");return false;}
        if(options.RegionCrossing&&!options.HasCameraStep)
        {std::fprintf(stderr,"--region-crossing requires --camera-step=X,Y,Z\n");return false;}
        if(options.TlsProbeRequested)return true;
        if(!options.WorldAssemblerPrototype||!options.StreamBenchmark||!options.StreamPipeline)
        {
            std::fprintf(stderr,"This headless target runs the world-assembler streaming pipeline; pass --world-assembler-prototype --stream-benchmark --stream-pipeline.\n");
            return false;
        }
        return true;
    }
}

int main(int argc,char** argv)
{
    VoxelForgePrintSourceStamp();
    if(argc==2&&std::string_view(argv[1])=="--print-source-stamp")return 0;
    using Clock=std::chrono::steady_clock;
    const auto coldStart=Clock::now();
    FOptions options;
    if(!ParseOptions(argc,argv,options))return 2;
    if(options.TlsProbeRequested)
        return StandaloneTlsProbe::Run(options.TlsProbeWorkers,options.TlsProbeTouch);
    std::printf("[HeadlessConfig] data=%s workers=%d clip_radius=%d max_clip_level=%d max_level=%d hash=%s column_overlap=%s force_generate=%s recipe=%s shared_column_cache=%s camera_step_m=(%.3f,%.3f,%.3f) seed_override=%s render_distance_override=%s\n",
        options.DataPath.string().c_str(),options.WorkerCount,options.ClipRadius,options.MaxClipLevel,
        options.MaxLevel,options.StreamHash?"on":"off",options.ProfileColumnOverlap?"on":"off",
        options.ForceGenerate?"on":"off",options.FloatingIslandsRecipe?"floating-islands":"surface-world",
        options.UseSharedColumnCache?"on":"off",options.CameraStepMeters.X,options.CameraStepMeters.Y,
        options.CameraStepMeters.Z,
        options.HasSeedOverride?"yes":"no",options.HasRenderDistanceOverride?"yes":"no");
    std::printf("[ColdTimeline] stage=owner_data_load begin_ms=%.3f\n",
        std::chrono::duration<double,std::milli>(Clock::now()-coldStart).count());

    std::string error;
    auto ownerWorld=std::make_shared<FStandaloneOwnerWorld>();
    VFJson::Value ownerJsonRoot;
    {
        std::ifstream jsonFile(options.DataPath,std::ios::binary);
        if(!jsonFile)
        {std::fprintf(stderr,"Owner data load failed: cannot open %s\n",options.DataPath.string().c_str());return 2;}
        std::string ownerJsonText{std::istreambuf_iterator<char>(jsonFile),std::istreambuf_iterator<char>{}};
        if(!jsonFile&&!jsonFile.eof())
        {std::fprintf(stderr,"Owner data load failed: read error for %s\n",options.DataPath.string().c_str());return 2;}
        if(!VFJson::Parser(std::move(ownerJsonText)).Parse(ownerJsonRoot,error))
        {std::fprintf(stderr,"Owner data load failed: %s\n",error.c_str());return 2;}
    }
    if(options.HasSeedOverride
        &&!StandaloneWorldAssemblyPrototype::OverrideStandaloneSeed(ownerJsonRoot,options.SeedOverride,error))
    {std::fprintf(stderr,"Seed override failed: %s\n",error.c_str());return 2;}
    if(options.HasRenderDistanceOverride
        &&!StandaloneWorldAssemblyPrototype::OverrideStandaloneRenderDistance(
            ownerJsonRoot,options.RenderDistanceOverride,error))
    {std::fprintf(stderr,"Render-distance override failed: %s\n",error.c_str());return 2;}
    if(options.FloatingIslandsRecipe
        &&!StandaloneWorldAssemblyPrototype::SelectTopStrateAsFloatingIslands(ownerJsonRoot,error))
    {std::fprintf(stderr,"Floating-island recipe selection failed: %s\n",error.c_str());return 2;}
    if((options.TransitionModeOverride>=0||options.TransitionWidthChunksOverride>=0)
        &&!OverrideTransitions(ownerJsonRoot,options.TransitionModeOverride,
            options.TransitionWidthChunksOverride,error))
    {std::fprintf(stderr,"Transition fixture override failed: %s\n",error.c_str());return 2;}
    if(!StandaloneOwnerLoader::Resolve(ownerJsonRoot,*ownerWorld,error))
    {std::fprintf(stderr,"Owner data load failed: %s\n",error.c_str());return 2;}
    std::printf("[ColdTimeline] stage=owner_data_load end_ms=%.3f\n",
        std::chrono::duration<double,std::milli>(Clock::now()-coldStart).count());

    const int seed=ownerWorld->Seed;
    const int exportedMaxClipLevel=ownerWorld->MaxClipLevel;
    ownerWorld->ClipRadius=options.ClipRadius;
    ownerWorld->Settings->ClipRadius=options.ClipRadius;
    ownerWorld->MaxClipLevel=options.MaxClipLevel;
    ownerWorld->Settings->MaxClipLevel=options.MaxClipLevel;
    if(exportedMaxClipLevel!=options.MaxClipLevel)
        std::printf("Standalone max clip level override: exported=%d -> max_level=%d.\n",
            exportedMaxClipLevel,options.MaxClipLevel);

    FVector cameraVoxels=ownerWorld->ViewerStartVoxels;
    if(options.HasCamera)
    {
        const float VoxelsPerMetre=1000000.0f/std::max<std::uint32_t>(1,ownerWorld->CoreVoxelSizeMicrons);
        cameraVoxels=FVector(options.CameraMeters.X*VoxelsPerMetre,
            options.CameraMeters.Y*VoxelsPerMetre,options.CameraMeters.Z*VoxelsPerMetre);
    }

    const auto planStart=Clock::now();
    VoxelForgeCore::WorldAssemblyManifest worldAssembly;
    if(!StandaloneWorldAssemblyPrototype::AttachRound1WorldAssemblyPrototype(
        *ownerWorld,ownerJsonRoot,error,{},&worldAssembly))
    {std::fprintf(stderr,"World assembler prototype setup failed: %s\n",error.c_str());return 2;}
    if(options.FloatingIslandsRecipe
        &&!StandaloneWorldAssemblyPrototype::AttachFloatingIslandWorldAssembly(
            *ownerWorld,ownerJsonRoot,worldAssembly,error))
    {std::fprintf(stderr,"Floating-island assembly setup failed: %s\n",error.c_str());return 2;}
    VoxelForgeCore::ResolvedLayoutSnapshotV3 resolvedLayout;
    {
        const std::string_view variant=options.FloatingIslandsRecipe?"floating-islands":"surface-world";
        if(!StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
            *ownerWorld,worldAssembly,variant,resolvedLayout,error))
        {std::fprintf(stderr,"Resolved-layout snapshot failed: %s\n",error.c_str());return 2;}
        if(options.LandmarkChamberDemo)
        {
            std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1> requests;
            if(!MakeLandmarkChamberDemoRequests(resolvedLayout,worldAssembly,seed,requests,error)
                ||!VoxelForgeCore::ResolveResolvedLayoutStampsV2(
                    resolvedLayout,seed,requests,error))
            {std::fprintf(stderr,"Landmark chamber stamp resolution failed: %s\n",error.c_str());return 2;}
            const auto audit=VoxelForgeCore::AuditResolvedLayoutStampPlacementV1(resolvedLayout);
            std::printf("[ResolvedStampPlacementAudit] vocabulary=%u records=%zu route_control=rejected band_control=rejected controls=%u/%u status=%s\n",
                resolvedLayout.stampVocabularyVersion,resolvedLayout.stamps.size(),
                audit.negativeControlsRejected,audit.negativeControlsRun,
                audit.passed?"PASS":"FAIL");
            if(!audit.passed)
            {std::fprintf(stderr,"Resolved stamp placement negative control failed.\n");return 2;}
            for(const auto& stamp:resolvedLayout.stamps)
                std::printf("[ResolvedSdfStamp] id=%s strate=%d kind=%u position_m=(%.3f,%.3f,%.3f) bounds_um=[%lld,%lld)x[%lld,%lld)x[%lld,%lld) extents_m=(%.2f,%.2f,%.2f) irregularity_m=%.2f/%.2f seed=%llu\n",
                    stamp.stableId.c_str(),stamp.strateIndex,static_cast<unsigned>(stamp.kind),
                    stamp.positionMicrometres[0]/1000000.0,
                    stamp.positionMicrometres[1]/1000000.0,
                    stamp.positionMicrometres[2]/1000000.0,
                    static_cast<long long>(stamp.boundsMinimumMicrometres[0]),
                    static_cast<long long>(stamp.boundsMaximumMicrometres[0]),
                    static_cast<long long>(stamp.boundsMinimumMicrometres[1]),
                    static_cast<long long>(stamp.boundsMaximumMicrometres[1]),
                    static_cast<long long>(stamp.boundsMinimumMicrometres[2]),
                    static_cast<long long>(stamp.boundsMaximumMicrometres[2]),
                    stamp.halfExtentsMicrometres[0]/1000000.0,
                    stamp.halfExtentsMicrometres[1]/1000000.0,
                    stamp.halfExtentsMicrometres[2]/1000000.0,
                    stamp.irregularityAmplitudeMicrometres/1000000.0,
                    stamp.irregularityWavelengthMicrometres/1000000.0,
                    static_cast<unsigned long long>(stamp.irregularitySeed));
            std::printf("[LandmarkStampDemo] enabled=true seed=%d layout_id=%s passage_safe=true walk_route_clear=true version=%u deterministic_hash=seed,strate,stable_id status=PASS\n",
                seed,resolvedLayout.stableIdentity.c_str(),
                resolvedLayout.stampVocabularyVersion);
        }
        const std::string layoutJson=resolvedLayout.ToJson();
        const auto roundTrip=VoxelForgeCore::ResolvedLayoutSnapshotV3::FromJson(layoutJson,error);
        if(!roundTrip||roundTrip->ToJson()!=layoutJson||roundTrip->stableIdentity!=resolvedLayout.stableIdentity)
        {if(error.empty())error="resolved-layout canonical serialization did not round-trip";
         std::fprintf(stderr,"Resolved-layout round trip failed: %s\n",error.c_str());return 2;}
        std::string resolvedStrateStyles="{";
        bool firstResolvedStrateStyle=true;
        for(const FStrateSlot& slot:ownerWorld->Manager->GetLayout())
        {
            if(!slot.Definition)continue;
            const auto resolvedStrate=std::find_if(resolvedLayout.strates.begin(),
                resolvedLayout.strates.end(),[&](const auto& value)
                    {return value.strateIndex==slot.StrateIndex;});
            if(resolvedStrate==resolvedLayout.strates.end())continue;
            const auto style=static_cast<std::uint32_t>(slot.Definition->PassageConfig.Style);
            if(!firstResolvedStrateStyle)resolvedStrateStyles+=',';
            firstResolvedStrateStyle=false;
            resolvedStrateStyles.push_back('"');
            resolvedStrateStyles+=std::to_string(slot.StrateIndex);
            resolvedStrateStyles+="\":";
            resolvedStrateStyles+=std::to_string(style);
        }
        resolvedStrateStyles+='}';
        const std::string layoutOutputJson=layoutJson.substr(0,layoutJson.size()-1)
            +",\"resolved_strate_passage_styles\":"+resolvedStrateStyles+"}";
        if(!options.ResolvedLayoutOutputPath.empty())
        {
            if(!options.ResolvedLayoutOutputPath.parent_path().empty())
                std::filesystem::create_directories(options.ResolvedLayoutOutputPath.parent_path());
            std::ofstream output(options.ResolvedLayoutOutputPath,std::ios::binary);
            if(!output){std::fprintf(stderr,"Could not write resolved-layout snapshot: %s\n",options.ResolvedLayoutOutputPath.c_str());return 2;}
            output.write(layoutOutputJson.data(),static_cast<std::streamsize>(layoutOutputJson.size()));
            if(!output){std::fprintf(stderr,"Resolved-layout snapshot write failed: %s\n",options.ResolvedLayoutOutputPath.c_str());return 2;}
        }
        const auto controls=VoxelForgeCore::AuditResolvedLayoutValidatorV3();
        std::vector<VoxelForgeCore::ResolvedLayoutIssueV2> compatibilityIssues;
        std::string compatibilityError;
        const bool compatibilityAccepted=resolvedLayout.validate(
            VoxelForgeCore::ResolvedLayoutValidationModeV3::compatibility,
            compatibilityIssues,compatibilityError);
        std::vector<VoxelForgeCore::ResolvedLayoutIssueV2> strictIssues;
        std::string strictError;
        const bool strictAccepted=resolvedLayout.validate(
            VoxelForgeCore::ResolvedLayoutValidationModeV3::strict,strictIssues,strictError);
        std::printf("[ResolvedLayoutSnapshot] schema=%u stable_identity=%s strata=%zu bytes=%zu round_trip=PASS\n",
            resolvedLayout.schemaVersion,resolvedLayout.stableIdentity.c_str(),resolvedLayout.strates.size(),layoutJson.size());
        for(const FStrateSlot& slot:ownerWorld->Manager->GetLayout())
        {
            if(!slot.Definition)continue;
            const auto resolvedStrate=std::find_if(resolvedLayout.strates.begin(),
                resolvedLayout.strates.end(),[&](const auto& value)
                    {return value.strateIndex==slot.StrateIndex;});
            if(resolvedStrate!=resolvedLayout.strates.end())
                std::printf("[ResolvedStratePassageStyle] strate_index=%d generator_kind=%s style=%u\n",
                    slot.StrateIndex,resolvedStrate->generatorKind.c_str(),
                    static_cast<std::uint32_t>(slot.Definition->PassageConfig.Style));
        }
        const auto requestedRecipe=options.FloatingIslandsRecipe
            ?std::string_view("floating-islands"):std::string_view("surface-world");
        const auto topStratum=std::max_element(resolvedLayout.strates.begin(),resolvedLayout.strates.end(),
            [](const auto& a,const auto& b)
                {return a.interiorTopMicrometres<b.interiorTopMicrometres;});
        const bool hasFloatingIslands=std::any_of(resolvedLayout.strates.begin(),resolvedLayout.strates.end(),
            [](const auto& stratum){return stratum.generatorKind=="FloatingIslands";});
        const bool hasSurfaceWorldPlan=std::any_of(resolvedLayout.strates.begin(),resolvedLayout.strates.end(),
            [&](const auto& stratum)
            {
                return stratum.generatorKind=="SurfaceWorld"
                    &&stratum.recipeId=="SurfaceWorld.Heightfield2D"
                    &&std::any_of(worldAssembly.plan.strates.begin(),worldAssembly.plan.strates.end(),
                        [&](const auto& plan){return plan.strateIndex==stratum.strateIndex;});
            });
        const auto actualRecipe=hasFloatingIslands?std::string_view("floating-islands")
            :hasSurfaceWorldPlan?std::string_view("surface-world")
            :std::string_view("missing");
        const char* topGenerator=topStratum==resolvedLayout.strates.end()
            ?"missing":topStratum->generatorKind.c_str();
        std::printf("[WorldAssemblerRecipeAudit] requested=%.*s actual=%.*s top_generator=%s surface_world_plan=%s floating_islands_stratum=%s status=%s\n",
            static_cast<int>(requestedRecipe.size()),requestedRecipe.data(),
            static_cast<int>(actualRecipe.size()),actualRecipe.data(),
            topGenerator,hasSurfaceWorldPlan?"present":"absent",hasFloatingIslands?"present":"absent",
            actualRecipe==requestedRecipe?"PASS":"FAIL");
        if(actualRecipe!=requestedRecipe)
        {std::fprintf(stderr,"Requested recipe %.*s resolved to %.*s\n",
            static_cast<int>(requestedRecipe.size()),requestedRecipe.data(),
            static_cast<int>(actualRecipe.size()),actualRecipe.data());return 2;}
        std::printf("[ResolvedLayoutCompatibility] accepted=%s issues=%zu error=%s\n",
            compatibilityAccepted?"true":"false",compatibilityIssues.size(),compatibilityError.c_str());
        for(const auto& issue:compatibilityIssues)
            std::printf("[ResolvedLayoutCompatibilityIssue] code=%s detail=%s\n",
                issue.code.c_str(),issue.detail.c_str());
        if(!compatibilityAccepted)
        {std::fprintf(stderr,"Resolved-layout compatibility validation failed: %s\n",compatibilityError.c_str());return 2;}
        std::printf("[ResolvedLayoutStrict] accepted=%s issues=%zu error=%s\n",
            strictAccepted?"true":"false",strictIssues.size(),strictError.c_str());
        for(const auto& issue:strictIssues)
            std::printf("[ResolvedLayoutStrictIssue] code=%s detail=%s\n",issue.code.c_str(),issue.detail.c_str());
        if(!strictAccepted)
        {std::fprintf(stderr,"Resolved-layout strict validation failed: %s\n",strictError.c_str());return 2;}
        std::printf("[ResolvedLayoutValidatorControls] rejected=%u/%u status=%s\n",
            controls.controlsRejectedAsExpected,controls.controlsRun,controls.passed?"PASS":"FAIL");
        if(!controls.passed)
        {for(const auto& failure:controls.failures)std::printf("[ResolvedLayoutValidatorControlFailure] %s %s\n",failure.code.c_str(),failure.detail.c_str());return 2;}
        if(!options.ResolvedLayoutOutputPath.empty())
            std::printf("[ResolvedLayoutSnapshotOutput] path=%s\n",options.ResolvedLayoutOutputPath.c_str());
        if(auto* root=std::get_if<VFJson::Value::Object>(&ownerJsonRoot.Data))
        {VFJson::Value layoutText;layoutText.Data=layoutJson;(*root)["resolved_layout_json"]=std::move(layoutText);}
        else
        {std::fprintf(stderr,"Owner snapshot root cannot carry its resolved layout.\n");return 2;}
        if(options.AuditSurfaceClearance)
        {
            if(options.FloatingIslandsRecipe)
            {std::fprintf(stderr,"--audit-surface-clearance requires --recipe=surface-world\n");return 2;}
            const auto surface=std::find_if(resolvedLayout.strates.begin(),resolvedLayout.strates.end(),
                [](const auto& Stratum){return Stratum.generatorKind=="SurfaceWorld";});
            const auto plan=surface==resolvedLayout.strates.end()?worldAssembly.plan.strates.end()
                :std::find_if(worldAssembly.plan.strates.begin(),worldAssembly.plan.strates.end(),
                    [&](const auto& Stratum){return Stratum.strateIndex==surface->strateIndex;});
            if(surface==resolvedLayout.strates.end()||plan==worldAssembly.plan.strates.end()
                ||!surface->ceiling.presentInCurrentField)
            {std::fprintf(stderr,"SurfaceWorld clearance audit could not resolve its plan/ceiling\n");return 2;}
            const VoxelForgeCore::Heightfield2D Field(worldAssembly.recipe,*plan);
            if(!Field.isValid())
            {std::fprintf(stderr,"SurfaceWorld clearance audit field is invalid\n");return 2;}
            constexpr std::int64_t HalfExtentMetres=2048,StepMetres=1;
            const double CoreMicrometres=std::max<std::uint32_t>(1,ownerWorld->CoreVoxelSizeMicrons);
            const double MetresPerSubvoxel=CoreMicrometres
                /(1000000.0*VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel);
            double CenterX=0.0,CenterY=0.0;
            if(!plan->route.empty())
            {CenterX=plan->route.front().positionSubvoxels[0]*MetresPerSubvoxel;
             CenterY=plan->route.front().positionSubvoxels[1]*MetresPerSubvoxel;}
            const std::int64_t CenterXQ=static_cast<std::int64_t>(std::llround(
                CenterX/MetresPerSubvoxel));
            const std::int64_t CenterYQ=static_cast<std::int64_t>(std::llround(
                CenterY/MetresPerSubvoxel));
            const std::int64_t StepQ=static_cast<std::int64_t>(std::llround(
                StepMetres/MetresPerSubvoxel));
            struct FBiomeClearance
            {
                std::uint64_t Samples=0;
                double MaximumGround=-std::numeric_limits<double>::infinity();
                double MaximumCap=-std::numeric_limits<double>::infinity();
                double MaximumSurface=-std::numeric_limits<double>::infinity();
                double MinimumClearance=std::numeric_limits<double>::infinity();
                double AtX=0.0,AtY=0.0,AtHeight=0.0;
                std::int64_t MaximumCapQ=std::numeric_limits<std::int64_t>::min();
            };
            std::map<std::uint32_t,FBiomeClearance> ByBiome;
            const double CeilingFace=static_cast<double>(surface->ceiling.bottomMicrometres)/1000000.0;
            for(std::int64_t Y=-HalfExtentMetres;Y<=HalfExtentMetres;Y+=StepMetres)
            for(std::int64_t X=-HalfExtentMetres;X<=HalfExtentMetres;X+=StepMetres)
            {
                const auto Sample=Field.point(CenterXQ+(X/StepMetres)*StepQ,
                    CenterYQ+(Y/StepMetres)*StepQ,0);
                const double Ground=Sample.groundHeightSubvoxels*MetresPerSubvoxel;
                const double Cap=Sample.capHeightSubvoxels*MetresPerSubvoxel;
                const double SurfaceHeight=std::max(Ground,Cap);
                auto& Stats=ByBiome[Sample.biomeId];
                ++Stats.Samples;
                Stats.MaximumGround=std::max(Stats.MaximumGround,Ground);
                Stats.MaximumCap=std::max(Stats.MaximumCap,Cap);
                Stats.MaximumCapQ=std::max(Stats.MaximumCapQ,Sample.capHeightSubvoxels);
                Stats.MaximumSurface=std::max(Stats.MaximumSurface,SurfaceHeight);
                const double Clearance=CeilingFace-SurfaceHeight;
                if(Clearance<Stats.MinimumClearance)
                {Stats.MinimumClearance=Clearance;Stats.AtX=CenterX+X;Stats.AtY=CenterY+Y;
                 Stats.AtHeight=SurfaceHeight;}
            }
            double MaximumRouteZ=-std::numeric_limits<double>::infinity();
            for(const auto& Point:plan->route)
                MaximumRouteZ=std::max(MaximumRouteZ,Point.positionSubvoxels[2]*MetresPerSubvoxel);
            const auto CapBounds=Field.capHeightBounds();
            const auto RouteSample=plan->route.empty()?VoxelForgeCore::HeightfieldPointSample{}
                :Field.point(plan->route.front().positionSubvoxels[0],
                    plan->route.front().positionSubvoxels[1],0);
            std::printf("[SurfaceClearancePlan] has_recipe_override=%s layout_chunk_q=%lld plan_cap_q=%lld cap_bounds_q=(%lld,%lld)\n",
                plan->hasRecipeOverride?"true":"false",
                static_cast<long long>(worldAssembly.recipe.layoutChunkWidthSubvoxels),
                static_cast<long long>(plan->capHeightSubvoxels),
                static_cast<long long>(CapBounds[0]),static_cast<long long>(CapBounds[1]));
            for(const auto& Profile:worldAssembly.recipe.biomes)
                std::printf("[SurfaceClearanceProfile] biome_id=%u has_cap=%s cap_q=%lld undulation_q=%lld detail_q=%lld ridge_q=%lld\n",
                    Profile.stableId,Profile.hasCapProfile?"true":"false",
                    static_cast<long long>(Profile.capHeightSubvoxels),
                    static_cast<long long>(Profile.capUndulationSubvoxels),
                    static_cast<long long>(Profile.capDetailAmplitudeSubvoxels),
                    static_cast<long long>(Profile.capRidgeAmplitudeSubvoxels));
            std::printf("[SurfaceClearanceAudit] box_m=4096x4096 step_m=%lld samples=%lld ceiling_inner_face_m=%.3f unmodified_field=true\n",
                static_cast<long long>(StepMetres),
                static_cast<long long>((2*HalfExtentMetres/StepMetres+1)*(2*HalfExtentMetres/StepMetres+1)),
                CeilingFace);
            std::printf("[SurfaceClearanceCapRange] plan_min_m=%.3f plan_max_m=%.3f spawn_cap_m=%.3f spawn_ground_m=%.3f\n",
                CapBounds[0]*MetresPerSubvoxel,CapBounds[1]*MetresPerSubvoxel,
                RouteSample.capHeightSubvoxels*MetresPerSubvoxel,
                RouteSample.groundHeightSubvoxels*MetresPerSubvoxel);
            for(const auto& Feature:plan->features)
                std::printf("[SurfaceClearanceFeature] type=%u params_q=(%lld,%lld,%lld,%lld)\n",
                    Feature.type,static_cast<long long>(Feature.parametersSubvoxels[0]),
                    static_cast<long long>(Feature.parametersSubvoxels[1]),
                    static_cast<long long>(Feature.parametersSubvoxels[2]),
                    static_cast<long long>(Feature.parametersSubvoxels[3]));
            for(const auto& [BiomeId,Stats]:ByBiome)
                std::printf("[SurfaceClearanceBiome] biome_id=%u samples=%llu max_ground_m=%.3f max_cap_m=%.3f max_cap_q=%lld max_surface_m=%.3f min_clearance_m=%.3f at_m=(%.1f,%.1f,%.3f)\n",
                    BiomeId,static_cast<unsigned long long>(Stats.Samples),Stats.MaximumGround,
                    Stats.MaximumCap,static_cast<long long>(Stats.MaximumCapQ),Stats.MaximumSurface,Stats.MinimumClearance,
                    Stats.AtX,Stats.AtY,Stats.AtHeight);
            std::printf("[SurfaceClearanceRoute] route_points=%zu max_route_z_m=%.3f clearance_m=%.3f status=%s\n",
                plan->route.size(),MaximumRouteZ,CeilingFace-MaximumRouteZ,
                MaximumRouteZ<CeilingFace?"PASS":"COLLISION");
        }
        if(options.ResolvedLayoutOnly)return 0;
    }
    if(options.AutoSurfaceCamera)
    {
        constexpr std::int64_t UnitsPerVoxel=VoxelForgeCore::WorldAssemblySubvoxelsPerVoxel;
        if(options.FloatingIslandsRecipe)
        {
            const VoxelForgeCore::FloatingIslandAnchorV1* chosen=nullptr;
            for(const auto& islandSet:worldAssembly.floatingIslands)
                for(const auto& island:islandSet.manifest.plan.islands)
                    if(!chosen||island.radiusSubvoxels>chosen->radiusSubvoxels)chosen=&island;
            if(!chosen)
            {std::fprintf(stderr,"[SeedSurfacePlacement] FAIL: island plan has no anchors\n");return 2;}
            cameraVoxels={
                static_cast<float>(chosen->centerSubvoxels[0])/UnitsPerVoxel,
                static_cast<float>(chosen->centerSubvoxels[1])/UnitsPerVoxel,
                static_cast<float>(chosen->centerSubvoxels[2])/UnitsPerVoxel};
            std::printf("[SeedSurfacePlacement] recipe=floating-islands seed=%d island_radius_vox=%.3f camera_voxel=(%.6f,%.6f,%.6f) status=PASS\n",
                seed,static_cast<double>(chosen->radiusSubvoxels)/UnitsPerVoxel,
                cameraVoxels.X,cameraVoxels.Y,cameraVoxels.Z);
        }
        else
        {
            if(worldAssembly.plan.strates.empty()||worldAssembly.plan.strates.front().route.empty())
            {std::fprintf(stderr,"[SeedSurfacePlacement] FAIL: route-derived spawn is missing\n");return 2;}
            const auto& spawn=worldAssembly.plan.strates.front().route.front();
            cameraVoxels={static_cast<float>(static_cast<double>(spawn.positionSubvoxels[0])/UnitsPerVoxel),
                static_cast<float>(static_cast<double>(spawn.positionSubvoxels[1])/UnitsPerVoxel),
                static_cast<float>(static_cast<double>(spawn.positionSubvoxels[2])/UnitsPerVoxel)};
            std::printf("[SeedSurfacePlacement] recipe=surface-world seed=%d source=route.front position_voxel=(%.6f,%.6f,%.6f) position_m=(%.3f,%.3f,%.3f) status=PASS\n",
                seed,cameraVoxels.X,cameraVoxels.Y,cameraVoxels.Z,
                cameraVoxels.X*ownerWorld->CoreVoxelSizeMicrons/1000000.0f,
                cameraVoxels.Y*ownerWorld->CoreVoxelSizeMicrons/1000000.0f,
                cameraVoxels.Z*ownerWorld->CoreVoxelSizeMicrons/1000000.0f);
        }
    }
    std::printf("[WorldAssemblerPlanTiming] total_ms=%.3f status=PASS\n",
        std::chrono::duration<double,std::milli>(Clock::now()-planStart).count());

    auto snapshot=VoxelForgeCore::MakeStandaloneSnapshotFromParsedJson(ownerJsonRoot,seed,
        options.ClipRadius,options.MaxClipLevel,false,false,error);
    if(!snapshot)
    {std::fprintf(stderr,"Shape interval build failed: %s\n",error.c_str());return 2;}

    FStandaloneCoreScheduler scheduler;
    const FVector cameraStepVoxels=options.HasCameraStep
        ?FVector(options.CameraStepMeters.X*1000000.0f/std::max<std::uint32_t>(1,ownerWorld->CoreVoxelSizeMicrons),
            options.CameraStepMeters.Y*1000000.0f/std::max<std::uint32_t>(1,ownerWorld->CoreVoxelSizeMicrons),
            options.CameraStepMeters.Z*1000000.0f/std::max<std::uint32_t>(1,ownerWorld->CoreVoxelSizeMicrons)):FVector::ZeroVector;
    return StandaloneStreamBenchmark::RunPipelinedStreamingBenchmark(ownerWorld,snapshot,
        cameraVoxels,options.WorkerCount,options.MaxLevel,VoxelForgeCore::DetailVariant::coherent,
        scheduler,options.StreamHash,false,false,false,false,coldStart,
        options.ProfileColumnOverlap,options.FarHorizonLOD8InteriorStepVoxels,
        options.MeshCoverage,options.MeshExportPath,options.CameraYawDegrees,
        options.CameraPitchDegrees,options.ScreenSpaceGate,options.UseSharedColumnCache,
        cameraStepVoxels,options.AuditUniformBlockProofs,options.ProfileLodWork,
        options.RegionCrossing,options.AuditTileShapeReadiness,
        options.DiagnosticSlowShapeCompileMs,options.AuditBasePageEquivalence,
        options.AuditRouteParity,options.AuditResolvedLayoutBoundaries,
        options.AuditResolvedLayoutPassages,options.AuditStrateTransitions,
        &resolvedLayout,options.StreamHashTiles,options.AuditLandmarkReachability);
}