perf(streaming): prove sealed rock solid instead of sampling it -- crossing fix's cost recovered

4c8d06f stopped content-cutting LOD0 so the player can cross strates, at a cost of +29% static
worker CPU: LOD0 tiles in the sealed rock between strates, which the old cut skipped by accident,
were sampled in full and found solid. This proves those tiles solid instead (Codex; reviewed by me).

- UVoxelGenerator::TryProveSealedSolidTile: AllSolid only for a tile whose whole lattice lies in a
  gap/seal region. It rejects player mods (HasAnyModInChunkRange), passages plus carve pads, the
  origin spine/landing, disturbances, recipes and overrides. It is narrower than the old
  ClassifyTile, which stays off in streaming. CollisionSolidTiles / CollisionNotRequiredTiles
  bookkeeping is preserved, so the collision gate's support search still resolves.
- TryProveOutOfLayoutAirTile: a separate fail-closed constant-air proof for the zero-triangle tiles
  outside the strate layout. It never supplies collision support.
- voxel.SealedSolidProof (default 1). Mining a proven tile invalidates and re-meshes it.
- A soundness test that can fail (VoxelForgeSealedSolidProofTest): 22 candidates, 22 skips, 0
  non-solid lattice samples; a deliberately weakened diff guard produces 437 non-solid samples
  and fails.

Verified: mining tile (14,-18,-8) went from proof=1 / 0 triangles to proof=0 / 8 triangles and
re-meshed; strate-crossing test PASS (max gate 0.098 s); off/on trace 899/899 identical; export
b3e5f4c3..9b377; capability 20,830 / 10,909.

Two interleaved rounds, serialized (owner-editor count 0 before each launch):
                        baseline   crossing-fixed   + proof
  static  worker        35.5 s     41.9 s           36.0 s   (+1.4% vs baseline)
  moving  worker        78.1 s     93.2 s           78.2 s   (+0.1%)
  mesher calls static   18.078M    22.280M          18.078M
Applied triangles identical: 669,834 static / 1,331,482 moving.
Runs: one early automation probe exited 3 with no log (the corrected harness passed); one
exploratory moving run was interrupted and excluded.

Note: HasAnyModInChunkRange scans every modified chunk per candidate (cold audit #21). That is cheap
today (~20 candidates), but it grows with mining; it is queued in the correctness round.

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

Source/VoxelForge/Private/Tests/VoxelForgeSealedSolidProofTest.cpp

@@ -0,0 +1,179 @@
+// Sealed-solid proof soundness and invalidation.
+//
+// The production shortcut is intentionally one-sided: it may return false too often, but a true
+// result skips both meshing and level-0 collision generation.  This test therefore brute-forces
+// every tile that the fixture presents to the proof and treats any non-solid lattice sample as a
+// hard failure.  The second half deliberately disables the diff guard; a carve must then make the
+// weakened proof look true while the same oracle finds an air sample.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Misc/AutomationTest.h"
+
+#include "VoxelForgeTestFixture.h"
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FVoxelForgeSealedSolidProofTest,
+    "VoxelForge.Determinism.SealedSolidProofSoundness",
+    EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)
+
+namespace
+{
+    struct FTileSpec
+    {
+        FIntVector Origin = FIntVector::ZeroValue;
+        int32 Step = 1;
+        int32 Cells = CHUNK_SIZE;
+    };
+
+    int32 CountNonSolidSamples(const UVoxelGenerator& Generator, const FTileSpec& Tile)
+    {
+        const int32 Cells = FMath::Clamp(Tile.Cells, 2, CHUNK_SIZE);
+        int32 NonSolid = 0;
+        for (int32 Z = 0; Z <= Cells; ++Z)
+        for (int32 Y = 0; Y <= Cells; ++Y)
+        for (int32 X = 0; X <= Cells; ++X)
+        {
+            const float Density = Generator.GetDensityAt(
+                static_cast<float>(Tile.Origin.X + X * Tile.Step),
+                static_cast<float>(Tile.Origin.Y + Y * Tile.Step),
+                static_cast<float>(Tile.Origin.Z + Z * Tile.Step));
+            if (!VoxelMath::IsFinite(Density) || !(Density < 0.0f))
+            {
+                ++NonSolid;
+            }
+        }
+        return NonSolid;
+    }
+
+    void SetSealThickness(UVoxelStrateDefinition& Definition, float Thickness)
+    {
+        Definition.GenerationParams.BoundarySealThickness = Thickness;
+        Definition.SlabParams.BoundarySealThickness = Thickness;
+        Definition.MazeParams.BoundarySealThickness = Thickness;
+        Definition.SurfaceParams.BoundarySealThickness = Thickness;
+        Definition.VerticalShaftParams.BoundarySealThickness = Thickness;
+        Definition.FloatingIslandParams.BoundarySealThickness = Thickness;
+    }
+}
+
+bool FVoxelForgeSealedSolidProofTest::RunTest(const FString& Parameters)
+{
+    using namespace VoxelForgeTest;
+
+    // Forty voxels makes a complete 32-cell level-0 tile fit inside a bottom boundary seal.  The
+    // production asset remains untouched; this is a transient proof-only fixture configuration.
+    FTestWorld World;
+    World.Build(/*Seed*/1337, /*GapChunks*/2, /*bUseOperatorStack*/false,
+                /*InStrateHeightInChunks*/8);
+    if (!World.IsValid())
+    {
+        AddError(World.WhyInvalid());
+        return false;
+    }
+    for (const TStrongObjectPtr<UVoxelStrateDefinition>& Definition : World.Definitions)
+    {
+        if (Definition.IsValid())
+        {
+            SetSealThickness(*Definition.Get(), 40.0f);
+        }
+    }
+    World.Reinitialize();
+
+    const UVoxelGenerator* Generator = World.Generator.Get();
+    const FIntVector FarXY(4096, 4096, 0);
+    TArray<FTileSpec> CandidateTiles;
+
+    // Enumerate every gap chunk and every strate's bottom-seal tile in this fixture.  No sample
+    // is selected after looking at the proof result: all candidates are offered to it first.
+    for (int32 ChunkZ = World.BottomChunkZ; ChunkZ <= World.TopChunkZ; ++ChunkZ)
+    {
+        if (World.StrateManager->IsGapChunk(FIntVector(0, 0, ChunkZ)))
+        {
+            CandidateTiles.Add({FIntVector(FarXY.X, FarXY.Y, ChunkZ * CHUNK_SIZE), 1, CHUNK_SIZE});
+        }
+    }
+    for (const FStrateSlot& Slot : World.StrateManager->GetLayout())
+    {
+        CandidateTiles.Add({
+            FIntVector(FarXY.X, FarXY.Y, Slot.BottomChunkZ * CHUNK_SIZE),
+            1, CHUNK_SIZE});
+    }
+
+    int32 NumProofSkips = 0;
+    int32 NumNonSolidSamples = 0;
+    int32 FirstProofTile = INDEX_NONE;
+    for (int32 Index = 0; Index < CandidateTiles.Num(); ++Index)
+    {
+        const FTileSpec& Tile = CandidateTiles[Index];
+        if (!Generator->TryProveSealedSolidTile(Tile.Origin, Tile.Step, Tile.Cells))
+        {
+            continue;
+        }
+        ++NumProofSkips;
+        if (FirstProofTile == INDEX_NONE)
+        {
+            FirstProofTile = Index;
+        }
+        const int32 TileNonSolid = CountNonSolidSamples(*Generator, Tile);
+        NumNonSolidSamples += TileNonSolid;
+        if (TileNonSolid != 0)
+        {
+            AddError(FString::Printf(
+                TEXT("FALSE ALL-SOLID PROOF: candidate tile (%d,%d,%d) returned true but has "
+                     "%d non-solid core-lattice samples."),
+                Tile.Origin.X, Tile.Origin.Y, Tile.Origin.Z, TileNonSolid));
+        }
+    }
+
+    AddInfo(FString::Printf(
+        TEXT("Sealed-solid proof brute force: %d candidate tiles, %d proof skips, %d non-solid "
+             "core-lattice samples."),
+        CandidateTiles.Num(), NumProofSkips, NumNonSolidSamples));
+    TestTrue(TEXT("the fixture exercised at least one sealed-solid proof skip"),
+             NumProofSkips > 0);
+    TestEqual(TEXT("every skipped tile has zero non-solid core-lattice samples"),
+              NumNonSolidSamples, 0);
+    if (FirstProofTile == INDEX_NONE)
+    {
+        return false;
+    }
+
+    // A carve in the proven region is the live-edit case that must invalidate the proof.  The
+    // diff layer stores the modification in the tile's chunk, so this is also the exact guard used
+    // by the worker before it decides to skip meshing.
+    const FTileSpec& ProofTile = CandidateTiles[FirstProofTile];
+    const FVector CarveCenter(
+        static_cast<float>(ProofTile.Origin.X + 16),
+        static_cast<float>(ProofTile.Origin.Y + 16),
+        static_cast<float>(ProofTile.Origin.Z + 16));
+    FVoxelModification Carve;
+    Carve.Center = CarveCenter;
+    Carve.Radius = 6.0f;
+    Carve.Strength = -64.0f;
+    Carve.Shape = EVoxelBrushShape::Sphere;
+    TestTrue(TEXT("the adversarial carve was registered"),
+             World.DiffLayer->ApplyModification(Carve).Num() > 0);
+
+    TestFalse(TEXT("a player carve kills the sealed-solid proof"),
+              Generator->TryProveSealedSolidTile(
+                  ProofTile.Origin, ProofTile.Step, ProofTile.Cells));
+
+    const uint8 DiffGuardDisabled = static_cast<uint8>(
+        EVoxelSealedSolidProofGuard::DiffLayer);
+    TestTrue(TEXT("the deliberately weakened proof still exposes the geometric candidate"),
+             Generator->TryProveSealedSolidTileForTest(
+                 ProofTile.Origin, ProofTile.Step, ProofTile.Cells, DiffGuardDisabled));
+
+    const int32 WeakenedNonSolidSamples = CountNonSolidSamples(*Generator, ProofTile);
+    AddInfo(FString::Printf(
+        TEXT("Weakened proof (diff guard disabled): %d non-solid core-lattice samples after the "
+             "carve."),
+        WeakenedNonSolidSamples));
+    TestTrue(TEXT("the brute-force oracle fails the deliberately weakened guard"),
+             WeakenedNonSolidSamples > 0);
+
+    return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

Source/VoxelForge/Private/VoxelGenerator.cpp

@@ -1600,8 +1600,624 @@ static FORCEINLINE bool VF_AnyDisturbanceCanTouchBox(
         || VF_AnyRidgeCanTouchBox(Box, D, Seed);
 }
 
+static FORCEINLINE bool VF_SealedSolidProofGuardDisabled(
+    uint8 DisabledGuards, EVoxelSealedSolidProofGuard Guard)
+{
+    return (DisabledGuards & static_cast<uint8>(Guard)) != 0;
+}
+
+static FORCEINLINE bool VF_IsSafeBoundarySealLatticeZ(
+    float WorldZ, float StrateTopZ, float StrateBottomZ,
+    float SealThickness, float BaseDensity)
+{
+    // ApplyBoundarySeal is a positive internal-density lower bound.  At an exact lattice point,
+    // the original inequalities are sufficient: a strictly positive seal factor times a finite,
+    // positive base density makes the final MC density negative.  Do not widen the band here;
+    // false Mixed costs time, while the brute-force test below is the authority for this shortcut.
+    if (!VoxelMath::IsFinite(WorldZ)
+        || !VoxelMath::IsFinite(StrateTopZ)
+        || !VoxelMath::IsFinite(StrateBottomZ)
+        || !VoxelMath::IsFinite(SealThickness)
+        || !VoxelMath::IsFinite(BaseDensity)
+        || !(StrateTopZ > StrateBottomZ)
+        || !(SealThickness > 0.0f)
+        || !(BaseDensity > 0.0f))
+    {
+        return false;
+    }
+
+    const float DistTop = StrateTopZ - WorldZ;
+    const float DistBottom = WorldZ - StrateBottomZ;
+    return (DistTop >= 0.0f && DistTop < SealThickness)
+        || (DistBottom >= 0.0f && DistBottom < SealThickness);
+}
+
+static bool VF_SealedSolidProofPassageInputsAreValid(const UVoxelStrateManager& Manager)
+{
+    // AnyPassageNearBox is intentionally a cheap bounding-sphere test.  Its normal runtime inputs
+    // are generated data, but a malformed bound must fail closed: NaN distance comparisons would
+    // otherwise turn an unknown passage into a false "no passage" result.
+    for (const FVoxelPassage& Passage : Manager.GetPassages())
+    {
+        if (!VoxelMath::IsFinite(Passage.BoundCenter.X)
+            || !VoxelMath::IsFinite(Passage.BoundCenter.Y)
+            || !VoxelMath::IsFinite(Passage.BoundCenter.Z)
+            || !VoxelMath::IsFinite(Passage.BoundRadius)
+            || Passage.BoundRadius < 0.0f
+            || !VoxelMath::IsFinite(Passage.Radius)
+            || Passage.Radius < 0.0f)
+        {
+            return false;
+        }
+        for (const FVector& Point : Passage.ControlPoints)
+        {
+            if (!VoxelMath::IsFinite(Point.X)
+                || !VoxelMath::IsFinite(Point.Y)
+                || !VoxelMath::IsFinite(Point.Z))
+            {
+                return false;
+            }
+        }
+        for (const float Radius : Passage.ControlRadii)
+        {
+            if (!VoxelMath::IsFinite(Radius) || Radius < 0.0f)
+            {
+                return false;
+            }
+        }
+
+        const FVoxelPassageLanding* Landings[] = {
+            &Passage.UpperLanding, &Passage.LowerLanding };
+        for (const FVoxelPassageLanding* Landing : Landings)
+        {
+            if (!VoxelMath::IsFinite(Landing->StandingPoint.X)
+                || !VoxelMath::IsFinite(Landing->StandingPoint.Y)
+                || !VoxelMath::IsFinite(Landing->StandingPoint.Z)
+                || !VoxelMath::IsFinite(Landing->DoorPoint.X)
+                || !VoxelMath::IsFinite(Landing->DoorPoint.Y)
+                || !VoxelMath::IsFinite(Landing->DoorPoint.Z)
+                || !VoxelMath::IsFinite(Landing->FloorZ)
+                || !VoxelMath::IsFinite(Landing->CeilingZ)
+                || !VoxelMath::IsFinite(Landing->HalfWidth)
+                || !VoxelMath::IsFinite(Landing->FloorThickness)
+                || Landing->HalfWidth < 0.0f
+                || Landing->FloorThickness < 0.0f)
+            {
+                return false;
+            }
+        }
+
+        if (Passage.bWalkableTunnelContract
+            && (Passage.ControlPoints.Num() < 2
+                || Passage.ControlRadii.Num() != Passage.ControlPoints.Num()))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool VF_TryProveSealedSolidTile(
+    const UVoxelGenerator& Generator, const FIntVector& OriginVoxels,
+    int32 Step, int32 CellsPerAxis, uint8 DisabledGuards)
+{
+    const UVoxelStrateManager* Manager = Generator.StrateManager;
+    if (Manager == nullptr)
+    {
+        return false;
+    }
+
+    Step = FMath::Max(1, Step);
+    const int32 CPA = FMath::Clamp(CellsPerAxis, 2, CHUNK_SIZE);
+
+    // Keep the integer arithmetic that defines the MC lattice identical to ClassifyTile, but
+    // reject a caller whose endpoint would overflow before any floor division or FBox creation.
+    const int64 MaxX64 = static_cast<int64>(OriginVoxels.X)
+        + static_cast<int64>(CPA) * static_cast<int64>(Step);
+    const int64 MaxY64 = static_cast<int64>(OriginVoxels.Y)
+        + static_cast<int64>(CPA) * static_cast<int64>(Step);
+    const int64 MaxZ64 = static_cast<int64>(OriginVoxels.Z)
+        + static_cast<int64>(CPA) * static_cast<int64>(Step);
+    if (MaxX64 < MIN_int32 || MaxX64 > MAX_int32
+        || MaxY64 < MIN_int32 || MaxY64 > MAX_int32
+        || MaxZ64 < MIN_int32 || MaxZ64 > MAX_int32)
+    {
+        return false;
+    }
+
+    const int32 MinX = OriginVoxels.X;
+    const int32 MinY = OriginVoxels.Y;
+    const int32 MinZ = OriginVoxels.Z;
+    const int32 MaxX = static_cast<int32>(MaxX64);
+    const int32 MaxY = static_cast<int32>(MaxY64);
+    const int32 MaxZ = static_cast<int32>(MaxZ64);
+    const FBox TileVoxelBox(
+        FVector(static_cast<float>(MinX), static_cast<float>(MinY), static_cast<float>(MinZ)),
+        FVector(static_cast<float>(MaxX), static_cast<float>(MaxY), static_cast<float>(MaxZ)));
+
+    auto FloorDivC = [](int32 A, int32 B) -> int32
+    {
+        const int32 Q = A / B;
+        const int32 R = A % B;
+        return (R != 0 && ((R < 0) != (B < 0))) ? Q - 1 : Q;
+    };
+
+    // First pass is deliberately Z-only.  Most streaming tiles are neither gap nor seal, so they
+    // leave in this cheap loop without taking a diff lock, scanning passages, or copying params.
+    enum : uint8 { GapRow = 1u, SealRow = 2u };
+    int32 SampleChunkZ[CHUNK_SIZE + 1];
+    uint8 SampleKind[CHUNK_SIZE + 1];
+    bool bSawSeal = false;
+    bool bSawSolidRegion = false;
+    for (int32 G = 0; G <= CPA; ++G)
+    {
+        const int64 Z64 = static_cast<int64>(OriginVoxels.Z)
+            + static_cast<int64>(G) * static_cast<int64>(Step);
+        const int32 Z = static_cast<int32>(Z64);
+        const int32 ChunkZ = FloorDivC(Z, CHUNK_SIZE);
+        SampleChunkZ[G] = ChunkZ;
+        if (Manager->IsGapChunk(FIntVector(0, 0, ChunkZ)))
+        {
+            SampleKind[G] = GapRow;
+            bSawSolidRegion = true;
+            continue;
+        }
+
+        int32 UnusedTopChunkZ = 0;
+        int32 UnusedBottomChunkZ = 0;
+        if (!Manager->GetStrateChunkZBounds(
+                ChunkZ, UnusedTopChunkZ, UnusedBottomChunkZ))
+        {
+            // Above/below the stack is open air, not a solid gap.  A tile that touches it is not
+            // a sealed-solid candidate even if another row happens to be bedrock.
+            return false;
+        }
+        SampleKind[G] = SealRow;
+        bSawSeal = true;
+        bSawSolidRegion = true;
+    }
+    if (!bSawSolidRegion)
+    {
+        return false;
+    }
+    if (bSawSeal && VoxelDensityAblation::IsBoundarySealOff())
+    {
+        return false;
+    }
+
+    // Player edits are the final writer and can carve a tile that was structurally solid.  This
+    // is intentionally checked only after the Z pre-pass: ordinary mixed tiles avoid the lock.
+    const int32 MinChunkX = FloorDivC(MinX, CHUNK_SIZE);
+    const int32 MaxChunkX = FloorDivC(MaxX, CHUNK_SIZE);
+    const int32 MinChunkY = FloorDivC(MinY, CHUNK_SIZE);
+    const int32 MaxChunkY = FloorDivC(MaxY, CHUNK_SIZE);
+    const int32 MinChunkZ = FloorDivC(MinZ, CHUNK_SIZE);
+    const int32 MaxChunkZ = FloorDivC(MaxZ, CHUNK_SIZE);
+    if (!VF_SealedSolidProofGuardDisabled(
+            DisabledGuards, EVoxelSealedSolidProofGuard::DiffLayer)
+        && Generator.DiffLayer != nullptr
+        && Generator.DiffLayer->HasAnyMods())
+    {
+        if (Generator.DiffLayer->HasAnyModInChunkRange(
+                FIntVector(MinChunkX, MinChunkY, MinChunkZ),
+                FIntVector(MaxChunkX, MaxChunkY, MaxChunkZ)))
+        {
+            return false;
+        }
+    }
+
+    // PassageCarving's public box guard includes the 4-voxel carve blend pad on top of each
+    // generated passage bound.  Landing and structural-post air are also handled conservatively:
+    // if carving is ablated but another passage air writer remains active, reject any passage data
+    // rather than trusting an API whose historical early-out is specific to carving.
+    if (!VF_SealedSolidProofGuardDisabled(
+            DisabledGuards, EVoxelSealedSolidProofGuard::Passages))
+    {
+        const bool bPassageAirWriterActive =
+            !VoxelDensityAblation::IsPassageCarvingOff()
+            || !VoxelDensityAblation::IsLandingPostsOff()
+            || !VoxelDensityAblation::IsPassageStructuralPostsOff();
+        if (bPassageAirWriterActive)
+        {
+            if (!VF_SealedSolidProofPassageInputsAreValid(*Manager))
+            {
+                return false;
+            }
+            if (!VoxelDensityAblation::IsPassageCarvingOff())
+            {
+                if (Manager->AnyPassageNearBox(
+                        TileVoxelBox.Min, TileVoxelBox.Max))
+                {
+                    return false;
+                }
+            }
+            else if (Manager->GetPassages().Num() > 0)
+            {
+                // AnyPassageNearBox deliberately returns false when the carve stage is off.  The
+                // remaining landing/tunnel posts have no equivalent box API, so this is the
+                // capability-first answer under that development ablation.
+                return false;
+            }
+        }
+    }
+
+    // The origin landing is the (0,0) spine's current room-shaped air writer.  Its box guard is
+    // broader than the exact lattice guard used by ClassifyTile; false Mixed is cheap here.
+    if (!VF_SealedSolidProofGuardDisabled(
+            DisabledGuards, EVoxelSealedSolidProofGuard::OriginLanding)
+        && (!VoxelDensityAblation::IsOriginSpineOff()
+            || !VoxelDensityAblation::IsLandingPostsOff())
+        && Manager->AnyOriginLandingNearBox(TileVoxelBox.Min, TileVoxelBox.Max))
+    {
+        return false;
+    }
+
+    const int64 XYChunkCount =
+        (static_cast<int64>(MaxChunkX) - static_cast<int64>(MinChunkX) + 1)
+        * (static_cast<int64>(MaxChunkY) - static_cast<int64>(MinChunkY) + 1);
+    const int64 ZChunkCount = static_cast<int64>(MaxChunkZ) - static_cast<int64>(MinChunkZ) + 1;
+    // This is a per-tile proof, not a second coarse mesher.  A normal LOD0/LOD1 tile touches at
+    // most a handful of chunks.  Refuse pathological caller boxes before a nested loop can turn
+    // the cheap path into a large param walk.
+    constexpr int64 MaxProofChunkCoordinates = 65536;
+    if (XYChunkCount <= 0 || ZChunkCount <= 0
+        || XYChunkCount > MaxProofChunkCoordinates
+        || XYChunkCount * ZChunkCount > MaxProofChunkCoordinates)
+    {
+        return false;
+    }
+
+    auto ResolveSealFields = [&](const FIntVector& ChunkCoord,
+                                 float& OutTop, float& OutBottom,
+                                 float& OutThickness, float& OutBase) -> bool
+    {
+        switch (Manager->GetGeneratorTypeForChunk(ChunkCoord))
+        {
+        case ECaveGeneratorType::FlatPlain:
+        case ECaveGeneratorType::CrystalChamber:
+        {
+            const FSlabGenerationParams P = Manager->GetSlabParamsForChunk(ChunkCoord);
+            OutTop = P.StrateTopWorldZ;
+            OutBottom = P.StrateBottomWorldZ;
+            OutThickness = P.BoundarySealThickness;
+            OutBase = P.BaseDensity;
+            return true;
+        }
+        case ECaveGeneratorType::Maze:
+        {
+            const FMazeGenerationParams P = Manager->GetMazeParamsForChunk(ChunkCoord);
+            OutTop = P.StrateTopWorldZ;
+            OutBottom = P.StrateBottomWorldZ;
+            OutThickness = P.BoundarySealThickness;
+            OutBase = P.BaseDensity;
+            return true;
+        }
+        case ECaveGeneratorType::SurfaceWorld:
+        {
+            const FSurfaceGenerationParams P = Manager->GetSurfaceParamsForChunk(ChunkCoord);
+            OutTop = P.StrateTopWorldZ;
+            OutBottom = P.StrateBottomWorldZ;
+            OutThickness = P.BoundarySealThickness;
+            OutBase = P.BaseDensity;
+            return true;
+        }
+        case ECaveGeneratorType::VerticalShafts:
+        {
+            const FVerticalShaftParams P = Manager->GetVerticalShaftParamsForChunk(ChunkCoord);
+            OutTop = P.StrateTopWorldZ;
+            OutBottom = P.StrateBottomWorldZ;
+            OutThickness = P.BoundarySealThickness;
+            OutBase = P.BaseDensity;
+            return true;
+        }
+        case ECaveGeneratorType::FloatingIslands:
+        {
+            const FFloatingIslandParams P = Manager->GetFloatingIslandParamsForChunk(ChunkCoord);
+            OutTop = P.StrateTopWorldZ;
+            OutBottom = P.StrateBottomWorldZ;
+            OutThickness = P.BoundarySealThickness;
+            OutBase = P.BaseDensity;
+            return true;
+        }
+        case ECaveGeneratorType::TunnelNetwork:
+        case ECaveGeneratorType::Underwater:
+        {
+            const FStrateGenerationParams P = Manager->GetGenerationParams(ChunkCoord);
+            OutTop = P.StrateTopWorldZ;
+            OutBottom = P.StrateBottomWorldZ;
+            OutThickness = P.BoundarySealThickness;
+            OutBase = P.BaseDensity;
+            return true;
+        }
+        default:
+            return false;
+        }
+    };
+
+    for (int32 ChunkZ = MinChunkZ; ChunkZ <= MaxChunkZ; ++ChunkZ)
+    {
+        bool bThisChunkHasSealRow = false;
+        for (int32 G = 0; G <= CPA; ++G)
+        {
+            if (SampleKind[G] == SealRow && SampleChunkZ[G] == ChunkZ)
+            {
+                bThisChunkHasSealRow = true;
+                break;
+            }
+        }
+        if (!bThisChunkHasSealRow)
+        {
+            continue;
+        }
+
+        for (int32 ChunkY = MinChunkY; ChunkY <= MaxChunkY; ++ChunkY)
+        for (int32 ChunkX = MinChunkX; ChunkX <= MaxChunkX; ++ChunkX)
+        {
+            const FIntVector ChunkCoord(ChunkX, ChunkY, ChunkZ);
+
+#if WITH_EDITOR
+            // A plain composer override changes the archetype/params, while a region override
+            // changes the lateral field.  Both must remain on the ordinary mesher/classifier path.
+            int32 ComposerSeed = 0;
+            ECaveGeneratorType ComposerArchetype = ECaveGeneratorType::TunnelNetwork;
+            FVoxelStrateArchetypeParams ComposerParams;
+            bool bComposerRecipe = false;
+            FVoxelOpStackRecipe ComposerRecipe;
+            if (Manager->GetComposerOverrideForChunk(
+                    ChunkCoord, ComposerSeed, ComposerArchetype, ComposerParams,
+                    bComposerRecipe, ComposerRecipe))
+            {
+                return false;
+            }
+            FVoxelStrateRegionManifest ComposerRegions;
+            if (Manager->GetComposerRegionOverrideForChunk(ChunkCoord, ComposerRegions))
+            {
+                return false;
+            }
+#endif
+
+            // Cooked seasons can materialise a custom recipe for a chunk.  The cheap proof only
+            // knows the native structural seal contract, so selected recipes fail closed.
+            int32 RecipeSeed = 0;
+            ECaveGeneratorType RecipeArchetype = ECaveGeneratorType::TunnelNetwork;
+            FVoxelStrateArchetypeParams RecipeParams;
+            FVoxelOpStackRecipe Recipe;
+            if (Manager->GetRecipeForChunk(
+                    ChunkCoord, RecipeSeed, RecipeArchetype, RecipeParams, Recipe))
+            {
+                return false;
+            }
+
+            float Top = 0.0f;
+            float Bottom = 0.0f;
+            float Thickness = 0.0f;
+            float BaseDensity = 0.0f;
+            if (!ResolveSealFields(ChunkCoord, Top, Bottom, Thickness, BaseDensity))
+            {
+                return false;
+            }
+
+            if (!VF_SealedSolidProofGuardDisabled(
+                    DisabledGuards, EVoxelSealedSolidProofGuard::DisturbanceChasms)
+                && !VoxelDensityAblation::IsDisturbancesOff())
+            {
+                const FStrateDisturbanceParams D =
+                    Manager->GetDisturbanceParamsForChunk(ChunkCoord);
+                if (VF_AnyChasmCanTouchBox(TileVoxelBox, D, static_cast<uint32>(Generator.Seed)))
+                {
+                    return false;
+                }
+            }
+
+            for (int32 G = 0; G <= CPA; ++G)
+            {
+                if (SampleKind[G] != SealRow || SampleChunkZ[G] != ChunkZ)
+                {
+                    continue;
+                }
+                const float Z = static_cast<float>(
+                    static_cast<int64>(OriginVoxels.Z)
+                    + static_cast<int64>(G) * static_cast<int64>(Step));
+                if (!VF_IsSafeBoundarySealLatticeZ(
+                        Z, Top, Bottom, Thickness, BaseDensity))
+                {
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool VF_TryProveOutOfLayoutAirTile(
+    const UVoxelGenerator& Generator, const FIntVector& OriginVoxels,
+    int32 Step, int32 CellsPerAxis)
+{
+    const UVoxelStrateManager* Manager = Generator.StrateManager;
+    if (Manager == nullptr)
+    {
+        return false;
+    }
+
+    Step = FMath::Max(1, Step);
+    const int32 CPA = FMath::Clamp(CellsPerAxis, 2, CHUNK_SIZE);
+
+    const int64 MaxX64 = static_cast<int64>(OriginVoxels.X)
+        + static_cast<int64>(CPA) * static_cast<int64>(Step);
+    const int64 MaxY64 = static_cast<int64>(OriginVoxels.Y)
+        + static_cast<int64>(CPA) * static_cast<int64>(Step);
+    const int64 MaxZ64 = static_cast<int64>(OriginVoxels.Z)
+        + static_cast<int64>(CPA) * static_cast<int64>(Step);
+    if (MaxX64 < MIN_int32 || MaxX64 > MAX_int32
+        || MaxY64 < MIN_int32 || MaxY64 > MAX_int32
+        || MaxZ64 < MIN_int32 || MaxZ64 > MAX_int32)
+    {
+        return false;
+    }
+
+    const int32 MinX = OriginVoxels.X;
+    const int32 MinY = OriginVoxels.Y;
+    const int32 MinZ = OriginVoxels.Z;
+    const int32 MaxX = static_cast<int32>(MaxX64);
+    const int32 MaxY = static_cast<int32>(MaxY64);
+    const int32 MaxZ = static_cast<int32>(MaxZ64);
+    const FBox TileVoxelBox(
+        FVector(static_cast<float>(MinX), static_cast<float>(MinY), static_cast<float>(MinZ)),
+        FVector(static_cast<float>(MaxX), static_cast<float>(MaxY), static_cast<float>(MaxZ)));
+
+    auto FloorDivC = [](int32 A, int32 B) -> int32
+    {
+        const int32 Q = A / B;
+        const int32 R = A % B;
+        return (R != 0 && ((R < 0) != (B < 0))) ? Q - 1 : Q;
+    };
+
+    // All core lattice rows must be outside the layout. A gap or a real strate row means that
+    // this is no longer the constant-air case, even when another row is open air.
+    for (int32 G = 0; G <= CPA; ++G)
+    {
+        const int64 Z64 = static_cast<int64>(OriginVoxels.Z)
+            + static_cast<int64>(G) * static_cast<int64>(Step);
+        const int32 ChunkZ = FloorDivC(static_cast<int32>(Z64), CHUNK_SIZE);
+        if (Manager->IsGapChunk(FIntVector(0, 0, ChunkZ)))
+        {
+            return false;
+        }
+        int32 UnusedTopChunkZ = 0;
+        int32 UnusedBottomChunkZ = 0;
+        if (Manager->GetStrateChunkZBounds(
+                ChunkZ, UnusedTopChunkZ, UnusedBottomChunkZ))
+        {
+            return false;
+        }
+    }
+
+    const int32 MinChunkX = FloorDivC(MinX, CHUNK_SIZE);
+    const int32 MaxChunkX = FloorDivC(MaxX, CHUNK_SIZE);
+    const int32 MinChunkY = FloorDivC(MinY, CHUNK_SIZE);
+    const int32 MaxChunkY = FloorDivC(MaxY, CHUNK_SIZE);
+    const int32 MinChunkZ = FloorDivC(MinZ, CHUNK_SIZE);
+    const int32 MaxChunkZ = FloorDivC(MaxZ, CHUNK_SIZE);
+    if (Generator.DiffLayer != nullptr
+        && Generator.DiffLayer->HasAnyMods()
+        && Generator.DiffLayer->HasAnyModInChunkRange(
+            FIntVector(MinChunkX, MinChunkY, MinChunkZ),
+            FIntVector(MaxChunkX, MaxChunkY, MaxChunkZ)))
+    {
+        return false;
+    }
+
+    // The final XY pass can add rock to open air. Radius == 0 (and other non-positive inputs) is
+    // the documented no-op, so only validate and inspect the band when that writer is live.
+    if (!VoxelDensityAblation::IsXYEdgeSealOff()
+        && Generator.WorldRadiusVoxels > 0.0f
+        && Generator.EdgeSealThickness > 0.0f)
+    {
+        if (!VF_IsValidXYEdgeSealProofInput(
+                TileVoxelBox, Generator.WorldRadiusVoxels,
+                Generator.EdgeSealThickness, 1.0f))
+        {
+            return false;
+        }
+
+        // Use double arithmetic here: the production helper is float-based, while this proof
+        // must not turn a large finite coordinate into an overflowed squared-distance false
+        // negative. Equality is safe because the production inner test is <= as well.
+        const double FarthestX = FMath::Max(
+            FMath::Abs(static_cast<double>(TileVoxelBox.Min.X)),
+            FMath::Abs(static_cast<double>(TileVoxelBox.Max.X)));
+        const double FarthestY = FMath::Max(
+            FMath::Abs(static_cast<double>(TileVoxelBox.Min.Y)),
+            FMath::Abs(static_cast<double>(TileVoxelBox.Max.Y)));
+        const double InnerRadius = static_cast<double>(Generator.WorldRadiusVoxels)
+            - static_cast<double>(Generator.EdgeSealThickness);
+        if (!(InnerRadius > 0.0)
+            || FarthestX * FarthestX + FarthestY * FarthestY
+                > InnerRadius * InnerRadius)
+        {
+            return false;
+        }
+    }
+
+    if (Manager->GetPassages().Num() > 0)
+    {
+        if (!VF_SealedSolidProofPassageInputsAreValid(*Manager))
+        {
+            return false;
+        }
+
+        // Passage carving is air-monotone and therefore cannot invalidate an AllAir proof. Only
+        // the solid floor/support writers need a guard here. Use the same exact lattice floor
+        // predicate as ClassifyTile: its padded AABBs stay cheap, but do not reject an open-air
+        // tile merely because a harmless carve bound passes near it.
+        const bool bPassageFloorWriterActive =
+            !VoxelDensityAblation::IsPassageStructuralPostsOff()
+            || !VoxelDensityAblation::IsNativeFloorOff()
+            || !VoxelDensityAblation::IsLandingPostsOff();
+        if (bPassageFloorWriterActive
+            && Manager->AnyPassageLandingFloorNearLattice(
+                TileVoxelBox, OriginVoxels, Step))
+        {
+            return false;
+        }
+    }
+
+    // Origin rooms only carve open air, but their landing floors reassert solid. The manager's
+    // floor box includes every per-strate room; this is intentionally broader than the exact
+    // lattice query used by ClassifyTile because a false Mixed is cheaper than a dropped floor.
+    if (!VoxelDensityAblation::IsOriginSpineOff()
+        || !VoxelDensityAblation::IsLandingPostsOff())
+    {
+        if (!VoxelMath::IsFinite(Generator.OriginSpineRadius)
+            || Generator.OriginSpineRadius <= 0.0f)
+        {
+            return false;
+        }
+        if (Manager->AnyOriginLandingFloorNearLattice(
+                TileVoxelBox, OriginVoxels, Step))
+        {
+            return false;
+        }
+    }
+
+    if (!VoxelDensityAblation::IsDisturbancesOff())
+    {
+        const int64 XYChunkCount =
+            (static_cast<int64>(MaxChunkX) - static_cast<int64>(MinChunkX) + 1)
+            * (static_cast<int64>(MaxChunkY) - static_cast<int64>(MinChunkY) + 1);
+        const int64 ZChunkCount =
+            static_cast<int64>(MaxChunkZ) - static_cast<int64>(MinChunkZ) + 1;
+        constexpr int64 MaxProofChunkCoordinates = 65536;
+        if (XYChunkCount <= 0 || ZChunkCount <= 0
+            || XYChunkCount > MaxProofChunkCoordinates
+            || XYChunkCount * ZChunkCount > MaxProofChunkCoordinates)
+        {
+            return false;
+        }
+
+        // Out-of-layout chunks normally return disabled disturbance params. Still ask the exact
+        // bridge/ridge predicates for every touched chunk so a future out-of-layout decoration
+        // cannot silently turn this air proof into an invisible solid patch.
+        for (int32 ChunkZ = MinChunkZ; ChunkZ <= MaxChunkZ; ++ChunkZ)
+        for (int32 ChunkY = MinChunkY; ChunkY <= MaxChunkY; ++ChunkY)
+        for (int32 ChunkX = MinChunkX; ChunkX <= MaxChunkX; ++ChunkX)
+        {
+            const FStrateDisturbanceParams D =
+                Manager->GetDisturbanceParamsForChunk(FIntVector(ChunkX, ChunkY, ChunkZ));
+            if (VF_AnyBridgeCanTouchBox(TileVoxelBox, D, static_cast<uint32>(Generator.Seed))
+                || VF_AnyRidgeCanTouchBox(TileVoxelBox, D, static_cast<uint32>(Generator.Seed)))
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 //=============================================================================
-// LE MAPPING « ARCHÉTYPE → PILE D'OPÉRATEURS » — UNE SEULE DÉFINITION
+// LE MAPPING « ARCHÉTYPE → PILE D’OPÉRATEURS » — UNE SEULE DÉFINITION
 //=============================================================================
 // ⚠️ EXTRAIT DE `GetDensityAt` PARCE QUE `ClassifyTile` EN A BESOIN AUSSI, ET QU'UNE DEUXIÈME COPIE
 // SERAIT LA PIRE FORME DE BUG DISPONIBLE ICI.
@@ -5713,6 +6329,29 @@ EVoxelTileClass UVoxelGenerator::ClassifyTile(const FIntVector& OriginVoxels,
     return ClassifyTile(OriginVoxels, Step, CellsPerAxis, nullptr);
 }
 
+bool UVoxelGenerator::TryProveSealedSolidTile(
+    const FIntVector& OriginVoxels, int32 Step, int32 CellsPerAxis) const
+{
+    return VF_TryProveSealedSolidTile(
+        *this, OriginVoxels, Step, CellsPerAxis, /*DisabledGuards=*/0);
+}
+
+bool UVoxelGenerator::TryProveOutOfLayoutAirTile(
+    const FIntVector& OriginVoxels, int32 Step, int32 CellsPerAxis) const
+{
+    return VF_TryProveOutOfLayoutAirTile(*this, OriginVoxels, Step, CellsPerAxis);
+}
+
+#if WITH_DEV_AUTOMATION_TESTS
+bool UVoxelGenerator::TryProveSealedSolidTileForTest(
+    const FIntVector& OriginVoxels, int32 Step, int32 CellsPerAxis,
+    uint8 DisabledGuards) const
+{
+    return VF_TryProveSealedSolidTile(
+        *this, OriginVoxels, Step, CellsPerAxis, DisabledGuards);
+}
+#endif
+
 EVoxelTileClass UVoxelGenerator::ClassifyTile(const FIntVector& OriginVoxels, int32 Step,
                                               int32 CellsPerAxis,
                                               FVoxelTileClassificationStats* OutStats) const

Source/VoxelForge/Private/VoxelStartupTrace.cpp

@@ -260,11 +260,12 @@ void RecordTile(const FTileSample& Sample)
     GState->Samples.Add(Sample);
     ++GState->TileRecordsWritten;
     WriteEventLocked(*GState, TEXT("tile"), FString::Printf(
-        TEXT("\"tile\":[%d,%d,%d],\"level\":%d,\"verdict\":%d,\"empty\":%d,\"triangles\":%d,"
+        TEXT("\"tile\":[%d,%d,%d],\"level\":%d,\"verdict\":%d,\"proof\":%d,\"empty\":%d,\"triangles\":%d,"
              "\"request_to_apply_s\":%s,\"queue_wait_s\":%s,\"worker_queue_s\":%s,\"result_queue_s\":%s,"
              "\"generation_s\":%s,\"classify_s\":%s,\"mesh_s\":%s,\"stream_s\":%s,\"apply_s\":%s"),
         Sample.TileX, Sample.TileY, Sample.TileZ,
-        Sample.Level, Sample.Verdict, Sample.bEmpty ? 1 : 0, Sample.Triangles,
+        Sample.Level, Sample.Verdict, Sample.bSealedSolidProof ? 1 : 0,
+        Sample.bEmpty ? 1 : 0, Sample.Triangles,
         *Number(Sample.RequestToApplySeconds), *Number(Sample.QueueWaitSeconds),
         *Number(Sample.WorkerQueueSeconds), *Number(Sample.ResultQueueSeconds),
         *Number(Sample.GenerationSeconds), *Number(Sample.ClassifySeconds),

Source/VoxelForge/Private/VoxelWorld.cpp

@@ -97,6 +97,15 @@ namespace
         GVoxelForgeOuterClassifierMode,
         TEXT("Outer tile classifier mode: 0 off, 1 discarded exact validation."));
 
+    // Cheap structural proofs for LOD tiles whose exact core lattice lies entirely in a gap/seal
+    // (AllSolid) or constant out-of-layout air (AllAir).  They are independent of the discarded
+    // full classifier and default on; 0 is retained for per-tile identity/A-B traces.
+    int32 GVoxelForgeSealedSolidProof = 1;
+    FAutoConsoleVariableRef CVarVoxelForgeSealedSolidProof(
+        TEXT("voxel.SealedSolidProof"),
+        GVoxelForgeSealedSolidProof,
+        TEXT("Skip meshing only when an exact gap/seal or constant-air proof holds: 0 off, 1 on."));
+
     // Startup command-line cvars can arrive before the game world has spawned AVoxelWorld (or
     // before its first tiles have become visible). Keep the diagnostic edit pending until Tick has
     // a loaded tile; otherwise a startup measurement silently becomes a no-op or edits the wrong
@@ -104,6 +113,7 @@ namespace
     int32 GVoxelForgePendingTestModification = 0;
     float GVoxelForgePendingModificationRadius = 3.0f;
     float GVoxelForgePendingModificationStrength = 10.0f;
+    bool GVoxelForgeTestModificationLoadedProofTarget = false;
     bool GVoxelForgeTestModificationCommandLineConsumed = false;
     bool GVoxelForgeStreamingBudgetReported = false;
     bool GVoxelForgeGenerationCapHitReported = false;
@@ -1105,6 +1115,9 @@ void AVoxelWorld::BeginPlay()
     TotalObsoleteWorkerTasks.store(0, std::memory_order_relaxed);
     TotalValidationDensityCalls.store(0, std::memory_order_relaxed);
     TotalMesherDensityCalls.store(0, std::memory_order_relaxed);
+    TotalSealedSolidProofCandidates.store(0, std::memory_order_relaxed);
+    TotalSealedSolidProofSkips.store(0, std::memory_order_relaxed);
+    TotalOutOfLayoutAirProofSkips.store(0, std::memory_order_relaxed);
     AppliedTileCount = 0;
     AppliedVisibleTileCount = 0;
     AppliedTriangleCount = 0;
@@ -1133,6 +1146,7 @@ void AVoxelWorld::BeginPlay()
     int32 CommandLineProfileTileGeneration = GVoxelForgeProfileTileGeneration;
     int32 CommandLineUseBlockEarlyOut = GVoxelForgeUseBlockEarlyOut;
     int32 CommandLineOuterClassifierMode = GVoxelForgeOuterClassifierMode;
+    int32 CommandLineSealedSolidProof = GVoxelForgeSealedSolidProof;
     int32 CommandLineSampleStacks = GVoxelForgeSampleStacks;
     if (FParse::Value(FCommandLine::Get(), TEXT("voxel.ProfileDensity="), CommandLineProfile))
     {
@@ -1161,6 +1175,10 @@ void AVoxelWorld::BeginPlay()
     {
         GVoxelForgeOuterClassifierMode = CommandLineOuterClassifierMode;
     }
+    if (FParse::Value(FCommandLine::Get(), TEXT("voxel.SealedSolidProof="), CommandLineSealedSolidProof))
+    {
+        GVoxelForgeSealedSolidProof = CommandLineSealedSolidProof;
+    }
     if (FParse::Value(FCommandLine::Get(), TEXT("voxel.SampleStacks="), CommandLineSampleStacks))
     {
         GVoxelForgeSampleStacks = CommandLineSampleStacks;
@@ -1168,6 +1186,7 @@ void AVoxelWorld::BeginPlay()
     GVoxelForgeProfileTileGeneration = GVoxelForgeProfileTileGeneration != 0 ? 1 : 0;
     GVoxelForgeUseBlockEarlyOut = GVoxelForgeUseBlockEarlyOut != 0 ? 1 : 0;
     GVoxelForgeOuterClassifierMode = FMath::Clamp(GVoxelForgeOuterClassifierMode, 0, 1);
+    GVoxelForgeSealedSolidProof = GVoxelForgeSealedSolidProof != 0 ? 1 : 0;
     GVoxelForgeSampleStacks = FMath::Clamp(
         GVoxelForgeSampleStacks,
         0,
@@ -1281,8 +1300,9 @@ void AVoxelWorld::BeginPlay()
     Mesher->bUseBlockEarlyOut = GVoxelForgeUseBlockEarlyOut != 0;
 
     UE_LOG(LogTemp, Display,
-        TEXT("[VoxelForgeClassifierConfig] outer_mode=%d nested_block_early_out=%d"),
+        TEXT("[VoxelForgeClassifierConfig] outer_mode=%d sealed_solid_proof=%d nested_block_early_out=%d"),
-        GVoxelForgeOuterClassifierMode, Mesher->bUseBlockEarlyOut ? 1 : 0);
+        GVoxelForgeOuterClassifierMode, GVoxelForgeSealedSolidProof,
+        Mesher->bUseBlockEarlyOut ? 1 : 0);
 
     VoxelForgeStartupTrace::RecordEvent(TEXT("generator_mesher_constructed"), FString::Printf(
         TEXT("\"generator\":1,\"mesher\":1,\"generate_skirts\":%d,\"full_res_clip_levels\":%d,\"coarse_tile_cells\":%d"),
@@ -1377,6 +1397,9 @@ void AVoxelWorld::ConfigureHeadlessStreamingTest()
 {
     bHeadlessStreamingTestMovement = false;
     bHeadlessStreamingTestExitRequested = false;
+    bStartupTraceThroughCrossing = false;
+    bHeadlessStreamingTestCenterOverride = false;
+    HeadlessStreamingTestCenterVoxel = FVector::ZeroVector;
     HeadlessStreamingTestMoveAttempts = 0;
     HeadlessStreamingTestDistanceCm = 0.0;
     HeadlessStreamingTestSpeedCmPerSecond = 0.0f;
@@ -1472,6 +1495,33 @@ void AVoxelWorld::ConfigureHeadlessStreamingTest()
             HeadlessStrateCrossingTestRequestedPassageIndex);
     }
 
+    int32 TraceThroughCrossingValue = 0;
+    if (FParse::Value(
+            CommandLine,
+            TEXT("voxel.StartupTraceThroughCrossing="),
+            TraceThroughCrossingValue))
+    {
+        bStartupTraceThroughCrossing = TraceThroughCrossingValue != 0;
+    }
+
+    float CenterX = 0.0f;
+    float CenterY = 0.0f;
+    float CenterZ = 0.0f;
+    const bool bCenterX = FParse::Value(CommandLine, TEXT("voxel.StreamingTestCenterX="), CenterX);
+    const bool bCenterY = FParse::Value(CommandLine, TEXT("voxel.StreamingTestCenterY="), CenterY);
+    const bool bCenterZ = FParse::Value(CommandLine, TEXT("voxel.StreamingTestCenterZ="), CenterZ);
+    if (bCenterX && bCenterY && bCenterZ
+        && VoxelMath::IsFinite(CenterX)
+        && VoxelMath::IsFinite(CenterY)
+        && VoxelMath::IsFinite(CenterZ))
+    {
+        bHeadlessStreamingTestCenterOverride = true;
+        HeadlessStreamingTestCenterVoxel = FVector(CenterX, CenterY, CenterZ);
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeStreamingTest] center_override=1 local_vox=(%.2f,%.2f,%.2f)"),
+            CenterX, CenterY, CenterZ);
+    }
+
     if (bMoveRequested && !bHeadlessStrateCrossingTest)
     {
         FString DirectionText;
@@ -2000,6 +2050,11 @@ void AVoxelWorld::MaybeFinishHeadlessStrateCrossingTest()
         HeadlessStrateCrossingTestLastActualPosition.X,
         HeadlessStrateCrossingTestLastActualPosition.Y,
         HeadlessStrateCrossingTestLastActualPosition.Z);
+    if (bStartupTraceThroughCrossing && VoxelForgeStartupTrace::IsActive())
+    {
+        VoxelForgeStartupTrace::Finish(
+            bPassed ? TEXT("strate_crossing_passed") : TEXT("strate_crossing_failed"));
+    }
     FPlatformMisc::RequestExitWithStatus(
         false, bPassed ? 0 : 1, TEXT("VoxelForge strate crossing test complete"));
 }
@@ -2110,7 +2165,10 @@ void AVoxelWorld::Tick(float DeltaTime)
             PeakObservedPawnSpeedCmPerSecond, PlayerHeading.Size2D());
         UpdatePawnCollisionGate(PlayerPawn, PlayerLastPos, DeltaTime);
         ObserveHeadlessStrateCrossingTest(PlayerLastPos, PlayerPawn);
-        UpdateChunksAroundPosition(PlayerLastPos, PlayerPawn, PlayerHeading);
+        const FVector StreamingCenterPosition = bHeadlessStreamingTestCenterOverride
+            ? LocalVoxelToWorld(HeadlessStreamingTestCenterVoxel)
+            : PlayerLastPos;
+        UpdateChunksAroundPosition(StreamingCenterPosition, PlayerPawn, PlayerHeading);
         if (AtmosphereManager)
         {
             AtmosphereManager->UpdateForPlayer(PlayerLastPos);
@@ -2165,10 +2223,20 @@ void AVoxelWorld::Tick(float DeltaTime)
         {
             GVoxelForgePendingModificationRadius = 3.0f;
             GVoxelForgePendingModificationStrength = 10.0f;
+            FString ModificationTarget;
+            if (FParse::Value(
+                    *CommandLine,
+                    TEXT("voxel.TestModificationTarget="),
+                    ModificationTarget)
+                && ModificationTarget.Equals(TEXT("loaded-proof"), ESearchCase::IgnoreCase))
+            {
+                GVoxelForgeTestModificationLoadedProofTarget = true;
+            }
             UE_LOG(LogTemp, Display,
-                TEXT("[VoxelForgeTestModification] queued radius=%.2f strength=%.2f"),
+                TEXT("[VoxelForgeTestModification] queued radius=%.2f strength=%.2f target=%s"),
                 GVoxelForgePendingModificationRadius,
-                GVoxelForgePendingModificationStrength);
+                GVoxelForgePendingModificationStrength,
+                GVoxelForgeTestModificationLoadedProofTarget ? TEXT("loaded-proof") : TEXT("player"));
             GVoxelForgePendingTestModification = 1;
         }
     }
@@ -2183,10 +2251,16 @@ void AVoxelWorld::Tick(float DeltaTime)
         && PendingTiles.Num() == 0
         && bStartupTraceDesiredRecorded
         && PendingCollisionCooks.Num() == 0
+        && (!bStartupTraceThroughCrossing
+            || !bHeadlessStrateCrossingTest
+            || bHeadlessStrateCrossingTestPassed
+            || bHeadlessStrateCrossingTestFailed)
         // The desired set being applied is not the player-ready point: the feet tile must have
         // received its completed LOD0 RMC body first. If no pawn exists, there is no gate to wait
         // for and the headless trace keeps its old completion behavior.
-        && (!bHasPlayer || IsPlayerSupportCollisionReady(PlayerPawn, PlayerLastPos)))
+        && (!bHasPlayer
+            || bHeadlessStreamingTestCenterOverride
+            || IsPlayerSupportCollisionReady(PlayerPawn, PlayerLastPos)))
     {
         TMap<int32, int32> SteadyLevelCounts;
         TMap<int32, FIntVector> SteadyLevelMins;
@@ -2244,22 +2318,75 @@ void AVoxelWorld::Tick(float DeltaTime)
     // No pawn is a distinct state from a pawn at (0,0,0); keep the diagnostic fallback for
     // headless/editor use without making the world-origin pawn skip streaming.
     FVector ModificationPosition = bHasPlayer ? PlayerLastPos : GetActorLocation();
-    const FVoxelTileKey ModificationCenterTile(
+    FVoxelTileKey ModificationCenterTile(
         WorldToChunkCoord(WorldToLocalCm(ModificationPosition)), 0);
+    bool bModificationTargetSelected = false;
+    if (GVoxelForgePendingTestModification != 0
+        && GVoxelForgeTestModificationLoadedProofTarget
+        && Generator)
+    {
+        // The diagnostic target is deliberately selected from the applied set.  That makes the
+        // edit exercise the normal loaded-tile synchronous remesh, while the proof query here is
+        // the same public predicate used by GenerateTileResult before the diff exists.
+        for (const FVoxelTileKey& CandidateTile : LoadedTiles)
+        {
+            if (CandidateTile.Level != 0
+                || PendingTiles.Contains(CandidateTile))
+            {
+                continue;
+            }
+            const FIntVector CandidateOrigin(
+                CandidateTile.Coord.X * CHUNK_SIZE,
+                CandidateTile.Coord.Y * CHUNK_SIZE,
+                CandidateTile.Coord.Z * CHUNK_SIZE);
+            if (!Generator->TryProveSealedSolidTile(CandidateOrigin, 1, CHUNK_SIZE))
+            {
+                continue;
+            }
+
+            const FIntVector CandidateCenter(
+                CandidateOrigin.X + CHUNK_SIZE / 2,
+                CandidateOrigin.Y + CHUNK_SIZE / 2,
+                CandidateOrigin.Z + CHUNK_SIZE / 2);
+            ModificationPosition = LocalVoxelToWorld(FVector(CandidateCenter));
+            ModificationCenterTile = CandidateTile;
+            bModificationTargetSelected = true;
+            UE_LOG(LogTemp, Display,
+                TEXT("[VoxelForgeTestModification] player_mine_target tile=(%d,%d,%d) "
+                     "local_center=(%d,%d,%d) before_proof=1"),
+                CandidateTile.Coord.X, CandidateTile.Coord.Y, CandidateTile.Coord.Z,
+                CandidateCenter.X, CandidateCenter.Y, CandidateCenter.Z);
+            break;
+        }
+    }
     if (GVoxelForgePendingTestModification != 0
         && DiffLayer
+        && (!GVoxelForgeTestModificationLoadedProofTarget || bModificationTargetSelected)
         && LoadedTiles.Contains(ModificationCenterTile)
         && !PendingTiles.Contains(ModificationCenterTile))
     {
         GVoxelForgePendingTestModification = 0;
         UE_LOG(LogTemp, Display,
-            TEXT("[VoxelForgeTestModification] applying position=(%.2f,%.2f,%.2f) radius=%.2f strength=%.2f"),
+            TEXT("[VoxelForgeTestModification] applying player_mine=1 tile=(%d,%d,%d) "
+                 "position=(%.2f,%.2f,%.2f) radius=%.2f strength=%.2f"),
+            ModificationCenterTile.Coord.X, ModificationCenterTile.Coord.Y, ModificationCenterTile.Coord.Z,
             ModificationPosition.X, ModificationPosition.Y, ModificationPosition.Z,
             GVoxelForgePendingModificationRadius, GVoxelForgePendingModificationStrength);
         CarveAtPosition(
             ModificationPosition,
             GVoxelForgePendingModificationRadius,
             GVoxelForgePendingModificationStrength);
+        const FIntVector ModifiedOrigin(
+            ModificationCenterTile.Coord.X * CHUNK_SIZE,
+            ModificationCenterTile.Coord.Y * CHUNK_SIZE,
+            ModificationCenterTile.Coord.Z * CHUNK_SIZE);
+        const bool bProofSurvivedCarve = Generator
+            && Generator->TryProveSealedSolidTile(ModifiedOrigin, 1, CHUNK_SIZE);
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeTestModification] player_mine_complete tile=(%d,%d,%d) "
+                 "after_proof=%d"),
+            ModificationCenterTile.Coord.X, ModificationCenterTile.Coord.Y,
+            ModificationCenterTile.Coord.Z, bProofSurvivedCarve ? 1 : 0);
     }
     ProcessUnloadQueue();
     MaybeFinishHeadlessStreamingTest();
@@ -2849,6 +2976,12 @@ void AVoxelWorld::LogStreamingLatencySummary() const
         TotalWorkerGenerationCycles.load(std::memory_order_relaxed);
     const uint64 ObsoleteWorkerCycles =
         TotalObsoleteWorkerCycles.load(std::memory_order_relaxed);
+    const uint64 SealedSolidProofCandidates =
+        TotalSealedSolidProofCandidates.load(std::memory_order_relaxed);
+    const uint64 SealedSolidProofSkips =
+        TotalSealedSolidProofSkips.load(std::memory_order_relaxed);
+    const uint64 OutOfLayoutAirProofSkips =
+        TotalOutOfLayoutAirProofSkips.load(std::memory_order_relaxed);
     const bool bDiagnosticsEnabled = GVoxelForgeProfileTileGeneration != 0
         || VoxelForgeStartupTrace::IsActive()
         || VoxelDensityProfile::GetMode() != VoxelDensityProfile::EMode::Disabled;
@@ -2863,6 +2996,8 @@ void AVoxelWorld::LogStreamingLatencySummary() const
              "applied_tiles=%llu applied_visible_tiles=%llu applied_triangles=%llu "
              "worker_generation_tasks=%llu worker_generation_sum_s=%.6f "
              "validation_density_calls=%llu mesher_density_calls=%llu "
+             "sealed_solid_proof_candidates=%llu sealed_solid_proof_skips=%llu "
+             "out_of_layout_air_proof_skips=%llu "
              "obsolete_worker_tasks=%llu obsolete_worker_sum_s=%.6f "
              "outer_classifier_verdicts=%s applied_level_summary=%s band_level_summary=%s"),
         bDiagnosticsEnabled ? TEXT("profiled") : TEXT("clean"),
@@ -2881,6 +3016,9 @@ void AVoxelWorld::LogStreamingLatencySummary() const
         FPlatformTime::ToSeconds64(WorkerGenerationCycles),
         static_cast<unsigned long long>(TotalValidationDensityCalls.load(std::memory_order_relaxed)),
         static_cast<unsigned long long>(TotalMesherDensityCalls.load(std::memory_order_relaxed)),
+        static_cast<unsigned long long>(SealedSolidProofCandidates),
+        static_cast<unsigned long long>(SealedSolidProofSkips),
+        static_cast<unsigned long long>(OutOfLayoutAirProofSkips),
         static_cast<unsigned long long>(TotalObsoleteWorkerTasks.load(std::memory_order_relaxed)),
         FPlatformTime::ToSeconds64(ObsoleteWorkerCycles),
         *ClassifierVerdictSummary,
@@ -3191,6 +3329,7 @@ bool AVoxelWorld::ApplyTileResult(FChunkResult& Result)
                 Sample.TileZ = Result.Tile.Coord.Z;
                 Sample.Level = Result.Tile.Level;
                 Sample.Verdict = Result.ClassifyVerdict;
+                Sample.bSealedSolidProof = Result.bSealedSolidProof;
                 Sample.bEmpty = bResultEmpty;
                 Sample.Triangles = Result.NumTriangles;
                 Sample.RequestToApplySeconds = RequestToApply;
@@ -4523,7 +4662,7 @@ void AVoxelWorld::GenerateTileResult(const FVoxelTileKey& Tile, const FIntVector
             UE_LOG(LogTemp, Display,
                 TEXT("[VoxelForgeTileProfile] tile=(%d,%d,%d) level=%d step=%d cells=%d sheet=%d aborted=%d empty=%d triangles=%d "
                      "band=(%d,%d) "
-                     "verdict=%d classify=%.6f mesh=%.6f streams=%.6f seconds=%.6f "
+                     "verdict=%d proof=%d air_proof=%d classify=%.6f mesh=%.6f streams=%.6f seconds=%.6f "
                      "cache_build=%.6f evaluation=%.6f "
                      "refine=%u stack=%u core_samples=%u final_samples=%u core_hits=%u final_hits=%u "
                      "core_leaves=%u final_leaves=%u tail_queries=%u tail_eval=%u "
@@ -4543,7 +4682,9 @@ void AVoxelWorld::GenerateTileResult(const FVoxelTileKey& Tile, const FIntVector
                 Tile.Coord.X, Tile.Coord.Y, Tile.Coord.Z, Tile.Level, Step, Cells,
                 bSheetTile ? 1 : 0, Result.bAborted ? 1 : 0,
                 Result.bEmpty ? 1 : 0, Result.NumTriangles, BandChunkLo, BandChunkHi,
-                ClassifyVerdict, ClassifySeconds, MeshSeconds, StreamSeconds,
+                ClassifyVerdict, Result.bSealedSolidProof ? 1 : 0,
+                Result.bOutOfLayoutAirProof ? 1 : 0,
+                ClassifySeconds, MeshSeconds, StreamSeconds,
                 TileSeconds, CacheBuildSeconds, EvaluationSeconds,
                 ClassifierStats.RefineNodes, ClassifierStats.StackBoxCalls,
                 ClassifierStats.ExactCoreSamples, ClassifierStats.ExactFinalSamples,
@@ -4637,6 +4778,8 @@ void AVoxelWorld::GenerateTileResult(const FVoxelTileKey& Tile, const FIntVector
     Result.bObsolete = false;
     Result.bEmpty = true;
     Result.ClassifyVerdict = -1;
+    Result.bSealedSolidProof = false;
+    Result.bOutOfLayoutAirProof = false;
     Result.ClassifySeconds = 0.0;
     Result.MeshSeconds = 0.0;
     Result.StreamSeconds = 0.0;
@@ -4674,8 +4817,49 @@ void AVoxelWorld::GenerateTileResult(const FVoxelTileKey& Tile, const FIntVector
     // même pour les cellules uniformes, et ces tuiles sont rares (fenêtre d'ombre).
     // (Gate IsoLevel == 0 : les verdicts du classifieur supposent l'iso MC à zéro exactement.)
     bool bTrivialEmpty = false;
+    if (GVoxelForgeSealedSolidProof != 0
+        && !bSheetTile && !bWantCapture && Generator && Mesher
+        && Mesher->IsoLevel == 0.0f)
+    {
+        TotalSealedSolidProofCandidates.fetch_add(1, std::memory_order_relaxed);
+        const double ProofStartSeconds = bMeasureTile ? FPlatformTime::Seconds() : 0.0;
+        if (Generator->TryProveSealedSolidTile(OriginVoxels, Step, Cells))
+        {
+            ClassifySeconds = bMeasureTile
+                ? FPlatformTime::Seconds() - ProofStartSeconds : 0.0;
+            ClassifyVerdict = static_cast<int32>(EVoxelTileClass::AllSolid);
+            Result.ClassifyVerdict = ClassifyVerdict;
+            Result.bSealedSolidProof = true;
+            TotalSealedSolidProofSkips.fetch_add(1, std::memory_order_relaxed);
+            INC_DWORD_STAT(STAT_VoxelForgeTilesSkippedAllSolid);
+            bTrivialEmpty = true;
+        }
+        else if (Generator->TryProveOutOfLayoutAirTile(OriginVoxels, Step, Cells))
+        {
+            ClassifySeconds = bMeasureTile
+                ? FPlatformTime::Seconds() - ProofStartSeconds : 0.0;
+            ClassifyVerdict = static_cast<int32>(EVoxelTileClass::AllAir);
+            Result.ClassifyVerdict = ClassifyVerdict;
+            Result.bOutOfLayoutAirProof = true;
+            TotalOutOfLayoutAirProofSkips.fetch_add(1, std::memory_order_relaxed);
+            INC_DWORD_STAT(STAT_VoxelForgeTilesSkippedAllAir);
+            bTrivialEmpty = true;
+        }
+        else if (bMeasureTile)
+        {
+            // Keep the measured proof cost visible on a tile that continues through the normal
+            // path. The clean summary remains counter-only and pays no timer overhead.
+            ClassifySeconds = FPlatformTime::Seconds() - ProofStartSeconds;
+        }
+    }
+    if (ShouldAbortWork(ObsoleteFlag))
+    {
+        AbortResult();
+        EmitTileProfile();
+        return;
+    }
     const int32 OuterClassifierMode = FMath::Clamp(GVoxelForgeOuterClassifierMode, 0, 1);
-    if (OuterClassifierMode != 0
+    if (!bTrivialEmpty && OuterClassifierMode != 0
         && !bSheetTile && !bWantCapture && Generator && Mesher && Mesher->IsoLevel == 0.0f)
     {
         TRACE_CPUPROFILER_EVENT_SCOPE(VoxelForge_ClassifyTile);
@@ -4754,7 +4938,7 @@ void AVoxelWorld::GenerateTileResult(const FVoxelTileKey& Tile, const FIntVector
             EmitTileProfile();
             return;
         }
-        ClassifySeconds = bMeasureTile ? FPlatformTime::Seconds() - ClassifyStartSeconds : 0.0;
+        ClassifySeconds += bMeasureTile ? FPlatformTime::Seconds() - ClassifyStartSeconds : 0.0;
         ClassifyVerdict = static_cast<int32>(ValidatedVerdict);
         Result.ClassifyVerdict = ClassifyVerdict;
         const int32 TrackedLOD = FMath::Clamp(Tile.Level, 0, TrackedClassifierLODCount - 1);

Source/VoxelForge/Public/VoxelGenerator.h

@@ -22,6 +22,16 @@ class UVoxelDiffLayer;
 class UVoxelBiomeDefinition;
 struct FTunnelCoreWorldEvaluation;
 
+/** Guards which may be disabled only by the sealed-solid proof's soundness tests. */
+enum class EVoxelSealedSolidProofGuard : uint8
+{
+    None              = 0,
+    DiffLayer         = 1u << 0,
+    Passages          = 1u << 1,
+    OriginLanding     = 1u << 2,
+    DisturbanceChasms = 1u << 3,
+};
+
 //=============================================================================
 // LOD-AWARE OCTAVE REDUCTION (T2.b)
 //=============================================================================
@@ -166,6 +176,27 @@ public:
                            int32 SizeX, int32 SizeY, int32 SizeZ) const;
     void EndDensityBlock() const;
 
+    /**
+     * Prove that the mesher's core lattice is entirely solid from the cheap, structural rules
+     * that own inter-strate gaps and boundary seals.  This never samples density.  It is intended
+     * for an empty-tile fast path; a false answer is harmless, while a true answer must make every
+     * core lattice vertex negative in the final MC field.
+     *
+     * The proof is deliberately narrower than ClassifyTile: it accepts only a tile made entirely
+     * of gap/seal lattice rows and rejects recipes/composer overrides plus every known air-writing
+     * structural feature.  The mesher's +/-1 normal halo is not part of the cell lattice, matching
+     * ClassifyTile and GenerateMesh.
+     */
+    bool TryProveSealedSolidTile(const FIntVector& OriginVoxels, int32 Step,
+                                 int32 CellsPerAxis) const;
+
+#if WITH_DEV_AUTOMATION_TESTS
+    /** Test hook: disable named proof guards and require the brute-force oracle to catch it. */
+    bool TryProveSealedSolidTileForTest(
+        const FIntVector& OriginVoxels, int32 Step, int32 CellsPerAxis,
+        uint8 DisabledGuards) const;
+#endif
+
     /**
      * Densité pour une strate TunnelNetwork (rooms + tunnels + worm noise).
      * Utilisée en interne par GetDensityAt quand la strate est de ce type.
@@ -385,6 +416,15 @@ public:
                                  int32 CellsPerAxis,
                                  struct FVoxelTileClassificationStats* OutStats) const;
 
+    /**
+     * Prove the exact constant-air field above/below the strate layout for a mesher lattice.
+     * This is separate from TryProveSealedSolidTile: it never supplies collision support and its
+     * caller records AllAir, not AllSolid.  It shares the layout/diff/structural guards with the
+     * production classifier and returns false for every mixed or uncertain box.
+     */
+    bool TryProveOutOfLayoutAirTile(const FIntVector& OriginVoxels, int32 Step,
+                                    int32 CellsPerAxis) const;
+
 private:
     /** Identité process-unique du propriétaire des caches `CP_*` thread_local.
      *  Process-unique owner identity for the `CP_*` thread-local cache key. */

Source/VoxelForge/Public/VoxelStartupTrace.h

@@ -14,6 +14,7 @@ namespace VoxelForgeStartupTrace
         int32 TileZ = 0;
         int32 Level = -1;
         int32 Verdict = -1; // Mixed=0, AllSolid=1, AllAir=2, -1=not classified (sheet/early path)
+        bool bSealedSolidProof = false;
         bool bEmpty = true;
         int32 Triangles = 0;
         // This is worker-result -> game-thread mesh submission. Collision readiness is a later

Source/VoxelForge/Public/VoxelWorld.h

@@ -107,6 +107,8 @@ struct FChunkResult
     uint64 GenerationEndCycles = 0;
     uint64 ApplyStartCycles = 0;
     int32 ClassifyVerdict = -1; double ClassifySeconds = 0.0; double MeshSeconds = 0.0; double StreamSeconds = 0.0; int32 NumTriangles = 0;
+    bool bSealedSolidProof = false; // true when the cheap gap/seal proof skipped meshing
+    bool bOutOfLayoutAirProof = false; // true when the exact constant-air guard skipped meshing
     // Clean, low-overhead work counters. These are carried with the result so the worker can
     // count exact validation and mesher density calls locally, then publish one aggregate update.
     int64 ValidationDensityCalls = 0;
@@ -934,6 +936,9 @@ public:
     std::atomic<uint64> TotalObsoleteWorkerTasks{0};
     std::atomic<uint64> TotalValidationDensityCalls{0};
     std::atomic<uint64> TotalMesherDensityCalls{0};
+    std::atomic<uint64> TotalSealedSolidProofCandidates{0};
+    std::atomic<uint64> TotalSealedSolidProofSkips{0};
+    std::atomic<uint64> TotalOutOfLayoutAirProofSkips{0};
     std::atomic<uint64> OuterClassifierCallsByLOD[TrackedClassifierLODCount]{};
     std::atomic<uint64> OuterClassifierVerdictsByLOD[TrackedClassifierLODCount][3]{};
 
@@ -959,6 +964,9 @@ public:
     // by explicit command-line switches; they do not alter ordinary player movement or streaming.
     bool bHeadlessStreamingTestMovement = false;
     bool bHeadlessStreamingTestExitRequested = false;
+    bool bStartupTraceThroughCrossing = false;
+    bool bHeadlessStreamingTestCenterOverride = false;
+    FVector HeadlessStreamingTestCenterVoxel = FVector::ZeroVector;
     int32 HeadlessStreamingTestMoveAttempts = 0;
     double HeadlessStreamingTestDistanceCm = 0.0;
     float HeadlessStreamingTestSpeedCmPerSecond = 0.0f;