// VoxelDensityOpStack.cpp
// Les opérateurs concrets : les décompositions d'archétypes + le post-traitement structurel.
// The concrete operators: the archetype decompositions + the structural post-process.
//
// Ces opérateurs génèrent chaque strate du jeu (voir l'en-tête de VoxelDensityOpStack.h).
// These operators generate every strate in the game (see the VoxelDensityOpStack.h header).
//
// Convention de signe INTERNE : positif = solide ; la pile négative une fois pour le MC.
// Internal sign convention: positive = solid; the stack negates once for MC.

#include "VoxelForgeCore/ThreadLocalStorage.h"
#include "VoxelDensityOpStack.h"
#include "VoxelStrateComposer.h"

#include "VoxelDensityPrimitives.h"   // VF_ApplyOriginSpine / seals / PassageCarving
#include "VoxelDensityAblation.h"      // fingerprinted development-only stage measurements
#include "VoxelCaveMorphology.h"      // VoxelSDF::Capsule, VoxelHash
#include "VoxelGenerator.h"           // VoxelGenLOD::Eff
#include "VoxelHeightOp.h"            // FVoxelHeightStack — SurfaceWorld's two height stacks
#include "VoxelNoise.h"               // VoxelNoise::FBM
#include "VoxelWormField.h"
#include "VoxelStrateDefinition.h"    // TerrainOperations — le pool que BuildChunkCache tire par salle
#include "VoxelTerrainOpDefinition.h" // ApplyTo — l'override d'op PAR SALLE (étape C1)
#include "VoxelStrateManager.h"       // EvaluateModifierSDF / AnyPassageNearBox
#include "VoxelTypes.h"               // SmoothStep01, VOXEL_NOISE_SCALE
#include "VoxelStats.h"

#include <atomic>                     // l'id d'instance non recyclé du mémo de colonne
#include "HAL/CriticalSection.h"
#include "HAL/Event.h"
#include "HAL/PlatformTime.h"
#include "HAL/PlatformProcess.h"
#include "Misc/ScopeLock.h"

namespace
{
    /**
     * Concrete block thunks use the scalar body with the concrete operator type visible to the
     * compiler.  This is deliberately not a second numerical implementation: the scalar Eval is
     * still the single source of truth, but the op-major caller pays one virtual dispatch for the
     * block and the inner calls can inline/devirtualize.  Operators with a block-native kernel can
     * replace this helper later without changing the stack contract.
     */
    template<typename TOp>
    FORCEINLINE void VF_EvalBlockByScalar(const TOp& Op, const FVoxelOpBlock& Block)
    {
        if (Block.Samples == nullptr || Block.Step <= 0
            || Block.SizeX <= 0 || Block.SizeY <= 0 || Block.SizeZ <= 0)
        {
            return;
        }

        for (int32 Z = 0; Z < Block.SizeZ; ++Z)
        {
            for (int32 Y = 0; Y < Block.SizeY; ++Y)
            {
                for (int32 X = 0; X < Block.SizeX; ++X)
                {
                    FVoxelOpSample& Sample = Block.At(X, Y, Z);
                    Op.PrepareBlockSample(Sample);
                    Op.Eval(
                        static_cast<float>(Block.OriginVoxels.X + X * Block.Step),
                        static_cast<float>(Block.OriginVoxels.Y + Y * Block.Step),
                        static_cast<float>(Block.OriginVoxels.Z + Z * Block.Step),
                        Sample);
                }
            }
        }
    }

    /**
     * BORNE **PROUVABLE** DE `|Perlin3D|`, ET ELLE N'EST PAS 1.0.
     *
     * L'en-tête de `VoxelNoise::Perlin3D` annonce « ~[-1,1] (typiquement [-0.7,0.7]) ». Le `~`
     * est un aveu : c'est une observation, pas un théorème, et un verdict de boîte fondé sur une
     * observation est exactement le genre de trou que ce fichier passe son temps à éviter.
     *
     * Ce qui EST démontrable, en lisant `GradDot` : il rend `ru + rv` où `ru` et `rv` sont des
     * composantes de l'offset fractionnaire, donc chacune dans `[-1, 1]` ⇒ `|GradDot| ≤ 2`. La
     * valeur finale est une interpolation trilinéaire de huit `GradDot`, et une interpolation
     * convexe ne sort jamais de l'enveloppe de ses entrées ⇒ `|Perlin3D| ≤ 2`. (La vraie borne
     * de Perlin 3D est `√3/2 ≈ 0.87` ; on ne s'appuie pas dessus, elle dépend du jeu de
     * gradients.) Se tromper ici coûte une boîte de recherche un peu plus large, jamais un
     * verdict faux : plus large ⇒ SUR-ensemble de primitives ⇒ `Identity` plus rare.
     *
     * ⚠️⚠️ **CETTE CONSTANTE EST LE TERME DOMINANT DE TOUTE LA FONCTION.** À lire avant d'y
     * retoucher.
     *
     * La dilatation vaut `CaveWarpStrength · VOXEL_NOISE_SCALE · CETTE BORNE`. Avec les défauts
     * (`CaveWarpStrength = 8`, `SCALE = 1.25`), une borne de 2.0 vaut **20 voxels** — appliquée
     * des deux côtés de chaque axe d'une tuile de **10 voxels**, soit une boîte de requête de
     * 50 voxels, **125× le volume de la tuile** : `BoxHalfDiag` est alors dominé par cette
     * dilatation et non par la géométrie, et tout resserrement ailleurs ne gagne presque rien.
     *
     * ⚠️ LE RESTE DU PLUGIN EST MOINS PRUDENT : `BuildChunkCache` est appelée avec
     * `Expansion = CaveWarpStrength + 2` (ici comme dans `GetDensityWithParams`), ce qui suppose
     * `|Perlin3D| · SCALE ≤ CaveWarpStrength`, donc `|Perlin3D| ≤ 0.8`. Le code de production
     * parie déjà là-dessus. 2.0 serait 2,5× plus conservateur que l'hypothèse dont dépend déjà la
     * correction du cache.
     *
     * LA BORNE 1.5, DÉMONTRÉE (et non observée) :
     *   1. `GradDot` rend `±u ± v` où `u` et `v` sont deux composantes **distinctes** de l'offset
     *      du coin — vérifié sur les quatre branches du `switch` de hash, pas supposé.
     *   2. Pour l'axe x : les coins à `i=0` portent le poids `(1−su)` et l'offset `fx`, ceux à
     *      `i=1` le poids `su` et l'offset `1−fx`. Donc `Σ_c w_c·|dx_c| = (1−su)·fx + su·(1−fx)`,
     *      dont le maximum sur `[0,1]` vaut **0.5** (atteint en `fx = 0.5`, où `su = 0.5` ;
     *      0.302 en 0.25 comme en 0.75).
     *   3. `|Perlin| ≤ Σ_c w_c(|a_c| + |b_c|) ≤ S_x + S_y + S_z ≤ 3 × 0.5 = 1.5.`
     * (Le vrai maximum est plus bas encore — seuls DEUX axes apparaissent par coin — mais 1.5
     * est la borne qui se démontre sans analyse de cas sur les hash. `√3/2 ≈ 0.87`, la borne
     * classique de Perlin 3D, dépend du jeu de gradients : on ne s'appuie pas dessus.)
     *
     * This bound is the dominant term of the whole function: 2.0 would inflate a 10-voxel tile
     * into a 50-voxel query box (125x the volume). The rest of the plugin already assumes
     * |Perlin3D| <= 0.8 (BuildChunkCache's Expansion = CaveWarpStrength + 2). 1.5 is PROVED
     * above from GradDot's two-distinct-axes form and the per-axis weighted bound of 0.5.
     */
    static constexpr float VF_PerlinAbsBound = 1.5f;

    struct FVFInterval
    {
        float Min = 0.0f;
        float Max = 0.0f;
    };

    FORCEINLINE FVFInterval VF_AddInterval(const FVFInterval& A, const FVFInterval& B)
    {
        return {A.Min + B.Min, A.Max + B.Max};
    }

    FORCEINLINE FVFInterval VF_NegateInterval(const FVFInterval& A)
    {
        return {-A.Max, -A.Min};
    }

    FORCEINLINE FVFInterval VF_MultiplyNonNegativeInterval(
        const FVFInterval& A, const FVFInterval& B)
    {
        const float P0 = A.Min * B.Min;
        const float P1 = A.Min * B.Max;
        const float P2 = A.Max * B.Min;
        const float P3 = A.Max * B.Max;
        return {FMath::Min(FMath::Min(P0, P1), FMath::Min(P2, P3)),
                FMath::Max(FMath::Max(P0, P1), FMath::Max(P2, P3))};
    }

    /** Exact interval for GradDot on one subdivision of one Perlin cell. */
    FORCEINLINE FVFInterval VF_GradDotInterval(
        uint32 Hash, const FVFInterval& X, const FVFInterval& Y, const FVFInterval& Z)
    {
        const uint32 H = Hash & 15u;
        const FVFInterval* Axes[3] = {&X, &Y, &Z};
        const FVFInterval& U = *Axes[(H & 8u) == 0u ? 0 : 1];

        int32 VAxis = 2;
        if ((H & 12u) == 0u)
        {
            VAxis = 1;
        }
        else if ((H & 13u) == 12u)
        {
            VAxis = 0;
        }

        const FVFInterval SignedU = (H & 1u) == 0u ? U : VF_NegateInterval(U);
        const FVFInterval SignedV = (H & 2u) == 0u
            ? *Axes[VAxis] : VF_NegateInterval(*Axes[VAxis]);
        return VF_AddInterval(SignedU, SignedV);
    }

    /**
     * Conservative local envelope for the exact scalar Perlin3D implementation.
     *
     * Perlin3D is a trilinear blend of eight linear GradDot values in each integer cell.  We split
     * every intersected cell into two pieces per axis and interval-evaluate the same fade/lerp
     * formula.  The result is therefore a proof over the whole finite box, not a sample-based
     * guess.  Large/invalid boxes fall back to the already-proven global envelope.
     */
    FORCEINLINE float VF_PerlinAbsBoundOverBox(
        const FVector3f& InMin, const FVector3f& InMax)
    {
        if (!VoxelMath::IsFinite(InMin.X) || !VoxelMath::IsFinite(InMin.Y)
            || !VoxelMath::IsFinite(InMin.Z) || !VoxelMath::IsFinite(InMax.X)
            || !VoxelMath::IsFinite(InMax.Y) || !VoxelMath::IsFinite(InMax.Z)
            || InMin.X > InMax.X || InMin.Y > InMax.Y || InMin.Z > InMax.Z
            || FMath::Abs(InMin.X) > 1000000.0f || FMath::Abs(InMax.X) > 1000000.0f
            || FMath::Abs(InMin.Y) > 1000000.0f || FMath::Abs(InMax.Y) > 1000000.0f
            || FMath::Abs(InMin.Z) > 1000000.0f || FMath::Abs(InMax.Z) > 1000000.0f)
        {
            return VF_PerlinAbsBound;
        }

        const int32 X0 = FMath::FloorToInt(InMin.X);
        const int32 Y0 = FMath::FloorToInt(InMin.Y);
        const int32 Z0 = FMath::FloorToInt(InMin.Z);
        const int32 X1 = FMath::FloorToInt(InMax.X);
        const int32 Y1 = FMath::FloorToInt(InMax.Y);
        const int32 Z1 = FMath::FloorToInt(InMax.Z);
        const int64 CellCount = ((int64)X1 - X0 + 1)
                              * ((int64)Y1 - Y0 + 1)
                              * ((int64)Z1 - Z0 + 1);
        if (X1 < X0 || Y1 < Y0 || Z1 < Z0 || CellCount <= 0 || CellCount > 64)
        {
            return VF_PerlinAbsBound;
        }

        // The interval remains a proof for every subdivision size: each cell piece is evaluated
        // with interval arithmetic, so a coarser partition can only widen the envelope.  Eight
        // pieces made a 32-voxel LOD0 root pay hundreds of thousands of tiny interval operations
        // before the graph proof even started. Four pieces are still bounded, but retain enough
        // finite-domain tightness at the 4-voxel refinement tail to discharge a proof without an
        // exact lattice walk. If the bound cannot discharge the proof, the caller returns Mixed
        // and the normal mesher remains the conservative fallback.
        constexpr int32 Subdivisions = 4;
        float Bound = 0.0f;
        for (int32 CellZ = Z0; CellZ <= Z1; ++CellZ)
        for (int32 CellY = Y0; CellY <= Y1; ++CellY)
        for (int32 CellX = X0; CellX <= X1; ++CellX)
        {
            const float TX0 = FMath::Clamp(InMin.X - (float)CellX, 0.0f, 1.0f);
            const float TY0 = FMath::Clamp(InMin.Y - (float)CellY, 0.0f, 1.0f);
            const float TZ0 = FMath::Clamp(InMin.Z - (float)CellZ, 0.0f, 1.0f);
            const float TX1 = FMath::Clamp(InMax.X - (float)CellX, 0.0f, 1.0f);
            const float TY1 = FMath::Clamp(InMax.Y - (float)CellY, 0.0f, 1.0f);
            const float TZ1 = FMath::Clamp(InMax.Z - (float)CellZ, 0.0f, 1.0f);

            for (int32 SZ = 0; SZ < Subdivisions; ++SZ)
            for (int32 SY = 0; SY < Subdivisions; ++SY)
            for (int32 SX = 0; SX < Subdivisions; ++SX)
            {
                const float AX = TX0 + (TX1 - TX0) * (float)SX / Subdivisions;
                const float BX = TX0 + (TX1 - TX0) * (float)(SX + 1) / Subdivisions;
                const float AY = TY0 + (TY1 - TY0) * (float)SY / Subdivisions;
                const float BY = TY0 + (TY1 - TY0) * (float)(SY + 1) / Subdivisions;
                const float AZ = TZ0 + (TZ1 - TZ0) * (float)SZ / Subdivisions;
                const float BZ = TZ0 + (TZ1 - TZ0) * (float)(SZ + 1) / Subdivisions;

                const float FX0 = VoxelNoise::Detail::Fade(AX);
                const float FX1 = VoxelNoise::Detail::Fade(BX);
                const float FY0 = VoxelNoise::Detail::Fade(AY);
                const float FY1 = VoxelNoise::Detail::Fade(BY);
                const float FZ0 = VoxelNoise::Detail::Fade(AZ);
                const float FZ1 = VoxelNoise::Detail::Fade(BZ);
                const float WXMin[2] = {1.0f - FX1, FX0};
                const float WXMax[2] = {1.0f - FX0, FX1};
                const float WYMin[2] = {1.0f - FY1, FY0};
                const float WYMax[2] = {1.0f - FY0, FY1};
                const float WZMin[2] = {1.0f - FZ1, FZ0};
                const float WZMax[2] = {1.0f - FZ0, FZ1};

                float ValueMin = 0.0f;
                float ValueMax = 0.0f;
                for (int32 CZ = 0; CZ < 2; ++CZ)
                for (int32 CY = 0; CY < 2; ++CY)
                for (int32 CX = 0; CX < 2; ++CX)
                {
                    const FVFInterval Grad = VF_GradDotInterval(
                        VoxelNoise::Detail::HashCorner(CellX + CX, CellY + CY, CellZ + CZ),
                        {AX - (float)CX, BX - (float)CX},
                        {AY - (float)CY, BY - (float)CY},
                        {AZ - (float)CZ, BZ - (float)CZ});
                    const FVFInterval Weight = VF_MultiplyNonNegativeInterval(
                        {WXMin[CX], WXMax[CX]},
                        VF_MultiplyNonNegativeInterval(
                            {WYMin[CY], WYMax[CY]}, {WZMin[CZ], WZMax[CZ]}));
                    const FVFInterval Contribution = VF_MultiplyNonNegativeInterval(Weight, Grad);
                    ValueMin += Contribution.Min;
                    ValueMax += Contribution.Max;
                }

                if (!VoxelMath::IsFinite(ValueMin) || !VoxelMath::IsFinite(ValueMax))
                {
                    return VF_PerlinAbsBound;
                }
                Bound = FMath::Max(Bound, FMath::Max(FMath::Abs(ValueMin), FMath::Abs(ValueMax)));
            }
        }

        // Cover the finite-precision rounding in the nested float lerps.  If the interval proof is
        // looser than the global theorem, retaining the theorem is both cheaper and safer.
        Bound += 0.002f;
        return FMath::Min(FMath::Max(Bound, 0.0f), VF_PerlinAbsBound);
    }

    FORCEINLINE float VF_PerlinAbsBoundOverWorldBox(
        float WorldMinX, float WorldMaxX, float WorldMinY, float WorldMaxY,
        float EffectiveMinZ, float EffectiveMaxZ, float Frequency,
        float OffsetX, float OffsetY, float OffsetZ)
    {
        const float X0 = WorldMinX * Frequency + OffsetX;
        const float X1 = WorldMaxX * Frequency + OffsetX;
        const float Y0 = WorldMinY * Frequency + OffsetY;
        const float Y1 = WorldMaxY * Frequency + OffsetY;
        const float Z0 = EffectiveMinZ * Frequency + OffsetZ;
        const float Z1 = EffectiveMaxZ * Frequency + OffsetZ;
        return VF_PerlinAbsBoundOverBox(
            FVector3f(FMath::Min(X0, X1), FMath::Min(Y0, Y1), FMath::Min(Z0, Z1)),
            FVector3f(FMath::Max(X0, X1), FMath::Max(Y0, Y1), FMath::Max(Z0, Z1)));
    }

    // Cellular3D returns 2*(F2-F1)-1 without a clamp. Every searched feature point is at most
    // sqrt(12) from the query's unit cell, so F2-F1 <= sqrt(12) and the positive supremum is
    // 2*sqrt(12)-1 = 5.9282... . Round that up for float evaluation instead of trusting the
    // "~[-1,1]" comment in the noise implementation (which is an observation, not a proof).
    static constexpr float VF_CellularAbsBound = 6.0f;

    /** La même enveloppe que `FractalNoise3D` de VoxelGenerator.cpp (qui y est `static`, donc
     *  invisible ici). Les coordonnées de bruit restent en float : FVector est double dans UE5
     *  et son aller-retour ne servait qu'à conserver l'ancien arrondi, exigence abandonnée. */
    FORCEINLINE float HFractal3D(const FVector3f& Position, int32 Octaves = 4,
                                 float Lacunarity = 2.0f, float Persistence = 0.5f)
    {
        return VoxelNoise::FBM(Position.X, Position.Y, Position.Z,
                               Octaves, Lacunarity, Persistence);
    }

    /** Idem pour `RidgedNoise3D` (également `static` dans VoxelGenerator.cpp). */
    FORCEINLINE float HRidged3D(const FVector3f& Position, int32 Octaves = 4,
                                float Lacunarity = 2.0f, float Persistence = 0.5f)
    {
        return VoxelNoise::Ridged(Position.X, Position.Y, Position.Z,
                                  Octaves, Lacunarity, Persistence);
    }

    //=========================================================================
    // LE GATE `bNearCaveSurface` — ÉTAPE B
    //=========================================================================
    // ⚠️ DÉCISION DE L'ÉTAPE B5, ÉCRITE ICI PARCE QUE C'EST LE POINT OÙ ELLE SE LIT.
    // Dans l'original, les douze modificateurs de détail vivent dans UN SEUL `if (bNearCaveSurface)`.
    // Deux façons de porter ça : (a) un opérateur « conteneur » qui enveloppe ses enfants, (b) le
    // même early-out répété dans chaque opérateur. **C'est (b), délibérément :**
    //
    //   • La pile est une LISTE PLATE, et `FVoxelOpStack::ClassifyBox` plie les opérateurs un par un.
    //     Un conteneur devrait replier ses enfants lui-même — donc reproduire `VF_FoldOp` — et ses
    //     enfants deviendraient invisibles au pliage. On paierait une abstraction pour en casser une.
    //   • Un opérateur qui n'existe QUE dans un conteneur n'est pas composable, donc pas transposable
    //     en asset (Phase 3). Le motif « chaque op teste son propre gate » est déjà celui de
    //     `FSdfRoughnessMod` (`InOut.Sdf >= ApplyWithin`) et de `FShaftLedgeMod`.
    //   • Le gate n'est de toute façon PAS uniforme : chaque modificateur a EN PLUS sa propre fenêtre
    //     (`RoughnessDepth`, `TerraceRange`, `LineRange`…). Le gate partagé n'est qu'un early-out
    //     commun, pas la condition réelle de chacun.
    //
    // ⚠️ CE QUE ÇA COÛTE, dit franchement : l'original teste UNE fois et saute les douze ; la pile
    // teste douze fois. Douze comparaisons flottantes parfaitement prédites par voxel de roc profond
    // — mesurable, mais c'est exactement le genre de chose que `AUDIT §C10` dit de MESURER avant
    // d'optimiser. C'est un poste de perf connu, pas à « corriger » à l'aveugle.
    //
    // STAGE B5 DECISION: repeated early-out in each op, NOT a scoping container — the stack is a flat
    // list that ClassifyBox folds op by op, and an op that only exists inside a container is not
    // composable. Cost stated honestly: twelve predictable compares instead of one branch.
    FORCEINLINE bool VF_NearCaveSurface(float Sdf, float SDFBlendRadius)
    {
        // Transcrit tel quel, ordre des comparaisons compris :
        //   const float DetailThreshold = Params.SDFBlendRadius * 3.0f;
        //   const bool bNearCaveSurface = (CaveSDF < DetailThreshold) && (CaveSDF < FLT_MAX);
        const float DetailThreshold = SDFBlendRadius * 3.0f;
        return (Sdf < DetailThreshold) && (Sdf < FLT_MAX);
    }

    /** Lower bound for the distance between two axis-aligned boxes. The segment's AABB contains
     * the segment, so this is a conservative lower bound for point-to-segment distance. */
    FORCEINLINE float VF_DistanceBetweenBoxes(const FVector& AMin, const FVector& AMax,
                                               const FVector& BMin, const FVector& BMax)
    {
        const float DX = FMath::Max3((float)(AMin.X - BMax.X), (float)(BMin.X - AMax.X), 0.0f);
        const float DY = FMath::Max3((float)(AMin.Y - BMax.Y), (float)(BMin.Y - AMax.Y), 0.0f);
        const float DZ = FMath::Max3((float)(AMin.Z - BMax.Z), (float)(BMin.Z - AMax.Z), 0.0f);
        return FMath::Sqrt(DX * DX + DY * DY + DZ * DZ);
    }

    FORCEINLINE float VF_DistanceBoxToPointXY(const FBox& Box, float X, float Y)
    {
        const float DX = FMath::Max3((float)(Box.Min.X - X), 0.0f, (float)(X - Box.Max.X));
        const float DY = FMath::Max3((float)(Box.Min.Y - Y), 0.0f, (float)(Y - Box.Max.Y));
        return FMath::Sqrt(DX * DX + DY * DY);
    }

    /** Distance from the nearest exact lattice coordinate in one axis to a point. The continuous
     * box proof uses the interval [BoxMin, BoxMax]; the lattice proof uses only
     * Origin + integer * Step values inside that interval. Extra is a per-axis displacement
     * envelope (the cave warp); subtracting it keeps the result conservative. */
    FORCEINLINE float VF_LatticeAxisDistanceToPoint(
        float BoxMin, float BoxMax, float Origin, float Step, float Target, float Extra)
    {
        if (!(Step > 0.0f) || !VoxelMath::IsFinite(BoxMin) || !VoxelMath::IsFinite(BoxMax)
            || !VoxelMath::IsFinite(Origin) || !VoxelMath::IsFinite(Target)
            || BoxMin > BoxMax)
        {
            return FLT_MAX;
        }

        const int32 GMin = FMath::CeilToInt((BoxMin - Origin) / Step - 1.0e-4f);
        const int32 GMax = FMath::FloorToInt((BoxMax - Origin) / Step + 1.0e-4f);
        if (GMin > GMax) { return FLT_MAX; }

        const int32 Near = FMath::FloorToInt((Target - Origin) / Step);
        float Distance = FLT_MAX;
        auto Consider = [&](int32 G)
        {
            G = FMath::Clamp(G, GMin, GMax);
            Distance = FMath::Min(Distance,
                FMath::Abs((Origin + static_cast<float>(G) * Step) - Target));
        };
        Consider(GMin);
        Consider(GMax);
        Consider(Near);
        Consider(Near + 1);
        return FMath::Max(0.0f, Distance - FMath::Max(Extra, 0.0f));
    }

    /** Same discrete distance, but to an axis-aligned interval. */
    FORCEINLINE float VF_LatticeAxisDistanceToInterval(
        float BoxMin, float BoxMax, float Origin, float Step,
        float TargetMin, float TargetMax, float Extra)
    {
        if (!(Step > 0.0f) || !VoxelMath::IsFinite(TargetMin) || !VoxelMath::IsFinite(TargetMax)
            || TargetMin > TargetMax)
        {
            return FLT_MAX;
        }

        const int32 GMin = FMath::CeilToInt((BoxMin - Origin) / Step - 1.0e-4f);
        const int32 GMax = FMath::FloorToInt((BoxMax - Origin) / Step + 1.0e-4f);
        if (GMin > GMax) { return FLT_MAX; }

        const int32 NearMin = FMath::FloorToInt((TargetMin - Origin) / Step);
        const int32 NearMax = FMath::FloorToInt((TargetMax - Origin) / Step);
        float Distance = FLT_MAX;
        auto Consider = [&](int32 G)
        {
            G = FMath::Clamp(G, GMin, GMax);
            const float Value = Origin + static_cast<float>(G) * Step;
            const float Delta = Value < TargetMin ? TargetMin - Value
                              : Value > TargetMax ? Value - TargetMax : 0.0f;
            Distance = FMath::Min(Distance, Delta);
        };
        Consider(GMin);
        Consider(GMax);
        Consider(NearMin);
        Consider(NearMin + 1);
        Consider(NearMax);
        Consider(NearMax + 1);
        return FMath::Max(0.0f, Distance - FMath::Max(Extra, 0.0f));
    }

    FORCEINLINE float VF_SaturatingAdd(float A, float B)
    {
        if (!VoxelMath::IsFinite(A) || !VoxelMath::IsFinite(B)) { return FLT_MAX; }
        if (B > 0.0f && A > FLT_MAX - B) { return FLT_MAX; }
        if (B < 0.0f && A < -FLT_MAX - B) { return -FLT_MAX; }
        return A + B;
    }

    //=========================================================================
    // RÔLE 1 — SOURCE : CHAMP CONSTANT / CONSTANT FIELD  (roc ET vide)
    //=========================================================================
    // `float Density = Params.BaseDensity;  // start solid` — la première ligne de TunnelNetwork,
    // de Maze ET de VerticalShafts. Et `float Density = -Params.BaseDensity;  // open air (void)` —
    // la première ligne de FloatingIslands. **C'est le MÊME opérateur au signe près**, et le signe
    // n'est pas un détail : il décide du verdict de boîte de départ (AllSolid contre AllAir), donc
    // de ce que la strate saura sauter.
    //
    // Quatre archétypes, une ligne, un opérateur. Deux fabriques (`MakeConstantRockSource` /
    // `MakeConstantVoidSource`) parce que « roc » et « vide » sont ce que l'auteur veut DIRE ; la
    // classe, elle, n'a aucune raison d'exister en deux exemplaires.
    //
    // One operator, two factories: rock and void are the same constant field with opposite signs,
    // and the sign is what decides the starting box verdict (AllSolid vs AllAir).
    class FConstantFieldSource final : public IVoxelDensityOp
    {
    public:
        explicit FConstantFieldSource(float InValue) : Value(InValue) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        bool IsXYPure() const override { return true; }   // constant ⇒ trivialement sans Z

        void Eval(float, float, float, FVoxelOpSample& InOut) const override
        {
            InOut.Density = Value;   // Replace : racine de pile, ignore l'entrée
        }

        // Exact et gratuit, dans les DEUX sens (convention interne : positif = solide).
        // Positif ⇒ AllSolid : c'est ce qui donne aux strates de grotte une hypothèse de départ
        // qu'elles n'ont jamais eue. Négatif ⇒ AllAir : c'est ce qui rend une strate d'îles
        // flottantes — un grand vide surtout vide — sautable là où aucune île n'arrive.
        EVoxelTileClass ClassifyBox(const FBox&, const FVoxelOpContext&) const override
        {
            if (Value > 0.0f) { return EVoxelTileClass::AllSolid; }
            if (Value < 0.0f) { return EVoxelTileClass::AllAir; }
            return EVoxelTileClass::Mixed;   // exactement 0 : le mesher le compte du côté AIR,
                                             // mais un champ nul n'est pas une hypothèse utile.
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Both;   // jamais atteint sauf Value == 0 : ClassifyBox répond avant
        }

        /** ⚠️ LA MOITIÉ MANQUANTE DU PLIAGE NUMÉRIQUE (`OPSTACK-DECOMPOSITION §0.2`).
         *  `MaxCarveOverBox` dit ce qu'un opérateur peut RETIRER ; ceci dit ce qu'il y avait à
         *  retirer. Un champ constant est le seul opérateur du plugin qui connaisse cette marge
         *  EXACTEMENT : la densité vaut `Value` partout, donc la marge est `|Value|`. Sans elle la
         *  soustraction n'a pas de premier terme et tout carve borné tue quand même l'hypothèse. */
        float ForcedMarginOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return FMath::Abs(Value);
        }

        const TCHAR* DebugName() const override { return TEXT("ConstantFieldSource"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        float Value;
    };

    //=======================================================================
    // TIER 4b — GENERIC ROLLED SOURCE/MODIFIER PRIMITIVES
    //=======================================================================
    // These two small primitives keep the non-room channel space large enough for the promised
    // k=4..8 draw.  They are deliberately bounded: their box contracts are amplitude proofs, not
    // guesses.  They do not carry any room/shaft/surface pointer, so the resource graph correctly
    // treats them as legal after every SDF shape source.
    class FNoiseRibbonSource final : public IVoxelDensityOp
    {
    public:
        FNoiseRibbonSource(const FMazeGenerationParams& InP, int32 InSeed)
            : CellSize(FMath::Max(InP.CellSize, 8.0f))
            , CorridorRadius(FMath::Max(InP.CorridorRadius, 0.5f))
            , SeedU(static_cast<uint32>(InSeed) ^ 0x5249626Eu) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Sdf; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float Frequency = 1.0f / CellSize;
            const FVector3f NoisePos(
                WorldX * Frequency + VoxelHash::SeedOffset(SeedU, 3.17f),
                WorldY * Frequency + VoxelHash::SeedOffset(SeedU, 7.31f),
                WorldZ * Frequency + VoxelHash::SeedOffset(SeedU, 11.47f));
            const float Ribbon = FMath::Clamp(
                FMath::Abs(VoxelNoise::FBM(NoisePos.X, NoisePos.Y, NoisePos.Z,
                                           VoxelGenLOD::Eff(3), 2.0f, 0.5f))
                    * VOXEL_NOISE_SCALE,
                0.0f, 2.0f);
            InOut.Sdf = Ribbon * CellSize - CorridorRadius;
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Identity;
        }

        void PropagateSdfOverBox(FVoxelBoxSdfInterval& InOut, const FBox&,
                                 const FVoxelOpContext&) const override
        {
            if (!VoxelMath::IsFinite(CellSize) || !VoxelMath::IsFinite(CorridorRadius)
                || CellSize <= 0.0f || CorridorRadius < 0.0f)
            {
                InOut.SetUnknown();
                return;
            }
            // Eval clamps the FBM envelope to [0,2].  This interval is exact enough for safety
            // and independent of the queried box, so it never claims a false empty region.
            InOut.Set(-CorridorRadius, 2.0f * CellSize - CorridorRadius);
        }

        const TCHAR* DebugName() const override { return TEXT("NoiseRibbonSource"); }

    private:
        float CellSize;
        float CorridorRadius;
        uint32 SeedU;
    };

    class FDensityNoiseMod final : public IVoxelDensityOp
    {
    public:
        FDensityNoiseMod(float InStrength, float InFrequency, int32 InOctaves,
                         int32 InSeed, bool bInFill)
            : Strength(FMath::Max(InStrength, 0.0f))
            , Frequency(FMath::Max(InFrequency, 0.0001f))
            , Octaves(FMath::Clamp(InOctaves, 1, 8))
            , SeedU(static_cast<uint32>(InSeed) ^ (bInFill ? 0x46696C6Cu : 0x43617276u))
            , bFill(bInFill) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            if (!(Strength > 0.0f)) { return; }
            const FVector3f NoisePos(
                WorldX * Frequency + VoxelHash::SeedOffset(SeedU, 13.2f),
                WorldY * Frequency + VoxelHash::SeedOffset(SeedU, 17.8f),
                WorldZ * Frequency + VoxelHash::SeedOffset(SeedU, 23.4f));
            const float Noise01 = FMath::Clamp(
                VoxelNoise::FBM(NoisePos.X, NoisePos.Y, NoisePos.Z,
                                VoxelGenLOD::Eff(Octaves), 2.0f, 0.5f) * 0.5f + 0.5f,
                0.0f, 1.0f);
            const float Delta = Strength * Noise01;
            InOut.Density += bFill ? Delta : -Delta;
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            if (!(Strength > 0.0f)) { return EVoxelOpEffect::Identity; }
            return bFill ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::CarveOnly;
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return bFill ? 0.0f : Strength;
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return bFill ? Strength : 0.0f;
        }

        const TCHAR* DebugName() const override
        {
            return bFill ? TEXT("DensityNoiseFillMod") : TEXT("DensityNoiseCarveMod");
        }

    private:
        float Strength;
        float Frequency;
        int32 Octaves;
        uint32 SeedU;
        bool bFill;
    };

    //=========================================================================
    // RÔLE 1 — SOURCE : COULOIRS SUR TREILLIS 3D / 3D LATTICE CORRIDORS
    //=========================================================================
    // Chaque nœud du treillis est au centre d'une cellule. Il choisit exactement un parent parmi
    // les axes qui le rapprochent de l'origine ; l'arête parent abaisse donc |X|+|Y|+|Z| de un.
    // Le résultat est un arbre couvrant de tout le treillis infini. Quelques arêtes supplémentaires
    // sont hashées comme des boucles, avec des probabilités plafonnées qui ne participent jamais à
    // la connectivité. Le couloir est une capsule.
    //
    // La règle est locale et seam-safe : les huit nœuds-enfants du halo {-1,0}³ suffisent à émettre
    // toutes les arêtes qui peuvent toucher la cellule évaluée. Chaque décision est une fonction
    // pure du nœud, de l'axe et de la seed ; il n'y a ni collect global ni dépendance à la fenêtre
    // de chunk.
    class FLatticeCorridorSource final : public IVoxelDensityOp
    {
    public:
        FLatticeCorridorSource(const FMazeGenerationParams& P, int32 Seed)
            : CellSize(FMath::Max(P.CellSize, 1.0f))
            , CorridorRadius(FMath::Max(P.CorridorRadius, 0.5f))
            , BranchProbability(P.BranchProbability)
            , Verticality(P.Verticality)
            , Salt((uint32)Seed ^ 0x4D617A65u)   // 'Maze'
        {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Sdf; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Sdf; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const int32 CX = FMath::FloorToInt(WorldX / CellSize);
            const int32 CY = FMath::FloorToInt(WorldY / CellSize);
            const int32 CZ = FMath::FloorToInt(WorldZ / CellSize);

            const TArray<FEdge, TInlineAllocator<24>>& Edges = GetCellEdges(FIntVector(CX, CY, CZ));

            const FVector Pos(WorldX, WorldY, WorldZ);
            float Sdf = FLT_MAX;
            for (const FEdge& E : Edges)
            {
                Sdf = FMath::Min(Sdf, VoxelSDF::Capsule(Pos, E.A, E.B, CorridorRadius));
            }
            // Union de formes ⇒ MIN sur le canal SDF (voir la note de signe dans VoxelDensityOp.h :
            // « min » ici veut dire l'inverse de ce qu'il veut dire sur le canal densité).
            InOut.Sdf = FMath::Min(InOut.Sdf, Sdf);
        }

        // This source writes SDF only. The following converter decides whether that SDF carves;
        // the source itself has no density effect in isolation.
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Identity;
        }

        /** Exact cell coverage plus a geometric lower bound for every open edge. The upper bound
         * is FLT_MAX because a far point can retain an arbitrarily positive capsule distance. */
        void PropagateSdfOverBox(FVoxelBoxSdfInterval& InOut, const FBox& VoxelBox,
                                 const FVoxelOpContext&) const override
        {
            const int32 CX0 = FMath::FloorToInt((float)VoxelBox.Min.X / CellSize);
            const int32 CY0 = FMath::FloorToInt((float)VoxelBox.Min.Y / CellSize);
            const int32 CZ0 = FMath::FloorToInt((float)VoxelBox.Min.Z / CellSize);
            const int32 CX1 = FMath::FloorToInt((float)VoxelBox.Max.X / CellSize);
            const int32 CY1 = FMath::FloorToInt((float)VoxelBox.Max.Y / CellSize);
            const int32 CZ1 = FMath::FloorToInt((float)VoxelBox.Max.Z / CellSize);

            constexpr int64 MaxCellsScanned = 64 * 64 * 64;
            const int64 CellCount = (int64)(CX1 - CX0 + 1) * (CY1 - CY0 + 1) * (CZ1 - CZ0 + 1);
            if (CellCount <= 0 || CellCount > MaxCellsScanned)
            {
                InOut.SetUnknown();
                return;
            }

            float Lower = FLT_MAX;
            bool bAnyEdge = false;
            for (int32 cz = CZ0; cz <= CZ1; ++cz)
            for (int32 cy = CY0; cy <= CY1; ++cy)
            for (int32 cx = CX0; cx <= CX1; ++cx)
            {
                const TArray<FEdge, TInlineAllocator<24>>& Edges =
                    GetCellEdges(FIntVector(cx, cy, cz));
                for (const FEdge& E : Edges)
                {
                    bAnyEdge = true;
                    const FVector SegmentMin(
                        FMath::Min(E.A.X, E.B.X), FMath::Min(E.A.Y, E.B.Y), FMath::Min(E.A.Z, E.B.Z));
                    const FVector SegmentMax(
                        FMath::Max(E.A.X, E.B.X), FMath::Max(E.A.Y, E.B.Y), FMath::Max(E.A.Z, E.B.Z));
                    Lower = FMath::Min(Lower,
                        VF_DistanceBetweenBoxes(VoxelBox.Min, VoxelBox.Max,
                                                 SegmentMin, SegmentMax) - CorridorRadius);
                }
            }

            FVoxelBoxSdfInterval Own;
            if (!bAnyEdge) { Own.Set(FLT_MAX, FLT_MAX); }
            else            { Own.Set(Lower, FLT_MAX); }
            InOut.MinWith(Own);
        }

    private:
        struct FEdge { FVector A, B; };

        FVector NodeCenter(int32 X, int32 Y, int32 Z) const
        {
            return FVector((X + 0.5f) * CellSize, (Y + 0.5f) * CellSize, (Z + 0.5f) * CellSize);
        }

        /**
         * Le cache par CELLULE. Il est `thread_local` et non
         * membre parce que la pile est PARTAGÉE entre workers en lecture — un membre mutable serait
         * une course. La reconstruction seule inspecte le petit voisinage ; Eval ne refait aucune
         * décision de parent ou de boucle.
         *
         * ⚠️ PHASE 3 : quand les opérateurs deviendront des assets partagés, il faudra un objet
         * d'état PAR WORKER plutôt que ce `thread_local` (qui est global à la fonction, donc partagé
         * entre DEUX piles Maze différentes sur le même thread — la clé le rattrape, mais au prix
         * d'un rebuild à chaque alternance).
         */
        const TArray<FEdge, TInlineAllocator<24>>& GetCellEdges(const FIntVector& Cell) const
        {
            thread_local TArray<FEdge, TInlineAllocator<24>> MZ_Edges;
            thread_local FIntVector MZ_Cell(INT32_MAX, INT32_MAX, INT32_MAX);
            thread_local uint32 MZ_Seed = 0xFFFFFFFFu;
            thread_local float  MZ_CS = -1.0f, MZ_Branch = -1.0f, MZ_Vert = -1.0f;

            if (Cell != MZ_Cell || Salt != MZ_Seed || CellSize != MZ_CS ||
                BranchProbability != MZ_Branch || Verticality != MZ_Vert)
            {
                MZ_Cell = Cell;  MZ_Seed = Salt;  MZ_CS = CellSize;
                MZ_Branch = BranchProbability;  MZ_Vert = Verticality;
                MZ_Edges.Reset();

                // Canonical lower-node edges in {-1,0} per axis cover every corridor that can
                // reach this voxel's cell. IsOpenEdge checks both endpoints, including a +1
                // node's parent choice, without needing a wider cache window.
                for (int32 dz = -1; dz <= 0; dz++)
                for (int32 dy = -1; dy <= 0; dy++)
                for (int32 dx = -1; dx <= 0; dx++)
                {
                    const int32 nx = Cell.X + dx, ny = Cell.Y + dy, nz = Cell.Z + dz;
                    const FVector A = NodeCenter(nx, ny, nz);

                    if (VoxelMazeTopology::IsOpenEdge(
                            nx, ny, nz, VoxelMazeTopology::EAxis::X,
                            Salt, BranchProbability, Verticality))
                    {
                        MZ_Edges.Add({ A, NodeCenter(nx + 1, ny, nz) });
                    }
                    if (VoxelMazeTopology::IsOpenEdge(
                            nx, ny, nz, VoxelMazeTopology::EAxis::Y,
                            Salt, BranchProbability, Verticality))
                    {
                        MZ_Edges.Add({ A, NodeCenter(nx, ny + 1, nz) });
                    }
                    if (VoxelMazeTopology::IsOpenEdge(
                            nx, ny, nz, VoxelMazeTopology::EAxis::Z,
                            Salt, BranchProbability, Verticality))
                    {
                        MZ_Edges.Add({ A, NodeCenter(nx, ny, nz + 1) });
                    }
                }
            }
            return MZ_Edges;
        }

        float  CellSize, CorridorRadius, BranchProbability, Verticality;
        uint32 Salt;
    };

    //=========================================================================
    // RÔLE 1 — SOURCE : DALLE / SLAB VOID  (FlatPlain ET CrystalChamber)
    //=========================================================================
    // Surface de sol, surface de plafond, puis `Density = -min(distAuSol, distAuPlafond)`.
    //
    // DEUX archétypes, UN opérateur, sans le moindre branchement sur le type — CrystalChamber
    // n'est rien d'autre que FlatPlain avec un `CeilingRoughness` plus grand (OPSTACK-PLAN §4) :
    // la différence entre eux est un jeu de valeurs par défaut.
    //
    // Two archetypes, ONE op, with no branch on the type.
    // CrystalChamber IS FlatPlain with a bigger CeilingRoughness.
    //
    // XY-PUR depuis §3.1 (le terme en Z des deux bruits est parti). C'est ce qui rend
    // `ClassifyBox` exact plutôt qu'estimé — voir plus bas.
    class FSlabVoidSource final : public IVoxelDensityOp
    {
    public:
        FSlabVoidSource(const FSlabGenerationParams& P, int32 Seed)
            : SeedU((uint32)Seed)
            , FloorRoughness(P.FloorRoughness)
            , FloorFrequency(P.FloorRoughnessFrequency)
            , CeilRoughness(P.CeilingRoughness)
            , CeilFrequency(P.CeilingRoughnessFrequency)
        {
            const float StrateHeight = P.StrateTopWorldZ - P.StrateBottomWorldZ;
            FloorZ = P.StrateBottomWorldZ + StrateHeight * P.FloorRelativeHeight;
            CeilZ  = P.StrateBottomWorldZ + StrateHeight * P.CeilingRelativeHeight;

            // FBM's proved supremum is 1.5, not the parameter's nominal [-1,1] label. Bounds must
            // cover every authored value, so never normalise the roughness parameter to repair a
            // bound: multiply the actual maximum noise envelope instead.
            FloorAmp = VOXEL_NOISE_SCALE * VF_PerlinAbsBound * FMath::Abs(FloorRoughness);
            CeilAmp  = VOXEL_NOISE_SCALE * VF_PerlinAbsBound * FMath::Abs(CeilRoughness);
        }

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        // ⚠️⚠️ `false`, ET NE PAS LE PASSER À `true`.
        //
        // Le contrat de `IsXYPure` est « **`Eval`** ne dépend pas de Z » — pas « les surfaces ne
        // dépendent pas de Z ». Or `Eval` calcule `min(Z - sol, plafond - Z)` : il dépend de Z de
        // la façon la plus directe qui soit. §3.1 a rendu les SURFACES pures en XY ; la DENSITÉ,
        // elle, ne l'a jamais été et ne peut pas l'être — c'est une distance à une surface.
        //
        // Le jour où un cache de colonnes générique lit ce drapeau, un `true` ici ferait partager
        // UNE valeur de densité sur TOUTE la pile verticale de chunks — un monde silencieusement
        // faux, que `ValidateDeterminism` ne verrait pas parce qu'il échantillonne le long d'un
        // bord X. C'est exactement le piège que l'avertissement de `VoxelDensityOp.h` décrit.
        //
        // ⚠️ Must stay `false`. The contract is "**Eval** does not depend on Z", and Eval computes
        // min(Z - floor, ceil - Z). §3.1 made the SURFACES XY-pure; the DENSITY never was and
        // cannot be — it is a distance to a surface. A generic column cache reading `true` here
        // would share one density down the whole vertical chunk stack.
        //
        // C'est précisément cette distinction qui justifie l'espace-hauteur (`VoxelHeightOp.h`) :
        // ce qui est pur en XY, ce sont les HAUTEURS, et elles y sont dans un type qui n'a pas de Z.
        bool IsXYPure() const override { return false; }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float FloorSurface = SurfaceFloor(WorldX, WorldY);
            const float CeilSurface  = SurfaceCeil(WorldX, WorldY, FloorSurface);

            const float DistAboveFloor = WorldZ - FloorSurface;
            const float DistBelowCeil  = CeilSurface - WorldZ;
            const float VoidField      = FMath::Min(DistAboveFloor, DistBelowCeil);

            InOut.Density = -VoidField;   // Replace : interne, positif = solide
        }

        //---------------------------------------------------------------------
        // LE VERDICT QUE FLATPLAIN N'A JAMAIS EU
        //---------------------------------------------------------------------
        // `ClassifyTile` ne prouve AUCUNE tuile pour les archétypes de grotte aujourd'hui. Ici la
        // preuve est immédiate et n'exige aucun échantillonnage : les deux surfaces vivent dans des
        // BANDES en Z dont on connaît les bornes exactes, donc une boîte entièrement sous la bande
        // du sol est solide, et une boîte entièrement entre les deux bandes est de l'air.
        //
        // ⚠️ Conservatif dans le bon sens : rendre `Mixed` ne coûte que du CPU, rendre le mauvais
        // verdict est un TROU. Toutes les comparaisons ci-dessous sont donc strictes et prennent le
        // pire cas des deux bruits.
        EVoxelTileClass ClassifyBox(const FBox& VoxelBox, const FVoxelOpContext&) const override
        {
            const float ZMin = (float)VoxelBox.Min.Z;
            const float ZMax = (float)VoxelBox.Max.Z;

            // Bornes de la surface de sol : FloorZ ± FloorAmp.
            const float FloorLo = FloorZ - FloorAmp;
            const float FloorHi = FloorZ + FloorAmp;

            // Bornes du plafond. `CeilNoise = |bruit| · rugosité` ∈ [0, CeilAmp] ⇒ la surface ne
            // peut que DESCENDRE depuis CeilZ… sauf que le clamp `Max(…, FloorSurface + 2)` peut la
            // remonter. Le majorant honnête est donc le max des deux possibilités.
            const float CeilLo = CeilZ - CeilAmp;
            const float CeilHi = FMath::Max(CeilZ, FloorHi + 2.0f);

            // Sous le sol le plus bas possible ⇒ distAuSol < 0 partout ⇒ densité > 0 ⇒ SOLIDE.
            if (ZMax < FloorLo) { return EVoxelTileClass::AllSolid; }

            // Au-dessus du plafond le plus haut possible ⇒ distAuPlafond < 0 ⇒ SOLIDE.
            if (ZMin > CeilHi)  { return EVoxelTileClass::AllSolid; }

            // Strictement entre les deux bandes ⇒ les deux distances sont > 0 ⇒ densité < 0 ⇒ AIR.
            // (Les colonnes peuvent re-remplir cet air : c'est FGridColumnMod qui le déclare, en
            //  rendant FillOnly quand une colonne atteint la boîte. Le pliage s'en charge.)
            if (ZMin > FloorHi && ZMax < CeilLo) { return EVoxelTileClass::AllAir; }

            return EVoxelTileClass::Mixed;
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Both;   // jamais atteint : ClassifyBox répond avant
        }

    private:
        // The surface coordinates stay in float; an FVector (double) round-trip is not part of
        // the output contract.
        float SurfaceFloor(float WorldX, float WorldY) const
        {
            if (FloorRoughness <= 0.0f) { return FloorZ; }
            const float FF = FloorFrequency;
            const FVector3f NoisePos(WorldX * FF + VoxelHash::SeedOffset(SeedU, 7.3f),
                                   WorldY * FF + VoxelHash::SeedOffset(SeedU, 11.1f),
                                   0.0f);
            const float N = VoxelNoise::FBM(NoisePos.X, NoisePos.Y, NoisePos.Z,
                                            VoxelGenLOD::Eff(3), 2.0f, 0.5f)
                          * VOXEL_NOISE_SCALE * FloorRoughness;
            return FloorZ + N;
        }

        float SurfaceCeil(float WorldX, float WorldY, float FloorSurface) const
        {
            float CeilNoise = 0.0f;
            if (CeilRoughness > 0.0f)
            {
                const float CF = CeilFrequency;
                const FVector3f NoisePos(WorldX * CF + VoxelHash::SeedOffset(SeedU, 17.3f) + 1000.0f,
                                       WorldY * CF + VoxelHash::SeedOffset(SeedU, 19.7f) + 2000.0f,
                                       3000.0f);
                const float Raw = VoxelNoise::FBM(NoisePos.X, NoisePos.Y, NoisePos.Z,
                                                  VoxelGenLOD::Eff(3), 2.0f, 0.5f)
                                * VOXEL_NOISE_SCALE;
                // abs() ⇒ les formations ne pendent QUE vers le bas.
                CeilNoise = FMath::Abs(Raw) * CeilRoughness;
            }
            return FMath::Max(CeilZ - CeilNoise, FloorSurface + 2.0f);
        }

        uint32 SeedU;
        float FloorZ = 0.0f, CeilZ = 0.0f;
        float FloorRoughness, FloorFrequency;
        float CeilRoughness,  CeilFrequency;
        float FloorAmp = 0.0f, CeilAmp = 0.0f;
    };

    //=========================================================================
    // RÔLE 1 — SOURCE : COLONNE DE SURFACE / SURFACE COLUMN  (SurfaceWorld)
    //=========================================================================
    // Le pont entre les deux espaces : consomme DEUX piles de hauteur (sol et voûte) et en fait une
    // densité :
    //
    //     Density = TerrainZ - Z                 ← solide sous le sol
    //     Density = max(Density, Z - CeilSurf)   ← solide au-dessus de la voûte
    //
    // ⚠️ `IsXYPure()` est **false**, et la distinction est LE point de tout ce découpage : les
    // HAUTEURS sont pures en XY (elles vivent dans `VoxelHeightOp.h`, un type sans Z), la DENSITÉ
    // ne l'est pas et ne peut pas l'être — c'est une distance à une surface. Confondre les deux est
    // exactement le bug que `FSlabVoidSource` portait jusqu'à aujourd'hui.
    //
    // The bridge between the two spaces: consumes two HEIGHT stacks and turns them into density.
    // IsXYPure is false — the heights are XY-pure, the density is a distance to them and never can be.
    class FSurfaceColumnSource final : public IVoxelDensityOp
    {
    public:
        /**
         * @param PerBiome  vide ⇒ pas de biomes, chemin d'origine inchangé. Non vide ⇒ le sol est
         *                  mélangé et le plafond sélectionné par `InField`.
         * @param InField   **POSSÉDÉ** — délibérément, plutôt qu'un pointeur nu. L'adaptateur réel
         *                  pointe vers des `thread_local` du générateur ; lier sa durée de vie à
         *                  celle de la pile (elle-même `thread_local`, reconstruite au même moment)
         *                  rend la question de survie structurelle au lieu de la laisser à une
         *                  convention que le prochain lecteur devrait deviner.
         *                  OWNED on purpose rather than borrowed: tying its lifetime to the stack's
         *                  makes the survival question structural instead of conventional.
         */
        FSurfaceColumnSource(const FSurfaceGenerationParams& InP, int32 Seed,
                             const TArray<FSurfaceGenerationParams>& PerBiome,
                             TUniquePtr<IVoxelBiomeField> InField)
            : P(InP), BiomeParams(PerBiome), Field(MoveTemp(InField))
        {
            if (BiomeParams.Num() > 0)
            {
                // Chemin BIOMES : une pile complète par biome, sol mélangé / plafond sélectionné.
                TerrainStack.Add(VoxelHeightOps::MakeBiomeBlendHeightSource(BiomeParams, Seed, Field.Get()));
                CeilingStack.Add(VoxelHeightOps::MakeBiomeSelectCeilingSource(BiomeParams, Seed, Field.Get()));

                // Un champ structurel PAR BIOME : la pente de l'overhang doit venir du champ du
                // biome DOMINANT (l'original échantillonne `*PD`), pas d'un champ moyen.
                PerBiomeStructural.Reserve(BiomeParams.Num());
                for (const FSurfaceGenerationParams& BP : BiomeParams)
                {
                    const IVoxelHeightOp* Raw = nullptr;
                    PerBiomeStructural.Add(VoxelHeightOps::MakeStructuralHeightSource(BP, Seed, &Raw));
                }
                Structural = PerBiomeStructural.Num() > 0 ? PerBiomeStructural[0].Get() : nullptr;
            }
            else
            {
                BuildSingleBiome(InP, Seed);
            }

            // Identité unique et NON RECYCLÉE — la clé du mémo par colonne. `this` ne suffirait
            // pas : une pile détruite puis une autre allouée à la même adresse avec d'autres params
            // donnerait un faux positif silencieux. Un compteur qui ne redescend jamais l'interdit.
            // Assignée ICI et nulle part ailleurs : l'autre constructeur délègue à celui-ci.
            // A unique, never-recycled id — assigned here only; the other ctor delegates.
            static std::atomic<uint64> NextId{ 1 };
            InstanceId = NextId.fetch_add(1, std::memory_order_relaxed);

            // Départ sur l'identité D'INSTANCE, pas sur 0 : les entrées du mémo s'initialisent à
            // `Key = 0`, donc une clé nulle ferait FAUSSEMENT toucher le slot vierge en (0,0).
            // `PrepareChunk` remplacera ceci par la clé partagée de strate ; sans lui, on garde un
            // cache par instance — moins de partage, mais correct. Dégrader, jamais mentir.
            // Starting at the INSTANCE id rather than 0: slots initialise to Key = 0, so a zero key
            // would falsely hit the pristine slot at (0,0). PrepareChunk upgrades this to the shared
            // strate key; without it we simply cache per instance. Degrade, never lie.
            ColumnKey = InstanceId;

            // Empreinte des params qui déterminent une colonne. `FSurfaceGenerationParams` est du
            // POD pur (que des float/int/bool, vérifié : aucun TArray, FString ni pointeur), donc
            // un CRC mémoire ne peut pas produire de FAUX POSITIF — au pire du padding non
            // initialisé donne un faux NÉGATIF, c'est-à-dire un recalcul. Se tromper du côté qui
            // coûte du CPU plutôt que du côté qui rend une mauvaise colonne.
            // Pure POD (verified: no TArray/FString/pointer), so a memory CRC cannot produce a false
            // HIT; at worst padding causes a false miss, i.e. a recompute. Err toward CPU, not lies.
            ParamsFingerprint = FCrc::MemCrc32(&P, sizeof(P));
            for (const FSurfaceGenerationParams& BP : BiomeParams)
            {
                ParamsFingerprint = VoxelHash::Mix(ParamsFingerprint ^ FCrc::MemCrc32(&BP, sizeof(BP)));
            }
        }

        void BuildSingleBiome(const FSurfaceGenerationParams& InP, int32 Seed)
        {
            // Construite à la main (pas via BuildSurfaceHeightStack) pour GARDER le pointeur vers la
            // source structurelle : l'overhang en a besoin, pour son gradient de pente comme pour
            // son ré-échantillonnage amont. Même dépendance que le cliff, même raison.
            TerrainStack.Add(VoxelHeightOps::MakeStructuralHeightSource(InP, Seed, &Structural));
            TerrainStack.Add(VoxelHeightOps::MakeCliffHeightMod(InP, Structural));
            TerrainStack.Add(VoxelHeightOps::MakeTerraceHeightMod(InP));
            TerrainStack.Add(VoxelHeightOps::MakeLayerLineHeightMod(InP));
            TerrainStack.Add(VoxelHeightOps::MakeBeachHeightMod(InP));

            VoxelHeightOps::BuildSurfaceCeilingStack(CeilingStack, InP, Seed);
        }

        /** La colonne complète, exactement les cinq sorties de `ComputeSurfaceColumn`.
         *  Le mémo est un LRU spatial de six boîtes à index direct, comme `GSurfColCache` : la
         *  pile évalue tous les Z d'une colonne au même XY, donc l'overhang lit la MÊME colonne
         *  que la source, par construction plutôt que par convention.
         *
         *  The memo is a six-box spatial LRU with direct XY indexing, matching `GSurfColCache`.
         *  Six boxes retain interleaved strate regions at the cost of roughly 0.79 MiB of TLS for
         *  the five-float column payload plus one computed flag per cell, before compiler padding. */
        struct FColumn { float TerrainZ, CeilSurf, OverhangAmp, DirX, DirY; };

        const FColumn& GetColumn(float WorldX, float WorldY) const
        {
            // Même schéma éprouvé que `GSurfColCache` : six boîtes à index direct dans XY, chacune
            // avec un drapeau `Computed` par cellule et une clé uint64 exacte. Une tuile MC pleine
            // résolution demande 35×35 = 1225 colonnes (anneau de marge inclus) ; une boîte de
            // Dim×Dim, recentrée sur le premier échantillon, les garde toutes sans éviction.
            // Same proven scheme as `GSurfColCache`: six direct-indexed XY boxes, each with one
            // `Computed` flag per cell and an exact uint64 key. A full-resolution MC tile needs
            // 35×35 = 1225 columns including its margin ring; one Dim×Dim box holds that tile.
            struct FColumnBox
            {
                enum : int32 { Halo = CHUNK_SIZE + 8, Dim = 2 * Halo + 1 };
                int32 BaseX = 0, BaseY = 0;
                uint64 Key = 0;             // strate + layout + seed + ParamsFingerprint
                uint32 LastUse = 0;         // LRU stamp
                bool bValid = false;
                FColumn Cols[Dim * Dim];
                bool Computed[Dim * Dim];
            };

            struct FColumnCache
            {
                enum : int32 { NumBoxes = 6 };
                FColumnBox Boxes[NumBoxes];
                uint32 Clock = 0;

                // Hit exact : clé complète + couverture XY complète. En cas de miss, seul le
                // victim LRU est recentré et invalidé ; les cinq autres boîtes restent chaudes.
                // Exact hit: full key + full XY coverage. On a miss, only the LRU victim is
                // recentered and invalidated; the other five boxes remain warm.
                FColumnBox& Acquire(int32 IX, int32 IY, uint64 InColumnKey)
                {
                    ++Clock;
                    for (FColumnBox& B : Boxes)
                    {
                        if (B.bValid && B.Key == InColumnKey
                            && IX >= B.BaseX && IX < B.BaseX + FColumnBox::Dim
                            && IY >= B.BaseY && IY < B.BaseY + FColumnBox::Dim)
                        {
                            B.LastUse = Clock;
                            return B;
                        }
                    }

                    // Miss d'acquisition : évincer/recentrer une seule boîte, jamais tout le cache.
                    // Acquisition miss: evict/recenter one box only, never the whole cache.
                    FColumnBox* Victim = &Boxes[0];
                    for (FColumnBox& B : Boxes)
                    {
                        if (B.LastUse < Victim->LastUse) Victim = &B;
                    }
                    Victim->BaseX = IX - FColumnBox::Halo;
                    Victim->BaseY = IY - FColumnBox::Halo;
                    Victim->Key = InColumnKey;
                    Victim->LastUse = Clock;
                    Victim->bValid = true;
                    FMemory::Memzero(Victim->Computed, sizeof(Victim->Computed));
                    return *Victim;
                }
            };

            thread_local VoxelForgeCoreThreadLocal::FLazy<FColumnCache> Cache;
            FColumnCache& columnCache = Cache.Get();
            thread_local FColumn DirectColumn = {};

            // The production mesher and the exact-lattice classifier use integer XY. Fractional
            // XY is still valid for the public density/equivalence probes: compute it directly so
            // no integer cell can ever be returned for a different full (WorldX, WorldY) pair.
            const bool bIntegerXY = WorldX == FMath::FloorToFloat(WorldX)
                                 && WorldY == FMath::FloorToFloat(WorldY);
            FColumn* MemoColumn = &DirectColumn;
            // ⚠️ La boîte acquise doit survivre au `if` : le drapeau `Computed` n'est posé qu'APRÈS
            // le calcul, plus bas, hors de cette portée. Non nul ⇔ chemin XY entier.
            // The acquired box must outlive the `if`: the `Computed` flag is only set AFTER the
            // column is computed, further down and outside this scope. Non-null <=> integer path.
            FColumnBox* AcquiredBox = nullptr;
            int32 CI = 0;
            bool bNeedsCompute = true;

            if (bIntegerXY)
            {
                const int32 IX = (int32)WorldX;
                const int32 IY = (int32)WorldY;

                // Acquire vérifie la clé uint64 complète et les bornes exactes avant de dériver CI.
                // Acquire checks the exact uint64 key and exact bounds before deriving CI.
                FColumnBox& Box = columnCache.Acquire(IX, IY, ColumnKey);
                AcquiredBox = &Box;

                CI = (IY - Box.BaseY) * FColumnBox::Dim + (IX - Box.BaseX);
                MemoColumn = &Box.Cols[CI];
                if (Box.Computed[CI])
                {
                    INC_DWORD_STAT(STAT_VoxelForgeColumnMemoHit);
                    bNeedsCompute = false;
                }
                else
                {
                    INC_DWORD_STAT(STAT_VoxelForgeColumnMemoMiss);
                }
            }
            else
            {
                INC_DWORD_STAT(STAT_VoxelForgeColumnMemoMiss);
            }

            if (bNeedsCompute)
            {
                FColumn& C = *MemoColumn;

                C.TerrainZ = TerrainStack.EvalHeight(WorldX, WorldY);
                C.CeilSurf = CeilingStack.EvalHeight(WorldX, WorldY);
                C.OverhangAmp = 0.0f;  C.DirX = 0.0f;  C.DirY = 0.0f;

                // Gate d'overhang par colonne : pente issue d'une différence AVANT du champ
                // STRUCTUREL, à l'échelle de la portée mais CLAMPÉE à [4,16]. Sans ce clamp, une
                // grande `Reach` moyenne la pente sur une énorme portée et lit même une vraie
                // falaise comme plate — le bug « grande Reach = rien ». Transcrit tel quel.
                // Quel jeu de params gouverne cette colonne ? Sans biomes, `P`. Avec, le DOMINANT
                // pour la pente et le seuil, et une interpolation de l'AMPLITUDE vers le voisin —
                // exactement ce que fait `ComputeSurfaceColumn` (`Lerp(Amp(PD), Amp(PN), W)`, pente
                // depuis `*PD` seul). Interpoler la pente n'aurait pas de sens : c'est une mesure du
                // terrain, pas un réglage.
                const FSurfaceGenerationParams* PD = &P;
                const FSurfaceGenerationParams* PN = nullptr;
                float W = 0.0f;
                const IVoxelHeightOp* SlopeField = Structural;

                if (BiomeParams.Num() > 0 && Field)
                {
                    const FVoxelBiomeWeights BW = Field->SampleAt(WorldX, WorldY);
                    const int32 Di = BiomeParams.IsValidIndex(BW.Dominant) ? BW.Dominant : 0;
                    PD = &BiomeParams[Di];
                    if (PerBiomeStructural.IsValidIndex(Di)) { SlopeField = PerBiomeStructural[Di].Get(); }
                    if (BW.NeighborWeight > 0.0f && BiomeParams.IsValidIndex(BW.Neighbor))
                    {
                        PN = &BiomeParams[BW.Neighbor];
                        W  = BW.NeighborWeight;
                    }
                }

                const bool bAnyOverhang = (PD->OverhangStrength > 0.0f)
                                       || (PN && PN->OverhangStrength > 0.0f);

                if (bAnyOverhang && SlopeField != nullptr)
                {
                    const float SD = FMath::Clamp(PD->OverhangReach, 4.0f, 16.0f);
                    const float Z0 = SampleStructuralOf(SlopeField, WorldX, WorldY);
                    const float GX = (SampleStructuralOf(SlopeField, WorldX + SD, WorldY) - Z0) / SD;
                    const float GY = (SampleStructuralOf(SlopeField, WorldX, WorldY + SD) - Z0) / SD;
                    const float Slope = FMath::Sqrt(GX * GX + GY * GY);

                    auto Amp = [Slope](const FSurfaceGenerationParams& Q) -> float
                    {
                        if (Q.OverhangStrength <= 0.0f) { return 0.0f; }
                        const float Thr  = FMath::Max(Q.OverhangSlopeThreshold, 0.05f);
                        const float Gate = FMath::Clamp((Slope - Thr) / Thr, 0.0f, 1.0f);
                        return Q.OverhangStrength * Gate;   // [0,1]
                    };
                    C.OverhangAmp = (W > 0.0f && PN) ? FMath::Lerp(Amp(*PD), Amp(*PN), W) : Amp(*PD);

                    // Direction amont unitaire (le gradient pointe vers le haut). Dégénérée sur le
                    // plat — mais l'amplitude y vaut 0 de toute façon.
                    if (Slope > KINDA_SMALL_NUMBER) { C.DirX = GX / Slope; C.DirY = GY / Slope; }
                }

                if (AcquiredBox) { AcquiredBox->Computed[CI] = true; }
            }
            return *MemoColumn;
        }

        /** Le champ structurel nu — l'overhang s'en sert pour emprunter la roche amont.
         *  Avec des biomes, c'est celui du biome DOMINANT en ce point (l'original emprunte à `*PD`). */
        float SampleStructural(float WorldX, float WorldY) const
        {
            const IVoxelHeightOp* Src = Structural;
            if (BiomeParams.Num() > 0 && Field)
            {
                const FVoxelBiomeWeights BW = Field->SampleAt(WorldX, WorldY);
                const int32 Di = PerBiomeStructural.IsValidIndex(BW.Dominant) ? BW.Dominant : 0;
                if (PerBiomeStructural.IsValidIndex(Di)) { Src = PerBiomeStructural[Di].Get(); }
            }
            return SampleStructuralOf(Src, WorldX, WorldY);
        }

        static float SampleStructuralOf(const IVoxelHeightOp* Src, float WorldX, float WorldY)
        {
            if (!Src) { return 0.0f; }
            FVoxelHeightSample S;
            Src->Eval(WorldX, WorldY, S);
            return S.Height;
        }

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask ProvidedResources() const override { return VoxelOpResources::SurfaceColumn; }
        bool IsAdditive() const override { return false; }
        bool IsXYPure() const override { return false; }   // voir le bloc ci-dessus

        /**
         * ⚠️ C'EST ICI QUE SE JOUE LA PERF DE CET ARCHÉTYPE.
         *
         * Ne PAS clé ce mémo sur `InstanceId` : il change à CHAQUE reconstruction de pile,
         * c'est-à-dire à chaque chunk, et une strate haute de 4 chunks recalculerait ses colonnes
         * **4 fois**, resamples du cliff compris. `GSurfColCache` est clé sur
         * `(boîte XY, StrateKey, Seed, LayoutVersion)` **SANS ChunkZ**, délibérément, « shared down
         * the whole vertical strate stack ». Cette pile reprend la même identité de
         * strate/layout/seed, en ajoutant l'empreinte obligatoire des params pour protéger ses
         * sorties propres ; son mémo est un LRU spatial de six boîtes.
         *
         * Donc la clé garde l'identité partagée : ce qui rend deux colonnes interchangeables, c'est
         * la STRATE, le seed, la version de layout et les params, pas le chunk. Le mémo étant
         * `thread_local`, il SURVIT à la reconstruction de la pile — seule la clé l'invalide.
         *
         * POURQUOI C'EST SÛR : les hauteurs sont XY-pures par construction (c'est tout l'objet de
         * `VoxelHeightOp.h`, où le type n'a pas de Z), et le champ de biomes est documenté
         * XY-pur — « ZERO Z dependence: the climate/Voronoi fields are pure-XY ». C'est exactement
         * la justification sur laquelle `GSurfColCache` repose déjà.
         *
         * Do not key the memo on InstanceId: it changes every chunk, so a 4-chunk strate would
         * recompute every column 4x. GSurfColCache deliberately omits ChunkZ and shares down the whole
         * vertical stack; this shares the same strate/layout/seed identity and adds the required
         * params fingerprint for its own outputs. The six-box LRU keeps independent XY regions alive. Safe
         * because heights are XY-pure by type and the biome field is documented Z-independent.
         */
        void PrepareChunk(const FVoxelOpContext& Ctx) override
        {
            // `StrateBottomWorldZ` est unique par strate empilée — la même valeur que
            // `CP_StrateKey` utilise dans `GetDensityAt`. La version de layout entre dans la clé
            // (AUDIT §C2) : une édition à chaud qui change les params sans déplacer la strate doit
            // invalider, sinon on sert des colonnes périmées.
            const uint32 A = (uint32)FMath::RoundToInt(Ctx.StrateBottomWorldZ);
            const uint32 B = Ctx.LayoutVersion;
            const uint32 C = Ctx.Seed;

            // ⚠️ `ParamsFingerprint` EST OBLIGATOIRE, et son absence a été un vrai bug — attrapé par
            // `SurfaceHeightEquivalence` au build suivant (69/20000 écarts, 1 traversée d'iso).
            //
            // Sans lui, la clé ne contenait que (strate, layout, seed). Deux piles de la MÊME strate
            // avec des params DIFFÉRENTS obtenaient donc la même clé et se partageaient les colonnes :
            // la seconde lisait les colonnes de la première, calculées avec `OverhangAmp = 0`, et
            // l'overhang disparaissait purement et simplement.
            //
            // ET CE N'EST PAS QU'UN ARTEFACT DE TEST : c'est exactement la faiblesse que le code
            // documente déjà pour `GSurfColCache` (VoxelGenerator.cpp, note AUDIT §C2 étendue) —
            // « une édition à chaud qui change les params SANS déplacer la strate laisse la clé
            // identique et sert des colonnes périmées ». En production `LayoutVersion` bouge à chaque
            // `RebuildStrates`, ce qui masque le trou ; ma clé en avait hérité, et le test l'a trouvé
            // tout de suite. Empreinte incluse ⇒ le trou est fermé ici, pas seulement masqué.
            //
            // The fingerprint is REQUIRED: without it two stacks of the same strate with different
            // params shared columns, and the overhang silently vanished. Same weakness the codebase
            // already documents for GSurfColCache, which LayoutVersion merely masks.
            ColumnKey = ((uint64)VoxelHash::Mix(A ^ VoxelHash::Mix(B)) << 32)
                      |  (uint64)VoxelHash::Mix(C ^ VoxelHash::Mix(A) ^ ParamsFingerprint);
            if (ColumnKey == 0) { ColumnKey = 1; }   // 0 = « jamais préparé »
        }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            // Le mémo par colonne vit ici, dans six boîtes thread_local partagées par les instances
            // mais séparées par la clé, et lues par les Eval de cette source et FOverhangShelfMod.
            // Il est séparé de `GSurfColCache` : la pile possède ses propres sorties et sa clé
            // complète (strate + layout + seed + empreinte des params), donc réutiliser le cache
            // du générateur serait incorrect.
            // The per-column memo lives here in six thread-local boxes shared across instances but
            // separated by the key, and read by this source's Eval calls and FOverhangShelfMod.
            // It is separate from `GSurfColCache`: the stack owns its own outputs and full key.
            const FColumn& C = GetColumn(WorldX, WorldY);

            float Density = C.TerrainZ - WorldZ;
            Density = FMath::Max(Density, WorldZ - C.CeilSurf);
            InOut.Density = Density;   // Replace : interne, positif = solide
        }

        // Mixed, honnêtement. Un verdict exact demanderait de borner le heightfield structurel sur
        // la boîte XY (continents + montagnes + détail sous un domain-warp) — faisable, mais c'est
        // une vraie borne à dériver, pas une constante à lire comme pour la dalle. Rendre Mixed ne
        // coûte que du CPU ; rendre faux serait un trou. À faire quand `MaxDisplacement` saura
        // répondre pour la source structurelle.
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Both;
        }

    private:
        FSurfaceGenerationParams P;
        FVoxelHeightStack TerrainStack;
        FVoxelHeightStack CeilingStack;
        const IVoxelHeightOp* Structural = nullptr;   // NON possédant : la pile terrain le possède

        // Chemin BIOMES. Vide ⇒ chemin d'origine, inchangé bit pour bit.
        TArray<FSurfaceGenerationParams>     BiomeParams;
        TUniquePtr<IVoxelBiomeField>         Field;              // POSSÉDÉ (voir le constructeur)
        TArray<TUniquePtr<IVoxelHeightOp>>   PerBiomeStructural; // pente d'overhang par biome

        uint64 InstanceId = 0;   // unique, jamais recyclée — le repli quand PrepareChunk n'a pas eu lieu
        uint64 ColumnKey  = 0;   // l'identité PARTAGÉE (strate + layout + seed + params) : voir PrepareChunk
        uint32 ParamsFingerprint = 0;   // sans lui, deux piles de la même strate se volaient leurs colonnes
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : ÉTAGÈRE D'OVERHANG / OVERHANG SHELF  (le seul op vraiment 3D)
    //=========================================================================
    // Pour les voxels d'AIR dans une fenêtre juste au-dessus d'une pente raide, ré-échantillonne le
    // heightfield EN AMONT (vers la falaise) d'une distance qui CROÎT avec la hauteur, et fait
    // l'union de cette roche → la roche du haut de falaise déborde AU-DESSUS du vide, avec de l'air
    // EN DESSOUS : un vrai surplomb.
    //
    // ⚠️ Il dépend de Z de façon essentielle — `Frac` fait varier la portée avec l'altitude. C'est
    // le seul op de SurfaceWorld qui ne pouvait PAS vivre en espace-hauteur, et c'est exactement
    // pour ça que la frontière entre les deux espaces est utile : elle est passée là où le code
    // change de nature, pas là où c'était commode.
    //
    // The one op here that genuinely depends on Z (the uphill reach grows with height), which is
    // precisely why it could not live in height space. The boundary between the two spaces falls
    // where the code changes nature.
    class FOverhangShelfMod final : public IVoxelDensityOp
    {
    public:
        FOverhangShelfMod(const FSurfaceGenerationParams& InP, int32 Seed,
                          const FSurfaceColumnSource* InColumn)
            : P(InP), SeedU((uint32)Seed), Column(InColumn) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::SurfaceColumn; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        bool IsXYPure() const override { return false; }   // franchement non : voir `Frac`

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            if (Column == nullptr || P.OverhangHeight <= 0.0f) { return; }

            // Même colonne que la source, garantie par le mémo : pas une seconde évaluation.
            const FSurfaceColumnSource::FColumn& C = Column->GetColumn(WorldX, WorldY);
            if (C.OverhangAmp <= 0.0f) { return; }

            // Gate dur, transcrit : seulement les voxels d'air dans `OverhangHeight` du sol local.
            if (!(WorldZ > C.TerrainZ && WorldZ <= C.TerrainZ + P.OverhangHeight)) { return; }

            const float f = P.OverhangFrequency;
            // Bruit de forme d'étagère [0,1] ; le terme en Z fait onduler la portée avec la hauteur
            // (déchiqueté, pas une lèvre lisse).
            const float Ns = HFractal3D(FVector3f(
                WorldX * f + VoxelHash::SeedOffset(SeedU, 17.3f),
                WorldY * f + VoxelHash::SeedOffset(SeedU, 23.9f),
                WorldZ * f * P.OverhangZScale + VoxelHash::SeedOffset(SeedU, 5.1f)), 3) * 0.5f + 0.5f;   // [0,1]

            // LA CLÉ : la portée amont CROÎT avec la hauteur dans la fenêtre (Frac : 0 au sol → 1
            // au plafond de la fenêtre). En bas le décalage est minuscule ⇒ on emprunte de la roche
            // basse voisine ⇒ ça reste de l'AIR au-dessus du vide ; en haut le décalage atteint la
            // falaise ⇒ solide ⇒ la lèvre se pose dessus avec de l'air DESSOUS = un vrai surplomb.
            const float Frac   = (WorldZ - C.TerrainZ) / P.OverhangHeight;
            const float ShiftV = P.OverhangReach * C.OverhangAmp * Frac * Ns;
            if (ShiftV > 0.5f)
            {
                // On emprunte la hauteur STRUCTURELLE amont (pas la surface complète avec ops) :
                // le dessous de l'étagère n'a pas besoin du raffinement cliff/terrace, et ça évite
                // de relancer les 4 resamples du cliff par voxel de lèvre.
                const float ShiftedTZ = Column->SampleStructural(WorldX + C.DirX * ShiftV,
                                                                 WorldY + C.DirY * ShiftV);
                InOut.Density = FMath::Max(InOut.Density, ShiftedTZ - WorldZ);   // union
            }
        }

        // N'ajoute que du solide (`Max`) ⇒ tue AllAir, jamais AllSolid. Conservateur : on ne sait
        // pas sans échantillonner si une colonne d'overhang touche la boîte, donc FillOnly partout
        // où l'archétype peut en produire, Identity quand il est éteint.
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.OverhangStrength > 0.0f && P.OverhangHeight > 0.0f)
                 ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

    private:
        FSurfaceGenerationParams P;
        uint32 SeedU;
        const FSurfaceColumnSource* Column;   // NON possédant : la pile possède la source
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : RUGOSITÉ DE PAROI, ESPACE SDF
    //=========================================================================
    // La variante SDF (Maze / VerticalShafts / FloatingIslands) : `Sdf += bruit · échelle · force`.
    // Déplace la SURFACE. La variante densité de TunnelNetwork est un opérateur DIFFÉRENT (fade
    // quadratique, clamp anti-remplissage, 4 types de bruit) — voir OPSTACK-DECOMPOSITION §1.
    class FSdfRoughnessMod final : public IVoxelDensityOp
    {
    public:
        FSdfRoughnessMod(float InStrength, float InFrequency, int32 InBaseOctaves, float InApplyWithin)
            : Strength(InStrength), Frequency(InFrequency)
            , BaseOctaves(InBaseOctaves), ApplyWithin(InApplyWithin) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Sdf; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Sdf; }
        bool IsAdditive() const override { return false; } // gate depends on the SDF it writes
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            if (Strength <= 0.0f || InOut.Sdf >= ApplyWithin) { return; }

            // Keep hot noise coordinates in float. The old FVector round-trip only preserved
            // legacy rounding; output compatibility with that field is intentionally abandoned.
            const FVector3f NoisePos(WorldX * Frequency, WorldY * Frequency, WorldZ * Frequency);
            InOut.Sdf += VoxelNoise::FBM(NoisePos.X, NoisePos.Y, NoisePos.Z,
                                         VoxelGenLOD::Eff(BaseOctaves), 2.0f, 0.5f)
                       * VOXEL_NOISE_SCALE * Strength;
        }

        // This modifier does not touch density itself. Its interval update is the only box-query
        // responsibility; the downstream converter consumes the resulting interval.
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Identity;
        }

        void PropagateSdfOverBox(FVoxelBoxSdfInterval& InOut, const FBox& VoxelBox,
                                 const FVoxelOpContext&) const override
        {
            if (!InOut.IsKnown()) { return; }
            if (!VoxelMath::IsFinite(Strength) || !VoxelMath::IsFinite(Frequency)
                || !VoxelMath::IsFinite(ApplyWithin) || BaseOctaves <= 0)
            {
                InOut.SetUnknown();
                return;
            }
            if (Strength <= 0.0f) { return; }

            // If an authored frequency/box product overflows, Eval can publish a non-finite SDF
            // and no finite interval is a proof. Unknown costs the skip and protects the geometry.
            const float MaxAbsCoord = FMath::Max3(
                FMath::Max(FMath::Abs((float)VoxelBox.Min.X), FMath::Abs((float)VoxelBox.Max.X)),
                FMath::Max(FMath::Abs((float)VoxelBox.Min.Y), FMath::Abs((float)VoxelBox.Max.Y)),
                FMath::Max(FMath::Abs((float)VoxelBox.Min.Z), FMath::Abs((float)VoxelBox.Max.Z)));
            if (!VoxelMath::IsFinite(MaxAbsCoord) || !VoxelMath::IsFinite(MaxAbsCoord * FMath::Abs(Frequency)))
            {
                InOut.SetUnknown();
                return;
            }

            // The gate is `Sdf < ApplyWithin`. If the whole input interval is outside it, the
            // modifier is exactly the identity. Otherwise add the proven FBM envelope to both
            // sides; conditional untouched points are still covered by [Min, Max] + envelope.
            if (InOut.Min >= ApplyWithin) { return; }

            const float Amplitude = FMath::Abs(Strength) * VOXEL_NOISE_SCALE * VF_PerlinAbsBound;
            InOut.Min = VF_SaturatingAdd(InOut.Min, -Amplitude);
            InOut.Max = VF_SaturatingAdd(InOut.Max,  Amplitude);
        }

    private:
        float Strength, Frequency;
        int32 BaseOctaves;
        float ApplyWithin;
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : COLONNES SUR GRILLE MONDE / WORLD-GRID COLUMNS
    //=========================================================================
    // Des cylindres de hauteur infinie posés sur une grille de
    // `ColumnSpacing`, un tirage d'existence et un jitter par cellule. Le champ de vide décide déjà
    // où est le solide, donc la colonne n'a qu'à AJOUTER de la densité le long de son XY — elle
    // n'est visible que là où le vide avait creusé autour d'elle.
    //
    // Le cache 3×3 par cellule est `thread_local`, ce que la note de threading de VoxelDensityOp.h
    // autorise. Sa clé
    // contient tous les paramètres qui influent sur le résultat + le seed, donc un changement de
    // layout qui change un param invalide bien ; un changement qui n'en touche aucun produirait
    // des colonnes identiques (cf. AUDIT C2 — la clé est complète, pas seulement le coord).
    class FGridColumnMod final : public IVoxelDensityOp
    {
    public:
        explicit FGridColumnMod(const FSlabGenerationParams& P, int32 InSeed)
            : Seed((uint32)InSeed)
            , Spacing(P.ColumnSpacing)
            , ColDensity(P.ColumnDensity)
            , MinRadius(P.ColumnMinRadius)
            , MaxRadius(P.ColumnMaxRadius)
            , BaseDensity(P.BaseDensity)
        {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        bool IsXYPure() const override { return true; }   // cylindres de hauteur infinie

        void Eval(float WorldX, float WorldY, float, FVoxelOpSample& InOut) const override
        {
            if (ColDensity <= 0.0f || Spacing <= 0.0f) { return; }

            const int32 ColCX = FMath::FloorToInt(WorldX / Spacing);
            const int32 ColCY = FMath::FloorToInt(WorldY / Spacing);

            const TArray<FSlabColumn, TInlineAllocator<9>>& Cols = GetCells(ColCX, ColCY);

            float ColumnSDF = FLT_MAX;
            for (const FSlabColumn& Col : Cols)
            {
                const float DX2D = WorldX - Col.X;
                const float DY2D = WorldY - Col.Y;
                ColumnSDF = FMath::Min(ColumnSDF, FMath::Sqrt(DX2D * DX2D + DY2D * DY2D) - Col.R);
            }

            if (ColumnSDF < ColBlend && ColumnSDF < FLT_MAX)
            {
                float Fill = FMath::Clamp((ColBlend - ColumnSDF) / (ColBlend * 2.0f), 0.0f, 1.0f);
                Fill = SmoothStep01(Fill);
                InOut.Density += Fill * BaseDensity * 1.5f;
            }
        }

        // N'AJOUTE que du solide ⇒ tue AllAir, jamais AllSolid. `Identity` dès qu'aucune colonne
        // n'atteint la boîte — ce qui, pour un `ColumnDensity` de 0.08, est l'écrasante majorité du
        // volume. C'est cet `Identity` qui laisse survivre le verdict AllAir de la source.
        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext&) const override
        {
            if (ColDensity <= 0.0f || Spacing <= 0.0f) { return EVoxelOpEffect::Identity; }

            // Marge : l'enveloppe de `Lerp(MinRadius, MaxRadius, t)` est max(MinRadius, MaxRadius),
            // pas `MaxRadius` seul si l'asset inverse les paramètres. The bound must cover both
            // endpoints; using `MaxRadius` alone would leave a hole when the asset reverses them.
            const float Reach = FMath::Max3(MinRadius, MaxRadius, 0.0f) + ColBlend;

            const int32 CX0 = FMath::FloorToInt(((float)VoxelBox.Min.X - Reach) / Spacing);
            const int32 CX1 = FMath::FloorToInt(((float)VoxelBox.Max.X + Reach) / Spacing);
            const int32 CY0 = FMath::FloorToInt(((float)VoxelBox.Min.Y - Reach) / Spacing);
            const int32 CY1 = FMath::FloorToInt(((float)VoxelBox.Max.Y + Reach) / Spacing);

            for (int32 CY = CY0; CY <= CY1; ++CY)
            {
                for (int32 CX = CX0; CX <= CX1; ++CX)
                {
                    FSlabColumn Col;
                    if (!RollColumn(CX, CY, Col)) { continue; }

                    // Cercle (rayon + blend) contre le rectangle XY de la boîte.
                    const float R  = Col.R + ColBlend;
                    const float QX = FMath::Max(0.0f, FMath::Max((float)VoxelBox.Min.X - Col.X,
                                                                 Col.X - (float)VoxelBox.Max.X));
                    const float QY = FMath::Max(0.0f, FMath::Max((float)VoxelBox.Min.Y - Col.Y,
                                                                 Col.Y - (float)VoxelBox.Max.Y));
                    if (QX * QX + QY * QY < R * R) { return EVoxelOpEffect::FillOnly; }
                }
            }
            return EVoxelOpEffect::Identity;
        }

    private:
        struct FSlabColumn { float X, Y, R; };

        static constexpr float ColBlend = 2.0f;

        /** Le tirage d'une cellule : existence, jitter, rayon. Fonction PURE de (cellule, seed,
         *  params) — donc `Eval` et `EffectOverBox` voient forcément la même colonne. */
        bool RollColumn(int32 CX, int32 CY, FSlabColumn& Out) const
        {
            const uint32 H = VoxelHash::Cell(CX, CY, Seed ^ 0xC01C01u);
            if (VoxelHash::ToFloat01(H) > ColDensity) { return false; }

            const float JX = VoxelHash::ToFloat01(VoxelHash::Mix(H ^ 0x12345678u));
            const float JY = VoxelHash::ToFloat01(VoxelHash::Mix(H ^ 0x9ABCDEF0u));

            Out.X = (CX + 0.15f + JX * 0.7f) * Spacing;
            Out.Y = (CY + 0.15f + JY * 0.7f) * Spacing;
            Out.R = FMath::Lerp(MinRadius, MaxRadius,
                                VoxelHash::ToFloat01(VoxelHash::Mix(H ^ 0xBEEFu)));
            return true;
        }

        /** Le voisinage 3×3 de la cellule centrale, mémoïsé par worker. */
        const TArray<FSlabColumn, TInlineAllocator<9>>& GetCells(int32 ColCX, int32 ColCY) const
        {
            thread_local TArray<FSlabColumn, TInlineAllocator<9>> SC_Cols;
            thread_local int32  SC_CX = INT32_MAX, SC_CY = INT32_MAX;
            thread_local uint32 SC_Seed = 0xFFFFFFFFu;
            thread_local float  SC_Spacing = -1.0f, SC_Dens = -1.0f, SC_MinR = -1.0f, SC_MaxR = -1.0f;

            if (ColCX != SC_CX || ColCY != SC_CY || Seed != SC_Seed || Spacing != SC_Spacing ||
                ColDensity != SC_Dens || MinRadius != SC_MinR || MaxRadius != SC_MaxR)
            {
                SC_CX = ColCX;  SC_CY = ColCY;  SC_Seed = Seed;  SC_Spacing = Spacing;
                SC_Dens = ColDensity;  SC_MinR = MinRadius;  SC_MaxR = MaxRadius;
                SC_Cols.Reset();

                for (int32 DY = -1; DY <= 1; DY++)
                {
                    for (int32 DX = -1; DX <= 1; DX++)
                    {
                        FSlabColumn Col;
                        if (RollColumn(ColCX + DX, ColCY + DY, Col)) { SC_Cols.Add(Col); }
                    }
                }
            }
            return SC_Cols;
        }

        uint32 Seed;
        float  Spacing, ColDensity, MinRadius, MaxRadius, BaseDensity;
    };

    //=========================================================================
    // RÔLE 2 — COMBINER : SDF → DENSITÉ (CARVE et FILL)
    //=========================================================================
    // Les six mêmes lignes dans TunnelNetwork, Maze, VerticalShafts — et FloatingIslands, où le
    // SEUL changement est `Density += Fill·Base·2` au lieu de `Density -= Carve·Base·2`.
    //
    // Un archétype qui CREUSE dans du roc et un archétype qui REMPLIT du vide sont donc le même
    // opérateur au signe près, exactement comme la source constante au-dessus.
    //
    // ⚠️ `Sign` vaut ±1.0f et rien d'autre. La multiplication par ±1 est EXACTE en IEEE-754, donc
    // `D += (-1·F)·B·2` rend bit pour bit ce que `D -= F·B·2` rendait — l'égalité binaire des trois
    // portages déjà verts en dépend.
    //
    // Same operator, opposite sign. Multiplying by ±1 is exact in IEEE-754, so the carve path is
    // bit-for-bit what it was before this generalisation — the three green ports depend on that.
    class FSdfConvertOp final : public IVoxelDensityOp
    {
    public:
        FSdfConvertOp(float InBlend, float InBaseDensity, float InSign, float InMinDivisor)
            : Blend(InBlend), BaseDensity(InBaseDensity), Sign(InSign), MinDivisor(InMinDivisor) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::Combiner; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float, float, float, FVoxelOpSample& InOut) const override
        {
            if (InOut.Sdf >= Blend) { return; }
            // ⚠️ `MinDivisor` n'est PAS une précaution ajoutée : TunnelNetwork écrit
            // `/ FMath::Max(SDFBlendRadius * 2, 1.0f)` là où Maze/Shafts/Islands écrivent `/ (Blend*2)`.
            // Les deux formules DIVERGENT dès que `Blend·2 < 1`, donc les confondre serait une faute
            // de portage silencieuse. Avec `MinDivisor = 0` et un Blend positif, `Max(x, 0) == x`
            // exactement — les trois portages déjà verts ne bougent pas d'un bit.
            // Not a safety tweak: TunnelNetwork genuinely floors this divisor at 1 and the others
            // do not. Max(x, 0) is exactly x for positive Blend, so existing ports are untouched.
            float T = FMath::Clamp((Blend - InOut.Sdf) / FMath::Max(Blend * 2.0f, MinDivisor), 0.0f, 1.0f);
            T = SmoothStep01(T);
            InOut.Density += Sign * T * BaseDensity * 2.0f;   // interne : monter = vers le solide
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            const float Coefficient = Sign * BaseDensity * 2.0f;
            if (!VoxelMath::IsFinite(Coefficient) || !VoxelMath::IsFinite(Blend)
                || !VoxelMath::IsFinite(MinDivisor) || Blend <= 0.0f)
            {
                return EVoxelOpEffect::Both;
            }
            if (Coefficient < 0.0f) { return EVoxelOpEffect::CarveOnly; }
            if (Coefficient > 0.0f) { return EVoxelOpEffect::FillOnly; }
            return EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            const EVoxelOpEffect Intrinsic = EffectOverBox(VoxelBox, Ctx);
            if (Intrinsic == EVoxelOpEffect::Both || Intrinsic == EVoxelOpEffect::Identity)
            {
                return Intrinsic;
            }
            return H.Sdf.IsKnown() && H.Sdf.Min >= Blend
                 ? EVoxelOpEffect::Identity : Intrinsic;
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            const float Coefficient = Sign * BaseDensity * 2.0f;
            if (!VoxelMath::IsFinite(Coefficient) || !VoxelMath::IsFinite(Blend)
                || !VoxelMath::IsFinite(MinDivisor) || Blend <= 0.0f)
            {
                return FLT_MAX;
            }
            return Coefficient < 0.0f ? FMath::Abs(Coefficient) : 0.0f;
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            const float Coefficient = Sign * BaseDensity * 2.0f;
            if (!VoxelMath::IsFinite(Coefficient) || !VoxelMath::IsFinite(Blend)
                || !VoxelMath::IsFinite(MinDivisor) || Blend <= 0.0f)
            {
                return FLT_MAX;
            }
            return Coefficient > 0.0f ? FMath::Abs(Coefficient) : 0.0f;
        }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            const float Coefficient = Sign * BaseDensity * 2.0f;
            if (!VoxelMath::IsFinite(Coefficient)) { return FLT_MAX; }
            if (!VoxelMath::IsFinite(Blend) || !VoxelMath::IsFinite(MinDivisor) || Blend <= 0.0f)
            {
                return FLT_MAX;
            }
            if (Coefficient >= 0.0f) { return 0.0f; }
            return IsInactive(H) ? 0.0f : FMath::Abs(Coefficient) * MaxFactor(H);
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                             const FVoxelBoxHypotheses& H) const override
        {
            const float Coefficient = Sign * BaseDensity * 2.0f;
            if (!VoxelMath::IsFinite(Coefficient)) { return FLT_MAX; }
            if (!VoxelMath::IsFinite(Blend) || !VoxelMath::IsFinite(MinDivisor) || Blend <= 0.0f)
            {
                return FLT_MAX;
            }
            if (Coefficient <= 0.0f) { return 0.0f; }
            return IsInactive(H) ? 0.0f : FMath::Abs(Coefficient) * MaxFactor(H);
        }

        const TCHAR* DebugName() const override { return TEXT("SdfConvertOp"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        bool IsInactive(const FVoxelBoxHypotheses& H) const
        {
            return !H.Sdf.IsKnown() ? false : H.Sdf.Min >= Blend;
        }

        float MaxFactor(const FVoxelBoxHypotheses& H) const
        {
            if (!H.Sdf.IsKnown() || !VoxelMath::IsFinite(Blend)
                || !VoxelMath::IsFinite(MinDivisor) || Blend <= 0.0f)
            {
                return 1.0f;
            }

            const float Denom = FMath::Max(Blend * 2.0f, MinDivisor);
            if (!(Denom > 0.0f) || !VoxelMath::IsFinite(Denom)) { return 1.0f; }

            const float T = FMath::Clamp((Blend - H.Sdf.Min) / Denom, 0.0f, 1.0f);
            return SmoothStep01(T);
        }

        float Blend, BaseDensity, Sign, MinDivisor;
    };

    //=========================================================================
    // RÔLE 4 — STRUCTUREL : SPINE (0,0)
    //=========================================================================
    class FOriginSpineOp final : public IVoxelDensityOp
    {
    public:
        FOriginSpineOp(float InTopZ, float InBotZ, float InSeal, float InBase, float InRadius)
            : TopZ(InTopZ), BotZ(InBotZ), Seal(InSeal), Base(InBase), Radius(InRadius) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::StructuralPost; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float X, float Y, float Z, FVoxelOpSample& InOut) const override
        {
            VF_ApplyOriginSpine(InOut.Density, X, Y, Z, TopZ, BotZ, Seal, Base, Radius);
        }

        // The room kills AllSolid; its support slab also kills AllAir. Identity when the room
        // misses the box or the box is wholly outside this strate's safe interior.
        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox,
                                     const FVoxelOpContext& Ctx) const override
        {
            if (VoxelDensityAblation::IsOriginSpineOff())
            {
                return EVoxelOpEffect::Identity;
            }
            const bool bRoomTouches = Ctx.bUseLatticeProof
                ? VoxelPassageGeometry::OriginLandingRoomTouchesLattice(
                    VoxelBox, Ctx.LatticeOriginVoxels, Ctx.Step,
                    TopZ, BotZ, Seal, Radius)
                : VoxelPassageGeometry::OriginLandingRoomTouchesBox(
                    VoxelBox, TopZ, BotZ, Seal, Radius);
            if (!bRoomTouches)
            {
                return EVoxelOpEffect::Identity;
            }
            const bool bFloorTouches = Ctx.bUseLatticeProof
                ? VoxelPassageGeometry::OriginLandingFloorTouchesLattice(
                    VoxelBox, Ctx.LatticeOriginVoxels, Ctx.Step,
                    TopZ, BotZ, Seal, Radius)
                : VoxelPassageGeometry::OriginLandingFloorTouchesBox(
                    VoxelBox, TopZ, BotZ, Seal, Radius);
            return bFloorTouches
                ? EVoxelOpEffect::Both : EVoxelOpEffect::CarveOnly;
        }

        // The landing carve interpolates from the incoming density toward an air target, so its
        // delta is unbounded without an input-density interval.  It is nevertheless exactly
        // inactive outside the geometric influence box; return zero there so an unrelated block
        // does not inherit the interface's conservative FLT_MAX sentinel.
        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            const EVoxelOpEffect Effect = EffectOverBox(VoxelBox, Ctx);
            return (Effect == EVoxelOpEffect::CarveOnly || Effect == EVoxelOpEffect::Both)
                 ? FLT_MAX : 0.0f;
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            return EffectOverBox(VoxelBox, Ctx) == EVoxelOpEffect::Both ? FLT_MAX : 0.0f;
        }

        const TCHAR* DebugName() const override { return TEXT("OriginSpineOp"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        float TopZ, BotZ, Seal, Base, Radius;
    };

    //=========================================================================
    // RÔLE 4 — STRUCTUREL : SEAL DE FRONTIÈRE (l'opérateur FORÇANT)
    //=========================================================================
    class FBoundarySealOp final : public IVoxelDensityOp
    {
    public:
        FBoundarySealOp(float InTopZ, float InBotZ, float InThickness, float InBase)
            : TopZ(InTopZ), BotZ(InBotZ), Thickness(InThickness), Base(InBase) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::StructuralPost; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float, float, float Z, FVoxelOpSample& InOut) const override
        {
            VF_ApplyBoundarySeal(InOut.Density, Z, TopZ, BotZ, Thickness, Base);
        }

        /**
         * Dans sa bande, le seal fait `Max(D, SealFactor·Base)` avec SealFactor > 0 : le résultat
         * est solide GARANTI quelle qu'ait été l'entrée. C'est un opérateur FORÇANT, et la raison
         * d'être de `ClassifyBox` (voir VoxelDensityOp.h).
         *
         * ⚠️ MARGE DE SÛRETÉ DÉLIBÉRÉE. Au bord INTÉRIEUR de la bande, `1 - Dist/Thickness` peut
         * arrondir à exactement 0.0f en float ; SealFactor·Base vaut alors 0, la densité interne
         * finit à 0, et le mesher (`D >= IsoLevel`) compte ce point du côté AIR. Prétendre AllSolid
         * là serait un TROU. On exige donc que la boîte soit dans la bande avec 1 voxel de marge
         * avant de forcer ; sinon on retombe sur le FillOnly, qui est toujours sûr.
         *
         * (Le `ClassifyTile` actuel n'a pas cette marge — il exclut simplement ces z du test de
         * colonne. La fenêtre est infime et demande que l'archétype produise de l'air pile à ce z,
         * mais elle est réelle.)
         */
        EVoxelTileClass ClassifyBox(const FBox& VoxelBox, const FVoxelOpContext&) const override
        {
            if (VoxelDensityAblation::IsBoundarySealOff())
            {
                return EVoxelTileClass::Mixed;
            }
            if (Thickness <= 0.0f || Base <= 0.0f) { return EVoxelTileClass::Mixed; }

            constexpr float SafetyMargin = 1.0f;
            const float Usable = Thickness - SafetyMargin;
            if (Usable <= 0.0f) { return EVoxelTileClass::Mixed; }

            const float MinDistTop = TopZ - (float)VoxelBox.Min.Z;   // plus petite distance au plafond
            const float MaxDistTop = TopZ - (float)VoxelBox.Max.Z;
            const bool bWhollyInTopBand = (MaxDistTop >= 0.0f) && (MinDistTop < Usable);

            const float MinDistBot = (float)VoxelBox.Min.Z - BotZ;
            const float MaxDistBot = (float)VoxelBox.Max.Z - BotZ;
            const bool bWhollyInBotBand = (MinDistBot >= 0.0f) && (MaxDistBot < Usable);

            return (bWhollyInTopBand || bWhollyInBotBand) ? EVoxelTileClass::AllSolid
                                                          : EVoxelTileClass::Mixed;
        }

        // Hors de sa bande, le seal ne fait rien du tout ; à cheval, il ne peut qu'ajouter du solide.
        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext&) const override
        {
            if (VoxelDensityAblation::IsBoundarySealOff())
            {
                return EVoxelOpEffect::Identity;
            }
            if (Thickness <= 0.0f) { return EVoxelOpEffect::Identity; }
            const bool bTouchesTopBand = ((float)VoxelBox.Max.Z >= TopZ - Thickness) && ((float)VoxelBox.Min.Z <= TopZ);
            const bool bTouchesBotBand = ((float)VoxelBox.Min.Z <= BotZ + Thickness) && ((float)VoxelBox.Max.Z >= BotZ);
            if (!bTouchesTopBand && !bTouchesBotBand) { return EVoxelOpEffect::Identity; }
            return EVoxelOpEffect::FillOnly;
        }

        // A partial seal can raise an arbitrarily negative incoming density, so its fill delta is
        // genuinely unbounded through this API.  Outside both bands it is an exact identity.
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            return EffectOverBox(VoxelBox, Ctx) == EVoxelOpEffect::Identity ? 0.0f : FLT_MAX;
        }

        const TCHAR* DebugName() const override { return TEXT("BoundarySealOp"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        float TopZ, BotZ, Thickness, Base;
    };

    //=========================================================================
    // RÔLE 4 — STRUCTUREL : SCELLEMENT DE LA LIMITE XY (opérateur FORÇANT)
    //=========================================================================
    class FXYEdgeSealOp final : public IVoxelDensityOp
    {
    public:
        explicit FXYEdgeSealOp(float InBase)
            : Base(InBase) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::StructuralPost; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return false; }

        void PrepareChunk(const FVoxelOpContext& Ctx) override
        {
            // The settings are global, but PrepareChunk is the stack's one per-chunk hand-off.
            // Keeping the prepared copy makes Eval hot and keeps the op independent of the asset.
            WorldRadius = Ctx.WorldRadiusVoxels;
            Thickness    = Ctx.EdgeSealThickness;
        }

        void Eval(float X, float Y, float, FVoxelOpSample& InOut) const override
        {
            VF_ApplyXYEdgeSeal(InOut.Density, X, Y, WorldRadius, Thickness, Base);
        }

        /**
         * The seal is forcing, not merely FillOnly: once every point in the box is at least one
         * voxel into the ramp (or beyond the radius), the result is positive-solid regardless of
         * all preceding source/carve operators.
         */
        EVoxelTileClass ClassifyBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            if (VoxelDensityAblation::IsXYEdgeSealOff())
            {
                return EVoxelTileClass::Mixed;
            }
            return VF_XYEdgeSealBoxIsForcedSolid(
                VoxelBox, Ctx.WorldRadiusVoxels, Ctx.EdgeSealThickness, Base)
                ? EVoxelTileClass::AllSolid : EVoxelTileClass::Mixed;
        }

        float ForcedMarginOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            return VF_XYEdgeSealForcedMarginOverBox(
                VoxelBox, Ctx.WorldRadiusVoxels, Ctx.EdgeSealThickness, Base);
        }

        // In the inner world it is Identity; a box that reaches the radial band can only gain rock.
        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            if (VoxelDensityAblation::IsXYEdgeSealOff())
            {
                return EVoxelOpEffect::Identity;
            }
            return VF_XYEdgeSealBoxTouchesBand(
                VoxelBox, Ctx.WorldRadiusVoxels, Ctx.EdgeSealThickness)
                 ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            return EffectOverBox(VoxelBox, Ctx) == EVoxelOpEffect::Identity ? 0.0f : FLT_MAX;
        }

        bool IsXYPure() const override { return true; }
        const TCHAR* DebugName() const override { return TEXT("XYEdgeSealOp"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        float Base = 8.0f;
        mutable float WorldRadius = 8192.0f;
        mutable float Thickness = 64.0f;
    };

    //=========================================================================
    // RÔLE 4 — STRUCTUREL : CARVE DE PASSAGE
    //=========================================================================
    class FPassageCarveOp final : public IVoxelDensityOp
    {
    public:
        FPassageCarveOp(const UVoxelStrateManager* InManager, float InBase, float InSeal,
                        float InTopZ, float InBotZ, float InSpineRadius)
            : Manager(InManager), Base(InBase), Seal(InSeal),
              TopZ(InTopZ), BotZ(InBotZ), SpineRadius(InSpineRadius) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::StructuralPost; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float X, float Y, float Z, FVoxelOpSample& InOut) const override
        {
            if (const UVoxelStrateManager* LiveManager = Manager.Get())
            {
                // Landing/tunnel support is a shared MC-space post after disturbances. Calling the
                // legacy full modifier here repeats those same writers before the shared post.
                LiveManager->ApplyPassageCarvingOnly(InOut.Density, X, Y, Z, Base, Seal);
            }
            // Keep the source and op-stack operation order identical: the origin room is carved
            // before the boundary seal, then its support floor is reasserted after the passage
            // post so no passage-air post can remove the standing surface.
            VF_ApplyOriginLandingFloor(
                InOut.Density, X, Y, Z, TopZ, BotZ, Seal, Base, SpineRadius);
        }

        // ≡ la garde `AnyPassageNearBox` écrite à la main dans ClassifyTile — déjà écrite, ici
        // simplement branchée au bon endroit au lieu d'être un cas particulier du classifieur.
        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox,
                                     const FVoxelOpContext& Ctx) const override
        {
            if (VoxelDensityAblation::IsPassageCarvingOff()
                && VoxelDensityAblation::IsLandingPostsOff()
                && VoxelDensityAblation::IsPassageStructuralPostsOff()
                && VoxelDensityAblation::IsOriginSpineOff())
            {
                return EVoxelOpEffect::Identity;
            }
            const UVoxelStrateManager* LiveManager = Manager.Get();
            if (!LiveManager) { return EVoxelOpEffect::Identity; }
            const bool bOriginFloor = !VoxelDensityAblation::IsLandingPostsOff()
                && (Ctx.bUseLatticeProof
                    ? VoxelPassageGeometry::OriginLandingFloorTouchesLattice(
                        VoxelBox, Ctx.LatticeOriginVoxels, Ctx.Step,
                        TopZ, BotZ, Seal, SpineRadius)
                    : VoxelPassageGeometry::OriginLandingFloorTouchesBox(
                        VoxelBox, TopZ, BotZ, Seal, SpineRadius));
            const bool bPassageFloor = !VoxelDensityAblation::IsLandingPostsOff()
                && (Ctx.bUseLatticeProof
                    ? LiveManager->AnyPassageLandingFloorNearLattice(
                        VoxelBox, Ctx.LatticeOriginVoxels, Ctx.Step)
                    : LiveManager->AnyPassageLandingFloorNearBox(
                        VoxelBox.Min, VoxelBox.Max));
            if (bOriginFloor || bPassageFloor)
            {
                // The room carves air, while its support slab force-writes solid. Both
                // hypotheses must therefore be killed for a box touching that slab.
                return EVoxelOpEffect::Both;
            }
            const bool bPassageCarve = !VoxelDensityAblation::IsPassageCarvingOff()
                && (Ctx.bUseLatticeProof
                    ? LiveManager->AnyPassageNearLattice(
                        VoxelBox, Ctx.LatticeOriginVoxels, Ctx.Step)
                    : LiveManager->AnyPassageNearBox(VoxelBox.Min, VoxelBox.Max));
            return bPassageCarve
                 ? EVoxelOpEffect::CarveOnly : EVoxelOpEffect::Identity;
        }

        // The current-density Lerp/Min passage carve has no finite delta bound for an arbitrary
        // incoming density.  Once the preceding stack has proved a positive solid margin,
        // however, the monotone carve can be bounded exactly on the MC lattice: evaluate the
        // largest carve factor, apply it to the lower input bound, and keep the resulting positive
        // margin.  This preserves the old conservative fallback for non-lattice callers.
        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            if (VoxelDensityAblation::IsPassageCarvingOff())
            {
                return 0.0f;
            }
            const UVoxelStrateManager* LiveManager = Manager.Get();
            if (!LiveManager) { return 0.0f; }
            if (!Ctx.bUseLatticeProof)
            {
                const EVoxelOpEffect Effect = EffectOverBox(VoxelBox, Ctx);
                return (Effect == EVoxelOpEffect::CarveOnly || Effect == EVoxelOpEffect::Both)
                     ? FLT_MAX : 0.0f;
            }

            const float MaxFactor = LiveManager->MaxPassageCarveFactorNearLattice(
                VoxelBox, Ctx.LatticeOriginVoxels, Ctx.Step);
            if (!(MaxFactor > 0.0f)) { return 0.0f; }
            if (!(H.SolidMargin > 0.0f) || !VoxelMath::IsFinite(H.SolidMargin)
                || !VoxelMath::IsFinite(Base) || !VoxelMath::IsFinite(Seal))
            {
                return FLT_MAX;
            }

            const float AirTarget = -(Base * 2.0f + Seal + 4.0f);
            if (!VoxelMath::IsFinite(AirTarget)) { return FLT_MAX; }
            const float LowerAfterCarve = FMath::Min(
                H.SolidMargin,
                FMath::Lerp(H.SolidMargin, AirTarget, FMath::Clamp(MaxFactor, 0.0f, 1.0f)));
            if (!VoxelMath::IsFinite(LowerAfterCarve)) { return FLT_MAX; }
            return FMath::Max(0.0f, H.SolidMargin - LowerAfterCarve);
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx) const override
        {
            return EffectOverBox(VoxelBox, Ctx) == EVoxelOpEffect::Both ? FLT_MAX : 0.0f;
        }

        const TCHAR* DebugName() const override { return TEXT("PassageCarveOp"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        TWeakObjectPtr<const UVoxelStrateManager> Manager;
        float Base, Seal, TopZ, BotZ, SpineRadius;
    };

    //=========================================================================
    // RÔLE 1 — SOURCE : PUITS VERTICAUX / VERTICAL SHAFTS
    //=========================================================================
    // Cylindres infinis sur une grille XY jitterée + un arbre de drainage déterministe, complété
    // par des connecteurs horizontaux entre paires proches ouverts par un hash de paire. Écrit le
    // canal SDF uniquement.
    //
    // ⚠️ ÉCART ASSUMÉ AVEC `OPSTACK-DECOMPOSITION §6`, qui suggérait DEUX sources (colonnes XY-pures
    // + connecteurs) pour que la moitié cylindrique reçoive le traitement du cache de colonne et un
    // `ClassifyBox` exact en XY. Gardé en UN opérateur, et voici pourquoi :
    //   • les connecteurs se dérivent de la MÊME liste inner 3×3 que les puits (il faut les paires), donc
    //     séparer imposerait soit de rouler les cellules deux fois, soit un cache partagé entre
    //     deux ops — c'est-à-dire la complexité qu'on voulait éviter ;
    //   • le `FShaftLedgeMod` en aval a de toute façon besoin de la liste des puits, donc il faut
    //     l'exposer depuis une source ; l'exposer depuis deux serait pire.
    // Ce qui est perdu : le verdict de boîte exact sur la seule moitié cylindrique. Le compromis
    // actuel est une propagation d'intervalle qui couvre cercles ET capsules, tandis que le
    // `EffectOverBox` intrinsèque reste Identity : le convertisseur ou consommateur aval décide
    // séparément de son propre effet.
    //
    // Kept as ONE op against §6's suggestion: the per-voxel connectors derive from the same inner
    // 3×3 roll as the shafts, while a rebuild-only 9×9 collection resolves each 5×5 tree window
    // and fixed ±3 fallback;
    // the downstream ledge mod needs the inner shaft list anyway. What is forfeited is an exact XY
    // box verdict on the cylinder half alone.
    class FShaftFieldSource final : public IVoxelDensityOp
    {
    public:
        FShaftFieldSource(const FVerticalShaftParams& InP, int32 Seed, float InSpineRadius)
            : P(InP), Salt((uint32)Seed ^ 0x53686674u)   // 'Shft'
            , SpineRadius(InSpineRadius) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Sdf; }
        EVoxelOpResourceMask ProvidedResources() const override { return VoxelOpResources::ShaftGeometry; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        struct FShaft { float X, Y, R; int32 CellX, CellY; bool bOriginSpine; };
        struct FConn
        {
            FVector A, B;
            float Radius = 0.0f;
            float FloorZ = 0.0f;
            bool bWalkableFloor = false;
        };

        // ⚠️ DÉCLARÉE ICI, avant toute fonction qui la renvoie. Un type imbriqué doit exister au
        // moment où le COMPILATEUR lit la SIGNATURE — les corps de méthodes sont différés, pas les
        // types de retour. La mettre en bas de la classe donne un C4430 « int par défaut » suivi
        // d'une cascade illisible, ce qui masque une cause pourtant triviale.
        // Declared here, before any function returning it: a nested type must exist when the
        // compiler reads the SIGNATURE — bodies are deferred, return types are not.
        struct FCells
        {
            TArray<FShaft, TInlineAllocator<10>> Shafts;
            TArray<FConn,  TInlineAllocator<32>> Conns;
        };

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const FCells& C = GetCells(WorldX, WorldY);

            float CaveSDF = FLT_MAX;
            for (const FShaft& Sh : C.Shafts)
            {
                if (Sh.bOriginSpine) continue;  // VF_ApplyOriginSpine owns the structural column.
                const float DX = WorldX - Sh.X;
                const float DY = WorldY - Sh.Y;
                CaveSDF = FMath::Min(CaveSDF, FMath::Sqrt(DX * DX + DY * DY) - Sh.R);
            }
            const FVector Pos(WorldX, WorldY, WorldZ);
            for (const FConn& Cn : C.Conns)
            {
                CaveSDF = FMath::Min(CaveSDF, VoxelSDF::Capsule(Pos, Cn.A, Cn.B, Cn.Radius));
            }
            InOut.Sdf = CaveSDF;
        }

        /** La liste des puits proches — `FShaftLedgeMod` doit trouver le PLUS PROCHE pour ne
         *  poser d'étagère que sur sa moitié +X/+Y. Même motif que colonne → overhang. */
        const FCells& GetCellsAt(float WorldX, float WorldY) const { return GetCells(WorldX, WorldY); }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            // This source writes SDF only. A converter or other SDF consumer must inspect the
            // propagated interval; the source has no density effect in isolation.
            return EVoxelOpEffect::Identity;
        }

        /**
         * Propagate the source's own SDF interval. Eval selects the inner 3x3 cell neighbourhood,
         * so enumerating every cell touched by the box and asking GetCells at that cell centre is an
         * exact superset. Shaft axes are infinite in Z; connector capsules use their segment AABB
         * as a conservative distance lower bound.
         */
        void PropagateSdfOverBox(FVoxelBoxSdfInterval& InOut, const FBox& VoxelBox,
                                 const FVoxelOpContext&) const override
        {
            if (!VoxelMath::IsFinite((float)VoxelBox.Min.X) || !VoxelMath::IsFinite((float)VoxelBox.Min.Y)
                || !VoxelMath::IsFinite((float)VoxelBox.Min.Z)
                || !VoxelMath::IsFinite((float)VoxelBox.Max.X) || !VoxelMath::IsFinite((float)VoxelBox.Max.Y)
                || !VoxelMath::IsFinite((float)VoxelBox.Max.Z)
                || VoxelBox.Min.X > VoxelBox.Max.X || VoxelBox.Min.Y > VoxelBox.Max.Y
                || VoxelBox.Min.Z > VoxelBox.Max.Z
                || !VoxelMath::IsFinite(P.ShaftSpacing) || P.ShaftSpacing <= 0.0f)
            {
                InOut.SetUnknown();
                return;
            }

            const float Spacing = FMath::Max(P.ShaftSpacing, 1.0f);
            const int32 CX0 = FMath::FloorToInt((float)VoxelBox.Min.X / Spacing);
            const int32 CY0 = FMath::FloorToInt((float)VoxelBox.Min.Y / Spacing);
            const int32 CX1 = FMath::FloorToInt((float)VoxelBox.Max.X / Spacing);
            const int32 CY1 = FMath::FloorToInt((float)VoxelBox.Max.Y / Spacing);
            constexpr int64 MaxCellsScanned = 64 * 64;
            const int64 CellCount = ((int64)CX1 - CX0 + 1) * ((int64)CY1 - CY0 + 1);
            if (CellCount <= 0 || CellCount > MaxCellsScanned)
            {
                InOut.SetUnknown();
                return;
            }

            float Lower = FLT_MAX;
            bool bAnyPrimitive = false;
            for (int32 cy = CY0; cy <= CY1; ++cy)
            for (int32 cx = CX0; cx <= CX1; ++cx)
            {
                const FCells& C = GetCells((cx + 0.5f) * Spacing, (cy + 0.5f) * Spacing);
                for (const FShaft& Sh : C.Shafts)
                {
                    if (Sh.bOriginSpine) { continue; }
                    bAnyPrimitive = true;
                    Lower = FMath::Min(Lower,
                        VF_DistanceBoxToPointXY(VoxelBox, Sh.X, Sh.Y) - FMath::Abs(Sh.R));
                }
                for (const FConn& Conn : C.Conns)
                {
                    bAnyPrimitive = true;
                    const FVector ConnMin(
                        FMath::Min(Conn.A.X, Conn.B.X), FMath::Min(Conn.A.Y, Conn.B.Y),
                        FMath::Min(Conn.A.Z, Conn.B.Z));
                    const FVector ConnMax(
                        FMath::Max(Conn.A.X, Conn.B.X), FMath::Max(Conn.A.Y, Conn.B.Y),
                        FMath::Max(Conn.A.Z, Conn.B.Z));
                    Lower = FMath::Min(Lower,
                        VF_DistanceBetweenBoxes(VoxelBox.Min, VoxelBox.Max, ConnMin, ConnMax)
                        - FMath::Abs(Conn.Radius));
                }
            }

            if (bAnyPrimitive) { InOut.Set(Lower, FLT_MAX); }
            else               { InOut.Set(FLT_MAX, FLT_MAX); }
        }

    private:
        /** Tirage d'une cellule. PURE en (cellule, seed, params) ⇒ `Eval` et `EffectOverBox` ne
         *  peuvent pas voir des puits différents. */
        bool RollShaft(int32 nx, int32 ny, FShaft& Out) const
        {
            const float Spacing = FMath::Max(P.ShaftSpacing, 1.0f);
            const uint32 Hh = VoxelHash::Cell(nx, ny, Salt);
            if (VoxelHash::ToFloat01(Hh) > P.ShaftDensity) { return false; }

            const float JX = VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0x12345678u));
            const float JY = VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0x9ABCDEF0u));
            Out.X = (nx + 0.15f + JX * 0.7f) * Spacing;
            Out.Y = (ny + 0.15f + JY * 0.7f) * Spacing;
            Out.R = FMath::Lerp(P.ShaftMinRadius, P.ShaftMaxRadius,
                                VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0xBEEFu)));
            Out.CellX = nx;
            Out.CellY = ny;
            Out.bOriginSpine = false;
            return true;
        }

        /** Spine links use a radius above the repository's proven sup|FBM|=1.5 roughness
         * envelope, so the roughness pass cannot pinch their centreline shut. */
        float SpineConnectorRadius() const
        {
            constexpr float RoughnessAbsBound = 1.5f;
            const float RoughnessReach = FMath::Max(P.SurfaceRoughness, 0.0f)
                                       * VOXEL_NOISE_SCALE * RoughnessAbsBound;
            return FMath::Max(P.ConnectorRadius, RoughnessReach + 1.0f);
        }

        /** Le voisinage inner 3×3 + ses connecteurs, mémoïsés par worker. Le rebuild collecte un
         *  halo 9×9 émetteur / 15×15 total pour résoudre les fenêtres parent 5×5 et le fallback
         *  fixe ±3. Clé = cellule + tous les params qui influent : stable à travers les
         *  reconstructions de pile, ce qui est la leçon retenue du mémo de colonne de SurfaceWorld. */
        const FCells& GetCells(float WorldX, float WorldY) const
        {
            const float Spacing = FMath::Max(P.ShaftSpacing, 1.0f);
            const int32 CX = FMath::FloorToInt(WorldX / Spacing);
            const int32 CY = FMath::FloorToInt(WorldY / Spacing);

            thread_local FCells  Cache;
            thread_local int32   VS_CX = INT32_MAX, VS_CY = INT32_MAX;
            thread_local uint32  VS_Salt = 0xFFFFFFFFu;
            thread_local float   VS_Spacing = -1.0f, VS_Dens = -1.0f, VS_MinR = -1.0f,
                                 VS_MaxR = -1.0f, VS_Cross = -1.0f, VS_ConnR = -1.0f,
                                 VS_Rough = -1.0f, VS_SpineR = -1.0f,
                                 VS_BotZ = FLT_MAX, VS_TopZ = FLT_MAX, VS_Seal = -1.0f,
                                 VS_LedgeSpacing = -1.0f, VS_LedgeDepth = -1.0f;

            if (CX != VS_CX || CY != VS_CY || Salt != VS_Salt || Spacing != VS_Spacing ||
                P.ShaftDensity != VS_Dens || P.ShaftMinRadius != VS_MinR || P.ShaftMaxRadius != VS_MaxR ||
                P.CrossConnectChance != VS_Cross || P.ConnectorRadius != VS_ConnR ||
                P.SurfaceRoughness != VS_Rough || SpineRadius != VS_SpineR ||
                P.StrateBottomWorldZ != VS_BotZ || P.StrateTopWorldZ != VS_TopZ ||
                P.BoundarySealThickness != VS_Seal || P.LedgeSpacing != VS_LedgeSpacing ||
                P.LedgeDepth != VS_LedgeDepth)
            {
                VS_CX = CX;  VS_CY = CY;  VS_Salt = Salt;  VS_Spacing = Spacing;
                VS_Dens = P.ShaftDensity;  VS_MinR = P.ShaftMinRadius;  VS_MaxR = P.ShaftMaxRadius;
                VS_Cross = P.CrossConnectChance;  VS_ConnR = P.ConnectorRadius;
                VS_Rough = P.SurfaceRoughness;    VS_SpineR = SpineRadius;
                VS_BotZ = P.StrateBottomWorldZ;  VS_TopZ = P.StrateTopWorldZ;
                VS_Seal = P.BoundarySealThickness;
                VS_LedgeSpacing = P.LedgeSpacing; VS_LedgeDepth = P.LedgeDepth;
                Cache.Shafts.Reset();
                Cache.Conns.Reset();

                constexpr int32 EmitRadius = 1;      // 3×3: shaft cylinders and random links
                constexpr int32 CandidateRadius = 2; // 5×5 parent window around an emitting shaft
                constexpr int32 FallbackRadius = 3;  // fixed fallback window around an emitting shaft
                constexpr uint32 TreeSalt = 0x7A11u;

                const float BottomZ = P.StrateBottomWorldZ + P.BoundarySealThickness;
                const float TopZ    = P.StrateTopWorldZ    - P.BoundarySealThickness;
                const float TreeRadius = SpineConnectorRadius();
                // A tree capsule can affect a cell even when neither endpoint is in that cell.
                // Keep a rebuild-only child halo for that geometric reach, then add the
                // parent-search halo. With the defaults this is 4 + 3 cells = 15×15 rolls.
                const int32 ConnectorCellPad = FMath::Max(
                    1, FMath::CeilToInt(TreeRadius / Spacing));
                const int32 TreeEmitRadius = FallbackRadius + ConnectorCellPad;
                const int32 CollectRadius = TreeEmitRadius + FallbackRadius;

                const int32 CollectSide = CollectRadius * 2 + 1;
                TArray<FShaft, TInlineAllocator<225>> ShaftGrid;
                TArray<uint8, TInlineAllocator<225>> ShaftPresent;
                TArray<FShaft, TInlineAllocator<81>> TreeEmitShafts;
                ShaftGrid.SetNum(CollectSide * CollectSide);
                ShaftPresent.Init(0, CollectSide * CollectSide);
                // Rebuild-only wide collection. `Cache.Shafts` remains the inner 3×3 working set
                // used by Eval and the ledge modifier; the wider tree work is not paid per voxel.
                for (int32 dy = -CollectRadius; dy <= CollectRadius; dy++)
                for (int32 dx = -CollectRadius; dx <= CollectRadius; dx++)
                {
                    FShaft Sh;
                    if (!RollShaft(CX + dx, CY + dy, Sh)) { continue; }
                    const int32 GridIndex = (dy + CollectRadius) * CollectSide + (dx + CollectRadius);
                    ShaftGrid[GridIndex] = Sh;
                    ShaftPresent[GridIndex] = 1;
                    if (FMath::Abs(dx) <= EmitRadius && FMath::Abs(dy) <= EmitRadius)
                    {
                        Cache.Shafts.Add(Sh);
                    }
                    if (FMath::Abs(dx) <= TreeEmitRadius && FMath::Abs(dy) <= TreeEmitRadius)
                    {
                        TreeEmitShafts.Add(Sh);
                    }
                }

                auto FindCollectedShaft = [&](int32 CellX, int32 CellY) -> const FShaft*
                {
                    const int32 dx = CellX - CX;
                    const int32 dy = CellY - CY;
                    if (FMath::Abs(dx) > CollectRadius || FMath::Abs(dy) > CollectRadius)
                    {
                        return nullptr;
                    }
                    const int32 GridIndex = (dy + CollectRadius) * CollectSide + (dx + CollectRadius);
                    return ShaftPresent[GridIndex] ? &ShaftGrid[GridIndex] : nullptr;
                };

                const bool bOriginNearby = FMath::Abs(CX) <= 1 && FMath::Abs(CY) <= 1;
                if (bOriginNearby && SpineRadius > 0.0f)
                {
                    Cache.Shafts.Add({0.0f, 0.0f, SpineRadius, 0, 0, true});
                }

                const float CellMinX = static_cast<float>(CX) * Spacing;
                const float CellMaxX = static_cast<float>(CX + 1) * Spacing;
                const float CellMinY = static_cast<float>(CY) * Spacing;
                const float CellMaxY = static_cast<float>(CY + 1) * Spacing;
                auto ConnectorMayReachCell = [&](const FConn& Conn)
                {
                    const float MinX = FMath::Min(Conn.A.X, Conn.B.X) - Conn.Radius;
                    const float MaxX = FMath::Max(Conn.A.X, Conn.B.X) + Conn.Radius;
                    const float MinY = FMath::Min(Conn.A.Y, Conn.B.Y) - Conn.Radius;
                    const float MaxY = FMath::Max(Conn.A.Y, Conn.B.Y) + Conn.Radius;
                    const float GapX = FMath::Max3(CellMinX - MaxX, MinX - CellMaxX, 0.0f);
                    const float GapY = FMath::Max3(CellMinY - MaxY, MinY - CellMaxY, 0.0f);
                    return GapX == 0.0f && GapY == 0.0f;
                };

                auto EmitTreeConnector = [&](const FShaft& Child, const FShaft* Parent)
                {
                    const float Zc = VoxelPassageGeometry::VerticalShaftConnectorCenterZ(
                        P.StrateBottomWorldZ,
                        BottomZ,
                        TopZ,
                        P.LedgeSpacing,
                        P.LedgeDepth,
                        TreeRadius);
                    const float FloorZ = VoxelPassageGeometry::VerticalShaftConnectorFloorZ(
                        P.StrateBottomWorldZ,
                        BottomZ,
                        TopZ,
                        P.LedgeSpacing,
                        P.LedgeDepth,
                        TreeRadius);
                    const FVector ParentPoint = Parent != nullptr
                        ? FVector(Parent->X, Parent->Y, Zc)
                        : FVector(0.0f, 0.0f, Zc);
                    const FConn Conn{
                        FVector(Child.X, Child.Y, Zc), ParentPoint, TreeRadius,
                        FloorZ, true };
                    if (ConnectorMayReachCell(Conn))
                    {
                        Cache.Conns.Add(Conn);
                    }
                };

                // Structural drainage tree. Every real shaft in the rebuild-only child window
                // first chooses the nearest strictly more-central shaft in its complete 5×5
                // window. A local minimum falls back to the nearest lower-origin shaft in the
                // deterministic halo; a window touching the origin uses the spine directly, with
                // a final direct-spine fallback for an unusually empty finite halo. Every parent
                // edge therefore either strictly decreases origin distance or terminates at the
                // spine: no cycles and no orphans. Spatial culling makes the same edge visible
                // throughout its capsule, independent of which cache cell evaluates it.
                for (const FShaft& Child : TreeEmitShafts)
                {
                    if (Child.bOriginSpine) continue;

                    const float ChildOriginSq = FMath::Square(Child.X) + FMath::Square(Child.Y);
                    const FShaft* Parent = nullptr;
                    float BestDistanceSq = FLT_MAX;
                    for (int32 dy = -CandidateRadius; dy <= CandidateRadius; ++dy)
                    for (int32 dx = -CandidateRadius; dx <= CandidateRadius; ++dx)
                    {
                        const FShaft* Candidate = FindCollectedShaft(
                            Child.CellX + dx, Child.CellY + dy);
                        if (Candidate == nullptr
                            || (Candidate->CellX == Child.CellX && Candidate->CellY == Child.CellY))
                        {
                            continue;
                        }

                        const float CandidateOriginSq = FMath::Square(Candidate->X)
                                                       + FMath::Square(Candidate->Y);
                        if (!(CandidateOriginSq < ChildOriginSq))
                        {
                            continue;
                        }

                        const float DistanceSq = FMath::Square(Child.X - Candidate->X)
                                               + FMath::Square(Child.Y - Candidate->Y);
                        const bool bLowerCell = Parent == nullptr
                            || Candidate->CellY < Parent->CellY
                            || (Candidate->CellY == Parent->CellY
                                && Candidate->CellX < Parent->CellX);
                        if (DistanceSq < BestDistanceSq
                            || (DistanceSq == BestDistanceSq && bLowerCell))
                        {
                            BestDistanceSq = DistanceSq;
                            Parent = Candidate;
                        }
                    }

                    if (Parent == nullptr
                        && !(FMath::Abs(Child.CellX) <= CandidateRadius
                            && FMath::Abs(Child.CellY) <= CandidateRadius))
                    {
                        // Specified neighbour-shaft fallback. The lower-origin restriction is the
                        // proof that this fallback cannot create a cycle.
                        for (int32 dy = -FallbackRadius; dy <= FallbackRadius; ++dy)
                        for (int32 dx = -FallbackRadius; dx <= FallbackRadius; ++dx)
                        {
                            const FShaft* Candidate = FindCollectedShaft(
                                Child.CellX + dx, Child.CellY + dy);
                            if (Candidate == nullptr
                                || (Candidate->CellX == Child.CellX
                                    && Candidate->CellY == Child.CellY))
                            {
                                continue;
                            }

                            const float CandidateOriginSq = FMath::Square(Candidate->X)
                                                           + FMath::Square(Candidate->Y);
                            if (!(CandidateOriginSq < ChildOriginSq))
                            {
                                continue;
                            }

                            const float DistanceSq = FMath::Square(Child.X - Candidate->X)
                                                   + FMath::Square(Child.Y - Candidate->Y);
                            const bool bLowerCell = Parent == nullptr
                                || Candidate->CellY < Parent->CellY
                                || (Candidate->CellY == Parent->CellY
                                    && Candidate->CellX < Parent->CellX);
                            if (DistanceSq < BestDistanceSq
                                || (DistanceSq == BestDistanceSq && bLowerCell))
                            {
                                BestDistanceSq = DistanceSq;
                                Parent = Candidate;
                            }
                        }
                    }

                    EmitTreeConnector(Child, Parent);
                }

                // Existing random links remain the texture/loop layer and stay on the inner 3×3
                // set. Only the deterministic tree build uses the wider 9×9/15×15 collection.
                if (P.CrossConnectChance > 0.0f && Cache.Shafts.Num() >= 2)
                {
                    for (int32 i = 0; i < Cache.Shafts.Num(); i++)
                    for (int32 j = i + 1; j < Cache.Shafts.Num(); j++)
                    {
                        const FShaft& A = Cache.Shafts[i];
                        const FShaft& B = Cache.Shafts[j];
                        const float DSq = FMath::Square(A.X - B.X) + FMath::Square(A.Y - B.Y);
                        if (DSq > FMath::Square(Spacing * 1.6f)) { continue; }

                        const uint32 PH = VoxelHash::Pair(
                            FMath::RoundToInt(A.X), FMath::RoundToInt(A.Y),
                            FMath::RoundToInt(B.X), FMath::RoundToInt(B.Y), Salt ^ 0xC04Eu);
                        const bool bSpineConnector = A.bOriginSpine || B.bOriginSpine;
                        if (VoxelHash::ToFloat01(PH) >= P.CrossConnectChance)
                        {
                            continue;
                        }

                        const float Zc = FMath::Lerp(BottomZ, TopZ, VoxelHash::ToFloat01(VoxelHash::Mix(PH)));
                        const float ConnectorR = bSpineConnector
                            ? SpineConnectorRadius() : P.ConnectorRadius;
                        const FConn Conn{
                            FVector(A.X, A.Y, Zc), FVector(B.X, B.Y, Zc), ConnectorR,
                            0.0f, false };
                        if (ConnectorMayReachCell(Conn))
                        {
                            Cache.Conns.Add(Conn);
                        }
                    }
                }
            }
            return Cache;
        }

        FVerticalShaftParams P;
        uint32 Salt;
        float  SpineRadius;
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : ÉTAGÈRES DE PUITS / SHAFT LEDGES
    //=========================================================================
    // Des tablettes fines à intervalles réguliers en Z, posées UNIQUEMENT sur la moitié +X/+Y du
    // puits le plus proche — pour que la moitié opposée reste libre et le puits franchissable.
    // C'est un op FORÇANT (`Max`) : il ne peut qu'ajouter du solide.
    class FShaftLedgeMod final : public IVoxelDensityOp
    {
    public:
        FShaftLedgeMod(const FVerticalShaftParams& InP, const FShaftFieldSource* InField)
            : P(InP), Field(InField) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::ShaftGeometry; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            if (P.LedgeSpacing <= 0.0f || P.LedgeDepth <= 0.0f || Field == nullptr) { return; }
            // ⚠️ La garde est `Sdf < 0` — le SDF APRÈS rugosité, tel que la pile l'a laissé. C'est
            // bien `InOut.Sdf` ici, pas une re-évaluation : re-calculer donnerait le SDF SANS
            // rugosité et déplacerait les étagères.
            if (InOut.Sdf >= 0.0f) { return; }

            const float Phase = FMath::Frac((WorldZ - P.StrateBottomWorldZ) / P.LedgeSpacing);
            const float BandT = FMath::Min(Phase, 1.0f - Phase) * P.LedgeSpacing;
            if (BandT >= P.LedgeDepth) { return; }

            const FShaftFieldSource::FCells& C = Field->GetCellsAt(WorldX, WorldY);
            if (C.Shafts.Num() == 0) { return; }

            const FShaftFieldSource::FShaft* Near = nullptr;
            float BestSq = FLT_MAX;
            for (const FShaftFieldSource::FShaft& Sh : C.Shafts)
            {
                if (Sh.bOriginSpine) continue;  // ledges belong to real shafts, not the post.
                const float D2 = FMath::Square(WorldX - Sh.X) + FMath::Square(WorldY - Sh.Y);
                if (D2 < BestSq) { BestSq = D2; Near = &Sh; }
            }
            // The shaft axis is the structural tree's terminal point. Keep the mathematical
            // half-plane boundary open: tiny cancellation error must not turn an exact axis
            // landing into a solid ledge cap and sever the parent capsule.
            if (Near && (WorldX - Near->X) + (WorldY - Near->Y) > 1.0e-3f)
            {
                const float Shelf = 1.0f - SmoothStep01(BandT / P.LedgeDepth);
                InOut.Density = FMath::Max(InOut.Density, Shelf * P.BaseDensity);
            }
        }

        // N'ajoute que du solide ⇒ tue AllAir, jamais AllSolid.
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (Field != nullptr && P.LedgeSpacing > 0.0f && P.LedgeDepth > 0.0f)
                 ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            if (Field == nullptr || P.LedgeSpacing <= 0.0f || P.LedgeDepth <= 0.0f)
            {
                return EVoxelOpEffect::Identity;
            }
            return H.Sdf.IsKnown() && H.Sdf.Min >= 0.0f
                 ? EVoxelOpEffect::Identity : EVoxelOpEffect::FillOnly;
        }

    private:
        FVerticalShaftParams P;
        const FShaftFieldSource* Field;   // NON possédant : la pile possède la source
    };

    // The deterministic shaft tree is a walkable network as well as an air topology. Reassert
    // its air core after partial shaft ledges, then add the same inset floor band as the native
    // path at the common first ledge level. This lets a player-fit route cross between shafts
    // without restoring the removed landing-to-origin roads.
    class FShaftConnectorAirMod final : public IVoxelDensityOp
    {
    public:
        explicit FShaftConnectorAirMod(const FShaftFieldSource* InField, float InBaseDensity)
            : Field(InField), BaseDensity(InBaseDensity) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::ShaftGeometry; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ,
                  FVoxelOpSample& InOut) const override
        {
            if (Field == nullptr) return;
            const FShaftFieldSource::FCells& Cells = Field->GetCellsAt(WorldX, WorldY);
            for (const FShaftFieldSource::FConn& Conn : Cells.Conns)
            {
                if (!Conn.bWalkableFloor) continue;
                VoxelPassageGeometry::VF_ApplyVerticalShaftConnectorAir(
                    InOut.Density, WorldX, WorldY, WorldZ,
                    Conn.A, Conn.B, Conn.Radius, Conn.FloorZ, BaseDensity);
            }
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return Field != nullptr ? EVoxelOpEffect::Both : EVoxelOpEffect::Identity;
        }

        const TCHAR* DebugName() const override { return TEXT("ShaftConnectorAirOp"); }

    private:
        const FShaftFieldSource* Field = nullptr; // NON possédant : la pile possède la source
        float BaseDensity = 8.0f;
    };

    class FShaftConnectorFloorMod final : public IVoxelDensityOp
    {
    public:
        FShaftConnectorFloorMod(const FShaftFieldSource* InField, float InBaseDensity)
            : Field(InField), BaseDensity(InBaseDensity) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::Density; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::ShaftGeometry; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ,
                  FVoxelOpSample& InOut) const override
        {
            if (Field == nullptr) return;
            const FShaftFieldSource::FCells& Cells = Field->GetCellsAt(WorldX, WorldY);
            for (const FShaftFieldSource::FConn& Conn : Cells.Conns)
            {
                if (!Conn.bWalkableFloor) continue;
                VoxelPassageGeometry::VF_ApplyVerticalShaftConnectorFloor(
                    InOut.Density, WorldX, WorldY, WorldZ,
                    Conn.A, Conn.B, Conn.Radius, Conn.FloorZ, BaseDensity);
            }
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return Field != nullptr ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        const TCHAR* DebugName() const override { return TEXT("ShaftConnectorFloorOp"); }

    private:
        const FShaftFieldSource* Field = nullptr; // NON possédant : la pile possède la source
        float BaseDensity = 8.0f;
    };

    //=========================================================================
    // RÔLE 1 — SOURCE : ÎLES FLOTTANTES / FLOATING ISLAND BLOBS
    //=========================================================================
    // Le SEUL archétype dont la source est de l'AIR : `FConstantFieldSource(-BaseDensity)` pose un
    // grand vide, et cet opérateur y suspend des blobs. C'est ce qui en fait le bon test de
    // composition — tous les autres portages partent de roc et creusent.
    //
    // FORME D'UNE ÎLE : une dalle assez plate au-dessus du centre (`TopHalf = 0.20·Rxy`) et un
    // dessous qui s'effile vers une pointe (`ThicknessRatio·Rxy`). C'est l'asymétrie qui se lit
    // comme une île flottante plutôt que comme une sphère.
    //
    // ⚠️ ÉCART ASSUMÉ AVEC `OPSTACK-DECOMPOSITION §7`, qui décrivait un `FRAME IslandWarp` enveloppant
    // la source. Le warp reste À L'INTÉRIEUR de l'opérateur, et c'est délibéré : `§7` compte trois
    // usages de frames (îles, caves de TunnelNetwork, tunnels), et aucun n'en a besoin. Voir
    // `BuildTunnelNetworkStack` : `CaveWarp` n'enveloppe qu'UN opérateur (donc c'est une variable
    // locale, pas un frame) et `VerticalScale` est une fonction pure d'un scalaire. **Zéro frame
    // sur trois candidats.** Ne pas rouvrir : le warp reste local ICI pour la même raison qu'il
    // est resté local là-bas. On n'abstrait qu'à la deuxième occurrence réelle (cf.
    // `IVoxelBiomeField`, né d'un besoin réel).
    //
    // The warp stays INSIDE the op against §7's FRAME suggestion. TunnelNetwork is ported, and the
    // second real use dissolved the question rather than settling it. See BuildTunnelNetworkStack:
    // CaveWarp wraps exactly ONE operator (a local variable, not a frame) and VerticalScale is a
    // pure function of a scalar. ZERO frames out of three candidates. Do not reopen.
    class FIslandBlobSource final : public IVoxelDensityOp
    {
    public:
        FIslandBlobSource(const FFloatingIslandParams& InP, int32 Seed)
            : P(InP), Salt((uint32)Seed ^ 0x49736C64u)   // 'Isld'
        {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Sdf; }
        bool IsAdditive() const override { return false; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        struct FIsland { float X, Y, Rxy, TopHalf, TopZ, BotZ, TaperEnd; };

        // ⚠️ DÉCLARÉE ICI, avant toute fonction qui la renvoie — même piège que `FShaftFieldSource`
        // (C4430 : les corps de méthodes sont différés, les types de retour non).
        struct FCells { TArray<FIsland, TInlineAllocator<9>> Islands; };

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float BlendK = FMath::Max(P.SDFBlendRadius, 0.01f);
            const FCells& C = GetCells(WorldX, WorldY);

            // CONTOUR IRRÉGULIER : on déforme la requête HORIZONTALE pour que les bords des îles
            // soient lobés au lieu d'être des cercles parfaits. Calculé une fois par voxel et
            // partagé par toutes les îles proches — chacune échantillonne une autre partie du champ,
            // d'où des silhouettes distinctes.
            const float WarpAmp = (P.IslandMinRadius + P.IslandMaxRadius) * 0.5f * 0.35f;
            const float WX = WorldX + HFractal3D(FVector3f(WorldX * 0.04f + VoxelHash::SeedOffset(Salt, 0.0007f),
                                                         WorldY * 0.04f, WorldZ * 0.012f), VoxelGenLOD::Eff(3))
                                      * VOXEL_NOISE_SCALE * WarpAmp;
            const float WY = WorldY + HFractal3D(FVector3f(WorldX * 0.04f + 31.0f, WorldY * 0.04f + 7.0f,
                                                         WorldZ * 0.012f), VoxelGenLOD::Eff(3))
                                      * VOXEL_NOISE_SCALE * WarpAmp;

            float IslandSDF = FLT_MAX;
            for (const FIsland& Isl : C.Islands)
            {
                // Distance horizontale dans le repère DÉFORMÉ, donc le contour n'est pas un cercle.
                const float Dxw = WX - Isl.X, Dyw = WY - Isl.Y;
                const float DistXY = FMath::Sqrt(Dxw * Dxw + Dyw * Dyw);

                // Enveloppe de rayon par la hauteur : pleine largeur en haut, resserrée jusqu'à une
                // pointe en bas (taper SmoothStep).
                const float Hgt = FMath::Clamp((WorldZ - Isl.BotZ) / FMath::Max(Isl.TopZ - Isl.BotZ, 1.0f),
                                               0.0f, 1.0f);
                const float Taper = SmoothStep01(FMath::Clamp(Hgt / Isl.TaperEnd, 0.0f, 1.0f));
                const float Env = Isl.Rxy * Taper;

                // Surface du dessus : plate par défaut ; les bords retombent en dôme si TopFlatten < 1.
                float TopSurf = Isl.TopZ;
                if (P.TopFlatten < 1.0f)
                {
                    const float Edge = FMath::Clamp(DistXY / FMath::Max(Isl.Rxy, 1.0f), 0.0f, 1.0f);
                    TopSurf = Isl.TopZ - (1.0f - P.TopFlatten) * Isl.TopHalf * 2.0f * Edge * Edge;
                }

                // Pseudo-SDF : dehors si au-delà de l'enveloppe radiale OU au-dessus du dessus.
                const float Sdf = FMath::Max(DistXY - Env, WorldZ - TopSurf);

                IslandSDF = VoxelSDF::SmoothMin(IslandSDF, Sdf, BlendK);
            }

            InOut.Sdf = IslandSDF;
        }

        /**
     * Cette source écrit uniquement le canal SDF : son `EffectOverBox` intrinsèque est donc
     * `Identity`. Le convertisseur de remplissage consomme ensuite l'intervalle publié ; sur une
     * strate d'îles, l'absence d'île prouvée est le cas COURANT et, combinée à l'`AllAir` de la
     * source constante, permet enfin de prouver « tout air » (`OPSTACK-DECOMPOSITION §7`).
         *
         * BORNE, et pourquoi elle est sûre dans les deux directions :
         *   • en XY, `Sdf ≥ DistXY − Rxy` (l'enveloppe ne dépasse jamais `Rxy`), et le warp déplace
         *     le POINT de `WarpAmp · VOXEL_NOISE_SCALE · √2` au plus (la borne prouvée de chaque
         *     FBM est 1.5 sur DEUX axes indépendants — voir la note √2 dans le corps) ;
         *   • en Z, `Sdf ≥ WorldZ − TopSurf ≥ WorldZ − TopZ`, donc au-dessus du sommet + marge il
         *     n'y a plus rien à faire. **En dessous, il n'y a PAS de borne** : sous une île, le SDF
         *     vaut ≈ `DistXY` à toute profondeur, donc un mince fil de matière descend le long de
         *     l'axe. Le confondre avec « rien en dessous » serait un TROU, et c'est pourquoi seule
         *     la borne HAUTE est testée.
         *   • cette source ne couvre pas l'aval : elle publie seulement son propre intervalle SDF.
         *     La rugosité, le blend du fill et le creux du SmoothMin sont bornés par leurs propres
         *     opérateurs dans le pliage, chacun avec son contrat isolé.
         */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            // This source writes SDF only. Island filling is the converter's responsibility.
            return EVoxelOpEffect::Identity;
        }

        /**
         * Propagate a source-only lower bound. The exact 3x3 neighbourhood used by Eval is
         * enumerated for every XY cell touched by the box. The warp, authored radius endpoints,
         * top envelope, and the bounded SmoothMin dip are all included in the bound.
         */
        void PropagateSdfOverBox(FVoxelBoxSdfInterval& InOut, const FBox& VoxelBox,
                                 const FVoxelOpContext&) const override
        {
            if (!VoxelMath::IsFinite((float)VoxelBox.Min.X) || !VoxelMath::IsFinite((float)VoxelBox.Min.Y)
                || !VoxelMath::IsFinite((float)VoxelBox.Min.Z)
                || !VoxelMath::IsFinite((float)VoxelBox.Max.X) || !VoxelMath::IsFinite((float)VoxelBox.Max.Y)
                || !VoxelMath::IsFinite((float)VoxelBox.Max.Z)
                || VoxelBox.Min.X > VoxelBox.Max.X || VoxelBox.Min.Y > VoxelBox.Max.Y
                || VoxelBox.Min.Z > VoxelBox.Max.Z
                || !VoxelMath::IsFinite(P.IslandSpacing) || !VoxelMath::IsFinite(P.IslandDensity)
                || !VoxelMath::IsFinite(P.IslandMinRadius) || !VoxelMath::IsFinite(P.IslandMaxRadius)
                || !VoxelMath::IsFinite(P.ThicknessRatio) || !VoxelMath::IsFinite(P.VerticalJitter)
                || !VoxelMath::IsFinite(P.TopFlatten) || !VoxelMath::IsFinite(P.SDFBlendRadius)
                || P.IslandDensity < 0.0f)
            {
                InOut.SetUnknown();
                return;
            }

            if (P.IslandDensity <= 0.0f)
            {
                InOut.Set(FLT_MAX, FLT_MAX);
                return;
            }

            const float Spacing = FMath::Max(P.IslandSpacing, 1.0f);
            const int32 CX0 = FMath::FloorToInt((float)VoxelBox.Min.X / Spacing);
            const int32 CY0 = FMath::FloorToInt((float)VoxelBox.Min.Y / Spacing);
            const int32 CX1 = FMath::FloorToInt((float)VoxelBox.Max.X / Spacing);
            const int32 CY1 = FMath::FloorToInt((float)VoxelBox.Max.Y / Spacing);
            constexpr int64 MaxCellsScanned = 64 * 64;
            const int64 CellCount = ((int64)CX1 - CX0 + 1) * ((int64)CY1 - CY0 + 1);
            if (CellCount <= 0 || CellCount > MaxCellsScanned)
            {
                InOut.SetUnknown();
                return;
            }

            constexpr float Sqrt2 = 1.4142136f;
            const float WarpAmp = (P.IslandMinRadius + P.IslandMaxRadius) * 0.5f * 0.35f;
            const float WarpDiag = FMath::Abs(WarpAmp) * VOXEL_NOISE_SCALE * VF_PerlinAbsBound * Sqrt2;
            const float RadiusUpper = FMath::Max3(P.IslandMinRadius, P.IslandMaxRadius, 0.0f);
            // For the authored TopFlatten range [0,1], TopSurf never exceeds TopZ. Keeping the
            // positive general-range term makes the proof remain safe if a data asset is widened.
            const float TopSurfExtra = FMath::Max(P.TopFlatten - 1.0f, 0.0f)
                                      * RadiusUpper * 0.20f * 2.0f;

            float Lower = FLT_MAX;
            bool bAnyIsland = false;
            const float BlendK = FMath::Max(P.SDFBlendRadius, 0.01f);
            for (int32 cy = CY0; cy <= CY1; ++cy)
            for (int32 cx = CX0; cx <= CX1; ++cx)
            {
                const FCells& C = GetCells((cx + 0.5f) * Spacing, (cy + 0.5f) * Spacing);
                for (const FIsland& Isl : C.Islands)
                {
                    bAnyIsland = true;
                    const float RadialLower = VF_DistanceBoxToPointXY(VoxelBox, Isl.X, Isl.Y)
                                            - WarpDiag
                                            - FMath::Max(Isl.Rxy, 0.0f);
                    const float TopLower = (float)VoxelBox.Min.Z - Isl.TopZ - TopSurfExtra;
                    const float IslandLower = FMath::Max(RadialLower, TopLower);
                    Lower = FMath::Min(Lower, IslandLower);
                }
            }

            if (!bAnyIsland)
            {
                InOut.Set(FLT_MAX, FLT_MAX);
                return;
            }

            // SmoothMin can dip below the smallest raw term, but its total deficit is bounded by
            // one blend radius: once the running minimum is a blend radius below another term,
            // the next penalty is zero. This is a lower bound for any number of islands.
            InOut.Set(VF_SaturatingAdd(Lower, -BlendK), FLT_MAX);
        }

    private:
        /** Tirage d'une cellule. PURE en (cellule, seed, params) ⇒ `Eval` et `EffectOverBox` ne
         *  peuvent pas voir des îles différentes. */
        bool RollIsland(int32 nx, int32 ny, FIsland& Out) const
        {
            const float H = P.StrateTopWorldZ - P.StrateBottomWorldZ;
            const float Spacing = FMath::Max(P.IslandSpacing, 1.0f);
            const float MidZ = (P.StrateTopWorldZ + P.StrateBottomWorldZ) * 0.5f;

            const uint32 Hh = VoxelHash::Cell(nx, ny, Salt);
            if (VoxelHash::ToFloat01(Hh) > P.IslandDensity) { return false; }

            const float JX = VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0x12345678u));
            const float JY = VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0x9ABCDEF0u));

            Out.X = (nx + 0.15f + JX * 0.7f) * Spacing;
            Out.Y = (ny + 0.15f + JY * 0.7f) * Spacing;
            Out.Rxy = FMath::Lerp(P.IslandMinRadius, P.IslandMaxRadius,
                                  VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0x5A5Au)));

            // PROFIL ASYMÉTRIQUE : dalle de terre au-dessus, dessous qui s'effile en pointe.
            Out.TopHalf = Out.Rxy * 0.20f;
            const float UnderDepth = Out.Rxy * FMath::Max(P.ThicknessRatio, 0.25f);

            const float SpreadZ = FMath::Max(H * 0.5f - FMath::Max(Out.TopHalf, UnderDepth)
                                             - P.BoundarySealThickness, 0.0f) * P.VerticalJitter;
            const float Cz = MidZ + VoxelHash::ToFloatSigned(VoxelHash::Mix(Hh ^ 0xB17Du)) * SpreadZ;
            Out.TopZ = Cz + Out.TopHalf;
            Out.BotZ = Cz - UnderDepth;

            // Netteté du taper par île (point d'arrivée du SmoothStep) → silhouettes variées.
            Out.TaperEnd = FMath::Lerp(0.45f, 0.7f, VoxelHash::ToFloat01(VoxelHash::Mix(Hh ^ 0x7A1Eu)));
            return true;
        }

        /**
         * Le voisinage 3×3, mémoïsé par worker (`thread_local`).
         *
         * ⚠️ LA CLÉ INCLUT `BoundarySealThickness` : `SpreadZ` s'en sert
         * (`H·0.5 − max(TopHalf, UnderDepth) − Seal`), donc sans lui une édition à chaud qui ne
         * change QUE l'épaisseur de seal servirait des îles périmées. Même famille que `AUDIT §C2` :
         * une clé de cache incomplète ne se voit pas, elle produit du terrain plausible.
         *
         * The key includes BoundarySealThickness because SpreadZ reads it; without it a live edit
         * of the seal thickness alone would serve stale islands.
         */
        const FCells& GetCells(float WorldX, float WorldY) const
        {
            const float Spacing = FMath::Max(P.IslandSpacing, 1.0f);
            const int32 CX = FMath::FloorToInt(WorldX / Spacing);
            const int32 CY = FMath::FloorToInt(WorldY / Spacing);

            thread_local FCells  Cache;
            thread_local int32   FI_CX = INT32_MAX, FI_CY = INT32_MAX;
            thread_local uint32  FI_Salt = 0xFFFFFFFFu;
            thread_local float   FI_Spacing = -1.0f, FI_Dens = -1.0f, FI_MinR = -1.0f, FI_MaxR = -1.0f,
                                 FI_Thick = -1.0f, FI_VJit = -1.0f, FI_Seal = -1.0f,
                                 FI_BotZ = FLT_MAX, FI_TopZ = FLT_MAX;

            if (CX != FI_CX || CY != FI_CY || Salt != FI_Salt || Spacing != FI_Spacing ||
                P.IslandDensity != FI_Dens || P.IslandMinRadius != FI_MinR ||
                P.IslandMaxRadius != FI_MaxR || P.ThicknessRatio != FI_Thick ||
                P.VerticalJitter != FI_VJit || P.BoundarySealThickness != FI_Seal ||
                P.StrateBottomWorldZ != FI_BotZ || P.StrateTopWorldZ != FI_TopZ)
            {
                FI_CX = CX;  FI_CY = CY;  FI_Salt = Salt;  FI_Spacing = Spacing;
                FI_Dens = P.IslandDensity;  FI_MinR = P.IslandMinRadius;  FI_MaxR = P.IslandMaxRadius;
                FI_Thick = P.ThicknessRatio;  FI_VJit = P.VerticalJitter;
                FI_Seal = P.BoundarySealThickness;
                FI_BotZ = P.StrateBottomWorldZ;  FI_TopZ = P.StrateTopWorldZ;
                Cache.Islands.Reset();

                for (int32 dy = -1; dy <= 1; dy++)
                for (int32 dx = -1; dx <= 1; dx++)
                {
                    FIsland Isl;
                    if (RollIsland(CX + dx, CY + dy, Isl)) { Cache.Islands.Add(Isl); }
                }
            }
            return Cache;
        }

        FFloatingIslandParams P;
        uint32 Salt;
    };

    // The mesher's coarse samples are sparse enough that one sample can land in a different
    // exact 32-voxel chunk every time.  Keeping one SDF cache inside every exact-chunk op-stack
    // therefore turns L4 into thousands of BuildChunkCache calls.  These worker-local entries
    // share the immutable room graph cache by its complete deterministic input key.  A wider
    // region is safe because BuildChunkCache's collect/store construction is window-invariant;
    // the key still includes every value that can change the graph or its terrain-op rolls.
    // A coarse tile traverses several deterministic XY search windows while LODs are generated
    // concurrently.  One mixed table made fine and coarse windows evict one another before the
    // next tile could reuse them.  Keep a bounded table per region-size class: this is a cache
    // partition only, not a change to the graph key or to graph construction.
    constexpr int32 RoomGraphCacheSlotCount = 128;
    constexpr int32 RoomGraphCacheBankCount = 3;

    struct FRoomGraphCacheEntry
    {
        bool bValid = false;
        uint32 Seed = 0;
        int32 StrateIndex = INT32_MIN;
        uint32 ParamsFingerprint = 0xFFFFFFFFu;
        uint32 LayoutVersion = 0xFFFFFFFFu;
        uint64 ManagerLifetimeId = 0;
        const TArray<FStrateTerrainOpEntry>* TerrainOps = nullptr;
        int32 RegionMinX = 0;
        int32 RegionMinY = 0;
        int32 RegionSize = 0;
        uint32 LastUse = 0;
        FChunkSDFCache Cache;
    };

    using FRoomGraphCacheStorage = std::array<
        std::array<FRoomGraphCacheEntry, RoomGraphCacheSlotCount>, RoomGraphCacheBankCount>;
    static thread_local VoxelForgeCoreThreadLocal::FLazy<FRoomGraphCacheStorage>
        GRoomGraphCache;
    static thread_local uint32 GRoomGraphCacheClock = 0;

    FORCEINLINE int32 RoomGraphCacheBank(int32 RegionSize)
    {
        return RegionSize <= CHUNK_SIZE ? 0
             : (RegionSize <= 2 * CHUNK_SIZE ? 1 : 2);
    }

    FORCEINLINE int32 RoomGraphCacheSlot(
        uint32 Seed, int32 StrateIndex, uint32 ParamsFingerprint, uint32 LayoutVersion,
        uint64 ManagerLifetimeId, int32 RegionMinX, int32 RegionMinY, int32 RegionSize)
    {
        uint32 Hash = Seed * 0x9E3779B9u;
        Hash ^= static_cast<uint32>(StrateIndex) * 0x85EBCA6Bu;
        Hash ^= ParamsFingerprint * 0xC2B2AE35u;
        Hash ^= LayoutVersion * 0x27D4EB2Fu;
        Hash ^= static_cast<uint32>(ManagerLifetimeId)
            ^ static_cast<uint32>(ManagerLifetimeId >> 32);
        Hash ^= static_cast<uint32>(RegionMinX) * 0x165667B1u;
        Hash ^= static_cast<uint32>(RegionMinY) * 0xD3A2646Cu;
        Hash ^= static_cast<uint32>(RegionSize) * 0xFD7046C5u;
        Hash ^= Hash >> 16;
        return static_cast<int32>(Hash & (RoomGraphCacheSlotCount - 1));
    }

    FRoomGraphCacheEntry* FindRoomGraphCacheEntry(
        uint32 Seed, int32 StrateIndex, uint32 ParamsFingerprint, uint32 LayoutVersion,
        uint64 ManagerLifetimeId, const TArray<FStrateTerrainOpEntry>* TerrainOps,
        int32 RegionMinX, int32 RegionMinY, int32 RegionSize)
    {
        auto& RoomGraphCache = GRoomGraphCache.Get();
        auto SelectForReuse = [](FRoomGraphCacheEntry* Selected, uint32 Use)
            -> FRoomGraphCacheEntry*
        {
            if (Selected != nullptr && Selected->bValid)
            {
                // Reset() deliberately preserves hot-path capacity. That is useful while the
                // same window is reused, but not when this slot is about to become a different
                // key: every worker could otherwise retain one full graph window per historical
                // streaming key. Release before invalidating the key so a long-lived game has a
                // bounded working set instead of a capacity leak.
                Selected->Cache.Release();
                Selected->bValid = false;
            }
            if (Selected != nullptr)
            {
                Selected->LastUse = Use;
            }
            return Selected;
        };

        const int32 Bank = RoomGraphCacheBank(RegionSize);
        const uint32 Use = ++GRoomGraphCacheClock;
        const int32 StartSlot = RoomGraphCacheSlot(
            Seed, StrateIndex, ParamsFingerprint, LayoutVersion, ManagerLifetimeId,
            RegionMinX, RegionMinY, RegionSize);
        FRoomGraphCacheEntry* ReuseEntry = nullptr;
        FRoomGraphCacheEntry* LeastRecentlyUsed = nullptr;
        for (int32 Probe = 0; Probe < RoomGraphCacheSlotCount; ++Probe)
        {
            FRoomGraphCacheEntry& Candidate = RoomGraphCache[Bank][
                (StartSlot + Probe) & (RoomGraphCacheSlotCount - 1)];
            if (!Candidate.bValid)
            {
                FRoomGraphCacheEntry* Selected = ReuseEntry != nullptr ? ReuseEntry : &Candidate;
                return SelectForReuse(Selected, Use);
            }
            if (Candidate.Seed == Seed
                && Candidate.StrateIndex == StrateIndex
                && Candidate.ParamsFingerprint == ParamsFingerprint
                && Candidate.LayoutVersion == LayoutVersion
                && Candidate.ManagerLifetimeId == ManagerLifetimeId
                && Candidate.TerrainOps == TerrainOps
                && Candidate.RegionMinX == RegionMinX
                && Candidate.RegionMinY == RegionMinY
                && Candidate.RegionSize == RegionSize)
            {
                Candidate.LastUse = Use;
                return &Candidate;
            }
            if (ReuseEntry == nullptr && Candidate.ManagerLifetimeId != ManagerLifetimeId)
            {
                ReuseEntry = &Candidate;
            }
            if (LeastRecentlyUsed == nullptr || Candidate.LastUse < LeastRecentlyUsed->LastUse)
            {
                LeastRecentlyUsed = &Candidate;
            }
        }
        FRoomGraphCacheEntry* Selected = ReuseEntry != nullptr
            ? ReuseEntry : LeastRecentlyUsed;
        return SelectForReuse(
            Selected != nullptr ? Selected : &RoomGraphCache[Bank][StartSlot], Use);
    }

    // Classification is dispatched across many workers before most of those workers have
    // evaluated a density sample.  A thread-local cache prevents races, but it also makes every
    // worker rebuild the same deterministic collect/NN graph.  Keep a small process-local set of
    // immutable classifier caches: construction is serialized, publication happens only after
    // BuildChunkCache has completed, and each consumer holds a shared reference while refining.
    // This cache never stores mutable manager state; all manager/terrain data are read while the
    // entry is built and the resulting FChunkSDFCache is read-only thereafter.
    struct FSharedRoomGraphCacheEntry
    {
        uint32 Seed = 0;
        int32 StrateIndex = INT32_MIN;
        uint32 ParamsFingerprint = 0xFFFFFFFFu;
        uint32 LayoutVersion = 0xFFFFFFFFu;
        uint64 ManagerLifetimeId = 0;
        const TArray<FStrateTerrainOpEntry>* TerrainOps = nullptr;
        int32 RegionMinX = 0;
        int32 RegionMinY = 0;
        int32 RegionSize = 0;
        uint32 LastUse = 0;
        bool bBuilding = false;
        FEvent* ReadyEvent = nullptr;
        TSharedPtr<const FChunkSDFCache, ESPMode::ThreadSafe> Cache;
        uint64 AllocatedBytes = 0;

        ~FSharedRoomGraphCacheEntry()
        {
            if (ReadyEvent != nullptr)
            {
                FPlatformProcess::ReturnSynchEventToPool(ReadyEvent);
            }
        }
    };

    static FCriticalSection GSharedRoomGraphCacheMutex;
    static TArray<TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>>
        GSharedRoomGraphCache;
    static uint32 GSharedRoomGraphCacheClock = 0;
    static uint64 GSharedRoomGraphCacheResidentBytes = 0;
    static FCriticalSection GSharedRoomGraphCacheBuildGateMutex;
    static int32 GSharedRoomGraphCacheActiveBuilds[2] = {0, 0};
    // The byte budget is the actual memory guard.  A 128-entry count is too small for the
    // player's streaming radius: it turns otherwise reusable 128-voxel windows into transient
    // rebuilds while only a few MiB are resident.  Keep a generous bounded index so the budget,
    // rather than an arbitrary key count, controls retention.
    constexpr int32 SharedRoomGraphCacheMaxEntries = 4096;
    // Limit the number of graph allocations that can exist before their size is
    // known and published into the byte budget. This is the guard against a
    // burst of distinct coarse tiles retaining one large build per worker.
    // Fine LOD0 proof windows are small and latency-sensitive. Keep their build slots separate
    // from coarse streaming windows: a pair of 250 ms LOD4 graph builds must not make a 32/64
    // voxel empty tile wait behind them. The fine slots are still bounded, and their graph
    // allocations are tiny compared with the coarse builds.
    constexpr int32 SharedRoomGraphCacheBuildBankCount = 2;
    constexpr int32 SharedRoomGraphCacheBuildConcurrency[SharedRoomGraphCacheBuildBankCount] = {4, 2};
    // This is a proof-cache budget, not a geometry budget. A miss rebuilds an immutable cache;
    // unknown/evicted proof data therefore falls back to sampling and cannot change the mesh.
    constexpr uint64 SharedRoomGraphCacheBudgetBytes = 256ull * 1024ull * 1024ull;

    static TSharedPtr<const FChunkSDFCache, ESPMode::ThreadSafe>
    SnapshotSharedRoomGraphCache(
        const TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>& Entry)
    {
        FScopeLock Lock(&GSharedRoomGraphCacheMutex);
        return Entry.IsValid()
            ? Entry->Cache
            : TSharedPtr<const FChunkSDFCache, ESPMode::ThreadSafe>();
    }

    int32 SharedRoomGraphCacheBuildBank(int32 RegionSize)
    {
        return RegionSize <= 2 * CHUNK_SIZE ? 0 : 1;
    }

    void AcquireSharedRoomGraphCacheBuildSlot(int32 RegionSize)
    {
        const int32 Bank = SharedRoomGraphCacheBuildBank(RegionSize);
        for (;;)
        {
            {
                FScopeLock Lock(&GSharedRoomGraphCacheBuildGateMutex);
                if (GSharedRoomGraphCacheActiveBuilds[Bank]
                    < SharedRoomGraphCacheBuildConcurrency[Bank])
                {
                    ++GSharedRoomGraphCacheActiveBuilds[Bank];
                    return;
                }
            }
            FPlatformProcess::Yield();
        }
    }

    void ReleaseSharedRoomGraphCacheBuildSlot(int32 RegionSize)
    {
        const int32 Bank = SharedRoomGraphCacheBuildBank(RegionSize);
        FScopeLock Lock(&GSharedRoomGraphCacheBuildGateMutex);
        check(GSharedRoomGraphCacheActiveBuilds[Bank] > 0);
        --GSharedRoomGraphCacheActiveBuilds[Bank];
    }

    void EvictSharedRoomGraphCacheLocked(const FSharedRoomGraphCacheEntry* ProtectedEntry = nullptr)
    {
        while (GSharedRoomGraphCache.Num() > SharedRoomGraphCacheMaxEntries
            || GSharedRoomGraphCacheResidentBytes > SharedRoomGraphCacheBudgetBytes)
        {
            int32 OldestIndex = INDEX_NONE;
            for (int32 Index = 0; Index < GSharedRoomGraphCache.Num(); ++Index)
            {
                const TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>& Candidate =
                    GSharedRoomGraphCache[Index];
                if (Candidate->bBuilding || Candidate.Get() == ProtectedEntry)
                {
                    continue;
                }
                if (OldestIndex == INDEX_NONE
                    || Candidate->LastUse < GSharedRoomGraphCache[OldestIndex]->LastUse)
                {
                    OldestIndex = Index;
                }
            }
            if (OldestIndex == INDEX_NONE)
            {
                // All remaining entries are in-flight or the protected oversized entry. Keep
                // them alive until their consumers finish; the next completed publish can evict.
                break;
            }

            const uint64 Bytes = GSharedRoomGraphCache[OldestIndex]->AllocatedBytes;
            GSharedRoomGraphCacheResidentBytes = Bytes >= GSharedRoomGraphCacheResidentBytes
                ? 0
                : GSharedRoomGraphCacheResidentBytes - Bytes;
            GSharedRoomGraphCache.RemoveAtSwap(OldestIndex, 1, EAllowShrinking::No);
        }
    }

    void RemoveStaleSharedRoomGraphCachesLocked(uint64 KeepManagerLifetimeId)
    {
        for (int32 Index = GSharedRoomGraphCache.Num() - 1; Index >= 0; --Index)
        {
            const TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>& Candidate =
                GSharedRoomGraphCache[Index];
            if (Candidate->bBuilding
                || (KeepManagerLifetimeId != 0
                    && Candidate->ManagerLifetimeId == KeepManagerLifetimeId))
            {
                continue;
            }

            const uint64 Bytes = Candidate->AllocatedBytes;
            GSharedRoomGraphCacheResidentBytes = Bytes >= GSharedRoomGraphCacheResidentBytes
                ? 0
                : GSharedRoomGraphCacheResidentBytes - Bytes;
            GSharedRoomGraphCache.RemoveAtSwap(Index, 1, EAllowShrinking::No);
        }
        EvictSharedRoomGraphCacheLocked();
    }

    TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe> FindOrBuildSharedRoomGraphCache(
        uint32 Seed, int32 StrateIndex, uint32 ParamsFingerprint, uint32 LayoutVersion,
        uint64 ManagerLifetimeId, const TArray<FStrateTerrainOpEntry>* TerrainOps,
        int32 RegionMinX, int32 RegionMinY, int32 RegionSize,
        float SearchMinX, float SearchMinY, float SearchMaxX, float SearchMaxY,
        const FStrateGenerationParams& Params,
        ERoomGraphBuildSite BuildSite)
    {
        for (;;)
        {
            TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe> Entry;
            bool bBuild = false;
            bool bBuildTransient = false;
            {
                FScopeLock Lock(&GSharedRoomGraphCacheMutex);
                const uint32 Use = ++GSharedRoomGraphCacheClock;
                for (const TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>& Candidate
                     : GSharedRoomGraphCache)
                {
                    if (Candidate->Seed == Seed
                        && Candidate->StrateIndex == StrateIndex
                        && Candidate->ParamsFingerprint == ParamsFingerprint
                        && Candidate->LayoutVersion == LayoutVersion
                        && Candidate->ManagerLifetimeId == ManagerLifetimeId
                        && Candidate->TerrainOps == TerrainOps
                        && Candidate->RegionMinX == RegionMinX
                        && Candidate->RegionMinY == RegionMinY
                        && Candidate->RegionSize == RegionSize)
                    {
                        Candidate->LastUse = Use;
                        Entry = Candidate;
                        break;
                    }
                }

                if (!Entry.IsValid())
                {
                    // Evict completed entries before admitting a new key. If
                    // the table is full of in-flight keys, do not append an
                    // unbounded waiting entry: build this request transiently
                    // under the build gate instead. The caller still gets the
                    // same immutable cache, but it is released with that
                    // classifier state rather than retained globally.
                    EvictSharedRoomGraphCacheLocked();
                    if (GSharedRoomGraphCache.Num() >= SharedRoomGraphCacheMaxEntries)
                    {
                        bBuildTransient = true;
                    }
                    else
                    {
                        Entry = MakeShared<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>();
                        Entry->Seed = Seed;
                        Entry->StrateIndex = StrateIndex;
                        Entry->ParamsFingerprint = ParamsFingerprint;
                        Entry->LayoutVersion = LayoutVersion;
                        Entry->ManagerLifetimeId = ManagerLifetimeId;
                        Entry->TerrainOps = TerrainOps;
                        Entry->RegionMinX = RegionMinX;
                        Entry->RegionMinY = RegionMinY;
                        Entry->RegionSize = RegionSize;
                        Entry->LastUse = Use;
                        Entry->bBuilding = true;
                        Entry->ReadyEvent = FPlatformProcess::GetSynchEventFromPool(true);
                        GSharedRoomGraphCache.Add(Entry);
                        bBuild = true;
                    }
                }
            }

            if (bBuild || bBuildTransient)
            {
                const double CacheBuildCallStart = FPlatformTime::Seconds();
                AcquireSharedRoomGraphCacheBuildSlot(RegionSize);
                const double CacheBuildSlotWait = FPlatformTime::Seconds() - CacheBuildCallStart;
                TSharedPtr<FChunkSDFCache, ESPMode::ThreadSafe> BuiltCache =
                    MakeShared<FChunkSDFCache, ESPMode::ThreadSafe>();
                VoxelCaveMorphology::BuildChunkCache(
                    *BuiltCache, SearchMinX, SearchMinY, SearchMaxX, SearchMaxY,
                    Params, Seed, StrateIndex, TerrainOps, BuildSite);
                const double CacheBuildSeconds = FPlatformTime::Seconds() - CacheBuildCallStart;

                const uint64 AllocatedBytes = static_cast<uint64>(sizeof(FSharedRoomGraphCacheEntry))
                    + static_cast<uint64>(sizeof(FChunkSDFCache))
                    + static_cast<uint64>(BuiltCache->GetAllocatedSize());
                if (bBuildTransient)
                {
                    Entry = MakeShared<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>();
                    Entry->Seed = Seed;
                    Entry->StrateIndex = StrateIndex;
                    Entry->ParamsFingerprint = ParamsFingerprint;
                    Entry->LayoutVersion = LayoutVersion;
                    Entry->ManagerLifetimeId = ManagerLifetimeId;
                    Entry->TerrainOps = TerrainOps;
                    Entry->RegionMinX = RegionMinX;
                    Entry->RegionMinY = RegionMinY;
                    Entry->RegionSize = RegionSize;
                    Entry->LastUse = 0;
                    Entry->AllocatedBytes = AllocatedBytes;
                    {
                        FScopeLock Lock(&GSharedRoomGraphCacheMutex);
                        Entry->Cache = BuiltCache;
                    }
                }
                else
                {
                    FScopeLock Lock(&GSharedRoomGraphCacheMutex);
                    Entry->Cache = BuiltCache;
                    Entry->AllocatedBytes = AllocatedBytes;
                    Entry->bBuilding = false;
                    Entry->ReadyEvent->Trigger();
                    if (AllocatedBytes <= SharedRoomGraphCacheBudgetBytes)
                    {
                        GSharedRoomGraphCacheResidentBytes += Entry->AllocatedBytes;
                        EvictSharedRoomGraphCacheLocked(Entry.Get());
                    }
                    else
                    {
                        // Publish to any waiters through the shared entry, but do not retain an
                        // oversized graph in the process-wide table. The caller's shared pointer
                        // keeps this one immutable build alive only for the current work item.
                        for (int32 Index = 0; Index < GSharedRoomGraphCache.Num(); ++Index)
                        {
                            if (GSharedRoomGraphCache[Index].Get() == Entry.Get())
                            {
                                GSharedRoomGraphCache.RemoveAtSwap(
                                    Index, 1, EAllowShrinking::No);
                                break;
                            }
                        }
                        EvictSharedRoomGraphCacheLocked();
                        UE_LOG(LogTemp, Warning,
                            TEXT("[VoxelForgeSharedCacheMemory] oversized_entry_bytes=%llu "
                                 "budget_bytes=%llu retained=0"),
                            static_cast<unsigned long long>(AllocatedBytes),
                            static_cast<unsigned long long>(SharedRoomGraphCacheBudgetBytes));
                    }
                }
                ReleaseSharedRoomGraphCacheBuildSlot(RegionSize);
                if (!bBuildTransient)
                {
                    VoxelDensityOps::ReportWorkerRoomGraphCacheFootprint();
                }
                if (RegionSize <= 2 * CHUNK_SIZE
                    || CacheBuildSeconds >= 0.25 || CacheBuildSlotWait >= 0.25)
                {
                    UE_LOG(LogTemp, Warning,
                        TEXT("[VoxelForgeSharedCacheTiming] action=build transient=%d "
                             "region=(%d,%d,%d) slot_wait=%.6f build=%.6f bytes=%llu"),
                        bBuildTransient ? 1 : 0, RegionMinX, RegionMinY, RegionSize,
                        CacheBuildSlotWait, CacheBuildSeconds,
                        static_cast<unsigned long long>(AllocatedBytes));
                }
                return Entry;
            }

            if (SnapshotSharedRoomGraphCache(Entry).IsValid())
            {
                return Entry;
            }

            // A different worker is building this exact immutable key.  Waiting on its event
            // avoids duplicate graph work without serializing unrelated region keys.
            const double CacheWaitStart = FPlatformTime::Seconds();
            Entry->ReadyEvent->Wait();
            const double CacheWaitSeconds = FPlatformTime::Seconds() - CacheWaitStart;
            if (Entry->RegionSize <= 2 * CHUNK_SIZE || CacheWaitSeconds >= 0.25)
            {
                UE_LOG(LogTemp, Warning,
                    TEXT("[VoxelForgeSharedCacheTiming] action=wait region=(%d,%d,%d) wait=%.6f"),
                    Entry->RegionMinX, Entry->RegionMinY, Entry->RegionSize, CacheWaitSeconds);
            }
        }
    }

    //=========================================================================
    // RÔLE 1 — SOURCE : GRAPHE DE SALLES / ROOM GRAPH  (TunnelNetwork)
    //=========================================================================
    // ⚠️⚠️ CET OPÉRATEUR N'A PAS RÉÉCRIT `BuildChunkCache` / `EvaluateSDFCached` : IL LES APPELLE.
    //
    // C'est LA décision de ce portage, et elle mérite d'être dite explicitement parce que la
    // tentation inverse est forte : les six autres portages sont des transcriptions littérales.
    // Celui-ci ne peut pas l'être. `BuildChunkCache` porte la discipline d'invariance de fenêtre à
    // deux régions (ARCHITECTURE §8.4) — la région COLLECT (plus large, décide QUELLES primitives
    // existent) et la région STORE (ce qu'on garde) — et c'est le code le plus délicat du plugin.
    // Le transcrire, ce serait le FORKER : deux copies d'un invariant qui dérivent, dont l'une n'est
    // testée que par un test d'équivalence qui compare... la copie à l'original.
    //
    // Ce qui EST transcrit ici, c'est la glu autour : la mémo d'index de strate, la clé de cache par
    // BOÎTE DE RECHERCHE (pas par chunk — voir plus bas), le warp, et les boucles pits/cheminées.
    // ~60 lignes déjà relues, contre ~400 lignes d'algorithme qu'on ne touche pas.
    //
    // This op CALLS the morphology cache rather than transcribing it: BuildChunkCache carries the
    // two-region window-invariance discipline (§8.4) and forking it would be the worst possible
    // outcome of a refactor whose whole point is to have ONE definition of each idea.
    class FRoomGraphSource final : public IVoxelDensityOp
    {
    public:
        FRoomGraphSource(const FStrateGenerationParams& InP, int32 InSeed,
                         const UVoxelStrateManager* InManager)
            : P(InP), Seed(InSeed), SeedU((uint32)InSeed), Manager(InManager)
            , ManagerLifetimeId(InManager ? InManager->GetCacheLifetimeId() : 0)
            , ParamsFingerprint(FCrc::MemCrc32(&InP, sizeof(InP)))
        {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Sdf; }
        EVoxelOpResourceMask ProvidedResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return false; }

        void PrepareChunk(const FVoxelOpContext& Ctx) override
        {
            // La seule chose vraiment constante par chunk ET dépendante du contexte. Le reste
            // (index de strate, pool d'ops) est résolu paresseusement dans `Eval` comme l'original,
            // parce que le cache SDF se ré-clé sur une BOÎTE, pas sur un chunk.
            LayoutVersion = Ctx.LayoutVersion;
        }

        //---------------------------------------------------------------------
        // L'ÉTAT PAR WORKER, ET POURQUOI IL EST SORTI DE `Eval`
        //---------------------------------------------------------------------
        // Les modificateurs de détail de l'étape B ont besoin de ce que CETTE source a produit pour
        // CE voxel : le cache SDF (les terrasses le ré-interrogent en Z±1, les colonnes le
        // parcourent) et l'index de la salle la plus proche (arches, dômes, pincement, biais de sol).
        // Dans l'original tout cela vit dans des `thread_local` d'une seule fonction de 1080 lignes ;
        // ici la source les possède et les expose.
        //
        // The state belongs to this source instance. The outer tunnel cache retains the immutable
        // op stack, so retaining the source's prepared SDF window with that stack avoids rebuilding
        // the room graph every time a coarse tile switches between cached chunk keys. It remains
        // worker-local because each op stack lives in the thread-local density cache.
        struct FState
        {
            // Fallback only for the invalid-owner path. Normal evaluations point at the worker-local
            // shared cache bank below, so switching exact chunk op-stacks does not rebuild the room
            // graph merely because the stack object changed.
            FChunkSDFCache Cache;
            const FChunkSDFCache* ActiveCache = nullptr;
            // Coarse density samples use the process-local immutable graph cache. Keep the entry
            // alive for the whole sequence of detail operators that consume ActiveCache.
            TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>
                SharedCacheEntry;

            /** La salle de SDF minimal pour le dernier voxel évalué. -1 = aucune. */
            int32 NearestRoom = -1;

        /** The warped SDF-space position belonging to the current voxel. */
        FVector LastWarpedPosition = FVector::ZeroVector;

            /** The unwarped position belonging to the current voxel. */
            FVector LastWorldPosition = FVector::ZeroVector;

            // The common generator tail runs after disturbances.  The tunnel structural posts
            // already evaluate this immutable result inside the stack; retain the exact same
            // sample's answer so the tail does not scan the tunnel list a second time.
            FTunnelCoreWorldEvaluation LastTunnelCoreWorldEvaluation;
            FVector LastTunnelCoreEvaluationPosition = FVector::ZeroVector;
            bool bLastTunnelCoreWorldEvaluationValid = false;
            bool bLastRoomOwnsBottom = false;
            bool bLastRoomOwnsBottomValid = false;

            /** ÉTAPE C1 — les params de la strate avec l'op de CETTE salle appliqué par-dessus.
             *  Mémo par voxel : invalidé au début de chaque `Eval`, calculé au PREMIER modificateur
             *  qui le demande. C'est ce qui reproduit le coût de l'original (une copie de struct par
             *  voxel PRÈS D'UNE SURFACE, pas partout) sans que onze opérateurs la refassent chacun. */
            FStrateGenerationParams LocalParams;
            bool bLocalParamsValid = false;

            // Window invariance is a cache-policy proof, not a sample evaluator.  Keep its result
            // beside the worker-local source state so LOD0 does not pay the full reach walk once
            // per voxel.
            bool bTileCachePolicyValid = false;
            bool bTileCachePolicyResult = false;
            bool bTileCachePolicyHasContext = false;
            int32 TileCachePolicySampleStep = 0;
            FIntVector TileCachePolicyOrigin = FIntVector::ZeroValue;
            int32 TileCachePolicyStep = 0;
            int32 TileCachePolicyCells = 0;
            uint32 TileCachePolicyFingerprint = 0xFFFFFFFFu;
            uint32 TileCachePolicyLayout = 0xFFFFFFFFu;
            uint64 TileCachePolicyManagerLifetimeId = 0;
            const TArray<FStrateTerrainOpEntry>* TileCachePolicyTerrainOps = nullptr;
        };

        FState& State() const
        {
            // The prepared SDF data lives in the worker-local keyed cache bank above.  This state
            // is only scratch for the current EvalSample: Eval resets NearestRoom and the local
            // parameter memo before its detail ops consume them.  A single TLS slot is therefore
            // safe even when this worker switches between immutable source instances, and avoids
            // a map lookup on every sample.  A mutable member is not safe because stacks can be
            // shared by concurrent readers during generation.
            static thread_local FState Scratch;
            return Scratch;
        }

        /** Le cache que la source vient de bâtir/servir pour ce voxel. Lu par les colonnes (4d). */
        const FChunkSDFCache& GetCache() const
        {
            return State().ActiveCache != nullptr ? *State().ActiveCache : State().Cache;
        }

        /** L'index de la salle la plus proche pour le dernier voxel évalué. -1 = aucune.
         *  Lu par les arches, les dômes, le pincement et le biais de sol. */
        int32 GetNearestRoomIdx() const { return State().NearestRoom; }

        /** Restore the source-owned state belonging to one sample before a later block op reads it. */
        void RestoreBlockSample(const FVoxelOpSample& Sample) const
        {
            FState& S = State();
            S.ActiveCache = Sample.RoomCache;
            S.NearestRoom = Sample.NearestRoomIndex;
            S.bLocalParamsValid = false;
            S.bLastRoomOwnsBottomValid = false;
        }

        bool TryGetLastTunnelCoreWorldEvaluation(
            FTunnelCoreWorldEvaluation& OutEvaluation) const override
        {
            if (VoxelDensityAblation::IsTunnelCoreOff())
            {
                return false;
            }
            FState& S = State();
            if (!S.bLastTunnelCoreWorldEvaluationValid
                || S.LastTunnelCoreEvaluationPosition != S.LastWorldPosition)
            {
                if (!(P.RoomDensity > 0.0f && P.RoomSpacing > 0.0f))
                {
                    return false;
                }

                // The common generator tail runs after EvalMC.  The stack has already evaluated
                // the graph source for this exact sample, but the native tunnel-core post is
                // intentionally outside the stack because it must remain after disturbances.  On
                // demand, publish the one combined result here so the tail can reuse it without
                // building/scanning a second native cache.
                const FVector& Position = S.LastWorldPosition;
                S.LastTunnelCoreWorldEvaluation = VoxelCaveMorphology::EvaluateTunnelCoreWorld(
                    Position.X, Position.Y, Position.Z, GetCache(), nullptr,
                    VoxelGenLOD::ShouldUseSpatialIndex(false),
                    &S.LastWarpedPosition,
                    S.bLastRoomOwnsBottomValid ? &S.bLastRoomOwnsBottom : nullptr);
                S.LastTunnelCoreEvaluationPosition = Position;
                S.bLastTunnelCoreWorldEvaluationValid = true;
            }
            OutEvaluation = S.LastTunnelCoreWorldEvaluation;
            return true;
        }

        /**
         * ÉTAPE C1 — L'OVERRIDE D'OP PAR SALLE. Les params de la strate avec l'op de terrain tiré
         * pour la salle la plus proche appliqué par-dessus. **ONZE des douze modificateurs de détail
         * lisent ceci au lieu de leurs propres params.**
         *
         * ⚠️ POURQUOI ÇA VIT ICI ET PAS DANS CHAQUE MODIFICATEUR.
         * `OPSTACK-DECOMPOSITION §2` disait que cette pièce n'a « pas de domicile propre » et
         * proposait de donner à chaque modificateur un prédicat « seulement dans la salle N ». La
         * difficulté venait d'une hypothèse : que chaque modificateur doive POSSÉDER ses params. Dès
         * qu'UN opérateur possède l'état partagé et que les autres le LISENT, elle disparaît — et ce
         * motif est déjà celui de `FOverhangShelfMod` ← `FSurfaceColumnSource` et de
         * `FShaftLedgeMod` ← `FShaftFieldSource`. C'est la résolution des pits/cheminées une
         * deuxième fois : ne pas inventer de mécanisme de portée, laisser une source publier.
         *
         * ⚠️ LA COPIE DE ~74 CHAMPS PAR VOXEL EST TRANSCRITE TELLE QUELLE. L'original écrit
         * `FStrateGenerationParams LocalTerrainParams = Params;` dans le bloc par voxel. C'est un
         * poste de perf réel, noté dans OPSTACK-PROGRESS ; le mémo ci-dessous garantit seulement
         * qu'on ne la fait pas ONZE fois là où l'original la fait une.
         *
         * ⚠️ **LA RUGOSITÉ (4b) N'APPELLE PAS CECI**, et c'est la lecture du code, pas une
         * simplification : dans l'original le shadow `const FStrateGenerationParams& Params =
         * LocalTerrainParams;` est déclaré DANS le bloc `if (bNearCaveSurface)` qui commence APRÈS
         * l'étape 4b. La rugosité lit les params de la strate. Douze modificateurs, onze lecteurs.
         *
         * One op owns the shared state and the rest read it — the same pattern the surface and shaft
         * ports already use, and the reason §2's "no clean home" problem evaporates. The ~74-field
         * per-voxel copy is the original's, kept. Roughness (4b) deliberately does NOT read this.
         */
        const FStrateGenerationParams& LocalParams() const
        {
            FState& S = State();
            if (!S.bLocalParamsValid)
            {
                S.LocalParams = P;
                const FChunkSDFCache& Cache = GetCache();
                if (S.NearestRoom >= 0 && Cache.Rooms.IsValidIndex(S.NearestRoom))
                {
                    const FCachedRoom& NR = Cache.Rooms[S.NearestRoom];
                    if (NR.RoomOp)
                    {
                        // N'écrit que les champs propres au type de l'op ; tout le reste garde la
                        // valeur de la strate. Exactement l'appel de l'original.
                        NR.RoomOp->ApplyTo(S.LocalParams, NR.RoomOpWeight);
                    }
                }
                S.bLocalParamsValid = true;
            }
            return S.LocalParams;
        }

        /**
         * Une requête SDF supplémentaire dans le cache courant, pour les sondes de gradient des
         * terrasses.
         *
         * ⚠️ TRANSCRIT TEL QUEL, Y COMPRIS CE QUI SEMBLE INCOHÉRENT : l'original sonde en
         * `(WorldX, WorldY, WorldZ ± 1)` — coordonnées NON warpées et Z NON divisé par
         * `VerticalScale` — alors que le champ qu'il sonde a été évalué en coordonnées WARPÉES et en
         * Z effectif. La sonde ne voit donc pas exactement le champ dont elle mesure la pente, et
         * elle ignore aussi les pits et les cheminées. C'est un écart réel de l'original ; le
         * corriger changerait le monde, donc il est NOTÉ (OPSTACK-PROGRESS) et porté à l'identique.
         *
         * Transcribed as-is including what looks wrong: the probe uses unwarped X/Y and raw Z while
         * the field it probes was evaluated warped, and it excludes pits/chimneys.
         */
        float ProbeSdfUnwarped(float X, float Y, float Z) const
        {
            return VoxelCaveMorphology::EvaluateSDFCached(
                X, Y, Z, GetCache(), P.SDFBlendRadius, nullptr,
                VoxelGenLOD::ShouldUseSpatialIndex(false));
        }

        /** Le Z « effectif » : `VerticalScale` étire le monde AVANT le bruit. Pure fonction de Z et
         *  d'un param — c'est pourquoi ce portage n'a PAS eu besoin d'un opérateur « frame »
         *  (voir la note de conception dans BuildTunnelNetworkStack). */
        FORCEINLINE float EffZ(float WorldZ) const
        {
            return (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f) ? (WorldZ / P.VerticalScale)
                                                                       : WorldZ;
        }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            VoxelDensityProfile::FScopedTimer ProfileTimer(
                VoxelDensityProfile::EBucket::RoomGraphSource);
            FState& S = State();
            S.LastWorldPosition = FVector(WorldX, WorldY, WorldZ);
            S.bLastTunnelCoreWorldEvaluationValid = false;
            S.bLastRoomOwnsBottomValid = false;

            // ⚠️ REMIS À -1 INCONDITIONNELLEMENT, ce que l'original ne fait pas : chez lui
            // `NearestRoomIdx` est un `thread_local` qui, quand `RoomDensity <= 0`, garde la valeur
            // du voxel PRÉCÉDENT. Inobservable là-bas (sans salles, `CaveSDF` reste FLT_MAX, donc
            // `bNearCaveSurface` est faux et aucun consommateur ne tourne) — mais ici les
            // consommateurs sont des objets séparés, et une valeur périmée qui traverse une frontière
            // d'opérateur est le genre de chose qu'on ne retrouve pas. On paie une écriture.
            S.NearestRoom = -1;
            // ÉTAPE C1 — le mémo d'override est PAR VOXEL. L'invalider ici, avant tout early-out,
            // est ce qui garantit qu'aucun modificateur ne lira les params de la salle du voxel
            // précédent. (Le mémo n'est PAS recalculé ici : le faire coûterait une copie de struct
            // sur chaque voxel de roc profond, ce que l'original ne paie pas.)
            S.bLocalParamsValid = false;

            const UVoxelStrateManager* LiveManager = Manager.Get();
            // A cached stack may outlive its UObject owner when an editor world is stopped. The
            // generator's manager-lifetime key prevents selecting it normally; this guard is the
            // final boundary for a task that is already inside an old stack. Keep commandlet stacks
            // (which deliberately have no manager) functional, but never evaluate stale room data.
            if (ManagerLifetimeId != 0 && LiveManager == nullptr)
            {
                S.Cache = FChunkSDFCache();
                S.SharedCacheEntry.Reset();
                S.ActiveCache = &S.Cache;
                InOut.Sdf = FLT_MAX;
                return;
            }

            if (!(P.RoomDensity > 0.0f && P.RoomSpacing > 0.0f))
            {
                S.SharedCacheEntry.Reset();
                S.ActiveCache = &S.Cache;
                return;   // Sdf reste FLT_MAX
            }

            const float EffectiveZ = EffZ(WorldZ);

            //---------------------------------------------------------------
            // WARP DE CAVE — coordonnées de REQUÊTE uniquement
            //---------------------------------------------------------------
            // ⚠️ Le warp ne s'applique QU'À la requête du graphe de salles. Les pits et les cheminées
            // plus bas lisent les coordonnées RÉELLES, et c'est délibéré dans l'original : leurs
            // ancres viennent de centres de salles NON warpés. C'est aussi pourquoi le warp n'est pas
            // un « frame » : sa portée est exactement UN opérateur, donc elle appartient à cet
            // opérateur.
            float WarpedX = WorldX, WarpedY = WorldY, WarpedZ = EffectiveZ;
            if (!VoxelDensityAblation::IsCaveWarpOff() && P.CaveWarpStrength > 0.0f)
            {
                const float WF = P.CaveWarpFrequency;
                const float WS = P.CaveWarpStrength;
                float WarpX, WarpY, WarpZ;
                VoxelNoise::Perlin3D_x3(
                    WorldX * WF + VoxelHash::SeedOffset(SeedU, 0.37f),
                    WorldY * WF + 1.3f,
                    EffectiveZ * WF + 5.7f,
                    WorldX * WF + 7.1f,
                    WorldY * WF + VoxelHash::SeedOffset(SeedU, 0.59f),
                    EffectiveZ * WF + 2.3f,
                    WorldX * WF + 11.3f,
                    WorldY * WF + 9.7f,
                    EffectiveZ * WF + VoxelHash::SeedOffset(SeedU, 0.41f),
                    WarpX, WarpY, WarpZ);
                WarpedX += WarpX * VOXEL_NOISE_SCALE * WS;
                WarpedY += WarpY * VOXEL_NOISE_SCALE * WS;
                WarpedZ += WarpZ * VOXEL_NOISE_SCALE * WS;
            }
            S.LastWarpedPosition = FVector(WarpedX, WarpedY, WarpedZ);

            //---------------------------------------------------------------
            // LE CACHE PAR BOÎTE DE RECHERCHE
            //---------------------------------------------------------------
            // ⚠️ CLÉ PAR BOÎTE, PAS PAR CHUNK, et c'est un INVARIANT DE PERF (§8.10) : les
            // échantillons de gradient interrogent `WorldX ± 1` et le warp déplace encore, donc une
            // clé « égalité de chunk » se retournait à chaque cellule de bord et reconstruisait le
            // cache (coûteux) en boucle. Comme le cache couvre la boîte + MaxInfluence, toute requête
            // DANS la boîte est correcte. Ne pas « simplifier » en clé de chunk.
            // (Les champs de cache vivent dans `FState`, au-dessus, pour que les modificateurs de
            // détail puissent les lire ; ce sont des `thread_local` partagés entre instances.)
            // ⚠️ LA CLÉ INCLUT LES PARAMS, CONTRAIREMENT À L'ORIGINAL.
            // L'original ne clé QUE sur (boîte, strate, seed) : deux jeux de params différents dans
            // la MÊME strate au MÊME seed se servent mutuellement leur cache. En production
            // `RebuildStrates` masque le trou en bougeant la strate ; en test, deux piles construites
            // côte à côte le déclenchent immédiatement. Empreinte CRC des params + LayoutVersion.
            // `FStrateGenerationParams` est du POD pur (aucun TArray/FString/pointeur), donc une CRC
            // mémoire ne peut pas donner un FAUX POSITIF ; au pire un padding donne un faux MANQUE,
            // c'est-à-dire un recalcul. On se trompe du côté du CPU, jamais du côté d'une salle fausse.

            // Index de strate — mémo (chunk-Z, version de layout), transcrit tel quel. La requête
            // vise le CENTRE de la bande, donc le résultat est une fonction pure de la clé.
            int32 StrateIdx = 0;
            if (LiveManager)
            {
                thread_local int32  SI_ChunkZ  = INT32_MAX;
                thread_local uint32 SI_Version = 0xFFFFFFFFu;
                thread_local int32  SI_Index   = 0;
                const int32 QZ = FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE);
                const uint32 LV = LiveManager->GetLayoutVersion();
                if (QZ != SI_ChunkZ || LV != SI_Version)
                {
                    SI_ChunkZ  = QZ;
                    SI_Version = LV;
                    SI_Index = LiveManager->GetStrateIndex(
                        ((float)QZ + 0.5f) * CHUNK_SIZE * VOXEL_SIZE);
                }
                StrateIdx = SI_Index;
            }

            // The graph is window-invariant, so a tile worker can use the exact requesting tile as
            // its deterministic XY cache region.  The step/origin/cell extent is supplied by the
            // mesher through VoxelGenLOD TLS; ordinary point queries keep the historical region
            // policy.  The cache key retains the exact params/strate/op-pool identity, so no
            // blended chunk can borrow another chunk's room graph.
            const int32 SampleStep = FMath::Max(VoxelGenLOD::SampleStep, 1);
            FIntVector RequestedTileOrigin = FIntVector::ZeroValue;
            int32 RequestedTileStep = SampleStep;
            int32 RequestedTileCells = 0;
            const TArray<FStrateTerrainOpEntry>* TerrainOps = nullptr;
            if (LiveManager)
            {
                const int32 ChunkX = FMath::FloorToInt(WorldX / (float)CHUNK_SIZE);
                const int32 ChunkY = FMath::FloorToInt(WorldY / (float)CHUNK_SIZE);
                const int32 ChunkZ = FMath::FloorToInt(WorldZ / (float)CHUNK_SIZE);
                UVoxelStrateDefinition* Def = LiveManager->GetStrateForChunk(
                    FIntVector(ChunkX, ChunkY, ChunkZ));
                if (Def) { TerrainOps = &Def->TerrainOperations; }
            }
            const bool bTileWindowEligible = VoxelGenLOD::IsTileCacheWindowEnabled(false);
            const bool bHasTileWindowContext = VoxelGenLOD::GetThreadTileCacheWindow(
                RequestedTileOrigin, RequestedTileStep, RequestedTileCells);
            const bool bTilePolicyKeyChanged =
                !S.bTileCachePolicyValid
                || S.bTileCachePolicyHasContext
                    != (bTileWindowEligible && bHasTileWindowContext)
                || S.TileCachePolicySampleStep != RequestedTileStep
                || S.TileCachePolicyOrigin != RequestedTileOrigin
                || S.TileCachePolicyStep != RequestedTileStep
                || S.TileCachePolicyCells != RequestedTileCells
                || S.TileCachePolicyFingerprint != ParamsFingerprint
                || S.TileCachePolicyLayout != LayoutVersion
                || S.TileCachePolicyManagerLifetimeId != ManagerLifetimeId
                || S.TileCachePolicyTerrainOps != TerrainOps;
            if (bTilePolicyKeyChanged)
            {
                S.bTileCachePolicyValid = true;
                S.bTileCachePolicyHasContext = bTileWindowEligible && bHasTileWindowContext;
                S.TileCachePolicySampleStep = RequestedTileStep;
                S.TileCachePolicyOrigin = RequestedTileOrigin;
                S.TileCachePolicyStep = RequestedTileStep;
                S.TileCachePolicyCells = RequestedTileCells;
                S.TileCachePolicyFingerprint = ParamsFingerprint;
                S.TileCachePolicyLayout = LayoutVersion;
                S.TileCachePolicyManagerLifetimeId = ManagerLifetimeId;
                S.TileCachePolicyTerrainOps = TerrainOps;
                S.bTileCachePolicyResult = S.bTileCachePolicyHasContext
                    && VoxelCaveMorphology::IsRoomGraphWindowInvariant(P, TerrainOps);
            }
            const bool bUseTileCacheWindow = S.bTileCachePolicyResult;
            int32 RegionSize = 0;
            int32 RegionMinX = 0;
            int32 RegionMinY = 0;
            if (bUseTileCacheWindow)
            {
                RegionSize = static_cast<int32>(
                    static_cast<int64>(RequestedTileStep)
                    * static_cast<int64>(RequestedTileCells));
                RegionMinX = RequestedTileOrigin.X;
                RegionMinY = RequestedTileOrigin.Y;
            }
            else
            {
                // Fine requests retain the historical four-chunk worker window. The op-stack
                // tile-sized window is gated to LOD4+ (the fused path starts at LOD3), so
                // LOD0-LOD2 and the op-stack's LOD3 floor do not pay a full tile rebuild on their
                // critical path while still reusing neighbouring chunks on the same worker.
                const int32 RegionChunks = 4;
                RegionSize = CHUNK_SIZE * RegionChunks;
                const int32 RegionCellX = FMath::FloorToInt(WorldX / (float)RegionSize);
                const int32 RegionCellY = FMath::FloorToInt(WorldY / (float)RegionSize);
                RegionMinX = RegionCellX * RegionSize;
                RegionMinY = RegionCellY * RegionSize;
            }
            const float CacheExpansion = FMath::Abs(P.CaveWarpStrength)
                * VOXEL_NOISE_SCALE * VF_PerlinAbsBound
                + (bUseTileCacheWindow ? static_cast<float>(SampleStep) : 0.0f)
                + 2.0f;

            if (SampleStep > 1)
            {
                TSharedPtr<const FChunkSDFCache, ESPMode::ThreadSafe> SharedRoomGraphCache =
                    S.SharedCacheEntry.IsValid()
                        ? SnapshotSharedRoomGraphCache(S.SharedCacheEntry)
                        : TSharedPtr<const FChunkSDFCache, ESPMode::ThreadSafe>();
                const bool bSharedCacheMatches =
                    S.SharedCacheEntry.IsValid()
                    && SharedRoomGraphCache.IsValid()
                    && S.SharedCacheEntry->Seed == SeedU
                    && S.SharedCacheEntry->StrateIndex == StrateIdx
                    && S.SharedCacheEntry->ParamsFingerprint == ParamsFingerprint
                    && S.SharedCacheEntry->LayoutVersion == LayoutVersion
                    && S.SharedCacheEntry->ManagerLifetimeId == ManagerLifetimeId
                    && S.SharedCacheEntry->TerrainOps == TerrainOps
                    && S.SharedCacheEntry->RegionMinX == RegionMinX
                    && S.SharedCacheEntry->RegionMinY == RegionMinY
                    && S.SharedCacheEntry->RegionSize == RegionSize;
                if (!bSharedCacheMatches)
                {
                    S.SharedCacheEntry = FindOrBuildSharedRoomGraphCache(
                        SeedU, StrateIdx, ParamsFingerprint, LayoutVersion,
                        ManagerLifetimeId, TerrainOps,
                        RegionMinX, RegionMinY, RegionSize,
                        (float)RegionMinX - CacheExpansion,
                        (float)RegionMinY - CacheExpansion,
                        (float)(RegionMinX + RegionSize) + CacheExpansion,
                        (float)(RegionMinY + RegionSize) + CacheExpansion,
                        P,
                        ERoomGraphBuildSite::OpShared);
                    SharedRoomGraphCache = SnapshotSharedRoomGraphCache(S.SharedCacheEntry);
                }
                S.ActiveCache = SharedRoomGraphCache.Get();
            }
            else
            {
                S.SharedCacheEntry.Reset();
                FRoomGraphCacheEntry* LocalCache = FindRoomGraphCacheEntry(
                    SeedU, StrateIdx, ParamsFingerprint, LayoutVersion,
                    ManagerLifetimeId, TerrainOps,
                    RegionMinX, RegionMinY, RegionSize);
                const bool bCacheMatches = LocalCache->bValid
                    && LocalCache->Seed == SeedU
                    && LocalCache->StrateIndex == StrateIdx
                    && LocalCache->ParamsFingerprint == ParamsFingerprint
                    && LocalCache->LayoutVersion == LayoutVersion
                    && LocalCache->ManagerLifetimeId == ManagerLifetimeId
                    && LocalCache->TerrainOps == TerrainOps
                    && LocalCache->RegionMinX == RegionMinX
                    && LocalCache->RegionMinY == RegionMinY
                    && LocalCache->RegionSize == RegionSize;
                if (!bCacheMatches)
                {
                    LocalCache->bValid = false;
                    LocalCache->Seed = SeedU;
                    LocalCache->StrateIndex = StrateIdx;
                    LocalCache->ParamsFingerprint = ParamsFingerprint;
                    LocalCache->LayoutVersion = LayoutVersion;
                    LocalCache->ManagerLifetimeId = ManagerLifetimeId;
                    LocalCache->TerrainOps = TerrainOps;
                    LocalCache->RegionMinX = RegionMinX;
                    LocalCache->RegionMinY = RegionMinY;
                    LocalCache->RegionSize = RegionSize;
                    VoxelCaveMorphology::BuildChunkCache(
                        LocalCache->Cache,
                        (float)RegionMinX - CacheExpansion,
                        (float)RegionMinY - CacheExpansion,
                        (float)(RegionMinX + RegionSize) + CacheExpansion,
                        (float)(RegionMinY + RegionSize) + CacheExpansion,
                         P, SeedU, StrateIdx, TerrainOps,
                         ERoomGraphBuildSite::OpLocal);
                    LocalCache->bValid = true;
                    VoxelDensityOps::ReportWorkerRoomGraphCacheFootprint();
                }
                S.ActiveCache = &LocalCache->Cache;
            }
            const bool bUseSpatialIndex = VoxelGenLOD::ShouldUseSpatialIndex(false);
            const FVector WorldTunnelPosition(WorldX, WorldY, WorldZ);
            float CaveSDF = VoxelCaveMorphology::EvaluateSDFCached(
                WarpedX, WarpedY, WarpedZ, GetCache(), P.SDFBlendRadius,
                &S.NearestRoom, bUseSpatialIndex, &WorldTunnelPosition,
                &S.bLastRoomOwnsBottom);
            S.bLastRoomOwnsBottomValid = true;

            //---------------------------------------------------------------
            // PITS & CHEMINÉES — coordonnées RÉELLES, SmoothMin dans le même canal SDF
            //---------------------------------------------------------------
            // C'est le point que `OPSTACK-DECOMPOSITION §2` annonçait comme « le plus retors de toute
            // la décomposition » : deux primitives qui écrivent le MÊME canal que le graphe de salles
            // mais à des coordonnées NON warpées. Sous un modèle de frames il aurait fallu les sortir
            // du frame tout en gardant le canal — exprimable, mais tordu. Dans un opérateur unique la
            // difficulté disparaît : le warp est une variable locale, pas un contexte hérité.
            if (!VoxelDensityAblation::IsPitChimneySDFOff())
            {
                auto EvaluatePit = [&](int32 PitIndex)
                {
                    const FCachedPit& Pit = GetCache().Pits[PitIndex];
                    const float DZ = WorldZ - Pit.TopZ;
                    if (DZ >= Pit.BlendK) { return; }
                    if (-DZ > Pit.Depth + Pit.BlendK) { return; }

                    const float DX = WorldX - Pit.CenterX;
                    const float DY = WorldY - Pit.CenterY;
                    const float XYDistSq = DX * DX + DY * DY;
                    if (XYDistSq > Pit.BoundXYRadiusSq) { return; }

                    float PitSDF;
                    if (DZ <= 0.0f)
                    {
                        const float DepthBelow  = -DZ;
                        float FlareFactor = FMath::Clamp(1.0f - DepthBelow / Pit.FlareDist, 0.0f, 1.0f);
                        FlareFactor       = FlareFactor * FlareFactor;
                        const float EffRadius = Pit.Radius + Pit.FlareExtra * FlareFactor;
                        PitSDF = FMath::Sqrt(XYDistSq) - EffRadius;
                    }
                    else
                    {
                        PitSDF = FMath::Sqrt(XYDistSq) - (Pit.Radius + Pit.FlareExtra);
                    }

                    CaveSDF = VoxelSDF::SmoothMin(CaveSDF, PitSDF, Pit.BlendK);
                };
            if (!VoxelDensityAblation::IsPitChimneySDFOff())
            {
                VF_ForEachChunkSDFSpatialCandidate(
                    GetCache().PitSpatialIndex, GetCache().Pits.Num(),
                    WorldX, WorldY, EvaluatePit, bUseSpatialIndex);
            }

                auto EvaluateChimney = [&](int32 ChimneyIndex)
                {
                    const FCachedChimney& Chim = GetCache().Chimneys[ChimneyIndex];
                    const float DZ = WorldZ - Chim.BottomZ;
                    if (-DZ >= Chim.BlendK) { return; }
                    if (DZ > Chim.Height + Chim.BlendK) { return; }

                    const float DX = WorldX - Chim.CenterX;
                    const float DY = WorldY - Chim.CenterY;
                    const float XYDistSq = DX * DX + DY * DY;
                    if (XYDistSq > Chim.BoundXYRadiusSq) { return; }

                    float ChmSDF;
                    if (DZ >= 0.0f)
                    {
                        float FlareFactor = FMath::Clamp(1.0f - DZ / Chim.FlareDist, 0.0f, 1.0f);
                        FlareFactor       = FlareFactor * FlareFactor;
                        const float EffRadius = Chim.Radius + Chim.FlareExtra * FlareFactor;
                        ChmSDF = FMath::Sqrt(XYDistSq) - EffRadius;
                    }
                    else
                    {
                        ChmSDF = FMath::Sqrt(XYDistSq) - (Chim.Radius + Chim.FlareExtra);
                    }

                    CaveSDF = VoxelSDF::SmoothMin(CaveSDF, ChmSDF, Chim.BlendK);
                };
            if (!VoxelDensityAblation::IsPitChimneySDFOff())
            {
                VF_ForEachChunkSDFSpatialCandidate(
                    GetCache().ChimneySpatialIndex, GetCache().Chimneys.Num(),
                    WorldX, WorldY, EvaluateChimney, bUseSpatialIndex);
            }
            }

            InOut.Sdf = CaveSDF;

            // Publish the same continuous tunnel-core field that the common generator tail will
            // reassert after generic writers.  The stack does not publish or protect a separate
            // support slab.
            if (!VoxelDensityAblation::IsTunnelCoreOff())
            {
                S.LastTunnelCoreWorldEvaluation = VoxelCaveMorphology::EvaluateTunnelCoreWorld(
                    WorldX, WorldY, WorldZ, GetCache(), nullptr,
                    bUseSpatialIndex, &S.LastWarpedPosition,
                    &S.bLastRoomOwnsBottom);
                S.LastTunnelCoreEvaluationPosition = S.LastWorldPosition;
                S.bLastTunnelCoreWorldEvaluationValid = true;

                // Keep the room-owned bottom hand-off for block evaluation compatibility. The
                // authored floor remains part of the tunnel shape, but it must not win inside a
                // room's own volume.
                InOut.bHasTunnelCoreWorldEvaluation = true;
                InOut.TunnelCoreWorldSDF = S.LastTunnelCoreWorldEvaluation.SDF;
                InOut.bTunnelCoreRoomFloor =
                    S.LastTunnelCoreWorldEvaluation.bRoomFloor;
                InOut.bHasTunnelCoreSweptFloor =
                    S.LastTunnelCoreWorldEvaluation.bHasSweptFloor;
                InOut.TunnelCoreSweptFloorZ =
                    S.LastTunnelCoreWorldEvaluation.SweptFloorZ;
                InOut.TunnelCoreSweptFloorRadius =
                    S.LastTunnelCoreWorldEvaluation.SweptFloorRadius;
            }

            // These cache hand-offs remain valid when tunnel core is off; detail operators still
            // need the room graph and nearest-room ownership.
            InOut.RoomCache = &GetCache();
            InOut.NearestRoomIndex = S.NearestRoom;
        }

        //---------------------------------------------------------------------
        // L'ÉTAT PAR BOÎTE — SÉPARÉ DE `FState`, ET DÉLIBÉRÉMENT
        //---------------------------------------------------------------------
        // `EffectOverBox` construit un cache pour la boîte INTERROGÉE, qui n'est pas la boîte de
        // recherche que `Eval` construit pour le voxel courant. Les faire partager `FState::Cache`
        // serait *correct* — la discipline d'invariance de fenêtre de §8.4 garantit qu'un cache bâti
        // sur une boîte PLUS LARGE donne le même SDF par voxel — mais ça rendrait `ClassifyTile`
        // capable de perturber le cache chaud d'une génération en cours, et un jour quelqu'un
        // paierait cette élégance très cher. Un deuxième cache par worker coûte une allocation
        // amortie ; on la paie.
        //
        // Le cache et l'intervalle sont mémoïsés, et ce n'est pas du confort : les DOUZE
        // modificateurs de détail consultent le même intervalle pour la même boîte. Sans mémo,
        // une tuile coûterait treize `BuildChunkCache` au lieu d'un.
        //
        // Second per-worker cache, on purpose: sharing FState::Cache would be sound but would let
        // tile classification disturb a live generation's hot cache. The verdict is memoised because
        // all twelve detail modifiers ask the same question about the same box.
        struct FBoxState
        {
            FChunkSDFCache Cache;
            const FChunkSDFCache* ActiveCache = nullptr;
            FBox   KeyBox = FBox(ForceInit);
            int32  KeyStrate = INT32_MIN;
            uint32 KeySeed = 0;
            uint32 KeyFingerprint = 0xFFFFFFFFu;
            uint32 KeyLayout = 0xFFFFFFFFu;
            uint64 KeyManagerLifetimeId = 0;
            bool   KeyUsesLatticeProof = false;
            bool   KeyTightenWarpProof = false;
            FIntVector KeyLatticeOrigin = FIntVector::ZeroValue;
            int32  KeyLatticeStep = 1;
            bool   bValid = false;

            // A refined tile proof asks the same source about a root box and then many child
            // boxes.  The morphology cache is window-invariant, so keep the root's superset
            // cache alive for all children instead of rebuilding the graph once per child.
            FBox   CacheWindowBox = FBox(ForceInit);
            int32  CacheWindowStrate = INT32_MIN;
            uint32 CacheWindowSeed = 0;
            uint32 CacheWindowFingerprint = 0xFFFFFFFFu;
            uint32 CacheWindowLayout = 0xFFFFFFFFu;
            uint64 CacheWindowManagerLifetimeId = 0;
            const TArray<FStrateTerrainOpEntry>* CacheWindowTerrainOps = nullptr;
            bool   CacheWindowUsesLatticeProof = false;
            bool   CacheWindowTightenWarpProof = false;
            int32  CacheWindowLatticeStep = 1;
            TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe> CacheWindowSharedEntry;
            int32  CacheWindowSharedRegionMinX = 0;
            int32  CacheWindowSharedRegionMinY = 0;
            int32  CacheWindowSharedRegionSize = 0;
            bool   bCacheWindowUsesShared = false;
            bool   CacheWindowUsesTileCacheWindow = false;
            FIntVector CacheWindowTileOrigin = FIntVector::ZeroValue;
            int32  CacheWindowTileStep = 0;
            int32  CacheWindowTileCells = 0;
            bool   bCacheWindowValid = false;

            // Tight warp bounds are proofs over a box. Refinement asks about nested child boxes,
            // so one bound for the current root is a sound superset for all descendants.
            FBox   TightWarpEnvelopeBox = FBox(ForceInit);
            FVector TightWarpEnvelope = FVector::ZeroVector;
            bool   bTightWarpEnvelopeValid = false;

            // Exact lattice warp queries are shared by all refined children of one classifier
            // root.  The old path rebuilt the same Perlin warp for every small child (64 times on
            // a uniform LOD0 tile).  This is a bounded worker-local scratch array, not a process
            // cache: it is keyed by the current box-proof state and never retains data for a
            // different tile or parameter set.
            TArray<FVector> ExactWarpedLatticeQueries;
            // Four-state results for the exact world-space tunnel-post check. This is a bounded
            // per-window point cache: refinement boxes share boundary vertices, but no interval or
            // tile verdict is retained here.
            TArray<uint8> ExactTailStates;
            // Per-box exact proofs reuse these bounded working arrays. They are scratch only: the
            // arrays are reset before every propagation and never retain an interval or verdict.
            // Keeping their capacity on the worker removes a heap allocation for every refined
            // LOD0 child while preserving the existing 100000-sample safety cap below.
            TArray<FVector> ExactWarpedLatticeScratch;
            TArray<FVector> ExactWorldLatticeScratch;
            FBox   ExactWarpedLatticeCacheBox = FBox(ForceInit);
            int32  ExactWarpedLatticeIX0 = 0;
            int32  ExactWarpedLatticeIY0 = 0;
            int32  ExactWarpedLatticeIZ0 = 0;
            int32  ExactWarpedLatticeNX = 0;
            int32  ExactWarpedLatticeNY = 0;
            int32  ExactWarpedLatticeNZ = 0;
            FIntVector ExactWarpedLatticeOrigin = FIntVector::ZeroValue;
            int32  ExactWarpedLatticeStep = 0;
            uint32 ExactWarpedLatticeSeed = 0xFFFFFFFFu;
            uint32 ExactWarpedLatticeFingerprint = 0xFFFFFFFFu;
            uint32 ExactWarpedLatticeLayout = 0xFFFFFFFFu;
            uint64 ExactWarpedLatticeManagerLifetimeId = 0;
            bool   bExactWarpedLatticeCacheValid = false;

            EVoxelOpEffect Verdict = EVoxelOpEffect::Both;
            FVoxelBoxSdfInterval SdfInterval;

            /** DIAGNOSTIC — combien de primitives de chaque classe atteignent la dernière boîte
             *  interrogée, et combien le cache en contenait. Lu par les tests via
             *  `VoxelDensityOps::GetLastRoomBoxDiagnostic`. N'entre dans aucune décision. */
            int32 HitRooms = 0, HitTunnels = 0, HitPits = 0, HitChimneys = 0;
            int32 NumRooms = 0, NumTunnels = 0, NumPits = 0, NumChimneys = 0;
            /** Les mêmes comptes avec une dilatation de warp NULLE, et de combien de voxels la
             *  boîte est dilatée. C'est la mesure qui manquait pendant trois builds : sans elle,
             *  « les tunnels bloquent » et « ma boîte est 125x trop grosse » sont indiscernables. */
            int32 HitRoomsNoWarp = 0, HitTunnelsNoWarp = 0;
            float WarpDilation = 0.0f;
            bool bMayHaveTunnelCoreAir = false;
            bool bMayHaveTunnelSupportFloor = false;
            bool bMayHaveTunnelCoreTail = false;
            uint32 ExactTailQueries = 0;
            uint32 ExactTailEvaluated = 0;
            uint64 ExactTailCycles = 0;
            uint64 PropagateCycles = 0;
            uint64 ExactPrimitiveCycles = 0;
            uint64 CacheWindowCycles = 0;
            int32 NumRoomFloorJoins = 0;
        };

        static FBoxState& BoxState()
        {
            thread_local FBoxState S;
            return S;
        }

        const FChunkSDFCache& GetBoxCache() const
        {
            const FBoxState& B = BoxState();
            return B.ActiveCache != nullptr ? *B.ActiveCache : B.Cache;
        }

        /**
         * ✅ LA RÉPONSE SPATIALE. La dette annoncée ici pendant tout le portage est payée.
         *
         * Ce que ça débloque, en un mot : la source publie un intervalle SDF et `FSdfConvertOp`
         * ainsi que les douze modificateurs de détail décident séparément, à partir de cet
         * intervalle, s'ils sont identités. Une boîte éloignée peut donc éteindre toute la chaîne,
         * mais aucune source ne répond au nom d'un convertisseur ou d'un modificateur.
         *
         * LE CRITÈRE — **UNE PRIMITIVE NE COMPTE PAS SI ELLE RATE SON CULL *OU* SI SON SDF RESTE
         * AU-DESSUS DU SEUIL `T`.** Une disjonction, pas une seule règle, et chaque branche gagne sur
         * une classe différente. Le détail de `T` et sa condition de validité sont dans la note
         * « LE SEUIL T » à l'intérieur de la fonction — la lire avant toute modification.
         *
         *  • branche CULL — `Eval` part de `MinSDF = FLT_MAX` et ne l'abaisse que via une primitive
         *    qui SURVIT à son cull par voxel. Aucune survivante ⇒ `Sdf` reste `FLT_MAX`. C'est la
         *    même inégalité que le cull, élevée du point à la boîte. **Meilleure pour les salles** :
         *    leur cull (`Rmax + 3K`) est plus serré que le seuil (`Rmax + T + K`).
         *  • branche SEUIL — une primitive peut survivre à son cull et rester malgré tout trop loin
         *    pour qu'un consommateur s'allume. **Meilleure pour les tunnels**, dont le cull est la
         *    sphère englobante d'une capsule : rayon ~107 pour un tube de rayon 7 long de 200.
         *
         * Mélanger les deux est sûr : les primitives de la branche cull ne contribuent RIEN, les
         * autres sont toutes ≥ `T + K`, donc le pli vaut ≥ `T` (voir la saturation de `SmoothMin`),
         * et les trois consommateurs sont éteints. Une seule raison d'échouer, dans les deux cas.
         *
         * LES TROIS CHOSES QUI RENDENT LE TEST CONSERVATIF DU BON CÔTÉ :
         *  1. le warp déplace la coordonnée de REQUÊTE, donc la boîte est dilatée de sa borne
         *     prouvable avant d'être confrontée aux salles et aux tunnels ;
         *  2. les pits et les cheminées sont interrogés en coordonnées RÉELLES (voir `Eval`), donc
         *     ils sont confrontés à la boîte NON dilatée — la dilater serait juste plus prudent, ne
         *     pas la dilater pour eux serait faux ;
         *  3. la boîte de recherche du cache est PLUS LARGE que celle de `Eval`, ce qui donne un
         *     SUR-ensemble de primitives : si rien n'atteint la boîte ici, rien ne l'atteint là-bas.
         *
         * The criterion is the per-voxel cull lifted from point to box. The source publishes only
         * its own SDF interval; the converter and the twelve modifiers consume that interval in
         * their own state-aware folds.
         */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            // This source writes SDF only. It must never answer for a converter or modifier that
            // happens to follow it; the interval is the source's complete box-query contract.
            return EVoxelOpEffect::Identity;
        }

        // This operator publishes SDF and does not change Density.  Reporting zero here is
        // important: FLT_MAX means "an unknown density delta", whereas this source has no density
        // delta at all.  The SDF interval remains the source's separate box contract below.
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        /**
         * State-aware detail gate support.  A room terrain op can replace the strate-level
         * activation/strength fields for the room selected by Eval.  Until the cache tells us
         * that the queried box contains no such override, a detail bound based on P alone would be
         * unsound.  Returning true on an invalid box state deliberately loses a skip rather than
         * manufacturing one.
         */
        bool HasRoomTerrainOverrideForLastBox() const
        {
            const FBoxState& B = BoxState();
            if (!B.bValid) { return true; }
            for (const FCachedRoom& Room : GetBoxCache().Rooms)
            {
                if (Room.RoomOp != nullptr) { return true; }
            }
            return false;
        }

        float RoomColumnFillSupremumForLastBox() const
        {
            const FBoxState& B = BoxState();
            if (!B.bValid) { return FLT_MAX; }

            float Supremum = 0.0f;
            for (const FCachedColumn& Column : GetBoxCache().Columns)
            {
                if (!VoxelMath::IsFinite(Column.BaseDensity) || Column.BaseDensity < 0.0f)
                {
                    // Eval multiplies by BaseDensity.  A negative authored value reverses the
                    // declared FillOnly direction, so the state-aware caller must fall back to
                    // Both/unknown rather than pretend this is a fill envelope.
                    return FLT_MAX;
                }
                const float Contribution = Column.BaseDensity * 1.5f;
                if (!VoxelMath::IsFinite(Contribution)
                    || Supremum > FLT_MAX - Contribution)
                {
                    return FLT_MAX;
                }
                Supremum += Contribution;
            }
            return Supremum;
        }

        float FloorBiasFillSupremumForLastBox() const
        {
            const FBoxState& B = BoxState();
            if (!B.bValid) { return FLT_MAX; }

            // Eval uses NormZ² only below the room centre.  The largest value over the queried
            // box is therefore the squared distance from the room centre to Box.Min.Z, divided by
            // max(RadiusZ, 1)².  Taking the maximum over cached rooms is conservative for whichever
            // room wins the nearest-SDF query, and is finite without assuming a global room height.
            float Supremum = 0.0f;
            const float BoxMinZ = static_cast<float>(B.KeyBox.Min.Z);
            if (!VoxelMath::IsFinite(BoxMinZ)) { return FLT_MAX; }
            for (const FCachedRoom& Room : GetBoxCache().Rooms)
            {
                const float CenterZ = static_cast<float>(Room.Center.Z);
                const float RadiusZ = Room.RadiusZ;
                if (!VoxelMath::IsFinite(CenterZ) || !VoxelMath::IsFinite(RadiusZ)
                    || !VoxelMath::IsFinite(P.FloorBias) || P.FloorBias < 0.0f)
                {
                    return FLT_MAX;
                }
                const float Denominator = FMath::Max(RadiusZ, 1.0f);
                const float Below = FMath::Max(CenterZ - BoxMinZ, 0.0f);
                const float Normalized = Below / Denominator;
                const float Contribution = Normalized * Normalized * P.FloorBias;
                if (!VoxelMath::IsFinite(Contribution)) { return FLT_MAX; }
                Supremum = FMath::Max(Supremum, Contribution);
            }
            return Supremum;
        }

        /**
         * Publish a conservative interval for this source alone.
         *
         * The cache is the same morphology implementation used by Eval, but the box proof never
         * samples a downstream density op. Rooms and tunnel segments are bounded by the exact
         * geometric support that Eval's culls admit; pits and chimneys are bounded in their real
         * (unwarped) coordinates. The final SmoothMin can lower the running minimum by at most K.
         *
         * Soundness is the priority: a failed validation, an overlarge scan, or a non-finite
         * intermediate returns Unknown. That can lose a tile skip; it cannot turn a tile into a
         * false AllSolid/AllAir result.
         */
        void PropagateSdfOverBox(FVoxelBoxSdfInterval& InOut, const FBox& VoxelBox,
                                 const FVoxelOpContext& Ctx) const override
        {
            FBoxState& B = BoxState();
            const uint64 PropagateStartCycles = FPlatformTime::Cycles64();
            B.ExactTailQueries = 0;
            B.ExactTailEvaluated = 0;
            B.ExactTailCycles = 0;
            B.PropagateCycles = 0;
            B.ExactPrimitiveCycles = 0;
            B.CacheWindowCycles = 0;
            B.NumRoomFloorJoins = 0;
            const UVoxelStrateManager* LiveManager = Manager.Get();
            auto InvalidateExactLatticeScratch = [&]()
            {
                B.bExactWarpedLatticeCacheValid = false;
                B.ExactWarpedLatticeQueries.Reset();
                B.ExactTailStates.Reset();
                B.ExactWarpedLatticeScratch.Reset();
                B.ExactWorldLatticeScratch.Reset();
                B.ExactWarpedLatticeCacheBox = FBox(ForceInit);
                B.ExactWarpedLatticeIX0 = B.ExactWarpedLatticeIY0 = 0;
                B.ExactWarpedLatticeIZ0 = 0;
                B.ExactWarpedLatticeNX = B.ExactWarpedLatticeNY = 0;
                B.ExactWarpedLatticeNZ = 0;
                B.ExactWarpedLatticeOrigin = FIntVector::ZeroValue;
                B.ExactWarpedLatticeStep = 0;
                B.ExactWarpedLatticeSeed = 0xFFFFFFFFu;
                B.ExactWarpedLatticeFingerprint = 0xFFFFFFFFu;
                B.ExactWarpedLatticeLayout = 0xFFFFFFFFu;
                B.ExactWarpedLatticeManagerLifetimeId = 0;
            };

            auto Unknown = [&]()
            {
                InvalidateExactLatticeScratch();
                B.bValid = false;
                B.ActiveCache = nullptr;
                B.CacheWindowSharedEntry.Reset();
                B.CacheWindowSharedRegionMinX = 0;
                B.CacheWindowSharedRegionMinY = 0;
                B.CacheWindowSharedRegionSize = 0;
                B.bCacheWindowUsesShared = false;
                B.CacheWindowUsesTileCacheWindow = false;
                B.CacheWindowTileOrigin = FIntVector::ZeroValue;
                B.CacheWindowTileStep = 0;
                B.CacheWindowTileCells = 0;
                B.bCacheWindowValid = false;
                B.bTightWarpEnvelopeValid = false;
                B.bMayHaveTunnelCoreAir = false;
                B.bMayHaveTunnelSupportFloor = false;
                B.bMayHaveTunnelCoreTail = false;
                B.SdfInterval.SetUnknown();
                InOut.SetUnknown();
            };
            auto Finite = [](float V) { return VoxelMath::IsFinite(V); };

            if (ManagerLifetimeId != 0 && LiveManager == nullptr)
            {
                Unknown();
                return;
            }

            const float BoxMinX = (float)VoxelBox.Min.X;
            const float BoxMinY = (float)VoxelBox.Min.Y;
            const float BoxMinZ = (float)VoxelBox.Min.Z;
            const float BoxMaxX = (float)VoxelBox.Max.X;
            const float BoxMaxY = (float)VoxelBox.Max.Y;
            const float BoxMaxZ = (float)VoxelBox.Max.Z;
            if (!Finite(BoxMinX) || !Finite(BoxMinY) || !Finite(BoxMinZ)
                || !Finite(BoxMaxX) || !Finite(BoxMaxY) || !Finite(BoxMaxZ)
                || BoxMinX > BoxMaxX || BoxMinY > BoxMaxY || BoxMinZ > BoxMaxZ)
            {
                Unknown();
                return;
            }

            // These are the fields that influence the source geometry or its cache window. If an
            // authored asset leaves the proven range, the safe answer is Unknown, never a guessed
            // "reasonable" radius. Non-positive room density/spacing is an exact Eval no-op.
            const float RelevantParams[] = {
                P.RoomDensity, P.RoomSpacing, P.MinRoomRadius, P.MaxRoomRadius, P.RoomHeightRatio,
                P.RoomFloorCutMin, P.RoomFloorCutMax, P.FloorReliefStrength, P.FloorReliefFrequency,
                P.RoomShapeVariety, P.OriginRoomRadius, P.TunnelMinRadius, P.TunnelMaxRadius,
                P.TunnelDensity, P.MaxTunnelLength, P.TunnelWarpStrength, P.TunnelHorizontalBias,
                P.TunnelEndpointZOffset, P.SDFBlendRadius, P.CaveWarpStrength, P.CaveWarpFrequency,
                P.VerticalScale
            };
            for (const float V : RelevantParams)
            {
                if (!Finite(V))
                {
                    Unknown();
                    return;
                }
            }

            if (!(P.RoomDensity > 0.0f && P.RoomSpacing > 0.0f))
            {
                InvalidateExactLatticeScratch();
                B.bValid = false;
                B.ActiveCache = nullptr;
                B.CacheWindowSharedEntry.Reset();
                B.bCacheWindowUsesShared = false;
                B.bCacheWindowValid = false;
                B.NumRooms = B.NumTunnels = B.NumPits = B.NumChimneys = 0;
                B.HitRooms = B.HitTunnels = B.HitPits = B.HitChimneys = 0;
                B.HitRoomsNoWarp = B.HitTunnelsNoWarp = 0;
                B.WarpDilation = 0.0f;
                B.bMayHaveTunnelCoreAir = false;
                B.bMayHaveTunnelSupportFloor = false;
                B.bMayHaveTunnelCoreTail = false;
                B.SdfInterval.Set(FLT_MAX, FLT_MAX);
                InOut = B.SdfInterval;
                return;
            }

            if (P.MinRoomRadius < 0.0f || P.MaxRoomRadius < 0.0f || P.RoomHeightRatio < 0.0f
                || P.OriginRoomRadius < 0.0f || P.TunnelMinRadius < 0.0f || P.TunnelMaxRadius < 0.0f
                || P.SDFBlendRadius < 0.0f)
            {
                Unknown();
                return;
            }

            const int32 CX0 = FMath::FloorToInt(BoxMinX / (float)CHUNK_SIZE);
            const int32 CY0 = FMath::FloorToInt(BoxMinY / (float)CHUNK_SIZE);
            const int32 CZ0 = FMath::FloorToInt(BoxMinZ / (float)CHUNK_SIZE);
            const int32 CX1 = FMath::FloorToInt(BoxMaxX / (float)CHUNK_SIZE);
            const int32 CY1 = FMath::FloorToInt(BoxMaxY / (float)CHUNK_SIZE);
            const int32 CZ1 = FMath::FloorToInt(BoxMaxZ / (float)CHUNK_SIZE);

            const int64 SpanX = (int64)CX1 - (int64)CX0 + 1;
            const int64 SpanY = (int64)CY1 - (int64)CY0 + 1;
            const int64 SpanZ = (int64)CZ1 - (int64)CZ0 + 1;
            if (SpanX <= 0 || SpanY <= 0 || SpanZ <= 0)
            {
                Unknown();
                return;
            }

            int32 StrateIdx = 0;
            const TArray<FStrateTerrainOpEntry>* TerrainOps = nullptr;
            if (LiveManager)
            {
                StrateIdx = LiveManager->GetStrateIndex(
                    ((float)CZ0 + 0.5f) * CHUNK_SIZE * VOXEL_SIZE);
                for (int32 CZ = CZ0 + 1; CZ <= CZ1; ++CZ)
                {
                    if (LiveManager->GetStrateIndex(
                            ((float)CZ + 0.5f) * CHUNK_SIZE * VOXEL_SIZE) != StrateIdx)
                    {
                        Unknown();
                        return;
                    }
                }

                // A room operation is part of the graph cache. Every Z slice covered by this
                // proof must resolve to the same definition before one cache can represent it.
                UVoxelStrateDefinition* Def0 = nullptr;
                for (int32 CZ = CZ0; CZ <= CZ1; ++CZ)
                {
                    UVoxelStrateDefinition* Def =
                        LiveManager->GetStrateForChunk(FIntVector(0, 0, CZ));
                    if (CZ == CZ0)
                    {
                        Def0 = Def;
                    }
                    else if (Def != Def0)
                    {
                        Unknown();
                        return;
                    }
                }
                if (Def0) { TerrainOps = &Def0->TerrainOperations; }
            }

            FIntVector RequestedTileOrigin = FIntVector::ZeroValue;
            int32 RequestedTileStep = FMath::Max(Ctx.Step, 1);
            int32 RequestedTileCells = 0;
            const bool bUseTileCacheWindow = VoxelGenLOD::IsTileCacheWindowEnabled(false)
                && VoxelGenLOD::GetThreadTileCacheWindow(
                    RequestedTileOrigin, RequestedTileStep, RequestedTileCells)
                && VoxelCaveMorphology::IsRoomGraphWindowInvariant(P, TerrainOps);
            const float RequestedTileExtent = static_cast<float>(
                static_cast<int64>(RequestedTileStep)
                * static_cast<int64>(RequestedTileCells));
            // FillChunk includes one sample-step of mesher halo around the requested tile.
            // Keep the tile footprint as the shared-cache identity, but let every block in that
            // halo reuse the same cache window.  The morphology search below includes the same
            // coverage, so this widens reuse without changing the set of values evaluated.
            const FBox CacheWindowCoverageBox = bUseTileCacheWindow
                ? FBox(
                    FVector(
                        static_cast<float>(RequestedTileOrigin.X)
                            - static_cast<float>(RequestedTileStep),
                        static_cast<float>(RequestedTileOrigin.Y)
                            - static_cast<float>(RequestedTileStep),
                        static_cast<float>(RequestedTileOrigin.Z)
                            - static_cast<float>(RequestedTileStep)),
                    FVector(
                        static_cast<float>(RequestedTileOrigin.X) + RequestedTileExtent,
                        static_cast<float>(RequestedTileOrigin.Y) + RequestedTileExtent,
                        static_cast<float>(RequestedTileOrigin.Z) + RequestedTileExtent)
                        + FVector(
                            static_cast<float>(RequestedTileStep),
                            static_cast<float>(RequestedTileStep),
                            static_cast<float>(RequestedTileStep)))
                : VoxelBox;
            const int64 RequestedTileChunkSpan = bUseTileCacheWindow
                ? FMath::Max<int64>(
                    1,
                    (static_cast<int64>(RequestedTileExtent) + CHUNK_SIZE - 1)
                        / CHUNK_SIZE)
                : 0;

            // A coarse tile is allowed to warm the proof, but never by allocating a morphology
            // cache for the whole tile.  At LOD3/4 the root can cover hundreds or thousands of
            // chunk keys; that is a proof-domain size, not a useful working set.  Descendants
            // are still queried normally and can use the bounded shared windows below.  Unknown
            // is deliberately the only answer here: it cannot authorize an empty-tile skip.
            constexpr int64 MaxLatticeProofChunkVolume = 512;
            if (Ctx.bUseLatticeProof
                && SpanX * SpanY * SpanZ > MaxLatticeProofChunkVolume
                && !(bUseTileCacheWindow
                    && RequestedTileChunkSpan <= 64
                    && SpanZ <= 16))
            {
                Unknown();
                return;
            }

            // The ordinary (non-lattice) proof keeps its original bounded query contract.  A
            // tile proof is different: its first query is the root box and its descendants are
            // all inside that box.  Build the root cache once even when the root spans more than
            // 64 chunk keys, then let the bounded child boxes use that same superset.  This is
            // what prevents a step-32 tile from paying one graph bake per coarse sample.
            constexpr int64 MaxNonLatticeChunkSpan = 64;
            if (!Ctx.bUseLatticeProof && SpanX * SpanY * SpanZ > MaxNonLatticeChunkSpan)
            {
                Unknown();
                return;
            }

            const uint32 LV = Ctx.LayoutVersion;
            auto IsSharedCacheCurrent = [&]() -> bool
            {
                const FSharedRoomGraphCacheEntry* Entry = B.CacheWindowSharedEntry.Get();
                return Entry != nullptr
                    && Entry->Seed == SeedU
                    && Entry->StrateIndex == StrateIdx
                    && Entry->ParamsFingerprint == ParamsFingerprint
                    && Entry->LayoutVersion == LayoutVersion
                    && Entry->ManagerLifetimeId == ManagerLifetimeId
                    && Entry->TerrainOps == TerrainOps
                    && Entry->RegionMinX == B.CacheWindowSharedRegionMinX
                    && Entry->RegionMinY == B.CacheWindowSharedRegionMinY
                    && Entry->RegionSize == B.CacheWindowSharedRegionSize;
            };
            if (B.bValid && B.KeyBox == VoxelBox && B.KeyStrate == StrateIdx
                && B.KeySeed == SeedU && B.KeyFingerprint == ParamsFingerprint && B.KeyLayout == LV
                && B.KeyManagerLifetimeId == ManagerLifetimeId
                && B.KeyUsesLatticeProof == Ctx.bUseLatticeProof
                && (!B.bCacheWindowUsesShared || IsSharedCacheCurrent())
                && B.KeyTightenWarpProof == Ctx.bTightenWarpProof
                && (!Ctx.bUseLatticeProof
                    || (B.KeyLatticeOrigin == Ctx.LatticeOriginVoxels
                        && B.KeyLatticeStep == Ctx.Step)))
            {
                InOut = B.SdfInterval;
                return;
            }

            const float EffectiveMinZ = (P.VerticalScale > 0.0f && P.VerticalScale != 1.0f)
                                      ? BoxMinZ / P.VerticalScale : BoxMinZ;
            const float EffectiveMaxZ = (P.VerticalScale > 0.0f && P.VerticalScale != 1.0f)
                                      ? BoxMaxZ / P.VerticalScale : BoxMaxZ;
            const float GlobalWarp = (P.CaveWarpStrength > 0.0f)
                                   ? P.CaveWarpStrength * VOXEL_NOISE_SCALE * VF_PerlinAbsBound
                                   : 0.0f;
            if (!Finite(GlobalWarp) || !Finite(EffectiveMinZ) || !Finite(EffectiveMaxZ))
            {
                Unknown();
                return;
            }

            FVector WarpEnvelope(GlobalWarp, GlobalWarp, GlobalWarp);
            // The finite Perlin interval is useful at the root too when the root is one ordinary
            // LOD0 tile wide. Compute it once and retain it as a superset for every descendant;
            // otherwise each refined child repeats the same finite-domain envelope work. The
            // helper falls back to the global theorem for larger/non-finite noise domains, so
            // widening this gate cannot weaken soundness.
            const bool bUseFiniteWarpEnvelope = Ctx.bTightenWarpProof
                && FMath::Max3(BoxMaxX - BoxMinX, BoxMaxY - BoxMinY, BoxMaxZ - BoxMinZ)
                    <= 32.0f * static_cast<float>(FMath::Max(Ctx.Step, 1));
            if (bUseFiniteWarpEnvelope && P.CaveWarpStrength > 0.0f
                && P.CaveWarpFrequency > 0.0f)
            {
                const bool bCanReuseTightEnvelope = B.bTightWarpEnvelopeValid
                    && B.TightWarpEnvelopeBox.Min.X <= BoxMinX
                    && B.TightWarpEnvelopeBox.Min.Y <= BoxMinY
                    && B.TightWarpEnvelopeBox.Min.Z <= BoxMinZ
                    && B.TightWarpEnvelopeBox.Max.X >= BoxMaxX
                    && B.TightWarpEnvelopeBox.Max.Y >= BoxMaxY
                    && B.TightWarpEnvelopeBox.Max.Z >= BoxMaxZ;
                if (bCanReuseTightEnvelope)
                {
                    WarpEnvelope = B.TightWarpEnvelope;
                }
                else
                {
                    const float WarpAmplitude = P.CaveWarpStrength * VOXEL_NOISE_SCALE;
                    WarpEnvelope.X = WarpAmplitude * VF_PerlinAbsBoundOverWorldBox(
                        BoxMinX, BoxMaxX, BoxMinY, BoxMaxY, EffectiveMinZ, EffectiveMaxZ,
                        P.CaveWarpFrequency, VoxelHash::SeedOffset(SeedU, 0.37f), 1.3f, 5.7f);
                    WarpEnvelope.Y = WarpAmplitude * VF_PerlinAbsBoundOverWorldBox(
                        BoxMinX, BoxMaxX, BoxMinY, BoxMaxY, EffectiveMinZ, EffectiveMaxZ,
                        P.CaveWarpFrequency, 7.1f, VoxelHash::SeedOffset(SeedU, 0.59f), 2.3f);
                    WarpEnvelope.Z = WarpAmplitude * VF_PerlinAbsBoundOverWorldBox(
                        BoxMinX, BoxMaxX, BoxMinY, BoxMaxY, EffectiveMinZ, EffectiveMaxZ,
                        P.CaveWarpFrequency, 11.3f, 9.7f, VoxelHash::SeedOffset(SeedU, 0.41f));
                    B.TightWarpEnvelopeBox = VoxelBox;
                    B.TightWarpEnvelope = WarpEnvelope;
                    B.bTightWarpEnvelopeValid = true;
                }
                if (!Finite((float)WarpEnvelope.X) || !Finite((float)WarpEnvelope.Y)
                    || !Finite((float)WarpEnvelope.Z))
                {
                    Unknown();
                    return;
                }
            }
            // A tile cache is a graph cache, not a proof-result cache.  Its search envelope must
            // therefore be identical for the root and every block/child that asks about the
            // tile.  In particular, a finite tight warp envelope is allowed to sharpen the
            // interval proof below, but it must not make the first classifier block publish a
            // smaller morphology cache for later blocks to reuse.
            const float CacheWarpX = bUseTileCacheWindow
                ? GlobalWarp : FMath::Max((float)WarpEnvelope.X, 0.0f);
            const float CacheWarpY = bUseTileCacheWindow
                ? GlobalWarp : FMath::Max((float)WarpEnvelope.Y, 0.0f);
            const float CacheWarpZ = bUseTileCacheWindow
                ? GlobalWarp : FMath::Max((float)WarpEnvelope.Z, 0.0f);
            const float CacheSearchMinX = bUseTileCacheWindow
                ? static_cast<float>(RequestedTileOrigin.X)
                    - CacheWarpX
                    - static_cast<float>(RequestedTileStep) - 2.0f
                : BoxMinX - CacheWarpX - 2.0f;
            const float CacheSearchMinY = bUseTileCacheWindow
                ? static_cast<float>(RequestedTileOrigin.Y)
                    - CacheWarpY
                    - static_cast<float>(RequestedTileStep) - 2.0f
                : BoxMinY - CacheWarpY - 2.0f;
            const float CacheSearchMaxX = bUseTileCacheWindow
                ? static_cast<float>(RequestedTileOrigin.X) + RequestedTileExtent
                    + CacheWarpX
                    + static_cast<float>(RequestedTileStep) + 2.0f
                : BoxMaxX + CacheWarpX + 2.0f;
            const float CacheSearchMaxY = bUseTileCacheWindow
                ? static_cast<float>(RequestedTileOrigin.Y) + RequestedTileExtent
                    + CacheWarpY
                    + static_cast<float>(RequestedTileStep) + 2.0f
                : BoxMaxY + CacheWarpY + 2.0f;
            const float CacheSearchMinZ = bUseTileCacheWindow
                ? static_cast<float>(RequestedTileOrigin.Z)
                    - CacheWarpZ
                    - static_cast<float>(RequestedTileStep) - 2.0f
                : BoxMinZ - CacheWarpZ - 2.0f;
            const float CacheSearchMaxZ = bUseTileCacheWindow
                ? static_cast<float>(RequestedTileOrigin.Z) + RequestedTileExtent
                    + CacheWarpZ
                    + static_cast<float>(RequestedTileStep) + 2.0f
                : BoxMaxZ + CacheWarpZ + 2.0f;
            // The search window is a superset of every warped point in the box, with the same
            // two-voxel gradient margin used by Eval's cache path.  In lattice mode, retain the
            // first/root window and reuse it for every refined child.  A larger morphology
            // window is sound for a child because BuildChunkCache's collect/store contract is
            // explicitly window-invariant; it is also the only way to keep refinement from
            // turning into one graph build per child box.
            const bool bWindowKeyMatches = B.bCacheWindowValid
                && B.CacheWindowStrate == StrateIdx
                && B.CacheWindowSeed == SeedU
                && B.CacheWindowFingerprint == ParamsFingerprint
                && B.CacheWindowLayout == LV
                && B.CacheWindowManagerLifetimeId == ManagerLifetimeId
                && B.CacheWindowTerrainOps == TerrainOps
                && B.CacheWindowUsesLatticeProof == Ctx.bUseLatticeProof
                && B.CacheWindowUsesTileCacheWindow == bUseTileCacheWindow
                && (!bUseTileCacheWindow
                    || (B.CacheWindowTileOrigin == RequestedTileOrigin
                        && B.CacheWindowTileStep == RequestedTileStep
                        && B.CacheWindowTileCells == RequestedTileCells))
                // A non-tight cache is built from the global warp envelope and is therefore a
                // superset cache for a later tight retry.  The reverse is not safe: a tight cache
                // may omit primitives needed by the conservative global-envelope query.
                && (!Ctx.bUseLatticeProof
                    // Tight queries may use either an equally tight cache or the larger global
                    // envelope cache. A global query must not reuse a tight cache.
                    || Ctx.bTightenWarpProof
                    || !B.CacheWindowTightenWarpProof)
                 // The graph window is independent of which block's lattice origin requested it;
                 // retain only the step because it controls the conservative finite-envelope gate
                 // for non-tile proof windows.
                 && (!Ctx.bUseLatticeProof
                     || B.CacheWindowLatticeStep == Ctx.Step)
                 && (!B.bCacheWindowUsesShared || IsSharedCacheCurrent())
                 && B.CacheWindowBox.Min.X <= BoxMinX
                && B.CacheWindowBox.Min.Y <= BoxMinY
                && B.CacheWindowBox.Min.Z <= BoxMinZ
                && B.CacheWindowBox.Max.X >= BoxMaxX
                && B.CacheWindowBox.Max.Y >= BoxMaxY
                && B.CacheWindowBox.Max.Z >= BoxMaxZ;

            if (!bWindowKeyMatches)
            {
                const uint64 CacheWindowStartCycles = FPlatformTime::Cycles64();
                InvalidateExactLatticeScratch();
                B.ActiveCache = nullptr;
                B.CacheWindowSharedEntry.Reset();
                B.CacheWindowSharedRegionMinX = 0;
                B.CacheWindowSharedRegionMinY = 0;
                B.CacheWindowSharedRegionSize = 0;
                B.bCacheWindowUsesShared = false;
                B.bTightWarpEnvelopeValid = false;

                // The morphology builder is window-invariant.  For the bounded lattice boxes,
                // reuse the worker-local graph cache used by Eval, but at a 128/256-voxel region
                // granularity.  A classifier root otherwise rebuilds the same collect/NN graph
                // for every neighbouring tile before the regular density path has a chance to
                // populate its cache.  The shared window is always built from the global warp
                // envelope, so it is a superset of this tight query and can only add conservative
                // primitives to the interval.
                const bool bFeatureFree =
                    !VoxelCaveMorphology::MayHaveFeatureInSearchBox(
                        CacheSearchMinX,
                        CacheSearchMinY,
                        CacheSearchMaxX,
                        CacheSearchMaxY,
                        P, SeedU, StrateIdx, true,
                        CacheSearchMinZ,
                        CacheSearchMaxZ,
                        TerrainOps);
                const int64 MaxSharedChunkSpan = Ctx.Step >= 32 ? 32 : 16;
                bool bUsedSharedCache = false;
                const bool bTileWithinSharedBudget = bUseTileCacheWindow
                    && RequestedTileChunkSpan <= 64;
                if (!bFeatureFree
                    && Ctx.bUseLatticeProof
                    // Fine LOD0/LOD1 requests are latency-sensitive and each worker already has
                    // a bounded graph cache. Sharing their tiny 64-voxel windows makes otherwise
                    // sub-millisecond empty proofs wait behind a different worker's build (the
                    // build itself is cheap). Coarse samples keep the shared window, where its
                    // larger footprint prevents thousands of per-chunk rebuilds.
                    && Ctx.Step > 1
                    && (bTileWithinSharedBudget
                        || (SpanX <= MaxSharedChunkSpan
                            && SpanY <= MaxSharedChunkSpan)))
                {
                    // Coarser LODs retain a shared immutable cache. With the tile policy its key
                    // is the exact tile footprint; the fallback keeps the historical expanding
                    // four-chunk working set for point/non-tile callers.
                    int32 SharedRegionSize = bUseTileCacheWindow
                        ? static_cast<int32>(RequestedTileExtent)
                        : 4 * CHUNK_SIZE;
                    int32 SharedRegionMinX = bUseTileCacheWindow
                        ? RequestedTileOrigin.X : 0;
                    int32 SharedRegionMinY = bUseTileCacheWindow
                        ? RequestedTileOrigin.Y : 0;
                    bool bCoversBox = bUseTileCacheWindow
                        ? (CacheWindowCoverageBox.Min.X <= BoxMinX
                            && CacheWindowCoverageBox.Min.Y <= BoxMinY
                            && CacheWindowCoverageBox.Max.X >= BoxMaxX
                            && CacheWindowCoverageBox.Max.Y >= BoxMaxY)
                        : false;
                    for (int32 Attempt = 0; !bUseTileCacheWindow && Attempt < 6; ++Attempt)
                    {
                        SharedRegionMinX = FMath::FloorToInt(
                            BoxMinX / (float)SharedRegionSize) * SharedRegionSize;
                        SharedRegionMinY = FMath::FloorToInt(
                            BoxMinY / (float)SharedRegionSize) * SharedRegionSize;
                        bCoversBox = BoxMaxX <= (float)(SharedRegionMinX + SharedRegionSize)
                            && BoxMaxY <= (float)(SharedRegionMinY + SharedRegionSize);
                        if (bCoversBox) { break; }
                        SharedRegionSize *= 2;
                    }

                    if (bCoversBox
                        && (bUseTileCacheWindow
                            || SharedRegionSize
                               <= static_cast<int32>(MaxSharedChunkSpan) * CHUNK_SIZE))
                    {
                        TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe> SharedCache =
                            FindOrBuildSharedRoomGraphCache(
                                SeedU, StrateIdx, ParamsFingerprint, LayoutVersion,
                                ManagerLifetimeId, TerrainOps,
                                SharedRegionMinX, SharedRegionMinY, SharedRegionSize,
                                bUseTileCacheWindow
                                    ? CacheSearchMinX
                                    : (float)SharedRegionMinX
                                        - (FMath::Abs(P.CaveWarpStrength)
                                            * VOXEL_NOISE_SCALE * VF_PerlinAbsBound + 2.0f),
                                bUseTileCacheWindow
                                    ? CacheSearchMinY
                                    : (float)SharedRegionMinY
                                        - (FMath::Abs(P.CaveWarpStrength)
                                            * VOXEL_NOISE_SCALE * VF_PerlinAbsBound + 2.0f),
                                bUseTileCacheWindow
                                    ? CacheSearchMaxX
                                    : (float)(SharedRegionMinX + SharedRegionSize)
                                        + (FMath::Abs(P.CaveWarpStrength)
                                            * VOXEL_NOISE_SCALE * VF_PerlinAbsBound + 2.0f),
                                bUseTileCacheWindow
                                    ? CacheSearchMaxY
                                    : (float)(SharedRegionMinY + SharedRegionSize)
                                        + (FMath::Abs(P.CaveWarpStrength)
                                            * VOXEL_NOISE_SCALE * VF_PerlinAbsBound + 2.0f),
                                P,
                                ERoomGraphBuildSite::ClassifierShared);
                        const TSharedPtr<const FChunkSDFCache, ESPMode::ThreadSafe>
                            SharedRoomGraphCache = SnapshotSharedRoomGraphCache(SharedCache);
                        B.ActiveCache = SharedRoomGraphCache.Get();
                        B.CacheWindowSharedEntry = SharedCache;
                        B.CacheWindowSharedRegionMinX = SharedRegionMinX;
                        B.CacheWindowSharedRegionMinY = SharedRegionMinY;
                        B.CacheWindowSharedRegionSize = SharedRegionSize;
                        B.bCacheWindowUsesShared = true;
                        bUsedSharedCache = true;
                    }
                }

                if (!bUsedSharedCache)
                {
                    if (bFeatureFree)
                    {
                        // Keep an empty worker-local cache object as the active
                        // window. Its arrays retain capacity, but no graph
                        // build or player-fit bake is paid for this box.
                        B.Cache.Release();
                    }
                    else
                    {
                        VoxelCaveMorphology::BuildChunkCache(
                            B.Cache,
                            CacheSearchMinX,
                            CacheSearchMinY,
                            CacheSearchMaxX,
                            CacheSearchMaxY,
                            P, SeedU, StrateIdx, TerrainOps,
                             ERoomGraphBuildSite::ClassifierLocal);
                    }
                    B.ActiveCache = &B.Cache;
                }

                B.CacheWindowBox = CacheWindowCoverageBox;
                B.CacheWindowStrate = StrateIdx;
                B.CacheWindowSeed = SeedU;
                B.CacheWindowFingerprint = ParamsFingerprint;
                B.CacheWindowLayout = LV;
                B.CacheWindowManagerLifetimeId = ManagerLifetimeId;
                B.CacheWindowTerrainOps = TerrainOps;
                B.CacheWindowUsesLatticeProof = Ctx.bUseLatticeProof;
                B.CacheWindowUsesTileCacheWindow = bUseTileCacheWindow;
                B.CacheWindowTileOrigin = bUseTileCacheWindow
                    ? RequestedTileOrigin : FIntVector::ZeroValue;
                B.CacheWindowTileStep = bUseTileCacheWindow ? RequestedTileStep : 0;
                B.CacheWindowTileCells = bUseTileCacheWindow ? RequestedTileCells : 0;
                B.CacheWindowTightenWarpProof = bUseTileCacheWindow
                    ? false
                    : bUsedSharedCache
                    ? false : Ctx.bTightenWarpProof;
                B.CacheWindowLatticeStep = Ctx.Step;
                B.bCacheWindowValid = true;
                B.CacheWindowCycles = FPlatformTime::Cycles64() - CacheWindowStartCycles;
            }
            else if (B.bCacheWindowUsesShared)
            {
                B.ActiveCache = SnapshotSharedRoomGraphCache(
                    B.CacheWindowSharedEntry).Get();
            }
            // Large root boxes are only a cache warm-up.  Their interval is intentionally still
            // unknown; proof resumes at bounded descendants where all bounds below are finite.
            if (SpanX * SpanY * SpanZ > 64)
            {
                // Keep the freshly built window alive for the descendants.  This is deliberately
                // different from Unknown(): the root is not invalid, it is merely too large to
                // publish a finite interval in one pass.
                B.bValid = false;
                B.bMayHaveTunnelCoreAir = false;
                B.bMayHaveTunnelSupportFloor = false;
                B.bMayHaveTunnelCoreTail = false;
                B.SdfInterval.SetUnknown();
                InOut.SetUnknown();
                return;
            }

            const FVector QMin(BoxMinX - (float)WarpEnvelope.X,
                               BoxMinY - (float)WarpEnvelope.Y,
                               EffectiveMinZ - (float)WarpEnvelope.Z);
            const FVector QMax(BoxMaxX + (float)WarpEnvelope.X,
                               BoxMaxY + (float)WarpEnvelope.Y,
                               EffectiveMaxZ + (float)WarpEnvelope.Z);
            const FVector RMin(BoxMinX, BoxMinY, BoxMinZ);
            const FVector RMax(BoxMaxX, BoxMaxY, BoxMaxZ);
            if (!Finite((float)QMin.X) || !Finite((float)QMin.Y) || !Finite((float)QMin.Z)
                || !Finite((float)QMax.X) || !Finite((float)QMax.Y) || !Finite((float)QMax.Z))
            {
                Unknown();
                return;
            }

            // In lattice mode the queried box is a proof domain for the exact MC samples, not
            // for every continuous point between them.  The room/tunnel bounds below therefore
            // use the nearest lattice coordinate in each axis and subtract the same per-axis warp
            // envelope as the continuous proof.  A sub-box containing no lattice point has no
            // samples to constrain and contributes the exact SDF identity.
            const bool bUseLatticeProof = Ctx.bUseLatticeProof;
            const float LatticeOriginX = static_cast<float>(Ctx.LatticeOriginVoxels.X);
            const float LatticeOriginY = static_cast<float>(Ctx.LatticeOriginVoxels.Y);
            const float LatticeOriginZ = (P.VerticalScale > 0.0f && P.VerticalScale != 1.0f)
                ? static_cast<float>(Ctx.LatticeOriginVoxels.Z) / P.VerticalScale
                : static_cast<float>(Ctx.LatticeOriginVoxels.Z);
            const float LatticeStepXY = static_cast<float>(Ctx.Step);
            const float LatticeStepZ = (P.VerticalScale > 0.0f && P.VerticalScale != 1.0f)
                ? static_cast<float>(Ctx.Step) / P.VerticalScale
                : static_cast<float>(Ctx.Step);
            if (bUseLatticeProof)
            {
                auto HasAxisSample = [](float Min, float Max, float Origin, float Step) -> bool
                {
                    return Step > 0.0f
                        && FMath::CeilToInt((Min - Origin) / Step - 1.0e-4f)
                           <= FMath::FloorToInt((Max - Origin) / Step + 1.0e-4f);
                };
                if (!HasAxisSample(BoxMinX, BoxMaxX, LatticeOriginX, LatticeStepXY)
                    || !HasAxisSample(BoxMinY, BoxMaxY, LatticeOriginY, LatticeStepXY)
                    || !HasAxisSample(BoxMinZ, BoxMaxZ, LatticeOriginZ, LatticeStepZ))
                {
                    InvalidateExactLatticeScratch();
                    B.bValid = false;
                    B.ActiveCache = nullptr;
                B.CacheWindowSharedEntry.Reset();
                    B.bCacheWindowUsesShared = false;
                    B.bCacheWindowValid = false;
                    B.SdfInterval.Set(FLT_MAX, FLT_MAX);
                    InOut = B.SdfInterval;
                    return;
                }
            }

            // A tight retry is a proof over the exact lattice the mesher will read.  Keep both
            // coordinate spaces: the room graph is queried in warped SDF space, while pits and
            // chimneys deliberately use the original world-space sample.  The old implementation
            // retained only an AABB at LOD0; that still admitted a tunnel when the warped samples
            // themselves missed it.  The exact primitive minima below remove that false overlap
            // without changing the lattice or the density evaluator used by the mesher.
            TArray<FVector>& ExactLatticeWarpedQueries = B.ExactWarpedLatticeScratch;
            TArray<FVector>& ExactLatticeWorldQueries = B.ExactWorldLatticeScratch;
            ExactLatticeWarpedQueries.Reset();
            ExactLatticeWorldQueries.Reset();
            FVector ExactLatticeQueryMin(FLT_MAX, FLT_MAX, FLT_MAX);
            FVector ExactLatticeQueryMax(-FLT_MAX, -FLT_MAX, -FLT_MAX);
            int32 ExactIX0 = 0, ExactIY0 = 0, ExactIZ0 = 0;
            int32 ExactNX = 0, ExactNY = 0, ExactNZ = 0;
            struct FExactLatticeBlock
            {
                int32 IX0 = 0, IX1 = -1;
                int32 IY0 = 0, IY1 = -1;
                int32 IZ0 = 0, IZ1 = -1;
                FVector WarpedMin = FVector(FLT_MAX, FLT_MAX, FLT_MAX);
                FVector WarpedMax = FVector(-FLT_MAX, -FLT_MAX, -FLT_MAX);
                FVector WorldMin = FVector(FLT_MAX, FLT_MAX, FLT_MAX);
                FVector WorldMax = FVector(-FLT_MAX, -FLT_MAX, -FLT_MAX);
            };
            TArray<FExactLatticeBlock, TInlineAllocator<128>> ExactLatticeBlocks;
            const float MaxBoxExtent = FMath::Max3(
                BoxMaxX - BoxMinX, BoxMaxY - BoxMinY, BoxMaxZ - BoxMinZ);
            const float ExactChildExtent = 16.0f * (float)FMath::Max(Ctx.Step, 1);
            const bool bTryExactLatticeWarp = bUseLatticeProof && Ctx.bTightenWarpProof
                // The root is a cache warm-up.  Exact warped lattice distances are only needed
                // once the refinement has reduced the domain to a child; this avoids rebuilding
                // a 33^3 query list before the eight 17^3 child proofs that actually decide the
                // residual solid tile.  A non-exact root remains conservative and cannot create a
                // skip on its own.
                // Include a box exactly one coarse child wide. This lets a depth-one LOD0 node
                // use the exact warped lattice certificate before it fans out into eight smaller
                // proofs; the certificate remains conservative because it samples only the same
                // lattice points the mesher reads.
                && MaxBoxExtent <= ExactChildExtent;
            if (bTryExactLatticeWarp)
            {
                 const int32 IX0 = FMath::CeilToInt(
                    (BoxMinX - LatticeOriginX) / LatticeStepXY - 1.0e-4f);
                const int32 IY0 = FMath::CeilToInt(
                    (BoxMinY - LatticeOriginY) / LatticeStepXY - 1.0e-4f);
                const int32 IZ0 = FMath::CeilToInt(
                    (BoxMinZ - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                    / static_cast<float>(Ctx.Step) - 1.0e-4f);
                const int32 IX1 = FMath::FloorToInt(
                    (BoxMaxX - LatticeOriginX) / LatticeStepXY + 1.0e-4f);
                const int32 IY1 = FMath::FloorToInt(
                    (BoxMaxY - LatticeOriginY) / LatticeStepXY + 1.0e-4f);
                const int32 IZ1 = FMath::FloorToInt(
                    (BoxMaxZ - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                    / static_cast<float>(Ctx.Step) + 1.0e-4f);
                const int64 Count = ((int64)IX1 - IX0 + 1)
                                 * ((int64)IY1 - IY0 + 1)
                                 * ((int64)IZ1 - IZ0 + 1);
                 if (IX1 >= IX0 && IY1 >= IY0 && IZ1 >= IZ0
                     && Count > 0 && Count <= 100000)
                 {
                    ExactIX0 = IX0;
                    ExactIY0 = IY0;
                    ExactIZ0 = IZ0;
                    ExactNX = IX1 - IX0 + 1;
                    ExactNY = IY1 - IY0 + 1;
                    ExactNZ = IZ1 - IZ0 + 1;
                    ExactLatticeWarpedQueries.Reserve(static_cast<int32>(Count));
                    ExactLatticeWorldQueries.Reserve(static_cast<int32>(Count));
                    const float WarpAmplitude = P.CaveWarpStrength * VOXEL_NOISE_SCALE;
                    auto MakeWarpedQuery = [&](int32 QueryIX, int32 QueryIY,
                                               int32 QueryIZ) -> FVector
                    {
                        const float WorldX = LatticeOriginX + (float)QueryIX * LatticeStepXY;
                        const float WorldY = LatticeOriginY + (float)QueryIY * LatticeStepXY;
                        const float WorldZ = static_cast<float>(Ctx.LatticeOriginVoxels.Z)
                            + (float)QueryIZ * (float)Ctx.Step;
                        const float EffectiveZ = (P.VerticalScale > 0.0f
                                                  && P.VerticalScale != 1.0f)
                                                ? WorldZ / P.VerticalScale : WorldZ;
                        FVector Query(WorldX, WorldY, EffectiveZ);
            if (!VoxelDensityAblation::IsCaveWarpOff() && P.CaveWarpStrength > 0.0f)
                        {
                            const float Frequency = P.CaveWarpFrequency;
                            float WarpX, WarpY, WarpZ;
                            VoxelNoise::Perlin3D_x3(
                                WorldX * Frequency + VoxelHash::SeedOffset(SeedU, 0.37f),
                                WorldY * Frequency + 1.3f,
                                EffectiveZ * Frequency + 5.7f,
                                WorldX * Frequency + 7.1f,
                                WorldY * Frequency + VoxelHash::SeedOffset(SeedU, 0.59f),
                                EffectiveZ * Frequency + 2.3f,
                                WorldX * Frequency + 11.3f,
                                WorldY * Frequency + 9.7f,
                                EffectiveZ * Frequency + VoxelHash::SeedOffset(SeedU, 0.41f),
                                WarpX, WarpY, WarpZ);
                            Query.X += WarpX * WarpAmplitude;
                            Query.Y += WarpY * WarpAmplitude;
                            Query.Z += WarpZ * WarpAmplitude;
                        }
                        return Query;
                    };

                    // All exact child boxes are contained in the classifier root held by the
                    // window cache. Cache only the deterministic warp samples, not any interval or
                    // verdict, so a cache miss can only cost work. The 100000-sample cap bounds
                    // this worker-local scratch allocation even for an unusually large root.
                    bool bCanUseWarpedQueryCache = false;
                    int32 CacheIX0 = 0;
                    int32 CacheIY0 = 0;
                    int32 CacheIZ0 = 0;
                    int32 CacheNX = 0;
                    int32 CacheNY = 0;
                    int32 CacheNZ = 0;
                    if (B.bCacheWindowValid
                        && Finite((float)B.CacheWindowBox.Min.X)
                        && Finite((float)B.CacheWindowBox.Min.Y)
                        && Finite((float)B.CacheWindowBox.Min.Z)
                        && Finite((float)B.CacheWindowBox.Max.X)
                        && Finite((float)B.CacheWindowBox.Max.Y)
                        && Finite((float)B.CacheWindowBox.Max.Z)
                        && B.CacheWindowBox.Min.X <= B.CacheWindowBox.Max.X
                        && B.CacheWindowBox.Min.Y <= B.CacheWindowBox.Max.Y
                        && B.CacheWindowBox.Min.Z <= B.CacheWindowBox.Max.Z)
                    {
                        CacheIX0 = FMath::CeilToInt(
                            ((float)B.CacheWindowBox.Min.X - LatticeOriginX)
                            / LatticeStepXY - 1.0e-4f);
                        CacheIY0 = FMath::CeilToInt(
                            ((float)B.CacheWindowBox.Min.Y - LatticeOriginY)
                            / LatticeStepXY - 1.0e-4f);
                        CacheIZ0 = FMath::CeilToInt(
                            ((float)B.CacheWindowBox.Min.Z
                             - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                            / static_cast<float>(Ctx.Step) - 1.0e-4f);
                        const int32 CacheIX1 = FMath::FloorToInt(
                            ((float)B.CacheWindowBox.Max.X - LatticeOriginX)
                            / LatticeStepXY + 1.0e-4f);
                        const int32 CacheIY1 = FMath::FloorToInt(
                            ((float)B.CacheWindowBox.Max.Y - LatticeOriginY)
                            / LatticeStepXY + 1.0e-4f);
                        const int32 CacheIZ1 = FMath::FloorToInt(
                            ((float)B.CacheWindowBox.Max.Z
                             - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                            / static_cast<float>(Ctx.Step) + 1.0e-4f);
                        const int64 CacheCount = ((int64)CacheIX1 - CacheIX0 + 1)
                                               * ((int64)CacheIY1 - CacheIY0 + 1)
                                               * ((int64)CacheIZ1 - CacheIZ0 + 1);
                        if (CacheIX1 >= CacheIX0 && CacheIY1 >= CacheIY0 && CacheIZ1 >= CacheIZ0
                            && CacheCount > 0 && CacheCount <= 100000
                            && IX0 >= CacheIX0 && IY0 >= CacheIY0 && IZ0 >= CacheIZ0
                            && IX1 <= CacheIX1 && IY1 <= CacheIY1 && IZ1 <= CacheIZ1)
                        {
                            CacheNX = CacheIX1 - CacheIX0 + 1;
                            CacheNY = CacheIY1 - CacheIY0 + 1;
                            CacheNZ = CacheIZ1 - CacheIZ0 + 1;
                            const bool bCacheKeyMatches = B.bExactWarpedLatticeCacheValid
                                && B.ExactWarpedLatticeCacheBox == B.CacheWindowBox
                                && B.ExactWarpedLatticeOrigin == Ctx.LatticeOriginVoxels
                                && B.ExactWarpedLatticeStep == Ctx.Step
                                && B.ExactWarpedLatticeSeed == SeedU
                                && B.ExactWarpedLatticeFingerprint == ParamsFingerprint
                                && B.ExactWarpedLatticeLayout == LV
                                && B.ExactWarpedLatticeManagerLifetimeId == ManagerLifetimeId
                                && B.ExactWarpedLatticeIX0 == CacheIX0
                                && B.ExactWarpedLatticeIY0 == CacheIY0
                                && B.ExactWarpedLatticeIZ0 == CacheIZ0
                                && B.ExactWarpedLatticeNX == CacheNX
                                && B.ExactWarpedLatticeNY == CacheNY
                                && B.ExactWarpedLatticeNZ == CacheNZ
                                && B.ExactWarpedLatticeQueries.Num() == CacheCount;
                            if (!bCacheKeyMatches)
                            {
                                B.ExactWarpedLatticeQueries.Reset();
                                B.ExactWarpedLatticeQueries.SetNumUninitialized(
                                    static_cast<int32>(CacheCount));
                                B.ExactTailStates.Init(0, static_cast<int32>(CacheCount));
                                for (int32 CacheIZ = CacheIZ0; CacheIZ <= CacheIZ1; ++CacheIZ)
                                for (int32 CacheIY = CacheIY0; CacheIY <= CacheIY1; ++CacheIY)
                                for (int32 CacheIX = CacheIX0; CacheIX <= CacheIX1; ++CacheIX)
                                {
                                    const int32 FlatIndex =
                                        ((CacheIZ - CacheIZ0) * CacheNY
                                         + (CacheIY - CacheIY0)) * CacheNX
                                        + (CacheIX - CacheIX0);
                                    B.ExactWarpedLatticeQueries[FlatIndex] =
                                        MakeWarpedQuery(CacheIX, CacheIY, CacheIZ);
                                }
                                B.ExactWarpedLatticeCacheBox = B.CacheWindowBox;
                                B.ExactWarpedLatticeIX0 = CacheIX0;
                                B.ExactWarpedLatticeIY0 = CacheIY0;
                                B.ExactWarpedLatticeIZ0 = CacheIZ0;
                                B.ExactWarpedLatticeNX = CacheNX;
                                B.ExactWarpedLatticeNY = CacheNY;
                                B.ExactWarpedLatticeNZ = CacheNZ;
                                B.ExactWarpedLatticeOrigin = Ctx.LatticeOriginVoxels;
                                B.ExactWarpedLatticeStep = Ctx.Step;
                                B.ExactWarpedLatticeSeed = SeedU;
                                B.ExactWarpedLatticeFingerprint = ParamsFingerprint;
                                B.ExactWarpedLatticeLayout = LV;
                                B.ExactWarpedLatticeManagerLifetimeId = ManagerLifetimeId;
                                B.bExactWarpedLatticeCacheValid = true;
                            }
                            else if (B.ExactTailStates.Num() != static_cast<int32>(CacheCount))
                            {
                                B.ExactTailStates.Init(0, static_cast<int32>(CacheCount));
                            }
                            bCanUseWarpedQueryCache = B.bExactWarpedLatticeCacheValid;
                        }
                    }

                    for (int32 IZ = IZ0; IZ <= IZ1; ++IZ)
                    for (int32 IY = IY0; IY <= IY1; ++IY)
                    for (int32 IX = IX0; IX <= IX1; ++IX)
                    {
                        const float WorldX = LatticeOriginX + (float)IX * LatticeStepXY;
                        const float WorldY = LatticeOriginY + (float)IY * LatticeStepXY;
                        const float WorldZ = static_cast<float>(Ctx.LatticeOriginVoxels.Z)
                            + (float)IZ * (float)Ctx.Step;
                        ExactLatticeWorldQueries.Add(FVector(WorldX, WorldY, WorldZ));
                        if (bCanUseWarpedQueryCache)
                        {
                            const int32 FlatIndex =
                                ((IZ - CacheIZ0) * CacheNY + (IY - CacheIY0)) * CacheNX
                                + (IX - CacheIX0);
                            ExactLatticeWarpedQueries.Add(
                                B.ExactWarpedLatticeQueries[FlatIndex]);
                        }
                        else
                        {
                            ExactLatticeWarpedQueries.Add(MakeWarpedQuery(IX, IY, IZ));
                        }
                        const FVector& Query = ExactLatticeWarpedQueries.Last();
                        ExactLatticeQueryMin.X = FMath::Min(ExactLatticeQueryMin.X, (float)Query.X);
                        ExactLatticeQueryMin.Y = FMath::Min(ExactLatticeQueryMin.Y, (float)Query.Y);
                        ExactLatticeQueryMin.Z = FMath::Min(ExactLatticeQueryMin.Z, (float)Query.Z);
                        ExactLatticeQueryMax.X = FMath::Max(ExactLatticeQueryMax.X, (float)Query.X);
                        ExactLatticeQueryMax.Y = FMath::Max(ExactLatticeQueryMax.Y, (float)Query.Y);
                        ExactLatticeQueryMax.Z = FMath::Max(ExactLatticeQueryMax.Z, (float)Query.Z);
                    }

                    // One envelope contains every warped lattice point in this refined child.
                    // The lower-bound helpers below are valid over any enclosing AABB, so using
                    // one envelope removes the repeated overlapping block traversal that made a
                    // single LOD0 classifier visit the same primitive geometry dozens of times.
                    // It is deliberately looser than the old sub-block decomposition: a looser
                    // lower bound can only retain Mixed and send work to the mesher; it cannot
                    // authorize a false empty-tile skip. The exact lattice itself is unchanged.
                    FExactLatticeBlock& Block = ExactLatticeBlocks.AddDefaulted_GetRef();
                    Block.IX0 = ExactIX0;
                    Block.IX1 = IX1;
                    Block.IY0 = ExactIY0;
                    Block.IY1 = IY1;
                    Block.IZ0 = ExactIZ0;
                    Block.IZ1 = IZ1;
                    Block.WarpedMin = ExactLatticeQueryMin;
                    Block.WarpedMax = ExactLatticeQueryMax;
                    Block.WorldMin = FVector(
                        LatticeOriginX + (float)ExactIX0 * LatticeStepXY,
                        LatticeOriginY + (float)ExactIY0 * LatticeStepXY,
                        (float)Ctx.LatticeOriginVoxels.Z
                            + (float)ExactIZ0 * (float)Ctx.Step);
                    Block.WorldMax = FVector(
                        LatticeOriginX + (float)IX1 * LatticeStepXY,
                        LatticeOriginY + (float)IY1 * LatticeStepXY,
                        (float)Ctx.LatticeOriginVoxels.Z
                            + (float)IZ1 * (float)Ctx.Step);
                }
            }

            const bool bUseExactLatticeWarp = ExactLatticeWarpedQueries.Num() > 0;
            const bool bUseExactLatticeBox = !bUseExactLatticeWarp
                && ExactLatticeQueryMin.X <= ExactLatticeQueryMax.X
                && ExactLatticeQueryMin.Y <= ExactLatticeQueryMax.Y
                && ExactLatticeQueryMin.Z <= ExactLatticeQueryMax.Z;
            bool bInvalidBound = false;
            float ExactSdfLower = FLT_MAX;
            float CheapSdfLower = FLT_MAX;
            int32 ExactRoomRefinements = 0;
            int32 ExactJoinRefinements = 0;
            int32 ExactTunnelRefinements = 0;
            int32 ExactPitRefinements = 0;
            int32 ExactChimneyRefinements = 0;

            auto ExactLatticePointDistance = [&](const FVector& Target) -> float
            {
                float Distance = FLT_MAX;
                // The block AABB contains every warped lattice point in the block.  Its distance
                // to the target is therefore a conservative lower bound for the exact point
                // minimum.  Do not rescan all 17^3 points for every room just to obtain this
                // broad-phase value; the same 2x2x2 block lattice is already built below for the
                // exact primitive walk.
                for (const FExactLatticeBlock& Block : ExactLatticeBlocks)
                {
                    Distance = FMath::Min(
                        Distance,
                        VF_DistanceBetweenBoxes(
                            Block.WarpedMin, Block.WarpedMax, Target, Target));
                }
                return FMath::Max(0.0f, Distance - 0.001f);
            };

            auto ExactLatticeBoxDistance = [&](const FVector& TargetMin,
                                               const FVector& TargetMax) -> float
            {
                float Distance = FLT_MAX;
                // As above, the block AABB distance is no larger than the distance from the
                // contained exact points to the target interval.  It can lose a skip, but can
                // never turn an unproven box into a proof.
                for (const FExactLatticeBlock& Block : ExactLatticeBlocks)
                {
                    Distance = FMath::Min(
                        Distance,
                        VF_DistanceBetweenBoxes(
                            Block.WarpedMin, Block.WarpedMax, TargetMin, TargetMax));
                }
                return FMath::Max(0.0f, Distance - 0.001f);
            };

            auto ForEachExactQueryInWorldBox = [&](const FVector& WorldMin,
                                                   const FVector& WorldMax,
                                                   auto&& Callback)
            {
                if (ExactNX <= 0 || ExactNY <= 0 || ExactNZ <= 0) { return; }
                const int32 IX0 = FMath::Max(
                    ExactIX0,
                    FMath::CeilToInt(
                        (WorldMin.X - LatticeOriginX) / LatticeStepXY - 1.0e-4f));
                const int32 IY0 = FMath::Max(
                    ExactIY0,
                    FMath::CeilToInt(
                        (WorldMin.Y - LatticeOriginY) / LatticeStepXY - 1.0e-4f));
                const int32 IZ0 = FMath::Max(
                    ExactIZ0,
                    FMath::CeilToInt(
                        (WorldMin.Z - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                        / static_cast<float>(Ctx.Step) - 1.0e-4f));
                const int32 IX1 = FMath::Min(
                    ExactIX0 + ExactNX - 1,
                    FMath::FloorToInt(
                        (WorldMax.X - LatticeOriginX) / LatticeStepXY + 1.0e-4f));
                const int32 IY1 = FMath::Min(
                    ExactIY0 + ExactNY - 1,
                    FMath::FloorToInt(
                        (WorldMax.Y - LatticeOriginY) / LatticeStepXY + 1.0e-4f));
                const int32 IZ1 = FMath::Min(
                    ExactIZ0 + ExactNZ - 1,
                    FMath::FloorToInt(
                        (WorldMax.Z - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                        / static_cast<float>(Ctx.Step) + 1.0e-4f));
                if (IX1 < IX0 || IY1 < IY0 || IZ1 < IZ0) { return; }

                for (int32 IZ = IZ0; IZ <= IZ1; ++IZ)
                for (int32 IY = IY0; IY <= IY1; ++IY)
                for (int32 IX = IX0; IX <= IX1; ++IX)
                {
                    const int32 FlatIndex =
                        ((IZ - ExactIZ0) * ExactNY + (IY - ExactIY0)) * ExactNX
                        + (IX - ExactIX0);
                    Callback(
                        ExactLatticeWarpedQueries[FlatIndex],
                        ExactLatticeWorldQueries[FlatIndex]);
                }
            };

            auto DistanceBlockToInfiniteLineLower = [&](const FExactLatticeBlock& Block,
                                                         const FVector& A,
                                                         const FVector& BPoint) -> float
            {
                const FVector Direction = BPoint - A;
                const float LengthSq = Direction.SizeSquared();
                if (!(LengthSq > KINDA_SMALL_NUMBER))
                {
                    return VF_DistanceBetweenBoxes(
                        Block.WarpedMin, Block.WarpedMax, A, A);
                }

                auto LinearRange = [](float Coefficient, float MinValue, float MaxValue,
                                      float Offset, float& OutMin, float& OutMax)
                {
                    const float AValue = Coefficient * (MinValue - Offset);
                    const float BValue = Coefficient * (MaxValue - Offset);
                    OutMin = FMath::Min(AValue, BValue);
                    OutMax = FMath::Max(AValue, BValue);
                };
                auto DistanceToZero = [](float MinValue, float MaxValue) -> float
                {
                    return MinValue > 0.0f ? MinValue
                         : MaxValue < 0.0f ? -MaxValue : 0.0f;
                };

                float XYMin = 0.0f, XYMax = 0.0f;
                float ZYMin = 0.0f, ZYMax = 0.0f;
                float XZMin = 0.0f, XZMax = 0.0f;
                float YXMin = 0.0f, YXMax = 0.0f;
                float ZXMin = 0.0f, ZXMax = 0.0f;
                float ZY2Min = 0.0f, ZY2Max = 0.0f;
                LinearRange(Direction.Y, Block.WarpedMin.Z, Block.WarpedMax.Z,
                            (float)A.Z, ZYMin, ZYMax);
                LinearRange(Direction.Z, Block.WarpedMin.Y, Block.WarpedMax.Y,
                            (float)A.Y, YXMin, YXMax);
                LinearRange(Direction.Z, Block.WarpedMin.X, Block.WarpedMax.X,
                            (float)A.X, XZMin, XZMax);
                LinearRange(Direction.X, Block.WarpedMin.Z, Block.WarpedMax.Z,
                            (float)A.Z, ZXMin, ZXMax);
                LinearRange(Direction.X, Block.WarpedMin.Y, Block.WarpedMax.Y,
                            (float)A.Y, XYMin, XYMax);
                LinearRange(Direction.Y, Block.WarpedMin.X, Block.WarpedMax.X,
                            (float)A.X, ZY2Min, ZY2Max);

                const float CrossXMin = ZYMin - YXMax;
                const float CrossXMax = ZYMax - YXMin;
                const float CrossYMin = XZMin - ZXMax;
                const float CrossYMax = XZMax - ZXMin;
                const float CrossZMin = XYMin - ZY2Max;
                const float CrossZMax = XYMax - ZY2Min;
                const float DX = DistanceToZero(CrossXMin, CrossXMax);
                const float DY = DistanceToZero(CrossYMin, CrossYMax);
                const float DZ = DistanceToZero(CrossZMin, CrossZMax);
                return FMath::Sqrt((DX * DX + DY * DY + DZ * DZ) / LengthSq);
            };

            auto LatticePointDistance = [&](const FVector& Target, const FVector& Extra) -> float
            {
                if (bUseExactLatticeWarp)
                {
                    return ExactLatticePointDistance(Target);
                }
                if (bUseExactLatticeBox)
                {
                    return VF_DistanceBetweenBoxes(
                        ExactLatticeQueryMin, ExactLatticeQueryMax, Target, Target);
                }
                const float DX = VF_LatticeAxisDistanceToPoint(
                    BoxMinX, BoxMaxX, LatticeOriginX, LatticeStepXY,
                    static_cast<float>(Target.X), (float)Extra.X);
                const float DY = VF_LatticeAxisDistanceToPoint(
                    BoxMinY, BoxMaxY, LatticeOriginY, LatticeStepXY,
                    static_cast<float>(Target.Y), (float)Extra.Y);
                const float DZ = VF_LatticeAxisDistanceToPoint(
                    BoxMinZ, BoxMaxZ, LatticeOriginZ, LatticeStepZ,
                    static_cast<float>(Target.Z), (float)Extra.Z);
                return FMath::Sqrt(DX * DX + DY * DY + DZ * DZ);
            };

            auto LatticeBoxDistance = [&](const FVector& TargetMin,
                                          const FVector& TargetMax,
                                          const FVector& Extra) -> float
            {
                if (bUseExactLatticeWarp)
                {
                    return ExactLatticeBoxDistance(TargetMin, TargetMax);
                }
                if (bUseExactLatticeBox)
                {
                    return VF_DistanceBetweenBoxes(
                        ExactLatticeQueryMin, ExactLatticeQueryMax, TargetMin, TargetMax);
                }
                const float DX = VF_LatticeAxisDistanceToInterval(
                    BoxMinX, BoxMaxX, LatticeOriginX, LatticeStepXY,
                    static_cast<float>(TargetMin.X), static_cast<float>(TargetMax.X),
                    (float)Extra.X);
                const float DY = VF_LatticeAxisDistanceToInterval(
                    BoxMinY, BoxMaxY, LatticeOriginY, LatticeStepXY,
                    static_cast<float>(TargetMin.Y), static_cast<float>(TargetMax.Y),
                    (float)Extra.Y);
                const float DZ = VF_LatticeAxisDistanceToInterval(
                    BoxMinZ, BoxMaxZ, LatticeOriginZ, LatticeStepZ,
                    static_cast<float>(TargetMin.Z), static_cast<float>(TargetMax.Z),
                    (float)Extra.Z);
                return FMath::Sqrt(DX * DX + DY * DY + DZ * DZ);
            };

            // The exact warped lattice list is also an exact AABB superset.  Use that cheap
            // distance as a first test and pay the primitive-by-query walk only when this bound is
            // close enough to affect the source's active threshold.  A far primitive can only
            // raise the lower bound; retaining its AABB bound is conservative and avoids scanning
            // 729 queries for every cached room/tunnel in every refined child.
            auto ExactLatticeAabbPointDistance = [&](const FVector& Target) -> float
            {
                return bUseExactLatticeWarp
                    && ExactLatticeQueryMin.X <= ExactLatticeQueryMax.X
                    && ExactLatticeQueryMin.Y <= ExactLatticeQueryMax.Y
                    && ExactLatticeQueryMin.Z <= ExactLatticeQueryMax.Z
                    ? VF_DistanceBetweenBoxes(
                        ExactLatticeQueryMin, ExactLatticeQueryMax, Target, Target)
                    : FLT_MAX;
            };
            auto ExactLatticeAabbBoxDistance = [&](const FVector& TargetMin,
                                                   const FVector& TargetMax) -> float
            {
                return bUseExactLatticeWarp
                    && ExactLatticeQueryMin.X <= ExactLatticeQueryMax.X
                    && ExactLatticeQueryMin.Y <= ExactLatticeQueryMax.Y
                    && ExactLatticeQueryMin.Z <= ExactLatticeQueryMax.Z
                    ? VF_DistanceBetweenBoxes(
                        ExactLatticeQueryMin, ExactLatticeQueryMax, TargetMin, TargetMax)
                    : FLT_MAX;
            };

            // Conservative lower bounds for primitive values on each warped lattice block.
            // Earlier versions walked every exact point in every refined child here. That was
            // sound, but it made an empty LOD0 tile pay thousands of room/tunnel evaluations.
            // These bounds are over the whole block AABB, which contains every warped lattice
            // point in the block. They are therefore allowed to be looser than the finite-point
            // minimum: looser costs a proof, never geometry. The smooth-min fold below remains
            // monotone in every primitive lower bound.
            auto ExactRoomShapeLower = [&](const FCachedRoom& Room,
                                           const FExactLatticeBlock& Block) -> float
            {
                auto Invalid = [&]() -> float
                {
                    bInvalidBound = true;
                    return 0.0f;
                };
                const FVector BlockMin = Block.WarpedMin;
                const FVector BlockMax = Block.WarpedMax;
                if (!Finite((float)BlockMin.X) || !Finite((float)BlockMin.Y)
                    || !Finite((float)BlockMin.Z) || !Finite((float)BlockMax.X)
                    || !Finite((float)BlockMax.Y) || !Finite((float)BlockMax.Z))
                {
                    return Invalid();
                }

                switch (Room.ShapeType)
                {
                case 0:
                {
                    // VoxelSDF::Ellipsoid uses the scaled Euclidean distance multiplied by
                    // the average radius. The closest scaled point to an axis-aligned box is
                    // obtained independently on each axis, so this is a direct lower bound for
                    // the exact approximation used by Eval.
                    const FVector& Radii = Room.ShapeA;
                    if (!Finite((float)Radii.X) || !Finite((float)Radii.Y)
                        || !Finite((float)Radii.Z) || Radii.X <= 0.0
                        || Radii.Y <= 0.0 || Radii.Z <= 0.0)
                    {
                        return Invalid();
                    }
                    const float Cx = (float)Room.Center.X;
                    const float Cy = (float)Room.Center.Y;
                    const float Cz = (float)Room.Center.Z;
                    const float Rx = (float)Radii.X;
                    const float Ry = (float)Radii.Y;
                    const float Rz = (float)Radii.Z;
                    const float DX = BlockMin.X > Cx ? BlockMin.X - Cx
                        : BlockMax.X < Cx ? Cx - BlockMax.X : 0.0f;
                    const float DY = BlockMin.Y > Cy ? BlockMin.Y - Cy
                        : BlockMax.Y < Cy ? Cy - BlockMax.Y : 0.0f;
                    const float DZ = BlockMin.Z > Cz ? BlockMin.Z - Cz
                        : BlockMax.Z < Cz ? Cz - BlockMax.Z : 0.0f;
                    const float AverageRadius = (Rx + Ry + Rz) / 3.0f;
                    const float ScaledDistance = FMath::Sqrt(
                        (DX / Rx) * (DX / Rx)
                        + (DY / Ry) * (DY / Ry)
                        + (DZ / Rz) * (DZ / Rz));
                    const float Lower = (ScaledDistance - 1.0f) * AverageRadius;
                    return Finite(Lower) ? Lower : Invalid();
                }
                case 1:
                {
                    // The rounded-box SDF is the exact SDF of a box dilated by a sphere. The
                    // enclosing sphere gives a cheap, unconditional lower bound for its signed
                    // distance, including points inside the box.
                    const FVector& HalfExtent = Room.ShapeA;
                    const float Rounding = (float)Room.ShapeR;
                    if (!Finite((float)HalfExtent.X) || !Finite((float)HalfExtent.Y)
                        || !Finite((float)HalfExtent.Z) || !Finite(Rounding)
                        || HalfExtent.X < 0.0 || HalfExtent.Y < 0.0
                        || HalfExtent.Z < 0.0 || Rounding < 0.0f)
                    {
                        return Invalid();
                    }
                    const FVector OuterExtent(
                        (float)HalfExtent.X + Rounding,
                        (float)HalfExtent.Y + Rounding,
                        (float)HalfExtent.Z + Rounding);
                    const float Lower = VF_DistanceBetweenBoxes(
                        BlockMin, BlockMax, Room.Center, Room.Center) - OuterExtent.Size();
                    return Finite(Lower) ? Lower : Invalid();
                }
                case 2:
                {
                    if (!Finite((float)Room.ShapeA.X) || !Finite((float)Room.ShapeA.Y)
                        || !Finite((float)Room.ShapeA.Z) || !Finite((float)Room.ShapeB.X)
                        || !Finite((float)Room.ShapeB.Y) || !Finite((float)Room.ShapeB.Z)
                        || !Finite((float)Room.ShapeR) || Room.ShapeR < 0.0f)
                    {
                        return Invalid();
                    }
                    const float Lower = DistanceBlockToInfiniteLineLower(
                        Block, Room.ShapeA, Room.ShapeB) - FMath::Abs((float)Room.ShapeR);
                    return Finite(Lower) ? Lower : Invalid();
                }
                default:
                    return Invalid();
                }
            };

            auto ExactRoomLower = [&](const FCachedRoom& Room) -> float
            {
                float LowerBound = FLT_MAX;
                const float CullRadiusSq = Room.CullRadiusSq;
                if (!Finite(CullRadiusSq) || CullRadiusSq < 0.0f)
                {
                    bInvalidBound = true;
                    return LowerBound;
                }
                const float CullRadius = FMath::Sqrt(CullRadiusSq);
                for (const FExactLatticeBlock& Block : ExactLatticeBlocks)
                {
                    const float BlockDistance = VF_DistanceBetweenBoxes(
                        Block.WarpedMin, Block.WarpedMax,
                        Room.Center, Room.Center);
                    if (!Finite(BlockDistance))
                    {
                        bInvalidBound = true;
                        continue;
                    }
                    // Every point in this block fails Eval's sphere cull when the block itself
                    // is farther than the cull radius. This reject is exact for that cull.
                    if (BlockDistance > CullRadius)
                    {
                        continue;
                    }

                    float RoomLower = ExactRoomShapeLower(Room, Block);
                    if (bInvalidBound) { continue; }
                    if (Room.FloorCutZ > -FLT_MAX)
                    {
                        if (!Finite((float)Room.FloorCutZ)
                            || !Finite((float)Room.FloorReliefStrength)
                            || (Room.FloorReliefStrength > 0.0f
                                && !Finite((float)Room.FloorReliefFrequency)))
                        {
                            bInvalidBound = true;
                            continue;
                        }
                        const float ReliefBound = Room.FloorReliefStrength > 0.0f
                            ? FMath::Abs((float)Room.FloorReliefStrength)
                                * VOXEL_NOISE_SCALE * VF_PerlinAbsBound
                            : 0.0f;
                        // SmoothMax(a,b) is never below max(a,b), so independently bounded
                        // shape and floor terms can be combined with an ordinary Max.
                        const float FloorLower = (float)Room.FloorCutZ - ReliefBound
                            - (float)Block.WarpedMax.Z;
                        RoomLower = FMath::Max(RoomLower, FloorLower);
                    }
                    LowerBound = FMath::Min(LowerBound, RoomLower);
                }
                return LowerBound;
            };

            auto ExactJoinLower = [&](const FCachedRoomFloorJoin& Join) -> float
            {
                float LowerBound = FLT_MAX;
                if (!Finite((float)Join.BoundRadiusSq) || Join.BoundRadiusSq < 0.0f
                    || !Finite((float)Join.BoundCenter.X)
                    || !Finite((float)Join.BoundCenter.Y)
                    || !Finite((float)Join.BoundCenter.Z)
                    || !Finite((float)Join.Start.X) || !Finite((float)Join.Start.Y)
                    || !Finite((float)Join.Start.Z) || !Finite((float)Join.End.X)
                    || !Finite((float)Join.End.Y) || !Finite((float)Join.End.Z)
                    || !Finite((float)Join.Radius) || !Finite((float)Join.FloorZ)
                    || !Finite((float)Join.CeilingZ) || Join.Radius < 0.0f)
                {
                    bInvalidBound = true;
                    return LowerBound;
                }
                const float BoundRadius = FMath::Sqrt(Join.BoundRadiusSq);
                for (const FExactLatticeBlock& Block : ExactLatticeBlocks)
                {
                    const float BlockDistance = VF_DistanceBetweenBoxes(
                        Block.WarpedMin, Block.WarpedMax,
                        Join.BoundCenter, Join.BoundCenter);
                    if (BlockDistance > BoundRadius)
                    {
                        continue;
                    }
                    const float HorizontalLower = DistanceBlockToInfiniteLineLower(
                        Block, Join.Start, Join.End) - FMath::Abs(Join.Radius);
                    const float VerticalLower = FMath::Max(
                        Join.FloorZ - (float)Block.WarpedMax.Z,
                        (float)Block.WarpedMin.Z - Join.CeilingZ);
                    const float Lower = FMath::Max(HorizontalLower, VerticalLower);
                    if (!Finite(Lower))
                    {
                        bInvalidBound = true;
                        continue;
                    }
                    LowerBound = FMath::Min(LowerBound, Lower);
                }
                return LowerBound;
            };

            auto ExactTunnelLower = [&](const FCachedTunnel& Tunnel) -> float
            {
                float LowerBound = FLT_MAX;
                if (!Finite((float)Tunnel.BoundRadiusSq)
                    || Tunnel.BoundRadiusSq < 0.0f
                    || !Finite((float)Tunnel.BoundCenter.X)
                    || !Finite((float)Tunnel.BoundCenter.Y)
                    || !Finite((float)Tunnel.BoundCenter.Z)
                    || !Finite((float)Tunnel.SDFInfluenceRadius)
                    || !Finite((float)Tunnel.SDFCenterlineMin.X)
                    || !Finite((float)Tunnel.SDFCenterlineMin.Y)
                    || !Finite((float)Tunnel.SDFCenterlineMin.Z)
                    || !Finite((float)Tunnel.SDFCenterlineMax.X)
                    || !Finite((float)Tunnel.SDFCenterlineMax.Y)
                    || !Finite((float)Tunnel.SDFCenterlineMax.Z)
                    || Tunnel.SDFCenterlineMin.X > Tunnel.SDFCenterlineMax.X
                    || Tunnel.SDFCenterlineMin.Y > Tunnel.SDFCenterlineMax.Y
                    || Tunnel.SDFCenterlineMin.Z > Tunnel.SDFCenterlineMax.Z)
                {
                    bInvalidBound = true;
                    return LowerBound;
                }
                const float BoundRadius = FMath::Sqrt(Tunnel.BoundRadiusSq);
                auto EvaluateSegment = [&](const FVector& A, const FVector& BPoint,
                                           float RadiusA, float RadiusB)
                {
                    if (!Finite((float)A.X) || !Finite((float)A.Y)
                        || !Finite((float)A.Z) || !Finite((float)BPoint.X)
                        || !Finite((float)BPoint.Y) || !Finite((float)BPoint.Z)
                        || !Finite(RadiusA) || !Finite(RadiusB))
                    {
                        bInvalidBound = true;
                        return;
                    }
                    const float SegmentRadius = FMath::Max(
                        FMath::Abs(RadiusA), FMath::Abs(RadiusB));
                    const FVector SegmentMin(
                        FMath::Min(A.X, BPoint.X), FMath::Min(A.Y, BPoint.Y),
                        FMath::Min(A.Z, BPoint.Z));
                    const FVector SegmentMax(
                        FMath::Max(A.X, BPoint.X), FMath::Max(A.Y, BPoint.Y),
                        FMath::Max(A.Z, BPoint.Z));
                    for (const FExactLatticeBlock& Block : ExactLatticeBlocks)
                    {
                        if (Tunnel.SDFInfluenceRadius > 0.0f
                            && VF_DistanceBetweenBoxes(
                                Block.WarpedMin, Block.WarpedMax,
                                Tunnel.SDFCenterlineMin, Tunnel.SDFCenterlineMax)
                                > Tunnel.SDFInfluenceRadius)
                        {
                            continue;
                        }
                        if (VF_DistanceBetweenBoxes(
                                Block.WarpedMin, Block.WarpedMax,
                                Tunnel.BoundCenter, Tunnel.BoundCenter)
                            > BoundRadius)
                        {
                            continue;
                        }

                        // Both terms are lower bounds for distance to the finite segment:
                        // the first uses the infinite supporting line, while the second uses
                        // the segment's AABB. Their maximum is still a lower bound and is much
                        // tighter near a segment endpoint than either term alone.
                        const float LineLower = DistanceBlockToInfiniteLineLower(
                            Block, A, BPoint);
                        const float SegmentBoxLower = VF_DistanceBetweenBoxes(
                            Block.WarpedMin, Block.WarpedMax, SegmentMin, SegmentMax);
                        const float Lower = FMath::Max(LineLower, SegmentBoxLower)
                            - SegmentRadius;
                        if (!Finite(Lower))
                        {
                            bInvalidBound = true;
                            continue;
                        }
                        LowerBound = FMath::Min(LowerBound, Lower);
                    }
                };

                if (Tunnel.ControlPoints.Num() >= 2
                    && Tunnel.ControlRadii.Num() == Tunnel.ControlPoints.Num())
                {
                    for (int32 SegmentIndex = 0;
                         SegmentIndex + 1 < Tunnel.ControlPoints.Num();
                         ++SegmentIndex)
                    {
                        EvaluateSegment(
                            Tunnel.ControlPoints[SegmentIndex],
                            Tunnel.ControlPoints[SegmentIndex + 1],
                            Tunnel.ControlRadii[SegmentIndex],
                            Tunnel.ControlRadii[SegmentIndex + 1]);
                    }
                }
                else if (Tunnel.bHasMidpoint)
                {
                    EvaluateSegment(Tunnel.EndpointA, Tunnel.Midpoint,
                                    Tunnel.RadiusA, Tunnel.RadiusMid);
                    EvaluateSegment(Tunnel.Midpoint, Tunnel.EndpointB,
                                    Tunnel.RadiusMid, Tunnel.RadiusB);
                }
                else
                {
                    EvaluateSegment(Tunnel.EndpointA, Tunnel.EndpointB,
                                    Tunnel.RadiusA, Tunnel.RadiusB);
                }
                return LowerBound;
            };

            auto ExactPitLower = [&](const FCachedPit& Pit) -> float
            {
                float LowerBound = FLT_MAX;
                const float Radius = FMath::Sqrt(FMath::Max(Pit.BoundXYRadiusSq, 0.0f));
                const FVector CandidateMin(
                    Pit.CenterX - Radius, Pit.CenterY - Radius,
                    Pit.TopZ - Pit.Depth - Pit.BlendK);
                const FVector CandidateMax(
                    Pit.CenterX + Radius, Pit.CenterY + Radius,
                    Pit.TopZ + Pit.BlendK);
                ForEachExactQueryInWorldBox(
                    CandidateMin, CandidateMax,
                    [&](const FVector&, const FVector& Query)
                {
                    const float DZ = (float)Query.Z - Pit.TopZ;
                    if (DZ >= Pit.BlendK || -DZ > Pit.Depth + Pit.BlendK)
                    {
                        return;
                    }
                    const float DX = (float)Query.X - Pit.CenterX;
                    const float DY = (float)Query.Y - Pit.CenterY;
                    const float XYDistSq = DX * DX + DY * DY;
                    if (XYDistSq > Pit.BoundXYRadiusSq) { return; }
                    float PitSDF;
                    if (DZ <= 0.0f)
                    {
                        float FlareFactor = FMath::Clamp(
                            1.0f - (-DZ) / Pit.FlareDist, 0.0f, 1.0f);
                        FlareFactor *= FlareFactor;
                        PitSDF = FMath::Sqrt(XYDistSq)
                               - (Pit.Radius + Pit.FlareExtra * FlareFactor);
                    }
                    else
                    {
                        PitSDF = FMath::Sqrt(XYDistSq)
                               - (Pit.Radius + Pit.FlareExtra);
                    }
                    LowerBound = FMath::Min(LowerBound, PitSDF);
                });
                return LowerBound;
            };

            auto ExactChimneyLower = [&](const FCachedChimney& Chimney) -> float
            {
                float LowerBound = FLT_MAX;
                const float Radius = FMath::Sqrt(FMath::Max(Chimney.BoundXYRadiusSq, 0.0f));
                const FVector CandidateMin(
                    Chimney.CenterX - Radius, Chimney.CenterY - Radius,
                    Chimney.BottomZ - Chimney.BlendK);
                const FVector CandidateMax(
                    Chimney.CenterX + Radius, Chimney.CenterY + Radius,
                    Chimney.BottomZ + Chimney.Height + Chimney.BlendK);
                ForEachExactQueryInWorldBox(
                    CandidateMin, CandidateMax,
                    [&](const FVector&, const FVector& Query)
                {
                    const float DZ = (float)Query.Z - Chimney.BottomZ;
                    if (-DZ >= Chimney.BlendK || DZ > Chimney.Height + Chimney.BlendK)
                    {
                        return;
                    }
                    const float DX = (float)Query.X - Chimney.CenterX;
                    const float DY = (float)Query.Y - Chimney.CenterY;
                    const float XYDistSq = DX * DX + DY * DY;
                    if (XYDistSq > Chimney.BoundXYRadiusSq) { return; }
                    float ChimneySDF;
                    if (DZ >= 0.0f)
                    {
                        float FlareFactor = FMath::Clamp(
                            1.0f - DZ / Chimney.FlareDist, 0.0f, 1.0f);
                        FlareFactor *= FlareFactor;
                        ChimneySDF = FMath::Sqrt(XYDistSq)
                                   - (Chimney.Radius + Chimney.FlareExtra * FlareFactor);
                    }
                    else
                    {
                        ChimneySDF = FMath::Sqrt(XYDistSq)
                                   - (Chimney.Radius + Chimney.FlareExtra);
                    }
                    LowerBound = FMath::Min(LowerBound, ChimneySDF);
                });
                return LowerBound;
            };

            auto ConsiderExact = [&](float PrimitiveLower, float BlendRadius)
            {
                if (!Finite(PrimitiveLower) || !Finite(BlendRadius))
                {
                    bInvalidBound = true;
                    return;
                }
                ExactSdfLower = VoxelSDF::SmoothMin(
                    ExactSdfLower, PrimitiveLower, BlendRadius);
            };
            auto ConsiderCheapExact = [&](float PrimitiveLower, float BlendRadius)
            {
                if (Finite(PrimitiveLower) && Finite(BlendRadius))
                {
                    CheapSdfLower = VoxelSDF::SmoothMin(
                        CheapSdfLower, PrimitiveLower, BlendRadius);
                }
            };

            auto LatticeXYPointDistance = [&](float X, float Y) -> float
            {
                const float DX = VF_LatticeAxisDistanceToPoint(
                    BoxMinX, BoxMaxX, LatticeOriginX, LatticeStepXY, X, 0.0f);
                const float DY = VF_LatticeAxisDistanceToPoint(
                    BoxMinY, BoxMaxY, LatticeOriginY, LatticeStepXY, Y, 0.0f);
                return FMath::Sqrt(DX * DX + DY * DY);
            };

            const float K = P.SDFBlendRadius;
            const float WormThreshold = VoxelMath::IsFinite(P.WormNetworkRange)
                                       ? FMath::Max(3.0f * K, P.WormNetworkRange) : FLT_MAX;
            const float ThresholdWithBlend = VF_SaturatingAdd(WormThreshold, K);
            float Lower = FLT_MAX;
            bool bAnyPrimitive = false;

            auto Consider = [&](float Candidate)
            {
                if (!Finite(Candidate))
                {
                    bInvalidBound = true;
                    return;
                }
                bAnyPrimitive = true;
                Lower = FMath::Min(Lower, Candidate);
            };
            auto CountThreshold = [&](float Candidate, int32& Count)
            {
                if (Finite(Candidate) && Candidate < ThresholdWithBlend) { ++Count; }
            };

            B.NumRooms = GetBoxCache().Rooms.Num();
            B.NumTunnels = GetBoxCache().Tunnels.Num();
            B.NumRoomFloorJoins = GetBoxCache().RoomFloorJoins.Num();
            B.NumPits = GetBoxCache().Pits.Num();
            B.NumChimneys = GetBoxCache().Chimneys.Num();
            B.HitRooms = B.HitTunnels = B.HitPits = B.HitChimneys = 0;
            B.HitRoomsNoWarp = B.HitTunnelsNoWarp = 0;
            B.WarpDilation = FMath::Max3(
                (float)WarpEnvelope.X, (float)WarpEnvelope.Y, (float)WarpEnvelope.Z);
            B.bMayHaveTunnelCoreAir = false;
            B.bMayHaveTunnelSupportFloor = false;
            B.bMayHaveTunnelCoreTail = false;

            auto MayHaveTunnelCoreTail = [&](const FCachedTunnel& Tunnel) -> uint8
            {
                const bool bHasWorldChain = Tunnel.WorldControlPoints.Num() >= 2
                    && Tunnel.WorldControlRadii.Num() == Tunnel.WorldControlPoints.Num();
                const FVector& CenterlineMin = bHasWorldChain
                    ? Tunnel.WorldCenterlineMin : Tunnel.SDFCenterlineMin;
                const FVector& CenterlineMax = bHasWorldChain
                    ? Tunnel.WorldCenterlineMax : Tunnel.SDFCenterlineMax;
                const float InfluenceRadius = bHasWorldChain
                    ? Tunnel.WorldInfluenceRadius : Tunnel.SDFInfluenceRadius;
                const FVector& BoundCenter = bHasWorldChain
                    ? Tunnel.WorldBoundCenter : Tunnel.BoundCenter;
                const float BoundRadiusSq = bHasWorldChain
                    ? Tunnel.WorldBoundRadiusSq : Tunnel.BoundRadiusSq;
                if (!Finite((float)CenterlineMin.X) || !Finite((float)CenterlineMin.Y)
                    || !Finite((float)CenterlineMin.Z) || !Finite((float)CenterlineMax.X)
                    || !Finite((float)CenterlineMax.Y) || !Finite((float)CenterlineMax.Z)
                    || !Finite(InfluenceRadius) || InfluenceRadius < 0.0f
                    || !Finite((float)BoundCenter.X) || !Finite((float)BoundCenter.Y)
                    || !Finite((float)BoundCenter.Z) || !Finite(BoundRadiusSq)
                    || BoundRadiusSq < 0.0f)
                {
                    return 3u;
                }

                // A post-air sample must lie within a tapered capsule's maximum radius of one
                // world-chain segment.  The segment AABB expanded by that radius is a cheap
                // superset of the exact capsule; unlike the old enclosing sphere it rejects a
                // long, thin tunnel from most unrelated LOD0 boxes.  The floor is part of this
                // same continuous field, so no second support-band candidate is needed.
                if (Ctx.bUseLatticeProof)
                {
                    const float WorldLatticeOriginX =
                        static_cast<float>(Ctx.LatticeOriginVoxels.X);
                    const float WorldLatticeOriginY =
                        static_cast<float>(Ctx.LatticeOriginVoxels.Y);
                    const float WorldLatticeOriginZ =
                        static_cast<float>(Ctx.LatticeOriginVoxels.Z);
                    const float WorldLatticeStep = static_cast<float>(Ctx.Step);
                    if (!(WorldLatticeStep > 0.0f)) { return 3u; }

                    auto TouchesLatticeAABB = [&](float MinX, float MaxX,
                                                   float MinY, float MaxY,
                                                   float MinZ, float MaxZ) -> bool
                    {
                        return VF_LatticeAxisDistanceToInterval(
                                   BoxMinX, BoxMaxX, WorldLatticeOriginX, WorldLatticeStep,
                                   MinX, MaxX, 0.0f) <= 0.0f
                            && VF_LatticeAxisDistanceToInterval(
                                   BoxMinY, BoxMaxY, WorldLatticeOriginY, WorldLatticeStep,
                                   MinY, MaxY, 0.0f) <= 0.0f
                            && VF_LatticeAxisDistanceToInterval(
                                   BoxMinZ, BoxMaxZ, WorldLatticeOriginZ, WorldLatticeStep,
                                   MinZ, MaxZ, 0.0f) <= 0.0f;
                    };

                    uint8 Result = 0u;
                    auto AddSegment = [&](const FVector& A, const FVector& BPoint,
                                           float RadiusA, float RadiusB,
                                           bool bWorldChain, int32 SegmentIndex)
                    {
                        if (!Finite((float)A.X) || !Finite((float)A.Y)
                            || !Finite((float)A.Z) || !Finite((float)BPoint.X)
                            || !Finite((float)BPoint.Y) || !Finite((float)BPoint.Z)
                            || !Finite(RadiusA) || !Finite(RadiusB))
                        {
                            Result = 3u;
                            return;
                        }
                        const float SafeRadiusA = FMath::Abs(RadiusA);
                        const float SafeRadiusB = FMath::Abs(RadiusB);
                        const float MaxRadius = FMath::Max(SafeRadiusA, SafeRadiusB);
                        if (!Finite(MaxRadius)) { Result = 3u; return; }

                        if (TouchesLatticeAABB(
                                FMath::Min(A.X, BPoint.X) - MaxRadius,
                                FMath::Max(A.X, BPoint.X) + MaxRadius,
                                FMath::Min(A.Y, BPoint.Y) - MaxRadius,
                                FMath::Max(A.Y, BPoint.Y) + MaxRadius,
                                FMath::Min(A.Z, BPoint.Z) - MaxRadius,
                                FMath::Max(A.Z, BPoint.Z) + MaxRadius))
                        {
                            Result |= 1u;
                        }

                        (void)bWorldChain;
                        (void)SegmentIndex;
                    };

                    if (bHasWorldChain)
                    {
                        for (int32 SegmentIndex = 0;
                             SegmentIndex + 1 < Tunnel.WorldControlPoints.Num();
                             ++SegmentIndex)
                        {
                            AddSegment(
                                Tunnel.WorldControlPoints[SegmentIndex],
                                Tunnel.WorldControlPoints[SegmentIndex + 1],
                                Tunnel.WorldControlRadii[SegmentIndex],
                                Tunnel.WorldControlRadii[SegmentIndex + 1], true, SegmentIndex);
                            if (Result == 3u) { return Result; }
                        }
                    }
                    else if (Tunnel.ControlPoints.Num() >= 2
                        && Tunnel.ControlRadii.Num() == Tunnel.ControlPoints.Num())
                    {
                        for (int32 SegmentIndex = 0;
                             SegmentIndex + 1 < Tunnel.ControlPoints.Num();
                             ++SegmentIndex)
                        {
                            AddSegment(
                                Tunnel.ControlPoints[SegmentIndex],
                                Tunnel.ControlPoints[SegmentIndex + 1],
                                Tunnel.ControlRadii[SegmentIndex],
                                Tunnel.ControlRadii[SegmentIndex + 1], false, SegmentIndex);
                            if (Result == 3u) { return Result; }
                        }
                    }
                    else if (Tunnel.bHasMidpoint)
                    {
                        AddSegment(Tunnel.EndpointA, Tunnel.Midpoint,
                                   Tunnel.RadiusA, Tunnel.RadiusMid, false, INDEX_NONE);
                        AddSegment(Tunnel.Midpoint, Tunnel.EndpointB,
                                   Tunnel.RadiusMid, Tunnel.RadiusB, false, INDEX_NONE);
                    }
                    else
                    {
                        AddSegment(Tunnel.EndpointA, Tunnel.EndpointB,
                                   Tunnel.RadiusA, Tunnel.RadiusB, false, INDEX_NONE);
                    }
                    return Result;
                }

                if (InfluenceRadius > 0.0f
                    && VF_DistanceBetweenBoxes(
                        VoxelBox.Min, VoxelBox.Max, CenterlineMin, CenterlineMax)
                       > InfluenceRadius)
                {
                    return 0u;
                }
                if (BoundRadiusSq > 0.0f
                    && VF_DistanceBetweenBoxes(
                        VoxelBox.Min, VoxelBox.Max, BoundCenter, BoundCenter)
                       > FMath::Sqrt(BoundRadiusSq))
                {
                    return 0u;
                }
                return 3u;
            };

            const FVector NoWarpMin(BoxMinX, BoxMinY, EffectiveMinZ);
            const FVector NoWarpMax(BoxMaxX, BoxMaxY, EffectiveMaxZ);

            const uint64 ExactPrimitiveStartCycles = FPlatformTime::Cycles64();
            for (const FCachedRoom& Room : GetBoxCache().Rooms)
            {
                const float CullRadiusSq = Room.CullRadiusSq;
                if (!Finite((float)Room.Center.X) || !Finite((float)Room.Center.Y)
                    || !Finite((float)Room.Center.Z) || !Finite(CullRadiusSq)
                    || CullRadiusSq < 0.0f)
                {
                    bInvalidBound = true;
                    continue;
                }

                const float RoomRadius = FMath::Sqrt(CullRadiusSq);
                const float FastRoomLower = bUseExactLatticeWarp
                    ? ExactLatticeAabbPointDistance(Room.Center) - RoomRadius
                    : (bUseLatticeProof
                        ? LatticePointDistance(Room.Center, WarpEnvelope) - RoomRadius
                        : VF_DistanceBetweenBoxes(QMin, QMax, Room.Center, Room.Center) - RoomRadius);
                const float RoomLower = bUseExactLatticeWarp
                    && FastRoomLower < ThresholdWithBlend
                    ? (ExactRoomRefinements++, ExactRoomLower(Room)) : FastRoomLower;
                const float RoomLowerNoWarp = VF_DistanceBetweenBoxes(
                    NoWarpMin, NoWarpMax, Room.Center, Room.Center) - RoomRadius;
                Consider(RoomLower);
                if (bUseExactLatticeWarp) { ConsiderCheapExact(FastRoomLower, K); }
                if (bUseExactLatticeWarp) { ConsiderExact(RoomLower, K); }
                CountThreshold(RoomLower, B.HitRooms);
                CountThreshold(RoomLowerNoWarp, B.HitRoomsNoWarp);
            }

            // Room-floor joins are part of EvaluateSDFCached's same smooth-min union.  They were
            // absent from the old box proof, which could only lose skips; include them here so the
            // exact retry remains a proof of the complete source rather than just rooms/tunnels.
            for (const FCachedRoomFloorJoin& Join : GetBoxCache().RoomFloorJoins)
            {
                const float JoinRadius = FMath::Sqrt(FMath::Max(Join.BoundRadiusSq, 0.0f));
                const float FastJoinLower = bUseExactLatticeWarp
                    ? ExactLatticeAabbPointDistance(Join.BoundCenter) - JoinRadius
                    : VF_DistanceBetweenBoxes(
                        QMin, QMax, Join.BoundCenter, Join.BoundCenter) - JoinRadius;
                const float JoinLower = bUseExactLatticeWarp
                    && FastJoinLower < ThresholdWithBlend
                    ? (ExactJoinRefinements++, ExactJoinLower(Join)) : FastJoinLower;
                Consider(JoinLower);
                if (bUseExactLatticeWarp) { ConsiderCheapExact(FastJoinLower, K); }
                if (bUseExactLatticeWarp) { ConsiderExact(JoinLower, K); }
            }

            for (const FCachedTunnel& Tunnel : GetBoxCache().Tunnels)
            {
                const uint8 TailMask = MayHaveTunnelCoreTail(Tunnel);
                B.bMayHaveTunnelCoreAir = B.bMayHaveTunnelCoreAir
                    || (TailMask & 1u) != 0;
                B.bMayHaveTunnelCoreTail = B.bMayHaveTunnelCoreTail
                    || TailMask != 0u;
                float MaxRadius = FMath::Max(
                    FMath::Abs(Tunnel.RadiusA), FMath::Abs(Tunnel.RadiusB));
                float TunnelLower = FLT_MAX;
                if (bUseExactLatticeWarp)
                {
                    if (Tunnel.ControlPoints.Num() >= 2
                        && Tunnel.ControlRadii.Num() == Tunnel.ControlPoints.Num())
                    {
                        for (int32 SegmentIndex = 0;
                             SegmentIndex + 1 < Tunnel.ControlPoints.Num();
                             ++SegmentIndex)
                        {
                            const FVector& A = Tunnel.ControlPoints[SegmentIndex];
                            const FVector& BPoint = Tunnel.ControlPoints[SegmentIndex + 1];
                            MaxRadius = FMath::Max(
                                MaxRadius,
                                FMath::Max(FMath::Abs(Tunnel.ControlRadii[SegmentIndex]),
                                           FMath::Abs(Tunnel.ControlRadii[SegmentIndex + 1])));
                            const FVector SegmentMin(
                                FMath::Min(A.X, BPoint.X),
                                FMath::Min(A.Y, BPoint.Y),
                                FMath::Min(A.Z, BPoint.Z));
                            const FVector SegmentMax(
                                FMath::Max(A.X, BPoint.X),
                                FMath::Max(A.Y, BPoint.Y),
                                FMath::Max(A.Z, BPoint.Z));
                            TunnelLower = FMath::Min(
                                TunnelLower,
                                ExactLatticeAabbBoxDistance(SegmentMin, SegmentMax));
                        }
                    }
                    else if (Tunnel.bHasMidpoint)
                    {
                        const FVector SegmentMin(
                            FMath::Min3(Tunnel.EndpointA.X, Tunnel.Midpoint.X,
                                        Tunnel.EndpointB.X),
                            FMath::Min3(Tunnel.EndpointA.Y, Tunnel.Midpoint.Y,
                                        Tunnel.EndpointB.Y),
                            FMath::Min3(Tunnel.EndpointA.Z, Tunnel.Midpoint.Z,
                                        Tunnel.EndpointB.Z));
                        const FVector SegmentMax(
                            FMath::Max3(Tunnel.EndpointA.X, Tunnel.Midpoint.X,
                                        Tunnel.EndpointB.X),
                            FMath::Max3(Tunnel.EndpointA.Y, Tunnel.Midpoint.Y,
                                        Tunnel.EndpointB.Y),
                            FMath::Max3(Tunnel.EndpointA.Z, Tunnel.Midpoint.Z,
                                        Tunnel.EndpointB.Z));
                        MaxRadius = FMath::Max(
                            MaxRadius,
                            FMath::Max(FMath::Abs(Tunnel.RadiusMid),
                                       FMath::Max(FMath::Abs(Tunnel.RadiusA),
                                                  FMath::Abs(Tunnel.RadiusB))));
                        TunnelLower = ExactLatticeAabbBoxDistance(SegmentMin, SegmentMax);
                    }
                    else
                    {
                        const FVector SegmentMin(
                            FMath::Min(Tunnel.EndpointA.X, Tunnel.EndpointB.X),
                            FMath::Min(Tunnel.EndpointA.Y, Tunnel.EndpointB.Y),
                            FMath::Min(Tunnel.EndpointA.Z, Tunnel.EndpointB.Z));
                        const FVector SegmentMax(
                            FMath::Max(Tunnel.EndpointA.X, Tunnel.EndpointB.X),
                            FMath::Max(Tunnel.EndpointA.Y, Tunnel.EndpointB.Y),
                            FMath::Max(Tunnel.EndpointA.Z, Tunnel.EndpointB.Z));
                        TunnelLower = ExactLatticeAabbBoxDistance(SegmentMin, SegmentMax);
                    }
                    TunnelLower -= MaxRadius;
                    const float FastTunnelLower = TunnelLower;
                    if (TunnelLower < ThresholdWithBlend)
                    {
                        ++ExactTunnelRefinements;
                        TunnelLower = ExactTunnelLower(Tunnel);
                    }
                    if (bUseExactLatticeWarp)
                    {
                        ConsiderCheapExact(FastTunnelLower, K);
                    }
                }
                else if (Tunnel.ControlPoints.Num() >= 2
                    && Tunnel.ControlRadii.Num() == Tunnel.ControlPoints.Num())
                {
                    for (int32 SegmentIndex = 0;
                         SegmentIndex + 1 < Tunnel.ControlPoints.Num();
                         ++SegmentIndex)
                    {
                        const FVector& A = Tunnel.ControlPoints[SegmentIndex];
                        const FVector& BPoint = Tunnel.ControlPoints[SegmentIndex + 1];
                        MaxRadius = FMath::Max(
                            MaxRadius,
                            FMath::Max(FMath::Abs(Tunnel.ControlRadii[SegmentIndex]),
                                       FMath::Abs(Tunnel.ControlRadii[SegmentIndex + 1])));
                        const FVector SegmentMin(
                            FMath::Min(A.X, BPoint.X),
                            FMath::Min(A.Y, BPoint.Y),
                            FMath::Min(A.Z, BPoint.Z));
                        const FVector SegmentMax(
                            FMath::Max(A.X, BPoint.X),
                            FMath::Max(A.Y, BPoint.Y),
                            FMath::Max(A.Z, BPoint.Z));
                        TunnelLower = FMath::Min(
                            TunnelLower,
                            bUseLatticeProof
                                ? LatticeBoxDistance(SegmentMin, SegmentMax, WarpEnvelope)
                                : VF_DistanceBetweenBoxes(QMin, QMax, SegmentMin, SegmentMax));
                    }
                    TunnelLower -= MaxRadius;
                }
                else
                {
                    const FVector SegmentMin(
                        FMath::Min(Tunnel.EndpointA.X, Tunnel.EndpointB.X),
                        FMath::Min(Tunnel.EndpointA.Y, Tunnel.EndpointB.Y),
                        FMath::Min(Tunnel.EndpointA.Z, Tunnel.EndpointB.Z));
                    const FVector SegmentMax(
                        FMath::Max(Tunnel.EndpointA.X, Tunnel.EndpointB.X),
                        FMath::Max(Tunnel.EndpointA.Y, Tunnel.EndpointB.Y),
                        FMath::Max(Tunnel.EndpointA.Z, Tunnel.EndpointB.Z));
                    TunnelLower = (bUseLatticeProof
                        ? LatticeBoxDistance(SegmentMin, SegmentMax, WarpEnvelope)
                        : VF_DistanceBetweenBoxes(QMin, QMax, SegmentMin, SegmentMax)) - MaxRadius;
                }

                const FVector NoWarpSegmentMin(
                    FMath::Min(Tunnel.EndpointA.X, Tunnel.EndpointB.X),
                    FMath::Min(Tunnel.EndpointA.Y, Tunnel.EndpointB.Y),
                    FMath::Min(Tunnel.EndpointA.Z, Tunnel.EndpointB.Z));
                const FVector NoWarpSegmentMax(
                    FMath::Max(Tunnel.EndpointA.X, Tunnel.EndpointB.X),
                    FMath::Max(Tunnel.EndpointA.Y, Tunnel.EndpointB.Y),
                    FMath::Max(Tunnel.EndpointA.Z, Tunnel.EndpointB.Z));
                const float TunnelLowerNoWarp = VF_DistanceBetweenBoxes(
                    NoWarpMin, NoWarpMax, NoWarpSegmentMin, NoWarpSegmentMax)
                    - MaxRadius;
                Consider(TunnelLower);
                if (bUseExactLatticeWarp) { ConsiderExact(TunnelLower, K); }
                CountThreshold(TunnelLower, B.HitTunnels);
                CountThreshold(TunnelLowerNoWarp, B.HitTunnelsNoWarp);
            }

            // The pointwise air probe above is intentionally narrower than the final generator
            // tail: a tunnel can write a solid swept floor at lattice points where its core SDF
            // is not negative.  Use the morphology module's shared broad reach predicate for the
            // complete world-space core/floor envelope; it is the same bound used by the mesher's
            // post-reach decision and keeps this diagnostic conservative for both polarities.
            if (!B.bMayHaveTunnelCoreTail)
            {
                B.bMayHaveTunnelCoreTail =
                    VoxelCaveMorphology::AnyTunnelCoreWorldNearLattice(
                        GetBoxCache(), VoxelBox, 1.0f);
            }

            if (B.bMayHaveTunnelCoreAir
                && bUseLatticeProof
                && ExactLatticeWorldQueries.Num() > 0)
            {
                // The bound test above is only a broad candidate.  The actual post is a
                // continuous writer: it opens a point when the world-core SDF is negative. This
                // is still a proof of the final lattice, never a density shortcut; if an exact
                // query is invalid, keep the conservative candidate.
                bool bExactAir = false;
                bool bExactTailUnknown = false;
                TArray<FBox, TInlineAllocator<16>> ExactTailDomains;
                bool bExactTailDomainCullSafe = true;
                const uint64 ExactTailStartCycles = FPlatformTime::Cycles64();
                for (const FCachedTunnel& Tunnel : GetBoxCache().Tunnels)
                {
                    const bool bHasWorldChain = Tunnel.WorldControlPoints.Num() >= 2
                        && Tunnel.WorldControlRadii.Num() == Tunnel.WorldControlPoints.Num();
                    const FVector& CenterlineMin = bHasWorldChain
                        ? Tunnel.WorldCenterlineMin : Tunnel.SDFCenterlineMin;
                    const FVector& CenterlineMax = bHasWorldChain
                        ? Tunnel.WorldCenterlineMax : Tunnel.SDFCenterlineMax;
                    const float InfluenceRadius = bHasWorldChain
                        ? Tunnel.WorldInfluenceRadius : Tunnel.SDFInfluenceRadius;
                    // EvaluateTunnel's first cull is exactly the distance to this AABB.  Turning
                    // it into a point-in-expanded-box test lets the exact tail reject points
                    // before it builds a support column or scans every tunnel.  A disabled,
                    // inverted, or non-finite bound cannot authorize a reject: fall back to the
                    // existing fully conservative evaluator for the whole query set.
                    if (!Finite((float)CenterlineMin.X) || !Finite((float)CenterlineMin.Y)
                        || !Finite((float)CenterlineMin.Z) || !Finite((float)CenterlineMax.X)
                        || !Finite((float)CenterlineMax.Y) || !Finite((float)CenterlineMax.Z)
                        || CenterlineMin.X > CenterlineMax.X
                        || CenterlineMin.Y > CenterlineMax.Y
                        || CenterlineMin.Z > CenterlineMax.Z
                        || !Finite(InfluenceRadius) || InfluenceRadius <= 0.0f)
                    {
                        bExactTailDomainCullSafe = false;
                        break;
                    }
                    const FVector Radius(InfluenceRadius, InfluenceRadius, InfluenceRadius);
                    ExactTailDomains.Emplace(CenterlineMin - Radius, CenterlineMax + Radius);
                }
                ForEachExactQueryInWorldBox(
                    VoxelBox.Min, VoxelBox.Max,
                    [&](const FVector&, const FVector& World)
                {
                    if (bExactAir || bExactTailUnknown) return;
                    ++B.ExactTailQueries;
                    if (bExactTailDomainCullSafe && ExactTailDomains.Num() > 0)
                    {
                        bool bInsideTailDomain = false;
                        for (const FBox& Domain : ExactTailDomains)
                        {
                            if (World.X >= Domain.Min.X && World.X <= Domain.Max.X
                                && World.Y >= Domain.Min.Y && World.Y <= Domain.Max.Y
                                && World.Z >= Domain.Min.Z && World.Z <= Domain.Max.Z)
                            {
                                bInsideTailDomain = true;
                                break;
                            }
                        }
                        if (!bInsideTailDomain) return;
                    }

                    uint8* CachedTailState = nullptr;
                    if (B.bExactWarpedLatticeCacheValid
                        && B.ExactTailStates.Num() == B.ExactWarpedLatticeQueries.Num())
                    {
                        const int32 TailIX = FMath::RoundToInt(
                            (World.X - LatticeOriginX) / LatticeStepXY);
                        const int32 TailIY = FMath::RoundToInt(
                            (World.Y - LatticeOriginY) / LatticeStepXY);
                        const int32 TailIZ = FMath::RoundToInt(
                            (World.Z - static_cast<float>(Ctx.LatticeOriginVoxels.Z))
                            / static_cast<float>(Ctx.Step));
                        if (TailIX >= B.ExactWarpedLatticeIX0
                            && TailIX < B.ExactWarpedLatticeIX0 + B.ExactWarpedLatticeNX
                            && TailIY >= B.ExactWarpedLatticeIY0
                            && TailIY < B.ExactWarpedLatticeIY0 + B.ExactWarpedLatticeNY
                            && TailIZ >= B.ExactWarpedLatticeIZ0
                            && TailIZ < B.ExactWarpedLatticeIZ0 + B.ExactWarpedLatticeNZ)
                        {
                            const int32 TailIndex =
                                ((TailIZ - B.ExactWarpedLatticeIZ0)
                                    * B.ExactWarpedLatticeNY
                                 + (TailIY - B.ExactWarpedLatticeIY0))
                                    * B.ExactWarpedLatticeNX
                                + (TailIX - B.ExactWarpedLatticeIX0);
                            CachedTailState = &B.ExactTailStates[TailIndex];
                        }
                    }
                    if (CachedTailState != nullptr && (*CachedTailState & 0x80u) != 0)
                    {
                        const uint8 State = *CachedTailState;
                        if ((State & 0x04u) != 0)
                        {
                            bExactTailUnknown = true;
                        }
                        else
                        {
                            bExactAir |= (State & 0x01u) != 0;
                        }
                        return;
                    }

                    const FTunnelCoreWorldEvaluation Evaluation =
                        VoxelCaveMorphology::EvaluateTunnelCoreWorld(
                            static_cast<float>(World.X), static_cast<float>(World.Y),
                            static_cast<float>(World.Z), GetBoxCache(), nullptr,
                            VoxelGenLOD::ShouldUseSpatialIndex(false));
                    ++B.ExactTailEvaluated;
                    if (!VoxelMath::IsFinite(Evaluation.SDF))
                    {
                        bExactTailUnknown = true;
                        if (CachedTailState != nullptr) { *CachedTailState = 0x84u; }
                    }
                    else
                    {
                        const bool bAir = Evaluation.SDF < 0.0f;
                        bExactAir |= bAir;
                        if (CachedTailState != nullptr)
                        {
                            *CachedTailState = static_cast<uint8>(
                                0x80u
                                | (bAir ? 0x01u : 0u));
                        }
                    }
                        });
                B.ExactTailCycles = FPlatformTime::Cycles64() - ExactTailStartCycles;
                if (!bExactTailUnknown)
                {
                    B.bMayHaveTunnelCoreAir = bExactAir;
                    B.bMayHaveTunnelSupportFloor = false;
                    // Keep the broad geometric tail candidate even when the exact lattice has
                    // no core-air vertex.  The final generator tail writes both polarities:
                    // it reopens tunnel air, but it can also write a solid swept floor below an
                    // otherwise-air stack box.  Collapsing this flag to bExactAir erased the
                    // latter reach and let the classifier certify a false AllAir child.
                }
            }

            for (const FCachedPit& Pit : GetBoxCache().Pits)
            {
                if (!(BoxMinZ < Pit.TopZ + Pit.BlendK)
                    || !(BoxMaxZ >= Pit.TopZ - Pit.Depth - Pit.BlendK))
                {
                    continue;
                }
                const float MaxRadius = FMath::Abs(Pit.Radius) + FMath::Abs(Pit.FlareExtra);
                const float FastPitLower = bUseExactLatticeWarp
                    ? LatticeXYPointDistance(Pit.CenterX, Pit.CenterY) - MaxRadius
                    : (bUseLatticeProof
                        ? LatticeXYPointDistance(Pit.CenterX, Pit.CenterY)
                        : VF_DistanceBoxToPointXY(FBox(RMin, RMax), Pit.CenterX, Pit.CenterY)) - MaxRadius;
                const float PitLower = bUseExactLatticeWarp
                    && FastPitLower < ThresholdWithBlend
                    ? (ExactPitRefinements++, ExactPitLower(Pit)) : FastPitLower;
                Consider(PitLower);
                if (bUseExactLatticeWarp) { ConsiderCheapExact(FastPitLower, Pit.BlendK); }
                if (bUseExactLatticeWarp) { ConsiderExact(PitLower, Pit.BlendK); }
                CountThreshold(PitLower, B.HitPits);
            }

            for (const FCachedChimney& Chimney : GetBoxCache().Chimneys)
            {
                if (!(BoxMaxZ > Chimney.BottomZ - Chimney.BlendK)
                    || !(BoxMinZ <= Chimney.BottomZ + Chimney.Height + Chimney.BlendK))
                {
                    continue;
                }
                const float MaxRadius = FMath::Abs(Chimney.Radius) + FMath::Abs(Chimney.FlareExtra);
                const float FastChimneyLower = bUseExactLatticeWarp
                    ? LatticeXYPointDistance(Chimney.CenterX, Chimney.CenterY) - MaxRadius
                    : (bUseLatticeProof
                        ? LatticeXYPointDistance(Chimney.CenterX, Chimney.CenterY)
                        : VF_DistanceBoxToPointXY(FBox(RMin, RMax), Chimney.CenterX, Chimney.CenterY)) - MaxRadius;
                const float ChimneyLower = bUseExactLatticeWarp
                    && FastChimneyLower < ThresholdWithBlend
                    ? (ExactChimneyRefinements++, ExactChimneyLower(Chimney)) : FastChimneyLower;
                Consider(ChimneyLower);
                if (bUseExactLatticeWarp) { ConsiderCheapExact(FastChimneyLower, Chimney.BlendK); }
                if (bUseExactLatticeWarp) { ConsiderExact(ChimneyLower, Chimney.BlendK); }
                CountThreshold(ChimneyLower, B.HitChimneys);
            }
            B.ExactPrimitiveCycles = FPlatformTime::Cycles64() - ExactPrimitiveStartCycles;

            if (bInvalidBound)
            {
                Unknown();
                return;
            }

            FVoxelBoxSdfInterval Own;
            if (bUseExactLatticeWarp)
            {
                // Exact per-primitive scans are a tightening only.  Their candidate-domain
                // filters can miss a warped lattice query near a primitive, so retain the
                // broad lower bound over the AABB that contains every warped sample.  The
                // minimum stays useful when both agree and remains safe when an exact scan is
                // incomplete.
                Own.Set(FMath::Min(ExactSdfLower, CheapSdfLower), FLT_MAX);
            }
            else if (!bAnyPrimitive)
            {
                Own.Set(FLT_MAX, FLT_MAX);
            }
            else
            {
                Own.Set(VF_SaturatingAdd(Lower, -K), FLT_MAX);
            }

            B.SdfInterval = Own;
            B.Verdict = Own.IsKnown() && Own.Min >= WormThreshold
                       ? EVoxelOpEffect::Identity : EVoxelOpEffect::Both;
            B.KeyBox = VoxelBox;
            B.KeyStrate = StrateIdx;
            B.KeySeed = SeedU;
            B.KeyFingerprint = ParamsFingerprint;
            B.KeyLayout = LV;
            B.KeyManagerLifetimeId = ManagerLifetimeId;
            B.KeyUsesLatticeProof = bUseLatticeProof;
            B.KeyTightenWarpProof = Ctx.bTightenWarpProof;
            B.KeyLatticeOrigin = Ctx.LatticeOriginVoxels;
            B.KeyLatticeStep = Ctx.Step;
            B.bValid = true;
            InOut = Own;
            B.PropagateCycles = FPlatformTime::Cycles64() - PropagateStartCycles;
        }

        const TCHAR* DebugName() const override { return TEXT("RoomGraphSource"); }

        void EvalBlock(const FVoxelOpBlock& Block) const override
        {
            VF_EvalBlockByScalar(*this, Block);
        }

    private:
        FStrateGenerationParams P;
        int32  Seed;
        uint32 SeedU;
        TWeakObjectPtr<const UVoxelStrateManager> Manager;
        uint64 ManagerLifetimeId = 0;
        uint32 ParamsFingerprint;
        uint32 LayoutVersion = 0;
    };

    //=========================================================================
    // LE GATE DE BOÎTE DES MODIFICATEURS DE CAVE
    //=========================================================================
    // The source publishes an SDF interval; detail modifiers consume that interval here. This is
    // deliberately a state test, never a call to the source's EffectOverBox: the latter is the
    // source-only answer and must remain valid when the composer chooses a different consumer.
    FORCEINLINE bool VF_CaveBoxIsFar(const FVoxelBoxHypotheses& H, float SDFBlendRadius)
    {
        const float Threshold = SDFBlendRadius * 3.0f;
        return VoxelMath::IsFinite(Threshold) && H.Sdf.IsKnown() && H.Sdf.Min >= Threshold;
    }

    FORCEINLINE EVoxelOpEffect VF_CaveDetailEffect(const FRoomGraphSource* Rooms,
                                                   const FVoxelBoxHypotheses& H,
                                                   float SDFBlendRadius,
                                                   EVoxelOpEffect Intrinsic)
    {
        // A detail op with no room source has the same no-op guard as Eval. An unknown interval is
        // not a reason to claim Identity: uncertainty costs a skip, while a false skip is a hole.
        if (Rooms == nullptr || VF_CaveBoxIsFar(H, SDFBlendRadius))
        {
            return EVoxelOpEffect::Identity;
        }
        // A terrain op is allowed to replace the strate-level activation fields for the room that
        // Eval selects.  Its exact direction is not part of the generic cache proof, so preserve
        // safety with Both whenever one is present.  The common no-override TunnelNetwork path
        // gets the real intrinsic direction and finite amplitude below.
        return Rooms->HasRoomTerrainOverrideForLastBox()
             ? EVoxelOpEffect::Both : Intrinsic;
    }

    FORCEINLINE float VF_CaveDetailMax(const FRoomGraphSource* Rooms,
                                       const FVoxelBoxHypotheses& H,
                                       float SDFBlendRadius,
                                       float IntrinsicMax)
    {
        // Per-room overrides can activate or enlarge a modifier even when the strate-level
        // parameter is zero.  A valid cache with no override makes the strate-level supremum
        // exact for these modifiers; an unknown/overridden cache keeps the old safe default.
        if (Rooms == nullptr || VF_CaveBoxIsFar(H, SDFBlendRadius)) { return 0.0f; }
        if (Rooms->HasRoomTerrainOverrideForLastBox()) { return FLT_MAX; }
        return IntrinsicMax;
    }

    //=========================================================================
    // RÔLE 3 — MODIFIER : RUGOSITÉ DE PAROI, ESPACE DENSITÉ  (TunnelNetwork, STEP 4b)
    //=========================================================================
    // ⚠️ CE N'EST PAS `FSdfRoughnessMod`, ET C'EST LE PIÈGE QUE `OPSTACK-DECOMPOSITION §1` SIGNALE.
    // Les deux s'appellent « rugosité de surface » et lisent le même champ de params, mais :
    //
    //   • variante SDF (Maze / VerticalShafts / FloatingIslands) : `Sdf += bruit·SCALE·Force`.
    //     Brut, sans fade, sans clamp, fréquence codée en dur au site d'appel. Déplace la SURFACE.
    //   • variante DENSITÉ (ici) : DEUX jeux d'octaves (principal + fin ×3), warp de domaine
    //     optionnel, QUATRE types de bruit, un `Min(…, 0)` anti-remplissage, et un fade QUADRATIQUE
    //     par distance à la surface. Déplace la MATIÈRE, mise à l'échelle par le gradient local.
    //
    // Les fusionner sous un enum `Space` était la suggestion du §1 ; en les portant, ils n'ont
    // presque aucune ligne en commun (le clamp, le fade et le second jeu d'octaves n'ont pas
    // d'équivalent dans l'autre). Deux opérateurs, un nom partagé — comme `FGridColumnMod` et le
    // futur `FRoomColumnMod`, que le §1 sépare pour la même raison.
    //
    // ⚠️⚠️ CET OPÉRATEUR EST **HORS** DE L'OVERRIDE D'OP PAR SALLE, et ce n'est pas un oubli.
    // Dans l'original, le shadow `const FStrateGenerationParams& Params = LocalTerrainParams;` est
    // déclaré à l'INTÉRIEUR du bloc `if (bNearCaveSurface)` qui commence APRÈS l'étape 4b. La
    // rugosité lit donc les params de la STRATE, jamais ceux de la salle la plus proche. Onze
    // modificateurs sur douze lisent la copie par salle ; celui-ci non. À NE PAS « uniformiser »
    // à l'étape C1.
    //
    // This op reads STRATE params, not the per-room copy: the original's shadow is declared inside
    // the `if (bNearCaveSurface)` block that starts AFTER step 4b. Eleven of twelve modifiers read
    // the shadowed copy; this one does not.
    class FCaveRoughnessMod final : public IVoxelDensityOp
    {
    public:
        FCaveRoughnessMod(const FStrateGenerationParams& InP, int32 Seed)
            : P(InP), SeedU((uint32)Seed) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        const TCHAR* DebugName() const override { return TEXT("CaveRoughnessMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (!(P.SurfaceRoughness > 0.0f)) { return; }

            const float EffectiveZ = (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f)
                                   ? (WorldZ / P.VerticalScale) : WorldZ;

            const float RoughnessDepth  = P.SurfaceRoughness * 2.0f;
            const float DistFromSurface = FMath::Abs(CaveSDF);
            if (!(DistFromSurface < RoughnessDepth)) { return; }

            const float RF = P.RoughnessFrequency;

            // Keep both hot noise-coordinate chains in float. The old FVector round-trip only
            // preserved legacy rounding; output compatibility with that field is abandoned.
            FVector3f MainPos(
                WorldX * RF + VoxelHash::SeedOffset(SeedU, 11.3f),
                WorldY * RF + VoxelHash::SeedOffset(SeedU, 13.7f),
                EffectiveZ * RF + VoxelHash::SeedOffset(SeedU, 17.1f)
            );
            FVector3f FinePos(
                WorldX * RF * 3.0f + VoxelHash::SeedOffset(SeedU, 19.1f) + 2000.0f,
                WorldY * RF * 3.0f + VoxelHash::SeedOffset(SeedU, 23.7f) + 2500.0f,
                EffectiveZ * RF * 3.0f + VoxelHash::SeedOffset(SeedU, 29.3f) + 3000.0f
            );

            // WARP DE DOMAINE : le MÊME offset est ajouté aux DEUX positions (une seule
            // `FVector WarpOffset`, deux `+=`). Transcrit tel quel — appliquer deux warps
            // indépendants serait plus « propre » et donnerait un autre monde.
            if (P.DomainWarpStrength > 0.0f)
            {
                const float WF = P.DomainWarpFrequency;
                const float WS = P.DomainWarpStrength;
                float WarpX=0.0f,WarpY=0.0f,WarpZ=0.0f;
                VoxelNoise::Perlin3D_x3(
                    WorldX*WF+VoxelHash::SeedOffset(SeedU,5.2f),
                    WorldY*WF+VoxelHash::SeedOffset(SeedU,1.3f),
                    EffectiveZ*WF+VoxelHash::SeedOffset(SeedU,9.7f),
                    WorldX*WF+100.0f+VoxelHash::SeedOffset(SeedU,7.7f),
                    WorldY*WF+200.0f+VoxelHash::SeedOffset(SeedU,3.1f),
                    EffectiveZ*WF+300.0f,
                    WorldX*WF+400.0f,
                    WorldY*WF+500.0f+VoxelHash::SeedOffset(SeedU,11.9f),
                    EffectiveZ*WF+600.0f+VoxelHash::SeedOffset(SeedU,13.3f),
                    WarpX,WarpY,WarpZ);
                WarpX*=VOXEL_NOISE_SCALE*WS;
                WarpY*=VOXEL_NOISE_SCALE*WS;
                WarpZ*=VOXEL_NOISE_SCALE*WS;

                const FVector3f WarpOffset(WarpX, WarpY, WarpZ);
                MainPos += WarpOffset;
                FinePos += WarpOffset;
            }

            // Les comptes d'octaves passent par VoxelGenLOD::Eff — contrat T2.b, les tuiles
            // lointaines perdent les octaves sous-cellulaires.
            float RoughNoise, FineNoise;
            const int32 Oct3 = VoxelGenLOD::Eff(3);
            const int32 Oct2 = VoxelGenLOD::Eff(2);

            switch (P.RoughnessNoiseType)
            {
            case EVoxelNoiseType::Ridged:
            {
                float MainFBM=0.0f,MainRidged=0.0f,FineFBM=0.0f,FineRidged=0.0f;
                VoxelNoise::FractalPair<false,true>(MainPos.X,MainPos.Y,MainPos.Z,Oct3,
                    FinePos.X,FinePos.Y,FinePos.Z,Oct2,
                    MainFBM,MainRidged,FineFBM,FineRidged);
                RoughNoise=MainRidged;FineNoise=FineRidged;
                break;
            }

            case EVoxelNoiseType::Mixed:
            {
                float MainFBM=0.0f,MainRidged=0.0f,FineFBM=0.0f,FineRidged=0.0f;
                VoxelNoise::FractalPair<true,true>(MainPos.X,MainPos.Y,MainPos.Z,Oct3,
                    FinePos.X,FinePos.Y,FinePos.Z,Oct2,
                    MainFBM,MainRidged,FineFBM,FineRidged);
                RoughNoise = MainFBM * 0.5f + MainRidged * 0.5f;
                FineNoise = FineFBM * 0.5f + FineRidged * 0.5f;
                break;
            }

            case EVoxelNoiseType::Cellular:
                RoughNoise = VoxelNoise::Cellular3D(MainPos);
                FineNoise  = VoxelNoise::Cellular3D(FinePos);
                break;

            case EVoxelNoiseType::FBM:
            default:
            {
                float MainFBM=0.0f,MainRidged=0.0f,FineFBM=0.0f,FineRidged=0.0f;
                VoxelNoise::FractalPair<true,false>(MainPos.X,MainPos.Y,MainPos.Z,Oct3,
                    FinePos.X,FinePos.Y,FinePos.Z,Oct2,
                    MainFBM,MainRidged,FineFBM,FineRidged);
                RoughNoise=MainFBM;FineNoise=FineFBM;
                break;
            }
            }

            RoughNoise *= VOXEL_NOISE_SCALE;
            FineNoise  *= VOXEL_NOISE_SCALE;

            float TotalRough = RoughNoise * P.SurfaceRoughness
                             + FineNoise * P.SurfaceRoughness * 0.4f;

            // CLAMP ANTI-REMPLISSAGE : dans l'air certain (SDF < 0) la rugosité ne doit JAMAIS
            // rajouter du solide — sinon lucarnes, membranes, coutures aux jonctions et aux lèvres
            // de puits. Elle peut encore creuser plus loin dans la paroi.
            if (CaveSDF < 0.0f)
            {
                TotalRough = FMath::Min(TotalRough, 0.0f);
            }

            float SurfaceFade = 1.0f - (DistFromSurface / RoughnessDepth);
            SurfaceFade = SurfaceFade * SurfaceFade;   // quadratique : concentre près de la surface

            InOut.Density += TotalRough * SurfaceFade;
        }

        /**
         * `Both` : la rugosité peut pousser dans les deux sens (le clamp ne s'applique que dans
         * l'air certain). Conservatif et donc correct, mais coûteux — comme les vers, c'est un
         * opérateur dont l'AMPLITUDE est bornée alors que sa DIRECTION ne l'est pas :
         *   |TotalRough| ≤ 2.1 · SurfaceRoughness · VOXEL_NOISE_SCALE,  fade ∈ [0,1].
         * Deuxième client pour le pliage numérique de `OPSTACK-DECOMPOSITION §0.2`, noté au point
         * exact où la borne manque (le premier est `FWormFieldSource::MaxCarveAmplitude`).
         */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.SurfaceRoughness > 0.0f) ? EVoxelOpEffect::Both : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            const EVoxelOpEffect Intrinsic = EffectOverBox(VoxelBox, Ctx);
            if (Intrinsic == EVoxelOpEffect::Identity) { return Intrinsic; }
            return IsInactiveFromSdf(H) ? EVoxelOpEffect::Identity : Intrinsic;
        }

        /**
         * ✅ Borne consommée par le pliage numérique. `RoughNoise` et `FineNoise` respectent tous
         * `FBM` est couvert par la borne prouvée `VF_PerlinAbsBound = 1.5`, mis à l'échelle par
         * `VOXEL_NOISE_SCALE`.  `Ridged` is in [-1,1] after its square/fold, while the unclamped
         * cellular mapping needs its own finite envelope below.  The two octaves contribute
         * `|Rough| + 0.4·|Fine|`; the fade is in `[0,1]`.  The anti-fill clamp only reduces the
         * positive side, so the same envelope is valid in both directions.
         */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return MaxAmplitude(); }
        float MaxFillOverBox (const FBox&, const FVoxelOpContext&) const override { return MaxAmplitude(); }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            return IsInactiveFromSdf(H) ? 0.0f : MaxCarveOverBox(VoxelBox, Ctx);
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                             const FVoxelBoxHypotheses& H) const override
        {
            return IsInactiveFromSdf(H) ? 0.0f : MaxFillOverBox(VoxelBox, Ctx);
        }

        /** La borne d'amplitude, en unités de densité. */
        float MaxAmplitude() const
        {
            if (!(P.SurfaceRoughness > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.SurfaceRoughness)) { return FLT_MAX; }

            float NoiseBound = VF_PerlinAbsBound;
            switch (P.RoughnessNoiseType)
            {
            case EVoxelNoiseType::Ridged:
                NoiseBound = 1.0f;
                break;
            case EVoxelNoiseType::Mixed:
                NoiseBound = 0.5f * (VF_PerlinAbsBound + 1.0f);
                break;
            case EVoxelNoiseType::Cellular:
                NoiseBound = VF_CellularAbsBound;
                break;
            case EVoxelNoiseType::FBM:
            default:
                NoiseBound = VF_PerlinAbsBound;
                break;
            }

            const float Result = 1.4f * NoiseBound * P.SurfaceRoughness * VOXEL_NOISE_SCALE;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        bool IsInactiveFromSdf(const FVoxelBoxHypotheses& H) const
        {
            if (VF_CaveBoxIsFar(H, P.SDFBlendRadius)) { return true; }
            if (!(P.SurfaceRoughness > 0.0f) || !VoxelMath::IsFinite(P.SurfaceRoughness))
            {
                return P.SurfaceRoughness <= 0.0f;
            }
            const float RoughnessDepth = P.SurfaceRoughness * 2.0f;
            // Eval's second gate is abs(CaveSDF) < SurfaceRoughness*2.  A known positive
            // lower endpoint at or beyond that depth therefore proves the op is an identity even
            // when the broader shared near-surface gate (SDFBlendRadius*3) remains open.
            return VoxelMath::IsFinite(RoughnessDepth) && H.Sdf.IsKnown()
                && H.Sdf.Min >= RoughnessDepth;
        }

        FStrateGenerationParams P;
        uint32 SeedU;
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : TERRASSES / TERRACING  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // Un escalier lissé en Z : `Offset = staircase(Z) − Z` ajouté à la densité. Positif ⇒ marche
    // solide sur laquelle marcher, négatif ⇒ vide sous la marche du dessus.
    //
    // ⚠️ LE SEUL MODIFICATEUR QUI RE-INTERROGE LE CHAMP SDF. Le facteur d'orientation vient de deux
    // sondes en Z±1 : un SDF a un gradient ≈ unitaire, donc |dSDF/dZ| EST déjà la composante
    // verticale normalisée — proche de 1 = sol/plafond, proche de 0 = paroi. Sans ce facteur, les
    // terrasses posent des bourrelets horizontaux dans les puits verticaux.
    //
    // C'est pour cette re-interrogation que `FRoomGraphSource` expose `ProbeSdfUnwarped` (et donc
    // que son cache est sorti de `Eval`) : le refaire ici voudrait dire un second cache SDF.
    class FCaveTerraceMod final : public IVoxelDensityOp
    {
    public:
        FCaveTerraceMod(const FStrateGenerationParams& InP, int32 Seed, const FRoomGraphSource* InRooms)
            : P(InP), SeedU((uint32)Seed), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("CaveTerraceMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }

            // `&& CaveSDF < FLT_MAX` est redondant sous le gate (qui le teste déjà) mais l'original
            // l'écrit, et une transcription littérale ne fait pas le tri.
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.TerraceStepHeight > 0.0f && CaveSDF < FLT_MAX)) { return; }

            const float StepH = LP.TerraceStepHeight;
            const float DistFromSurface = FMath::Abs(CaveSDF);
            const float TerraceRange = StepH * 3.0f;
            if (!(DistFromSurface < TerraceRange)) { return; }

            // Deux évaluations SDF de plus par voxel, seulement près d'une surface. Approximation
            // en Z seul : le gradient complet à 6 échantillons coûtait 3× pour le même signal.
            const float SDF_Zp1 = Rooms->ProbeSdfUnwarped(WorldX, WorldY, WorldZ + 1.0f);
            const float SDF_Zm1 = Rooms->ProbeSdfUnwarped(WorldX, WorldY, WorldZ - 1.0f);
            const float GZ = (SDF_Zp1 - SDF_Zm1) * 0.5f;
            const float SurfaceHorizontality = FMath::Clamp(FMath::Abs(GZ), 0.0f, 1.0f);
            const float TerraceOrientFactor = FMath::Clamp((SurfaceHorizontality - 0.3f) / 0.4f, 0.0f, 1.0f);

            // ⚠️ Z BRUT, PAS `EffectiveZ` : les terrasses sont géologiques, elles restent
            // horizontales quelle que soit l'échelle verticale de la strate. Idem pour les lignes de
            // strates et les nervures plus bas. La rugosité (4b), elle, utilise EffectiveZ. C'est
            // délibéré dans l'original et ça se lit dans son commentaire d'en-tête du STEP 3.
            float NoisedZ = WorldZ;
            if (LP.TerraceNoiseDisplacement > 0.0f)
            {
                const float DispNoise = HFractal3D(FVector3f(
                    WorldX * 0.04f + VoxelHash::SeedOffset(SeedU, 31.1f),
                    WorldY * 0.04f + VoxelHash::SeedOffset(SeedU, 37.3f),
                    WorldZ * 0.02f + VoxelHash::SeedOffset(SeedU, 41.7f)
                ), VoxelGenLOD::Eff(2)) * VOXEL_NOISE_SCALE;
                NoisedZ += DispNoise * LP.TerraceNoiseDisplacement * StepH;
            }

            const float K = NoisedZ / StepH;
            const float FloorK = FMath::FloorToFloat(K);
            const float Frac = K - FloorK;   // toujours [0, 1)

            const float Edge = FMath::Lerp(0.45f, 0.02f, LP.TerraceHardness);
            float StairValue;
            if (Frac < 0.5f - Edge)
            {
                StairValue = 0.0f;
            }
            else if (Frac > 0.5f + Edge)
            {
                StairValue = 1.0f;
            }
            else
            {
                const float T = (Frac - (0.5f - Edge)) / (2.0f * Edge);
                StairValue = SmoothStep01(T);
            }

            const float TerracedZ = (FloorK + StairValue) * StepH;
            const float Offset = TerracedZ - NoisedZ;   // ≈ [-StepH/2, +StepH/2]

            float Fade = 1.0f - (DistFromSurface / TerraceRange);
            Fade = Fade * Fade;

            InOut.Density += Offset * Fade * TerraceOrientFactor;
        }

        /** `Both` : `Offset` change de signe d'une demi-marche à l'autre. Amplitude bornée par
         *  `StepH/2` — troisième client du pliage numérique de `OPSTACK-DECOMPOSITION §0.2`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.TerraceStepHeight > 0.0f) ? EVoxelOpEffect::Both : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxCarveOverBox(VoxelBox, Ctx));
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                             const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxFillOverBox(VoxelBox, Ctx));
        }

        /**
         * `TerracedZ` is one staircase step below or above `NoisedZ`; the modulo phase is in
         * [0,1], so the safe supremum of `abs(TerracedZ - NoisedZ)` is one full step, not StepH/2.
         * The noise displacement changes which phase is selected but cannot enlarge that interval.
         */
        float MaxAmplitude() const
        {
            return (P.TerraceStepHeight > 0.0f
                    && VoxelMath::IsFinite(P.TerraceStepHeight)
                    && VoxelMath::IsFinite(P.TerraceHardness)
                    && P.TerraceHardness >= 0.0f && P.TerraceHardness <= 1.0f)
                 ? P.TerraceStepHeight : (P.TerraceStepHeight > 0.0f ? FLT_MAX : 0.0f);
        }

    private:
        FStrateGenerationParams P;
        uint32 SeedU;
        const FRoomGraphSource* Rooms;   // NON possédant : la pile possède la source
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : LIGNES DE STRATES / LAYER LINES  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // Rainures horizontales dans les parois — la strate sédimentaire vue en coupe. Une sinusoïde en
    // Z, rectifiée puis CUBÉE : les bosses larges du sinus deviennent des pointes fines, donc des
    // rainures étroites au lieu d'une ondulation.
    class FLayerLineMod final : public IVoxelDensityOp
    {
    public:
        FLayerLineMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("LayerLineMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float, float, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.LayerLineSpacing > 0.0f && CaveSDF < FLT_MAX)) { return; }

            const float DistFromSurface = FMath::Abs(CaveSDF);
            const float LineRange = LP.LayerLineSpacing * 1.5f;
            if (!(DistFromSurface < LineRange)) { return; }

            const float LinePhase = WorldZ * (2.0f * PI) / LP.LayerLineSpacing;
            float LineValue = VoxelMath::DetSin(LinePhase);

            LineValue = FMath::Max(LineValue, 0.0f);
            LineValue = LineValue * LineValue * LineValue;   // affûtage cubique

            float Fade = 1.0f - (DistFromSurface / LineRange);
            Fade = Fade * Fade;

            InOut.Density -= LineValue * LP.LayerLineDepth * Fade;
        }

        /** Ne SOUSTRAIT que (`LineValue ≥ 0`, `Depth ≥ 0`) ⇒ `CarveOnly`, jamais `Both`. Un des
         *  rares modificateurs de détail qui garde une DIRECTION exploitable par le pliage. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.LayerLineSpacing > 0.0f && P.LayerLineDepth > 0.0f)
                 ? EVoxelOpEffect::CarveOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        /** `LineValue = max(sin,0)³ ∈ [0,1]`, `Fade ∈ [0,1]` ⇒ retrait ≤ `LayerLineDepth`.
         *  ⚠️ Borne calculée sur les params de la STRATE : un op `LayerLines` par salle peut écrire
         *  une profondeur PLUS GRANDE, ce qui rendrait cette borne fausse dans le sens dangereux.
         *  C'est la même dette que la note d'`EffectOverBox` juste au-dessus, et elle doit être
         *  réglée par le même correctif — AVANT que `ClassifyTile` ne consomme `ClassifyBox`. */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius, MaxAmplitude());
        }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses&) const override { return 0.0f; }

        float MaxAmplitude() const
        {
            if (!(P.LayerLineSpacing > 0.0f)) { return 0.0f; }
            return VoxelMath::IsFinite(P.LayerLineDepth)
                 ? FMath::Max(P.LayerLineDepth, 0.0f) : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : NERVURES / RIBBING  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // La MÊME sinusoïde en Z que les lignes de strates, décalée d'un quart de période
    // (`+ PI · 0.5`), rectifiée puis CARRÉE au lieu de cubée, et AJOUTÉE au lieu d'être soustraite :
    // des bourrelets arrondis (tube de lave) au lieu de rainures fines.
    //
    // ⚠️ Deux opérateurs, pas un avec un signe : l'exposant diffère (3 contre 2), la phase diffère,
    // et le paramètre d'espacement est indépendant. Les fusionner demanderait trois paramètres pour
    // économiser dix lignes, et rendrait la correspondance avec l'original illisible.
    class FRibbingMod final : public IVoxelDensityOp
    {
    public:
        FRibbingMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("RibbingMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float, float, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.RibbingSpacing > 0.0f && CaveSDF < FLT_MAX)) { return; }

            const float DistFromSurface = FMath::Abs(CaveSDF);
            const float RibRange = LP.RibbingSpacing * 1.5f;
            if (!(DistFromSurface < RibRange)) { return; }

            const float RibPhase = WorldZ * (2.0f * PI) / LP.RibbingSpacing + PI * 0.5f;
            float RibValue = VoxelMath::DetSin(RibPhase);

            RibValue = FMath::Max(RibValue, 0.0f);
            RibValue = RibValue * RibValue;   // profil de bosse arrondi

            float Fade = 1.0f - (DistFromSurface / RibRange);
            Fade = Fade * Fade;

            InOut.Density += RibValue * LP.RibbingDepth * Fade;
        }

        /** N'AJOUTE que du solide ⇒ `FillOnly`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.RibbingSpacing > 0.0f && P.RibbingDepth > 0.0f)
                 ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        /** `RibValue = max(sin,0)² ∈ [0,1]`, `Fade ∈ [0,1]` ⇒ ajout ≤ `RibbingDepth`.
         *  Même réserve « params de strate » que `FLayerLineMod::MaxCarveOverBox`. */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses&) const override { return 0.0f; }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius, MaxAmplitude());
        }

        float MaxAmplitude() const
        {
            if (!(P.RibbingSpacing > 0.0f)) { return 0.0f; }
            return VoxelMath::IsFinite(P.RibbingDepth)
                 ? FMath::Max(P.RibbingDepth, 0.0f) : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : SURPLOMBS DE GROTTE / CAVE OVERHANGS  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // ⚠️ TROISIÈME OPÉRATEUR NOMMÉ « OVERHANG » DANS CE FICHIER, et ils n'ont rien en commun :
    //   • `FOverhangShelfMod` (SurfaceWorld) emprunte la hauteur de terrain amont — géométrique ;
    //   • celui-ci est un bruit fBM à FRÉQUENCE EN Z RÉDUITE (×0.15), dont on ne garde que le lobe
    //     POSITIF : la roche ne s'étend que VERS la grotte, jamais en creux. D'où des étagères
    //     éparses au lieu d'un déplacement uniforme.
    // Même nom dans l'éditeur, deux idées différentes. `OPSTACK-DECOMPOSITION §1` les sépare déjà.
    class FCaveOverhangMod final : public IVoxelDensityOp
    {
    public:
        FCaveOverhangMod(const FStrateGenerationParams& InP, int32 Seed, const FRoomGraphSource* InRooms)
            : P(InP), SeedU((uint32)Seed), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("CaveOverhangMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.OverhangStrength > 0.0f && CaveSDF < FLT_MAX)) { return; }

            const float DistFromSurface = FMath::Abs(CaveSDF);
            const float OverhangRange = LP.OverhangDepth * 2.0f;
            if (!(DistFromSurface < OverhangRange)) { return; }

            const float EffectiveZ = (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f)
                                   ? (WorldZ / P.VerticalScale) : WorldZ;

            // Fréquence en Z à 0.15× celle de XY ⇒ les motifs s'étirent horizontalement.
            const float OverhangNoise = HFractal3D(FVector3f(
                WorldX * LP.OverhangFrequency + VoxelHash::SeedOffset(SeedU, 53.1f),
                WorldY * LP.OverhangFrequency + VoxelHash::SeedOffset(SeedU, 59.3f),
                EffectiveZ * LP.OverhangFrequency * 0.15f + VoxelHash::SeedOffset(SeedU, 61.7f)
            ), VoxelGenLOD::Eff(2)) * VOXEL_NOISE_SCALE;

            if (OverhangNoise > 0.0f)
            {
                float Fade = 1.0f - (DistFromSurface / OverhangRange);
                Fade = Fade * Fade;

                InOut.Density += OverhangNoise * LP.OverhangDepth * LP.OverhangStrength * Fade;
            }
        }

        /** Lobe positif seulement ⇒ n'AJOUTE que du solide ⇒ `FillOnly`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.OverhangStrength > 0.0f && P.OverhangDepth > 0.0f)
                 ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        /** fBM ∈ [-1,1] × `VOXEL_NOISE_SCALE`, lobe positif seulement, `Fade ∈ [0,1]` ⇒ ajout
         *  ≤ `SCALE · Depth · Strength`. Même réserve « params de strate ». */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses&) const override { return 0.0f; }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius, MaxAmplitude());
        }

        float MaxAmplitude() const
        {
            if (!(P.OverhangStrength > 0.0f && P.OverhangDepth > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.OverhangDepth)
                || !VoxelMath::IsFinite(P.OverhangStrength))
            {
                return FLT_MAX;
            }
            const float Result = VOXEL_NOISE_SCALE * VF_PerlinAbsBound
                 * P.OverhangDepth * P.OverhangStrength;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        uint32 SeedU;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : AFFÛTAGE DE FALAISE / CLIFF SHARPENING  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // ⚠️ TRANSCRIT TEL QUEL BIEN QUE LE COMMENTAIRE DE L'ORIGINAL DÉCRIVE AUTRE CHOSE.
    // Il annonce « échantillonner la densité en Z±1 et calculer le gradient vertical » ; le code, lui,
    // n'échantillonne RIEN : il tire un Perlin dont la fréquence en Z est 3× celle de XY et l'appelle
    // `VertGrad`. C'est un PROXY de gradient, pas un gradient — donc l'effet est décorrélé de la
    // pente réelle de la paroi. Le multiplier par `CaveSDF` lui donne quand même le bon SIGNE de part
    // et d'autre de la surface (plus solide côté roche, plus creusé côté air), ce qui suffit à
    // produire des faces plus raides.
    //
    // Corriger l'écart changerait le monde ; le taire le laisserait se faire « corriger » un jour par
    // quelqu'un qui lit le commentaire et pas le code. Noté ici ET dans OPSTACK-PROGRESS.
    //
    // Ported as written, not as commented: the original's comment promises a sampled vertical
    // gradient, the code uses a Z-stretched Perlin as a proxy. Fixing it would change the world.
    class FCaveCliffMod final : public IVoxelDensityOp
    {
    public:
        FCaveCliffMod(const FStrateGenerationParams& InP, int32 Seed, const FRoomGraphSource* InRooms)
            : P(InP), SeedU((uint32)Seed), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("CaveCliffMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.CliffStrength > 0.0f && CaveSDF < FLT_MAX)) { return; }

            const float DistFromSurface = FMath::Abs(CaveSDF);
            const float CliffRange = 8.0f;   // constante en dur dans l'original
            if (!(DistFromSurface < CliffRange)) { return; }

            const float EffectiveZ = (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f)
                                   ? (WorldZ / P.VerticalScale) : WorldZ;

            const float VertGrad = VoxelNoise::Perlin3D(FVector3f(
                WorldX * 0.05f + VoxelHash::SeedOffset(SeedU, 71.3f),
                WorldY * 0.05f + VoxelHash::SeedOffset(SeedU, 73.7f),
                EffectiveZ * 0.15f + VoxelHash::SeedOffset(SeedU, 79.1f)   // 3× plus vite en Z
            )) * VOXEL_NOISE_SCALE;

            const float CliffEffect = VertGrad * CaveSDF * LP.CliffStrength;

            if (FMath::Abs(VertGrad) > 0.3f)
            {
                float Fade = 1.0f - (DistFromSurface / CliffRange);
                Fade = Fade * Fade;
                InOut.Density += CliffEffect * Fade * 3.0f;
            }
        }

        /** `Both` : le signe suit celui de `VertGrad · CaveSDF`, donc les deux directions. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.CliffStrength > 0.0f) ? EVoxelOpEffect::Both : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        /** `|VertGrad| ≤ SCALE·1.5`, `|CaveSDF| < 8`, `Fade ≤ 1`, final multiplier `3`. */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxCarveOverBox(VoxelBox, Ctx));
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                             const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxFillOverBox(VoxelBox, Ctx));
        }

        float MaxAmplitude() const
        {
            if (!(P.CliffStrength > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.CliffStrength)) { return FLT_MAX; }
            const float Result = 8.0f * 3.0f * VOXEL_NOISE_SCALE
                               * VF_PerlinAbsBound * P.CliffStrength;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        uint32 SeedU;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : FESTONS / SCALLOP  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // Cuvettes concaves d'érosion hydraulique. Bruit cellulaire : la valeur est haute AU CENTRE
    // d'une cellule (loin des points-features), donc on y creuse — d'où des rangées de coupelles
    // lisses, la signature des grottes calcaires.
    //
    // Deuxième client de `VoxelNoise::Cellular3D` (le premier est la rugosité en mode Cellular) —
    // c'est-à-dire la deuxième raison pour laquelle ce corps devait être PARTAGÉ et non recopié.
    class FScallopMod final : public IVoxelDensityOp
    {
    public:
        FScallopMod(const FStrateGenerationParams& InP, int32 Seed, const FRoomGraphSource* InRooms)
            : P(InP), SeedU((uint32)Seed), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("ScallopMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.ScallopStrength > 0.0f && CaveSDF < FLT_MAX)) { return; }

            const float DistFromSurface = FMath::Abs(CaveSDF);
            const float ScallopRange = LP.ScallopStrength * 4.0f;
            if (!(DistFromSurface < ScallopRange)) { return; }

            const float EffectiveZ = (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f)
                                   ? (WorldZ / P.VerticalScale) : WorldZ;

            const float SF = LP.ScallopFrequency;
            const float ScallopNoise = VoxelNoise::Cellular3D(FVector3f(
                WorldX * SF + VoxelHash::SeedOffset(SeedU, 83.1f),
                WorldY * SF + VoxelHash::SeedOffset(SeedU, 89.3f),
                EffectiveZ * SF + VoxelHash::SeedOffset(SeedU, 97.7f)
            ));

            if (ScallopNoise > 0.0f)
            {
                float Fade = 1.0f - (DistFromSurface / ScallopRange);
                Fade = Fade * Fade;

                InOut.Density -= ScallopNoise * LP.ScallopStrength * Fade;
            }
        }

        /** Lobe positif seulement, SOUSTRAIT ⇒ `CarveOnly`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.ScallopStrength > 0.0f) ? EVoxelOpEffect::CarveOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        /** The implementation maps an unclamped F2-F1 distance to `2*d-1`; the proven finite
         *  envelope used here is `VF_CellularAbsBound`, not the approximate [-1,1] comment beside
         *  the noise function.  The positive lobe and `Fade ∈ [0,1]` then bound the carve. */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius, MaxAmplitude());
        }
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses&) const override { return 0.0f; }

        float MaxAmplitude() const
        {
            if (!(P.ScallopStrength > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.ScallopStrength)) { return FLT_MAX; }
            const float Result = VF_CellularAbsBound * P.ScallopStrength;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        uint32 SeedU;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : ARCHES / PONTS DE ROCHE  (TunnelNetwork, STEP 4c)
    //=========================================================================
    // ⚠️ PREMIER MODIFICATEUR RELATIF À LA SALLE. Il ne lit pas seulement `InOut.Sdf` : il lui faut
    // LA SALLE — son hash (pour tirer les arches de façon déterministe), son centre et ses rayons.
    // C'est l'unique consommateur de `NearestRoomIdx` avec les dômes, le pincement et le biais de
    // sol, et c'est ce qui rend `FRoomGraphSource::GetNearestRoomIdx()` nécessaire.
    //
    // ⚠️ SA PORTE N'EST PAS LE GATE COMMUN : `CaveSDF < SDFBlendRadius` (dans la grotte ou tout
    // près), pas `< SDFBlendRadius·3`. Une arche se pose dans le VIDE de la salle, pas dans sa paroi.
    class FCaveArchMod final : public IVoxelDensityOp
    {
    public:
        FCaveArchMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("CaveArchMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }

            const int32 NearestRoomIdx = Rooms->GetNearestRoomIdx();
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.ArchDensity > 0.0f && CaveSDF < LP.SDFBlendRadius && CaveSDF < FLT_MAX
                  && NearestRoomIdx >= 0))
            {
                return;
            }

            // ⚠️ `IsValidIndex` AJOUTÉ : l'original indexe directement après le seul test `>= 0`.
            // L'index vient d'`EvaluateSDFCached` donc il est valide par construction — ce garde-fou
            // ne peut donc JAMAIS changer la sortie, seulement empêcher un crash si l'invariant se
            // cassait un jour. Même famille de décision que l'empreinte de params dans la clé de
            // cache : on se trompe du côté du coût, jamais du côté du résultat.
            const FChunkSDFCache& Cache = Rooms->GetCache();
            if (!Cache.Rooms.IsValidIndex(NearestRoomIdx)) { return; }
            const FCachedRoom& Room = Cache.Rooms[NearestRoomIdx];

            const FVector VoxPos(WorldX, WorldY, WorldZ);

            for (int32 i = 0; i < 3; i++)
            {
                const FCachedArch& Arch = Room.Arches[i];
                if (!Arch.bActive) { continue; }
                const float ArchSDF = VoxelSDF::Capsule(
                    VoxPos, Arch.EndpointA, Arch.EndpointB, Arch.Radius);

                const float ArchBlend = 2.0f;
                if (ArchSDF < ArchBlend)
                {
                    float Fill = FMath::Clamp((ArchBlend - ArchSDF) / (ArchBlend * 2.0f), 0.0f, 1.0f);
                    Fill = SmoothStep01(Fill);
                    InOut.Density += Fill * Arch.BaseDensity * 1.5f;
                }
            }
        }

        /** N'AJOUTE que du solide ⇒ `FillOnly`. La décision spatiale est indépendante : elle
         *  consomme l'intervalle SDF publié par la source, comme les autres détails de salle. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            if (!(P.ArchDensity > 0.0f)) { return EVoxelOpEffect::Identity; }
            if (P.BaseDensity > 0.0f) { return EVoxelOpEffect::FillOnly; }
            if (P.BaseDensity < 0.0f) { return EVoxelOpEffect::CarveOnly; }
            return EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return P.BaseDensity < 0.0f ? MaxAmplitude() : 0.0f;
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return P.BaseDensity > 0.0f ? MaxAmplitude() : 0.0f;
        }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxCarveOverBox(VoxelBox, Ctx));
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                             const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxFillOverBox(VoxelBox, Ctx));
        }

        float MaxAmplitude() const
        {
            if (!(P.ArchDensity > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.BaseDensity)) { return FLT_MAX; }
            const float Result = FMath::Abs(P.BaseDensity) * 3.0f * 1.5f;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : COLONNES DE SALLE / ROOM COLUMNS  (TunnelNetwork, STEP 4d)
    //=========================================================================
    // ⚠️ CE N'EST PAS `FGridColumnMod` (FlatPlain / CrystalChamber). Celui-là pose des cylindres sur
    // une GRILLE MONDE et se tire par cellule ; celui-ci PARCOURT une liste PRÉ-CUITE par
    // `BuildChunkCache`, salle par salle. `OPSTACK-DECOMPOSITION §1` les sépare explicitement.
    //
    // ⚠️⚠️ IL N'A **AUCUN** PARAMÈTRE DE STRATE, ET C'EST LE PIÈGE DE CE GROUPE.
    // Le code d'origine n'écrit aucun `if (Params.ColumnDensity > 0)` : il itère la liste cuite,
    // point. `FStrateGenerationParams::ColumnDensity` n'est JAMAIS lu par la cuisson non plus (elle
    // lit `OpParams`, un struct NEUF où seul l'op de la salle a été appliqué). Donc :
    //   • mettre `ColumnDensity = 0` dans les params N'ÉTEINT PAS les colonnes ;
    //   • la seule façon d'avoir des colonnes est un `UVoxelTerrainOpDefinition` de type `Column`
    //     dans le pool de la strate ;
    //   • et la seule façon de PROUVER qu'elles ont tiré est de regarder `SDFCache.Columns.Num()`.
    // C'est exactement la leçon des pits, une troisième fois. Le test l'applique au contrôle 3b.
    class FRoomColumnMod final : public IVoxelDensityOp
    {
    public:
        FRoomColumnMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("RoomColumnMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float, FVoxelOpSample& InOut) const override
        {
            if (!VF_NearCaveSurface(InOut.Sdf, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }

            auto EvaluateColumn = [&](int32 ColumnIndex)
            {
                const FCachedColumn& Col = Rooms->GetCache().Columns[ColumnIndex];
                const float DX = WorldX - Col.CenterX;
                const float DY = WorldY - Col.CenterY;
                const float XYDistSq = DX * DX + DY * DY;
                if (XYDistSq > Col.BoundXYRadiusSq) { return; }

                const float CylSDF = FMath::Sqrt(XYDistSq) - Col.Radius;

                const float ColBlend = 3.0f;
                if (CylSDF < ColBlend)
                {
                    float Fill = FMath::Clamp((ColBlend - CylSDF) / (ColBlend * 2.0f), 0.0f, 1.0f);
                    Fill = SmoothStep01(Fill);
                    InOut.Density += Fill * Col.BaseDensity * 1.5f;
                }
            };
            VF_ForEachChunkSDFSpatialCandidate(
                Rooms->GetCache().ColumnSpatialIndex,
                Rooms->GetCache().Columns.Num(), WorldX, WorldY, EvaluateColumn,
                VoxelGenLOD::ShouldUseSpatialIndex(false));
        }

        /** The cached column list is the complete source of this op's work.  A valid empty list is
         *  therefore an exact Identity result; an invalid box cache stays conservative. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::FillOnly;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            if (Rooms == nullptr || VF_CaveBoxIsFar(H, P.SDFBlendRadius))
            {
                return EVoxelOpEffect::Identity;
            }
            const float Bound = Rooms->RoomColumnFillSupremumForLastBox();
            if (!(Bound > 0.0f)) { return EVoxelOpEffect::Identity; }
            return VoxelMath::IsFinite(Bound) ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Both;
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return FLT_MAX;
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses& H) const override
        {
            if (Rooms == nullptr || VF_CaveBoxIsFar(H, P.SDFBlendRadius)) { return 0.0f; }
            const float Bound = Rooms->RoomColumnFillSupremumForLastBox();
            return VoxelMath::IsFinite(Bound) ? 0.0f : Bound;
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses& H) const override
        {
            if (Rooms == nullptr || VF_CaveBoxIsFar(H, P.SDFBlendRadius)) { return 0.0f; }
            return Rooms->RoomColumnFillSupremumForLastBox();
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : DÔMES / CATHEDRAL CEILINGS  (TunnelNetwork, STEP 4g)
    //=========================================================================
    // Un demi-ellipsoïde creusé VERS LE HAUT depuis un point ancré au-dessus du centre de la salle.
    // Relatif à la salle comme les arches, même porte `CaveSDF < SDFBlendRadius`.
    class FDomeMod final : public IVoxelDensityOp
    {
    public:
        FDomeMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("DomeMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }

            const int32 NearestRoomIdx = Rooms->GetNearestRoomIdx();
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.DomeDensity > 0.0f && CaveSDF < LP.SDFBlendRadius && CaveSDF < FLT_MAX
                  && NearestRoomIdx >= 0))
            {
                return;
            }

            const FChunkSDFCache& Cache = Rooms->GetCache();
            if (!Cache.Rooms.IsValidIndex(NearestRoomIdx)) { return; }   // cf. FCaveArchMod
            const FCachedRoom& Room = Cache.Rooms[NearestRoomIdx];

            const int32 MaxDomes = 2;

            for (int32 i = 0; i < MaxDomes; i++)
            {
                const uint32 DH = VoxelHash::Mix(Room.Hash ^ (0xD0AE0u + (uint32)i * 8191u));

                if (VoxelHash::ToFloat01(DH) > LP.DomeDensity) { continue; }

                const uint32 DH2 = VoxelHash::Mix(DH ^ 0xD0A0u);
                const float DmX = Room.Center.X + VoxelHash::ToFloatSigned(DH2) * Room.RadiusXY * 0.4f;
                const float DmY = Room.Center.Y
                                + VoxelHash::ToFloatSigned(VoxelHash::Mix(DH2)) * Room.RadiusXY * 0.4f;

                const uint32 DH3 = VoxelHash::Mix(DH2 ^ 0x90DEu);
                const float DmRadius = FMath::Min(
                    FMath::Lerp(LP.DomeMinRadius, LP.DomeMaxRadius, VoxelHash::ToFloat01(DH3)),
                    Room.RadiusXY * 0.85f
                );

                const uint32 DH4 = VoxelHash::Mix(DH3 ^ 0xCAFEu);
                const float DmCenterZ = Room.Center.Z + Room.RadiusZ * 0.2f
                                      + VoxelHash::ToFloat01(DH4) * Room.RadiusZ * 0.3f;

                const float DmHeight = DmRadius * LP.DomeHeightRatio;

                if (WorldZ > DmCenterZ + DmHeight + 3.0f || WorldZ < DmCenterZ - 3.0f) { continue; }

                const float DXDm = WorldX - DmX;
                const float DYDm = WorldY - DmY;
                const float DZDm = WorldZ - DmCenterZ;

                if (DZDm < 0.0f) { continue; }   // ne creuse que vers le haut

                const float NormX = DXDm / DmRadius;
                const float NormY = DYDm / DmRadius;
                const float NormZ = DZDm / DmHeight;
                const float EllipDist = FMath::Sqrt(NormX * NormX + NormY * NormY + NormZ * NormZ) - 1.0f;
                const float DomeSDF = EllipDist * FMath::Min(DmRadius, DmHeight);

                const float DmBlend = 3.0f;
                if (DomeSDF < DmBlend)
                {
                    float Carve = FMath::Clamp((DmBlend - DomeSDF) / (DmBlend * 2.0f), 0.0f, 1.0f);
                    Carve = SmoothStep01(Carve);
                    InOut.Density -= Carve * LP.BaseDensity * 1.5f;
                }
            }
        }

        /** Ne SOUSTRAIT que ⇒ `CarveOnly`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.DomeDensity > 0.0f) ? EVoxelOpEffect::CarveOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return 0.0f;
        }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxCarveOverBox(VoxelBox, Ctx));
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses&) const override
        {
            return 0.0f;
        }

        float MaxAmplitude() const
        {
            if (!(P.DomeDensity > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.BaseDensity)) { return FLT_MAX; }
            const float Result = FMath::Abs(P.BaseDensity) * 2.0f * 1.5f;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : PINCEMENT / BOTTLENECK  (TunnelNetwork, STEP 4h)
    //=========================================================================
    // Resserre un passage PAR LES CÔTÉS. Placé sur le PÉRIMÈTRE de la salle (offset 0.85 · rayon) —
    // là où les tunnels débouchent — et pas au centre, sinon il boucherait la salle elle-même.
    // `SideFactor` (distance à l'axe, clampée) est ce qui laisse l'axe du passage libre : le
    // remplissage est nul sur l'axe et maximal sur les bords de l'ellipsoïde.
    class FPinchMod final : public IVoxelDensityOp
    {
    public:
        FPinchMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("PinchMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }

            const int32 NearestRoomIdx = Rooms->GetNearestRoomIdx();
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.PinchDensity > 0.0f && CaveSDF < LP.SDFBlendRadius && CaveSDF < FLT_MAX
                  && NearestRoomIdx >= 0))
            {
                return;
            }

            const FChunkSDFCache& Cache = Rooms->GetCache();
            if (!Cache.Rooms.IsValidIndex(NearestRoomIdx)) { return; }   // cf. FCaveArchMod
            const FCachedRoom& Room = Cache.Rooms[NearestRoomIdx];

            for (int32 i = 0; i < 3; i++)
            {
                const FCachedPinch& Pinch = Room.Pinches[i];
                if (!Pinch.bActive) { continue; }
                const float DXPn = WorldX - Pinch.CenterX;
                const float DYPn = WorldY - Pinch.CenterY;
                const float DZPn = WorldZ - Pinch.CenterZ;

                if (FMath::Abs(DXPn) + FMath::Abs(DYPn) + FMath::Abs(DZPn) > Pinch.MaxExtent) { continue; }

                const float Along  =  DXPn * Pinch.CosAngle + DYPn * Pinch.SinAngle;
                const float Across = -DXPn * Pinch.SinAngle + DYPn * Pinch.CosAngle;

                const float NAlong   = Along   / Pinch.HalfLength;
                const float NAcross  = Across  / Pinch.HalfNarrow;
                const float NUp      = DZPn    / Pinch.HalfVertical;
                const float EllipDist = NAlong * NAlong + NAcross * NAcross + NUp * NUp;

                if (EllipDist < 1.0f)
                {
                    float Fill = 1.0f - EllipDist;
                    Fill = SmoothStep01(Fill);
                    const float AxisDist = FMath::Sqrt(NAcross * NAcross + NUp * NUp);
                    const float SideFactor = FMath::Clamp(AxisDist * 2.0f, 0.0f, 1.0f);
                    InOut.Density += Fill * SideFactor * Pinch.BaseDensity * 1.5f;
                }
            }
        }

        /** N'AJOUTE que du solide ⇒ `FillOnly`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.PinchDensity > 0.0f) ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxAmplitude();
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius, 0.0f);
        }

        float MaxFillOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                             const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailMax(Rooms, H, P.SDFBlendRadius,
                                    MaxFillOverBox(VoxelBox, Ctx));
        }

        float MaxAmplitude() const
        {
            if (!(P.PinchDensity > 0.0f)) { return 0.0f; }
            if (!VoxelMath::IsFinite(P.BaseDensity)) { return FLT_MAX; }
            const float Result = FMath::Abs(P.BaseDensity) * 3.0f * 1.5f;
            return VoxelMath::IsFinite(Result) ? Result : FLT_MAX;
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 3 — MODIFIER : BIAIS DE SOL / FLOOR BIAS  (TunnelNetwork, fin de 4h)
    //=========================================================================
    // Rend de la densité dans la moitié BASSE de la salle pour contrer le relief que la rugosité
    // laisse sur les sols — un sol praticable au lieu d'un sol bosselé. Ne s'applique QUE dans l'air
    // certain (`CaveSDF < 0`) : dans la paroi, le clamp anti-remplissage de la rugosité tient déjà.
    //
    // ⚠️ DERNIER DE LA CHAÎNE, ET CE N'EST PAS INTERCHANGEABLE : il ajoute un biais indépendant à
    // la densité déjà accumulée par les étapes précédentes. Il ne lit ni ne soustrait la variation
    // de rugosité (4b). Le déplacer avant les autres étapes changerait donc leur entrée et leur
    // sortie, ce qui est la raison pour laquelle l'ordre de `BuildTunnelNetworkStack` reste celui
    // de l'original, ligne pour ligne.
    //
    // This op is intentionally separate from 4b. Ten operators lie
    // between 4b and this phase (4c through 4h), and every one reads+writes Density. Moving this
    // phase next to 4b would reorder those density updates, so a bit-identical fuse is not legal.
    class FFloorBiasMod final : public IVoxelDensityOp
    {
    public:
        FFloorBiasMod(const FStrateGenerationParams& InP, const FRoomGraphSource* InRooms)
            : P(InP), Rooms(InRooms) {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::DetailModifier; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        EVoxelOpResourceMask RequiredResources() const override { return VoxelOpResources::RoomGeometry; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}
        void PrepareBlockSample(const FVoxelOpSample& Sample) const override
        {
            if (Rooms != nullptr) { Rooms->RestoreBlockSample(Sample); }
        }
        const TCHAR* DebugName() const override { return TEXT("FloorBiasMod"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

        void Eval(float, float, float WorldZ, FVoxelOpSample& InOut) const override
        {
            const float CaveSDF = InOut.Sdf;
            if (!VF_NearCaveSurface(CaveSDF, P.SDFBlendRadius)) { return; }
            if (Rooms == nullptr) { return; }

            const int32 NearestRoomIdx = Rooms->GetNearestRoomIdx();
            const FStrateGenerationParams& LP = Rooms->LocalParams();   // C1 : params PAR SALLE
            if (!(LP.FloorBias > 0.0f && NearestRoomIdx >= 0 && CaveSDF < 0.0f)) { return; }

            const FChunkSDFCache& Cache = Rooms->GetCache();
            if (!Cache.Rooms.IsValidIndex(NearestRoomIdx)) { return; }   // cf. FCaveArchMod
            const FCachedRoom& NR = Cache.Rooms[NearestRoomIdx];

            // NormZ : -1 = sol de la salle, 0 = centre, +1 = plafond.
            const float NormZ = (WorldZ - NR.Center.Z) / FMath::Max(NR.RadiusZ, 1.0f);

            if (NormZ < 0.0f)
            {
                const float FloorFactor = NormZ * NormZ;   // 0 au centre, 1 au sol
                InOut.Density += FloorFactor * LP.FloorBias;
            }
        }

        /** N'AJOUTE que du solide ⇒ `FillOnly`. */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return (P.FloorBias > 0.0f) ? EVoxelOpEffect::FillOnly : EVoxelOpEffect::Identity;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveDetailEffect(Rooms, H, P.SDFBlendRadius,
                                        EffectOverBox(VoxelBox, Ctx));
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override { return 0.0f; }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return VoxelMath::IsFinite(P.FloorBias) && P.FloorBias >= 0.0f
                 ? P.FloorBias : (P.FloorBias < 0.0f ? 0.0f : FLT_MAX);
        }

        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&,
                              const FVoxelBoxHypotheses& H) const override
        {
            return VF_CaveBoxIsFar(H, P.SDFBlendRadius) ? 0.0f : 0.0f;
        }

        float MaxFillOverBox(const FBox&, const FVoxelOpContext&,
                             const FVoxelBoxHypotheses& H) const override
        {
            if (Rooms == nullptr || VF_CaveBoxIsFar(H, P.SDFBlendRadius)) { return 0.0f; }
            return Rooms->FloorBiasFillSupremumForLastBox();
        }

    private:
        FStrateGenerationParams P;
        const FRoomGraphSource* Rooms;   // NON possédant
    };

    //=========================================================================
    // RÔLE 1 — SOURCE : VERS / WORM TUNNELS  (TunnelNetwork)
    //=========================================================================
    // Un carve par SEUIL sur du bruit 3D, masqué par la distance au réseau de salles. Il écrit la
    // DENSITÉ directement (pas le canal SDF) : c'est une source « fieldée », pas une primitive
    // placée — la distinction que `AUDIT §6.2` pose et que `OPSTACK-DECOMPOSITION §0.2` chiffre.
    //
    // ⚠️ IL LIT `InOut.Sdf` : le masque de réseau est une fonction de `CaveSDF` APRÈS pits et
    // cheminées. C'est encore le canal SDF utilisé comme ce pour quoi il existe — transporter une
    // information géométrique entre deux opérateurs au lieu de la recalculer.
    class FWormFieldSource final : public IVoxelDensityOp
    {
    public:
        FWormFieldSource(const FStrateGenerationParams& InP, int32 Seed)
            : P(InP)
            , SeedU((uint32)Seed)
        {}

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
        EVoxelOpChannelMask ChannelReads() const override
        {
            return VoxelOpChannels::Density | VoxelOpChannels::Sdf;
        }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return true; }
        void PrepareChunk(const FVoxelOpContext&) override {}

        void Eval(float WorldX, float WorldY, float WorldZ, FVoxelOpSample& InOut) const override
        {
            if (!(P.WormStrength > 0.0f && P.WormThreshold > 0.0f)) { return; }

            const float CaveSDF = InOut.Sdf;

            float NetworkMask = 1.0f;
            if (P.WormNetworkRange > 0.0f)
            {
                if (CaveSDF >= P.WormNetworkRange)   // vrai aussi quand il n'y a pas de réseau (FLT_MAX)
                {
                    NetworkMask = 0.0f;
                }
                else if (CaveSDF > 0.0f)
                {
                    NetworkMask = 1.0f - SmoothStep01(CaveSDF / P.WormNetworkRange);
                }
            }

            if (NetworkMask <= 0.0f) { return; }

            const VoxelWormField::FParameters WormParameters{
                P.WormFrequency,
                P.WormHorizontalBias,
                P.VerticalScale,
                SeedU};
            const float WormValue = VoxelWormField::Evaluate(
                WorldX, WorldY, WorldZ, P.WormThreshold,
                WormParameters);
            if (WormValue < P.WormThreshold)
            {
                const float t = 1.0f - (WormValue / P.WormThreshold);
                InOut.Density -= t * P.WormStrength * NetworkMask;
            }
        }

        /**
         * The worm is a density consumer, not an SDF source. Its intrinsic response is `CarveOnly`.
         * The state-aware fold may prove it inactive only when the interval already published by a
         * preceding SDF writer proves `Sdf >= WormNetworkRange` throughout the box. An unknown or
         * unrelated interval leaves the carve active, which is conservative for free composition.
         * Its magnitude is independently bounded by `WormStrength` because both `t` and
         * `NetworkMask` are in [0, 1].
         */
        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            if (!(P.WormStrength > 0.0f && P.WormThreshold > 0.0f)) { return EVoxelOpEffect::Identity; }
            return EVoxelOpEffect::CarveOnly;
        }

        EVoxelOpEffect EffectOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                     const FVoxelBoxHypotheses& H) const override
        {
            const EVoxelOpEffect Intrinsic = EffectOverBox(VoxelBox, Ctx);
            if (Intrinsic == EVoxelOpEffect::Identity) { return Intrinsic; }
            if (P.WormNetworkRange > 0.0f && H.Sdf.IsKnown()
                && H.Sdf.Min >= P.WormNetworkRange)
            {
                return EVoxelOpEffect::Identity;
            }
            return Intrinsic;
        }

        /**
         * ✅ **LA BORNE DE `§0.2`, MAINTENANT CONSOMMÉE.** Elle a passé plusieurs entrées de journal
         * écrite mais inutilisée, faute d'un pliage capable de porter un nombre ; ce pliage existe.
         *
         * La preuve tient en une ligne : `t = 1 − WormValue/WormThreshold ∈ [0,1]` (le bloc ne
         * s'exécute que sous le seuil) et `NetworkMask ∈ [0,1]` par construction, donc
         * `t · WormStrength · NetworkMask ≤ WormStrength`. C'est une borne PROUVÉE, pas prudente —
         * la seule sorte qui ait le droit d'être ici : sur-estimer coûte du CPU, sous-estimer fait
         * un trou.
         */
        float MaxCarveOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return MaxCarveAmplitude();
        }

        float MaxCarveOverBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                              const FVoxelBoxHypotheses& H) const override
        {
            const float Strength = MaxCarveOverBox(VoxelBox, Ctx);
            if (!(Strength > 0.0f) || !VoxelMath::IsFinite(Strength))
            {
                return Strength;
            }
            if (!(P.WormNetworkRange > 0.0f) || !VoxelMath::IsFinite(P.WormNetworkRange)
                || !H.Sdf.IsKnown() || !VoxelMath::IsFinite(H.Sdf.Min))
            {
                return Strength;
            }

            // The classifier's lattice proof is about the exact MC vertices, not the continuum
            // between them.  On a refined child, evaluate the worm's two threshold noises at
            // those vertices once and bound the actual carve factor there.  The root is left on
            // the cheap interval path; a refined step-32 child has at most 17^3 vertices and the
            // explicit count cap keeps this check bounded.  The network mask still uses the SDF
            // interval's worst case, so this never assumes a room value that the preceding source
            // did not prove.
            if (Ctx.bUseLatticeProof && Ctx.bTightenWarpProof && Ctx.Step >= 1
                && VoxelMath::IsFinite(P.WormFrequency)
                && VoxelMath::IsFinite(P.WormHorizontalBias)
                && VoxelMath::IsFinite(P.WormThreshold)
                && P.WormThreshold > 0.0f
                && VoxelMath::IsFinite(P.VerticalScale))
            {
                const int32 Step = FMath::Max(Ctx.Step, 1);
                const float OriginX = static_cast<float>(Ctx.LatticeOriginVoxels.X);
                const float OriginY = static_cast<float>(Ctx.LatticeOriginVoxels.Y);
                const float OriginZ = static_cast<float>(Ctx.LatticeOriginVoxels.Z);
                const int32 IX0 = FMath::CeilToInt(
                    ((float)VoxelBox.Min.X - OriginX) / (float)Step - 1.0e-4f);
                const int32 IY0 = FMath::CeilToInt(
                    ((float)VoxelBox.Min.Y - OriginY) / (float)Step - 1.0e-4f);
                const int32 IZ0 = FMath::CeilToInt(
                    ((float)VoxelBox.Min.Z - OriginZ) / (float)Step - 1.0e-4f);
                const int32 IX1 = FMath::FloorToInt(
                    ((float)VoxelBox.Max.X - OriginX) / (float)Step + 1.0e-4f);
                const int32 IY1 = FMath::FloorToInt(
                    ((float)VoxelBox.Max.Y - OriginY) / (float)Step + 1.0e-4f);
                const int32 IZ1 = FMath::FloorToInt(
                    ((float)VoxelBox.Max.Z - OriginZ) / (float)Step + 1.0e-4f);
                const int64 Count = ((int64)IX1 - IX0 + 1)
                                 * ((int64)IY1 - IY0 + 1)
                                 * ((int64)IZ1 - IZ0 + 1);
                // A full LOD0 root is intentionally left on the cheap interval path.  Refined
                // child boxes are at most 17^3 lattice vertices, so their exact threshold bound
                // couples the worm's spatial maximum to each child's SDF lower bound without
                // evaluating the room graph 35,937 times.
                if (IX1 >= IX0 && IY1 >= IY0 && IZ1 >= IZ0
                    && Count > 0 && Count <= 10000)
                {
                    float MaxThresholdFactor = 0.0f;
                    const float WormZFrequency = P.WormFrequency * P.WormHorizontalBias;
                    for (int32 IZ = IZ0; IZ <= IZ1; ++IZ)
                    for (int32 IY = IY0; IY <= IY1; ++IY)
                    for (int32 IX = IX0; IX <= IX1; ++IX)
                    {
                        const float WorldX = OriginX + (float)IX * (float)Step;
                        const float WorldY = OriginY + (float)IY * (float)Step;
                        const float WorldZ = OriginZ + (float)IZ * (float)Step;
                        const float EffectiveZ = (P.VerticalScale != 1.0f
                                                   && P.VerticalScale > 0.0f)
                                                ? WorldZ / P.VerticalScale : WorldZ;
                        const FVector3f NoiseBase(
                            WorldX * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f),
                            WorldY * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f),
                            EffectiveZ * WormZFrequency + VoxelHash::SeedOffset(SeedU, 2.3f));
                        const float N1 = FMath::Abs(VoxelNoise::Perlin3D(NoiseBase)
                                                   * VOXEL_NOISE_SCALE);
                        if (N1 >= P.WormThreshold) { continue; }

                        const FVector3f NoiseOffset(
                            137.0f, 259.0f, 431.0f);
                        const float N2 = FMath::Abs(VoxelNoise::Perlin3D(
                            NoiseBase + NoiseOffset) * VOXEL_NOISE_SCALE);
                        const float WormValue = N1 + N2;
                        if (WormValue < P.WormThreshold)
                        {
                            MaxThresholdFactor = FMath::Max(
                                MaxThresholdFactor,
                                1.0f - WormValue / P.WormThreshold);
                        }
                    }

                    if (!(MaxThresholdFactor > 0.0f)) { return 0.0f; }
                    float MaxNetworkMask = 1.0f;
                    if (H.Sdf.Min >= P.WormNetworkRange)
                    {
                        MaxNetworkMask = 0.0f;
                    }
                    else if (H.Sdf.Min > 0.0f)
                    {
                        MaxNetworkMask = 1.0f - SmoothStep01(
                            FMath::Clamp(H.Sdf.Min / P.WormNetworkRange, 0.0f, 1.0f));
                    }
                    return Strength * MaxThresholdFactor
                        * FMath::Clamp(MaxNetworkMask, 0.0f, 1.0f);
                }
            }

            // NetworkMask is monotone non-increasing in CaveSDF.  The source interval's lower
            // endpoint therefore gives a sound upper bound for the mask across the whole box,
            // not just the old all-or-nothing test at WormNetworkRange.  This matters in deep
            // solid: a positive SDF can leave only a fraction of the worm amplitude, enough for
            // the constant-rock margin to survive even when the full WormStrength would not.
            float MaxNetworkMask = 1.0f;
            if (H.Sdf.Min >= P.WormNetworkRange)
            {
                MaxNetworkMask = 0.0f;
            }
            else if (H.Sdf.Min > 0.0f)
            {
                MaxNetworkMask = 1.0f - SmoothStep01(
                    FMath::Clamp(H.Sdf.Min / P.WormNetworkRange, 0.0f, 1.0f));
            }
            return Strength * FMath::Clamp(MaxNetworkMask, 0.0f, 1.0f);
        }

        /** Le ver ne REMPLIT jamais : `InOut.Density -= …` avec un terme positif. */
        float MaxFillOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return 0.0f;
        }

        /** L'amplitude max de carve, en unités de densité. Borne BRUTE : elle ignore la portée du
         *  réseau, c'est `MaxCarveOverBox` qui l'applique. */
        float MaxCarveAmplitude() const
        {
            if (!(P.WormStrength > 0.0f && P.WormThreshold > 0.0f)) { return 0.0f; }
            return VoxelMath::IsFinite(P.WormStrength) ? P.WormStrength : FLT_MAX;
        }

        const TCHAR* DebugName() const override { return TEXT("WormFieldSource"); }
        void EvalBlock(const FVoxelOpBlock& Block) const override { VF_EvalBlockByScalar(*this, Block); }

    private:
        FStrateGenerationParams P;
        uint32 SeedU;
    };

#if WITH_EDITOR
    //=============================================================================
    // RÔLE 2 — COMBINER : RÉGIONS LATÉRALES
    //=============================================================================
    // The creative stacks stay independent.  This op owns only their density-level junction;
    // the parent FVoxelOpStack appends the global structural posts after it.  In particular, no
    // recipe can make the spine, vertical seal, passage carve, or XY edge seal region-local.
    class FLateralRegionBlendOp final : public IVoxelDensityOp
    {
    public:
        FLateralRegionBlendOp(const FVoxelStrateRegionManifest& InManifest,
                              TArray<FVoxelOpStack>&& InStacks)
            : RegionStacks(MoveTemp(InStacks))
        {
            // Keep only partition metadata here.  The native vectors/recipes have already been
            // consumed by the stacks and must not be duplicated in the voxel operator.
            PartitionManifest.bValid = true;
            PartitionManifest.Seed = InManifest.Seed;
            PartitionManifest.StrateIndex = InManifest.StrateIndex;
            PartitionManifest.RegionCount = InManifest.RegionCount;
            PartitionManifest.PartitionSeed = InManifest.PartitionSeed;
            PartitionManifest.LatticeCellSize = InManifest.LatticeCellSize;
            PartitionManifest.BlendWidth = InManifest.BlendWidth;
            PartitionManifest.Regions.SetNum(InManifest.RegionCount);
        }

        EVoxelOpRole GetRole() const override { return EVoxelOpRole::Combiner; }
        EVoxelOpChannelMask ChannelReads() const override { return VoxelOpChannels::None; }
        EVoxelOpChannelMask ChannelWrites() const override { return VoxelOpChannels::Density; }
        bool IsAdditive() const override { return false; }

        void PrepareChunk(const FVoxelOpContext& Ctx) override
        {
            PartitionCache.PrepareForChunk(PartitionManifest, Ctx.ChunkCoord);
            bPrepared = true;
            for (FVoxelOpStack& Stack : RegionStacks)
            {
                Stack.PrepareChunk(Ctx);
            }
        }

        void Eval(float WorldX, float WorldY, float WorldZ,
                  FVoxelOpSample& InOut) const override
        {
            if (RegionStacks.Num() == 0) { return; }

            const FVoxelStrateRegionQuery Query = bPrepared
                ? PartitionCache.Query(WorldX, WorldY)
                : VF_QueryStrateRegion(PartitionManifest, WorldX, WorldY);
            const int32 Primary = FMath::Clamp(Query.PrimaryRegion, 0, RegionStacks.Num() - 1);
            const float PrimaryDensity = RegionStacks[Primary].EvalInternal(
                WorldX, WorldY, WorldZ);
            float Density = PrimaryDensity;

            if (Query.NeighborWeight > 0.0f && Query.NeighborRegion != INDEX_NONE
                && RegionStacks.IsValidIndex(Query.NeighborRegion)
                && Query.NeighborRegion != Primary)
            {
                const float NeighborDensity = RegionStacks[Query.NeighborRegion].EvalInternal(
                    WorldX, WorldY, WorldZ);
                Density = FMath::Lerp(PrimaryDensity, NeighborDensity, Query.NeighborWeight);
            }
            InOut.Density = Density;
        }

        /**
         * A box wholly outside the band can use its one creative stack.  A box that may touch a
         * bisector or the band asks every region stack.  If any is Mixed, the parent is Mixed. If
         * all possible stacks agree, their convex density blend has the same sign everywhere, so
         * the blend band is proved uniform too.  This is deliberately stricter than sampling a
         * center point and is the protection against a cross-region false uniform tile.
         */
        EVoxelTileClass ClassifyBox(const FBox& VoxelBox,
                                    const FVoxelOpContext& Ctx) const override
        {
            if (RegionStacks.Num() == 0) { return EVoxelTileClass::Mixed; }

            const FVoxelStrateRegionBoxProof Proof =
                VF_AnalyzeStrateRegionBox(PartitionManifest, VoxelBox);
            if (Proof.bProvablySingleRegion)
            {
                const FVoxelStrateRegionQuery Query = VF_QueryStrateRegion(
                    PartitionManifest,
                    ((float)VoxelBox.Min.X + (float)VoxelBox.Max.X) * 0.5f,
                    ((float)VoxelBox.Min.Y + (float)VoxelBox.Max.Y) * 0.5f);
                const int32 Primary = FMath::Clamp(
                    Query.PrimaryRegion, 0, RegionStacks.Num() - 1);
                return RegionStacks[Primary].ClassifyBox(VoxelBox, Ctx);
            }

            EVoxelTileClass CommonVerdict = EVoxelTileClass::Mixed;
            for (const FVoxelOpStack& Stack : RegionStacks)
            {
                const EVoxelTileClass Verdict = Stack.ClassifyBox(VoxelBox, Ctx);
                if (Verdict == EVoxelTileClass::Mixed)
                {
                    return EVoxelTileClass::Mixed;
                }
                if (CommonVerdict == EVoxelTileClass::Mixed)
                {
                    CommonVerdict = Verdict;
                }
                else if (CommonVerdict != Verdict)
                {
                    return EVoxelTileClass::Mixed;
                }
            }
            return CommonVerdict;
        }

        EVoxelOpEffect EffectOverBox(const FBox&, const FVoxelOpContext&) const override
        {
            return EVoxelOpEffect::Both;
        }

        const TCHAR* DebugName() const override { return TEXT("LateralRegionBlendOp"); }

    private:
        FVoxelStrateRegionManifest PartitionManifest;
        TArray<FVoxelOpStack> RegionStacks;
        mutable FVoxelStrateRegionPartitionCache PartitionCache;
        mutable bool bPrepared = false;
    };
#endif

}   // ⚠️ FIN DU NAMESPACE ANONYME — TOUT NOUVEL OPÉRATEUR SE MET AU-DESSUS DE CETTE LIGNE.
    // Même piège que dans VoxelHeightOpStack.cpp : s'ancrer sur une bannière située plus bas
    // (« FVoxelOpStack », « FABRIQUES ») insère la classe HORS du namespace anonyme, et l'accolade
    // ajoutée avec elle ne ferme rien → C2059.
    // END OF THE ANONYMOUS NAMESPACE — new operators go ABOVE this line.

//=============================================================================
// DIAGNOSTIC — voir la déclaration dans VoxelDensityOpStack.h
//=============================================================================

VoxelDensityOps::FRoomBoxDiagnostic VoxelDensityOps::GetLastRoomBoxDiagnostic()
{
    const FRoomGraphSource::FBoxState& B = FRoomGraphSource::BoxState();

    FRoomBoxDiagnostic D;
    D.HitRooms    = B.HitRooms;
    D.HitTunnels  = B.HitTunnels;
    D.HitPits     = B.HitPits;
    D.HitChimneys = B.HitChimneys;
    D.NumRooms    = B.NumRooms;
    D.NumTunnels  = B.NumTunnels;
    D.NumPits     = B.NumPits;
    D.NumChimneys = B.NumChimneys;
    D.HitRoomsNoWarp   = B.HitRoomsNoWarp;
    D.HitTunnelsNoWarp = B.HitTunnelsNoWarp;
    D.WarpDilation     = B.WarpDilation;
    D.bMayHaveTunnelCoreAir = B.bMayHaveTunnelCoreAir;
    D.bMayHaveTunnelSupportFloor = B.bMayHaveTunnelSupportFloor;
    D.bMayHaveTunnelCoreTail = B.bMayHaveTunnelCoreTail;
    D.ExactTailQueries = B.ExactTailQueries;
    D.ExactTailEvaluated = B.ExactTailEvaluated;
    D.ExactTailCycles = B.ExactTailCycles;
    D.PropagateCycles = B.PropagateCycles;
    D.ExactPrimitiveCycles = B.ExactPrimitiveCycles;
    D.CacheWindowCycles = B.CacheWindowCycles;
    D.NumRooms = B.NumRooms;
    D.NumTunnels = B.NumTunnels;
    D.NumRoomFloorJoins = B.NumRoomFloorJoins;
    D.NumPits = B.NumPits;
    D.NumChimneys = B.NumChimneys;
    return D;
}

void VoxelDensityOps::ReportWorkerRoomGraphCacheFootprint()
{
    if (!VoxelDensityProfile::IsEnabled())
    {
        return;
    }

    uint64 DynamicBytes = 0;
    uint64 EntryBytes = 0;
    uint64 LargestEntryBytes = 0;
    uint64 ValidEntries = 0;
    VoxelDensityProfile::FCacheMemoryBreakdown Breakdown;
    auto& RoomGraphCache = GRoomGraphCache.Get();
    for (int32 Bank = 0; Bank < RoomGraphCacheBankCount; ++Bank)
    {
        for (int32 Index = 0; Index < RoomGraphCacheSlotCount; ++Index)
        {
            const FRoomGraphCacheEntry& Entry = RoomGraphCache[Bank][Index];
            if (!Entry.bValid)
            {
                continue;
            }

            ++ValidEntries;
            Breakdown += Entry.Cache.GetAllocatedSizeBreakdown();
            const uint64 EntryDynamicBytes = static_cast<uint64>(Entry.Cache.GetAllocatedSize());
            const uint64 FullEntryBytes = static_cast<uint64>(sizeof(FRoomGraphCacheEntry))
                + EntryDynamicBytes;
            DynamicBytes += EntryDynamicBytes;
            EntryBytes += FullEntryBytes;
            LargestEntryBytes = FMath::Max(LargestEntryBytes, FullEntryBytes);
        }
    }
    Breakdown.SlotStorageBytes = static_cast<uint64>(sizeof(RoomGraphCache));

    VoxelDensityProfile::SetWorkerRoomGraphCacheFootprint(
        RoomGraphCacheBankCount * RoomGraphCacheSlotCount,
        ValidEntries,
        static_cast<uint64>(sizeof(RoomGraphCache)),
        DynamicBytes,
        EntryBytes,
        LargestEntryBytes,
        ValidEntries,
        Breakdown);
}

void VoxelDensityOps::ReportSharedRoomGraphCacheFootprint()
{
    uint64 ReadyEntries = 0;
    uint64 BuildingEntries = 0;
    uint64 LargestEntryBytes = 0;
    uint64 CacheBytes = 0;
    {
        FScopeLock Lock(&GSharedRoomGraphCacheMutex);
        for (const TSharedPtr<FSharedRoomGraphCacheEntry, ESPMode::ThreadSafe>& Entry
             : GSharedRoomGraphCache)
        {
            if (Entry->bBuilding)
            {
                ++BuildingEntries;
            }
            else
            {
                ++ReadyEntries;
                LargestEntryBytes = FMath::Max(LargestEntryBytes, Entry->AllocatedBytes);
                CacheBytes += Entry->AllocatedBytes;
            }
        }
        UE_LOG(LogTemp, Display,
            TEXT("[VoxelForgeSharedCacheMemory] entries=%d ready=%llu building=%llu "
                 "resident_bytes=%llu resident_mib=%.2f budget_bytes=%llu "
                 "largest_entry_bytes=%llu"),
            GSharedRoomGraphCache.Num(),
            static_cast<unsigned long long>(ReadyEntries),
            static_cast<unsigned long long>(BuildingEntries),
            static_cast<unsigned long long>(CacheBytes),
            static_cast<double>(CacheBytes) / (1024.0 * 1024.0),
            static_cast<unsigned long long>(SharedRoomGraphCacheBudgetBytes),
            static_cast<unsigned long long>(LargestEntryBytes));
    }
}

void VoxelDensityOps::TrimSharedRoomGraphCache(uint64 KeepManagerLifetimeId)
{
    uint64 BeforeBytes = 0;
    uint64 AfterBytes = 0;
    int32 BeforeEntries = 0;
    int32 AfterEntries = 0;
    {
        FScopeLock Lock(&GSharedRoomGraphCacheMutex);
        BeforeBytes = GSharedRoomGraphCacheResidentBytes;
        BeforeEntries = GSharedRoomGraphCache.Num();
        RemoveStaleSharedRoomGraphCachesLocked(KeepManagerLifetimeId);
        AfterBytes = GSharedRoomGraphCacheResidentBytes;
        AfterEntries = GSharedRoomGraphCache.Num();
    }
    if (BeforeBytes != AfterBytes || BeforeEntries != AfterEntries)
    {
        UE_LOG(LogTemp, Display,
            TEXT("[VoxelForgeSharedCacheMemory] trim keep_lifetime=%llu entries=%d->%d "
                 "resident_bytes=%llu->%llu"),
            static_cast<unsigned long long>(KeepManagerLifetimeId),
            BeforeEntries, AfterEntries,
            static_cast<unsigned long long>(BeforeBytes),
            static_cast<unsigned long long>(AfterBytes));
    }
}

//=============================================================================
// FVoxelOpStack
//=============================================================================

SIZE_T FVoxelOpStack::GetAllocatedSize() const
{
    SIZE_T Bytes = static_cast<SIZE_T>(Ops.GetAllocatedSize());
    for (const FOpEntry& Entry : Ops)
    {
        if (Entry.Op.IsValid())
        {
            Bytes += FMemory::GetAllocSize(const_cast<IVoxelDensityOp*>(Entry.Op.Get()));
        }
    }
    return Bytes;
}

bool FVoxelOpStack::TryGetLastTunnelCoreWorldEvaluation(
    FTunnelCoreWorldEvaluation& OutEvaluation) const
{
    // The last provider wins in the same way the structural tail is ordered.  At present the
    // tunnel source is the only provider; walking backwards keeps this safe if a composed stack
    // later adds another structural core provider.
    for (int32 Index = Ops.Num() - 1; Index >= 0; --Index)
    {
        if (Ops[Index].Op->TryGetLastTunnelCoreWorldEvaluation(OutEvaluation))
        {
            return true;
        }
    }
    return false;
}

void FVoxelOpStack::DiagnoseBox(const FBox& VoxelBox, const FVoxelOpContext& Ctx,
                                int32 SampleStep, TArray<FOpBoxDiagnostic>& OutDiagnostics,
                                EVoxelTileClass* OutVerdict) const
{
    OutDiagnostics.Reset();
    OutDiagnostics.SetNum(Ops.Num());
    if (OutVerdict != nullptr)
    {
        *OutVerdict = EVoxelTileClass::Mixed;
    }

    if (!VoxelBox.IsValid || SampleStep <= 0)
    {
        return;
    }

    FVoxelBoxHypotheses H;
    for (int32 Index = 0; Index < Ops.Num(); ++Index)
    {
        const FOpEntry& Entry = Ops[Index];
        FOpBoxDiagnostic& Diagnostic = OutDiagnostics[Index];
        Diagnostic.Index = Index;
        Diagnostic.Name = Entry.Op.IsValid() ? FString(Entry.Op->DebugName()) : TEXT("(null op)");
        Diagnostic.bWritesSdf = (Entry.Writes & VoxelOpChannels::Sdf) != 0;

        if (!Entry.Op.IsValid())
        {
            continue;
        }

        // This is intentionally the same order and branch structure as VF_FoldOp. The diagnostic
        // must explain the production classifier, not an approximation of it.
        const EVoxelTileClass Forced = Entry.Op->ClassifyBox(VoxelBox, Ctx);
        Diagnostic.ForcedVerdict = Forced;
        Diagnostic.bForced = Forced != EVoxelTileClass::Mixed;
        if (Diagnostic.bForced)
        {
            Diagnostic.Effect = EVoxelOpEffect::Identity;
            Diagnostic.ForcedMargin = Entry.Op->ForcedMarginOverBox(VoxelBox, Ctx);
            VF_ForceHypotheses(H, Forced, Diagnostic.ForcedMargin);
            if (Diagnostic.bWritesSdf)
            {
                Entry.Op->PropagateSdfOverBox(H.Sdf, VoxelBox, Ctx);
                Diagnostic.bHasSdfBound = H.Sdf.IsKnown();
                if (Diagnostic.bHasSdfBound)
                {
                    Diagnostic.SdfBoundMin = H.Sdf.Min;
                    Diagnostic.SdfBoundMax = H.Sdf.Max;
                }
            }
        }
        else
        {
            Diagnostic.Effect = Entry.Op->EffectOverBox(VoxelBox, Ctx, H);
            Diagnostic.MaxCarve = Entry.Op->MaxCarveOverBox(VoxelBox, Ctx, H);
            Diagnostic.MaxFill = Entry.Op->MaxFillOverBox(VoxelBox, Ctx, H);
            VF_FoldEffect(H, Diagnostic.Effect, Diagnostic.MaxCarve, Diagnostic.MaxFill);
            if (Diagnostic.bWritesSdf)
            {
                Entry.Op->PropagateSdfOverBox(H.Sdf, VoxelBox, Ctx);
                Diagnostic.bHasSdfBound = H.Sdf.IsKnown();
                if (Diagnostic.bHasSdfBound)
                {
                    Diagnostic.SdfBoundMin = H.Sdf.Min;
                    Diagnostic.SdfBoundMax = H.Sdf.Max;
                }
            }
        }
    }

    if (OutVerdict != nullptr)
    {
        *OutVerdict = H.Resolve();
    }

    const int32 MinX = FMath::CeilToInt(static_cast<float>(VoxelBox.Min.X));
    const int32 MinY = FMath::CeilToInt(static_cast<float>(VoxelBox.Min.Y));
    const int32 MinZ = FMath::CeilToInt(static_cast<float>(VoxelBox.Min.Z));
    const int32 MaxX = FMath::FloorToInt(static_cast<float>(VoxelBox.Max.X));
    const int32 MaxY = FMath::FloorToInt(static_cast<float>(VoxelBox.Max.Y));
    const int32 MaxZ = FMath::FloorToInt(static_cast<float>(VoxelBox.Max.Z));
    if (MinX > MaxX || MinY > MaxY || MinZ > MaxZ)
    {
        return;
    }

    constexpr float BoundEpsilon = 1.0e-4f;
    for (int32 Z = MinZ; Z <= MaxZ; )
    {
        for (int32 Y = MinY; Y <= MaxY; )
        {
            for (int32 X = MinX; X <= MaxX; )
            {
                FVoxelOpSample Sample;
                for (int32 Index = 0; Index < Ops.Num(); ++Index)
                {
                    const FOpEntry& Entry = Ops[Index];
                    FOpBoxDiagnostic& Diagnostic = OutDiagnostics[Index];
                    if (!Entry.Op.IsValid())
                    {
                        continue;
                    }

                    const float DensityBefore = Sample.Density;
                    Entry.Op->Eval(static_cast<float>(X), static_cast<float>(Y),
                                   static_cast<float>(Z), Sample);
                    const float DensityDelta = Sample.Density - DensityBefore;
                    if (VoxelMath::IsFinite(DensityDelta))
                    {
                        Diagnostic.bHasDensityDelta = true;
                        Diagnostic.ActualDensityDeltaMin =
                            FMath::Min(Diagnostic.ActualDensityDeltaMin, DensityDelta);
                        Diagnostic.ActualDensityDeltaMax =
                            FMath::Max(Diagnostic.ActualDensityDeltaMax, DensityDelta);

                        // A forced classifier is a stronger statement than a directional delta
                        // bound. Its density can legitimately replace an arbitrary incoming
                        // value (the constant source is the canonical example), so do not call
                        // that replacement a MaxFill/MaxCarve violation. ForcedMargin records the
                        // proof margin separately for the report.
                        if (!Diagnostic.bForced)
                        {
                            const float CarveEpsilon = BoundEpsilon
                                * FMath::Max(1.0f, FMath::Abs(Diagnostic.MaxCarve));
                            const float FillEpsilon = BoundEpsilon
                                * FMath::Max(1.0f, FMath::Abs(Diagnostic.MaxFill));
                            if (VoxelMath::IsFinite(Diagnostic.MaxCarve)
                                && DensityDelta < -Diagnostic.MaxCarve - CarveEpsilon)
                            {
                                Diagnostic.bCarveBoundViolated = true;
                            }
                            if (VoxelMath::IsFinite(Diagnostic.MaxFill)
                                && DensityDelta > Diagnostic.MaxFill + FillEpsilon)
                            {
                                Diagnostic.bFillBoundViolated = true;
                            }
                        }
                    }

                    if (Diagnostic.bWritesSdf && VoxelMath::IsFinite(Sample.Sdf))
                    {
                        Diagnostic.bHasSdfValue = true;
                        Diagnostic.ActualSdfMin = FMath::Min(
                            Diagnostic.ActualSdfMin, Sample.Sdf);
                        Diagnostic.ActualSdfMax = FMath::Max(
                            Diagnostic.ActualSdfMax, Sample.Sdf);
                    }
                    ++Diagnostic.SampleCount;
                }

                if (X > MaxX - SampleStep) { break; }
                X += SampleStep;
            }
            if (Y > MaxY - SampleStep) { break; }
            Y += SampleStep;
        }
        if (Z > MaxZ - SampleStep) { break; }
        Z += SampleStep;
    }
}

bool FVoxelOpStack::ValidateChannelOrder(FString* OutError) const
{
    if (OutError != nullptr) { OutError->Reset(); }

    auto DescribeMask = [](EVoxelOpChannelMask Mask) -> FString
    {
        FString Result;
        if ((Mask & VoxelOpChannels::Density) != 0) { Result += TEXT("Density"); }
        if ((Mask & VoxelOpChannels::Sdf) != 0)
        {
            if (!Result.IsEmpty()) { Result += TEXT(", "); }
            Result += TEXT("Sdf");
        }
        return Result.IsEmpty() ? TEXT("none") : Result;
    };

    auto DescribeResourceMask = [](EVoxelOpResourceMask Mask) -> FString
    {
        FString Result;
        if ((Mask & VoxelOpResources::RoomGeometry) != 0) { Result += TEXT("RoomGeometry"); }
        if ((Mask & VoxelOpResources::ShaftGeometry) != 0)
        {
            if (!Result.IsEmpty()) { Result += TEXT(", "); }
            Result += TEXT("ShaftGeometry");
        }
        if ((Mask & VoxelOpResources::SurfaceColumn) != 0)
        {
            if (!Result.IsEmpty()) { Result += TEXT(", "); }
            Result += TEXT("SurfaceColumn");
        }
        return Result.IsEmpty() ? TEXT("none") : Result;
    };

    auto Fail = [&](int32 Index, const FOpEntry* Entry, const TCHAR* Rule) -> bool
    {
        if (OutError != nullptr)
        {
            const TCHAR* Name = (Entry != nullptr && Entry->Op.Get() != nullptr)
                              ? Entry->Op->DebugName() : TEXT("(null op)");
            const EVoxelOpChannelMask Reads = Entry != nullptr ? Entry->Reads : VoxelOpChannels::None;
            const EVoxelOpChannelMask Writes = Entry != nullptr ? Entry->Writes : VoxelOpChannels::None;
            *OutError = FString::Printf(
                TEXT("op %d (%s) violates stack DAG: %s; reads=[%s], writes=[%s], requires=[%s], provides=[%s]"),
                Index, Name, Rule, *DescribeMask(Reads), *DescribeMask(Writes),
                *DescribeResourceMask(Entry != nullptr ? Entry->RequiredResources : VoxelOpResources::None),
                *DescribeResourceMask(Entry != nullptr ? Entry->ProvidedResources : VoxelOpResources::None));
        }
        return false;
    };

    // The two array slots are deliberately explicit: FVoxelOpSample has exactly two fields, and
    // adding a third field requires extending EVoxelOpChannel and this validator together.
    int32 LastWriter[2] = { INDEX_NONE, INDEX_NONE };
    EVoxelOpResourceMask AvailableResources = VoxelOpResources::None;

    auto ChannelIndex = [](EVoxelOpChannelMask Channel) -> int32
    {
        return Channel == VoxelOpChannels::Density ? 0 : 1;
    };

    for (int32 Index = 0; Index < Ops.Num(); ++Index)
    {
        const FOpEntry& Entry = Ops[Index];
        if (Entry.Op.Get() == nullptr) { return Fail(Index, &Entry, TEXT("null operator")); }

        if ((Entry.RequiredResources & VoxelOpResources::All) != Entry.RequiredResources)
        {
            return Fail(Index, &Entry, TEXT("requires an unknown op resource"));
        }
        if ((Entry.ProvidedResources & VoxelOpResources::All) != Entry.ProvidedResources)
        {
            return Fail(Index, &Entry, TEXT("provides an unknown op resource"));
        }
        if ((Entry.RequiredResources
             & static_cast<EVoxelOpResourceMask>(~AvailableResources)) != 0)
        {
            return Fail(Index, &Entry,
                        TEXT("requires op state before an earlier provider published it"));
        }

        if ((Entry.Reads & VoxelOpChannels::All) != Entry.Reads)
        {
            return Fail(Index, &Entry, TEXT("reads an unknown sample channel"));
        }
        if ((Entry.Writes & VoxelOpChannels::All) != Entry.Writes)
        {
            return Fail(Index, &Entry, TEXT("writes an unknown sample channel"));
        }

        if (Entry.bAdditive && Entry.Writes == VoxelOpChannels::None)
        {
            return Fail(Index, &Entry, TEXT("an additive operator must publish a channel"));
        }
        if (Entry.bAdditive
            && (Entry.Writes & static_cast<EVoxelOpChannelMask>(~Entry.Reads)) != 0)
        {
            return Fail(Index, &Entry,
                        TEXT("an additive operator must read every channel it writes"));
        }

        const EVoxelOpChannelMask Channels[] = {
            VoxelOpChannels::Density, VoxelOpChannels::Sdf
        };
        for (const EVoxelOpChannelMask Channel : Channels)
        {
            if ((Entry.Reads & Channel) == 0) { continue; }

            const int32 Writer = LastWriter[ChannelIndex(Channel)];
            const bool bRootIdentityFold = Entry.Op->GetRole() == EVoxelOpRole::FieldSource
                                         && (Entry.Writes & Channel) != 0
                                         && Writer == INDEX_NONE;
            if (Writer == INDEX_NONE && !bRootIdentityFold)
            {
                return Fail(Index, &Entry,
                            TEXT("reads a channel before a producer has published it"));
            }
        }

        for (const EVoxelOpChannelMask Channel : Channels)
        {
            if ((Entry.Writes & Channel) == 0 || (Entry.Reads & Channel) != 0) { continue; }

            // A write-only op is an assignment/replacement. It may establish the first version,
            // but it may not erase a previously produced channel without declaring a read of it.
            if (LastWriter[ChannelIndex(Channel)] != INDEX_NONE)
            {
                return Fail(Index, &Entry,
                            TEXT("a write-only replacement would clobber an existing channel"));
            }
        }

        for (const EVoxelOpChannelMask Channel : Channels)
        {
            if ((Entry.Writes & Channel) != 0)
            {
                // Every read above has either consumed this writer's predecessor or the explicit
                // root identity. Updating the version here makes all later consumer edges forward.
                LastWriter[ChannelIndex(Channel)] = Index;
            }
        }

        AvailableResources |= Entry.ProvidedResources;
    }

    return true;
}

void FVoxelOpStack::AppendStructuralPost(float StrateTopWorldZ, float StrateBottomWorldZ,
                                         float SealThickness, float BaseDensity, float SpineRadius,
                                         const UVoxelStrateManager* StrateManager,
                                         bool bAppendEdgeSeal)
{
    // ORDRE NON NÉGOCIABLE : la spine creuse l'intérieur (et ne touche JAMAIS les bandes de seal),
    // le seal vertical re-solidifie ses bandes, les passages (tube + landing + support) percent
    // les seals, puis la limite XY gagne sur tout ce qui précède. Ainsi, même un passage placé
    // dans la rampe ou au-delà du rayon ne peut pas ouvrir la coque extérieure. Les éditions joueur
    // restent le dernier post de GetDensityAt, hors de cette pile, comme avant.
    Add(MakeUnique<FOriginSpineOp>(StrateTopWorldZ, StrateBottomWorldZ, SealThickness, BaseDensity, SpineRadius));
    Add(MakeUnique<FBoundarySealOp>(StrateTopWorldZ, StrateBottomWorldZ, SealThickness, BaseDensity));
    Add(MakeUnique<FPassageCarveOp>(StrateManager, BaseDensity, SealThickness,
                                    StrateTopWorldZ, StrateBottomWorldZ, SpineRadius));
    if (bAppendEdgeSeal)
    {
        Add(MakeUnique<FXYEdgeSealOp>(BaseDensity));
    }
}

//=============================================================================
// FABRIQUES / FACTORIES
//=============================================================================

namespace VoxelDensityOps
{
    bool GetStrateOpContract(EVoxelStrateOpClass OpClass, FVoxelStrateOpContract& OutContract)
    {
        const FStrateGenerationParams TunnelParams;
        const FSlabGenerationParams SlabParams;
        const FMazeGenerationParams MazeParams;
        const FSurfaceGenerationParams SurfaceParams;
        const FVerticalShaftParams ShaftParams;
        const FFloatingIslandParams IslandParams;

        TUniquePtr<IVoxelDensityOp> Probe;
        switch (OpClass)
        {
        case EVoxelStrateOpClass::ConstantRockSource:
            Probe = MakeConstantRockSource(TunnelParams.BaseDensity);
            break;
        case EVoxelStrateOpClass::ConstantVoidSource:
            Probe = MakeConstantVoidSource(IslandParams.BaseDensity);
            break;
        case EVoxelStrateOpClass::RoomGraphSource:
            Probe = MakeUnique<FRoomGraphSource>(TunnelParams, 0, nullptr);
            break;
        case EVoxelStrateOpClass::LatticeCorridorSource:
            Probe = MakeUnique<FLatticeCorridorSource>(MazeParams, 0);
            break;
        case EVoxelStrateOpClass::ShaftFieldSource:
            Probe = MakeUnique<FShaftFieldSource>(ShaftParams, 0, 14.0f);
            break;
        case EVoxelStrateOpClass::IslandBlobSource:
            Probe = MakeUnique<FIslandBlobSource>(IslandParams, 0);
            break;
        case EVoxelStrateOpClass::NoiseRibbonSource:
            Probe = MakeUnique<FNoiseRibbonSource>(MazeParams, 0);
            break;
        case EVoxelStrateOpClass::SdfRoughnessMod:
            Probe = MakeSdfRoughnessMod(MazeParams.SurfaceRoughness, 0.12f, 3, 8.0f);
            break;
        case EVoxelStrateOpClass::SdfCarve:
            Probe = MakeSdfCarve(2.0f, TunnelParams.BaseDensity);
            break;
        case EVoxelStrateOpClass::SdfFill:
            Probe = MakeSdfFill(2.0f, IslandParams.BaseDensity);
            break;
        case EVoxelStrateOpClass::GridColumnMod:
            Probe = MakeUnique<FGridColumnMod>(SlabParams, 0);
            break;
        case EVoxelStrateOpClass::CaveRoughnessMod:
            Probe = MakeUnique<FCaveRoughnessMod>(TunnelParams, 0);
            break;
        case EVoxelStrateOpClass::CaveTerraceMod:
            Probe = MakeUnique<FCaveTerraceMod>(TunnelParams, 0, nullptr);
            break;
        case EVoxelStrateOpClass::LayerLineMod:
            Probe = MakeUnique<FLayerLineMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::RibbingMod:
            Probe = MakeUnique<FRibbingMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::CaveOverhangMod:
            Probe = MakeUnique<FCaveOverhangMod>(TunnelParams, 0, nullptr);
            break;
        case EVoxelStrateOpClass::CaveCliffMod:
            Probe = MakeUnique<FCaveCliffMod>(TunnelParams, 0, nullptr);
            break;
        case EVoxelStrateOpClass::ScallopMod:
            Probe = MakeUnique<FScallopMod>(TunnelParams, 0, nullptr);
            break;
        case EVoxelStrateOpClass::CaveArchMod:
            Probe = MakeUnique<FCaveArchMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::RoomColumnMod:
            Probe = MakeUnique<FRoomColumnMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::DomeMod:
            Probe = MakeUnique<FDomeMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::PinchMod:
            Probe = MakeUnique<FPinchMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::FloorBiasMod:
            Probe = MakeUnique<FFloorBiasMod>(TunnelParams, nullptr);
            break;
        case EVoxelStrateOpClass::WormFieldSource:
            Probe = MakeUnique<FWormFieldSource>(TunnelParams, 0);
            break;
        case EVoxelStrateOpClass::ShaftLedgeMod:
            Probe = MakeUnique<FShaftLedgeMod>(ShaftParams, nullptr);
            break;
        case EVoxelStrateOpClass::DensityNoiseCarveMod:
            Probe = MakeUnique<FDensityNoiseMod>(1.0f, 0.02f, 3, 0, false);
            break;
        case EVoxelStrateOpClass::DensityNoiseFillMod:
            Probe = MakeUnique<FDensityNoiseMod>(1.0f, 0.02f, 3, 0, true);
            break;
        default:
            return false;
        }

        if (!Probe)
        {
            return false;
        }

        OutContract.Role = Probe->GetRole();
        OutContract.Reads = Probe->ChannelReads();
        OutContract.Writes = Probe->ChannelWrites();
        OutContract.bAdditive = Probe->IsAdditive();
        OutContract.RequiredResources = Probe->RequiredResources();
        OutContract.ProvidedResources = Probe->ProvidedResources();
        return true;
    }

    TUniquePtr<IVoxelDensityOp> MakeConstantRockSource(float BaseDensity)
    {
        return MakeUnique<FConstantFieldSource>(BaseDensity);
    }

    TUniquePtr<IVoxelDensityOp> MakeConstantVoidSource(float BaseDensity)
    {
        // `Density = -BaseDensity` : on part du vide. La négation unaire est exacte.
        // Start as open air; unary negation is exact.
        return MakeUnique<FConstantFieldSource>(-BaseDensity);
    }

    TUniquePtr<IVoxelDensityOp> MakeLatticeCorridorSource(const FMazeGenerationParams& P, int32 Seed)
    {
        return MakeUnique<FLatticeCorridorSource>(P, Seed);
    }

    TUniquePtr<IVoxelDensityOp> MakeSdfRoughnessMod(float Strength, float Frequency,
                                                    int32 BaseOctaves, float ApplyWithin)
    {
        return MakeUnique<FSdfRoughnessMod>(Strength, Frequency, BaseOctaves, ApplyWithin);
    }

    TUniquePtr<IVoxelDensityOp> MakeSdfCarve(float Blend, float BaseDensity, float MinDivisor)
    {
        return MakeUnique<FSdfConvertOp>(Blend, BaseDensity, -1.0f, MinDivisor);
    }

    TUniquePtr<IVoxelDensityOp> MakeSdfFill(float Blend, float BaseDensity)
    {
        return MakeUnique<FSdfConvertOp>(Blend, BaseDensity, +1.0f, 0.0f);
    }

    TUniquePtr<IVoxelDensityOp> MakeSlabVoidSource(const FSlabGenerationParams& P, int32 Seed)
    {
        return MakeUnique<FSlabVoidSource>(P, Seed);
    }

    TUniquePtr<IVoxelDensityOp> MakeGridColumnMod(const FSlabGenerationParams& P, int32 Seed)
    {
        return MakeUnique<FGridColumnMod>(P, Seed);
    }

    void BuildSurfaceStack(FVoxelOpStack& OutStack, const FSurfaceGenerationParams& P,
                           int32 Seed, float SpineRadius, const UVoxelStrateManager* StrateManager,
                           const TArray<FSurfaceGenerationParams>& PerBiomeParams,
                           TUniquePtr<IVoxelBiomeField> BiomeField,
                           bool bAppendStructuralPosts)
    {
        // ARCHÉTYPE COMPLET : vide + overhang + mélange de biomes.
        // `PerBiomeParams` vide ⇒ chemin sans biomes, strictement inchangé.
        TUniquePtr<FSurfaceColumnSource> ColumnSource =
            MakeUnique<FSurfaceColumnSource>(P, Seed, PerBiomeParams, MoveTemp(BiomeField));
        const FSurfaceColumnSource* ColumnPtr = ColumnSource.Get();
        OutStack.Add(MoveTemp(ColumnSource));

        // L'overhang lit la colonne de la source (mémo partagé, même XY par construction). Même
        // motif que cliff → structural : un modificateur qui a besoin de ce que la source a produit.
        OutStack.Add(MakeUnique<FOverhangShelfMod>(P, Seed, ColumnPtr));

        if (bAppendStructuralPosts)
        {
            OutStack.AppendStructuralPost(P.StrateTopWorldZ, P.StrateBottomWorldZ,
                                          P.BoundarySealThickness, P.BaseDensity,
                                          SpineRadius, StrateManager);
        }
    }

    void BuildSlabStack(FVoxelOpStack& OutStack, const FSlabGenerationParams& P,
                        int32 Seed, float SpineRadius, const UVoxelStrateManager* StrateManager,
                        bool bAppendStructuralPosts)
    {
        // DEUX archétypes entrent ici, aucun branchement ne les distingue : FlatPlain et
        // CrystalChamber ne diffèrent que par leurs valeurs par défaut.
        OutStack.Add(MakeSlabVoidSource(P, Seed));
        OutStack.Add(MakeGridColumnMod(P, Seed));

        if (bAppendStructuralPosts)
        {
            OutStack.AppendStructuralPost(P.StrateTopWorldZ, P.StrateBottomWorldZ,
                                          P.BoundarySealThickness, P.BaseDensity,
                                          SpineRadius, StrateManager);
        }
    }

    void BuildVerticalShaftStack(FVoxelOpStack& OutStack, const FVerticalShaftParams& P,
                                 int32 Seed, float SpineRadius, const UVoxelStrateManager* StrateManager,
                                 bool bAppendStructuralPosts)
    {
        // TROIS des cinq opérateurs ci-dessous sont ceux de Maze, repris tels quels —
        // `ConstantRock`, `SdfRoughness`, `SdfCarve` — avec une source différente (`§2.5`).
        //
        // THREE of the five ops below are Maze's, reused unchanged, with a different source.
        constexpr float CarveBlend = 2.0f;

        TUniquePtr<FShaftFieldSource> ShaftSource =
            MakeUnique<FShaftFieldSource>(P, Seed, SpineRadius);
        const FShaftFieldSource* ShaftPtr = ShaftSource.Get();

        OutStack.Add(MakeConstantRockSource(P.BaseDensity));
        OutStack.Add(MoveTemp(ShaftSource));
        // Fréquence 0.1 et fenêtre `SurfaceRoughness + 4` — PAS celles de Maze
        // (0.12 / `R + rough + 2`). Même opérateur, réglages différents.
        OutStack.Add(MakeSdfRoughnessMod(P.SurfaceRoughness, 0.1f, 3, P.SurfaceRoughness + 4.0f));
        OutStack.Add(MakeSdfCarve(CarveBlend, P.BaseDensity));
        OutStack.Add(MakeUnique<FShaftLedgeMod>(P, ShaftPtr));
        OutStack.Add(MakeUnique<FShaftConnectorAirMod>(ShaftPtr, P.BaseDensity));
        OutStack.Add(MakeUnique<FShaftConnectorFloorMod>(ShaftPtr, P.BaseDensity));

        if (bAppendStructuralPosts)
        {
            OutStack.AppendStructuralPost(P.StrateTopWorldZ, P.StrateBottomWorldZ,
                                          P.BoundarySealThickness, P.BaseDensity,
                                          SpineRadius, StrateManager);
        }
    }

    void BuildTunnelNetworkStack(FVoxelOpStack& OutStack, const FStrateGenerationParams& P,
                                 int32 Seed, float SpineRadius, const UVoxelStrateManager* StrateManager,
                                 bool bAppendStructuralPosts)
    {
        // ⚠️ ÉTAPES A + B + C1 — LA PILE EST COMPLÈTE POUR CET ARCHÉTYPE.
        // Portés : échelle verticale, roc de base, warp, graphe de salles (+ pits + cheminées),
        // carve, LES DOUZE MODIFICATEURS DE DÉTAIL (4b–4h), l'override d'op PAR SALLE, les vers,
        // le post structurel.
        //
        // L'override (C1) n'ajoute AUCUN opérateur : il change ce que ONZE d'entre eux LISENT.
        // `FRoomGraphSource::LocalParams()` publie les params de la strate avec l'op de la salle la
        // plus proche appliqué ; les onze modificateurs concernés y lisent leurs champs au lieu des
        // leurs. La rugosité (4b) NON — dans l'original elle précède la déclaration du shadow.
        //
        //---------------------------------------------------------------------
        // ⚠️ CE PORTAGE RETIRE L'IDÉE DE « FRAME OPS » (OPSTACK-DECOMPOSITION §1)
        //---------------------------------------------------------------------
        // `§2` décrivait deux frames imbriqués : `VerticalScale` et `CaveWarp`. En les portant pour
        // de vrai, les deux se sont dissous :
        //   • `CaveWarp` a une portée d'EXACTEMENT UN opérateur (le graphe de salles — pits et
        //     cheminées lisent explicitement les coordonnées non warpées). Une transformation qui
        //     n'enveloppe qu'un opérateur n'est pas un frame, c'est une variable locale.
        //   • `VerticalScale` est `Z / Scale` : une fonction PURE d'un scalaire et d'un param, que
        //     chaque opérateur qui en a besoin recalcule en une ligne. Un frame ne ferait
        //     qu'ajouter un canal pour éviter une division.
        // Il restait le warp d'îles (§7), déjà gardé local pour la même raison. **Zéro frame sur
        // trois candidats** : ce n'était pas une infrastructure manquante, c'était trois fois la
        // même chose vue de loin.
        constexpr float CarveMinDivisor = 1.0f;   // TunnelNetwork plancher son diviseur, cf. FSdfConvertOp

        // La source de salles est retenue par pointeur non possédant : les terrasses re-interrogent
        // son cache SDF en Z±1. Même motif que `FShaftFieldSource` → `FShaftLedgeMod`.
        TUniquePtr<FRoomGraphSource> RoomSource = MakeUnique<FRoomGraphSource>(
            P, Seed, StrateManager);
        const FRoomGraphSource* RoomPtr = RoomSource.Get();

        OutStack.Add(MakeConstantRockSource(P.BaseDensity));
        OutStack.Add(MoveTemp(RoomSource));
        OutStack.Add(MakeSdfCarve(P.SDFBlendRadius, P.BaseDensity, CarveMinDivisor));
        // ── ÉTAPE B : les modificateurs de détail (4b–4h), chacun gated sur
        //    `Sdf < SDFBlendRadius·3` via VF_NearCaveSurface. Voir la note de l'étape B5 là-bas.
        //    L'ORDRE EST CELUI DE L'ORIGINAL et il compte : chacun lit la densité que le précédent
        //    a laissée (le biais de sol est un ajout indépendant appliqué à cette accumulation).
        if (!VoxelDensityAblation::IsDetailOpsOff())
        {
        OutStack.Add(MakeUnique<FCaveRoughnessMod>(P, Seed));            // 4b
        OutStack.Add(MakeUnique<FCaveTerraceMod>(P, Seed, RoomPtr));     // 4c — terrasses
        OutStack.Add(MakeUnique<FLayerLineMod>(P, RoomPtr));             // 4c — lignes de strates
        OutStack.Add(MakeUnique<FRibbingMod>(P, RoomPtr));               // 4c — nervures
        OutStack.Add(MakeUnique<FCaveOverhangMod>(P, Seed, RoomPtr));    // 4c — surplombs
        OutStack.Add(MakeUnique<FCaveCliffMod>(P, Seed, RoomPtr));       // 4c — falaise
        OutStack.Add(MakeUnique<FScallopMod>(P, Seed, RoomPtr));         // 4c — festons
        OutStack.Add(MakeUnique<FCaveArchMod>(P, RoomPtr));              // 4c — arches
        OutStack.Add(MakeUnique<FRoomColumnMod>(P, RoomPtr));            // 4d — colonnes (pré-cuites)
        OutStack.Add(MakeUnique<FDomeMod>(P, RoomPtr));                  // 4g — dômes
        OutStack.Add(MakeUnique<FPinchMod>(P, RoomPtr));                 // 4h — pincement
        OutStack.Add(MakeUnique<FFloorBiasMod>(P, RoomPtr));             // fin 4h — biais de sol
        }
        if (P.WormStrength > 0.0f && P.WormThreshold > 0.0f)
        {
            OutStack.Add(MakeUnique<FWormFieldSource>(P, Seed));
        }

        if (bAppendStructuralPosts)
        {
            OutStack.AppendStructuralPost(P.StrateTopWorldZ, P.StrateBottomWorldZ,
                                          P.BoundarySealThickness, P.BaseDensity,
                                          SpineRadius, StrateManager, false);
            // The generator's shared MC post evaluates the prepared tunnel-core cache after
            // disturbances. Keeping these pre-disturbance graph scans here duplicated both the
            // support and air queries for every voxel; the feature remains in that shared post.
            OutStack.Add(MakeUnique<FXYEdgeSealOp>(P.BaseDensity));

            // Lower only the canonical native graph.  The old scalar TunnelNetwork evaluator is
            // the fused form of exactly these authored stages: it keeps density/SDF/room state in
            // locals and gates the complete 4b-4h detail suite per sample.  Marking the plan after
            // the final op is important: recipes and composer stacks keep the interpreted/block
            // fallback, even when they happen to contain a similar-looking subset of operators.
            OutStack.SetFusedEvaluator(EVoxelOpFusedEvaluator::TunnelNetwork);
        }
    }

    void BuildFloatingIslandStack(FVoxelOpStack& OutStack, const FFloatingIslandParams& P,
                                  int32 Seed, float SpineRadius, const UVoxelStrateManager* StrateManager,
                                  bool bAppendStructuralPosts)
    {
        // ⚠️ LA PILE QUI S'INVERSE, et c'est la mesure que ce portage-ci ajoute : les quatre autres
        // archétypes partent de ROC et CREUSENT ; celui-ci part du VIDE et REMPLIT. Aucune des deux
        // extrémités n'a demandé un opérateur neuf — la source constante et la conversion SDF→densité
        // sont les MÊMES classes, au signe près (`FConstantFieldSource`, `FSdfConvertOp`). Un
        // opérateur qui se réutilise en s'inversant est une preuve plus forte qu'un opérateur qui se
        // réutilise à l'identique : ça veut dire que l'axe abstrait (le signe de la densité) est le
        // bon, pas seulement que deux archétypes se ressemblaient.
        //
        // The stack that runs BACKWARDS: four archetypes start from rock and carve, this one starts
        // from void and fills — and neither end needed a new operator, only the opposite sign.
        const float BlendK = FMath::Max(P.SDFBlendRadius, 0.01f);

        OutStack.Add(MakeConstantVoidSource(P.BaseDensity));
        OutStack.Add(MakeUnique<FIslandBlobSource>(P, Seed));
        // Fréquence 0.08 et 4 octaves — les constantes de FloatingIslands (Maze 0.12/3,
        // VerticalShafts 0.1/3).
        OutStack.Add(MakeSdfRoughnessMod(P.SurfaceRoughness, 0.08f, 4,
                                         P.SurfaceRoughness + BlendK + 2.0f));
        OutStack.Add(MakeSdfFill(BlendK, P.BaseDensity));

        if (bAppendStructuralPosts)
        {
            OutStack.AppendStructuralPost(P.StrateTopWorldZ, P.StrateBottomWorldZ,
                                          P.BoundarySealThickness, P.BaseDensity,
                                          SpineRadius, StrateManager);
        }
    }

    void BuildMazeStack(FVoxelOpStack& OutStack, const FMazeGenerationParams& P,
                        int32 Seed, float SpineRadius, const UVoxelStrateManager* StrateManager,
                        bool bAppendStructuralPosts)
    {
        // Constantes Maze, codées en dur. / Maze's hard-coded constants.
        constexpr float CarveBlend      = 2.0f;
        constexpr float RoughFrequency  = 0.12f;
        constexpr int32 RoughOctaves    = 3;

        const float R = FMath::Max(P.CorridorRadius, 0.5f);

        // Fenêtre d'application de la rugosité : `MazeSDF < R + SurfaceRoughness + 2.0f`.
        const float RoughApplyWithin = R + P.SurfaceRoughness + 2.0f;

        OutStack.Add(MakeConstantRockSource(P.BaseDensity));
        OutStack.Add(MakeLatticeCorridorSource(P, Seed));
        OutStack.Add(MakeSdfRoughnessMod(P.SurfaceRoughness, RoughFrequency, RoughOctaves, RoughApplyWithin));
        OutStack.Add(MakeSdfCarve(CarveBlend, P.BaseDensity));

        if (bAppendStructuralPosts)
        {
            OutStack.AppendStructuralPost(P.StrateTopWorldZ, P.StrateBottomWorldZ,
                                          P.BoundarySealThickness, P.BaseDensity,
                                          SpineRadius, StrateManager);
        }
    }
}

namespace VoxelStrateRecipePrivate
{
    const FStrateGenerationParams* Tunnel(const FVoxelStrateArchetypeParams& Params)
    {
        return &Params.TunnelNetworkParams;
    }

    const FSlabGenerationParams* Slab(const FVoxelStrateArchetypeParams& Params)
    {
        return &Params.SlabParams;
    }

    const FMazeGenerationParams* Maze(const FVoxelStrateArchetypeParams& Params)
    {
        return &Params.MazeParams;
    }

    const FSurfaceGenerationParams* Surface(const FVoxelStrateArchetypeParams& Params)
    {
        return &Params.SurfaceParams;
    }

    const FVerticalShaftParams* Shaft(const FVoxelStrateArchetypeParams& Params)
    {
        return &Params.VerticalShaftParams;
    }

    const FFloatingIslandParams* Island(const FVoxelStrateArchetypeParams& Params)
    {
        return &Params.FloatingIslandParams;
    }

    float BaseDensity(const FVoxelStrateArchetypeParams& Params, EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork: return Tunnel(Params)->BaseDensity;
        case EVoxelStrateParamBlock::Slab:          return Slab(Params)->BaseDensity;
        case EVoxelStrateParamBlock::Maze:          return Maze(Params)->BaseDensity;
        case EVoxelStrateParamBlock::Surface:       return Surface(Params)->BaseDensity;
        case EVoxelStrateParamBlock::VerticalShaft: return Shaft(Params)->BaseDensity;
        case EVoxelStrateParamBlock::FloatingIsland: return Island(Params)->BaseDensity;
        default:                                    return 8.0f;
        }
    }

    float BoundarySeal(const FVoxelStrateArchetypeParams& Params, EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork: return Tunnel(Params)->BoundarySealThickness;
        case EVoxelStrateParamBlock::Slab:          return Slab(Params)->BoundarySealThickness;
        case EVoxelStrateParamBlock::Maze:          return Maze(Params)->BoundarySealThickness;
        case EVoxelStrateParamBlock::Surface:       return Surface(Params)->BoundarySealThickness;
        case EVoxelStrateParamBlock::VerticalShaft: return Shaft(Params)->BoundarySealThickness;
        case EVoxelStrateParamBlock::FloatingIsland: return Island(Params)->BoundarySealThickness;
        default:                                    return 4.0f;
        }
    }

    float Top(const FVoxelStrateArchetypeParams& Params, EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork: return Tunnel(Params)->StrateTopWorldZ;
        case EVoxelStrateParamBlock::Slab:          return Slab(Params)->StrateTopWorldZ;
        case EVoxelStrateParamBlock::Maze:          return Maze(Params)->StrateTopWorldZ;
        case EVoxelStrateParamBlock::Surface:       return Surface(Params)->StrateTopWorldZ;
        case EVoxelStrateParamBlock::VerticalShaft: return Shaft(Params)->StrateTopWorldZ;
        case EVoxelStrateParamBlock::FloatingIsland: return Island(Params)->StrateTopWorldZ;
        default:                                    return 0.0f;
        }
    }

    float Bottom(const FVoxelStrateArchetypeParams& Params, EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork: return Tunnel(Params)->StrateBottomWorldZ;
        case EVoxelStrateParamBlock::Slab:          return Slab(Params)->StrateBottomWorldZ;
        case EVoxelStrateParamBlock::Maze:          return Maze(Params)->StrateBottomWorldZ;
        case EVoxelStrateParamBlock::Surface:       return Surface(Params)->StrateBottomWorldZ;
        case EVoxelStrateParamBlock::VerticalShaft: return Shaft(Params)->StrateBottomWorldZ;
        case EVoxelStrateParamBlock::FloatingIsland: return Island(Params)->StrateBottomWorldZ;
        default:                                    return 0.0f;
        }
    }

    EVoxelStrateParamBlock ShapeBlock(EVoxelStrateOpClass OpClass)
    {
        switch (OpClass)
        {
        case EVoxelStrateOpClass::RoomGraphSource:     return EVoxelStrateParamBlock::TunnelNetwork;
        case EVoxelStrateOpClass::LatticeCorridorSource:
        case EVoxelStrateOpClass::NoiseRibbonSource:   return EVoxelStrateParamBlock::Maze;
        case EVoxelStrateOpClass::ShaftFieldSource:    return EVoxelStrateParamBlock::VerticalShaft;
        case EVoxelStrateOpClass::IslandBlobSource:    return EVoxelStrateParamBlock::FloatingIsland;
        default:                                       return EVoxelStrateParamBlock::None;
        }
    }

    EVoxelStrateParamBlock FixedParamBlock(EVoxelStrateOpClass OpClass)
    {
        switch (OpClass)
        {
        case EVoxelStrateOpClass::GridColumnMod:
            return EVoxelStrateParamBlock::Slab;
        case EVoxelStrateOpClass::CaveRoughnessMod:
        case EVoxelStrateOpClass::CaveTerraceMod:
        case EVoxelStrateOpClass::LayerLineMod:
        case EVoxelStrateOpClass::RibbingMod:
        case EVoxelStrateOpClass::CaveOverhangMod:
        case EVoxelStrateOpClass::CaveCliffMod:
        case EVoxelStrateOpClass::ScallopMod:
        case EVoxelStrateOpClass::CaveArchMod:
        case EVoxelStrateOpClass::RoomColumnMod:
        case EVoxelStrateOpClass::DomeMod:
        case EVoxelStrateOpClass::PinchMod:
        case EVoxelStrateOpClass::FloorBiasMod:
        case EVoxelStrateOpClass::WormFieldSource:
            return EVoxelStrateParamBlock::TunnelNetwork;
        case EVoxelStrateOpClass::ShaftLedgeMod:
            return EVoxelStrateParamBlock::VerticalShaft;
        default:
            return EVoxelStrateParamBlock::None;
        }
    }

    float SdfBlend(const FVoxelStrateArchetypeParams& Params, EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork:
            return Params.TunnelNetworkParams.SDFBlendRadius;
        case EVoxelStrateParamBlock::Maze:
            return 2.0f;
        case EVoxelStrateParamBlock::VerticalShaft:
            return 2.0f;
        case EVoxelStrateParamBlock::FloatingIsland:
            return FMath::Max(Params.FloatingIslandParams.SDFBlendRadius, 0.01f);
        default:
            return 2.0f;
        }
    }

    float SdfRoughnessStrength(const FVoxelStrateArchetypeParams& Params,
                               EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork: return Params.TunnelNetworkParams.SurfaceRoughness;
        case EVoxelStrateParamBlock::Maze:          return Params.MazeParams.SurfaceRoughness;
        case EVoxelStrateParamBlock::VerticalShaft: return Params.VerticalShaftParams.SurfaceRoughness;
        case EVoxelStrateParamBlock::FloatingIsland: return Params.FloatingIslandParams.SurfaceRoughness;
        default:                                    return 2.0f;
        }
    }

    float SdfRoughnessFrequency(const FVoxelStrateArchetypeParams& Params,
                                EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork: return Params.TunnelNetworkParams.RoughnessFrequency;
        case EVoxelStrateParamBlock::Maze:          return 0.12f;
        case EVoxelStrateParamBlock::VerticalShaft: return 0.1f;
        case EVoxelStrateParamBlock::FloatingIsland: return 0.08f;
        default:                                    return 0.1f;
        }
    }

    int32 SdfRoughnessOctaves(EVoxelStrateParamBlock Block)
    {
        return Block == EVoxelStrateParamBlock::FloatingIsland ? 4 : 3;
    }

    float SdfRoughnessWindow(const FVoxelStrateArchetypeParams& Params,
                             EVoxelStrateParamBlock Block)
    {
        const float Strength = SdfRoughnessStrength(Params, Block);
        switch (Block)
        {
        case EVoxelStrateParamBlock::TunnelNetwork:
            return Params.TunnelNetworkParams.SDFBlendRadius * 3.0f + Strength + 2.0f;
        case EVoxelStrateParamBlock::Maze:
            return FMath::Max(Params.MazeParams.CorridorRadius, 0.5f) + Strength + 2.0f;
        case EVoxelStrateParamBlock::VerticalShaft:
            return Strength + 4.0f;
        case EVoxelStrateParamBlock::FloatingIsland:
            return Strength + SdfBlend(Params, Block) + 2.0f;
        default:
            return Strength + 4.0f;
        }
    }

    float GenericStrength(const FVoxelStrateArchetypeParams& Params,
                           EVoxelStrateParamBlock Block)
    {
        return FMath::Max(0.25f, 0.35f * FMath::Abs(BaseDensity(Params, Block)));
    }

    float GenericFrequency(const FVoxelStrateArchetypeParams& Params,
                           EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::Maze:
            return 1.0f / FMath::Max(Params.MazeParams.CellSize, 8.0f);
        case EVoxelStrateParamBlock::VerticalShaft:
            return 0.01f;
        case EVoxelStrateParamBlock::FloatingIsland:
            return 0.02f;
        case EVoxelStrateParamBlock::TunnelNetwork:
            return FMath::Max(Params.TunnelNetworkParams.RoughnessFrequency, 0.001f);
        default:
            return 0.02f;
        }
    }

    bool IsShapeSource(EVoxelStrateOpClass OpClass)
    {
        switch (OpClass)
        {
        case EVoxelStrateOpClass::RoomGraphSource:
        case EVoxelStrateOpClass::LatticeCorridorSource:
        case EVoxelStrateOpClass::ShaftFieldSource:
        case EVoxelStrateOpClass::IslandBlobSource:
        case EVoxelStrateOpClass::NoiseRibbonSource:
            return true;
        default:
            return false;
        }
    }

    bool ValidateRecipeContracts(const FVoxelOpStackRecipe& Recipe, FString& OutError)
    {
        TArray<EVoxelStrateOpClass> Classes;
        Classes.Reserve(3 + Recipe.Modifiers.Num());
        Classes.Add(Recipe.Root.OpClass);
        Classes.Add(Recipe.ShapeSource.OpClass);
        Classes.Add(Recipe.Conversion.OpClass);
        for (const FVoxelOpRecipeEntry& Entry : Recipe.Modifiers)
        {
            Classes.Add(Entry.OpClass);
        }

        auto ValidateParamBlock = [&](const FVoxelOpRecipeEntry& Entry, int32 EntryIndex)
        {
            if (Entry.ParamBlock == EVoxelStrateParamBlock::None)
            {
                OutError = FString::Printf(TEXT("recipe op %d has no parameter block"), EntryIndex);
                return false;
            }
            const EVoxelStrateParamBlock Fixed = FixedParamBlock(Entry.OpClass);
            if (Fixed != EVoxelStrateParamBlock::None && Entry.ParamBlock != Fixed)
            {
                OutError = FString::Printf(TEXT("recipe op %d uses the wrong parameter block"), EntryIndex);
                return false;
            }
            return true;
        };
        if (!ValidateParamBlock(Recipe.Root, 0)
            || !ValidateParamBlock(Recipe.ShapeSource, 1)
            || !ValidateParamBlock(Recipe.Conversion, 2))
        {
            return false;
        }
        for (int32 ModifierIndex = 0; ModifierIndex < Recipe.Modifiers.Num(); ++ModifierIndex)
        {
            if (!ValidateParamBlock(Recipe.Modifiers[ModifierIndex], 3 + ModifierIndex))
            {
                return false;
            }
        }

        int32 LastWriter[2] = { INDEX_NONE, INDEX_NONE };
        EVoxelOpResourceMask AvailableResources = VoxelOpResources::None;
        const EVoxelOpChannelMask Channels[] = { VoxelOpChannels::Density, VoxelOpChannels::Sdf };
        auto ChannelIndex = [](EVoxelOpChannelMask Channel) { return Channel == VoxelOpChannels::Density ? 0 : 1; };

        for (int32 Index = 0; Index < Classes.Num(); ++Index)
        {
            FVoxelStrateOpContract Contract;
            if (!VoxelDensityOps::GetStrateOpContract(Classes[Index], Contract))
            {
                OutError = FString::Printf(TEXT("recipe op %d has no declaration"), Index);
                return false;
            }
            if ((Contract.Reads & VoxelOpChannels::All) != Contract.Reads
                || (Contract.Writes & VoxelOpChannels::All) != Contract.Writes
                || (Contract.RequiredResources & VoxelOpResources::All) != Contract.RequiredResources
                || (Contract.ProvidedResources & VoxelOpResources::All) != Contract.ProvidedResources)
            {
                OutError = FString::Printf(TEXT("recipe op %d has an unknown declaration bit"), Index);
                return false;
            }
            if ((Contract.RequiredResources
                 & static_cast<EVoxelOpResourceMask>(~AvailableResources)) != 0)
            {
                OutError = FString::Printf(TEXT("recipe op %d requires unavailable state"), Index);
                return false;
            }
            if (Contract.bAdditive && Contract.Writes == VoxelOpChannels::None)
            {
                OutError = FString::Printf(TEXT("recipe op %d is additive but writes no channel"), Index);
                return false;
            }
            if (Contract.bAdditive
                && (Contract.Writes & static_cast<EVoxelOpChannelMask>(~Contract.Reads)) != 0)
            {
                OutError = FString::Printf(TEXT("recipe op %d is additive without reading its writes"), Index);
                return false;
            }
            for (const EVoxelOpChannelMask Channel : Channels)
            {
                if ((Contract.Reads & Channel) == 0) { continue; }
                const int32 CI = ChannelIndex(Channel);
                const bool bRootIdentity = Contract.Role == EVoxelOpRole::FieldSource
                    && (Contract.Writes & Channel) != 0 && LastWriter[CI] == INDEX_NONE;
                if (LastWriter[CI] == INDEX_NONE && !bRootIdentity)
                {
                    OutError = FString::Printf(TEXT("recipe op %d reads an unpublished channel"), Index);
                    return false;
                }
            }
            for (const EVoxelOpChannelMask Channel : Channels)
            {
                if ((Contract.Writes & Channel) == 0 || (Contract.Reads & Channel) != 0) { continue; }
                if (LastWriter[ChannelIndex(Channel)] != INDEX_NONE)
                {
                    OutError = FString::Printf(TEXT("recipe op %d clobbers a channel"), Index);
                    return false;
                }
            }
            for (const EVoxelOpChannelMask Channel : Channels)
            {
                if ((Contract.Writes & Channel) != 0)
                {
                    LastWriter[ChannelIndex(Channel)] = Index;
                }
            }
            AvailableResources |= Contract.ProvidedResources;
        }
        return true;
    }

    TUniquePtr<IVoxelDensityOp> BuildRecipeOp(const FVoxelOpRecipeEntry& Entry,
                                              const FVoxelStrateArchetypeParams& Params,
                                              int32 Seed,
                                              float SpineRadius,
                                              const UVoxelStrateManager* StrateManager,
                                              const FRoomGraphSource*& OutRoom,
                                              const FShaftFieldSource*& OutShaft)
    {
        const EVoxelStrateParamBlock Block = Entry.ParamBlock;
        switch (Entry.OpClass)
        {
        case EVoxelStrateOpClass::ConstantRockSource:
            return VoxelDensityOps::MakeConstantRockSource(BaseDensity(Params, Block));
        case EVoxelStrateOpClass::ConstantVoidSource:
            return VoxelDensityOps::MakeConstantVoidSource(BaseDensity(Params, Block));
        case EVoxelStrateOpClass::RoomGraphSource:
        {
            TUniquePtr<FRoomGraphSource> Op = MakeUnique<FRoomGraphSource>(*Tunnel(Params), Seed, StrateManager);
            OutRoom = Op.Get();
            return Op;
        }
        case EVoxelStrateOpClass::LatticeCorridorSource:
            return MakeUnique<FLatticeCorridorSource>(*Maze(Params), Seed);
        case EVoxelStrateOpClass::ShaftFieldSource:
        {
            TUniquePtr<FShaftFieldSource> Op = MakeUnique<FShaftFieldSource>(*Shaft(Params), Seed, SpineRadius);
            OutShaft = Op.Get();
            return Op;
        }
        case EVoxelStrateOpClass::IslandBlobSource:
            return MakeUnique<FIslandBlobSource>(*Island(Params), Seed);
        case EVoxelStrateOpClass::NoiseRibbonSource:
            return MakeUnique<FNoiseRibbonSource>(*Maze(Params), Seed);
        case EVoxelStrateOpClass::SdfRoughnessMod:
            return VoxelDensityOps::MakeSdfRoughnessMod(
                SdfRoughnessStrength(Params, Block),
                SdfRoughnessFrequency(Params, Block),
                SdfRoughnessOctaves(Block),
                SdfRoughnessWindow(Params, Block));
        case EVoxelStrateOpClass::SdfCarve:
            return VoxelDensityOps::MakeSdfCarve(SdfBlend(Params, Block), BaseDensity(Params, Block));
        case EVoxelStrateOpClass::SdfFill:
            return VoxelDensityOps::MakeSdfFill(SdfBlend(Params, Block), BaseDensity(Params, Block));
        case EVoxelStrateOpClass::GridColumnMod:
            return MakeUnique<FGridColumnMod>(*Slab(Params), Seed);
        case EVoxelStrateOpClass::CaveRoughnessMod:
            return MakeUnique<FCaveRoughnessMod>(*Tunnel(Params), Seed);
        case EVoxelStrateOpClass::CaveTerraceMod:
            return MakeUnique<FCaveTerraceMod>(*Tunnel(Params), Seed, OutRoom);
        case EVoxelStrateOpClass::LayerLineMod:
            return MakeUnique<FLayerLineMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::RibbingMod:
            return MakeUnique<FRibbingMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::CaveOverhangMod:
            return MakeUnique<FCaveOverhangMod>(*Tunnel(Params), Seed, OutRoom);
        case EVoxelStrateOpClass::CaveCliffMod:
            return MakeUnique<FCaveCliffMod>(*Tunnel(Params), Seed, OutRoom);
        case EVoxelStrateOpClass::ScallopMod:
            return MakeUnique<FScallopMod>(*Tunnel(Params), Seed, OutRoom);
        case EVoxelStrateOpClass::CaveArchMod:
            return MakeUnique<FCaveArchMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::RoomColumnMod:
            return MakeUnique<FRoomColumnMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::DomeMod:
            return MakeUnique<FDomeMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::PinchMod:
            return MakeUnique<FPinchMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::FloorBiasMod:
            return MakeUnique<FFloorBiasMod>(*Tunnel(Params), OutRoom);
        case EVoxelStrateOpClass::WormFieldSource:
            return MakeUnique<FWormFieldSource>(*Tunnel(Params), Seed);
        case EVoxelStrateOpClass::ShaftLedgeMod:
            return MakeUnique<FShaftLedgeMod>(*Shaft(Params), OutShaft);
        case EVoxelStrateOpClass::DensityNoiseCarveMod:
            return MakeUnique<FDensityNoiseMod>(GenericStrength(Params, Block),
                                                GenericFrequency(Params, Block), 3, Seed, false);
        case EVoxelStrateOpClass::DensityNoiseFillMod:
            return MakeUnique<FDensityNoiseMod>(GenericStrength(Params, Block),
                                                GenericFrequency(Params, Block), 3, Seed, true);
        default:
            return nullptr;
        }
    }
}

bool VF_BuildStackFromRecipe(const FVoxelOpStackRecipe& Recipe,
                             const FVoxelStrateArchetypeParams& Params,
                             int32 Seed, float SpineRadius,
                             const UVoxelStrateManager* StrateManager,
                             FVoxelOpStack& OutStack,
                             FVoxelOpContext& OutContext,
                             FString* OutError,
                             bool bAppendStructuralPosts)
{
    auto Fail = [&](const FString& Reason) -> bool
    {
        if (OutError != nullptr) { *OutError = Reason; }
        return false;
    };
    if (OutError != nullptr) { OutError->Reset(); }

    if (Recipe.Modifiers.Num() < 4 || Recipe.Modifiers.Num() > 8)
    {
        return Fail(TEXT("A structure recipe must draw between 4 and 8 modifiers."));
    }
    const EVoxelStrateOpClass ExpectedRoot = Recipe.RootPolarity == EVoxelStrateRootPolarity::VoidFill
        ? EVoxelStrateOpClass::ConstantVoidSource : EVoxelStrateOpClass::ConstantRockSource;
    const EVoxelStrateOpClass ExpectedConversion = Recipe.RootPolarity == EVoxelStrateRootPolarity::VoidFill
        ? EVoxelStrateOpClass::SdfFill : EVoxelStrateOpClass::SdfCarve;
    if (Recipe.Root.OpClass != ExpectedRoot || Recipe.Conversion.OpClass != ExpectedConversion)
    {
        return Fail(TEXT("Recipe polarity does not match its root/conversion ids."));
    }
    if (!VoxelStrateRecipePrivate::IsShapeSource(Recipe.ShapeSource.OpClass))
    {
        return Fail(TEXT("Recipe shape source is not a rollable SDF source."));
    }
    const EVoxelStrateParamBlock ShapeBlock =
        VoxelStrateRecipePrivate::ShapeBlock(Recipe.ShapeSource.OpClass);
    if (ShapeBlock == EVoxelStrateParamBlock::None
        || Recipe.StructuralParamBlock != ShapeBlock
        || Recipe.Root.ParamBlock == EVoxelStrateParamBlock::None
        || Recipe.ShapeSource.ParamBlock != ShapeBlock
        || Recipe.Conversion.ParamBlock != ShapeBlock)
    {
        return Fail(TEXT("Recipe parameter blocks do not match its shape source."));
    }

    FString ContractError;
    if (!VoxelStrateRecipePrivate::ValidateRecipeContracts(Recipe, ContractError))
    {
        return Fail(ContractError);
    }

    FVoxelOpStack Candidate;
    const FRoomGraphSource* RoomPtr = nullptr;
    const FShaftFieldSource* ShaftPtr = nullptr;

    FVoxelOpRecipeEntry Root = Recipe.Root;
    TUniquePtr<IVoxelDensityOp> RootOp =
        VoxelStrateRecipePrivate::BuildRecipeOp(Root, Params, Seed, SpineRadius, StrateManager, RoomPtr, ShaftPtr);
    if (!RootOp) { return Fail(TEXT("Recipe root could not be materialised.")); }
    Candidate.Add(MoveTemp(RootOp));

    TUniquePtr<IVoxelDensityOp> ShapeOp =
        VoxelStrateRecipePrivate::BuildRecipeOp(Recipe.ShapeSource, Params, Seed, SpineRadius,
                                                StrateManager, RoomPtr, ShaftPtr);
    if (!ShapeOp) { return Fail(TEXT("Recipe shape source could not be materialised.")); }
    Candidate.Add(MoveTemp(ShapeOp));

    TUniquePtr<IVoxelDensityOp> ConversionOp =
        VoxelStrateRecipePrivate::BuildRecipeOp(Recipe.Conversion, Params, Seed, SpineRadius,
                                                StrateManager, RoomPtr, ShaftPtr);
    if (!ConversionOp) { return Fail(TEXT("Recipe conversion could not be materialised.")); }
    Candidate.Add(MoveTemp(ConversionOp));

    for (const FVoxelOpRecipeEntry& Entry : Recipe.Modifiers)
    {
        if (Entry.OpClass == EVoxelStrateOpClass::WormFieldSource
            && !(Params.TunnelNetworkParams.WormStrength > 0.0f
                 && Params.TunnelNetworkParams.WormThreshold > 0.0f))
        {
            // A disabled strate has no worm operator at all. This makes the off switch cheap on
            // the interpreted path as well as exact in its interval/classifier fold.
            continue;
        }
        TUniquePtr<IVoxelDensityOp> Modifier =
            VoxelStrateRecipePrivate::BuildRecipeOp(Entry, Params, Seed, SpineRadius,
                                                    StrateManager, RoomPtr, ShaftPtr);
        if (!Modifier)
        {
            return Fail(TEXT("Recipe modifier could not be materialised."));
        }
        Candidate.Add(MoveTemp(Modifier));
    }

    const float Top = VoxelStrateRecipePrivate::Top(Params, Recipe.StructuralParamBlock);
    const float Bottom = VoxelStrateRecipePrivate::Bottom(Params, Recipe.StructuralParamBlock);
    const float Seal = VoxelStrateRecipePrivate::BoundarySeal(Params, Recipe.StructuralParamBlock);
    const float Base = VoxelStrateRecipePrivate::BaseDensity(Params, Recipe.StructuralParamBlock);
    if (!VoxelMath::IsFinite(Top) || !VoxelMath::IsFinite(Bottom) || Top <= Bottom
        || !VoxelMath::IsFinite(Seal) || !VoxelMath::IsFinite(Base))
    {
        return Fail(TEXT("Recipe structural parameters do not define a finite positive strate."));
    }

    OutContext = FVoxelOpContext();
    OutContext.Seed = Seed;
    OutContext.LayoutVersion = StrateManager != nullptr ? StrateManager->GetLayoutVersion() : 0;
    OutContext.WorldRadiusVoxels = 0.0f;
    OutContext.EdgeSealThickness = Seal;
    OutContext.StrateTopWorldZ = Top;
    OutContext.StrateBottomWorldZ = Bottom;

    // This is the only place a recipe can acquire world-law operators. There is no recipe field
    // for posts, so a serialised manifest cannot forget them or reorder them. Lateral callers
    // materialise this same creative recipe with posts disabled, then append the global post set
    // to the parent stack below.
    if (bAppendStructuralPosts)
    {
        Candidate.AppendStructuralPost(Top, Bottom, Seal, Base, SpineRadius, StrateManager);
    }

    FString ValidationError;
    if (!Candidate.ValidateChannelOrder(&ValidationError))
    {
        return Fail(FString::Printf(TEXT("Materialised recipe failed ValidateChannelOrder: %s"),
                                    *ValidationError));
    }

    OutStack = MoveTemp(Candidate);
    return true;
}

#if WITH_EDITOR
namespace
{
    static EVoxelStrateParamBlock VF_RegionParamBlock(ECaveGeneratorType Archetype)
    {
        switch (Archetype)
        {
        case ECaveGeneratorType::FlatPlain:
        case ECaveGeneratorType::CrystalChamber: return EVoxelStrateParamBlock::Slab;
        case ECaveGeneratorType::Maze:            return EVoxelStrateParamBlock::Maze;
        case ECaveGeneratorType::SurfaceWorld:   return EVoxelStrateParamBlock::Surface;
        case ECaveGeneratorType::VerticalShafts: return EVoxelStrateParamBlock::VerticalShaft;
        case ECaveGeneratorType::FloatingIslands:return EVoxelStrateParamBlock::FloatingIsland;
        case ECaveGeneratorType::Underwater:
        case ECaveGeneratorType::TunnelNetwork:
        default:                                  return EVoxelStrateParamBlock::TunnelNetwork;
        }
    }

    static float VF_RegionTop(const FVoxelStrateArchetypeParams& Params,
                              EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::Slab:           return Params.SlabParams.StrateTopWorldZ;
        case EVoxelStrateParamBlock::Maze:           return Params.MazeParams.StrateTopWorldZ;
        case EVoxelStrateParamBlock::Surface:        return Params.SurfaceParams.StrateTopWorldZ;
        case EVoxelStrateParamBlock::VerticalShaft:  return Params.VerticalShaftParams.StrateTopWorldZ;
        case EVoxelStrateParamBlock::FloatingIsland: return Params.FloatingIslandParams.StrateTopWorldZ;
        case EVoxelStrateParamBlock::TunnelNetwork:
        default:                                     return Params.TunnelNetworkParams.StrateTopWorldZ;
        }
    }

    static float VF_RegionBottom(const FVoxelStrateArchetypeParams& Params,
                                 EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::Slab:           return Params.SlabParams.StrateBottomWorldZ;
        case EVoxelStrateParamBlock::Maze:           return Params.MazeParams.StrateBottomWorldZ;
        case EVoxelStrateParamBlock::Surface:        return Params.SurfaceParams.StrateBottomWorldZ;
        case EVoxelStrateParamBlock::VerticalShaft:  return Params.VerticalShaftParams.StrateBottomWorldZ;
        case EVoxelStrateParamBlock::FloatingIsland: return Params.FloatingIslandParams.StrateBottomWorldZ;
        case EVoxelStrateParamBlock::TunnelNetwork:
        default:                                     return Params.TunnelNetworkParams.StrateBottomWorldZ;
        }
    }

    static float VF_RegionSeal(const FVoxelStrateArchetypeParams& Params,
                               EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::Slab:           return Params.SlabParams.BoundarySealThickness;
        case EVoxelStrateParamBlock::Maze:           return Params.MazeParams.BoundarySealThickness;
        case EVoxelStrateParamBlock::Surface:        return Params.SurfaceParams.BoundarySealThickness;
        case EVoxelStrateParamBlock::VerticalShaft:  return Params.VerticalShaftParams.BoundarySealThickness;
        case EVoxelStrateParamBlock::FloatingIsland: return Params.FloatingIslandParams.BoundarySealThickness;
        case EVoxelStrateParamBlock::TunnelNetwork:
        default:                                     return Params.TunnelNetworkParams.BoundarySealThickness;
        }
    }

    static float VF_RegionBase(const FVoxelStrateArchetypeParams& Params,
                               EVoxelStrateParamBlock Block)
    {
        switch (Block)
        {
        case EVoxelStrateParamBlock::Slab:           return Params.SlabParams.BaseDensity;
        case EVoxelStrateParamBlock::Maze:           return Params.MazeParams.BaseDensity;
        case EVoxelStrateParamBlock::Surface:        return Params.SurfaceParams.BaseDensity;
        case EVoxelStrateParamBlock::VerticalShaft:  return Params.VerticalShaftParams.BaseDensity;
        case EVoxelStrateParamBlock::FloatingIsland: return Params.FloatingIslandParams.BaseDensity;
        case EVoxelStrateParamBlock::TunnelNetwork:
        default:                                     return Params.TunnelNetworkParams.BaseDensity;
        }
    }

    static bool VF_BuildNativeRegionCore(
        const FVoxelStrateRegion& Region,
        const FVoxelStrateArchetypeParams& Params,
        float SpineRadius,
        const UVoxelStrateManager* StrateManager,
        bool bAppendStructuralPosts,
        FVoxelOpStack& OutStack,
        FVoxelOpContext& OutContext)
    {
        switch (Region.Archetype)
        {
        case ECaveGeneratorType::FlatPlain:
        case ECaveGeneratorType::CrystalChamber:
            if (Params.SlabParams.StrateTopWorldZ - Params.SlabParams.StrateBottomWorldZ <= 0.0f)
            {
                return false;
            }
            OutContext.StrateTopWorldZ = Params.SlabParams.StrateTopWorldZ;
            OutContext.StrateBottomWorldZ = Params.SlabParams.StrateBottomWorldZ;
            VoxelDensityOps::BuildSlabStack(OutStack, Params.SlabParams, Region.Seed,
                                            SpineRadius, StrateManager, bAppendStructuralPosts);
            return true;
        case ECaveGeneratorType::Maze:
            if (Params.MazeParams.StrateTopWorldZ - Params.MazeParams.StrateBottomWorldZ <= 0.0f)
            {
                return false;
            }
            OutContext.StrateTopWorldZ = Params.MazeParams.StrateTopWorldZ;
            OutContext.StrateBottomWorldZ = Params.MazeParams.StrateBottomWorldZ;
            VoxelDensityOps::BuildMazeStack(OutStack, Params.MazeParams, Region.Seed,
                                            SpineRadius, StrateManager, bAppendStructuralPosts);
            return true;
        case ECaveGeneratorType::SurfaceWorld:
            if (Params.SurfaceParams.StrateTopWorldZ - Params.SurfaceParams.StrateBottomWorldZ <= 0.0f)
            {
                return false;
            }
            OutContext.StrateTopWorldZ = Params.SurfaceParams.StrateTopWorldZ;
            OutContext.StrateBottomWorldZ = Params.SurfaceParams.StrateBottomWorldZ;
            VoxelDensityOps::BuildSurfaceStack(
                OutStack, Params.SurfaceParams, Region.Seed, SpineRadius, StrateManager,
                TArray<FSurfaceGenerationParams>(), nullptr, bAppendStructuralPosts);
            return true;
        case ECaveGeneratorType::VerticalShafts:
            if (Params.VerticalShaftParams.StrateTopWorldZ
                - Params.VerticalShaftParams.StrateBottomWorldZ <= 0.0f)
            {
                return false;
            }
            OutContext.StrateTopWorldZ = Params.VerticalShaftParams.StrateTopWorldZ;
            OutContext.StrateBottomWorldZ = Params.VerticalShaftParams.StrateBottomWorldZ;
            VoxelDensityOps::BuildVerticalShaftStack(
                OutStack, Params.VerticalShaftParams, Region.Seed,
                SpineRadius, StrateManager, bAppendStructuralPosts);
            return true;
        case ECaveGeneratorType::FloatingIslands:
            if (Params.FloatingIslandParams.StrateTopWorldZ
                - Params.FloatingIslandParams.StrateBottomWorldZ <= 0.0f)
            {
                return false;
            }
            OutContext.StrateTopWorldZ = Params.FloatingIslandParams.StrateTopWorldZ;
            OutContext.StrateBottomWorldZ = Params.FloatingIslandParams.StrateBottomWorldZ;
            VoxelDensityOps::BuildFloatingIslandStack(
                OutStack, Params.FloatingIslandParams, Region.Seed,
                SpineRadius, StrateManager, bAppendStructuralPosts);
            return true;
        case ECaveGeneratorType::Underwater:
        case ECaveGeneratorType::TunnelNetwork:
            OutContext.StrateTopWorldZ = Params.TunnelNetworkParams.StrateTopWorldZ;
            OutContext.StrateBottomWorldZ = Params.TunnelNetworkParams.StrateBottomWorldZ;
            VoxelDensityOps::BuildTunnelNetworkStack(
                OutStack, Params.TunnelNetworkParams, Region.Seed,
                SpineRadius, StrateManager, bAppendStructuralPosts);
            return true;
        default:
            return false;
        }
    }
}

bool VF_BuildStrateRegionStack(
    const FVoxelStrateRegionManifest& Manifest,
    float SpineRadius,
    const UVoxelStrateManager* StrateManager,
    FVoxelOpStack& OutStack,
    FVoxelOpContext& OutContext,
    FString* OutError)
{
    auto Fail = [&](const FString& Reason) -> bool
    {
        if (OutError != nullptr) { *OutError = Reason; }
        return false;
    };
    if (OutError != nullptr) { OutError->Reset(); }
    if (!Manifest.IsValid())
    {
        return Fail(Manifest.FailureReason.IsEmpty()
            ? TEXT("lateral region manifest is invalid") : Manifest.FailureReason);
    }
    if (Manifest.PartitionSeed != VF_GetStrateRegionPartitionSeed(
            Manifest.Seed, Manifest.StrateIndex))
    {
        return Fail(TEXT("lateral region partition seed is stale for its seed/strate index"));
    }

    EVoxelStrateParamBlock GlobalBlock = Manifest.StructuralParamBlock;
    if (GlobalBlock == EVoxelStrateParamBlock::None)
    {
        GlobalBlock = Manifest.Regions[0].bUsesRecipe
            ? Manifest.Regions[0].Recipe.StructuralParamBlock
            : VF_RegionParamBlock(Manifest.Regions[0].Archetype);
    }

    FVoxelStrateArchetypeParams FirstParams = Manifest.Regions[0].ArchetypeParams;
    float Top = Manifest.bHasGlobalStructuralParams
        ? Manifest.StrateTopWorldZ : VF_RegionTop(FirstParams, GlobalBlock);
    float Bottom = Manifest.bHasGlobalStructuralParams
        ? Manifest.StrateBottomWorldZ : VF_RegionBottom(FirstParams, GlobalBlock);
    float Seal = Manifest.bHasGlobalStructuralParams
        ? Manifest.BoundarySealThickness : VF_RegionSeal(FirstParams, GlobalBlock);
    float Base = Manifest.bHasGlobalStructuralParams
        ? Manifest.BaseDensity : VF_RegionBase(FirstParams, GlobalBlock);
    if (!VoxelMath::IsFinite(Top) || !VoxelMath::IsFinite(Bottom) || !(Top > Bottom)
        || !VoxelMath::IsFinite(Seal) || Seal < 0.0f
        || !VoxelMath::IsFinite(Base) || !(Base > 0.0f))
    {
        return Fail(TEXT("lateral region structural parameters are not a finite positive strate"));
    }

    auto MakeRegionParams = [&](const FVoxelStrateRegion& Region)
    {
        FVoxelStrateArchetypeParams Params = Region.ArchetypeParams;
        VF_SetStrateArchetypeRuntimeBounds(Params, Top, Bottom);
        return Params;
    };

    // The one-region form remains a normal stack.  It is useful to callers that consume a region
    // manifest, while production keeps its old branch entirely untouched for the hard identity
    // gate.
    if (Manifest.RegionCount == 1)
    {
        const FVoxelStrateRegion& Region = Manifest.Regions[0];
        const FVoxelStrateArchetypeParams Params = MakeRegionParams(Region);
        bool bBuilt = false;
        if (Region.bUsesRecipe)
        {
            bBuilt = VF_BuildStackFromRecipe(Region.Recipe, Params, Region.Seed,
                                              SpineRadius, StrateManager, OutStack,
                                              OutContext, OutError, true);
        }
        else
        {
            OutContext = FVoxelOpContext();
            OutContext.Seed = static_cast<uint32>(Region.Seed);
            OutContext.LayoutVersion = StrateManager != nullptr
                ? StrateManager->GetLayoutVersion() : 0;
            bBuilt = VF_BuildNativeRegionCore(Region, Params, SpineRadius, StrateManager,
                                              true, OutStack, OutContext);
            if (!bBuilt && OutError != nullptr)
            {
                *OutError = TEXT("single lateral region native stack could not be materialised");
            }
        }
        if (!bBuilt) { return false; }
        OutContext.WorldRadiusVoxels = 0.0f;
        OutContext.EdgeSealThickness = Seal;
        return true;
    }

    TArray<FVoxelOpStack> RegionStacks;
    RegionStacks.Reserve(Manifest.RegionCount);
    for (const FVoxelStrateRegion& Region : Manifest.Regions)
    {
        const FVoxelStrateArchetypeParams Params = MakeRegionParams(Region);
        FVoxelOpStack Core;
        FVoxelOpContext CoreContext;
        bool bBuilt = false;
        if (Region.bUsesRecipe)
        {
            bBuilt = VF_BuildStackFromRecipe(Region.Recipe, Params, Region.Seed,
                                              SpineRadius, StrateManager, Core,
                                              CoreContext, OutError, false);
        }
        else
        {
            CoreContext = FVoxelOpContext();
            CoreContext.Seed = static_cast<uint32>(Region.Seed);
            CoreContext.LayoutVersion = StrateManager != nullptr
                ? StrateManager->GetLayoutVersion() : 0;
            bBuilt = VF_BuildNativeRegionCore(Region, Params, SpineRadius, StrateManager,
                                              false, Core, CoreContext);
            if (!bBuilt && OutError != nullptr)
            {
                *OutError = FString::Printf(TEXT("region %d native stack could not be materialised"),
                                             Region.RegionIndex);
            }
        }
        if (!bBuilt)
        {
            return false;
        }
        RegionStacks.Add(MoveTemp(Core));
    }

    FVoxelOpStack Parent;
    Parent.Add(MakeUnique<FLateralRegionBlendOp>(Manifest, MoveTemp(RegionStacks)));
    Parent.AppendStructuralPost(Top, Bottom, Seal, Base, SpineRadius, StrateManager);

    FString ValidationError;
    if (!Parent.ValidateChannelOrder(&ValidationError))
    {
        return Fail(FString::Printf(TEXT("lateral region parent failed ValidateChannelOrder: %s"),
                                    *ValidationError));
    }

    OutContext = FVoxelOpContext();
    OutContext.Seed = static_cast<uint32>(Manifest.Seed);
    OutContext.LayoutVersion = StrateManager != nullptr
        ? StrateManager->GetLayoutVersion() : 0;
    OutContext.WorldRadiusVoxels = 0.0f;
    OutContext.EdgeSealThickness = Seal;
    OutContext.StrateTopWorldZ = Top;
    OutContext.StrateBottomWorldZ = Bottom;
    OutStack = MoveTemp(Parent);
    return true;
}
#endif // WITH_EDITOR — lateral regions remain behind the failed shippability gate